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