FFmpeg
dolby_e.c
Go to the documentation of this file.
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 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 };
grp_tab_3
static const DBEGroup grp_tab_3[1]
Definition: dolby_e.c:144
AVCodec
AVCodec.
Definition: codec.h:197
AV_SAMPLE_FMT_FLTP
@ AV_SAMPLE_FMT_FLTP
float, planar
Definition: samplefmt.h:69
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
start_window
static const float start_window[192]
Definition: dolby_e.c:196
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
DolbyEHeaderInfo::end_gain
int end_gain[MAX_CHANNELS]
Definition: dolby_e.h:54
dolby_e_close
static av_cold int dolby_e_close(AVCodecContext *avctx)
Definition: dolby_e.c:1139
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
DolbyEHeaderInfo::begin_gain
int begin_gain[MAX_CHANNELS]
Definition: dolby_e.h:53
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
DBEGroup::exp_ofs
uint16_t exp_ofs
Definition: dolby_e.c:44
dolby_e_init
static av_cold int dolby_e_init(AVCodecContext *avctx)
Definition: dolby_e.c:1238
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
mem_internal.h
ch_reorder_6
static const uint8_t ch_reorder_6[6]
Definition: dolby_e.c:89
DBEDecodeContext::avctx
AVCodecContext * avctx
Definition: dolby_e.c:72
grp_tab_0
static const DBEGroup grp_tab_0[1]
Definition: dolby_e.c:119
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1196
imdct_calc
static void imdct_calc(DBEDecodeContext *s1, DBEGroup *g, float *result, float *values)
Definition: dolby_e.c:981
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:925
thread.h
av_clip_uintp2
#define av_clip_uintp2
Definition: common.h:146
hearing_thresh_tab
static const uint16_t hearing_thresh_tab[3][3][50]
Definition: dolby_e.c:499
lfe_channel_tab
static const int8_t lfe_channel_tab[MAX_PROG_CONF+1]
Definition: dolby_e.c:83
output
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce output
Definition: filter_design.txt:225
MAX_MANTISSAS
#define MAX_MANTISSAS
Definition: dolby_e.c:36
DBEChannel::bw_code
int bw_code
Definition: dolby_e.c:57
DolbyEHeaderInfo::nb_programs
int nb_programs
Definition: dolby_e.h:43
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
DBEGroup::imdct_idx
uint8_t imdct_idx
Definition: dolby_e.c:47
internal.h
ch_reorder_n
static const uint8_t ch_reorder_n[8]
Definition: dolby_e.c:91
MAX_GROUPS
#define MAX_GROUPS
Definition: dolby_e.c:34
AVPacket::data
uint8_t * data
Definition: packet.h:369
b
#define b
Definition: input.c:41
data
const char data[16]
Definition: mxf.c:142
ff_mdct_init
#define ff_mdct_init
Definition: fft.h:161
ff_dolby_e_parse_header
int ff_dolby_e_parse_header(DBEContext *s, const uint8_t *buf, int buf_size)
Initialize DBEContext and parse Dolby E metadata.
Definition: dolby_e_parse.c:97
exponent_tab
static float exponent_tab[50]
Definition: dolby_e.c:599
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
DBEChannel::exp_strategy
int exp_strategy[MAX_GROUPS]
Definition: dolby_e.c:63
AVCodecContext::request_channel_layout
uint64_t request_channel_layout
Request decoder to use this channel layout if it can (0 for default)
Definition: avcodec.h:1254
parse_audio
static int parse_audio(DBEDecodeContext *s1, int start, int end, int seg_id)
Definition: dolby_e.c:945
ht_code_tab
static const uint8_t ht_code_tab[5]
Definition: dolby_e.c:323
band_low_tab
static const uint8_t band_low_tab[3]
Definition: dolby_e.c:329
misc_decay_tab
static const uint16_t misc_decay_tab[3][2][2]
Definition: dolby_e.c:337
win
static float win(SuperEqualizerContext *s, float n, int N)
Definition: af_superequalizer.c:119
FRAME_SAMPLES
#define FRAME_SAMPLES
Definition: dolby_e.h:27
DBEGroup::nb_bias_exp
uint8_t nb_bias_exp[MAX_MSTR_EXP]
Definition: dolby_e.c:43
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
DBEDecodeContext::imdct
FFTContext imdct[3]
Definition: dolby_e.c:79
transform
static void transform(DBEDecodeContext *s1, DBEChannel *c, float *history, float *output)
Definition: dolby_e.c:1007
DBEChannel::groups
DBEGroup groups[MAX_GROUPS]
Definition: dolby_e.c:61
DBEContext
Definition: dolby_e.h:70
short_window2
static const float short_window2[192]
Definition: dolby_e.c:249
parse_mantissas
static int parse_mantissas(DBEContext *s, DBEChannel *c)
Definition: dolby_e.c:838
DBEChannel::nb_mstr_exp
int nb_mstr_exp
Definition: dolby_e.c:60
DBEChannel::idx
int idx[MAX_EXPONENTS]
Definition: dolby_e.c:66
parse_meter
static int parse_meter(DBEDecodeContext *s1)
Definition: dolby_e.c:973
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
frm_ofs_tab
static const DBEGroup *const frm_ofs_tab[2][4]
Definition: dolby_e.c:177
av_cold
#define av_cold
Definition: attributes.h:90
lwc_adj_tab
static const int16_t lwc_adj_tab[7]
Definition: dolby_e.c:568
DBEChannel::gr_code
int gr_code
Definition: dolby_e.c:56
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
DBEGroup::nb_mantissa
const uint8_t * nb_mantissa
Definition: dolby_e.c:46
mantissa_tab1
static float mantissa_tab1[17][4]
Definition: dolby_e.c:596
nb_mantissa_44
static const uint8_t nb_mantissa_44[44]
Definition: dolby_e.c:104
dolby_e_flush
static av_cold void dolby_e_flush(AVCodecContext *avctx)
Definition: dolby_e.c:1132
s
#define s(width, name)
Definition: cbs_vp9.c:257
fast_gain_tab
static const uint16_t fast_gain_tab[8]
Definition: dolby_e.c:331
g
const char * g
Definition: vf_curves.c:117
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
s1
#define s1
Definition: regdef.h:38
gain_tab
static float gain_tab[1024]
Definition: dolby_e.c:600
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
parse_key
static int parse_key(DBEContext *s)
Definition: dolby_e.c:616
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
exp2f
#define exp2f(x)
Definition: libm.h:293
channels
channels
Definition: aptx.h:33
get_bits.h
slow_gain_tab
static const uint16_t slow_gain_tab[3][2][50]
Definition: dolby_e.c:461
kbdwin.h
unbias_exponents
static void unbias_exponents(DBEContext *s, DBEChannel *c, DBEGroup *g)
Definition: dolby_e.c:636
AV_CODEC_ID_DOLBY_E
@ AV_CODEC_ID_DOLBY_E
Definition: codec_id.h:509
key
const char * key
Definition: hwcontext_opencl.c:168
f
#define f(width, name)
Definition: cbs_vp9.c:255
bit_allocate
static void bit_allocate(int nb_exponent, int nb_code, int fr_code, int *exp, int *bap, int fg_spc, int fg_ofs, int msk_mod, int snr_ofs)
Definition: dolby_e.c:711
DBEGroup::imdct_phs
uint8_t imdct_phs
Definition: dolby_e.c:48
short_window3
static const float short_window3[64]
Definition: dolby_e.c:302
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
slow_decay_tab
static const uint16_t slow_decay_tab[2][2]
Definition: dolby_e.c:335
DBEDecodeContext::dectx
DBEContext dectx
Definition: dolby_e.c:73
nb_groups_tab
static const uint8_t nb_groups_tab[4]
Definition: dolby_e.c:94
bap_tab
static const uint8_t bap_tab[64]
Definition: dolby_e.c:589
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:592
NULL
#define NULL
Definition: coverity.c:32
DolbyEHeaderInfo
Definition: dolby_e.h:37
LOCAL_ALIGNED_32
#define LOCAL_ALIGNED_32(t, v,...)
Definition: mem_internal.h:136
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
parse_exponents
static int parse_exponents(DBEContext *s, DBEChannel *c)
Definition: dolby_e.c:653
fast_decay_tab
static const uint16_t fast_decay_tab[3][2][2][50]
Definition: dolby_e.c:343
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
src
#define src
Definition: vp8dsp.c:255
band_ofs_tab
static const uint8_t band_ofs_tab[3][4]
Definition: dolby_e.c:325
AV_CH_LAYOUT_5POINT1
#define AV_CH_LAYOUT_5POINT1
Definition: channel_layout.h:101
mantissa_tab3
static float mantissa_tab3[17][4]
Definition: dolby_e.c:598
filter_frame
static int filter_frame(DBEDecodeContext *s, AVFrame *frame)
Definition: dolby_e.c:1049
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1656
exp
int8_t exp
Definition: eval.c:72
dolby_e_decode_frame
static int dolby_e_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: dolby_e.c:1078
AVOnce
#define AVOnce
Definition: thread.h:172
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
float_dsp.h
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
FFTContext::imdct_half
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:103
DBEGroup::mnt_ofs
uint16_t mnt_ofs
Definition: dolby_e.c:45
DBEGroup::nb_exponent
uint8_t nb_exponent
Definition: dolby_e.c:42
AV_CODEC_CAP_CHANNEL_CONF
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:104
FFTContext::imdct_calc
void(* imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:102
grp_tab_5
static const DBEGroup grp_tab_5[8]
Definition: dolby_e.c:152
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1900
parse_channel
static int parse_channel(DBEDecodeContext *s1, int ch, int seg_id)
Definition: dolby_e.c:894
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
fast_gain_adj_tab
static const uint16_t fast_gain_adj_tab[3][2][62]
Definition: dolby_e.c:415
AVPacket::size
int size
Definition: packet.h:370
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
DBEChannel::nb_groups
int nb_groups
Definition: dolby_e.c:59
FFMAX
#define FFMAX(a, b)
Definition: common.h:103
MAX_PROG_CONF
#define MAX_PROG_CONF
Definition: dolby_e.h:29
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:59
DBEDecodeContext
Definition: dolby_e.c:71
ff_mdct_end
#define ff_mdct_end
Definition: fft.h:162
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
mantissa_tab2
static float mantissa_tab2[17][4]
Definition: dolby_e.c:597
AVFloatDSPContext
Definition: float_dsp.h:24
grp_tab_1
static const DBEGroup grp_tab_1[8]
Definition: dolby_e.c:123
nb_mantissa_38
static const uint8_t nb_mantissa_38[38]
Definition: dolby_e.c:98
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
skip_input
static int skip_input(DBEContext *s, int nb_words)
Definition: dolby_e.c:604
lwc_gain_tab
static const int16_t lwc_gain_tab[11][7]
Definition: dolby_e.c:554
grp_tab_2
static const DBEGroup grp_tab_2[7]
Definition: dolby_e.c:134
parse_metadata_ext
static int parse_metadata_ext(DBEDecodeContext *s1)
Definition: dolby_e.c:628
MAX_CHANNELS
#define MAX_CHANNELS
Definition: aac.h:48
DBEDecodeContext::history
float history[MAX_CHANNELS][256]
Definition: dolby_e.c:77
MAX_EXPONENTS
#define MAX_EXPONENTS
Definition: dolby_e.c:35
DBEChannel::bap
int bap[MAX_EXPONENTS]
Definition: dolby_e.c:65
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:1197
calc_lowcomp
static void calc_lowcomp(int *msk_val)
Definition: dolby_e.c:678
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:117
MAX_MSTR_EXP
#define MAX_MSTR_EXP
Definition: dolby_e.c:38
FFTContext
Definition: fft.h:83
i
int i
Definition: input.c:407
DBEDecodeContext::fdsp
AVFloatDSPContext * fdsp
Definition: dolby_e.c:80
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
DBEGroup::dst_ofs
uint16_t dst_ofs
Definition: dolby_e.c:50
grp_tab_4
static const DBEGroup grp_tab_4[1]
Definition: dolby_e.c:148
mantissa_size2
static const uint8_t mantissa_size2[16][4]
Definition: dolby_e.c:189
AV_CH_LAYOUT_NATIVE
#define AV_CH_LAYOUT_NATIVE
Channel mask value used for AVCodecContext.request_channel_layout to indicate that the user requests ...
Definition: channel_layout.h:83
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
AV_CH_LAYOUT_7POINT1
#define AV_CH_LAYOUT_7POINT1
Definition: channel_layout.h:112
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
grp_tab_6
static const DBEGroup grp_tab_6[7]
Definition: dolby_e.c:163
uint8_t
uint8_t
Definition: audio_convert.c:194
mantissa_size1
static const uint8_t mantissa_size1[16][4]
Definition: dolby_e.c:182
MAX_SEGMENTS
#define MAX_SEGMENTS
Definition: dolby_e.c:32
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
DBEGroup::win_len
uint16_t win_len
Definition: dolby_e.c:49
nb_mstr_exp_tab
static const uint8_t nb_mstr_exp_tab[4]
Definition: dolby_e.c:96
ret
ret
Definition: filter_design.txt:187
DBEChannel::mantissas
float mantissas[MAX_MANTISSAS]
Definition: dolby_e.c:68
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
ff_dolby_e_convert_input
int ff_dolby_e_convert_input(DBEContext *s, int nb_words, int key)
Use the provided key to transform the input into data (put into s->buffer) suitable for further proce...
Definition: dolby_e_parse.c:60
log_add
static int log_add(int a, int b)
Definition: dolby_e.c:672
DBEGroup::src_ofs
uint16_t src_ofs
Definition: dolby_e.c:52
M_SQRT1_2
#define M_SQRT1_2
Definition: mathematics.h:58
DBEChannel
Definition: dolby_e.c:55
fft.h
AVCodecContext
main external API structure.
Definition: avcodec.h:536
ch_reorder_4
static const uint8_t ch_reorder_4[4]
Definition: dolby_e.c:88
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
ff_kbd_window_init
av_cold void ff_kbd_window_init(float *window, float alpha, int n)
Generate a Kaiser-Bessel Derived Window.
Definition: kbdwin.c:26
DBEChannel::exponents
int exponents[MAX_EXPONENTS]
Definition: dolby_e.c:64
grp_tab_7
static const DBEGroup grp_tab_7[1]
Definition: dolby_e.c:173
values
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return values
Definition: filter_design.txt:263
log_add_tab
static const uint8_t log_add_tab[212]
Definition: dolby_e.c:572
MAX_BIAS_EXP
#define MAX_BIAS_EXP
Definition: dolby_e.c:39
mem.h
imdct_bits_tab
static const uint8_t imdct_bits_tab[3]
Definition: dolby_e.c:117
ch_reorder_8
static const uint8_t ch_reorder_8[8]
Definition: dolby_e.c:90
dc_code_tab
static const uint8_t dc_code_tab[5]
Definition: dolby_e.c:321
nb_mantissa_50
static const uint8_t nb_mantissa_50[50]
Definition: dolby_e.c:110
parse_indices
static int parse_indices(DBEContext *s, DBEChannel *c)
Definition: dolby_e.c:807
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
AVPacket
This structure stores compressed data.
Definition: packet.h:346
parse_bit_alloc
static int parse_bit_alloc(DBEDecodeContext *s1, DBEChannel *c)
Definition: dolby_e.c:760
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
avpriv_float_dsp_alloc
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
window
static float window[3712]
Definition: dolby_e.c:602
AV_CH_LAYOUT_4POINT0
#define AV_CH_LAYOUT_4POINT0
Definition: channel_layout.h:96
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
dolby_e.h
DolbyEHeaderInfo::nb_channels
int nb_channels
Definition: dolby_e.h:42
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
apply_gain
static void apply_gain(DBEDecodeContext *s, int begin, int end, float *output)
Definition: dolby_e.c:1032
ff_dolby_e_decoder
AVCodec ff_dolby_e_decoder
Definition: dolby_e.c:1259
AV_RB24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:97
init_tables
static av_cold void init_tables(void)
Definition: dolby_e.c:1152
DBEGroup::win_ofs
uint16_t win_ofs
Definition: dolby_e.c:51
DBEGroup
Definition: dolby_e.c:41
Generated on Wed Aug 24 2022 21:33:52 for FFmpeg by   doxygen 1.8.17