FFmpeg: libavcodec/dolby_e.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /