falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10114 Commits
32 Branches
340MB
Tree: 6bd4660cdb
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6bd4660cdb'
${ noResults }
FFmpeg/libavcodec/ac3dec.c

1950 lines
65KB
Raw Blame History 

  1. /* AC3 Audio Decoder.

  2.  *

  3.  * Copyright (c) 2006 Kartikey Mahendra BHATT (bhattkm at gmail dot com).

  4.  *

  5.  * This library is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU Lesser General Public

  7.  * License as published by the Free Software Foundation; either

  8.  * version 2 of the License, or (at your option) any later version.

  9.  *

  10.  * This library is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  13.  * Lesser General Public License for more details.

  14.  *

  15.  * You should have received a copy of the GNU Lesser General Public

  16.  * License along with this library; if not, write to the Free Software

  17.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  18.  */

  19. 

  20. #include <stdio.h>

  21. #include <stddef.h>

  22. #include <math.h>

  23. #include <inttypes.h>

  24. #include <string.h>

  25. 

  26. #define ALT_BITSTREAM_READER

  27. 

  28. #include "ac3tab.h"

  29. #include "ac3.h"

  30. #include "ac3_decoder.h"

  31. #include "avcodec.h"

  32. #include "bitstream.h"

  33. #include "dsputil.h"

  34. #include "avutil.h"

  35. #include "common.h"

  36. 

  37. #define MAX_CHANNELS    6

  38. #define BLOCK_SIZE    256

  39. #define AUDIO_BLOCKS    6

  40. 

  41. /* Synchronization information. */

  42. typedef struct {

  43.     uint16_t sync_word;     //synchronization word = always 0x0b77

  44.     uint16_t crc1;          //crc for the first 5/8 of the frame

  45.     uint8_t  fscod;         //sampling rate code

  46.     uint8_t  frmsizecod;    //frame size code

  47. 

  48.     /* Derived Attributes */

  49.     int sampling_rate;      //sampling rate - 48, 44.1 or 32 kHz (value in Hz)

  50.     int bit_rate;           //nominal bit rate (value in kbps)

  51.     int framesize;          //frame size - 16 bit words

  52. } ac3_sync_info;

  53. 

  54. /* flags for the BSI. */

  55. #define AC3_BSI_LFEON       0x00000001  //low frequency effects channel on

  56. #define AC3_BSI_COMPRE      0x00000002  //compression exists

  57. #define AC3_BSI_LANGCODE    0x00000004  //langcode exists

  58. #define AC3_BSI_AUDPRODIE   0x00000008  //audio production information exists

  59. #define AC3_BSI_COMPR2E     0x00000010  //compr2 exists

  60. #define AC3_BSI_LANGCOD2E   0x00000020  //langcod2 exists

  61. #define AC3_BSI_AUDPRODI2E  0x00000040  //audio production information 2 exists

  62. #define AC3_BSI_COPYRIGHTB  0x00000080  //copyright

  63. #define AC3_BSI_ORIGBS      0x00000100  //original bit stream

  64. #define AC3_BSI_TIMECOD1E   0x00000200  //timecod1 exists

  65. #define AC3_BSI_TIMECOD2E   0x00000400  //timecod2 exists

  66. #define AC3_BSI_ADDBSIE     0x00000800  //additional bit stream information exists

  67. 

  68. /* Bit Stream Information. */

  69. typedef struct {

  70.     uint32_t flags;

  71.     uint8_t  bsid;          //bit stream identification

  72.     uint8_t  bsmod;         //bit stream mode - type of service

  73.     uint8_t  acmod;         //audio coding mode - which channels are in use

  74.     uint8_t  cmixlev;       //center mix level

  75.     uint8_t  surmixlev;     //surround mix level

  76.     uint8_t  dsurmod;       //dynamic surround encoded

  77.     uint8_t  dialnorm;      //dialog normalization

  78.     uint8_t  compr;         //compression gain word

  79.     uint8_t  langcod;       //language code

  80.     uint8_t  mixlevel;      //mixing level

  81.     uint8_t  roomtyp;       //room type

  82.     uint8_t  dialnorm2;     //dialogue normalization for 1+1 mode

  83.     uint8_t  compr2;        //compression gain word for 1+1 mode

  84.     uint8_t  langcod2;      //language code for 1+1 mode

  85.     uint8_t  mixlevel2;     //mixing level for 1+1 mode

  86.     uint8_t  roomtyp2;      //room type for 1+1 mode

  87.     uint16_t timecod1;      //timecode 1

  88.     uint16_t timecod2;      //timecode 2

  89.     uint8_t  addbsil;       //additional bit stream information length

  90. 

  91.     /* Dervied Attributes */

  92.     int      nfchans;      //number of full bandwidth channels - derived from acmod

  93. } ac3_bsi;

  94. 

  95. /* #defs relevant to Audio Block. */

  96. #define MAX_FBW_CHANNELS    5       //maximum full bandwidth channels

  97. #define NUM_LFE_GROUPS      3       //number of LFE Groups

  98. #define MAX_NUM_SEGS        8       //maximum number of segments per delta bit allocation

  99. #define NUM_LFE_MANTS       7       //number of lfe mantissas

  100. #define MAX_CPL_SUBNDS      18      //maximum number of coupling sub bands

  101. #define MAX_CPL_BNDS        18      //maximum number of coupling bands

  102. #define MAX_CPL_GRPS        253     //maximum number of coupling groups

  103. #define MAX_CHNL_GRPS       88      //maximum number of channel groups

  104. #define MAX_NUM_MANTISSAS   256     //maximum number of mantissas

  105. 

  106. /* flags for the Audio Block. */

  107. #define AC3_AB_DYNRNGE      0x00000001  //dynamic range control exists

  108. #define AC3_AB_DYNRNG2E     0x00000002  //dynamic range control 2 exists

  109. #define AC3_AB_CPLSTRE      0x00000004  //coupling strategy exists

  110. #define AC3_AB_CPLINU       0x00000008  //coupling in use

  111. #define AC3_AB_PHSFLGINU    0x00000010  //phase flag in use

  112. #define AC3_AB_REMATSTR     0x00000020  //rematrixing required

  113. #define AC3_AB_LFEEXPSTR    0x00000100  //lfe exponent strategy

  114. #define AC3_AB_BAIE         0x00000200  //bit allocation information exists

  115. #define AC3_AB_SNROFFSTE    0x00000400  //SNR offset exists

  116. #define AC3_AB_CPLLEAKE     0x00000800  //coupling leak initialization exists

  117. #define AC3_AB_DELTBAIE     0x00001000  //delta bit allocation information exists

  118. #define AC3_AB_SKIPLE       0x00002000  //skip length exists

  119. 

  120. /* Exponent strategies. */

  121. #define AC3_EXPSTR_D15      0x01

  122. #define AC3_EXPSTR_D25      0x02

  123. #define AC3_EXPSTR_D45      0x03

  124. #define AC3_EXPSTR_REUSE    0x00

  125. 

  126. /* Bit allocation strategies */

  127. #define AC3_DBASTR_NEW      0x01

  128. #define AC3_DBASTR_NONE     0x02

  129. #define AC3_DBASTR_RESERVED 0x03

  130. #define AC3_DBASTR_REUSE    0x00

  131. 

  132. /* Audio Block */

  133. typedef struct {

  134.     uint32_t flags;

  135.     uint8_t  blksw;                 //block switch flags for channels in use

  136.     uint8_t  dithflag;              //dithering flags for channels in use

  137.     int8_t   dynrng;                //dynamic range word

  138.     int8_t   dynrng2;               //dynamic range word for 1+1 mode

  139.     uint8_t  chincpl;               //channel in coupling flags for channels in use

  140.     uint8_t  cplbegf;               //coupling begin frequency code

  141.     uint8_t  cplendf;               //coupling end frequency code

  142.     uint32_t cplbndstrc;            //coupling band structure

  143.     uint8_t  cplcoe;                //coupling co-ordinates exists for the channel in use

  144.     uint32_t phsflg;                //phase flag per band

  145.     uint8_t  rematflg;              //rematrixing flag

  146.     uint8_t  cplexpstr;             //coupling exponent strategy

  147.     uint8_t  chexpstr[5];           //channel exponent strategy

  148.     uint8_t  lfeexpstr;             //lfe exponent strategy

  149.     uint8_t  chbwcod[5];            //channel bandwdith code for channels in use

  150.     uint8_t  cplabsexp;             //coupling absolute exponent

  151.     uint8_t  gainrng[5];            //gain range

  152.     uint8_t  sdcycod;               //slow decay code

  153.     uint8_t  fdcycod;               //fast decay code

  154.     uint8_t  sgaincod;              //slow gain code

  155.     uint8_t  dbpbcod;               //dB per bit code

  156.     uint8_t  floorcod;              //masking floor code

  157.     uint8_t  csnroffst;             //coarse SNR offset

  158.     uint8_t  cplfsnroffst;          //coupling fine SNR offset

  159.     uint8_t  cplfgaincod;           //coupling fast gain code

  160.     uint8_t  fsnroffst[5];          //fine SNR offset for channels in use

  161.     uint8_t  fgaincod[5];           //fast gain code for channels in use

  162.     uint8_t  lfefsnroffst;          //lfe fine SNR offset

  163.     uint8_t  lfefgaincod;           //lfe fast gain code

  164.     uint8_t  cplfleak;              //coupling fast leak initialization value

  165.     uint8_t  cplsleak;              //coupling slow leak initialization value

  166.     uint8_t  cpldeltbae;            //coupling delta bit allocation exists

  167.     uint8_t  deltbae[5];            //delta bit allocation exists for channels in use

  168.     uint8_t  cpldeltnseg;           //coupling delta bit allocation number of segments

  169.     uint8_t  cpldeltoffst[8];       //coupling delta offset

  170.     uint8_t  cpldeltlen[8];         //coupling delta len

  171.     uint8_t  cpldeltba[8];          //coupling delta bit allocation

  172.     uint8_t  deltnseg[5];           //delta bit allocation number of segments per channel

  173.     uint8_t  deltoffst[5][8];       //delta offset for channels in use

  174.     uint8_t  deltlen[5][8];         //delta len for channels in use

  175.     uint8_t  deltba[5][8];          //delta bit allocation

  176.     uint16_t skipl;                 //skip length

  177. 

  178.     /* Derived Attributes */

  179.     int      ncplsubnd;             //number of active coupling sub bands = 3 + cplendf - cplbegf

  180.     int      ncplbnd;               //derived from ncplsubnd and cplbndstrc

  181.     int      ncplgrps;              //derived from ncplsubnd, cplexpstr

  182.     int      nchgrps[5];            //derived from chexpstr, and cplbegf or chbwcod

  183.     int      ncplmant;              //derived from ncplsubnd = 12 * ncplsubnd

  184. 

  185.     uint8_t  cplstrtmant;           //coupling start mantissa

  186.     uint8_t  cplendmant;            //coupling end mantissa

  187.     uint8_t  endmant[5];            //channel end mantissas

  188. 

  189.     uint8_t  dcplexps[256];         //decoded coupling exponents

  190.     uint8_t  dexps[5][256];         //decoded fbw channel exponents

  191.     uint8_t  dlfeexps[256];         //decoded lfe exponents

  192.     uint8_t  cplbap[256];           //coupling bit allocation parameters table

  193.     uint8_t  bap[5][256];           //fbw channels bit allocation parameters table

  194.     uint8_t  lfebap[256];           //lfe bit allocaiton parameters table

  195. 

  196.     DECLARE_ALIGNED_16(float, transform_coeffs[MAX_CHANNELS][BLOCK_SIZE]); //transform coefficients

  197.     DECLARE_ALIGNED_16(float, output[MAX_CHANNELS][BLOCK_SIZE]);  //output of the block

  198.     DECLARE_ALIGNED_16(float, delay[MAX_CHANNELS][BLOCK_SIZE]); //delay (for overlap and add)

  199.     DECLARE_ALIGNED_16(float, tmp_imdct[BLOCK_SIZE]);   //temporary storage for ff_imdct_calc

  200.     DECLARE_ALIGNED_16(float, tmp_output[BLOCK_SIZE * 2]);  //output of ff_imdct_calc

  201.     float    cplco[5][18];          //coupling coordinates

  202.     float    chcoeffs[6];           //channel coefficients for downmix

  203. } ac3_audio_block;

  204. 

  205. 

  206. 

  207. #define AC3_OUTPUT_UNMODIFIED   0x01

  208. #define AC3_OUTPUT_MONO         0x02

  209. #define AC3_OUTPUT_STEREO       0x04

  210. #define AC3_OUTPUT_DOLBY        0x08

  211. #define AC3_OUTPUT_LFEON        0x10

  212. 

  213. #define AC3_INPUT_DUALMONO      0x00

  214. #define AC3_INPUT_MONO          0x01

  215. #define AC3_INPUT_STEREO        0x02

  216. #define AC3_INPUT_3F            0x03

  217. #define AC3_INPUT_2F_1R         0x04

  218. #define AC3_INPUT_3F_1R         0x05

  219. #define AC3_INPUT_2F_2R         0x06

  220. #define AC3_INPUT_3F_2R         0x07

  221. 

  222. /* BEGIN Mersenne Twister Code. */

  223. #define N 624

  224. #define M 397

  225. #define MATRIX_A    0x9908b0df

  226. #define UPPER_MASK  0x80000000

  227. #define LOWER_MASK  0x7fffffff

  228. 

  229. typedef struct {

  230.     uint32_t mt[N];

  231.     int      mti;

  232. } dither_state;

  233. 

  234. static void dither_seed(dither_state *state, uint32_t seed)

  235. {

  236.     if (seed == 0)

  237.         seed = 0x1f2e3d4c;

  238. 

  239.     state->mt[0] = seed;

  240.     for (state->mti = 1; state->mti < N; state->mti++)

  241.         state->mt[state->mti] = ((69069 * state->mt[state->mti - 1]) + 1);

  242. }

  243. 

  244. static uint32_t dither_uint32(dither_state *state)

  245. {

  246.     uint32_t y;

  247.     static const uint32_t mag01[2] = { 0x00, MATRIX_A };

  248.     int kk;

  249. 

  250.     if (state->mti >= N) {

  251.         for (kk = 0; kk < N - M; kk++) {

  252.             y = (state->mt[kk] & UPPER_MASK) | (state->mt[kk + 1] & LOWER_MASK);

  253.             state->mt[kk] = state->mt[kk + M] ^ (y >> 1) ^ mag01[y & 0x01];

  254.         }

  255.         for (;kk < N - 1; kk++) {

  256.             y = (state->mt[kk] & UPPER_MASK) | (state->mt[kk + 1] & LOWER_MASK);

  257.             state->mt[kk] = state->mt[kk + (M - N)] ^ (y >> 1) ^ mag01[y & 0x01];

  258.         }

  259.         y = (state->mt[N - 1] & UPPER_MASK) | (state->mt[0] & LOWER_MASK);

  260.         state->mt[N - 1] = state->mt[M - 1] ^ (y >> 1) ^ mag01[y & 0x01];

  261. 

  262.         state->mti = 0;

  263.     }

  264. 

  265.     y = state->mt[state->mti++];

  266.     y ^= (y >> 11);

  267.     y ^= ((y << 7) & 0x9d2c5680);

  268.     y ^= ((y << 15) & 0xefc60000);

  269.     y ^= (y >> 18);

  270. 

  271.     return y;

  272. }

  273. 

  274. static inline int16_t dither_int16(dither_state *state)

  275. {

  276.     return ((dither_uint32(state) << 16) >> 16);

  277. }

  278. 

  279. /* END Mersenne Twister */

  280. 

  281. /* AC3 Context. */

  282. typedef struct {

  283.     ac3_sync_info   sync_info;

  284.     ac3_bsi         bsi;

  285.     ac3_audio_block audio_block;

  286.     dither_state    state;

  287.     MDCTContext     imdct_ctx_256;

  288.     MDCTContext     imdct_ctx_512;

  289.     GetBitContext   gb;

  290.     int             output;

  291. } AC3DecodeContext;

  292. 

  293. static void ac3_common_init1(void)

  294. {

  295.     int i, j, k, l, v;

  296.     /* compute bndtab and masktab from bandsz */

  297.     k = 0;

  298.     l = 0;

  299.     for(i=0;i<50;i++) {

  300.         bndtab[i] = l;

  301.         v = bndsz[i];

  302.         for(j=0;j<v;j++) masktab[k++]=i;

  303.         l += v;

  304.     }

  305.     masktab[253] = masktab[254] = masktab[255] = 0;

  306.     bndtab[50] = 0;

  307. }

  308. 

  309. 

  310. static int ac3_decode_init(AVCodecContext *avctx)

  311. {

  312.     AC3DecodeContext *ctx = avctx->priv_data;

  313.     int i;

  314. 

  315.     ac3_common_init1();

  316. 

  317.     ff_mdct_init(&ctx->imdct_ctx_256, 8, 1);

  318.     ff_mdct_init(&ctx->imdct_ctx_512, 9, 1);

  319.     dither_seed(&ctx->state, 0);

  320.     for (i = 0; i < MAX_CHANNELS; i++)

  321.         memset(ctx->audio_block.delay[i], 0, sizeof(ctx->audio_block.delay[i]));

  322. 

  323.     return 0;

  324. }

  325. 

  326. static int ac3_synchronize(uint8_t *buf, int buf_size)

  327. {

  328.     int i;

  329. 

  330.     for (i = 0; i < buf_size - 1; i++)

  331.         if (buf[i] == 0x0b && buf[i + 1] == 0x77)

  332.             return i;

  333. 

  334.     return -1;

  335. }

  336. 

  337. //Returns -1 when 'fscod' is not valid;

  338. static int ac3_parse_sync_info(AC3DecodeContext *ctx)

  339. {

  340.     ac3_sync_info *sync_info = &ctx->sync_info;

  341.     ac3_bsi *bsi = &ctx->bsi;

  342.     GetBitContext *gb = &ctx->gb;

  343. 

  344.     sync_info->sync_word = get_bits(gb, 16);

  345.     sync_info->crc1 = get_bits(gb, 16);

  346.     sync_info->fscod = get_bits(gb, 2);

  347.     if (sync_info->fscod == 0x03)

  348.         return 0;

  349.     sync_info->frmsizecod = get_bits(gb, 6);

  350.     if (sync_info->frmsizecod >= 38)

  351.         return 0;

  352.     sync_info->sampling_rate = ac3_freqs[sync_info->fscod];

  353.     sync_info->bit_rate = ac3_bitratetab[sync_info->frmsizecod >> 1];

  354. 

  355.     /* we include it here in order to determine validity of ac3 frame */

  356.     bsi->bsid = get_bits(gb, 5);

  357.     if (bsi->bsid > 0x08)

  358.         return 0;

  359.     bsi->bsmod = get_bits(gb, 3);

  360. 

  361.     switch (sync_info->fscod) {

  362.         case 0x00:

  363.             sync_info->framesize = 4 * sync_info->bit_rate;

  364.             return sync_info->framesize;

  365.         case 0x01:

  366.             sync_info->framesize = 2 * (320 * sync_info->bit_rate / 147 + (sync_info->frmsizecod & 1));

  367.             return sync_info->framesize;

  368.         case 0x02:

  369.             sync_info->framesize =  6 * sync_info->bit_rate;

  370.             return sync_info->framesize;

  371.     }

  372. 

  373.     /* never reached */

  374.     return 0;

  375. }

  376. 

  377. //Returns -1 when

  378. static int ac3_parse_bsi(AC3DecodeContext *ctx)

  379. {

  380.     ac3_bsi *bsi = &ctx->bsi;

  381.     uint32_t *flags = &bsi->flags;

  382.     GetBitContext *gb = &ctx->gb;

  383.     int i;

  384. 

  385.     *flags = 0;

  386.     bsi->cmixlev = 0;

  387.     bsi->surmixlev = 0;

  388.     bsi->dsurmod = 0;

  389.     bsi->nfchans = 0;

  390.     ctx->audio_block.cpldeltbae = AC3_DBASTR_NONE;

  391.     ctx->audio_block.cpldeltnseg = 0;

  392.     for (i = 0; i < 5; i++) {

  393.         ctx->audio_block.deltbae[i] = AC3_DBASTR_NONE;

  394.         ctx->audio_block.deltnseg[i] = 0;

  395.     }

  396. 

  397.     bsi->acmod = get_bits(gb, 3);

  398.     if (bsi->acmod & 0x01 && bsi->acmod != 0x01)

  399.         bsi->cmixlev = get_bits(gb, 2);

  400.     if (bsi->acmod & 0x04)

  401.         bsi->surmixlev = get_bits(gb, 2);

  402.     if (bsi->acmod == 0x02)

  403.         bsi->dsurmod = get_bits(gb, 2);

  404.     if (get_bits1(gb))

  405.         *flags |= AC3_BSI_LFEON;

  406.     bsi->dialnorm = get_bits(gb, 5);

  407.     if (get_bits1(gb)) {

  408.         *flags |= AC3_BSI_COMPRE;

  409.         bsi->compr = get_bits(gb, 8);

  410.     }

  411.     if (get_bits1(gb)) {

  412.         *flags |= AC3_BSI_LANGCODE;

  413.         bsi->langcod = get_bits(gb, 8);

  414.     }

  415.     if (get_bits1(gb)) {

  416.         *flags |= AC3_BSI_AUDPRODIE;

  417.         bsi->mixlevel = get_bits(gb, 5);

  418.         bsi->roomtyp = get_bits(gb, 2);

  419.     }

  420.     if (bsi->acmod == 0x00) {

  421.         bsi->dialnorm2 = get_bits(gb, 5);

  422.         if (get_bits1(gb)) {

  423.             *flags |= AC3_BSI_COMPR2E;

  424.             bsi->compr2 = get_bits(gb, 8);

  425.         }

  426.         if (get_bits1(gb)) {

  427.             *flags |= AC3_BSI_LANGCOD2E;

  428.             bsi->langcod2 = get_bits(gb, 8);

  429.         }

  430.         if (get_bits1(gb)) {

  431.             *flags |= AC3_BSI_AUDPRODIE;

  432.             bsi->mixlevel2 = get_bits(gb, 5);

  433.             bsi->roomtyp2 = get_bits(gb, 2);

  434.         }

  435.     }

  436.     if (get_bits1(gb))

  437.         *flags |= AC3_BSI_COPYRIGHTB;

  438.     if (get_bits1(gb))

  439.         *flags |= AC3_BSI_ORIGBS;

  440.     if (get_bits1(gb)) {

  441.         *flags |= AC3_BSI_TIMECOD1E;

  442.         bsi->timecod1 = get_bits(gb, 14);

  443.     }

  444.     if (get_bits1(gb)) {

  445.         *flags |= AC3_BSI_TIMECOD2E;

  446.         bsi->timecod2 = get_bits(gb, 14);

  447.     }

  448.     if (get_bits1(gb)) {

  449.         *flags |= AC3_BSI_ADDBSIE;

  450.         bsi->addbsil = get_bits(gb, 6);

  451.         do {

  452.             skip_bits(gb, 8);

  453.         } while(bsi->addbsil--);

  454.     }

  455. 

  456.     bsi->nfchans = nfchans_tbl[bsi->acmod];

  457. 

  458.     return 0;

  459. }

  460. 

  461.  /* Decodes the grouped exponents and stores them

  462.  * in decoded exponents (dexps).

  463.  * The code is derived from liba52.

  464.  * Uses liba52 tables.

  465.  */

  466. static int decode_exponents(GetBitContext *gb, int expstr, int ngrps, uint8_t absexp, uint8_t *dexps)

  467. {

  468.     int exps;

  469. 

  470.     while (ngrps--) {

  471.         exps = get_bits(gb, 7);

  472. 

  473.         absexp += exp_1[exps];

  474.         if (absexp > 24) {

  475.             av_log(NULL, AV_LOG_ERROR, "Absolute Exponent > 24, ngrp = %d\n", ngrps);

  476.             return -ngrps;

  477.         }

  478.         switch (expstr) {

  479.             case AC3_EXPSTR_D45:

  480.                 *(dexps++) = absexp;

  481.                 *(dexps++) = absexp;

  482.             case AC3_EXPSTR_D25:

  483.                 *(dexps++) = absexp;

  484.             case AC3_EXPSTR_D15:

  485.                 *(dexps++) = absexp;

  486.         }

  487. 

  488.         absexp += exp_2[exps];

  489.         if (absexp > 24) {

  490.             av_log(NULL, AV_LOG_ERROR, "Absolute Exponent > 24, ngrp = %d\n", ngrps);

  491.             return -ngrps;

  492.         }

  493.         switch (expstr) {

  494.             case AC3_EXPSTR_D45:

  495.                 *(dexps++) = absexp;

  496.                 *(dexps++) = absexp;

  497.             case AC3_EXPSTR_D25:

  498.                 *(dexps++) = absexp;

  499.             case AC3_EXPSTR_D15:

  500.                 *(dexps++) = absexp;

  501.         }

  502. 

  503.         absexp += exp_3[exps];

  504.         if (absexp > 24) {

  505.             av_log(NULL, AV_LOG_ERROR, "Absolute Exponent > 24, ngrp = %d\n", ngrps);

  506.             return -ngrps;

  507.         }

  508.         switch (expstr) {

  509.             case AC3_EXPSTR_D45:

  510.                 *(dexps++) = absexp;

  511.                 *(dexps++) = absexp;

  512.             case AC3_EXPSTR_D25:

  513.                 *(dexps++) = absexp;

  514.             case AC3_EXPSTR_D15:

  515.                 *(dexps++) = absexp;

  516.         }

  517.     }

  518. 

  519.     return 0;

  520. }

  521. 

  522. static inline int logadd(int a, int b)

  523. {

  524.     int c = a - b;

  525.     int address;

  526. 

  527.     address = FFMIN(ABS(c) >> 1, 255);

  528. 

  529.     if (c >= 0)

  530.         return (a + latab[address]);

  531.     else

  532.         return (b + latab[address]);

  533. }

  534. 

  535. static inline int calc_lowcomp(int a, int b0, int b1, int bin)

  536. {

  537.     if (bin < 7) {

  538.         if ((b0 + 256) == b1)

  539.             a = 384;

  540.         else if (b0 > b1)

  541.             a = FFMAX(0, a - 64);

  542.     }

  543.     else if (bin < 20) {

  544.         if ((b0 + 256) == b1)

  545.             a = 320;

  546.         else if (b0 > b1)

  547.             a = FFMAX(0, a - 64);

  548.     }

  549.     else

  550.         a = FFMAX(0, a - 128);

  551. 

  552.     return a;

  553. }

  554. 

  555. /* do the bit allocation for chnl.

  556.  * chnl = 0 to 4 - fbw channel

  557.  * chnl = 5 coupling channel

  558.  * chnl = 6 lfe channel

  559.  */

  560. static void do_bit_allocation1(AC3DecodeContext *ctx, int chnl)

  561. {

  562.     ac3_audio_block *ab = &ctx->audio_block;

  563.     int sdecay, fdecay, sgain, dbknee, floor;

  564.     int lowcomp = 0, fgain = 0, snroffset = 0, fastleak = 0, slowleak = 0;

  565.     int psd[256], bndpsd[50], excite[50], mask[50], delta;

  566.     int start = 0, end = 0, bin = 0, i = 0, j = 0, k = 0, lastbin = 0, bndstrt = 0;

  567.     int bndend = 0, begin = 0, deltnseg = 0, band = 0, seg = 0, address = 0;

  568.     int fscod = ctx->sync_info.fscod;

  569.     uint8_t *exps, *deltoffst = 0, *deltlen = 0, *deltba = 0;

  570.     uint8_t *baps;

  571.     int do_delta = 0;

  572. 

  573.     /* initialization */

  574.     sdecay = sdecaytab[ab->sdcycod];

  575.     fdecay = fdecaytab[ab->fdcycod];

  576.     sgain = sgaintab[ab->sgaincod];

  577.     dbknee = dbkneetab[ab->dbpbcod];

  578.     floor = floortab[ab->floorcod];

  579. 

  580.     if (chnl == 5) {

  581.         start = ab->cplstrtmant;

  582.         end = ab->cplendmant;

  583.         fgain = fgaintab[ab->cplfgaincod];

  584.         snroffset = (((ab->csnroffst - 15) << 4) + ab->cplfsnroffst) << 2;

  585.         fastleak = (ab->cplfleak << 8) + 768;

  586.         slowleak = (ab->cplsleak << 8) + 768;

  587.         exps = ab->dcplexps;

  588.         baps = ab->cplbap;

  589.         if (ab->cpldeltbae == AC3_DBASTR_NEW || ab->cpldeltbae == AC3_DBASTR_REUSE) {

  590.             do_delta = 1;

  591.             deltnseg = ab->cpldeltnseg;

  592.             deltoffst = ab->cpldeltoffst;

  593.             deltlen = ab->cpldeltlen;

  594.             deltba = ab->cpldeltba;

  595.         }

  596.     }

  597.     else if (chnl == 6) {

  598.         start = 0;

  599.         end = 7;

  600.         lowcomp = 0;

  601.         fastleak = 0;

  602.         slowleak = 0;

  603.         fgain = fgaintab[ab->lfefgaincod];

  604.         snroffset = (((ab->csnroffst - 15) << 4) + ab->lfefsnroffst) << 2;

  605.         exps = ab->dlfeexps;

  606.         baps = ab->lfebap;

  607.     }

  608.     else {

  609.         start = 0;

  610.         end = ab->endmant[chnl];

  611.         lowcomp = 0;

  612.         fastleak = 0;

  613.         slowleak = 0;

  614.         fgain = fgaintab[ab->fgaincod[chnl]];

  615.         snroffset = (((ab->csnroffst - 15) << 4) + ab->fsnroffst[chnl]) << 2;

  616.         exps = ab->dexps[chnl];

  617.         baps = ab->bap[chnl];

  618.         if (ab->deltbae[chnl] == AC3_DBASTR_NEW || ab->deltbae[chnl] == AC3_DBASTR_REUSE) {

  619.             do_delta = 1;

  620.             deltnseg = ab->deltnseg[chnl];

  621.             deltoffst = ab->deltoffst[chnl];

  622.             deltlen = ab->deltlen[chnl];

  623.             deltba = ab->deltba[chnl];

  624.         }

  625.     }

  626. 

  627.     for (bin = start; bin < end; bin++) /* exponent mapping into psd */

  628.         psd[bin] = (3072 - ((int)(exps[bin]) << 7));

  629. 

  630.     /* psd integration */

  631.     j = start;

  632.     k = masktab[start];

  633.     do {

  634.         lastbin = FFMIN(bndtab[k] + bndsz[k], end);

  635.         bndpsd[k] = psd[j];

  636.         j++;

  637.         for (i = j; i < lastbin; i++) {

  638.             bndpsd[k] = logadd(bndpsd[k], psd[j]);

  639.             j++;

  640.         }

  641.         k++;

  642.     } while (end > lastbin);

  643. 

  644.     /* compute the excite function */

  645.     bndstrt = masktab[start];

  646.     bndend = masktab[end - 1] + 1;

  647.     if (bndstrt == 0) {

  648.         lowcomp = calc_lowcomp(lowcomp, bndpsd[0], bndpsd[1], 0);

  649.         excite[0] = bndpsd[0] - fgain - lowcomp;

  650.         lowcomp = calc_lowcomp(lowcomp, bndpsd[1], bndpsd[2], 1);

  651.         excite[1] = bndpsd[1] - fgain - lowcomp;

  652.         begin = 7;

  653.         for (bin = 2; bin < 7; bin++) {

  654.             if (!(chnl == 6 && bin == 6))

  655.                 lowcomp = calc_lowcomp(lowcomp, bndpsd[bin], bndpsd[bin + 1], bin);

  656.             fastleak = bndpsd[bin] - fgain;

  657.             slowleak = bndpsd[bin] - sgain;

  658.             excite[bin] = fastleak - lowcomp;

  659.             if (!(chnl == 6 && bin == 6))

  660.                 if (bndpsd[bin] <= bndpsd[bin + 1]) {

  661.                     begin = bin + 1;

  662.                     break;

  663.                 }

  664.         }

  665.         for (bin = begin; bin < FFMIN(bndend, 22); bin++) {

  666.             if (!(chnl == 6 && bin == 6))

  667.                 lowcomp = calc_lowcomp(lowcomp, bndpsd[bin], bndpsd[bin + 1], bin);

  668.             fastleak -= fdecay;

  669.             fastleak = FFMAX(fastleak, bndpsd[bin] - fgain);

  670.             slowleak -= sdecay;

  671.             slowleak = FFMAX(slowleak, bndpsd[bin] - sgain);

  672.             excite[bin] = FFMAX(fastleak - lowcomp, slowleak);

  673.         }

  674.         begin = 22;

  675.     }

  676.     else {

  677.         begin = bndstrt;

  678.     }

  679.     for (bin = begin; bin < bndend; bin++) {

  680.         fastleak -= fdecay;

  681.         fastleak = FFMAX(fastleak, bndpsd[bin] - fgain);

  682.         slowleak -= sdecay;

  683.         slowleak = FFMAX(slowleak, bndpsd[bin] - sgain);

  684.         excite[bin] = FFMAX(fastleak, slowleak);

  685.     }

  686. 

  687.     /* compute the masking curve */

  688.     for (bin = bndstrt; bin < bndend; bin++) {

  689.         if (bndpsd[bin] < dbknee)

  690.             excite[bin] += ((dbknee - bndpsd[bin]) >> 2);

  691.         mask[bin] = FFMAX(excite[bin], hth[bin][fscod]);

  692.     }

  693. 

  694.     /* apply the delta bit allocation */

  695.     if (do_delta) {

  696.         band = 0;

  697.         for (seg = 0; seg < deltnseg + 1; seg++) {

  698.             band += (int)(deltoffst[seg]);

  699.             if ((int)(deltba[seg]) >= 4)

  700.                 delta = ((int)(deltba[seg]) - 3) << 7;

  701.             else

  702.                 delta = ((int)(deltba[seg]) - 4) << 7;

  703.             for (k = 0; k < (int)(deltlen[seg]); k++) {

  704.                 mask[band] += delta;

  705.                 band++;

  706.             }

  707.         }

  708.     }

  709. 

  710.     /*compute the bit allocation */

  711.     i = start;

  712.     j = masktab[start];

  713.     do {

  714.         lastbin = FFMIN(bndtab[j] + bndsz[j], end);

  715.         mask[j] -= snroffset;

  716.         mask[j] -= floor;

  717.         if (mask[j] < 0)

  718.             mask[j] = 0;

  719.         mask[j] &= 0x1fe0;

  720.         mask[j] += floor;

  721.         for (k = i; k < lastbin; k++) {

  722.             address = (psd[i] - mask[j]) >> 5;

  723.             address = FFMIN(63, FFMAX(0, address));

  724.             baps[i] = baptab[address];

  725.             i++;

  726.         }

  727.         j++;

  728.     } while (end > lastbin);

  729. }

  730. 

  731. static void do_bit_allocation(AC3DecodeContext *ctx, int flags)

  732. {

  733.     ac3_audio_block *ab = &ctx->audio_block;

  734.     int i, snroffst = 0;

  735. 

  736.     if (!flags) /* bit allocation is not required */

  737.         return;

  738. 

  739.     if (ab->flags & AC3_AB_SNROFFSTE) { /* check whether snroffsts are zero */

  740.         snroffst += ab->csnroffst;

  741.         if (ab->flags & ab->chincpl)

  742.             snroffst += ab->cplfsnroffst;

  743.         for (i = 0; i < ctx->bsi.nfchans; i++)

  744.             snroffst += ab->fsnroffst[i];

  745.         if (ctx->bsi.flags & AC3_BSI_LFEON)

  746.             snroffst += ab->lfefsnroffst;

  747.         if (!snroffst) {

  748.             memset(ab->cplbap, 0, sizeof (ab->cplbap));

  749.             for (i = 0; i < ctx->bsi.nfchans; i++)

  750.                 memset(ab->bap[i], 0, sizeof (ab->bap[i]));

  751.             memset(ab->lfebap, 0, sizeof (ab->lfebap));

  752. 

  753.             return;

  754.         }

  755.     }

  756. 

  757.     /* perform bit allocation */

  758.     if (ab->chincpl && (flags & 64))

  759.         do_bit_allocation1(ctx, 5);

  760.     for (i = 0; i < ctx->bsi.nfchans; i++)

  761.         if (flags & (1 << i))

  762.             do_bit_allocation1(ctx, i);

  763.     if ((ctx->bsi.flags & AC3_BSI_LFEON) && (flags & 32))

  764.         do_bit_allocation1(ctx, 6);

  765. }

  766. 

  767. typedef struct { /* grouped mantissas for 3-level 5-leve and 11-level quantization */

  768.     uint8_t gcodesl3[3];

  769.     uint8_t gcodesl5[3];

  770.     uint8_t gcodesl11[3];

  771.     int l3ptr;

  772.     int l5ptr;

  773.     int l11ptr;

  774. } mant_groups;

  775. 

  776. #define TRANSFORM_COEFF(tc, m, e, f) (tc) = (m) * (f)[(e)]

  777. 

  778. /* Get the transform coefficients for coupling channel and uncouple channels.

  779.  * The coupling transform coefficients starts at the the cplstrtmant, which is

  780.  * equal to endmant[ch] for fbw channels. Hence we can uncouple channels before

  781.  * getting transform coefficients for the channel.

  782.  */

  783. static int get_transform_coeffs_cpling(AC3DecodeContext *ctx, mant_groups *m)

  784. {

  785.     ac3_audio_block *ab = &ctx->audio_block;

  786.     GetBitContext *gb = &ctx->gb;

  787.     int sbnd, bin, ch, index, gcode;

  788.     float cplcos[5], cplcoeff;

  789.     uint8_t *exps = ab->dcplexps;

  790.     uint8_t *bap = ab->cplbap;

  791. 

  792.     for (sbnd = ab->cplbegf; sbnd < ab->cplendf + 3; sbnd++) {

  793.         for (ch = 0; ch < ctx->bsi.nfchans; ch++)

  794.             cplcos[ch] = ab->chcoeffs[ch] * ab->cplco[ch][sbnd];

  795.         for (bin = 0; bin < 12; bin++) {

  796.             index = sbnd * 12 + bin + 37;

  797.             switch(bap[index]) {

  798.                 case 0:

  799.                     for (ch = 0; ch < ctx->bsi.nfchans; ctx++)

  800.                         if (((ab->chincpl) >> ch) & 1) {

  801.                             if (((ab->dithflag) >> ch) & 1) {

  802.                                 TRANSFORM_COEFF(cplcoeff, dither_int16(&ctx->state), exps[index], scale_factors);

  803.                                 ab->transform_coeffs[ch + 1][index] = cplcoeff * cplcos[ch];

  804.                             } else

  805.                                 ab->transform_coeffs[ch + 1][index] = 0;

  806.                         }

  807.                     continue;

  808.                 case 1:

  809.                     if (m->l3ptr > 2) {

  810.                         gcode = get_bits(gb, 5);

  811.                         if (gcode > 26)

  812.                             return -1;

  813.                         m->gcodesl3[0] = gcode / 9;

  814.                         m->gcodesl3[1] = (gcode % 9) / 3;

  815.                         m->gcodesl3[2] = (gcode % 9) % 3;

  816.                         m->l3ptr = 0;

  817.                     }

  818.                     TRANSFORM_COEFF(cplcoeff, l3_q_tab[m->gcodesl3[m->l3ptr++]], exps[index], scale_factors);

  819.                     break;

  820. 

  821.                 case 2:

  822.                     if (m->l5ptr > 2) {

  823.                         gcode = get_bits(gb, 7);

  824.                         if (gcode > 124)

  825.                             return -1;

  826.                         m->gcodesl5[0] = gcode / 25;

  827.                         m->gcodesl5[1] = (gcode % 25) / 5;

  828.                         m->gcodesl5[2] = (gcode % 25) % 5;

  829.                         m->l5ptr = 0;

  830.                     }

  831.                     TRANSFORM_COEFF(cplcoeff, l5_q_tab[m->gcodesl5[m->l5ptr++]], exps[index], scale_factors);

  832.                     break;

  833. 

  834.                 case 3:

  835.                     gcode = get_bits(gb, 3);

  836.                     if (gcode > 6)

  837.                         return -1;

  838.                     TRANSFORM_COEFF(cplcoeff, l7_q_tab[gcode], exps[index], scale_factors);

  839.                     break;

  840. 

  841.                 case 4:

  842.                     if (m->l11ptr > 1) {

  843.                         gcode = get_bits(gb, 7);

  844.                         if (gcode > 120)

  845.                             return -1;

  846.                         m->gcodesl11[0] = gcode / 11;

  847.                         m->gcodesl11[1] = gcode % 11;

  848.                         m->l11ptr = 0;

  849.                     }

  850.                     TRANSFORM_COEFF(cplcoeff, l11_q_tab[m->gcodesl11[m->l11ptr++]], exps[index], scale_factors);

  851.                     break;

  852. 

  853.                 case 5:

  854.                     gcode = get_bits(gb, 4);

  855.                     if (gcode > 14)

  856.                         return -1;

  857.                     TRANSFORM_COEFF(cplcoeff, l15_q_tab[gcode], exps[index], scale_factors);

  858.                     break;

  859. 

  860.                 default:

  861.                     TRANSFORM_COEFF(cplcoeff, get_bits(gb, qntztab[bap[index]]) << (16 - qntztab[bap[index]]),

  862.                             exps[index], scale_factors);

  863.             }

  864.             for (ch = 0; ch < ctx->bsi.nfchans; ch++)

  865.                 if (((ab->chincpl) >> ch) & 1)

  866.                     ab->transform_coeffs[ch][index] = cplcoeff * cplcos[ch];

  867.         }

  868.     }

  869. 

  870.     return 0;

  871. }

  872. 

  873. /* Get the transform coefficients for particular channel */

  874. static int get_transform_coeffs_ch(uint8_t *exps, uint8_t *bap, float chcoeff,

  875.         float *coeffs, int start, int end, int dith_flag, GetBitContext *gb,

  876.         dither_state *state, mant_groups *m)

  877. {

  878.     int i;

  879.     int gcode;

  880.     float factors[25];

  881. 

  882.     for (i = 0; i < 25; i++)

  883.         factors[i] = scale_factors[i] * chcoeff;

  884. 

  885.     for (i = start; i < end; i++) {

  886.         switch (bap[i]) {

  887.             case 0:

  888.                 if (!dith_flag) {

  889.                     coeffs[i] = 0;

  890.                     continue;

  891.                 }

  892.                 else {

  893.                     TRANSFORM_COEFF(coeffs[i], dither_int16(state), exps[i], factors);

  894.                     continue;

  895.                 }

  896. 

  897.             case 1:

  898.                 if (m->l3ptr > 2) {

  899.                     gcode = get_bits(gb, 5);

  900.                     if (gcode > 26)

  901.                         return -1;

  902.                     m->gcodesl3[0] = gcode / 9;

  903.                     m->gcodesl3[1] = (gcode % 9) / 3;

  904.                     m->gcodesl3[2] = (gcode % 9) % 3;

  905.                     m->l3ptr = 0;

  906.                 }

  907.                 TRANSFORM_COEFF(coeffs[i], l3_q_tab[m->gcodesl3[m->l3ptr++]], exps[i], factors);

  908.                 continue;

  909. 

  910.             case 2:

  911.                 if (m->l5ptr > 2) {

  912.                     gcode = get_bits(gb, 7);

  913.                     if (gcode > 124)

  914.                         return -1;

  915.                     m->gcodesl5[0] = gcode / 25;

  916.                     m->gcodesl5[1] = (gcode % 25) / 5;

  917.                     m->gcodesl5[2] = (gcode % 25) % 5;

  918.                     m->l5ptr = 0;

  919.                 }

  920.                 TRANSFORM_COEFF(coeffs[i], l5_q_tab[m->gcodesl5[m->l5ptr++]], exps[i], factors);

  921.                 continue;

  922. 

  923.             case 3:

  924.                 gcode = get_bits(gb, 3);

  925.                 if (gcode > 6)

  926.                     return -1;

  927.                 TRANSFORM_COEFF(coeffs[i], l7_q_tab[gcode], exps[i], factors);

  928.                 continue;

  929. 

  930.             case 4:

  931.                 if (m->l11ptr > 1) {

  932.                     gcode = get_bits(gb, 7);

  933.                     if (gcode > 120)

  934.                         return -1;

  935.                     m->gcodesl11[0] = gcode / 11;

  936.                     m->gcodesl11[1] = gcode % 11;

  937.                     m->l11ptr = 0;

  938.                 }

  939.                 TRANSFORM_COEFF(coeffs[i], l11_q_tab[m->gcodesl11[m->l11ptr++]], exps[i], factors);

  940.                 continue;

  941. 

  942.             case 5:

  943.                 gcode = get_bits(gb, 4);

  944.                 if (gcode > 14)

  945.                     return -1;

  946.                 TRANSFORM_COEFF(coeffs[i], l15_q_tab[gcode], exps[i], factors);

  947.                 continue;

  948. 

  949.             default:

  950.                 TRANSFORM_COEFF(coeffs[i], get_bits(gb, qntztab[bap[i]]) << (16 - qntztab[bap[i]]), exps[i], factors);

  951.                 continue;

  952.         }

  953.     }

  954. 

  955.     return 0;

  956. }

  957. 

  958. static int get_transform_coeffs(AC3DecodeContext * ctx)

  959. {

  960.     int i, end;

  961.     ac3_audio_block *ab = &ctx->audio_block;

  962.     int got_cplchan = 0;

  963.     int dithflag = 0;

  964.     mant_groups m;

  965. 

  966.     m.l3ptr = m.l5ptr = m.l11ptr = 3;

  967. 

  968.     for (i = 0; i < ctx->bsi.nfchans; i++) {

  969.         dithflag = ab->dithflag & (1 << i);

  970.         /* transform coefficients for individual channel */

  971.         if (get_transform_coeffs_ch(ab->dexps[i], ab->bap[i], ab->chcoeffs[i], ab->transform_coeffs[i + 1],

  972.                     0, ab->endmant[i], dithflag, &ctx->gb, &ctx->state, &m))

  973.             return -1;

  974.         /* tranform coefficients for coupling channels */

  975.         if (((ab->chincpl) >> i & 1))  {

  976.             if (!got_cplchan) {

  977.                 if (get_transform_coeffs_cpling(ctx, &m))

  978.                     return -1;

  979.                 got_cplchan = 1;

  980.             }

  981.             end = ab->cplendmant;

  982.         } else

  983.             end = ab->endmant[i];

  984.         do

  985.             ab->transform_coeffs[i + 1][end] = 0;

  986.         while(++end < 256);

  987.     }

  988.     if (ctx->bsi.flags & AC3_BSI_LFEON) {

  989.         if (get_transform_coeffs_ch(ab->dlfeexps, ab->lfebap, 1.0f, ab->transform_coeffs[0], 0, 7, 0, &ctx->gb, &ctx->state, &m))

  990.                 return -1;

  991.         for (i = 7; i < 256; i++) {

  992.             ab->transform_coeffs[0][i] = 0;

  993.         }

  994.     }

  995. 

  996.     return 0;

  997. }

  998. 

  999. static void do_rematrixing1(AC3DecodeContext *ctx, int start, int end)

  1000. {

  1001.     float tmp0, tmp1;

  1002. 

  1003.     while (start < end) {

  1004.         tmp0 = ctx->audio_block.transform_coeffs[1][start];

  1005.         tmp1 = ctx->audio_block.transform_coeffs[2][start];

  1006.         ctx->audio_block.transform_coeffs[1][start] = tmp0 + tmp1;

  1007.         ctx->audio_block.transform_coeffs[2][start] = tmp0 - tmp1;

  1008.         start++;

  1009.     }

  1010. }

  1011. 

  1012. static void do_rematrixing(AC3DecodeContext *ctx)

  1013. {

  1014.     ac3_audio_block *ab = &ctx->audio_block;

  1015.     uint8_t bnd1 = 13, bnd2 = 25, bnd3 = 37, bnd4 = 61;

  1016.     uint8_t bndend;

  1017. 

  1018.     bndend = FFMIN(ab->endmant[0], ab->endmant[1]);

  1019.     if (ab->rematflg & 1)

  1020.         do_rematrixing1(ctx, bnd1, bnd2);

  1021.     if (ab->rematflg & 2)

  1022.         do_rematrixing1(ctx, bnd2, bnd3);

  1023.     if (ab->rematflg & 4) {

  1024.         if (ab->cplbegf > 0 && ab->cplbegf <= 2 && (ab->chincpl))

  1025.             do_rematrixing1(ctx, bnd3, bndend);

  1026.         else {

  1027.             do_rematrixing1(ctx, bnd3, bnd4);

  1028.             if (ab->rematflg & 8)

  1029.                 do_rematrixing1(ctx, bnd4, bndend);

  1030.         }

  1031.     }

  1032. }

  1033. 

  1034. static void get_downmix_coeffs(AC3DecodeContext *ctx)

  1035. {

  1036.     int from = ctx->bsi.acmod;

  1037.     int to = ctx->output;

  1038.     float clev = clevs[ctx->bsi.cmixlev];

  1039.     float slev = slevs[ctx->bsi.surmixlev];

  1040.     ac3_audio_block *ab = &ctx->audio_block;

  1041. 

  1042.     if (to == AC3_OUTPUT_UNMODIFIED)

  1043.         return;

  1044. 

  1045.     switch (from) {

  1046.         case AC3_INPUT_DUALMONO:

  1047.             switch (to) {

  1048.                 case AC3_OUTPUT_MONO:

  1049.                 case AC3_OUTPUT_STEREO: /* We Assume that sum of both mono channels is requested */

  1050.                     ab->chcoeffs[0] *= LEVEL_MINUS_6DB;

  1051.                     ab->chcoeffs[1] *= LEVEL_MINUS_6DB;

  1052.                     break;

  1053.             }

  1054.             break;

  1055.         case AC3_INPUT_MONO:

  1056.             switch (to) {

  1057.                 case AC3_OUTPUT_STEREO:

  1058.                     ab->chcoeffs[0] *= LEVEL_MINUS_3DB;

  1059.                     break;

  1060.             }

  1061.             break;

  1062.         case AC3_INPUT_STEREO:

  1063.             switch (to) {

  1064.                 case AC3_OUTPUT_MONO:

  1065.                     ab->chcoeffs[0] *= LEVEL_MINUS_3DB;

  1066.                     ab->chcoeffs[1] *= LEVEL_MINUS_3DB;

  1067.                     break;

  1068.             }

  1069.             break;

  1070.         case AC3_INPUT_3F:

  1071.             switch (to) {

  1072.                 case AC3_OUTPUT_MONO:

  1073.                     ab->chcoeffs[0] *= LEVEL_MINUS_3DB;

  1074.                     ab->chcoeffs[2] *= LEVEL_MINUS_3DB;

  1075.                     ab->chcoeffs[1] *= clev * LEVEL_PLUS_3DB;

  1076.                     break;

  1077.                 case AC3_OUTPUT_STEREO:

  1078.                     ab->chcoeffs[1] *= clev;

  1079.                     break;

  1080.             }

  1081.             break;

  1082.         case AC3_INPUT_2F_1R:

  1083.             switch (to) {

  1084.                 case AC3_OUTPUT_MONO:

  1085.                     ab->chcoeffs[0] *= LEVEL_MINUS_3DB;

  1086.                     ab->chcoeffs[1] *= LEVEL_MINUS_3DB;

  1087.                     ab->chcoeffs[2] *= slev * LEVEL_MINUS_3DB;

  1088.                     break;

  1089.                 case AC3_OUTPUT_STEREO:

  1090.                     ab->chcoeffs[2] *= slev * LEVEL_MINUS_3DB;

  1091.                     break;

  1092.                 case AC3_OUTPUT_DOLBY:

  1093.                     ab->chcoeffs[2] *= LEVEL_MINUS_3DB;

  1094.                     break;

  1095.             }

  1096.             break;

  1097.         case AC3_INPUT_3F_1R:

  1098.             switch (to) {

  1099.                 case AC3_OUTPUT_MONO:

  1100.                     ab->chcoeffs[0] *= LEVEL_MINUS_3DB;

  1101.                     ab->chcoeffs[2] *= LEVEL_MINUS_3DB;

  1102.                     ab->chcoeffs[1] *= clev * LEVEL_PLUS_3DB;

  1103.                     ab->chcoeffs[3] *= slev * LEVEL_MINUS_3DB;

  1104.                     break;

  1105.                 case AC3_OUTPUT_STEREO:

  1106.                     ab->chcoeffs[1] *= clev;

  1107.                     ab->chcoeffs[3] *= slev * LEVEL_MINUS_3DB;

  1108.                     break;

  1109.                 case AC3_OUTPUT_DOLBY:

  1110.                     ab->chcoeffs[1] *= LEVEL_MINUS_3DB;

  1111.                     ab->chcoeffs[3] *= LEVEL_MINUS_3DB;

  1112.                     break;

  1113.             }

  1114.             break;

  1115.         case AC3_INPUT_2F_2R:

  1116.             switch (to) {

  1117.                 case AC3_OUTPUT_MONO:

  1118.                     ab->chcoeffs[0] *= LEVEL_MINUS_3DB;

  1119.                     ab->chcoeffs[1] *= LEVEL_MINUS_3DB;

  1120.                     ab->chcoeffs[2] *= slev * LEVEL_MINUS_3DB;

  1121.                     ab->chcoeffs[3] *= slev * LEVEL_MINUS_3DB;

  1122.                     break;

  1123.                 case AC3_OUTPUT_STEREO:

  1124.                     ab->chcoeffs[2] *= slev;

  1125.                     ab->chcoeffs[3] *= slev;

  1126.                     break;

  1127.                 case AC3_OUTPUT_DOLBY:

  1128.                     ab->chcoeffs[2] *= LEVEL_MINUS_3DB;

  1129.                     ab->chcoeffs[3] *= LEVEL_MINUS_3DB;

  1130.                     break;

  1131.             }

  1132.             break;

  1133.         case AC3_INPUT_3F_2R:

  1134.             switch (to) {

  1135.                 case AC3_OUTPUT_MONO:

  1136.                     ab->chcoeffs[0] *= LEVEL_MINUS_3DB;

  1137.                     ab->chcoeffs[2] *= LEVEL_MINUS_3DB;

  1138.                     ab->chcoeffs[1] *= clev * LEVEL_PLUS_3DB;

  1139.                     ab->chcoeffs[3] *= slev * LEVEL_MINUS_3DB;

  1140.                     ab->chcoeffs[4] *= slev * LEVEL_MINUS_3DB;

  1141.                     break;

  1142.                 case AC3_OUTPUT_STEREO:

  1143.                     ab->chcoeffs[1] *= clev;

  1144.                     ab->chcoeffs[3] *= slev;

  1145.                     ab->chcoeffs[4] *= slev;

  1146.                     break;

  1147.                 case AC3_OUTPUT_DOLBY:

  1148.                     ab->chcoeffs[1] *= LEVEL_MINUS_3DB;

  1149.                     ab->chcoeffs[3] *= LEVEL_MINUS_3DB;

  1150.                     ab->chcoeffs[4] *= LEVEL_MINUS_3DB;

  1151.                     break;

  1152.             }

  1153.             break;

  1154.     }

  1155. }

  1156. 

  1157. static inline void mix_dualmono_to_mono(AC3DecodeContext *ctx)

  1158. {

  1159.     int i;

  1160.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1161. 

  1162.     for (i = 0; i < 256; i++)

  1163.         output[1][i] += output[2][i];

  1164.     memset(output[2], 0, sizeof(output[2]));

  1165. }

  1166. 

  1167. static inline void mix_dualmono_to_stereo(AC3DecodeContext *ctx)

  1168. {

  1169.     int i;

  1170.     float tmp;

  1171.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1172. 

  1173.     for (i = 0; i < 256; i++) {

  1174.         tmp = output[1][i] + output[2][i];

  1175.         output[1][i] = output[2][i] = tmp;

  1176.     }

  1177. }

  1178. 

  1179. static inline void upmix_mono_to_stereo(AC3DecodeContext *ctx)

  1180. {

  1181.     int i;

  1182.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1183. 

  1184.     for (i = 0; i < 256; i++)

  1185.         output[2][i] = output[1][i];

  1186. }

  1187. 

  1188. static inline void mix_stereo_to_mono(AC3DecodeContext *ctx)

  1189. {

  1190.     int i;

  1191.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1192. 

  1193.     for (i = 0; i < 256; i++)

  1194.         output[1][i] += output[2][i];

  1195.     memset(output[2], 0, sizeof(output[2]));

  1196. }

  1197. 

  1198. static inline void mix_3f_to_mono(AC3DecodeContext *ctx)

  1199. {

  1200.     int i;

  1201.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1202. 

  1203.     for (i = 0; i < 256; i++)

  1204.         output[1][i] += (output[2][i] + output[3][i]);

  1205.     memset(output[2], 0, sizeof(output[2]));

  1206.     memset(output[3], 0, sizeof(output[3]));

  1207. }

  1208. 

  1209. static inline void mix_3f_to_stereo(AC3DecodeContext *ctx)

  1210. {

  1211.     int i;

  1212.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1213. 

  1214.     for (i = 0; i < 256; i++) {

  1215.         output[1][i] += output[2][i];

  1216.         output[2][i] += output[3][i];

  1217.     }

  1218.     memset(output[3], 0, sizeof(output[3]));

  1219. }

  1220. 

  1221. static inline void mix_2f_1r_to_mono(AC3DecodeContext *ctx)

  1222. {

  1223.     int i;

  1224.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1225. 

  1226.     for (i = 0; i < 256; i++)

  1227.         output[1][i] += (output[2][i] + output[3][i]);

  1228.     memset(output[2], 0, sizeof(output[2]));

  1229.     memset(output[3], 0, sizeof(output[3]));

  1230. 

  1231. }

  1232. 

  1233. static inline void mix_2f_1r_to_stereo(AC3DecodeContext *ctx)

  1234. {

  1235.     int i;

  1236.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1237. 

  1238.     for (i = 0; i < 256; i++) {

  1239.         output[1][i] += output[2][i];

  1240.         output[2][i] += output[3][i];

  1241.     }

  1242.     memset(output[3], 0, sizeof(output[3]));

  1243. }

  1244. 

  1245. static inline void mix_2f_1r_to_dolby(AC3DecodeContext *ctx)

  1246. {

  1247.     int i;

  1248.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1249. 

  1250.     for (i = 0; i < 256; i++) {

  1251.         output[1][i] -= output[3][i];

  1252.         output[2][i] += output[3][i];

  1253.     }

  1254.     memset(output[3], 0, sizeof(output[3]));

  1255. }

  1256. 

  1257. static inline void mix_3f_1r_to_mono(AC3DecodeContext *ctx)

  1258. {

  1259.     int i;

  1260.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1261. 

  1262.     for (i = 0; i < 256; i++)

  1263.         output[1][i] = (output[2][i] + output[3][i] + output[4][i]);

  1264.     memset(output[2], 0, sizeof(output[2]));

  1265.     memset(output[3], 0, sizeof(output[3]));

  1266.     memset(output[4], 0, sizeof(output[4]));

  1267. }

  1268. 

  1269. static inline void mix_3f_1r_to_stereo(AC3DecodeContext *ctx)

  1270. {

  1271.     int i;

  1272.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1273. 

  1274.     for (i = 0; i < 256; i++) {

  1275.         output[1][i] += (output[2][i] + output[4][i]);

  1276.         output[2][i] += (output[3][i] + output[4][i]);

  1277.     }

  1278.     memset(output[3], 0, sizeof(output[3]));

  1279.     memset(output[4], 0, sizeof(output[4]));

  1280. }

  1281. 

  1282. static inline void mix_3f_1r_to_dolby(AC3DecodeContext *ctx)

  1283. {

  1284.     int i;

  1285.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1286. 

  1287.     for (i = 0; i < 256; i++) {

  1288.         output[1][i] += (output[2][i] - output[4][i]);

  1289.         output[2][i] += (output[3][i] + output[4][i]);

  1290.     }

  1291.     memset(output[3], 0, sizeof(output[3]));

  1292.     memset(output[4], 0, sizeof(output[4]));

  1293. }

  1294. 

  1295. static inline void mix_2f_2r_to_mono(AC3DecodeContext *ctx)

  1296. {

  1297.     int i;

  1298.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1299. 

  1300.     for (i = 0; i < 256; i++)

  1301.         output[1][i] = (output[2][i] + output[3][i] + output[4][i]);

  1302.     memset(output[2], 0, sizeof(output[2]));

  1303.     memset(output[3], 0, sizeof(output[3]));

  1304.     memset(output[4], 0, sizeof(output[4]));

  1305. }

  1306. 

  1307. static inline void mix_2f_2r_to_stereo(AC3DecodeContext *ctx)

  1308. {

  1309.     int i;

  1310.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1311. 

  1312.     for (i = 0; i < 256; i++) {

  1313.         output[1][i] += output[3][i];

  1314.         output[2][i] += output[4][i];

  1315.     }

  1316.     memset(output[3], 0, sizeof(output[3]));

  1317.     memset(output[4], 0, sizeof(output[4]));

  1318. }

  1319. 

  1320. static inline void mix_2f_2r_to_dolby(AC3DecodeContext *ctx)

  1321. {

  1322.     int i;

  1323.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1324. 

  1325.     for (i = 0; i < 256; i++) {

  1326.         output[1][i] -= output[3][i];

  1327.         output[2][i] += output[4][i];

  1328.     }

  1329.     memset(output[3], 0, sizeof(output[3]));

  1330.     memset(output[4], 0, sizeof(output[4]));

  1331. }

  1332. 

  1333. static inline void mix_3f_2r_to_mono(AC3DecodeContext *ctx)

  1334. {

  1335.     int i;

  1336.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1337. 

  1338.     for (i = 0; i < 256; i++)

  1339.         output[1][i] += (output[2][i] + output[3][i] + output[4][i] + output[5][i]);

  1340.     memset(output[2], 0, sizeof(output[2]));

  1341.     memset(output[3], 0, sizeof(output[3]));

  1342.     memset(output[4], 0, sizeof(output[4]));

  1343.     memset(output[5], 0, sizeof(output[5]));

  1344. }

  1345. 

  1346. static inline void mix_3f_2r_to_stereo(AC3DecodeContext *ctx)

  1347. {

  1348.     int i;

  1349.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1350. 

  1351.     for (i = 0; i < 256; i++) {

  1352.         output[1][i] += (output[2][i] + output[4][i]);

  1353.         output[2][i] += (output[3][i] + output[5][i]);

  1354.     }

  1355.     memset(output[3], 0, sizeof(output[3]));

  1356.     memset(output[4], 0, sizeof(output[4]));

  1357.     memset(output[5], 0, sizeof(output[5]));

  1358. }

  1359. 

  1360. static inline void mix_3f_2r_to_dolby(AC3DecodeContext *ctx)

  1361. {

  1362.     int i;

  1363.     float (*output)[BLOCK_SIZE] = ctx->audio_block.output;

  1364. 

  1365.     for (i = 0; i < 256; i++) {

  1366.         output[1][i] += (output[2][i] - output[4][i] - output[5][i]);

  1367.         output[2][i] += (output[3][i] + output[4][i] + output[5][i]);

  1368.     }

  1369.     memset(output[3], 0, sizeof(output[3]));

  1370.     memset(output[4], 0, sizeof(output[4]));

  1371.     memset(output[5], 0, sizeof(output[5]));

  1372. }

  1373. 

  1374. static void do_downmix(AC3DecodeContext *ctx)

  1375. {

  1376.     int from = ctx->bsi.acmod;

  1377.     int to = ctx->output;

  1378. 

  1379.     switch (from) {

  1380.         case AC3_INPUT_DUALMONO:

  1381.             switch (to) {

  1382.                 case AC3_OUTPUT_MONO:

  1383.                     mix_dualmono_to_mono(ctx);

  1384.                     break;

  1385.                 case AC3_OUTPUT_STEREO: /* We assume that sum of both mono channels is requested */

  1386.                     mix_dualmono_to_stereo(ctx);

  1387.                     break;

  1388.             }

  1389.             break;

  1390.         case AC3_INPUT_MONO:

  1391.             switch (to) {

  1392.                 case AC3_OUTPUT_STEREO:

  1393.                     upmix_mono_to_stereo(ctx);

  1394.                     break;

  1395.             }

  1396.             break;

  1397.         case AC3_INPUT_STEREO:

  1398.             switch (to) {

  1399.                 case AC3_OUTPUT_MONO:

  1400.                     mix_stereo_to_mono(ctx);

  1401.                     break;

  1402.             }

  1403.             break;

  1404.         case AC3_INPUT_3F:

  1405.             switch (to) {

  1406.                 case AC3_OUTPUT_MONO:

  1407.                     mix_3f_to_mono(ctx);

  1408.                     break;

  1409.                 case AC3_OUTPUT_STEREO:

  1410.                     mix_3f_to_stereo(ctx);

  1411.                     break;

  1412.             }

  1413.             break;

  1414.         case AC3_INPUT_2F_1R:

  1415.             switch (to) {

  1416.                 case AC3_OUTPUT_MONO:

  1417.                     mix_2f_1r_to_mono(ctx);

  1418.                     break;

  1419.                 case AC3_OUTPUT_STEREO:

  1420.                     mix_2f_1r_to_stereo(ctx);

  1421.                     break;

  1422.                 case AC3_OUTPUT_DOLBY:

  1423.                     mix_2f_1r_to_dolby(ctx);

  1424.                     break;

  1425.             }

  1426.             break;

  1427.         case AC3_INPUT_3F_1R:

  1428.             switch (to) {

  1429.                 case AC3_OUTPUT_MONO:

  1430.                     mix_3f_1r_to_mono(ctx);

  1431.                     break;

  1432.                 case AC3_OUTPUT_STEREO:

  1433.                     mix_3f_1r_to_stereo(ctx);

  1434.                     break;

  1435.                 case AC3_OUTPUT_DOLBY:

  1436.                     mix_3f_1r_to_dolby(ctx);

  1437.                     break;

  1438.             }

  1439.             break;

  1440.         case AC3_INPUT_2F_2R:

  1441.             switch (to) {

  1442.                 case AC3_OUTPUT_MONO:

  1443.                     mix_2f_2r_to_mono(ctx);

  1444.                     break;

  1445.                 case AC3_OUTPUT_STEREO:

  1446.                     mix_2f_2r_to_stereo(ctx);

  1447.                     break;

  1448.                 case AC3_OUTPUT_DOLBY:

  1449.                     mix_2f_2r_to_dolby(ctx);

  1450.                     break;

  1451.             }

  1452.             break;

  1453.         case AC3_INPUT_3F_2R:

  1454.             switch (to) {

  1455.                 case AC3_OUTPUT_MONO:

  1456.                     mix_3f_2r_to_mono(ctx);

  1457.                     break;

  1458.                 case AC3_OUTPUT_STEREO:

  1459.                     mix_3f_2r_to_stereo(ctx);

  1460.                     break;

  1461.                 case AC3_OUTPUT_DOLBY:

  1462.                     mix_3f_2r_to_dolby(ctx);

  1463.                     break;

  1464.             }

  1465.             break;

  1466.     }

  1467. }

  1468. 

  1469. static void dump_floats(const char *name, int prec, const float *tab, int n)

  1470. {

  1471.     int i;

  1472. 

  1473.     av_log(NULL, AV_LOG_INFO, "%s[%d]:\n", name, n);

  1474.     for(i=0;i<n;i++) {

  1475.         if ((i & 7) == 0)

  1476.             av_log(NULL, AV_LOG_INFO, "%4d: ", i);

  1477.         av_log(NULL, AV_LOG_INFO, " %8.*f", prec, tab[i]);

  1478.         if ((i & 7) == 7)

  1479.             av_log(NULL, AV_LOG_INFO, "\n");

  1480.     }

  1481.     if ((i & 7) != 0)

  1482.         av_log(NULL, AV_LOG_INFO, "\n");

  1483. }

  1484. 

  1485. /*static void window_and_de_interleave(float *output)

  1486. {

  1487.     int n2, n4, n8;

  1488.     int k;

  1489. 

  1490.     n2 = 512 >> 1;

  1491.     n4 = 512 >> 2;

  1492.     n8 = 512 >> 3;

  1493. 

  1494.     for (k = 0; k < n8; k++) {

  1495.         output[2 * k] *= window[2 * k];

  1496.         output[n2 - 2 * k - 1] *= window[n2 - 2 * k - 1];

  1497. 

  1498.         output[2 * k + 1] *= window[2 * k + 1];

  1499.         output[n2 - 2 * k - 2] *= window[n2 - 2 * k - 2];

  1500. 

  1501.         output[n2 + 2 * k] *= window[n2 - 2 * k - 1];

  1502.         output[n - 2 * k - 1] *= window[n - 2 * k - 1];

  1503. 

  1504.         output[n2 + 2 * k + 1] *= window[n2 - 2 * k - 2];

  1505.         output[n - 2 * k - 2] *= window[n - 2 * k - 2];

  1506.         output[3 * n4 + 2 * k + 1] *= window[n4 - 2 * k - 2];

  1507.     }

  1508. }*/

  1509. 

  1510. static inline void overlap_and_add(float *tmp_output, float *delay, float *output)

  1511. {

  1512.     int n;

  1513. 

  1514.     for (n = 0; n < BLOCK_SIZE; n++) {

  1515.         output[n] = 2 * (tmp_output[n] * window[n] + delay[n] * window[255 - n]);

  1516.         delay[n] = tmp_output[BLOCK_SIZE + n];

  1517.     }

  1518. }

  1519. 

  1520. 

  1521. static inline void do_imdct(AC3DecodeContext *ctx)

  1522. {

  1523.     ac3_audio_block *ab = &ctx->audio_block;

  1524.     int i;

  1525. 

  1526.     if (ctx->output & AC3_OUTPUT_LFEON) {

  1527.         av_log(NULL, AV_LOG_INFO, "imdct lfe\n");

  1528.         ff_imdct_calc(&ctx->imdct_ctx_512, ab->tmp_output, ab->transform_coeffs[0], ab->tmp_imdct);

  1529.         //window_and_de_interleave(ab->tmp_output);

  1530.         overlap_and_add(ab->tmp_output, ab->delay[0], ab->output[0]);

  1531.     }

  1532.     for (i = 0; i < ctx->bsi.nfchans; i++) {

  1533.         if (!(((ab->blksw) >> i) & 1)) {

  1534.             av_log(NULL, AV_LOG_INFO, "imdct channel %d - block switching not enabled\n", i);

  1535.             ff_imdct_calc(&ctx->imdct_ctx_512, ab->tmp_output, ab->transform_coeffs[i + 1], ab->tmp_imdct);

  1536.             //window_and_de_interleave(ab->tmp_output);

  1537.             overlap_and_add(ab->tmp_output, ab->delay[i + 1], ab->output[i + 1]);

  1538.         } else {

  1539.             av_log(NULL, AV_LOG_INFO, "imdct channel %d skipping - block switching enabled\n", i);

  1540.         }

  1541.     }

  1542. }

  1543. 

  1544. 

  1545. 

  1546. static int ac3_parse_audio_block(AC3DecodeContext * ctx, int index)

  1547. {

  1548.     ac3_audio_block *ab = &ctx->audio_block;

  1549.     int nfchans = ctx->bsi.nfchans;

  1550.     int acmod = ctx->bsi.acmod;

  1551.     int i, bnd, rbnd, seg, grpsize;

  1552.     GetBitContext *gb = &ctx->gb;

  1553.     uint32_t *flags = &ab->flags;

  1554.     int bit_alloc_flags = 0;

  1555.     float drange, tmpco;

  1556.     uint8_t *dexps;

  1557.     int mstrcplco, cplcoexp, cplcomant, sbnd, cplbndstrc;

  1558. 

  1559.     *flags = 0;

  1560.     ab->blksw = 0;

  1561.     for (i = 0; i < 5; i++)

  1562.         ab->chcoeffs[i] = 1.0;

  1563.     for (i = 0; i < nfchans; i++) /*block switch flag */

  1564.         ab->blksw |= get_bits1(gb) << i;

  1565.     ab->dithflag = 0;

  1566.     for (i = 0; i < nfchans; i++) /* dithering flag */

  1567.         ab->dithflag |= get_bits1(gb) << i;

  1568.     if (get_bits1(gb)) { /* dynamic range */

  1569.         *flags |= AC3_AB_DYNRNGE;

  1570.         ab->dynrng = get_bits(gb, 8);

  1571.         drange = ((((ab->dynrng & 0x1f) | 0x20) << 13) * scale_factors[3 - (ab->dynrng >> 5)]);

  1572.         for (i = 0; i < nfchans; i++)

  1573.             ab->chcoeffs[i] *= drange;

  1574.     }

  1575.     if (acmod == 0x00) { /* dynamic range 1+1 mode */

  1576.         if (get_bits1(gb)) {

  1577.             *flags |= AC3_AB_DYNRNG2E;

  1578.             ab->dynrng2 = get_bits(gb, 8);

  1579.             drange = ((((ab->dynrng2 & 0x1f) | 0x20) << 13) * scale_factors[3 - (ab->dynrng2 >> 5)]);

  1580.             ab->chcoeffs[1] *= drange;

  1581.         }

  1582.     }

  1583.     get_downmix_coeffs(ctx);

  1584.     if (get_bits1(gb)) { /* coupling strategy */

  1585.         *flags |= AC3_AB_CPLSTRE;

  1586.         ab->cplbndstrc = 0;

  1587.         ab->chincpl = 0;

  1588.         if (get_bits1(gb)) { /* coupling in use */

  1589.             *flags |= AC3_AB_CPLINU;

  1590.             for (i = 0; i < nfchans; i++)

  1591.                 ab->chincpl |= get_bits1(gb) << i;

  1592.             if (acmod == 0x02)

  1593.                 if (get_bits1(gb)) /* phase flag in use */

  1594.                     *flags |= AC3_AB_PHSFLGINU;

  1595.             ab->cplbegf = get_bits(gb, 4);

  1596.             ab->cplendf = get_bits(gb, 4);

  1597.             if (3 + ab->cplendf - ab->cplbegf < 0)

  1598.                 return -1;

  1599.             ab->ncplbnd = ab->ncplsubnd = 3 + ab->cplendf - ab->cplbegf;

  1600.             ab->cplstrtmant = ab->cplbegf * 12 + 37;

  1601.             ab->cplendmant = ab->cplendf * 12 + 73;

  1602.             for (i = 0; i < ab->ncplsubnd - 1; i++) /* coupling band structure */

  1603.                 if (get_bits1(gb)) {

  1604.                     ab->cplbndstrc |= 1 << i;

  1605.                     ab->ncplbnd--;

  1606.                 }

  1607.         }

  1608.     }

  1609.     if (ab->chincpl) {

  1610.         ab->cplcoe = 0;

  1611.         for (i = 0; i < nfchans; i++)

  1612.             if ((ab->chincpl) >> i & 1)

  1613.                 if (get_bits1(gb)) { /* coupling co-ordinates */

  1614.                     ab->cplcoe |= 1 << i;

  1615.                     mstrcplco = 3 * get_bits(gb, 2);

  1616.                     sbnd = ab->cplbegf;

  1617.                     cplbndstrc = ab->cplbndstrc;

  1618.                     for (bnd = 0; bnd < ab->ncplbnd; bnd++) {

  1619.                         cplcoexp = get_bits(gb, 4);

  1620.                         cplcomant = get_bits(gb, 4);

  1621.                         if (cplcoexp == 15)

  1622.                             cplcomant <<= 14;

  1623.                         else

  1624.                             cplcomant = (cplcomant | 0x10) << 13;

  1625.                         tmpco = ab->cplco[i][sbnd++] = cplcomant * scale_factors[cplcoexp + mstrcplco];

  1626.                         while (cplbndstrc & 1) {

  1627.                             ab->cplco[i][sbnd++] = tmpco;

  1628.                             cplbndstrc >>= 1;

  1629.                         }

  1630.                         cplbndstrc >>= 1;

  1631.                     }

  1632.                 }

  1633.         ab->phsflg = 0;

  1634.         if ((acmod == 0x02) && (*flags & AC3_AB_PHSFLGINU) && (ab->cplcoe & 1 || ab->cplcoe & (1 << 1))) {

  1635.             sbnd = ab->cplbegf;

  1636.             cplbndstrc = ab->cplbndstrc;

  1637.             for (bnd = 0; bnd < ab->ncplbnd; bnd++)

  1638.                 if (get_bits1(gb)) {

  1639.                     ab->phsflg |= 1 << bnd;

  1640.                     ab->cplco[1][sbnd] = -ab->cplco[1][sbnd];

  1641.                     sbnd++;

  1642.                     while (cplbndstrc & 1) {

  1643.                         ab->cplco[1][sbnd] = -ab->cplco[1][sbnd];

  1644.                         sbnd++;

  1645.                         cplbndstrc >>= 1;

  1646.                     }

  1647.                     cplbndstrc >>= 1;

  1648.                 } else {

  1649.                     sbnd++;

  1650.                     while (cplbndstrc & 1) {

  1651.                         sbnd++;

  1652.                         cplbndstrc >>= 1;

  1653.                     }

  1654.                     cplbndstrc >>= 1;

  1655.                 }

  1656.         }

  1657.     }

  1658.     ab->rematflg = 0;

  1659.     if (acmod == 0x02) /* rematrixing */

  1660.         if (get_bits1(gb)) {

  1661.             *flags |= AC3_AB_REMATSTR;

  1662.             if (!(ab->chincpl) || ab->cplbegf > 2)

  1663.                 for (rbnd = 0; rbnd < 4; rbnd++)

  1664.                     ab->rematflg |= get_bits1(gb) << rbnd;

  1665.             if (ab->cplbegf > 0 && ab->cplbegf <= 2 && (ab->chincpl))

  1666.                 for (rbnd = 0; rbnd < 3; rbnd++)

  1667.                     ab->rematflg |= get_bits1(gb) << rbnd;

  1668.             if (ab->cplbegf == 0 && (ab->chincpl))

  1669.                 for (rbnd = 0; rbnd < 2; rbnd++)

  1670.                     ab->rematflg |= get_bits1(gb) << rbnd;

  1671.         }

  1672.     ab->cplexpstr = AC3_EXPSTR_REUSE;

  1673.     ab->lfeexpstr = AC3_EXPSTR_REUSE;

  1674.     if (ab->chincpl) /* coupling exponent strategy */

  1675.         ab->cplexpstr = get_bits(gb, 2);

  1676.     for (i = 0; i < nfchans; i++) /* channel exponent strategy */

  1677.         ab->chexpstr[i] = get_bits(gb, 2);

  1678.     if (ctx->bsi.flags & AC3_BSI_LFEON) /* lfe exponent strategy */

  1679.         ab->lfeexpstr = get_bits1(gb);

  1680.     for (i = 0; i < nfchans; i++) /* channel bandwidth code */

  1681.         if (ab->chexpstr[i] != AC3_EXPSTR_REUSE) {

  1682.             if (((ab->chincpl) >> i) & 1)  {

  1683.                 ab->endmant[i] = ab->cplstrtmant;

  1684.             }

  1685.             else {

  1686.                 ab->chbwcod[i] = get_bits(gb, 6);

  1687.                 if (ab->chbwcod[i] > 60) {

  1688.                     av_log(NULL, AV_LOG_ERROR, "chbwcod = %d > 60", ab->chbwcod[i]);

  1689.                     return -1;

  1690.                 }

  1691.                 ab->endmant[i] = ab->chbwcod[i] * 3 + 73;

  1692.             }

  1693.         }

  1694.     if (ab->cplexpstr != AC3_EXPSTR_REUSE) {/* coupling exponents */

  1695.         bit_alloc_flags |= 64;

  1696.         ab->cplabsexp = get_bits(gb, 4) << 1;

  1697.         ab->ncplgrps = (ab->cplendmant - ab->cplstrtmant) / (3 << (ab->cplexpstr - 1));

  1698.         if (decode_exponents(gb, ab->cplexpstr, ab->ncplgrps, ab->cplabsexp, ab->dcplexps + ab->cplstrtmant)) {

  1699.             av_log(NULL, AV_LOG_ERROR, "error decoding coupling exponents\n");

  1700.             return -1;

  1701.         }

  1702.     }

  1703.     for (i = 0; i < nfchans; i++) /* fbw channel exponents */

  1704.         if (ab->chexpstr[i] != AC3_EXPSTR_REUSE) {

  1705.             bit_alloc_flags |= 1 << i;

  1706.             grpsize = 3 << (ab->chexpstr[i] - 1);

  1707.             ab->nchgrps[i] = (ab->endmant[i] + grpsize - 4) / grpsize;

  1708.             dexps = ab->dexps[i];

  1709.             dexps[0] = get_bits(gb, 4);

  1710.             if (decode_exponents(gb, ab->chexpstr[i], ab->nchgrps[i], dexps[0], dexps + 1)) {

  1711.                 av_log(NULL, AV_LOG_ERROR, "error decoding channel %d exponents\n", i);

  1712.                 return -1;

  1713.             }

  1714.             ab->gainrng[i] = get_bits(gb, 2);

  1715.         }

  1716.     if (ab->lfeexpstr != AC3_EXPSTR_REUSE) { /* lfe exponents */

  1717.         bit_alloc_flags |= 32;

  1718.         ab->dlfeexps[0] = get_bits(gb, 4);

  1719.         if (decode_exponents(gb, ab->lfeexpstr, 2, ab->dlfeexps[0], ab->dlfeexps + 1)) {

  1720.             av_log(NULL, AV_LOG_ERROR, "error decoding lfe exponents\n");

  1721.             return -1;

  1722.         }

  1723.     }

  1724. 

  1725.     if (get_bits1(gb)) { /* bit allocation information */

  1726.         *flags |= AC3_AB_BAIE;

  1727.         bit_alloc_flags |= 127;

  1728.         ab->sdcycod = get_bits(gb, 2);

  1729.         ab->fdcycod = get_bits(gb, 2);

  1730.         ab->sgaincod = get_bits(gb, 2);

  1731.         ab->dbpbcod = get_bits(gb, 2);

  1732.         ab->floorcod = get_bits(gb, 3);

  1733.     }

  1734.     if (get_bits1(gb)) { /* snroffset */

  1735.         *flags |= AC3_AB_SNROFFSTE;

  1736.         bit_alloc_flags |= 127;

  1737.         ab->csnroffst = get_bits(gb, 6);

  1738.         if (ab->chincpl) { /* couling fine snr offset and fast gain code */

  1739.             ab->cplfsnroffst = get_bits(gb, 4);

  1740.             ab->cplfgaincod = get_bits(gb, 3);

  1741.         }

  1742.         for (i = 0; i < nfchans; i++) { /* channel fine snr offset and fast gain code */

  1743.             ab->fsnroffst[i] = get_bits(gb, 4);

  1744.             ab->fgaincod[i] = get_bits(gb, 3);

  1745.         }

  1746.         if (ctx->bsi.flags & AC3_BSI_LFEON) { /* lfe fine snr offset and fast gain code */

  1747.             ab->lfefsnroffst = get_bits(gb, 4);

  1748.             ab->lfefgaincod = get_bits(gb, 3);

  1749.         }

  1750.     }

  1751.     if (ab->chincpl)

  1752.         if (get_bits1(gb)) { /* coupling leak information */

  1753.             bit_alloc_flags |= 64;

  1754.             *flags |= AC3_AB_CPLLEAKE;

  1755.             ab->cplfleak = get_bits(gb, 3);

  1756.             ab->cplsleak = get_bits(gb, 3);

  1757.         }

  1758.     ab->cpldeltbae = AC3_DBASTR_RESERVED;

  1759.     for (i = 0; i < nfchans; i++)

  1760.         ab->deltbae[i] = AC3_DBASTR_RESERVED;

  1761.     if (get_bits1(gb)) { /* delta bit allocation information */

  1762.         *flags |= AC3_AB_DELTBAIE;

  1763.         bit_alloc_flags |= 127;

  1764.         if (ab->chincpl) {

  1765.             ab->cpldeltbae = get_bits(gb, 2);

  1766.             if (ab->cpldeltbae == AC3_DBASTR_RESERVED) {

  1767.                 av_log(NULL, AV_LOG_ERROR, "coupling delta bit allocation strategy reserved\n");

  1768.                 return -1;

  1769.             }

  1770.         }

  1771.         for (i = 0; i < nfchans; i++) {

  1772.             ab->deltbae[i] = get_bits(gb, 2);

  1773.             if (ab->deltbae[i] == AC3_DBASTR_RESERVED) {

  1774.                 av_log(NULL, AV_LOG_ERROR, "delta bit allocation strategy reserved\n");

  1775.                 return -1;

  1776.             }

  1777.         }

  1778.         if (ab->chincpl)

  1779.             if (ab->cpldeltbae == AC3_DBASTR_NEW) { /*coupling delta offset, len and bit allocation */

  1780.                 ab->cpldeltnseg = get_bits(gb, 3);

  1781.                 for (seg = 0; seg <= ab->cpldeltnseg; seg++) {

  1782.                     ab->cpldeltoffst[seg] = get_bits(gb, 5);

  1783.                     ab->cpldeltlen[seg] = get_bits(gb, 4);

  1784.                     ab->cpldeltba[seg] = get_bits(gb, 3);

  1785.                 }

  1786.             }

  1787.         for (i = 0; i < nfchans; i++)

  1788.             if (ab->deltbae[i] == AC3_DBASTR_NEW) {/*channel delta offset, len and bit allocation */

  1789.                 ab->deltnseg[i] = get_bits(gb, 3);

  1790.                 for (seg = 0; seg <= ab->deltnseg[i]; seg++) {

  1791.                     ab->deltoffst[i][seg] = get_bits(gb, 5);

  1792.                     ab->deltlen[i][seg] = get_bits(gb, 4);

  1793.                     ab->deltba[i][seg] = get_bits(gb, 3);

  1794.                 }

  1795.             }

  1796.     }

  1797. 

  1798.     do_bit_allocation (ctx, bit_alloc_flags); /* perform the bit allocation */

  1799.     if (get_bits1(gb)) { /* unused dummy data */

  1800.         *flags |= AC3_AB_SKIPLE;

  1801.         ab->skipl = get_bits(gb, 9);

  1802.         while(ab->skipl--)

  1803.             skip_bits(gb, 8);

  1804.     }

  1805.     /* unpack the transform coefficients

  1806.      * * this also uncouples channels if coupling is in use.

  1807.      */

  1808.     if (get_transform_coeffs(ctx)) {

  1809.         av_log(NULL, AV_LOG_ERROR, "Error in routine get_transform_coeffs\n");

  1810.         return -1;

  1811.     }

  1812.     /*for (i = 0; i < nfchans; i++)

  1813.         dump_floats("channel transform coefficients", 10, ab->transform_coeffs[i + 1], BLOCK_SIZE);*/

  1814. 

  1815.     /* recover coefficients if rematrixing is in use */

  1816.     if (*flags & AC3_AB_REMATSTR)

  1817.         do_rematrixing(ctx);

  1818. 

  1819.     do_imdct(ctx);

  1820.     /*for(i = 0; i < nfchans; i++)

  1821.         dump_floats("channel output", 10, ab->output[i + 1], BLOCK_SIZE);*/

  1822. 

  1823.     do_downmix(ctx);

  1824. 

  1825.     return 0;

  1826. }

  1827. 

  1828. /* from FreeSWITCH Modular Media Switching Library */

  1829. #define NORMFACT    (float)0x8000

  1830. #define MAXSAMPLE   (float)0x7fff

  1831. 

  1832. 

  1833. static inline int16_t convert(float f)

  1834. {

  1835.     /*short s;

  1836.     f = f * NORMFACT;

  1837.     if (f >= 0)

  1838.         s = (short)(f + 0.5);

  1839.     else

  1840.         s = (short)(f - 0.5);

  1841.     if ((float)s > MAXSAMPLE)

  1842.         s = (float)MAXSAMPLE;

  1843.     if (s < (short) -MAXSAMPLE)

  1844.         s = (short) -MAXSAMPLE;

  1845. 

  1846.     return s;*/

  1847.     int a;

  1848.     a = lrintf(f * 32767.0);

  1849.     return ((int16_t)a);

  1850. }

  1851. 

  1852. static int ac3_decode_frame(AVCodecContext * avctx, void *data, int *data_size, uint8_t *buf, int buf_size)

  1853. {

  1854.     AC3DecodeContext *ctx = (AC3DecodeContext *)avctx->priv_data;

  1855.     ac3_audio_block *ab = &ctx->audio_block;

  1856.     int frame_start;

  1857.     int16_t *out_samples = (int16_t *)data;

  1858.     int i, j, k, value;

  1859. 

  1860.     //Synchronize the frame.

  1861.     frame_start = ac3_synchronize(buf, buf_size);

  1862.     if (frame_start == -1) {

  1863.         av_log(avctx, AV_LOG_ERROR, "frame is not synchronized\n");

  1864.         *data_size = 0;

  1865.         return buf_size;

  1866.     }

  1867. 

  1868.     //Initialize the GetBitContext with the start of valid AC3 Frame.

  1869.     init_get_bits(&(ctx->gb), buf + frame_start, (buf_size - frame_start) * 8);

  1870. 

  1871.     //Parse the syncinfo.

  1872.     //If 'fscod' or 'bsid' is not valid the decoder shall mute as per the standard.

  1873.     if (!ac3_parse_sync_info(ctx)) {

  1874.         av_log(avctx, AV_LOG_ERROR, "\n");

  1875.         *data_size = 0;

  1876.         return buf_size;

  1877.     }

  1878. 

  1879.     //Check for the errors.

  1880.     /* if (ac3_error_check(ctx)) {

  1881.         *data_size = 0;

  1882.         return -1;

  1883.     } */

  1884. 

  1885.     //Parse the BSI.

  1886.     //If 'bsid' is not valid decoder shall not decode the audio as per the standard.

  1887.     ac3_parse_bsi(ctx);

  1888. 

  1889.     avctx->sample_rate = ctx->sync_info.sampling_rate;

  1890.     avctx->bit_rate = ctx->sync_info.bit_rate;

  1891.     if (avctx->channels == 0) {

  1892.         ctx->output |= AC3_OUTPUT_UNMODIFIED;

  1893.         avctx->channels = ctx->bsi.nfchans;

  1894.     } else if ((ctx->bsi.nfchans + ((ctx->bsi.flags & AC3_BSI_LFEON) ? 1 : 0)) < avctx->channels) {

  1895.         av_log(avctx, AV_LOG_INFO, "ac3_decoder: AC3 Source Channels Are Less Then Specified %d: Output to %d Channels\n",

  1896.                 avctx->channels, (ctx->bsi.nfchans + ((ctx->bsi.flags & AC3_BSI_LFEON) ? 1 : 0)));

  1897.         avctx->channels = ctx->bsi.nfchans;

  1898.         ctx->output |= AC3_OUTPUT_UNMODIFIED;

  1899.     } else if (avctx->channels == 1) {

  1900.         ctx->output |= AC3_OUTPUT_MONO;

  1901.     } else if (avctx->channels == 2) {

  1902.         if (ctx->bsi.dsurmod == 0x02)

  1903.             ctx->output |= AC3_OUTPUT_DOLBY;

  1904.         else

  1905.             ctx->output |= AC3_OUTPUT_STEREO;

  1906.     }

  1907.     if (ctx->bsi.flags & AC3_BSI_LFEON) {

  1908.         avctx->channels++;

  1909.         ctx->output |= AC3_OUTPUT_LFEON;

  1910.     }

  1911. 

  1912.     av_log(avctx, AV_LOG_INFO, "channels = %d \t bit rate = %d \t sampling rate = %d \n", avctx->channels, avctx->bit_rate * 1000, avctx->sample_rate);

  1913. 

  1914.     //Parse the Audio Blocks.

  1915.     for (i = 0; i < AUDIO_BLOCKS; i++) {

  1916.         if (ac3_parse_audio_block(ctx, i)) {

  1917.             av_log(avctx, AV_LOG_ERROR, "error parsing the audio block\n");

  1918.             *data_size = 0;

  1919.             return ctx->sync_info.framesize;

  1920.         }

  1921.         j = ((ctx->output & AC3_OUTPUT_LFEON) ? 0 : 1);

  1922.         for (;j < avctx->channels; j++) {

  1923.             for(k = 0; k < BLOCK_SIZE; k++) {

  1924.                 value = convert(ab->output[j][k]);

  1925.                 av_log(NULL, AV_LOG_INFO, "%d\t", value);

  1926.                 *(out_samples++) = value;

  1927.             }

  1928.         }

  1929.     }

  1930.     *data_size = AUDIO_BLOCKS * BLOCK_SIZE * avctx->channels * sizeof (int16_t);

  1931.     return ctx->sync_info.framesize;

  1932. }

  1933. 

  1934. static int ac3_decode_end(AVCodecContext *ctx)

  1935. {

  1936.     return 0;

  1937. }

  1938. 

  1939. AVCodec lgpl_ac3_decoder = {

  1940.     "ac3",

  1941.     CODEC_TYPE_AUDIO,

  1942.     CODEC_ID_AC3,

  1943.     sizeof (AC3DecodeContext),

  1944.     ac3_decode_init,

  1945.     NULL,

  1946.     ac3_decode_end,

  1947.     ac3_decode_frame,

  1948. };