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
skip_input(DBEContext * s,int nb_words)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
parse_key(DBEContext * s)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
parse_metadata_ext(DBEDecodeContext * s1)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
unbias_exponents(DBEContext * s,DBEChannel * c,DBEGroup * g)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
parse_exponents(DBEContext * s,DBEChannel * c)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
log_add(int a,int b)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
calc_lowcomp(int * msk_val)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
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)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
parse_bit_alloc(DBEDecodeContext * s1,DBEChannel * c)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
parse_indices(DBEContext * s,DBEChannel * c)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
parse_mantissas(DBEContext * s,DBEChannel * c)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
parse_channel(DBEDecodeContext * s1,int ch,int seg_id)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
parse_audio(DBEDecodeContext * s1,int start,int end,int seg_id)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
parse_meter(DBEDecodeContext * s1)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
imdct_calc(DBEDecodeContext * s1,DBEGroup * g,float * result,float * values)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
transform(DBEDecodeContext * s1,DBEChannel * c,float * history,float * output)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
apply_gain(DBEDecodeContext * s,int begin,int end,float * output)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
filter_frame(DBEDecodeContext * s,AVFrame * frame)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
dolby_e_decode_frame(AVCodecContext * avctx,AVFrame * frame,int * got_frame_ptr,AVPacket * avpkt)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
dolby_e_flush(AVCodecContext * avctx)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
dolby_e_close(AVCodecContext * avctx)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
init_tables(void)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
dolby_e_init(AVCodecContext * avctx)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 };
1315