LCOV - code coverage report
Current view: top level - libavcodec - g726.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 156 176 88.6 %
Date: 2017-12-16 21:16:39 Functions: 12 13 92.3 %

          Line data    Source code
       1             : /*
       2             :  * G.726 ADPCM audio codec
       3             :  * Copyright (c) 2004 Roman Shaposhnik
       4             :  *
       5             :  * This is a very straightforward rendition of the G.726
       6             :  * Section 4 "Computational Details".
       7             :  *
       8             :  * This file is part of FFmpeg.
       9             :  *
      10             :  * FFmpeg is free software; you can redistribute it and/or
      11             :  * modify it under the terms of the GNU Lesser General Public
      12             :  * License as published by the Free Software Foundation; either
      13             :  * version 2.1 of the License, or (at your option) any later version.
      14             :  *
      15             :  * FFmpeg is distributed in the hope that it will be useful,
      16             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      17             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      18             :  * Lesser General Public License for more details.
      19             :  *
      20             :  * You should have received a copy of the GNU Lesser General Public
      21             :  * License along with FFmpeg; if not, write to the Free Software
      22             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      23             :  */
      24             : #include <limits.h>
      25             : 
      26             : #include "libavutil/channel_layout.h"
      27             : #include "libavutil/opt.h"
      28             : #include "avcodec.h"
      29             : #include "internal.h"
      30             : #include "get_bits.h"
      31             : #include "put_bits.h"
      32             : 
      33             : /**
      34             :  * G.726 11-bit float.
      35             :  * G.726 Standard uses rather odd 11-bit floating point arithmetic for
      36             :  * numerous occasions. It's a mystery to me why they did it this way
      37             :  * instead of simply using 32-bit integer arithmetic.
      38             :  */
      39             : typedef struct Float11 {
      40             :     uint8_t sign;   /**< 1 bit sign */
      41             :     uint8_t exp;    /**< 4 bits exponent */
      42             :     uint8_t mant;   /**< 6 bits mantissa */
      43             : } Float11;
      44             : 
      45     3840000 : static inline Float11* i2f(int i, Float11* f)
      46             : {
      47     3840000 :     f->sign = (i < 0);
      48     3840000 :     if (f->sign)
      49     1903568 :         i = -i;
      50     3840000 :     f->exp = av_log2_16bit(i) + !!i;
      51     3840000 :     f->mant = i? (i<<6) >> f->exp : 1<<5;
      52     3840000 :     return f;
      53             : }
      54             : 
      55     3072000 : static inline int16_t mult(Float11* f1, Float11* f2)
      56             : {
      57             :         int res, exp;
      58             : 
      59     3072000 :         exp = f1->exp + f2->exp;
      60     3072000 :         res = (((f1->mant * f2->mant) + 0x30) >> 4);
      61     3072000 :         res = exp > 19 ? res << (exp - 19) : res >> (19 - exp);
      62     3072000 :         return (f1->sign ^ f2->sign) ? -res : res;
      63             : }
      64             : 
      65     3022660 : static inline int sgn(int value)
      66             : {
      67     3022660 :     return (value < 0) ? -1 : 1;
      68             : }
      69             : 
      70             : typedef struct G726Tables {
      71             :     const int* quant;         /**< quantization table */
      72             :     const int16_t* iquant;    /**< inverse quantization table */
      73             :     const int16_t* W;         /**< special table #1 ;-) */
      74             :     const uint8_t* F;         /**< special table #2 */
      75             : } G726Tables;
      76             : 
      77             : typedef struct G726Context {
      78             :     AVClass *class;
      79             :     G726Tables tbls;    /**< static tables needed for computation */
      80             : 
      81             :     Float11 sr[2];      /**< prev. reconstructed samples */
      82             :     Float11 dq[6];      /**< prev. difference */
      83             :     int a[2];           /**< second order predictor coeffs */
      84             :     int b[6];           /**< sixth order predictor coeffs */
      85             :     int pk[2];          /**< signs of prev. 2 sez + dq */
      86             : 
      87             :     int ap;             /**< scale factor control */
      88             :     int yu;             /**< fast scale factor */
      89             :     int yl;             /**< slow scale factor */
      90             :     int dms;            /**< short average magnitude of F[i] */
      91             :     int dml;            /**< long average magnitude of F[i] */
      92             :     int td;             /**< tone detect */
      93             : 
      94             :     int se;             /**< estimated signal for the next iteration */
      95             :     int sez;            /**< estimated second order prediction */
      96             :     int y;              /**< quantizer scaling factor for the next iteration */
      97             :     int code_size;
      98             :     int little_endian;  /**< little-endian bitstream as used in aiff and Sun AU */
      99             : } G726Context;
     100             : 
     101             : static const int quant_tbl16[] =                  /**< 16kbit/s 2 bits per sample */
     102             :            { 260, INT_MAX };
     103             : static const int16_t iquant_tbl16[] =
     104             :            { 116, 365, 365, 116 };
     105             : static const int16_t W_tbl16[] =
     106             :            { -22, 439, 439, -22 };
     107             : static const uint8_t F_tbl16[] =
     108             :            { 0, 7, 7, 0 };
     109             : 
     110             : static const int quant_tbl24[] =                  /**< 24kbit/s 3 bits per sample */
     111             :            {  7, 217, 330, INT_MAX };
     112             : static const int16_t iquant_tbl24[] =
     113             :            { INT16_MIN, 135, 273, 373, 373, 273, 135, INT16_MIN };
     114             : static const int16_t W_tbl24[] =
     115             :            { -4,  30, 137, 582, 582, 137,  30, -4 };
     116             : static const uint8_t F_tbl24[] =
     117             :            { 0, 1, 2, 7, 7, 2, 1, 0 };
     118             : 
     119             : static const int quant_tbl32[] =                  /**< 32kbit/s 4 bits per sample */
     120             :            { -125,  79, 177, 245, 299, 348, 399, INT_MAX };
     121             : static const int16_t iquant_tbl32[] =
     122             :          { INT16_MIN,   4, 135, 213, 273, 323, 373, 425,
     123             :                  425, 373, 323, 273, 213, 135,   4, INT16_MIN };
     124             : static const int16_t W_tbl32[] =
     125             :            { -12,  18,  41,  64, 112, 198, 355, 1122,
     126             :             1122, 355, 198, 112,  64,  41,  18, -12};
     127             : static const uint8_t F_tbl32[] =
     128             :            { 0, 0, 0, 1, 1, 1, 3, 7, 7, 3, 1, 1, 1, 0, 0, 0 };
     129             : 
     130             : static const int quant_tbl40[] =                  /**< 40kbit/s 5 bits per sample */
     131             :            { -122, -16,  67, 138, 197, 249, 297, 338,
     132             :               377, 412, 444, 474, 501, 527, 552, INT_MAX };
     133             : static const int16_t iquant_tbl40[] =
     134             :          { INT16_MIN, -66,  28, 104, 169, 224, 274, 318,
     135             :                  358, 395, 429, 459, 488, 514, 539, 566,
     136             :                  566, 539, 514, 488, 459, 429, 395, 358,
     137             :                  318, 274, 224, 169, 104,  28, -66, INT16_MIN };
     138             : static const int16_t W_tbl40[] =
     139             :            {   14,  14,  24,  39,  40,  41,   58,  100,
     140             :               141, 179, 219, 280, 358, 440,  529,  696,
     141             :               696, 529, 440, 358, 280, 219,  179,  141,
     142             :               100,  58,  41,  40,  39,  24,   14,   14 };
     143             : static const uint8_t F_tbl40[] =
     144             :            { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 6,
     145             :              6, 6, 5, 4, 3, 2, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 };
     146             : 
     147             : static const G726Tables G726Tables_pool[] =
     148             :            {{ quant_tbl16, iquant_tbl16, W_tbl16, F_tbl16 },
     149             :             { quant_tbl24, iquant_tbl24, W_tbl24, F_tbl24 },
     150             :             { quant_tbl32, iquant_tbl32, W_tbl32, F_tbl32 },
     151             :             { quant_tbl40, iquant_tbl40, W_tbl40, F_tbl40 }};
     152             : 
     153             : 
     154             : /**
     155             :  * Paragraph 4.2.2 page 18: Adaptive quantizer.
     156             :  */
     157      192000 : static inline uint8_t quant(G726Context* c, int d)
     158             : {
     159             :     int sign, exp, i, dln;
     160             : 
     161      192000 :     sign = i = 0;
     162      192000 :     if (d < 0) {
     163       91006 :         sign = 1;
     164       91006 :         d = -d;
     165             :     }
     166      192000 :     exp = av_log2_16bit(d);
     167      192000 :     dln = ((exp<<7) + (((d<<7)>>exp)&0x7f)) - (c->y>>2);
     168             : 
     169      820554 :     while (c->tbls.quant[i] < INT_MAX && c->tbls.quant[i] < dln)
     170      436554 :         ++i;
     171             : 
     172      192000 :     if (sign)
     173       91006 :         i = ~i;
     174      192000 :     if (c->code_size != 2 && i == 0) /* I'm not sure this is a good idea */
     175       12505 :         i = 0xff;
     176             : 
     177      192000 :     return i;
     178             : }
     179             : 
     180             : /**
     181             :  * Paragraph 4.2.3 page 22: Inverse adaptive quantizer.
     182             :  */
     183      384000 : static inline int16_t inverse_quant(G726Context* c, int i)
     184             : {
     185             :     int dql, dex, dqt;
     186             : 
     187      384000 :     dql = c->tbls.iquant[i] + (c->y >> 2);
     188      384000 :     dex = (dql>>7) & 0xf;        /* 4-bit exponent */
     189      384000 :     dqt = (1<<7) + (dql & 0x7f); /* log2 -> linear */
     190      384000 :     return (dql < 0) ? 0 : ((dqt<<dex) >> 7);
     191             : }
     192             : 
     193      384000 : static int16_t g726_decode(G726Context* c, int I)
     194             : {
     195             :     int dq, re_signal, pk0, fa1, i, tr, ylint, ylfrac, thr2, al, dq0;
     196             :     Float11 f;
     197      384000 :     int I_sig= I >> (c->code_size - 1);
     198             : 
     199      384000 :     dq = inverse_quant(c, I);
     200             : 
     201             :     /* Transition detect */
     202      384000 :     ylint = (c->yl >> 15);
     203      384000 :     ylfrac = (c->yl >> 10) & 0x1f;
     204      384000 :     thr2 = (ylint > 9) ? 0x1f << 10 : (0x20 + ylfrac) << ylint;
     205      384000 :     tr= (c->td == 1 && dq > ((3*thr2)>>2));
     206             : 
     207      384000 :     if (I_sig)  /* get the sign */
     208      207022 :         dq = -dq;
     209      384000 :     re_signal = (int16_t)(c->se + dq);
     210             : 
     211             :     /* Update second order predictor coefficient A2 and A1 */
     212      384000 :     pk0 = (c->sez + dq) ? sgn(c->sez + dq) : 0;
     213      384000 :     dq0 = dq ? sgn(dq) : 0;
     214      384000 :     if (tr) {
     215           6 :         c->a[0] = 0;
     216           6 :         c->a[1] = 0;
     217          42 :         for (i=0; i<6; i++)
     218          36 :             c->b[i] = 0;
     219             :     } else {
     220             :         /* This is a bit crazy, but it really is +255 not +256 */
     221      383994 :         fa1 = av_clip_intp2((-c->a[0]*c->pk[0]*pk0)>>5, 8);
     222             : 
     223      383994 :         c->a[1] += 128*pk0*c->pk[1] + fa1 - (c->a[1]>>7);
     224      383994 :         c->a[1] = av_clip(c->a[1], -12288, 12288);
     225      383994 :         c->a[0] += 64*3*pk0*c->pk[0] - (c->a[0] >> 8);
     226      383994 :         c->a[0] = av_clip(c->a[0], -(15360 - c->a[1]), 15360 - c->a[1]);
     227             : 
     228     2687958 :         for (i=0; i<6; i++)
     229     2303964 :             c->b[i] += 128*dq0*sgn(-c->dq[i].sign) - (c->b[i]>>8);
     230             :     }
     231             : 
     232             :     /* Update Dq and Sr and Pk */
     233      384000 :     c->pk[1] = c->pk[0];
     234      384000 :     c->pk[0] = pk0 ? pk0 : 1;
     235      384000 :     c->sr[1] = c->sr[0];
     236      384000 :     i2f(re_signal, &c->sr[0]);
     237     2304000 :     for (i=5; i>0; i--)
     238     1920000 :         c->dq[i] = c->dq[i-1];
     239      384000 :     i2f(dq, &c->dq[0]);
     240      384000 :     c->dq[0].sign = I_sig; /* Isn't it crazy ?!?! */
     241             : 
     242      384000 :     c->td = c->a[1] < -11776;
     243             : 
     244             :     /* Update Ap */
     245      384000 :     c->dms += (c->tbls.F[I]<<4) + ((- c->dms) >> 5);
     246      384000 :     c->dml += (c->tbls.F[I]<<4) + ((- c->dml) >> 7);
     247      384000 :     if (tr)
     248           6 :         c->ap = 256;
     249             :     else {
     250      383994 :         c->ap += (-c->ap) >> 4;
     251      383994 :         if (c->y <= 1535 || c->td || abs((c->dms << 2) - c->dml) >= (c->dml >> 3))
     252      270694 :             c->ap += 0x20;
     253             :     }
     254             : 
     255             :     /* Update Yu and Yl */
     256      384000 :     c->yu = av_clip(c->y + c->tbls.W[I] + ((-c->y)>>5), 544, 5120);
     257      384000 :     c->yl += c->yu + ((-c->yl)>>6);
     258             : 
     259             :     /* Next iteration for Y */
     260      384000 :     al = (c->ap >= 256) ? 1<<6 : c->ap >> 2;
     261      384000 :     c->y = (c->yl + (c->yu - (c->yl>>6))*al) >> 6;
     262             : 
     263             :     /* Next iteration for SE and SEZ */
     264      384000 :     c->se = 0;
     265     2688000 :     for (i=0; i<6; i++)
     266     2304000 :         c->se += mult(i2f(c->b[i] >> 2, &f), &c->dq[i]);
     267      384000 :     c->sez = c->se >> 1;
     268     1152000 :     for (i=0; i<2; i++)
     269      768000 :         c->se += mult(i2f(c->a[i] >> 2, &f), &c->sr[i]);
     270      384000 :     c->se >>= 1;
     271             : 
     272      384000 :     return av_clip(re_signal * 4, -0xffff, 0xffff);
     273             : }
     274             : 
     275          12 : static av_cold int g726_reset(G726Context *c)
     276             : {
     277             :     int i;
     278             : 
     279          12 :     c->tbls = G726Tables_pool[c->code_size - 2];
     280          36 :     for (i=0; i<2; i++) {
     281          24 :         c->sr[i].mant = 1<<5;
     282          24 :         c->pk[i] = 1;
     283             :     }
     284          84 :     for (i=0; i<6; i++) {
     285          72 :         c->dq[i].mant = 1<<5;
     286             :     }
     287          12 :     c->yu = 544;
     288          12 :     c->yl = 34816;
     289             : 
     290          12 :     c->y = 544;
     291             : 
     292          12 :     return 0;
     293             : }
     294             : 
     295             : #if CONFIG_ADPCM_G726_ENCODER || CONFIG_ADPCM_G726LE_ENCODER
     296      192000 : static int16_t g726_encode(G726Context* c, int16_t sig)
     297             : {
     298             :     uint8_t i;
     299             : 
     300      192000 :     i = av_mod_uintp2(quant(c, sig/4 - c->se), c->code_size);
     301      192000 :     g726_decode(c, i);
     302      192000 :     return i;
     303             : }
     304             : 
     305             : /* Interfacing to the libavcodec */
     306             : 
     307           4 : static av_cold int g726_encode_init(AVCodecContext *avctx)
     308             : {
     309           4 :     G726Context* c = avctx->priv_data;
     310             : 
     311           4 :     c->little_endian = !strcmp(avctx->codec->name, "g726le");
     312             : 
     313           8 :     if (avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL &&
     314           4 :         avctx->sample_rate != 8000) {
     315           0 :         av_log(avctx, AV_LOG_ERROR, "Sample rates other than 8kHz are not "
     316             :                "allowed when the compliance level is higher than unofficial. "
     317             :                "Resample or reduce the compliance level.\n");
     318           0 :         return AVERROR(EINVAL);
     319             :     }
     320           4 :     if (avctx->sample_rate <= 0) {
     321           0 :         av_log(avctx, AV_LOG_ERROR, "Invalid sample rate %d\n",
     322             :                avctx->sample_rate);
     323           0 :         return AVERROR(EINVAL);
     324             :     }
     325             : 
     326           4 :     if(avctx->channels != 1){
     327           0 :         av_log(avctx, AV_LOG_ERROR, "Only mono is supported\n");
     328           0 :         return AVERROR(EINVAL);
     329             :     }
     330             : 
     331           4 :     if (avctx->bit_rate)
     332           4 :         c->code_size = (avctx->bit_rate + avctx->sample_rate/2) / avctx->sample_rate;
     333             : 
     334           4 :     c->code_size = av_clip(c->code_size, 2, 5);
     335           4 :     avctx->bit_rate = c->code_size * avctx->sample_rate;
     336           4 :     avctx->bits_per_coded_sample = c->code_size;
     337             : 
     338           4 :     g726_reset(c);
     339             : 
     340             :     /* select a frame size that will end on a byte boundary and have a size of
     341             :        approximately 1024 bytes */
     342           4 :     avctx->frame_size = ((int[]){ 4096, 2736, 2048, 1640 })[c->code_size - 2];
     343             : 
     344           4 :     return 0;
     345             : }
     346             : 
     347          84 : static int g726_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
     348             :                              const AVFrame *frame, int *got_packet_ptr)
     349             : {
     350          84 :     G726Context *c = avctx->priv_data;
     351          84 :     const int16_t *samples = (const int16_t *)frame->data[0];
     352             :     PutBitContext pb;
     353             :     int i, ret, out_size;
     354             : 
     355          84 :     out_size = (frame->nb_samples * c->code_size + 7) / 8;
     356          84 :     if ((ret = ff_alloc_packet2(avctx, avpkt, out_size, 0)) < 0)
     357           0 :         return ret;
     358          84 :     init_put_bits(&pb, avpkt->data, avpkt->size);
     359             : 
     360      192084 :     for (i = 0; i < frame->nb_samples; i++)
     361      192000 :         if (c->little_endian) {
     362           0 :             put_bits_le(&pb, c->code_size, g726_encode(c, *samples++));
     363             :         } else {
     364      192000 :             put_bits(&pb, c->code_size, g726_encode(c, *samples++));
     365             :         }
     366             : 
     367          84 :     if (c->little_endian) {
     368           0 :         flush_put_bits_le(&pb);
     369             :     } else {
     370          84 :         flush_put_bits(&pb);
     371             :     }
     372             : 
     373          84 :     avpkt->size = out_size;
     374          84 :     *got_packet_ptr = 1;
     375          84 :     return 0;
     376             : }
     377             : 
     378             : #define OFFSET(x) offsetof(G726Context, x)
     379             : #define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
     380             : static const AVOption options[] = {
     381             :     { "code_size", "Bits per code", OFFSET(code_size), AV_OPT_TYPE_INT, { .i64 = 4 }, 2, 5, AE },
     382             :     { NULL },
     383             : };
     384             : 
     385             : static const AVCodecDefault defaults[] = {
     386             :     { "b", "0" },
     387             :     { NULL },
     388             : };
     389             : #endif
     390             : 
     391             : #if CONFIG_ADPCM_G726_ENCODER
     392             : static const AVClass g726_class = {
     393             :     .class_name = "g726",
     394             :     .item_name  = av_default_item_name,
     395             :     .option     = options,
     396             :     .version    = LIBAVUTIL_VERSION_INT,
     397             : };
     398             : 
     399             : AVCodec ff_adpcm_g726_encoder = {
     400             :     .name           = "g726",
     401             :     .long_name      = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),
     402             :     .type           = AVMEDIA_TYPE_AUDIO,
     403             :     .id             = AV_CODEC_ID_ADPCM_G726,
     404             :     .priv_data_size = sizeof(G726Context),
     405             :     .init           = g726_encode_init,
     406             :     .encode2        = g726_encode_frame,
     407             :     .capabilities   = AV_CODEC_CAP_SMALL_LAST_FRAME,
     408             :     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
     409             :                                                      AV_SAMPLE_FMT_NONE },
     410             :     .priv_class     = &g726_class,
     411             :     .defaults       = defaults,
     412             : };
     413             : #endif
     414             : 
     415             : #if CONFIG_ADPCM_G726LE_ENCODER
     416             : static const AVClass g726le_class = {
     417             :     .class_name = "g726le",
     418             :     .item_name  = av_default_item_name,
     419             :     .option     = options,
     420             :     .version    = LIBAVUTIL_VERSION_INT,
     421             : };
     422             : 
     423             : AVCodec ff_adpcm_g726le_encoder = {
     424             :     .name           = "g726le",
     425             :     .long_name      = NULL_IF_CONFIG_SMALL("G.726 little endian ADPCM (\"right-justified\")"),
     426             :     .type           = AVMEDIA_TYPE_AUDIO,
     427             :     .id             = AV_CODEC_ID_ADPCM_G726LE,
     428             :     .priv_data_size = sizeof(G726Context),
     429             :     .init           = g726_encode_init,
     430             :     .encode2        = g726_encode_frame,
     431             :     .capabilities   = AV_CODEC_CAP_SMALL_LAST_FRAME,
     432             :     .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
     433             :                                                      AV_SAMPLE_FMT_NONE },
     434             :     .priv_class     = &g726le_class,
     435             :     .defaults       = defaults,
     436             : };
     437             : #endif
     438             : 
     439             : #if CONFIG_ADPCM_G726_DECODER || CONFIG_ADPCM_G726LE_DECODER
     440           8 : static av_cold int g726_decode_init(AVCodecContext *avctx)
     441             : {
     442           8 :     G726Context* c = avctx->priv_data;
     443             : 
     444           8 :     if(avctx->channels > 1){
     445           0 :         avpriv_request_sample(avctx, "Decoding more than one channel");
     446           0 :         return AVERROR_PATCHWELCOME;
     447             :     }
     448           8 :     avctx->channels       = 1;
     449           8 :     avctx->channel_layout = AV_CH_LAYOUT_MONO;
     450             : 
     451           8 :     c->little_endian = !strcmp(avctx->codec->name, "g726le");
     452             : 
     453           8 :     c->code_size = avctx->bits_per_coded_sample;
     454           8 :     if (c->code_size < 2 || c->code_size > 5) {
     455           0 :         av_log(avctx, AV_LOG_ERROR, "Invalid number of bits %d\n", c->code_size);
     456           0 :         return AVERROR(EINVAL);
     457             :     }
     458           8 :     g726_reset(c);
     459             : 
     460           8 :     avctx->sample_fmt = AV_SAMPLE_FMT_S16;
     461             : 
     462           8 :     return 0;
     463             : }
     464             : 
     465          22 : static int g726_decode_frame(AVCodecContext *avctx, void *data,
     466             :                              int *got_frame_ptr, AVPacket *avpkt)
     467             : {
     468          22 :     AVFrame *frame     = data;
     469          22 :     const uint8_t *buf = avpkt->data;
     470          22 :     int buf_size = avpkt->size;
     471          22 :     G726Context *c = avctx->priv_data;
     472             :     int16_t *samples;
     473             :     GetBitContext gb;
     474             :     int out_samples, ret;
     475             : 
     476          22 :     out_samples = buf_size * 8 / c->code_size;
     477             : 
     478             :     /* get output buffer */
     479          22 :     frame->nb_samples = out_samples;
     480          22 :     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
     481           0 :         return ret;
     482          22 :     samples = (int16_t *)frame->data[0];
     483             : 
     484          22 :     init_get_bits(&gb, buf, buf_size * 8);
     485             : 
     486      192044 :     while (out_samples--)
     487      384000 :         *samples++ = g726_decode(c, c->little_endian ?
     488           0 :                                     get_bits_le(&gb, c->code_size) :
     489      192000 :                                     get_bits(&gb, c->code_size));
     490             : 
     491          22 :     if (get_bits_left(&gb) > 0)
     492           0 :         av_log(avctx, AV_LOG_ERROR, "Frame invalidly split, missing parser?\n");
     493             : 
     494          22 :     *got_frame_ptr = 1;
     495             : 
     496          22 :     return buf_size;
     497             : }
     498             : 
     499           0 : static void g726_decode_flush(AVCodecContext *avctx)
     500             : {
     501           0 :     G726Context *c = avctx->priv_data;
     502           0 :     g726_reset(c);
     503           0 : }
     504             : #endif
     505             : 
     506             : #if CONFIG_ADPCM_G726_DECODER
     507             : AVCodec ff_adpcm_g726_decoder = {
     508             :     .name           = "g726",
     509             :     .long_name      = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),
     510             :     .type           = AVMEDIA_TYPE_AUDIO,
     511             :     .id             = AV_CODEC_ID_ADPCM_G726,
     512             :     .priv_data_size = sizeof(G726Context),
     513             :     .init           = g726_decode_init,
     514             :     .decode         = g726_decode_frame,
     515             :     .flush          = g726_decode_flush,
     516             :     .capabilities   = AV_CODEC_CAP_DR1,
     517             : };
     518             : #endif
     519             : 
     520             : #if CONFIG_ADPCM_G726LE_DECODER
     521             : AVCodec ff_adpcm_g726le_decoder = {
     522             :     .name           = "g726le",
     523             :     .type           = AVMEDIA_TYPE_AUDIO,
     524             :     .id             = AV_CODEC_ID_ADPCM_G726LE,
     525             :     .priv_data_size = sizeof(G726Context),
     526             :     .init           = g726_decode_init,
     527             :     .decode         = g726_decode_frame,
     528             :     .flush          = g726_decode_flush,
     529             :     .capabilities   = AV_CODEC_CAP_DR1,
     530             :     .long_name      = NULL_IF_CONFIG_SMALL("G.726 ADPCM little-endian"),
     531             : };
     532             : #endif

Generated by: LCOV version 1.13