git.sesse.net Git - ffmpeg/blob - libavcodec/dolby_e.c

   1 /*
   2  * Copyright (C) 2017 foo86
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include "libavutil/float_dsp.h"
  22 #include "libavutil/thread.h"
  23 #include "libavutil/mem.h"
  24 #include "libavutil/mem_internal.h"
  25
  26 #include "internal.h"
  27 #include "get_bits.h"
  28 #include "dolby_e.h"
  29 #include "kbdwin.h"
  30 #include "fft.h"
  31
  32 #define MAX_SEGMENTS    2
  33
  34 #define MAX_GROUPS      8
  35 #define MAX_EXPONENTS   304
  36 #define MAX_MANTISSAS   1024
  37
  38 #define MAX_MSTR_EXP    2
  39 #define MAX_BIAS_EXP    50
  40
  41 typedef struct DBEGroup {
  42     uint8_t         nb_exponent;
  43     uint8_t         nb_bias_exp[MAX_MSTR_EXP];
  44     uint16_t        exp_ofs;
  45     uint16_t        mnt_ofs;
  46     const uint8_t   *nb_mantissa;
  47     uint8_t         imdct_idx;
  48     uint8_t         imdct_phs;
  49     uint16_t        win_len;
  50     uint16_t        dst_ofs;
  51     uint16_t        win_ofs;
  52     uint16_t        src_ofs;
  53 } DBEGroup;
  54
  55 typedef struct DBEChannel {
  56     int     gr_code;
  57     int     bw_code;
  58
  59     int         nb_groups;
  60     int         nb_mstr_exp;
  61     DBEGroup    groups[MAX_GROUPS];
  62
  63     int     exp_strategy[MAX_GROUPS];
  64     int     exponents[MAX_EXPONENTS];
  65     int     bap[MAX_EXPONENTS];
  66     int     idx[MAX_EXPONENTS];
  67
  68     DECLARE_ALIGNED(32, float, mantissas)[MAX_MANTISSAS];
  69 } DBEChannel;
  70
  71 typedef struct DBEDecodeContext {
  72     AVCodecContext  *avctx;
  73     DBEContext  dectx;
  74
  75     DBEChannel  channels[MAX_SEGMENTS][MAX_CHANNELS];
  76
  77     DECLARE_ALIGNED(32, float, history)[MAX_CHANNELS][256];
  78
  79     FFTContext          imdct[3];
  80     AVFloatDSPContext   *fdsp;
  81 } DBEDecodeContext;
  82
  83 static const int8_t lfe_channel_tab[MAX_PROG_CONF + 1] = {
  84      5,  5, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4,
  85     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  5, 5
  86 };
  87
  88 static const uint8_t ch_reorder_4[4] = { 0, 2, 1, 3 };
  89 static const uint8_t ch_reorder_6[6] = { 0, 2, 4, 1, 3, 5 };
  90 static const uint8_t ch_reorder_8[8] = { 0, 2, 6, 4, 1, 3, 7, 5 };
  91 static const uint8_t ch_reorder_n[8] = { 0, 2, 4, 6, 1, 3, 5, 7 };
  92
  93
  94 static const uint8_t nb_groups_tab[4] = { 1, 8, 7, 1 };
  95
  96 static const uint8_t nb_mstr_exp_tab[4] = { 2, 2, 2, 1 };
  97
  98 static const uint8_t nb_mantissa_38[38] = {
  99      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
 100      2,  2,  2,  2,  2,  2,  3,  3,  3,  4,  4,  4,  5,  5,  6,  6,
 101      7,  8,  9, 10, 11, 12,
 102 };
 103
 104 static const uint8_t nb_mantissa_44[44] = {
 105      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  2,
 106      2,  2,  2,  2,  2,  3,  3,  3,  3,  4,  4,  5,  5,  6,  7,  7,
 107      8,  9, 10, 11, 12, 13, 15, 16, 18, 20, 22, 25,
 108 };
 109
 110 static const uint8_t nb_mantissa_50[50] = {
 111      1,  1,  1,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  3,  3,  3,
 112      3,  4,  4,  5,  5,  6,  6,  7,  8,  9,  9, 10, 12, 13, 14, 16,
 113     18, 19, 22, 24, 27, 29, 32, 36, 40, 44, 49, 54, 60, 66, 74, 82,
 114     90, 100,
 115 };
 116
 117 static const uint8_t imdct_bits_tab[3] = { 8, 9, 11 };
 118
 119 static const DBEGroup grp_tab_0[1] = {
 120     { 50, { 27, 23 }, 0, 0, nb_mantissa_50, 2, 0, 1152, 0, 1408, 0 },
 121 };
 122
 123 static const DBEGroup grp_tab_1[8] = {
 124     { 38, { 12, 26 }, 0, 0, nb_mantissa_38, 0, 0, 192, 0, 256, 0 },
 125     { 38, { 12, 26 }, 38, 128, nb_mantissa_38, 0, 1, 256, 64, 448, 0 },
 126     { 38, { 12, 26 }, 76, 256, nb_mantissa_38, 0, 1, 256, 192, 704, 0 },
 127     { 38, { 12, 26 }, 114, 384, nb_mantissa_38, 0, 1, 256, 320, 0, 0 },
 128     { 38, { 12, 26 }, 152, 512, nb_mantissa_38, 0, 1, 256, 448, 0, 0 },
 129     { 38, { 12, 26 }, 190, 640, nb_mantissa_38, 0, 1, 256, 576, 0, 0 },
 130     { 38, { 12, 26 }, 228, 768, nb_mantissa_38, 0, 1, 256, 704, 0, 0 },
 131     { 38, { 12, 26 }, 266, 896, nb_mantissa_38, 0, 1, 256, 832, 0, 0 },
 132 };
 133
 134 static const DBEGroup grp_tab_2[7] = {
 135     { 38, { 12, 26 }, 0, 0, nb_mantissa_38, 0, 0, 192, 0, 256, 0 },
 136     { 38, { 12, 26 }, 38, 128, nb_mantissa_38, 0, 1, 256, 64, 448, 0 },
 137     { 38, { 12, 26 }, 76, 256, nb_mantissa_38, 0, 1, 256, 192, 704, 0 },
 138     { 38, { 12, 26 }, 114, 384, nb_mantissa_38, 0, 1, 256, 320, 0, 0 },
 139     { 38, { 12, 26 }, 152, 512, nb_mantissa_38, 0, 1, 256, 448, 0, 0 },
 140     { 38, { 12, 26 }, 190, 640, nb_mantissa_38, 0, 1, 256, 576, 0, 0 },
 141     { 44, { 19, 25 }, 228, 768, nb_mantissa_44, 1, 1, 448, 704, 960, 64 },
 142 };
 143
 144 static const DBEGroup grp_tab_3[1] = {
 145     { 21, { 21 }, 0, 0, nb_mantissa_50, 2, 0, 1152, 0, 1408, 0 },
 146 };
 147
 148 static const DBEGroup grp_tab_4[1] = {
 149     { 50, { 27, 23 }, 0, 0, nb_mantissa_50, 2, 2, 1152, 0, 1408, 896 },
 150 };
 151
 152 static const DBEGroup grp_tab_5[8] = {
 153     { 38, { 12, 26 }, 0, 0, nb_mantissa_38, 0, 1, 256, 64, 0, 0 },
 154     { 38, { 12, 26 }, 38, 128, nb_mantissa_38, 0, 1, 256, 192, 0, 0 },
 155     { 38, { 12, 26 }, 76, 256, nb_mantissa_38, 0, 1, 256, 320, 0, 0 },
 156     { 38, { 12, 26 }, 114, 384, nb_mantissa_38, 0, 1, 256, 448, 0, 0 },
 157     { 38, { 12, 26 }, 152, 512, nb_mantissa_38, 0, 1, 256, 576, 0, 0 },
 158     { 38, { 12, 26 }, 190, 640, nb_mantissa_38, 0, 1, 256, 704, 3008, 0 },
 159     { 38, { 12, 26 }, 228, 768, nb_mantissa_38, 0, 1, 256, 832, 2752, 0 },
 160     { 38, { 12, 26 }, 266, 896, nb_mantissa_38, 0, 2, 192, 960, 2560, 64 },
 161 };
 162
 163 static const DBEGroup grp_tab_6[7] = {
 164     { 44, { 19, 25 }, 0, 0, nb_mantissa_44, 1, 1, 448, 0, 3264, 0 },
 165     { 38, { 12, 26 }, 44, 256, nb_mantissa_38, 0, 1, 256, 320, 0, 0 },
 166     { 38, { 12, 26 }, 82, 384, nb_mantissa_38, 0, 1, 256, 448, 0, 0 },
 167     { 38, { 12, 26 }, 120, 512, nb_mantissa_38, 0, 1, 256, 576, 0, 0 },
 168     { 38, { 12, 26 }, 158, 640, nb_mantissa_38, 0, 1, 256, 704, 3008, 0 },
 169     { 38, { 12, 26 }, 196, 768, nb_mantissa_38, 0, 1, 256, 832, 2752, 0 },
 170     { 38, { 12, 26 }, 234, 896, nb_mantissa_38, 0, 2, 192, 960, 2560, 64 },
 171 };
 172
 173 static const DBEGroup grp_tab_7[1] = {
 174     { 21, { 21 }, 0, 0, nb_mantissa_50, 2, 2, 1152, 0, 1408, 896 },
 175 };
 176
 177 static const DBEGroup *const frm_ofs_tab[2][4] = {
 178     { grp_tab_0, grp_tab_1, grp_tab_2, grp_tab_3 },
 179     { grp_tab_4, grp_tab_5, grp_tab_6, grp_tab_7 }
 180 };
 181
 182 static const uint8_t mantissa_size1[16][4] = {
 183     {  0,  0,  0,  0 }, {  2,  1,  1,  1 }, {  3,  2,  1,  1 }, {  4,  3,  2,  1 },
 184     {  5,  4,  3,  2 }, {  6,  5,  4,  3 }, {  7,  6,  5,  4 }, {  8,  7,  6,  5 },
 185     {  9,  8,  7,  6 }, { 10,  9,  8,  7 }, { 11, 10,  9,  8 }, { 12, 11, 10,  9 },
 186     { 13, 12, 11, 10 }, { 14, 13, 12, 11 }, { 15, 14, 13, 12 }, { 16, 15, 14, 13 },
 187 };
 188
 189 static const uint8_t mantissa_size2[16][4] = {
 190     {  0,  0,  0,  0 }, {  2,  1,  2,  2 }, {  3,  2,  3,  3 }, {  4,  3,  4,  4 },
 191     {  5,  4,  5,  5 }, {  6,  5,  6,  6 }, {  7,  6,  7,  7 }, {  8,  7,  8,  8 },
 192     {  9,  8,  9,  9 }, { 10,  9, 10, 10 }, { 11, 10, 11, 11 }, { 12, 11, 12, 12 },
 193     { 13, 12, 13, 13 }, { 14, 13, 14, 14 }, { 15, 14, 15, 15 }, { 16, 15, 16, 16 },
 194 };
 195
 196 static const float start_window[192] = {
 197     0.00161569379826, 0.00185748233347, 0.00198562758548, 0.00207834078104,
 198     0.00215717748523, 0.00223067096393, 0.00230299213147, 0.00237651215396,
 199     0.00245275561606, 0.00253281402069, 0.00261754673613, 0.00270768786168,
 200     0.00280390761895, 0.00290684998656, 0.00301715751161, 0.00313548872798,
 201     0.00326253122934, 0.00339901215995, 0.00354570716636, 0.00370344845023,
 202     0.00387313232586, 0.00405572653911, 0.00425227750970, 0.00446391759265,
 203     0.00469187240551, 0.00493746822816, 0.00520213944619, 0.00548743597507,
 204     0.00579503056737, 0.00612672586953, 0.00648446105606, 0.00687031782873,
 205     0.00728652552677, 0.00773546505205, 0.00821967127415, 0.00874183354619,
 206     0.00930479393832, 0.00991154278653, 0.01056521116692, 0.01126905994567,
 207     0.01202646513050, 0.01284089936559, 0.01371590957417, 0.01465509096066,
 208     0.01566205783408, 0.01674041199523, 0.01789370972358, 0.01912542867865,
 209     0.02043893626265, 0.02183746113793, 0.02332406961796, 0.02490164852364,
 210     0.02657289580178, 0.02834031974193, 0.03020624702903, 0.03217283918354,
 211     0.03424211623810, 0.03641598586180, 0.03869627565015, 0.04108476601498,
 212     0.04358322107390, 0.04619341515939, 0.04891715301882, 0.05175628239149,
 213
 214     0.05471237327267, 0.05778734733755, 0.06098291402413, 0.06430101352084,
 215     0.06774345212186, 0.07131188644726, 0.07500780649199, 0.07883251748595,
 216     0.08278712056651, 0.08687249228061, 0.09108926295730, 0.09543779401074,
 217     0.09991815425851, 0.10453009536427, 0.10927302653894, 0.11414598865987,
 218     0.11914762799220, 0.12427616972097, 0.12952939152560, 0.13490459744934,
 219     0.14039859233595, 0.14600765712201, 0.15172752528722, 0.15755336077528,
 220     0.16347973770491, 0.16950062219342, 0.17560935661442, 0.18179864660619,
 221     0.18806055113821, 0.19438647593012, 0.20076717050010, 0.20719272909882,
 222     0.21365259576030, 0.22013557367283, 0.22662983904194, 0.23312295958328,
 223     0.23960191774666, 0.24605313873388, 0.25246252333253, 0.25881548554631,
 224     0.26509699495987, 0.27129162373316, 0.27738359807707, 0.28335685401987,
 225     0.28919509723179, 0.29488186663467, 0.30040060148455, 0.30573471157819,
 226     0.31086765019993, 0.31578298939317, 0.32046449711227, 0.32489621578468,
 227     0.32906254179156, 0.33294830535654, 0.33653885031840, 0.33982011325336,
 228     0.34277870140679, 0.34540196889300, 0.34767809062480, 0.34959613344194,
 229     0.35114612391958, 0.35231911235422, 0.35310723244504, 0.35350375621308,
 230
 231     0.35350314372945, 0.35310108725579, 0.35229454943591, 0.35108179521634,
 232     0.34946241721522, 0.34743735430290, 0.34500890320420, 0.34218072298001,
 233     0.33895783229541, 0.33534659943168, 0.33135472505060, 0.32699121776996,
 234     0.32226636266000, 0.31719168282019, 0.31177989424432, 0.30604485422875,
 235     0.30000150362379, 0.29366580327088, 0.28705466500775, 0.28018587766131,
 236     0.27307802848095, 0.26575042049535, 0.25822298630189, 0.25051619882000,
 237     0.24265097955783, 0.23464860495522, 0.22653061137548, 0.21831869932335,
 238     0.21003463746705, 0.20170016703857, 0.19333690717811, 0.18496626177620,
 239     0.17660932835062, 0.16828680947474, 0.16001892724986, 0.15182534128597,
 240     0.14372507062477, 0.13573642000364, 0.12787691082233, 0.12016321713317,
 241     0.11261110693234, 0.10523538898282, 0.09804986534955, 0.09106728977263,
 242     0.08429933194438, 0.07775654768810, 0.07144835495683, 0.06538301547324,
 243     0.05956762170687, 0.05400808871425, 0.04870915012107, 0.04367435714993,
 244     0.03890607899172, 0.03440550179663, 0.03017262174627, 0.02620622428513,
 245     0.02250383492507, 0.01906161305732, 0.01587412848221, 0.01293388032354,
 246     0.01023019677288, 0.00774641320626, 0.00545109736891, 0.00325868651263,
 247 };
 248
 249 static const float short_window2[192] = {
 250     0.00018861094606, 0.00033433010202, 0.00050309624485, 0.00070306161748,
 251     0.00093995174533, 0.00121913067128, 0.00154606505568, 0.00192647806126,
 252     0.00236641248692, 0.00287225985240, 0.00345077377440, 0.00410907465023,
 253     0.00485464855241, 0.00569534163219, 0.00663935063508, 0.00769520981249,
 254     0.00887177436246, 0.01017820046395, 0.01162392194150, 0.01321862359335,
 255     0.01497221122468, 0.01689477844427, 0.01899657030441, 0.02128794388846,
 256     0.02377932597692, 0.02648116795039, 0.02940389811590, 0.03255787167130,
 257     0.03595331854986, 0.03960028941437, 0.04350860009563, 0.04768777479454,
 258     0.05214698838949, 0.05689500821121, 0.06194013566525, 0.06729014809766,
 259     0.07295224131210, 0.07893297315602, 0.08523820859989, 0.09187306673620,
 260     0.09884187012422, 0.10614809690222, 0.11379433608064, 0.12178224641797,
 261     0.13011251926531, 0.13878484574660, 0.14779788861830, 0.15714925912610,
 262     0.16683549914631, 0.17685206886673, 0.18719334022589, 0.19785259629099,
 263     0.20882203671372, 0.22009278936030, 0.23165492816694, 0.24349749722585,
 264     0.25560854105961, 0.26797514099368, 0.28058345748882, 0.29341877824732,
 265     0.30646557185942, 0.31970754671026, 0.33312771482295, 0.34670846027024,
 266
 267     0.36043161174692, 0.37427851885723, 0.38823013163645, 0.40226708279486,
 268     0.41636977214436, 0.43051845264462, 0.44469331748632, 0.45887458761470,
 269     0.47304259908636, 0.48717788964798, 0.50126128392546, 0.51527397661778,
 270     0.52919761310050, 0.54301436685998, 0.55670701320069, 0.57025899869448,
 271     0.58365450587230, 0.59687851269542, 0.60991684638414, 0.62275623122793,
 272     0.63538433005035, 0.64778977905593, 0.65996221584264, 0.67189230042379,
 273     0.68357172916486, 0.69499324160511, 0.70615062019861, 0.71703868307548,
 274     0.72765326998919, 0.73799122168099, 0.74805035295521, 0.75782941981995,
 275     0.76732808110520, 0.77654685502339, 0.78548707118622, 0.79415081863423,
 276     0.80254089047207, 0.81066072573188, 0.81851434910893, 0.82610630922734,
 277     0.83344161609862, 0.84052567843230, 0.84736424144524, 0.85396332579459,
 278     0.86032916822973, 0.86646816451999, 0.87238681516918, 0.87809167437532,
 279     0.88358930263537, 0.88888622333073, 0.89398888356256, 0.89890361943564,
 280     0.90363662591861, 0.90819393133744, 0.91258137648979, 0.91680459830070,
 281     0.92086901787718, 0.92477983276087, 0.92854201312583, 0.93216030163834,
 282     0.93563921662343, 0.93898305819384, 0.94219591693690, 0.94528168477979,
 283
 284     0.94823843319821, 0.95106834367330, 0.95377776558539, 0.95636718335775,
 285     0.95883679961479, 0.96118650212341, 0.96341583179195, 0.96552395212906,
 286     0.96750962060547, 0.96937116231768, 0.97110644638309, 0.97271286544154,
 287     0.97418731862798, 0.97552619834964, 0.97672538116257, 0.97778022299974,
 288     0.97868555895586, 0.97943570778357, 0.98002448120255, 0.98044519806866,
 289     0.98069070339493, 0.98075339216123, 0.98062523779637, 0.98029782516478,
 290     0.97976238784222, 0.97900984942031, 0.97803086854002, 0.97681588731895,
 291     0.97535518280755, 0.97363892108474, 0.97165721358452, 0.96940017523145,
 292     0.96685798395452, 0.96402094114589, 0.96087953263194, 0.95742448973047,
 293     0.95364684997699, 0.94953801711660, 0.94508981997396, 0.94029456983253,
 294     0.93514511597504, 0.92963489905951, 0.92375800202883, 0.91750919827624,
 295     0.91088399681406, 0.90387868421832, 0.89649036314692, 0.88871698725397,
 296     0.88055739234735, 0.87201132366062, 0.86307945913336, 0.85376342861693,
 297     0.84406582894455, 0.83399023482637, 0.82354120554757, 0.81272428745995,
 298     0.80154601230457, 0.79001389138101, 0.77813640562199, 0.76592299164227,
 299     0.75338402384395, 0.74053079267526, 0.72737547915460, 0.71393112578527,
 300 };
 301
 302 static const float short_window3[64] = {
 303     0.00326887936450, 0.00550242900936, 0.00786846643791, 0.01045683453520,
 304     0.01330402120132, 0.01643221072863, 0.01985798040609, 0.02359509464766,
 305     0.02765559221954, 0.03205025893128, 0.03678884369614, 0.04188015679495,
 306     0.04733210987781, 0.05315172583924, 0.05934513287609, 0.06591755045290,
 307     0.07287327156378, 0.08021564389822, 0.08794705152307, 0.09606889811179,
 308     0.10458159240070, 0.11348453632940, 0.12277611617809, 0.13245369691511,
 309     0.14251361989876, 0.15295120402567, 0.16376075037904, 0.17493555039885,
 310     0.18646789757072, 0.19834910260891, 0.21056951208995, 0.22311853047787,
 311     0.23598464546683, 0.24915545655419, 0.26261770674500, 0.27635731727778,
 312     0.29035942525136, 0.30460842402318, 0.31908800624032, 0.33378120935681,
 313     0.34867046348260, 0.36373764140285, 0.37896411059909, 0.39433078709788,
 314     0.40981819096657, 0.42540650327031, 0.44107562429959, 0.45680523287270,
 315     0.47257484651351, 0.48836388230077, 0.50415171818214, 0.51991775454258,
 316     0.53564147581496, 0.55130251191887, 0.56688069931047, 0.58235614142007,
 317     0.59770926827271, 0.61292089506118, 0.62797227945823, 0.64284517745255,
 318     0.65752189749349, 0.67198535273209, 0.68621911114984, 0.70020744337099,
 319 };
 320
 321 static const uint8_t dc_code_tab[5] = { 0, 0, 0, 1, 1 };
 322
 323 static const uint8_t ht_code_tab[5] = { 0, 0, 1, 2, 2 };
 324
 325 static const uint8_t band_ofs_tab[3][4] = {
 326     { 12, 8, 4, 0 }, { 14, 10, 6, 0 }, { 12, 8, 4, 0 }
 327 };
 328
 329 static const uint8_t band_low_tab[3] = { 9, 17, 24 };
 330
 331 static const uint16_t fast_gain_tab[8] = {
 332     128, 256, 384, 512, 640, 768, 896, 1024
 333 };
 334
 335 static const uint16_t slow_decay_tab[2][2] = { { 27, -1 }, { 32, 21 } };
 336
 337 static const uint16_t misc_decay_tab[3][2][2] = {
 338     { { 354, -1 }, { 425, 425 } },
 339     { { 266, -1 }, { 320,  -1 } },
 340     { { 213, -1 }, { 256,  -1 } }
 341 };
 342
 343 static const uint16_t fast_decay_tab[3][2][2][50] = {
 344     {{{
 345         142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
 346         142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
 347         142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
 348         142, 142, 142, 142, 142, 142, 142, 142,
 349     }, {
 350          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 351          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 352          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 353          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 354     }}, {{
 355         170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
 356         170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
 357         170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
 358         170, 170, 170, 170, 170, 170, 170, 170,
 359     }, {
 360          64,  64,  64,  64,  64,  64,  64,  64,  64,  64,
 361          64,  64,  64,  64,  64,  64,  64,  64,  64,  64,
 362          64,  64,  64,  64,  64,  64,  64,  64,  64,  64,
 363          64,  64,  64,  64,  64,  64,  64,  64,
 364     }}}, {{{
 365         266, 266, 106, 106, 106, 106, 106, 106, 106, 106,
 366         106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
 367         106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
 368         106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
 369         106, 106, 106, 106,
 370     }, {
 371          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 372          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 373          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 374          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 375          -1,  -1,  -1,  -1,
 376     }}, {{
 377         319, 319, 128, 128, 128, 128, 128, 128, 128, 128,
 378         128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
 379         128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
 380         128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
 381         128, 128, 128, 128,
 382     }, {
 383          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 384          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 385          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 386          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 387          -1,  -1,  -1,  -1,
 388     }}}, {{{
 389         106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
 390         106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
 391         106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
 392         106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
 393         106, 106, 106, 106, 106, 106, 106, 106, 106, 106,
 394     }, {
 395          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 396          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 397          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 398          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 399          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 400     }}, {{
 401         128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
 402         128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
 403         128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
 404         128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
 405         128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
 406     }, {
 407          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 408          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 409          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 410          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 411          -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
 412     }}}
 413 };
 414
 415 static const uint16_t fast_gain_adj_tab[3][2][62] = {
 416     {{
 417           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 418           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 419           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 420           0,   1,   2,   4,   7,  11,  16,  29,  44,  59,
 421          76,  94, 116, 142, 179, 221, 252, 285, 312, 334,
 422     }, {
 423           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 424           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 425           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 426           2,   5,   8,  10,  15,  28,  42,  57,  75,  93,
 427         115, 140, 177, 219, 247, 280, 308, 330, 427, 533,
 428     }}, {{
 429           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 430           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 431           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 432           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 433           0,   2,   5,   8,  12,  21,  35,  51,  69,  89,
 434         111, 138, 176, 220, 251, 284, 312, 334,
 435     }, {
 436           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 437           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 438           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 439           0,   0,   0,   0,   0,   0,   0,   0,   0,   2,
 440           5,   8,  11,  18,  33,  49,  65,  84, 106, 132,
 441         168, 214, 245, 279, 308, 329, 427, 533,
 442     }}, {{
 443           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 444           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 445           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 446           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 447           0,   0,   0,   0,   0,   1,   4,   7,  10,  17,
 448          31,  47,  65,  84, 107, 134, 171, 215, 250, 283,
 449         312, 334,
 450     }, {
 451           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 452           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 453           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 454           0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 455           0,   0,   0,   0,   3,   6,   9,  13,  27,  43,
 456          60,  79, 100, 126, 160, 207, 242, 276, 307, 329,
 457         427, 533,
 458     }}
 459 };
 460
 461 static const uint16_t slow_gain_tab[3][2][50] = {
 462     {{
 463         3072, 3072, 3072, 3072, 3072, 3072, 1063, 1063, 1063, 1063,
 464         1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063,
 465         1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063,
 466         1063, 1063, 1063, 1063, 1063, 1063, 1063, 1063,
 467     }, {
 468         3072, 3072, 3072, 3072, 3072, 3072,  850,  850,  850,  850,
 469          850,  850,  850,  850,  850,  850,  850,  850,  850,  850,
 470          850,  850,  850,  850,  850,  850,  850,  850,  850,  850,
 471          850,  850,  850,  850,  850,  850,  850,  850,
 472     }}, {{
 473         3072, 1212, 1212, 1212,  999,  999,  999,  999,  999,  999,
 474          999,  999,  999,  999,  999,  999,  999,  999,  999,  999,
 475          999,  999,  999,  999,  999,  999,  999,  999,  999,  999,
 476          999,  999,  999,  999,  999,  999,  999,  999,  999,  999,
 477          999,  999,  999,  999,
 478     }, {
 479           -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 480           -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 481           -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 482           -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 483           -1,   -1,   -1,   -1,
 484     }}, {{
 485         3072, 3072, 3072, 3072, 3072, 3072, 3072, 3072, 3072, 3072,
 486          999,  999,  999,  999,  999,  999,  999,  999,  999,  999,
 487          999,  999,  999,  999,  999,  999,  999,  999,  999,  999,
 488          999,  999,  999,  999,  999,  999,  999,  999,  999,  999,
 489          999,  999,  999,  999,  999,  999,  999,  999,  999,  999,
 490     }, {
 491           -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 492           -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 493           -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 494           -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 495           -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 496     }}
 497 };
 498
 499 static const uint16_t hearing_thresh_tab[3][3][50] = {
 500     {{
 501         1403, 1141, 1000,  959,  948,  957,  946,  925,  899,  871,
 502          843,  815,  789,  766,  745,  727,  705,  687,  681,  686,
 503          701,  725,  768,  854,  940, 1018, 1075, 1103, 1111, 1106,
 504         1098, 1105, 1142, 1237, 1419, 1721, 2169, 2805,
 505     }, {
 506         1401, 1130,  995,  957,  947,  955,  941,  918,  890,  861,
 507          831,  803,  777,  754,  734,  717,  698,  684,  682,  692,
 508          712,  743,  798,  894,  976, 1045, 1091, 1109, 1110, 1102,
 509         1098, 1116, 1174, 1300, 1526, 1884, 2401, 3072,
 510     }, {
 511         1393, 1086,  974,  949,  957,  941,  913,  878,  843,  808,
 512          777,  750,  727,  708,  695,  686,  681,  689,  714,  752,
 513          811,  888,  971, 1044, 1087, 1108, 1110, 1102, 1098, 1115,
 514         1172, 1290, 1489, 1812, 2293, 2964, 3072, 3072,
 515     }}, {{
 516         1412, 1343, 1141, 1047, 1000,  974,  959,  951,  948,  947,
 517          957,  953,  946,  936,  925,  906,  878,  850,  822,  795,
 518          771,  745,  719,  700,  687,  681,  685,  701,  733,  784,
 519          885,  977, 1047, 1092, 1110, 1108, 1099, 1102, 1138, 1233,
 520         1413, 1711, 2157, 2797,
 521     }, {
 522         1412, 1336, 1130, 1040,  995,  970,  957,  950,  947,  947,
 523          955,  950,  941,  930,  918,  897,  868,  838,  810,  783,
 524          759,  734,  710,  693,  684,  681,  690,  712,  752,  823,
 525          924, 1009, 1069, 1102, 1111, 1104, 1098, 1111, 1168, 1295,
 526         1518, 1873, 2388, 3072,
 527     }, {
 528         1411, 1293, 1086, 1009,  974,  957,  949,  947,  957,  951,
 529          941,  928,  913,  896,  878,  852,  817,  785,  756,  732,
 530          713,  695,  683,  682,  689,  710,  746,  811,  906,  992,
 531         1061, 1099, 1111, 1106, 1098, 1107, 1155, 1266, 1471, 1799,
 532         2277, 2945, 3072, 3072,
 533     }}, {{
 534         1431, 1412, 1403, 1379, 1343, 1293, 1229, 1180, 1125, 1075,
 535         1040, 1014,  996,  979,  965,  957,  951,  948,  947,  957,
 536          951,  940,  924,  903,  877,  846,  815,  785,  753,  725,
 537          702,  686,  681,  689,  714,  760,  847,  947, 1028, 1083,
 538         1108, 1109, 1101, 1100, 1132, 1222, 1402, 1705, 2160, 2803,
 539     }, {
 540         1431, 1412, 1401, 1375, 1336, 1278, 1215, 1168, 1115, 1066,
 541         1032, 1008,  991,  975,  962,  954,  950,  947,  947,  955,
 542          948,  935,  916,  894,  866,  835,  803,  772,  742,  715,
 543          695,  683,  683,  697,  729,  784,  887,  982, 1054, 1096,
 544         1111, 1106, 1098, 1107, 1159, 1281, 1505, 1865, 2391, 3072,
 545     }, {
 546         1427, 1411, 1393, 1353, 1293, 1215, 1160, 1118, 1072, 1031,
 547         1003,  984,  971,  960,  952,  948,  947,  957,  952,  941,
 548          924,  902,  876,  847,  815,  781,  750,  723,  700,  685,
 549          681,  691,  719,  766,  858,  958, 1039, 1089, 1109, 1108,
 550         1099, 1102, 1141, 1245, 1442, 1766, 2250, 2930, 3072, 3072,
 551     }}
 552 };
 553
 554 static const int16_t lwc_gain_tab[11][7] = {
 555     {   -21,  -197,  -271,  -466, 32767, 32767, 32767 },
 556     {  -197,   -29,  -244,  -271,  -540, 32767, 32767 },
 557     {  -271,  -244,   -29,  -249,  -271,  -593, 32767 },
 558     {  -466,  -271,  -249,   -29,  -251,  -271,  -632 },
 559     {  -540,  -271,  -251,   -29,  -251,  -271,  -664 },
 560     {  -593,  -271,  -251,   -29,  -252,  -271,  -690 },
 561     {  -632,  -271,  -252,   -29,  -252,  -271,  -711 },
 562     {  -664,  -271,  -252,   -29,  -252,  -271,  -730 },
 563     {  -690,  -271,  -252,   -29,  -252,  -271,  -745 },
 564     {  -711,  -271,  -252,   -29,  -253,  -271,  -759 },
 565     {  -730,  -271,  -253,   -29,  -253,  -271,  -771 },
 566 };
 567
 568 static const int16_t lwc_adj_tab[7] = {
 569     -192, -320, -448, -512, -448, -320, -192,
 570 };
 571
 572 static const uint8_t log_add_tab[212] = {
 573     64, 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 52, 51, 50,
 574     49, 48, 47, 47, 46, 45, 44, 44, 43, 42, 41, 41, 40, 39, 38, 38,
 575     37, 36, 36, 35, 35, 34, 33, 33, 32, 32, 31, 30, 30, 29, 29, 28,
 576     28, 27, 27, 26, 26, 25, 25, 24, 24, 23, 23, 22, 22, 21, 21, 21,
 577     20, 20, 19, 19, 19, 18, 18, 18, 17, 17, 17, 16, 16, 16, 15, 15,
 578     15, 14, 14, 14, 13, 13, 13, 13, 12, 12, 12, 12, 11, 11, 11, 11,
 579     10, 10, 10, 10, 10,  9,  9,  9,  9,  9,  8,  8,  8,  8,  8,  8,
 580      7,  7,  7,  7,  7,  7,  6,  6,  6,  6,  6,  6,  6,  6,  5,  5,
 581      5,  5,  5,  5,  5,  5,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
 582      4,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  2,
 583      2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
 584      2,  2,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
 585      1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
 586      1,  1,  0,  0,
 587 };
 588
 589 static const uint8_t bap_tab[64] = {
 590      0,  1,  1,  1,  1,  1,  2,  2,  2,  2,  2,  3,  3,  3,  3,  4,
 591      4,  4,  4,  5,  5,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,
 592      8,  8,  8,  9,  9,  9,  9, 10, 10, 10, 10, 11, 11, 11, 11, 12,
 593     12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 15,
 594 };
 595
 596 static float mantissa_tab1[17][4];
 597 static float mantissa_tab2[17][4];
 598 static float mantissa_tab3[17][4];
 599 static float exponent_tab[50];
 600 static float gain_tab[1024];
 601
 602 DECLARE_ALIGNED(32, static float, window)[3712];
 603
 604 static int skip_input(DBEContext *s, int nb_words)
 605 {
 606     if (nb_words > s->input_size) {
 607         av_log(s->avctx, AV_LOG_ERROR, "Packet too short\n");
 608         return AVERROR_INVALIDDATA;
 609     }
 610
 611     s->input      += nb_words * s->word_bytes;
 612     s->input_size -= nb_words;
 613     return 0;
 614 }
 615
 616 static int parse_key(DBEContext *s)
 617 {
 618     if (s->key_present) {
 619         const uint8_t *key = s->input;
 620         int      ret = skip_input(s, 1);
 621         if (ret < 0)
 622             return ret;
 623         return AV_RB24(key) >> 24 - s->word_bits;
 624     }
 625     return 0;
 626 }
 627
 628 static int parse_metadata_ext(DBEDecodeContext *s1)
 629 {
 630     DBEContext *s = &s1->dectx;
 631     if (s->metadata.mtd_ext_size)
 632         return skip_input(s, s->key_present + s->metadata.mtd_ext_size + 1);
 633     return 0;
 634 }
 635
 636 static void unbias_exponents(DBEContext *s, DBEChannel *c, DBEGroup *g)
 637 {
 638     int mstr_exp[MAX_MSTR_EXP];
 639     int bias_exp[MAX_BIAS_EXP];
 640     int i, j, k;
 641
 642     for (i = 0; i < c->nb_mstr_exp; i++)
 643         mstr_exp[i] = get_bits(&s->gb, 2) * 6;
 644
 645     for (i = 0; i < g->nb_exponent; i++)
 646         bias_exp[i] = get_bits(&s->gb, 5);
 647
 648     for (i = k = 0; i < c->nb_mstr_exp; i++)
 649         for (j = 0; j < g->nb_bias_exp[i]; j++, k++)
 650             c->exponents[g->exp_ofs + k] = mstr_exp[i] + bias_exp[k];
 651 }
 652
 653 static int parse_exponents(DBEContext *s, DBEChannel *c)
 654 {
 655     DBEGroup *p, *g;
 656     int i;
 657
 658     for (i = 0, p = NULL, g = c->groups; i < c->nb_groups; i++, p = g, g++) {
 659         c->exp_strategy[i] = !i || g->nb_exponent != p->nb_exponent || get_bits1(&s->gb);
 660         if (c->exp_strategy[i]) {
 661             unbias_exponents(s, c, g);
 662         } else {
 663             memcpy(c->exponents + g->exp_ofs,
 664                    c->exponents + p->exp_ofs,
 665                    g->nb_exponent * sizeof(c->exponents[0]));
 666         }
 667     }
 668
 669     return 0;
 670 }
 671
 672 static inline int log_add(int a, int b)
 673 {
 674     int c = FFABS(a - b) >> 1;
 675     return FFMAX(a, b) + log_add_tab[FFMIN(c, 211)];
 676 }
 677
 678 static void calc_lowcomp(int *msk_val)
 679 {
 680     int lwc_val[17] = { 0 };
 681     int i, j, k;
 682
 683     for (i = 0; i < 11; i++) {
 684         int max_j = 0;
 685         int max_v = INT_MIN;
 686         int thr   = 0;
 687
 688         for (j = FFMAX(i - 3, 0), k = 0; j <= i + 3; j++, k++) {
 689             int v = msk_val[j] + lwc_gain_tab[i][k];
 690             if (v > max_v) {
 691                 max_j = j;
 692                 max_v = v;
 693             }
 694             thr = log_add(thr, v);
 695         }
 696
 697         if (msk_val[i] < thr) {
 698             for (j = FFMAX(max_j - 3, 0),
 699                  k = FFMAX(3 - max_j, 0);
 700                  j <= max_j + 3; j++, k++)
 701                 lwc_val[j] += lwc_adj_tab[k];
 702         }
 703     }
 704
 705     for (i = 0; i < 16; i++) {
 706         int v = FFMAX(lwc_val[i], -512);
 707         msk_val[i] = FFMAX(msk_val[i] + v, 0);
 708     }
 709 }
 710
 711 static void bit_allocate(int nb_exponent, int nb_code, int fr_code,
 712                          int *exp, int *bap,
 713                          int fg_spc, int fg_ofs, int msk_mod, int snr_ofs)
 714 {
 715     int msk_val[MAX_BIAS_EXP];
 716     int psd_val[MAX_BIAS_EXP];
 717     int fast_leak  = 0;
 718     int slow_leak  = 0;
 719     int dc_code    = dc_code_tab[fr_code - 1];
 720     int ht_code    = ht_code_tab[fr_code - 1];
 721     int fast_gain  = fast_gain_tab[fg_ofs];
 722     int slow_decay = slow_decay_tab[dc_code][msk_mod];
 723     int misc_decay = misc_decay_tab[nb_code][dc_code][msk_mod];
 724     const uint16_t *slow_gain      = slow_gain_tab[nb_code][msk_mod];
 725     const uint16_t *fast_decay     = fast_decay_tab[nb_code][dc_code][msk_mod];
 726     const uint16_t *fast_gain_adj  = fast_gain_adj_tab[nb_code][dc_code];
 727     const uint16_t *hearing_thresh = hearing_thresh_tab[nb_code][ht_code];
 728     int i;
 729
 730     for (i = 0; i < nb_exponent; i++)
 731         psd_val[i] = (48 - exp[i]) * 64;
 732
 733     fast_gain_adj += band_ofs_tab[nb_code][fg_spc];
 734     for (i = 0; i < nb_exponent; i++) {
 735         fast_leak = log_add(fast_leak  - fast_decay[i],
 736                             psd_val[i] - fast_gain + fast_gain_adj[i]);
 737         slow_leak = log_add(slow_leak  - slow_decay,
 738                             psd_val[i] - slow_gain[i]);
 739         msk_val[i] = FFMAX(fast_leak, slow_leak);
 740     }
 741
 742     fast_leak = 0;
 743     for (i = nb_exponent - 1; i > band_low_tab[nb_code]; i--) {
 744         fast_leak = log_add(fast_leak - misc_decay, psd_val[i] - fast_gain);
 745         msk_val[i] = FFMAX(msk_val[i], fast_leak);
 746     }
 747
 748     for (i = 0; i < nb_exponent; i++)
 749         msk_val[i] = FFMAX(msk_val[i], hearing_thresh[i]);
 750
 751     if (!nb_code)
 752         calc_lowcomp(msk_val);
 753
 754     for (i = 0; i < nb_exponent; i++) {
 755         int v = 16 * (snr_ofs - 64) + psd_val[i] - msk_val[i] >> 5;
 756         bap[i] = bap_tab[av_clip_uintp2(v, 6)];
 757     }
 758 }
 759
 760 static int parse_bit_alloc(DBEDecodeContext *s1, DBEChannel *c)
 761 {
 762     DBEContext *s = &s1->dectx;
 763     DBEGroup *p, *g;
 764     int bap_strategy[MAX_GROUPS], fg_spc[MAX_GROUPS];
 765     int fg_ofs[MAX_GROUPS], msk_mod[MAX_GROUPS];
 766     int i, snr_ofs;
 767
 768     for (i = 0; i < c->nb_groups; i++) {
 769         bap_strategy[i] = !i || get_bits1(&s->gb);
 770         if (bap_strategy[i]) {
 771              fg_spc[i] = get_bits(&s->gb, 2);
 772              fg_ofs[i] = get_bits(&s->gb, 3);
 773             msk_mod[i] = get_bits1(&s->gb);
 774         } else {
 775              fg_spc[i] =  fg_spc[i - 1];
 776              fg_ofs[i] =  fg_ofs[i - 1];
 777             msk_mod[i] = msk_mod[i - 1];
 778         }
 779     }
 780
 781     if (get_bits1(&s->gb)) {
 782         avpriv_report_missing_feature(s->avctx, "Delta bit allocation");
 783         return AVERROR_PATCHWELCOME;
 784     }
 785
 786     snr_ofs = get_bits(&s->gb, 8);
 787     if (!snr_ofs) {
 788         memset(c->bap, 0, sizeof(c->bap));
 789         return 0;
 790     }
 791
 792     for (i = 0, p = NULL, g = c->groups; i < c->nb_groups; i++, p = g, g++) {
 793         if (c->exp_strategy[i] || bap_strategy[i]) {
 794             bit_allocate(g->nb_exponent, g->imdct_idx, s->metadata.fr_code,
 795                          c->exponents + g->exp_ofs, c->bap + g->exp_ofs,
 796                          fg_spc[i], fg_ofs[i], msk_mod[i], snr_ofs);
 797         } else {
 798             memcpy(c->bap + g->exp_ofs,
 799                    c->bap + p->exp_ofs,
 800                    g->nb_exponent * sizeof(c->bap[0]));
 801         }
 802     }
 803
 804     return 0;
 805 }
 806
 807 static int parse_indices(DBEContext *s, DBEChannel *c)
 808 {
 809     DBEGroup *p, *g;
 810     int i, j;
 811
 812     for (i = 0, p = NULL, g = c->groups; i < c->nb_groups; i++, p = g, g++) {
 813         if (get_bits1(&s->gb)) {
 814             int start = get_bits(&s->gb, 6);
 815
 816             if (start > g->nb_exponent) {
 817                 av_log(s->avctx, AV_LOG_ERROR, "Invalid start index\n");
 818                 return AVERROR_INVALIDDATA;
 819             }
 820
 821             for (j = 0; j < start; j++)
 822                 c->idx[g->exp_ofs + j] = 0;
 823
 824             for (; j < g->nb_exponent; j++)
 825                 c->idx[g->exp_ofs + j] = get_bits(&s->gb, 2);
 826         } else if (i && g->nb_exponent == p->nb_exponent) {
 827             memcpy(c->idx + g->exp_ofs,
 828                    c->idx + p->exp_ofs,
 829                    g->nb_exponent * sizeof(c->idx[0]));
 830         } else {
 831             memset(c->idx + g->exp_ofs, 0, g->nb_exponent * sizeof(c->idx[0]));
 832         }
 833     }
 834
 835     return 0;
 836 }
 837
 838 static int parse_mantissas(DBEContext *s, DBEChannel *c)
 839 {
 840     DBEGroup *g;
 841     int i, j, k;
 842
 843     for (i = 0, g = c->groups; i < c->nb_groups; i++, g++) {
 844         float *mnt = c->mantissas + g->mnt_ofs;
 845
 846         for (j = 0; j < g->nb_exponent; j++) {
 847             int bap     = c->bap[g->exp_ofs + j];
 848             int idx     = c->idx[g->exp_ofs + j];
 849             int size1   = mantissa_size1[bap][idx];
 850             int count   = g->nb_mantissa[j];
 851             float exp   = exponent_tab[c->exponents[g->exp_ofs + j]];
 852             float scale = mantissa_tab1[size1][idx] * exp;
 853
 854             if (!size1) {
 855                 memset(mnt, 0, count * sizeof(*mnt));
 856             } else if (idx) {
 857                 int values[100];
 858                 int escape = -(1 << size1 - 1);
 859
 860                 for (k = 0; k < count; k++)
 861                     values[k] = get_sbits(&s->gb, size1);
 862
 863                 for (k = 0; k < count; k++) {
 864                     if (values[k] != escape) {
 865                         mnt[k] = values[k] * scale;
 866                     } else {
 867                         int size2 = mantissa_size2[bap][idx];
 868                         int value = get_sbits(&s->gb, size2);
 869                         float a = mantissa_tab2[size2][idx];
 870                         float b = mantissa_tab3[size2][idx];
 871                         if (value < 0)
 872                             mnt[k] = ((value + 1) * a - b) * exp;
 873                         else
 874                             mnt[k] = (value * a + b) * exp;
 875                     }
 876                 }
 877             } else {
 878                 for (k = 0; k < count; k++)
 879                     mnt[k] = get_sbits(&s->gb, size1) * scale;
 880             }
 881
 882             mnt += count;
 883         }
 884
 885         for (; j < g->nb_exponent + c->bw_code; j++) {
 886             memset(mnt, 0, g->nb_mantissa[j] * sizeof(*mnt));
 887             mnt += g->nb_mantissa[j];
 888         }
 889     }
 890
 891     return 0;
 892 }
 893
 894 static int parse_channel(DBEDecodeContext *s1, int ch, int seg_id)
 895 {
 896     DBEContext *s = &s1->dectx;
 897     DBEChannel *c = &s1->channels[seg_id][ch];
 898     int i, ret;
 899
 900     if (s->metadata.rev_id[ch] > 1) {
 901         avpriv_report_missing_feature(s->avctx, "Encoder revision %d", s->metadata.rev_id[ch]);
 902         return AVERROR_PATCHWELCOME;
 903     }
 904
 905     if (ch == lfe_channel_tab[s->metadata.prog_conf]) {
 906         c->gr_code = 3;
 907         c->bw_code = 29;
 908     } else {
 909         c->gr_code = get_bits(&s->gb, 2);
 910         c->bw_code = get_bits(&s->gb, 3);
 911         if (c->gr_code == 3) {
 912             av_log(s->avctx, AV_LOG_ERROR, "Invalid group type code\n");
 913             return AVERROR_INVALIDDATA;
 914         }
 915     }
 916
 917     c->nb_groups   = nb_groups_tab[c->gr_code];
 918     c->nb_mstr_exp = nb_mstr_exp_tab[c->gr_code];
 919
 920     for (i = 0; i < c->nb_groups; i++) {
 921         c->groups[i] = frm_ofs_tab[seg_id][c->gr_code][i];
 922         if (c->nb_mstr_exp == 2) {
 923             c->groups[i].nb_exponent    -= c->bw_code;
 924             c->groups[i].nb_bias_exp[1] -= c->bw_code;
 925         }
 926     }
 927
 928     if ((ret = parse_exponents(s, c)) < 0)
 929         return ret;
 930     if ((ret = parse_bit_alloc(s1, c)) < 0)
 931         return ret;
 932     if ((ret = parse_indices(s, c)) < 0)
 933         return ret;
 934     if ((ret = parse_mantissas(s, c)) < 0)
 935         return ret;
 936
 937     if (get_bits_left(&s->gb) < 0) {
 938         av_log(s->avctx, AV_LOG_ERROR, "Read past end of channel %d\n", ch);
 939         return AVERROR_INVALIDDATA;
 940     }
 941
 942     return 0;
 943 }
 944
 945 static int parse_audio(DBEDecodeContext *s1, int start, int end, int seg_id)
 946 {
 947     DBEContext *s = &s1->dectx;
 948     int ch, ret, key;
 949
 950     if ((key = parse_key(s)) < 0)
 951         return key;
 952
 953     for (ch = start; ch < end; ch++) {
 954         if (!s->metadata.ch_size[ch]) {
 955             s1->channels[seg_id][ch].nb_groups = 0;
 956             continue;
 957         }
 958         ret = ff_dolby_e_convert_input(s, s->metadata.ch_size[ch], key);
 959         if (ret < 0)
 960             return ret;
 961         if ((ret = parse_channel(s1, ch, seg_id)) < 0) {
 962             if (s1->avctx->err_recognition & AV_EF_EXPLODE)
 963                 return ret;
 964             s1->channels[seg_id][ch].nb_groups = 0;
 965         }
 966         if ((ret = skip_input(s, s->metadata.ch_size[ch])) < 0)
 967             return ret;
 968     }
 969
 970     return skip_input(s, 1);
 971 }
 972
 973 static int parse_meter(DBEDecodeContext *s1)
 974 {
 975     DBEContext *s = &s1->dectx;
 976     if (s->metadata.meter_size)
 977         return skip_input(s, s->key_present + s->metadata.meter_size + 1);
 978     return 0;
 979 }
 980
 981 static void imdct_calc(DBEDecodeContext *s1, DBEGroup *g, float *result, float *values)
 982 {
 983     FFTContext *imdct = &s1->imdct[g->imdct_idx];
 984     int n   = 1 << imdct_bits_tab[g->imdct_idx];
 985     int n2  = n >> 1;
 986     int i;
 987
 988     switch (g->imdct_phs) {
 989     case 0:
 990         imdct->imdct_half(imdct, result, values);
 991         for (i = 0; i < n2; i++)
 992             result[n2 + i] = result[n2 - i - 1];
 993         break;
 994     case 1:
 995         imdct->imdct_calc(imdct, result, values);
 996         break;
 997     case 2:
 998         imdct->imdct_half(imdct, result + n2, values);
 999         for (i = 0; i < n2; i++)
1000             result[i] = -result[n - i - 1];
1001         break;
1002     default:
1003         av_assert0(0);
1004     }
1005 }
1006
1007 static void transform(DBEDecodeContext *s1, DBEChannel *c, float *history, float *output)
1008 {
1009     LOCAL_ALIGNED_32(float, buffer, [2048]);
1010     LOCAL_ALIGNED_32(float, result, [1152]);
1011     DBEGroup *g;
1012     int i;
1013
1014     memset(result, 0, 1152 * sizeof(float));
1015     for (i = 0, g = c->groups; i < c->nb_groups; i++, g++) {
1016         float *src = buffer + g->src_ofs;
1017         float *dst = result + g->dst_ofs;
1018         float *win = window + g->win_ofs;
1019
1020         imdct_calc(s1, g, buffer, c->mantissas + g->mnt_ofs);
1021         s1->fdsp->vector_fmul_add(dst, src, win, dst, g->win_len);
1022     }
1023
1024     for (i = 0; i < 256; i++)
1025         output[i] = history[i] + result[i];
1026     for (i = 256; i < 896; i++)
1027         output[i] = result[i];
1028     for (i = 0; i < 256; i++)
1029         history[i] = result[896 + i];
1030 }
1031
1032 static void apply_gain(DBEDecodeContext *s, int begin, int end, float *output)
1033 {
1034     if (begin == 960 && end == 960)
1035         return;
1036
1037     if (begin == end) {
1038         s->fdsp->vector_fmul_scalar(output, output, gain_tab[end], FRAME_SAMPLES);
1039     } else {
1040         float a = gain_tab[begin] * (1.0f / (FRAME_SAMPLES - 1));
1041         float b = gain_tab[end  ] * (1.0f / (FRAME_SAMPLES - 1));
1042         int i;
1043
1044         for (i = 0; i < FRAME_SAMPLES; i++)
1045             output[i] *= a * (FRAME_SAMPLES - i - 1) + b * i;
1046     }
1047 }
1048
1049 static int filter_frame(DBEDecodeContext *s, AVFrame *frame)
1050 {
1051     const DolbyEHeaderInfo *const metadata = &s->dectx.metadata;
1052     const uint8_t *reorder;
1053     int ch, ret;
1054
1055     if (metadata->nb_channels == 4)
1056         reorder = ch_reorder_4;
1057     else if (metadata->nb_channels == 6)
1058         reorder = ch_reorder_6;
1059     else if (metadata->nb_programs == 1 && !(s->avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE))
1060         reorder = ch_reorder_8;
1061     else
1062         reorder = ch_reorder_n;
1063
1064     frame->nb_samples = FRAME_SAMPLES;
1065     if ((ret = ff_get_buffer(s->avctx, frame, 0)) < 0)
1066         return ret;
1067
1068     for (ch = 0; ch < metadata->nb_channels; ch++) {
1069         float *output = (float *)frame->extended_data[reorder[ch]];
1070         transform(s, &s->channels[0][ch], s->history[ch], output);
1071         transform(s, &s->channels[1][ch], s->history[ch], output + FRAME_SAMPLES / 2);
1072         apply_gain(s, metadata->begin_gain[ch], metadata->end_gain[ch], output);
1073     }
1074
1075     return 0;
1076 }
1077
1078 static int dolby_e_decode_frame(AVCodecContext *avctx, void *data,
1079                                 int *got_frame_ptr, AVPacket *avpkt)
1080 {
1081     DBEDecodeContext *s1 = avctx->priv_data;
1082     DBEContext *s = &s1->dectx;
1083     int i, j, ret;
1084
1085     if ((ret = ff_dolby_e_parse_header(s, avpkt->data, avpkt->size)) < 0)
1086         return ret;
1087
1088     if (s->metadata.nb_programs > 1 && !s->metadata.multi_prog_warned) {
1089         av_log(avctx, AV_LOG_WARNING, "Stream has %d programs (configuration %d), "
1090                "channels will be output in native order.\n",
1091                s->metadata.nb_programs, s->metadata.prog_conf);
1092         s->metadata.multi_prog_warned = 1;
1093     }
1094
1095     switch (s->metadata.nb_channels) {
1096     case 4:
1097         avctx->channel_layout = AV_CH_LAYOUT_4POINT0;
1098         break;
1099     case 6:
1100         avctx->channel_layout = AV_CH_LAYOUT_5POINT1;
1101         break;
1102     case 8:
1103         avctx->channel_layout = AV_CH_LAYOUT_7POINT1;
1104         break;
1105     }
1106
1107     avctx->channels    = s->metadata.nb_channels;
1108     avctx->sample_rate = s->metadata.sample_rate;
1109     avctx->sample_fmt  = AV_SAMPLE_FMT_FLTP;
1110
1111     i = s->metadata.nb_channels / 2;
1112     j = s->metadata.nb_channels;
1113     if ((ret = parse_audio(s1, 0, i, 0)) < 0)
1114         return ret;
1115     if ((ret = parse_audio(s1, i, j, 0)) < 0)
1116         return ret;
1117     if ((ret = parse_metadata_ext(s1)) < 0)
1118         return ret;
1119     if ((ret = parse_audio(s1, 0, i, 1)) < 0)
1120         return ret;
1121     if ((ret = parse_audio(s1, i, j, 1)) < 0)
1122         return ret;
1123     if ((ret = parse_meter(s1)) < 0)
1124         return ret;
1125     if ((ret = filter_frame(s1, data)) < 0)
1126         return ret;
1127
1128     *got_frame_ptr = 1;
1129     return avpkt->size;
1130 }
1131
1132 static av_cold void dolby_e_flush(AVCodecContext *avctx)
1133 {
1134     DBEDecodeContext *s = avctx->priv_data;
1135
1136     memset(s->history, 0, sizeof(s->history));
1137 }
1138
1139 static av_cold int dolby_e_close(AVCodecContext *avctx)
1140 {
1141     DBEDecodeContext *s = avctx->priv_data;
1142     int i;
1143
1144     for (i = 0; i < 3; i++)
1145         ff_mdct_end(&s->imdct[i]);
1146
1147     av_freep(&s->fdsp);
1148     return 0;
1149 }
1150
1151
1152 static av_cold void init_tables(void)
1153 {
1154     int i, j;
1155
1156     for (i = 1; i < 17; i++)
1157         mantissa_tab1[i][0] = 1.0f / (1 << i - 1);
1158
1159     for (i = 2; i < 16; i++) {
1160         mantissa_tab1[i][1] = 1.0f  / ((1 << i) - 1);
1161         mantissa_tab1[i][2] = 0.5f  / ((1 << i) - 1);
1162         mantissa_tab1[i][3] = 0.25f / ((1 << i) - 1);
1163     }
1164
1165     mantissa_tab1[i][1] = 0.5f   / (1 << 15);
1166     mantissa_tab1[i][2] = 0.75f  / (1 << 15);
1167     mantissa_tab1[i][3] = 0.875f / (1 << 15);
1168
1169     for (i = 1; i < 17; i++) {
1170         mantissa_tab2[i][1] = mantissa_tab1[i][0] * 0.5f;
1171         mantissa_tab2[i][2] = mantissa_tab1[i][0] * 0.75f;
1172         mantissa_tab2[i][3] = mantissa_tab1[i][0] * 0.875f;
1173         for (j = 1; j < 4; j++)
1174             mantissa_tab3[i][j] = 1.0f / (1 << i) + 1.0f / (1 << j) - 1.0f / (1 << i + j);
1175     }
1176
1177     mantissa_tab3[1][3] = 0.6875f;
1178
1179     for (i = 0; i < 25; i++) {
1180         exponent_tab[i * 2    ] = 1.0f      / (1 << i);
1181         exponent_tab[i * 2 + 1] = M_SQRT1_2 / (1 << i);
1182     }
1183
1184     for (i = 1; i < 1024; i++)
1185         gain_tab[i] = exp2f((i - 960) / 64.0f);
1186
1187     // short 1
1188     ff_kbd_window_init(window, 3.0f, 128);
1189     for (i = 0; i < 128; i++)
1190         window[128 + i] = window[127 - i];
1191
1192     // start
1193     for (i = 0; i < 192; i++)
1194         window[256 + i] = start_window[i];
1195
1196     // short 2
1197     for (i = 0; i < 192; i++)
1198         window[448 + i] = short_window2[i];
1199     for (i = 0; i < 64; i++)
1200         window[640 + i] = window[63 - i];
1201
1202     // short 3
1203     for (i = 0; i < 64; i++)
1204         window[704 + i] = short_window3[i];
1205     for (i = 0; i < 192; i++)
1206         window[768 + i] = window[64 + i];
1207
1208     // bridge
1209     for (i = 0; i < 128; i++)
1210         window[960 + i] = window[i];
1211     for (i = 0; i < 64; i++)
1212         window[1088 + i] = 1.0f;
1213
1214     // long
1215     ff_kbd_window_init(window + 1408, 3.0f, 256);
1216     for (i = 0; i < 640; i++)
1217         window[1664 + i] = 1.0f;
1218     for (i = 0; i < 256; i++)
1219         window[2304 + i] = window[1152 + i] = window[1663 - i];
1220
1221     // reverse start
1222     for (i = 0; i < 192; i++)
1223         window[2560 + i] = window[447 - i];
1224
1225     // reverse short 2
1226     for (i = 0; i < 256; i++)
1227         window[2752 + i] = window[703 - i];
1228
1229     // reverse short 3
1230     for (i = 0; i < 256; i++)
1231         window[3008 + i] = window[959 - i];
1232
1233     // reverse bridge
1234     for (i = 0; i < 448; i++)
1235         window[3264 + i] = window[1407 - i];
1236 }
1237
1238 static av_cold int dolby_e_init(AVCodecContext *avctx)
1239 {
1240     static AVOnce init_once = AV_ONCE_INIT;
1241     DBEDecodeContext *s = avctx->priv_data;
1242     int i;
1243
1244     if (ff_thread_once(&init_once, init_tables))
1245         return AVERROR_UNKNOWN;
1246
1247     for (i = 0; i < 3; i++)
1248         if (ff_mdct_init(&s->imdct[i], imdct_bits_tab[i], 1, 2.0) < 0)
1249             return AVERROR(ENOMEM);
1250
1251     if (!(s->fdsp = avpriv_float_dsp_alloc(0)))
1252         return AVERROR(ENOMEM);
1253
1254     s->dectx.metadata.multi_prog_warned = !!(avctx->request_channel_layout & AV_CH_LAYOUT_NATIVE);
1255     s->dectx.avctx = s->avctx = avctx;
1256     return 0;
1257 }
1258
1259 const AVCodec ff_dolby_e_decoder = {
1260     .name           = "dolby_e",
1261     .long_name      = NULL_IF_CONFIG_SMALL("Dolby E"),
1262     .type           = AVMEDIA_TYPE_AUDIO,
1263     .id             = AV_CODEC_ID_DOLBY_E,
1264     .priv_data_size = sizeof(DBEDecodeContext),
1265     .init           = dolby_e_init,
1266     .decode         = dolby_e_decode_frame,
1267     .close          = dolby_e_close,
1268     .flush          = dolby_e_flush,
1269     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1270     .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP, AV_SAMPLE_FMT_NONE },
1271     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
1272 };