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.
10112 Commits
32 Branches
789MB
Tree: 0058584580
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0058584580'
${ noResults }
FFmpeg/libavcodec/ac3dec.c

1836 lines
63KB
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 "ac3.h"

  29. #include "ac3tab.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 MAX_BLOCK_SIZE  256

  39. #define MAX_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.     uint8_t  mstrcplco[5];          //master coupling co-ordinate for channels in use

  145.     uint8_t  cplcoexp[5][18];       //coupling co-ordinate exponenets

  146.     uint8_t  cplcomant[5][18];      //coupling co-ordinate mantissas

  147.     uint32_t phsflg;                //phase flag per band

  148.     uint8_t  rematflg;              //rematrixing flag

  149.     uint8_t  cplexpstr;             //coupling exponent strategy

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

  151.     uint8_t  lfeexpstr;             //lfe exponent strategy

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

  153.     uint8_t  cplabsexp;             //coupling absolute exponent

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

  155.     uint8_t  sdcycod;               //slow decay code

  156.     uint8_t  fdcycod;               //fast decay code

  157.     uint8_t  sgaincod;              //slow gain code

  158.     uint8_t  dbpbcod;               //dB per bit code

  159.     uint8_t  floorcod;              //masking floor code

  160.     uint8_t  csnroffst;             //coarse SNR offset

  161.     uint8_t  cplfsnroffst;          //coupling fine SNR offset

  162.     uint8_t  cplfgaincod;           //coupling fast gain code

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

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

  165.     uint8_t  lfefsnroffst;          //lfe fine SNR offset

  166.     uint8_t  lfefgaincod;           //lfe fast gain code

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

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

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

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

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

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

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

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

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

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

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

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

  179.     uint16_t skipl;                 //skip length

  180. 

  181.     /* Derived Attributes */

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

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

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

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

  186.     int      nchmant[5];            //derived from cplbegf or chbwcod

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

  188. 

  189.     uint8_t  cplstrtbnd;            //coupling start band for bit allocation

  190.     uint8_t  cplstrtmant;           //coupling start mantissa

  191.     uint8_t  cplendmant;            //coupling end mantissa

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

  193. 

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

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

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

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

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

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

  200. 

  201.     DECLARE_ALIGNED_16(float, transform_coeffs[MAX_CHANNELS][MAX_BLOCK_SIZE]); //transform coefficients

  202.     DECLARE_ALIGNED_16(float, cplcoeffs[256]);        //temporary storage for coupling transform coefficients

  203.     DECLARE_ALIGNED_16(float, block_output[MAX_CHANNELS][MAX_BLOCK_SIZE]);

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

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

  206. } ac3_audio_block;

  207. 

  208. 

  209. 

  210. #define AC3_OUTPUT_UNMODIFIED   0x00

  211. #define AC3_OUTPUT_MONO         0x01

  212. #define AC3_OUTPUT_STEREO       0x02

  213. #define AC3_OUTPUT_DOLBY        0x03

  214. 

  215. #define AC3_INPUT_DUALMONO      0x00

  216. #define AC3_INPUT_MONO          0x01

  217. #define AC3_INPUT_STEREO        0x02

  218. #define AC3_INPUT_3F            0x03

  219. #define AC3_INPUT_2F_1R         0x04

  220. #define AC3_INPUT_3F_1R         0x05

  221. #define AC3_INPUT_2F_2R         0x06

  222. #define AC3_INPUT_3F_2R         0x07

  223. 

  224. /* BEGIN Mersenne Twister Code. */

  225. #define N 624

  226. #define M 397

  227. #define MATRIX_A    0x9908b0df

  228. #define UPPER_MASK  0x80000000

  229. #define LOWER_MASK  0x7fffffff

  230. 

  231. typedef struct {

  232.     uint32_t mt[N];

  233.     int      mti;

  234. } dither_state;

  235. 

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

  237. {

  238.     if (seed == 0)

  239.         seed = 0x1f2e3d4c;

  240. 

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

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

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

  244. }

  245. 

  246. static uint32_t dither_uint32(dither_state *state)

  247. {

  248.     uint32_t y;

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

  250.     int kk;

  251. 

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

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

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

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

  256.         }

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

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

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

  260.         }

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

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

  263. 

  264.         state->mti = 0;

  265.     }

  266. 

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

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

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

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

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

  272. 

  273.     return y;

  274. }

  275. 

  276. static inline int16_t dither_int16(dither_state *state)

  277. {

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

  279. }

  280. 

  281. /* END Mersenne Twister */

  282. 

  283. /* AC3 Context. */

  284. typedef struct {

  285.     ac3_sync_info   sync_info;

  286.     ac3_bsi         bsi;

  287.     ac3_audio_block audio_block;

  288.     dither_state    state;

  289.     MDCTContext     imdct_ctx_256;

  290.     MDCTContext     imdct_ctx_512;

  291.     GetBitContext   gb;

  292.     int             output;

  293.     DECLARE_ALIGNED_16(float, delay[MAX_CHANNELS][MAX_BLOCK_SIZE]);

  294.     DECLARE_ALIGNED_16(FFTSample, tmp_imdct[MAX_BLOCK_SIZE * 2]);

  295.     DECLARE_ALIGNED_16(FFTSample, tmp_output[MAX_BLOCK_SIZE * 2]);

  296. } AC3DecodeContext;

  297. 

  298. static void ac3_common_init1(void)

  299. {

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

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

  302.     k = 0;

  303.     l = 0;

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

  305.         bndtab[i] = l;

  306.         v = bndsz[i];

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

  308.         l += v;

  309.     }

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

  311.     bndtab[50] = 0;

  312. }

  313. 

  314. 

  315. static int ac3_decode_init(AVCodecContext *avctx)

  316. {

  317.     AC3DecodeContext *ctx = avctx->priv_data;

  318. 

  319.     ac3_common_init1();

  320. 

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

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

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

  324. 

  325.     return 0;

  326. }

  327. 

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

  329. {

  330.     int i;

  331. 

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

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

  334.             return i;

  335. 

  336.     return -1;

  337. }

  338. 

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

  340. static int ac3_parse_sync_info(AC3DecodeContext *ctx)

  341. {

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

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

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

  345. 

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

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

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

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

  350.         return 0;

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

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

  353.         return 0;

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

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

  356. 

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

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

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

  360.         return 0;

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

  362. 

  363.     switch (sync_info->fscod) {

  364.         case 0x00:

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

  366.             return sync_info->framesize;

  367.         case 0x01:

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

  369.             return sync_info->framesize;

  370.         case 0x02:

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

  372.             return sync_info->framesize;

  373.     }

  374. 

  375.     /* never reached */

  376.     return 0;

  377. }

  378. 

  379. //Returns -1 when

  380. static int ac3_parse_bsi(AC3DecodeContext *ctx)

  381. {

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

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

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

  385.     int i;

  386. 

  387.     *flags = 0;

  388.     bsi->cmixlev = 0;

  389.     bsi->surmixlev = 0;

  390.     bsi->dsurmod = 0;

  391.     ctx->audio_block.cpldeltbae = AC3_DBASTR_NONE;

  392.     ctx->audio_block.cpldeltnseg = 0;

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

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

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

  396.     }

  397. 

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

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

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

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

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

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

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

  405.     if (get_bits1(gb))

  406.         *flags |= AC3_BSI_LFEON;

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

  408.     if (get_bits1(gb)) {

  409.         *flags |= AC3_BSI_COMPRE;

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

  411.     }

  412.     if (get_bits1(gb)) {

  413.         *flags |= AC3_BSI_LANGCODE;

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

  415.     }

  416.     if (get_bits1(gb)) {

  417.         *flags |= AC3_BSI_AUDPRODIE;

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

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

  420.     }

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

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

  423.         if (get_bits1(gb)) {

  424.             *flags |= AC3_BSI_COMPR2E;

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

  426.         }

  427.         if (get_bits1(gb)) {

  428.             *flags |= AC3_BSI_LANGCOD2E;

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

  430.         }

  431.         if (get_bits1(gb)) {

  432.             *flags |= AC3_BSI_AUDPRODIE;

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

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

  435.         }

  436.     }

  437.     if (get_bits1(gb))

  438.         *flags |= AC3_BSI_COPYRIGHTB;

  439.     if (get_bits1(gb))

  440.         *flags |= AC3_BSI_ORIGBS;

  441.     if (get_bits1(gb)) {

  442.         *flags |= AC3_BSI_TIMECOD1E;

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

  444.     }

  445.     if (get_bits1(gb)) {

  446.         *flags |= AC3_BSI_TIMECOD2E;

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

  448.     }

  449.     if (get_bits1(gb)) {

  450.         *flags |= AC3_BSI_ADDBSIE;

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

  452.         for (i = 0; i < (bsi->addbsil + 1); i++)

  453.             skip_bits(gb, 8);

  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 (bndend != 7 || 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 (bndend != 7 || 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 (bndend != 7 || 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 & AC3_AB_CPLINU)

  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->flags & AC3_AB_CPLINU) && (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. static inline float to_float(uint8_t exp, int16_t mantissa)

  768. {

  769.     return ((float) (mantissa * scale_factors[exp]));

  770. }

  771. 

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

  773.     uint8_t gcodes[3];

  774.     uint8_t gcptr;

  775. } mant_group;

  776. 

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

  778. static int get_transform_coeffs1(uint8_t *exps, uint8_t *bap, float chcoeff,

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

  780.         dither_state *state)

  781. {

  782.     int16_t mantissa;

  783.     int i;

  784.     int gcode;

  785.     mant_group l3_grp, l5_grp, l11_grp;

  786. 

  787.     for (i = 0; i < 3; i++)

  788.         l3_grp.gcodes[i] = l5_grp.gcodes[i] = l11_grp.gcodes[i] = -1;

  789.     l3_grp.gcptr = l5_grp.gcptr = 3;

  790.     l11_grp.gcptr = 2;

  791. 

  792.     i = 0;

  793.     while (i < start)

  794.         coeffs[i++] = 0;

  795. 

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

  797.         switch (bap[i]) {

  798.             case 0:

  799.                 if (!dith_flag) {

  800.                     coeffs[i] = 0;

  801.                     continue;

  802.                 }

  803.                 else {

  804.                     mantissa = dither_int16(state);

  805.                     coeffs[i] = to_float(exps[i], mantissa) * chcoeff;

  806.                     continue;

  807.                 }

  808. 

  809.             case 1:

  810.                 if (l3_grp.gcptr > 2) {

  811.                     gcode = get_bits(gb, 5);

  812.                     if (gcode > 26)

  813.                         return -1;

  814.                     l3_grp.gcodes[0] = gcode / 9;

  815.                     l3_grp.gcodes[1] = (gcode % 9) / 3;

  816.                     l3_grp.gcodes[2] = (gcode % 9) % 3;

  817.                     l3_grp.gcptr = 0;

  818.                 }

  819.                 mantissa = l3_q_tab[l3_grp.gcodes[l3_grp.gcptr++]];

  820.                 coeffs[i] = to_float(exps[i], mantissa) * chcoeff;

  821.                 continue;

  822. 

  823.             case 2:

  824.                 if (l5_grp.gcptr > 2) {

  825.                     gcode = get_bits(gb, 7);

  826.                     if (gcode > 124)

  827.                         return -1;

  828.                     l5_grp.gcodes[0] = gcode / 25;

  829.                     l5_grp.gcodes[1] = (gcode % 25) / 5;

  830.                     l5_grp.gcodes[2] = (gcode % 25) % 5;

  831.                     l5_grp.gcptr = 0;

  832.                 }

  833.                 mantissa = l5_q_tab[l5_grp.gcodes[l5_grp.gcptr++]];

  834.                 coeffs[i] = to_float(exps[i], mantissa) * chcoeff;

  835.                 continue;

  836. 

  837.             case 3:

  838.                 mantissa = get_bits(gb, 3);

  839.                 if (mantissa > 6)

  840.                     return -1;

  841.                 mantissa = l7_q_tab[mantissa];

  842.                 coeffs[i] = to_float(exps[i], mantissa);

  843.                 continue;

  844. 

  845.             case 4:

  846.                 if (l11_grp.gcptr > 1) {

  847.                     gcode = get_bits(gb, 7);

  848.                     if (gcode > 120)

  849.                         return -1;

  850.                     l11_grp.gcodes[0] = gcode / 11;

  851.                     l11_grp.gcodes[1] = gcode % 11;

  852.                 }

  853.                 mantissa = l11_q_tab[l11_grp.gcodes[l11_grp.gcptr++]];

  854.                 coeffs[i] = to_float(exps[i], mantissa) * chcoeff;

  855.                 continue;

  856. 

  857.             case 5:

  858.                 mantissa = get_bits(gb, 4);

  859.                 if (mantissa > 14)

  860.                     return -1;

  861.                 mantissa = l15_q_tab[mantissa];

  862.                 coeffs[i] = to_float(exps[i], mantissa) * chcoeff;

  863.                 continue;

  864. 

  865.             default:

  866.                 mantissa = get_bits(gb, qntztab[bap[i]]) << (16 - qntztab[bap[i]]);

  867.                 coeffs[i] = to_float(exps[i], mantissa) * chcoeff;

  868.                 continue;

  869.         }

  870.     }

  871. 

  872.     i = end;

  873.     while (i < 256)

  874.         coeffs[i++] = 0;

  875. 

  876.     return 0;

  877. }

  878. 

  879. static void uncouple_channels(AC3DecodeContext * ctx)

  880. {

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

  882.     int ch, sbnd, bin;

  883.     int index;

  884.     int16_t mantissa;

  885. 

  886.     /* uncouple channels */

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

  888.         if (ab->chincpl & (1 << ch))

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

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

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

  892.                     ab->transform_coeffs[ch + 1][index] = ab->cplcoeffs[index] * ab->cplco[ch][sbnd] * ab->chcoeffs[ch];

  893.                     /* generate dither if required */

  894.                     if (!ab->bap[ch][index] && (ab->chincpl & (1 << ch)) && (ab->dithflag & (1 << ch))) {

  895.                         mantissa = dither_int16(&ctx->state);

  896.                         ab->transform_coeffs[ch + 1][index] = to_float(ab->dexps[ch][index], mantissa) * ab->chcoeffs[ch];

  897.                     }

  898.                 }

  899. }

  900. 

  901. static int get_transform_coeffs(AC3DecodeContext * ctx)

  902. {

  903.     int i;

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

  905.     int got_cplchan = 0;

  906.     int dithflag = 0;

  907. 

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

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

  910.         /* transform coefficients for individual channel */

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

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

  913.             return -1;

  914.         /* tranform coefficients for coupling channels */

  915.         if ((ab->flags & AC3_AB_CPLINU) && (ab->chincpl & (1 << i)) && !got_cplchan) {

  916.             if (get_transform_coeffs1(ab->dcplexps, ab->cplbap, 1.0f, ab->cplcoeffs,

  917.                         ab->cplstrtmant, ab->cplendmant, 0, &ctx->gb, &ctx->state))

  918.                 return -1;

  919.             got_cplchan = 1;

  920.         }

  921.     }

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

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

  924.                 return -1;

  925. 

  926.     /* uncouple the channels from the coupling channel */

  927.     if (ab->flags & AC3_AB_CPLINU)

  928.         uncouple_channels(ctx);

  929. 

  930.     return 0;

  931. }

  932. 

  933. /* generate coupling co-ordinates for each coupling subband

  934.  * from coupling co-ordinates of each band and coupling band

  935.  * structure information

  936.  */

  937. static void generate_coupling_coordinates(AC3DecodeContext * ctx)

  938. {

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

  940.     uint8_t exp, mstrcplco;

  941.     int16_t mant;

  942.     uint32_t cplbndstrc = (1 << ab->ncplsubnd) >> 1;

  943.     int ch, bnd, sbnd;

  944.     float cplco;

  945. 

  946.     if (ab->cplcoe)

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

  948.             if (ab->cplcoe & (1 << ch)) {

  949.                 mstrcplco = 3 * ab->mstrcplco[ch];

  950.                 sbnd = ab->cplbegf;

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

  952.                     exp = ab->cplcoexp[ch][bnd];

  953.                     if (exp == 15)

  954.                         mant = ab->cplcomant[ch][bnd] <<= 14;

  955.                     else

  956.                         mant = (ab->cplcomant[ch][bnd] | 0x10) << 13;

  957.                     cplco = to_float(exp + mstrcplco, mant);

  958.                     if (ctx->bsi.acmod == 0x02 && (ab->flags & AC3_AB_PHSFLGINU) && ch == 1

  959.                             && (ab->phsflg & (1 << bnd)))

  960.                         cplco = -cplco; /* invert the right channel */

  961.                     ab->cplco[ch][sbnd++] = cplco;

  962.                     while (cplbndstrc & ab->cplbndstrc) {

  963.                         cplbndstrc >>= 1;

  964.                         ab->cplco[ch][sbnd++] = cplco;

  965.                     }

  966.                     cplbndstrc >>= 1;

  967.                 }

  968.             }

  969. }

  970. 

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

  972. {

  973.     float tmp0, tmp1;

  974. 

  975.     while (start < end) {

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

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

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

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

  980.         start++;

  981.     }

  982. }

  983. 

  984. static void do_rematrixing(AC3DecodeContext *ctx)

  985. {

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

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

  988.     uint8_t bndend;

  989. 

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

  991.     if (ab->rematflg & 1)

  992.         do_rematrixing1(ctx, bnd1, bnd2);

  993.     if (ab->rematflg & 2)

  994.         do_rematrixing1(ctx, bnd2, bnd3);

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

  996.         if (ab->cplbegf > 0 && ab->cplbegf <= 2 && (ab->flags & AC3_AB_CPLINU))

  997.             do_rematrixing1(ctx, bnd3, bndend);

  998.         else {

  999.             do_rematrixing1(ctx, bnd3, bnd4);

  1000.             if (ab->rematflg & 8)

  1001.                 do_rematrixing1(ctx, bnd4, bndend);

  1002.         }

  1003.     }

  1004. }

  1005. 

  1006. static void get_downmix_coeffs(AC3DecodeContext *ctx)

  1007. {

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

  1009.     int to = ctx->output;

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

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

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

  1013. 

  1014.     if (to == AC3_OUTPUT_UNMODIFIED)

  1015.         return;

  1016. 

  1017.     switch (from) {

  1018.         case AC3_INPUT_DUALMONO:

  1019.             switch (to) {

  1020.                 case AC3_OUTPUT_MONO:

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

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

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

  1024.                     break;

  1025.             }

  1026.             break;

  1027.         case AC3_INPUT_MONO:

  1028.             switch (to) {

  1029.                 case AC3_OUTPUT_STEREO:

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

  1031.                     break;

  1032.             }

  1033.             break;

  1034.         case AC3_INPUT_STEREO:

  1035.             switch (to) {

  1036.                 case AC3_OUTPUT_MONO:

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

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

  1039.                     break;

  1040.             }

  1041.             break;

  1042.         case AC3_INPUT_3F:

  1043.             switch (to) {

  1044.                 case AC3_OUTPUT_MONO:

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

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

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

  1048.                     break;

  1049.                 case AC3_OUTPUT_STEREO:

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

  1051.                     break;

  1052.             }

  1053.             break;

  1054.         case AC3_INPUT_2F_1R:

  1055.             switch (to) {

  1056.                 case AC3_OUTPUT_MONO:

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

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

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

  1060.                     break;

  1061.                 case AC3_OUTPUT_STEREO:

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

  1063.                     break;

  1064.                 case AC3_OUTPUT_DOLBY:

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

  1066.                     break;

  1067.             }

  1068.             break;

  1069.         case AC3_INPUT_3F_1R:

  1070.             switch (to) {

  1071.                 case AC3_OUTPUT_MONO:

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

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

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

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

  1076.                     break;

  1077.                 case AC3_OUTPUT_STEREO:

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

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

  1080.                     break;

  1081.                 case AC3_OUTPUT_DOLBY:

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

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

  1084.                     break;

  1085.             }

  1086.             break;

  1087.         case AC3_INPUT_2F_2R:

  1088.             switch (to) {

  1089.                 case AC3_OUTPUT_MONO:

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

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

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

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

  1094.                     break;

  1095.                 case AC3_OUTPUT_STEREO:

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

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

  1098.                     break;

  1099.                 case AC3_OUTPUT_DOLBY:

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

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

  1102.                     break;

  1103.             }

  1104.             break;

  1105.         case AC3_INPUT_3F_2R:

  1106.             switch (to) {

  1107.                 case AC3_OUTPUT_MONO:

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

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

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

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

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

  1113.                     break;

  1114.                 case AC3_OUTPUT_STEREO:

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

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

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

  1118.                     break;

  1119.                 case AC3_OUTPUT_DOLBY:

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

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

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

  1123.                     break;

  1124.             }

  1125.             break;

  1126.     }

  1127. }

  1128. 

  1129. static inline void mix_dualmono_to_mono(AC3DecodeContext *ctx)

  1130. {

  1131.     int i;

  1132.     float (*output)[256] = ctx->audio_block.block_output;

  1133. 

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

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

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

  1137. }

  1138. 

  1139. static inline void mix_dualmono_to_stereo(AC3DecodeContext *ctx)

  1140. {

  1141.     int i;

  1142.     float tmp;

  1143.     float (*output)[256] = ctx->audio_block.block_output;

  1144. 

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

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

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

  1148.     }

  1149. }

  1150. 

  1151. static inline void upmix_mono_to_stereo(AC3DecodeContext *ctx)

  1152. {

  1153.     int i;

  1154.     float (*output)[256] = ctx->audio_block.block_output;

  1155. 

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

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

  1158. }

  1159. 

  1160. static inline void mix_stereo_to_mono(AC3DecodeContext *ctx)

  1161. {

  1162.     int i;

  1163.     float (*output)[256] = ctx->audio_block.block_output;

  1164. 

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

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

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

  1168. }

  1169. 

  1170. static inline void mix_3f_to_mono(AC3DecodeContext *ctx)

  1171. {

  1172.     int i;

  1173.     float (*output)[256] = ctx->audio_block.block_output;

  1174. 

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

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

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

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

  1179. }

  1180. 

  1181. static inline void mix_3f_to_stereo(AC3DecodeContext *ctx)

  1182. {

  1183.     int i;

  1184.     float (*output)[256] = ctx->audio_block.block_output;

  1185. 

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

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

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

  1189.     }

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

  1191. }

  1192. 

  1193. static inline void mix_2f_1r_to_mono(AC3DecodeContext *ctx)

  1194. {

  1195.     int i;

  1196.     float (*output)[256] = ctx->audio_block.block_output;

  1197. 

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

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

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

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

  1202. 

  1203. }

  1204. 

  1205. static inline void mix_2f_1r_to_stereo(AC3DecodeContext *ctx)

  1206. {

  1207.     int i;

  1208.     float (*output)[256] = ctx->audio_block.block_output;

  1209. 

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

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

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

  1213.     }

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

  1215. }

  1216. 

  1217. static inline void mix_2f_1r_to_dolby(AC3DecodeContext *ctx)

  1218. {

  1219.     int i;

  1220.     float (*output)[256] = ctx->audio_block.block_output;

  1221. 

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

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

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

  1225.     }

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

  1227. }

  1228. 

  1229. static inline void mix_3f_1r_to_mono(AC3DecodeContext *ctx)

  1230. {

  1231.     int i;

  1232.     float (*output)[256] = ctx->audio_block.block_output;

  1233. 

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

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

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

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

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

  1239. }

  1240. 

  1241. static inline void mix_3f_1r_to_stereo(AC3DecodeContext *ctx)

  1242. {

  1243.     int i;

  1244.     float (*output)[256] = ctx->audio_block.block_output;

  1245. 

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

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

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

  1249.     }

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

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

  1252. }

  1253. 

  1254. static inline void mix_3f_1r_to_dolby(AC3DecodeContext *ctx)

  1255. {

  1256.     int i;

  1257.     float (*output)[256] = ctx->audio_block.block_output;

  1258. 

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

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

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

  1262.     }

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

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

  1265. }

  1266. 

  1267. static inline void mix_2f_2r_to_mono(AC3DecodeContext *ctx)

  1268. {

  1269.     int i;

  1270.     float (*output)[256] = ctx->audio_block.block_output;

  1271. 

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

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

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

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

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

  1277. }

  1278. 

  1279. static inline void mix_2f_2r_to_stereo(AC3DecodeContext *ctx)

  1280. {

  1281.     int i;

  1282.     float (*output)[256] = ctx->audio_block.block_output;

  1283. 

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

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

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

  1287.     }

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

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

  1290. }

  1291. 

  1292. static inline void mix_2f_2r_to_dolby(AC3DecodeContext *ctx)

  1293. {

  1294.     int i;

  1295.     float (*output)[256] = ctx->audio_block.block_output;

  1296. 

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

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

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

  1300.     }

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

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

  1303. }

  1304. 

  1305. static inline void mix_3f_2r_to_mono(AC3DecodeContext *ctx)

  1306. {

  1307.     int i;

  1308.     float (*output)[256] = ctx->audio_block.block_output;

  1309. 

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

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

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

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

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

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

  1316. }

  1317. 

  1318. static inline void mix_3f_2r_to_stereo(AC3DecodeContext *ctx)

  1319. {

  1320.     int i;

  1321.     float (*output)[256] = ctx->audio_block.block_output;

  1322. 

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

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

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

  1326.     }

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

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

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

  1330. }

  1331. 

  1332. static inline void mix_3f_2r_to_dolby(AC3DecodeContext *ctx)

  1333. {

  1334.     int i;

  1335.     float (*output)[256] = ctx->audio_block.block_output;

  1336. 

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

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

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

  1340.     }

  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 void do_downmix(AC3DecodeContext *ctx)

  1347. {

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

  1349.     int to = ctx->output;

  1350. 

  1351.     switch (from) {

  1352.         case AC3_INPUT_DUALMONO:

  1353.             switch (to) {

  1354.                 case AC3_OUTPUT_MONO:

  1355.                     mix_dualmono_to_mono(ctx);

  1356.                     break;

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

  1358.                     mix_dualmono_to_stereo(ctx);

  1359.                     break;

  1360.             }

  1361.             break;

  1362.         case AC3_INPUT_MONO:

  1363.             switch (to) {

  1364.                 case AC3_OUTPUT_STEREO:

  1365.                     upmix_mono_to_stereo(ctx);

  1366.                     break;

  1367.             }

  1368.             break;

  1369.         case AC3_INPUT_STEREO:

  1370.             switch (to) {

  1371.                 case AC3_OUTPUT_MONO:

  1372.                     mix_stereo_to_mono(ctx);

  1373.                     break;

  1374.             }

  1375.             break;

  1376.         case AC3_INPUT_3F:

  1377.             switch (to) {

  1378.                 case AC3_OUTPUT_MONO:

  1379.                     mix_3f_to_mono(ctx);

  1380.                     break;

  1381.                 case AC3_OUTPUT_STEREO:

  1382.                     mix_3f_to_stereo(ctx);

  1383.                     break;

  1384.             }

  1385.             break;

  1386.         case AC3_INPUT_2F_1R:

  1387.             switch (to) {

  1388.                 case AC3_OUTPUT_MONO:

  1389.                     mix_2f_1r_to_mono(ctx);

  1390.                     break;

  1391.                 case AC3_OUTPUT_STEREO:

  1392.                     mix_2f_1r_to_stereo(ctx);

  1393.                     break;

  1394.                 case AC3_OUTPUT_DOLBY:

  1395.                     mix_2f_1r_to_dolby(ctx);

  1396.                     break;

  1397.             }

  1398.             break;

  1399.         case AC3_INPUT_3F_1R:

  1400.             switch (to) {

  1401.                 case AC3_OUTPUT_MONO:

  1402.                     mix_3f_1r_to_mono(ctx);

  1403.                     break;

  1404.                 case AC3_OUTPUT_STEREO:

  1405.                     mix_3f_1r_to_stereo(ctx);

  1406.                     break;

  1407.                 case AC3_OUTPUT_DOLBY:

  1408.                     mix_3f_1r_to_dolby(ctx);

  1409.                     break;

  1410.             }

  1411.             break;

  1412.         case AC3_INPUT_2F_2R:

  1413.             switch (to) {

  1414.                 case AC3_OUTPUT_MONO:

  1415.                     mix_2f_2r_to_mono(ctx);

  1416.                     break;

  1417.                 case AC3_OUTPUT_STEREO:

  1418.                     mix_2f_2r_to_stereo(ctx);

  1419.                     break;

  1420.                 case AC3_OUTPUT_DOLBY:

  1421.                     mix_2f_2r_to_dolby(ctx);

  1422.                     break;

  1423.             }

  1424.             break;

  1425.         case AC3_INPUT_3F_2R:

  1426.             switch (to) {

  1427.                 case AC3_OUTPUT_MONO:

  1428.                     mix_3f_2r_to_mono(ctx);

  1429.                     break;

  1430.                 case AC3_OUTPUT_STEREO:

  1431.                     mix_3f_2r_to_stereo(ctx);

  1432.                     break;

  1433.                 case AC3_OUTPUT_DOLBY:

  1434.                     mix_3f_2r_to_dolby(ctx);

  1435.                     break;

  1436.             }

  1437.             break;

  1438.     }

  1439. }

  1440. 

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

  1442. {

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

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

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

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

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

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

  1449.     int bit_alloc_flags = 0;

  1450.     float drange;

  1451.     uint8_t *dexps;

  1452. 

  1453.     *flags = 0;

  1454.     ab->blksw = 0;

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

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

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

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

  1459.     ab->dithflag = 0;

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

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

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

  1463.         *flags |= AC3_AB_DYNRNGE;

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

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

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

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

  1468.     }

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

  1470.         if (get_bits1(gb)) {

  1471.             *flags |= AC3_AB_DYNRNG2E;

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

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

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

  1475.         }

  1476.     }

  1477.     get_downmix_coeffs(ctx);

  1478.     ab->chincpl = 0;

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

  1480.         *flags |= AC3_AB_CPLSTRE;

  1481.         ab->cplbndstrc = 0;

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

  1483.             *flags |= AC3_AB_CPLINU;

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

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

  1486.             if (acmod == 0x00 || acmod == 0x01)

  1487.                 return -1; /* coupling needs atleast two shared channels */

  1488.             if (acmod == 0x02)

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

  1490.                     *flags |= AC3_AB_PHSFLGINU;

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

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

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

  1494.                 return -1;

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

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

  1497.             ab->cplendmant = ((ab->cplendf + 3) * 12) + 37;

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

  1499.                 if (get_bits1(gb)) {

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

  1501.                     ab->ncplbnd--;

  1502.                 }

  1503.         }

  1504.     }

  1505.     if (*flags & AC3_AB_CPLINU) {

  1506.         ab->cplcoe = 0;

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

  1508.             if (ab->chincpl & (1 << i))

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

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

  1511.                     ab->mstrcplco[i] = get_bits(gb, 2);

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

  1513.                         ab->cplcoexp[i][bnd] = get_bits(gb, 4);

  1514.                         ab->cplcomant[i][bnd] = get_bits(gb, 4);

  1515.                     }

  1516.                 }

  1517.         ab->phsflg = 0;

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

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

  1520.                 if (get_bits1(gb))

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

  1522.         }

  1523.     }

  1524.     generate_coupling_coordinates(ctx);

  1525.     ab->rematflg = 0;

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

  1527.         if (get_bits1(gb)) {

  1528.             *flags |= AC3_AB_REMATSTR;

  1529.             if (!(*flags & AC3_AB_CPLINU) || ab->cplbegf > 2)

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

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

  1532.             if (ab->cplbegf > 0 && ab->cplbegf <= 2 && (*flags & AC3_AB_CPLINU))

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

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

  1535.             if (ab->cplbegf == 0 && (*flags & AC3_AB_CPLINU))

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

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

  1538.         }

  1539.     ab->cplexpstr = AC3_EXPSTR_REUSE;

  1540.     ab->lfeexpstr = AC3_EXPSTR_REUSE;

  1541.     if (*flags & AC3_AB_CPLINU) /* coupling exponent strategy */

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

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

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

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

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

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

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

  1549.             if ((ab->chincpl & (1 << i)))

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

  1551.             else {

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

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

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

  1555.                     return -1;

  1556.                 }

  1557.                 ab->endmant[i] = ((ab->chbwcod[i] + 12) * 3) + 37;

  1558.             }

  1559.         }

  1560.     if (*flags & AC3_AB_CPLINU)

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

  1562.             bit_alloc_flags |= 64;

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

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

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

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

  1567.                     return -1;

  1568.             }

  1569.         }

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

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

  1572.             bit_alloc_flags |= 1 << i;

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

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

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

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

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

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

  1579.                 return -1;

  1580.             }

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

  1582.         }

  1583.     if (ctx->bsi.flags & AC3_BSI_LFEON) /* lfe exponents */

  1584.         if (ab->lfeexpstr != AC3_EXPSTR_REUSE) {

  1585.             bit_alloc_flags |= 32;

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

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

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

  1589.                 return -1;

  1590.             }

  1591.         }

  1592. 

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

  1594.         *flags |= AC3_AB_BAIE;

  1595.         bit_alloc_flags |= 127;

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

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

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

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

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

  1601.     }

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

  1603.         *flags |= AC3_AB_SNROFFSTE;

  1604.         bit_alloc_flags |= 127;

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

  1606.         if (*flags & AC3_AB_CPLINU) { /* couling fine snr offset and fast gain code */

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

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

  1609.         }

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

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

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

  1613.         }

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

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

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

  1617.         }

  1618.     }

  1619.     if (*flags & AC3_AB_CPLINU)

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

  1621.             bit_alloc_flags |= 64;

  1622.             *flags |= AC3_AB_CPLLEAKE;

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

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

  1625.         }

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

  1627.         *flags |= AC3_AB_DELTBAIE;

  1628.         bit_alloc_flags |= 127;

  1629.         if (*flags & AC3_AB_CPLINU) {

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

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

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

  1633.                 return -1;

  1634.             }

  1635.         }

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

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

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

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

  1640.                 return -1;

  1641.             }

  1642.         }

  1643.         if (*flags & AC3_AB_CPLINU)

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

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

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

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

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

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

  1650.                 }

  1651.             }

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

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

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

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

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

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

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

  1659.                 }

  1660.             }

  1661.     }

  1662. 

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

  1664. 

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

  1666.         *flags |= AC3_AB_SKIPLE;

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

  1668.         for (i = 0; i < ab->skipl; i++)

  1669.             skip_bits(gb, 8);

  1670.     }

  1671.     /* unpack the transform coefficients

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

  1673.      */

  1674.     if (get_transform_coeffs(ctx)) {

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

  1676.         return -1;

  1677.     }

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

  1679.     if (*flags & AC3_AB_REMATSTR)

  1680.         do_rematrixing(ctx);

  1681. 

  1682.     return 0;

  1683. }

  1684. 

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

  1686. {

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

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

  1689.     int frame_start;

  1690.     int i, j, k, l, value;

  1691.     float tmp_block_first_half[128], tmp_block_second_half[128];

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

  1693.     int nfchans;

  1694. 

  1695.     //Synchronize the frame.

  1696.     frame_start = ac3_synchronize(buf, buf_size);

  1697.     if (frame_start == -1) {

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

  1699.         *data_size = 0;

  1700.         return buf_size;

  1701.     }

  1702. 

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

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

  1705. 

  1706.     //Parse the syncinfo.

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

  1708.     if (!ac3_parse_sync_info(ctx)) {

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

  1710.         *data_size = 0;

  1711.         return -1;

  1712.     }

  1713. 

  1714.     //Check for the errors.

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

  1716.         *data_size = 0;

  1717.         return -1;

  1718.     } */

  1719. 

  1720.     //Parse the BSI.

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

  1722.     if (ac3_parse_bsi(ctx)) {

  1723.         av_log(avctx, AV_LOG_ERROR, "bsid is not valid\n");

  1724.         *data_size = 0;

  1725.         return -1;

  1726.     }

  1727. 

  1728.     for (i = 0; i < MAX_BLOCKS; i++)

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

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

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

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

  1733.         //avctx->channels = ctx->bsi.nfchans + ((ctx->bsi.flags & AC3_BSI_LFEON) ? 1 : 0);

  1734.         ctx->output = AC3_OUTPUT_UNMODIFIED;

  1735.     }

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

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

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

  1739.         //avctx->channels = ctx->bsi.nfchans + ((ctx->bsi.flags & AC3_BSI_LFEON) ? 1 : 0);

  1740.         ctx->output = AC3_OUTPUT_UNMODIFIED;

  1741.     }

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

  1743.         ctx->output = AC3_OUTPUT_MONO;

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

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

  1746.             ctx->output = AC3_OUTPUT_DOLBY;

  1747.         else

  1748.             ctx->output = AC3_OUTPUT_STEREO;

  1749.     }

  1750. 

  1751. 

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

  1753. 

  1754.     //Parse the Audio Blocks.

  1755.     *data_size = 0;

  1756.     for (i = 0; i < 6; i++) {

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

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

  1759.             *data_size = 0;

  1760.             return -1;

  1761.         }

  1762. 

  1763.         av_log(NULL, AV_LOG_INFO, "doing imdct\n");

  1764. 

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

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

  1767.             for (l = 0; l < 256; l++)

  1768.                 ab->block_output[0][l] = ctx->tmp_output[l] * window[l] + ctx->delay[0][l] * window[255 -l];

  1769.             memcpy(ctx->delay[0], ctx->tmp_output + 256, sizeof(ctx->delay[0]));

  1770.         }

  1771. 

  1772.         for (j = 0; j < ctx->bsi.nfchans; j++) {

  1773.             if (ctx->audio_block.blksw & (1 << j)) {

  1774.                 for (k = 0; k < 128; k++) {

  1775.                     tmp_block_first_half[k] = ab->transform_coeffs[j + 1][2 * k];

  1776.                     tmp_block_second_half[k] = ab->transform_coeffs[j + 1][2 * k + 1];

  1777.                 }

  1778.                 ff_imdct_calc(&ctx->imdct_ctx_256, ctx->tmp_output, tmp_block_first_half, ctx->tmp_imdct);

  1779.                 for (l = 0; l < 256; l++)

  1780.                     ab->block_output[j + 1][l] = ctx->tmp_output[l] * window[l] + ctx->delay[j + 1][l] * window[255 - l];

  1781.                 ff_imdct_calc(&ctx->imdct_ctx_256, ctx->delay[j + 1], tmp_block_second_half, ctx->tmp_imdct);

  1782.             } else {

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

  1784.                 for (l = 0; l < 256; l++)

  1785.                     ab->block_output[j + 1][l] = ctx->tmp_output[l] * window[l] + ctx->delay[j + 1][l] * window[255 - l];

  1786.                 memcpy(ctx->delay[j + 1], ctx->tmp_output + 256, sizeof(ctx->delay[j + 1]));

  1787.             }

  1788.         }

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

  1790.             for (l = 0; l < 256; l++) {

  1791.                 value = lrint(ab->block_output[0][l]);

  1792.                 if (value < -32768)

  1793.                     value = -32768;

  1794.                 else if (value > 32767)

  1795.                     value = 32767;

  1796.                 *(out_samples++) = value;

  1797.             }

  1798.             *data_size += 256 * sizeof(int16_t);

  1799.         }

  1800.         do_downmix(ctx);

  1801.         if (ctx->output == AC3_OUTPUT_UNMODIFIED)

  1802.             nfchans = ctx->bsi.nfchans;

  1803.         else

  1804.             nfchans = avctx->channels;

  1805.         for (k = 0; k < nfchans; k++)

  1806.             for (l = 0; l < 256; l++) {

  1807.                 value = lrint(ab->block_output[k + 1][l]);

  1808.                 if (value < -32768)

  1809.                     value = -32768;

  1810.                 else if (value > 32767)

  1811.                     value = 32767;

  1812.                 *(out_samples++) = value;

  1813.             }

  1814.         *data_size += nfchans * 256 * sizeof (int16_t);

  1815.     }

  1816. 

  1817.     return ctx->sync_info.framesize;

  1818. }

  1819. 

  1820. static int ac3_decode_end(AVCodecContext *ctx)

  1821. {

  1822.     return 0;

  1823. }

  1824. 

  1825. AVCodec lgpl_ac3_decoder = {

  1826.     "ac3",

  1827.     CODEC_TYPE_AUDIO,

  1828.     CODEC_ID_AC3,

  1829.     sizeof (AC3DecodeContext),

  1830.     ac3_decode_init,

  1831.     NULL,

  1832.     ac3_decode_end,

  1833.     ac3_decode_frame,

  1834. };