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 {
44  uint16_t exp_ofs;
45  uint16_t mnt_ofs;
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;
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 {
74 
76 
77  DECLARE_ALIGNED(32, float, history)[MAX_CHANNELS][256];
78 
79  FFTContext imdct[3];
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 
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 
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 
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 
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]) {
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 
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 
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 
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) {
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 
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 
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",
1092  s->metadata.multi_prog_warned = 1;
1093  }
1094 
1095  switch (s->metadata.nb_channels) {
1096  case 4:
1098  break;
1099  case 6:
1101  break;
1102  case 8:
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 
1133 {
1134  DBEDecodeContext *s = avctx->priv_data;
1135 
1136  memset(s->history, 0, sizeof(s->history));
1137 }
1138 
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 
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 
1255  s->dectx.avctx = s->avctx = avctx;
1256  return 0;
1257 }
1258 
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,
1267  .close = dolby_e_close,
1268  .flush = dolby_e_flush,
1269  .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1272 };
static const uint8_t nb_groups_tab[4]
Definition: dolby_e.c:94
#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
uint16_t src_ofs
Definition: dolby_e.c:52
float, planar
Definition: samplefmt.h:69
#define NULL
Definition: coverity.c:32
#define AV_CH_LAYOUT_7POINT1
int exp_strategy[MAX_GROUPS]
Definition: dolby_e.c:63
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static const DBEGroup grp_tab_1[8]
Definition: dolby_e.c:123
static float mantissa_tab3[17][4]
Definition: dolby_e.c:598
static int filter_frame(DBEDecodeContext *s, AVFrame *frame)
Definition: dolby_e.c:1049
#define MAX_GROUPS
Definition: dolby_e.c:34
#define av_clip_uintp2
Definition: common.h:146
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
static void apply_gain(DBEDecodeContext *s, int begin, int end, float *output)
Definition: dolby_e.c:1032
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static void flush(AVCodecContext *avctx)
Dolby E reading context used by decoder and parser.
Definition: dolby_e.h:70
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
av_cold void ff_kbd_window_init(float *window, float alpha, int n)
Generate a Kaiser-Bessel Derived Window.
Definition: kbdwin.c:26
int end_gain[MAX_CHANNELS]
Definition: dolby_e.h:54
uint8_t nb_bias_exp[MAX_MSTR_EXP]
Definition: dolby_e.c:43
FFTContext imdct[3]
Definition: dolby_e.c:79
Memory handling functions.
uint16_t win_len
Definition: dolby_e.c:49
static float win(SuperEqualizerContext *s, float n, int N)
const char * g
Definition: vf_curves.c:117
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
DBEGroup groups[MAX_GROUPS]
Definition: dolby_e.c:61
static const uint8_t mantissa_size1[16][4]
Definition: dolby_e.c:182
#define M_SQRT1_2
Definition: mathematics.h:58
int size
Definition: packet.h:370
uint16_t win_ofs
Definition: dolby_e.c:51
static const int8_t lfe_channel_tab[MAX_PROG_CONF+1]
Definition: dolby_e.c:83
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:36
static const uint8_t ht_code_tab[5]
Definition: dolby_e.c:323
static const DBEGroup grp_tab_6[7]
Definition: dolby_e.c:163
int nb_mstr_exp
Definition: dolby_e.c:60
#define AV_CH_LAYOUT_4POINT0
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
Definition: codec.h:104
const char * key
static const uint8_t ch_reorder_4[4]
Definition: dolby_e.c:88
static const DBEGroup grp_tab_5[8]
Definition: dolby_e.c:152
static const uint8_t mantissa_size2[16][4]
Definition: dolby_e.c:189
AVCodec.
Definition: codec.h:197
#define MAX_MANTISSAS
Definition: dolby_e.c:36
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static const uint16_t fast_decay_tab[3][2][2][50]
Definition: dolby_e.c:343
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
uint8_t imdct_phs
Definition: dolby_e.c:48
static const uint8_t band_ofs_tab[3][4]
Definition: dolby_e.c:325
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
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
static int parse_metadata_ext(DBEDecodeContext *s1)
Definition: dolby_e.c:628
AVCodecContext * avctx
Definition: dolby_e.c:72
static int parse_channel(DBEDecodeContext *s1, int ch, int seg_id)
Definition: dolby_e.c:894
#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
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1204
uint8_t
#define av_cold
Definition: attributes.h:88
static int dolby_e_decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr, AVPacket *avpkt)
Definition: dolby_e.c:1078
DolbyEHeaderInfo metadata
Definition: dolby_e.h:81
int idx[MAX_EXPONENTS]
Definition: dolby_e.c:66
static const int16_t lwc_gain_tab[11][7]
Definition: dolby_e.c:554
static const OptionGroupDef groups[]
Definition: ffmpeg_opt.c:3312
#define f(width, name)
Definition: cbs_vp9.c:255
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
GetBitContext gb
Definition: dolby_e.h:72
#define LOCAL_ALIGNED_32(t, v,...)
Definition: mem_internal.h:136
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
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
static const uint16_t fast_gain_tab[8]
Definition: dolby_e.c:331
static const uint8_t ch_reorder_n[8]
Definition: dolby_e.c:91
DBEContext dectx
Definition: dolby_e.c:73
const uint8_t * input
Definition: dolby_e.h:74
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
uint8_t * data
Definition: packet.h:369
static const float short_window3[64]
Definition: dolby_e.c:302
uint16_t mnt_ofs
Definition: dolby_e.c:45
static const uint16_t hearing_thresh_tab[3][3][50]
Definition: dolby_e.c:499
bitstream reader API header.
static const uint8_t dc_code_tab[5]
Definition: dolby_e.c:321
static const uint8_t nb_mantissa_50[50]
Definition: dolby_e.c:110
channels
Definition: aptx.h:33
#define AVOnce
Definition: thread.h:172
#define MAX_BIAS_EXP
Definition: dolby_e.c:39
#define av_log(a,...)
int key_present
Definition: dolby_e.h:79
#define AV_CH_LAYOUT_5POINT1
static const uint8_t imdct_bits_tab[3]
Definition: dolby_e.c:117
#define src
Definition: vp8dsp.c:255
static int parse_key(DBEContext *s)
Definition: dolby_e.c:616
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
static int parse_bit_alloc(DBEDecodeContext *s1, DBEChannel *c)
Definition: dolby_e.c:760
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
static float mantissa_tab2[17][4]
Definition: dolby_e.c:597
av_cold AVFloatDSPContext * avpriv_float_dsp_alloc(int bit_exact)
Allocate a float DSP context.
Definition: float_dsp.c:135
int gr_code
Definition: dolby_e.c:56
int multi_prog_warned
Definition: dolby_e.h:60
#define MAX_SEGMENTS
Definition: dolby_e.c:32
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:117
static const uint8_t ch_reorder_8[8]
Definition: dolby_e.c:90
static const int16_t lwc_adj_tab[7]
Definition: dolby_e.c:568
static const DBEGroup grp_tab_2[7]
Definition: dolby_e.c:134
int nb_groups
Definition: dolby_e.c:59
static const uint8_t bap_tab[64]
Definition: dolby_e.c:589
#define MAX_PROG_CONF
Definition: dolby_e.h:29
DBEChannel channels[MAX_SEGMENTS][MAX_CHANNELS]
Definition: dolby_e.c:75
static const DBEGroup grp_tab_4[1]
Definition: dolby_e.c:148
const char * name
Name of the codec implementation.
Definition: codec.h:204
void(* imdct_calc)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:102
#define ff_mdct_init
Definition: fft.h:161
GLsizei count
Definition: opengl_enc.c:108
#define FFMAX(a, b)
Definition: common.h:103
AVCodec ff_dolby_e_decoder
Definition: dolby_e.c:1259
int8_t exp
Definition: eval.c:72
static const uint16_t slow_gain_tab[3][2][50]
Definition: dolby_e.c:461
static int parse_indices(DBEContext *s, DBEChannel *c)
Definition: dolby_e.c:807
static av_cold int dolby_e_init(AVCodecContext *avctx)
Definition: dolby_e.c:1238
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1247
#define FRAME_SAMPLES
Definition: dolby_e.h:27
static const uint8_t nb_mstr_exp_tab[4]
Definition: dolby_e.c:96
uint8_t imdct_idx
Definition: dolby_e.c:47
#define b
Definition: input.c:41
static const uint16_t slow_decay_tab[2][2]
Definition: dolby_e.c:335
Definition: fft.h:83
int bap[MAX_EXPONENTS]
Definition: dolby_e.c:65
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1645
#define FFMIN(a, b)
Definition: common.h:105
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
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
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
int word_bytes
Definition: dolby_e.h:78
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1656
static const uint16_t fast_gain_adj_tab[3][2][62]
Definition: dolby_e.c:415
int mtd_ext_size
Definition: dolby_e.h:49
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int input_size
Definition: dolby_e.h:75
float mantissas[MAX_MANTISSAS]
Definition: dolby_e.c:68
static const uint8_t nb_mantissa_44[44]
Definition: dolby_e.c:104
#define exp2f(x)
Definition: libm.h:293
static void transform(DBEDecodeContext *s1, DBEChannel *c, float *history, float *output)
Definition: dolby_e.c:1007
static const uint16_t misc_decay_tab[3][2][2]
Definition: dolby_e.c:337
#define AV_ONCE_INIT
Definition: thread.h:173
static void imdct_calc(DBEDecodeContext *s1, DBEGroup *g, float *result, float *values)
Definition: dolby_e.c:981
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:58
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:91
int sample_rate
samples per second
Definition: avcodec.h:1196
#define AV_CH_LAYOUT_NATIVE
Channel mask value used for AVCodecContext.request_channel_layout to indicate that the user requests ...
static const uint8_t nb_mantissa_38[38]
Definition: dolby_e.c:98
main external API structure.
Definition: avcodec.h:536
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1893
static void calc_lowcomp(int *msk_val)
Definition: dolby_e.c:678
static const DBEGroup grp_tab_3[1]
Definition: dolby_e.c:144
static const float short_window2[192]
Definition: dolby_e.c:249
static float exponent_tab[50]
Definition: dolby_e.c:599
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static float gain_tab[1024]
Definition: dolby_e.c:600
static int parse_mantissas(DBEContext *s, DBEChannel *c)
Definition: dolby_e.c:838
AVFloatDSPContext * fdsp
Definition: dolby_e.c:80
static int parse_audio(DBEDecodeContext *s1, int start, int end, int seg_id)
Definition: dolby_e.c:945
void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)
Multiply a vector of floats by a scalar float.
Definition: float_dsp.h:85
int rev_id[MAX_CHANNELS]
Definition: dolby_e.h:52
#define MAX_CHANNELS
Definition: aac.h:48
uint16_t dst_ofs
Definition: dolby_e.c:50
#define s1
Definition: regdef.h:38
static const uint8_t log_add_tab[212]
Definition: dolby_e.c:572
static int log_add(int a, int b)
Definition: dolby_e.c:672
static const float start_window[192]
Definition: dolby_e.c:196
static const DBEGroup grp_tab_7[1]
Definition: dolby_e.c:173
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:103
static av_cold void dolby_e_flush(AVCodecContext *avctx)
Definition: dolby_e.c:1132
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
static const DBEGroup *const frm_ofs_tab[2][4]
Definition: dolby_e.c:177
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
const uint8_t * nb_mantissa
Definition: dolby_e.c:46
common internal api header.
float history[MAX_CHANNELS][256]
Definition: dolby_e.c:77
#define MAX_EXPONENTS
Definition: dolby_e.c:35
#define ff_mdct_end
Definition: fft.h:162
void(* vector_fmul_add)(float *dst, const float *src0, const float *src1, const float *src2, int len)
Calculate the entry wise product of two vectors of floats, add a third vector of floats and store the...
Definition: float_dsp.h:137
static const DBEGroup grp_tab_0[1]
Definition: dolby_e.c:119
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
void * priv_data
Definition: avcodec.h:563
int ch_size[MAX_CHANNELS]
Definition: dolby_e.h:48
int exponents[MAX_EXPONENTS]
Definition: dolby_e.c:64
int channels
number of audio channels
Definition: avcodec.h:1197
Coded Dolby E header values up to end_gain element, plus derived values.
Definition: dolby_e.h:37
static int parse_exponents(DBEContext *s, DBEChannel *c)
Definition: dolby_e.c:653
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
int begin_gain[MAX_CHANNELS]
Definition: dolby_e.h:53
uint16_t exp_ofs
Definition: dolby_e.c:44
static int skip_input(DBEContext *s, int nb_words)
Definition: dolby_e.c:604
static av_cold void init_tables(void)
Definition: dolby_e.c:1152
static float mantissa_tab1[17][4]
Definition: dolby_e.c:596
uint8_t nb_exponent
Definition: dolby_e.c:42
and forward the result(frame or status change) to the corresponding input.If nothing is possible
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:941
#define av_freep(p)
static const uint8_t band_low_tab[3]
Definition: dolby_e.c:329
int bw_code
Definition: dolby_e.c:57
#define MAX_MSTR_EXP
Definition: dolby_e.c:38
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
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:365
uint64_t request_channel_layout
Request decoder to use this channel layout if it can (0 for default)
Definition: avcodec.h:1254
This structure stores compressed data.
Definition: packet.h:346
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:384
static void unbias_exponents(DBEContext *s, DBEChannel *c, DBEGroup *g)
Definition: dolby_e.c:636
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators...
Definition: codec.h:52
int word_bits
Definition: dolby_e.h:77
for(j=16;j >0;--j)
int i
Definition: input.c:407
static const uint8_t ch_reorder_6[6]
Definition: dolby_e.c:89
GLuint buffer
Definition: opengl_enc.c:101
static int parse_meter(DBEDecodeContext *s1)
Definition: dolby_e.c:973
static float window[3712]
Definition: dolby_e.c:602
void * avctx
Definition: dolby_e.h:71
static av_cold int dolby_e_close(AVCodecContext *avctx)
Definition: dolby_e.c:1139