]> git.sesse.net Git - ffmpeg/blob - libavcodec/aacps_common.c
avformat/avio: Add Metacube support
[ffmpeg] / libavcodec / aacps_common.c
1 /*
2  * Functions common to fixed/float MPEG-4 Parametric Stereo decoding
3  * Copyright (c) 2010 Alex Converse <alex.converse@gmail.com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include <stdint.h>
23 #include "libavutil/common.h"
24 #include "libavutil/thread.h"
25 #include "aacps.h"
26 #include "get_bits.h"
27 #include "aacpsdata.c"
28
29 static const int8_t num_env_tab[2][4] = {
30     { 0, 1, 2, 4, },
31     { 1, 2, 3, 4, },
32 };
33
34 static const int8_t nr_iidicc_par_tab[] = {
35     10, 20, 34, 10, 20, 34,
36 };
37
38 static const int8_t nr_iidopd_par_tab[] = {
39      5, 11, 17,  5, 11, 17,
40 };
41
42 enum {
43     huff_iid_df1,
44     huff_iid_dt1,
45     huff_iid_df0,
46     huff_iid_dt0,
47     huff_icc_df,
48     huff_icc_dt,
49     huff_ipd_df,
50     huff_ipd_dt,
51     huff_opd_df,
52     huff_opd_dt,
53 };
54
55 static const int huff_iid[] = {
56     huff_iid_df0,
57     huff_iid_df1,
58     huff_iid_dt0,
59     huff_iid_dt1,
60 };
61
62 static VLC vlc_ps[10];
63
64 #define READ_PAR_DATA(PAR, OFFSET, MASK, ERR_CONDITION, NB_BITS, MAX_DEPTH) \
65 /** \
66  * Read Inter-channel Intensity Difference/Inter-Channel Coherence/ \
67  * Inter-channel Phase Difference/Overall Phase Difference parameters from the \
68  * bitstream. \
69  * \
70  * @param avctx contains the current codec context \
71  * @param gb    pointer to the input bitstream \
72  * @param ps    pointer to the Parametric Stereo context \
73  * @param PAR   pointer to the parameter to be read \
74  * @param e     envelope to decode \
75  * @param dt    1: time delta-coded, 0: frequency delta-coded \
76  */ \
77 static int read_ ## PAR ## _data(AVCodecContext *avctx, GetBitContext *gb, PSCommonContext *ps, \
78                         int8_t (*PAR)[PS_MAX_NR_IIDICC], int table_idx, int e, int dt) \
79 { \
80     int b, num = ps->nr_ ## PAR ## _par; \
81     VLC_TYPE (*vlc_table)[2] = vlc_ps[table_idx].table; \
82     if (dt) { \
83         int e_prev = e ? e - 1 : ps->num_env_old - 1; \
84         e_prev = FFMAX(e_prev, 0); \
85         for (b = 0; b < num; b++) { \
86             int val = PAR[e_prev][b] + get_vlc2(gb, vlc_table, NB_BITS, MAX_DEPTH) - OFFSET; \
87             if (MASK) val &= MASK; \
88             PAR[e][b] = val; \
89             if (ERR_CONDITION) \
90                 goto err; \
91         } \
92     } else { \
93         int val = 0; \
94         for (b = 0; b < num; b++) { \
95             val += get_vlc2(gb, vlc_table, NB_BITS, MAX_DEPTH) - OFFSET; \
96             if (MASK) val &= MASK; \
97             PAR[e][b] = val; \
98             if (ERR_CONDITION) \
99                 goto err; \
100         } \
101     } \
102     return 0; \
103 err: \
104     av_log(avctx, AV_LOG_ERROR, "illegal "#PAR"\n"); \
105     return AVERROR_INVALIDDATA; \
106 }
107
108 READ_PAR_DATA(iid,    huff_offset[table_idx],    0, FFABS(ps->iid_par[e][b]) > 7 + 8 * ps->iid_quant, 9, 3)
109 READ_PAR_DATA(icc,    huff_offset[table_idx],    0, ps->icc_par[e][b] > 7U, 9, 2)
110 READ_PAR_DATA(ipdopd,                      0, 0x07, 0, 5, 1)
111
112 static int ps_read_extension_data(GetBitContext *gb, PSCommonContext *ps,
113                                   int ps_extension_id)
114 {
115     int e;
116     int count = get_bits_count(gb);
117
118     if (ps_extension_id)
119         return 0;
120
121     ps->enable_ipdopd = get_bits1(gb);
122     if (ps->enable_ipdopd) {
123         for (e = 0; e < ps->num_env; e++) {
124             int dt = get_bits1(gb);
125             read_ipdopd_data(NULL, gb, ps, ps->ipd_par, dt ? huff_ipd_dt : huff_ipd_df, e, dt);
126             dt = get_bits1(gb);
127             read_ipdopd_data(NULL, gb, ps, ps->opd_par, dt ? huff_opd_dt : huff_opd_df, e, dt);
128         }
129     }
130     skip_bits1(gb);      //reserved_ps
131     return get_bits_count(gb) - count;
132 }
133
134 int ff_ps_read_data(AVCodecContext *avctx, GetBitContext *gb_host,
135                     PSCommonContext *ps, int bits_left)
136 {
137     int e;
138     int bit_count_start = get_bits_count(gb_host);
139     int header;
140     int bits_consumed;
141     GetBitContext gbc = *gb_host, *gb = &gbc;
142
143     header = get_bits1(gb);
144     if (header) {     //enable_ps_header
145         ps->enable_iid = get_bits1(gb);
146         if (ps->enable_iid) {
147             int iid_mode = get_bits(gb, 3);
148             if (iid_mode > 5) {
149                 av_log(avctx, AV_LOG_ERROR, "iid_mode %d is reserved.\n",
150                        iid_mode);
151                 goto err;
152             }
153             ps->nr_iid_par    = nr_iidicc_par_tab[iid_mode];
154             ps->iid_quant     = iid_mode > 2;
155             ps->nr_ipdopd_par = nr_iidopd_par_tab[iid_mode];
156         }
157         ps->enable_icc = get_bits1(gb);
158         if (ps->enable_icc) {
159             ps->icc_mode = get_bits(gb, 3);
160             if (ps->icc_mode > 5) {
161                 av_log(avctx, AV_LOG_ERROR, "icc_mode %d is reserved.\n",
162                        ps->icc_mode);
163                 goto err;
164             }
165             ps->nr_icc_par = nr_iidicc_par_tab[ps->icc_mode];
166         }
167         ps->enable_ext = get_bits1(gb);
168     }
169
170     ps->frame_class = get_bits1(gb);
171     ps->num_env_old = ps->num_env;
172     ps->num_env     = num_env_tab[ps->frame_class][get_bits(gb, 2)];
173
174     ps->border_position[0] = -1;
175     if (ps->frame_class) {
176         for (e = 1; e <= ps->num_env; e++) {
177             ps->border_position[e] = get_bits(gb, 5);
178             if (ps->border_position[e] < ps->border_position[e-1]) {
179                 av_log(avctx, AV_LOG_ERROR, "border_position non monotone.\n");
180                 goto err;
181             }
182         }
183     } else
184         for (e = 1; e <= ps->num_env; e++)
185             ps->border_position[e] = (e * numQMFSlots >> ff_log2_tab[ps->num_env]) - 1;
186
187     if (ps->enable_iid) {
188         for (e = 0; e < ps->num_env; e++) {
189             int dt = get_bits1(gb);
190             if (read_iid_data(avctx, gb, ps, ps->iid_par, huff_iid[2*dt+ps->iid_quant], e, dt))
191                 goto err;
192         }
193     } else
194         memset(ps->iid_par, 0, sizeof(ps->iid_par));
195
196     if (ps->enable_icc)
197         for (e = 0; e < ps->num_env; e++) {
198             int dt = get_bits1(gb);
199             if (read_icc_data(avctx, gb, ps, ps->icc_par, dt ? huff_icc_dt : huff_icc_df, e, dt))
200                 goto err;
201         }
202     else
203         memset(ps->icc_par, 0, sizeof(ps->icc_par));
204
205     if (ps->enable_ext) {
206         int cnt = get_bits(gb, 4);
207         if (cnt == 15) {
208             cnt += get_bits(gb, 8);
209         }
210         cnt *= 8;
211         while (cnt > 7) {
212             int ps_extension_id = get_bits(gb, 2);
213             cnt -= 2 + ps_read_extension_data(gb, ps, ps_extension_id);
214         }
215         if (cnt < 0) {
216             av_log(avctx, AV_LOG_ERROR, "ps extension overflow %d\n", cnt);
217             goto err;
218         }
219         skip_bits(gb, cnt);
220     }
221
222     ps->enable_ipdopd &= !PS_BASELINE;
223
224     //Fix up envelopes
225     if (!ps->num_env || ps->border_position[ps->num_env] < numQMFSlots - 1) {
226         //Create a fake envelope
227         int source = ps->num_env ? ps->num_env - 1 : ps->num_env_old - 1;
228         int b;
229         if (source >= 0 && source != ps->num_env) {
230             if (ps->enable_iid) {
231                 memcpy(ps->iid_par+ps->num_env, ps->iid_par+source, sizeof(ps->iid_par[0]));
232             }
233             if (ps->enable_icc) {
234                 memcpy(ps->icc_par+ps->num_env, ps->icc_par+source, sizeof(ps->icc_par[0]));
235             }
236             if (ps->enable_ipdopd) {
237                 memcpy(ps->ipd_par+ps->num_env, ps->ipd_par+source, sizeof(ps->ipd_par[0]));
238                 memcpy(ps->opd_par+ps->num_env, ps->opd_par+source, sizeof(ps->opd_par[0]));
239             }
240         }
241         if (ps->enable_iid){
242             for (b = 0; b < ps->nr_iid_par; b++) {
243                 if (FFABS(ps->iid_par[ps->num_env][b]) > 7 + 8 * ps->iid_quant) {
244                     av_log(avctx, AV_LOG_ERROR, "iid_par invalid\n");
245                     goto err;
246                 }
247             }
248         }
249         if (ps->enable_icc){
250             for (b = 0; b < ps->nr_iid_par; b++) {
251                 if (ps->icc_par[ps->num_env][b] > 7U) {
252                     av_log(avctx, AV_LOG_ERROR, "icc_par invalid\n");
253                     goto err;
254                 }
255             }
256         }
257         ps->num_env++;
258         ps->border_position[ps->num_env] = numQMFSlots - 1;
259     }
260
261
262     ps->is34bands_old = ps->is34bands;
263     if (!PS_BASELINE && (ps->enable_iid || ps->enable_icc))
264         ps->is34bands = (ps->enable_iid && ps->nr_iid_par == 34) ||
265                         (ps->enable_icc && ps->nr_icc_par == 34);
266
267     //Baseline
268     if (!ps->enable_ipdopd) {
269         memset(ps->ipd_par, 0, sizeof(ps->ipd_par));
270         memset(ps->opd_par, 0, sizeof(ps->opd_par));
271     }
272
273     if (header)
274         ps->start = 1;
275
276     bits_consumed = get_bits_count(gb) - bit_count_start;
277     if (bits_consumed <= bits_left) {
278         skip_bits_long(gb_host, bits_consumed);
279         return bits_consumed;
280     }
281     av_log(avctx, AV_LOG_ERROR, "Expected to read %d PS bits actually read %d.\n", bits_left, bits_consumed);
282 err:
283     ps->start = 0;
284     skip_bits_long(gb_host, bits_left);
285     memset(ps->iid_par, 0, sizeof(ps->iid_par));
286     memset(ps->icc_par, 0, sizeof(ps->icc_par));
287     memset(ps->ipd_par, 0, sizeof(ps->ipd_par));
288     memset(ps->opd_par, 0, sizeof(ps->opd_par));
289     return bits_left;
290 }
291
292 #define PS_INIT_VLC_STATIC(num, nb_bits, size)                          \
293     INIT_VLC_STATIC(&vlc_ps[num], nb_bits, ps_tmp[num].table_size / ps_tmp[num].elem_size,    \
294                     ps_tmp[num].ps_bits, 1, 1,                                          \
295                     ps_tmp[num].ps_codes, ps_tmp[num].elem_size, ps_tmp[num].elem_size, \
296                     size);
297
298 #define PS_VLC_ROW(name) \
299     { name ## _codes, name ## _bits, sizeof(name ## _codes), sizeof(name ## _codes[0]) }
300
301 static av_cold void ps_init_common(void)
302 {
303     // Syntax initialization
304     static const struct {
305         const void *ps_codes, *ps_bits;
306         const unsigned int table_size, elem_size;
307     } ps_tmp[] = {
308         PS_VLC_ROW(huff_iid_df1),
309         PS_VLC_ROW(huff_iid_dt1),
310         PS_VLC_ROW(huff_iid_df0),
311         PS_VLC_ROW(huff_iid_dt0),
312         PS_VLC_ROW(huff_icc_df),
313         PS_VLC_ROW(huff_icc_dt),
314         PS_VLC_ROW(huff_ipd_df),
315         PS_VLC_ROW(huff_ipd_dt),
316         PS_VLC_ROW(huff_opd_df),
317         PS_VLC_ROW(huff_opd_dt),
318     };
319
320     PS_INIT_VLC_STATIC(0, 9, 1544);
321     PS_INIT_VLC_STATIC(1, 9,  832);
322     PS_INIT_VLC_STATIC(2, 9, 1024);
323     PS_INIT_VLC_STATIC(3, 9, 1036);
324     PS_INIT_VLC_STATIC(4, 9,  544);
325     PS_INIT_VLC_STATIC(5, 9,  544);
326     PS_INIT_VLC_STATIC(6, 5,   32);
327     PS_INIT_VLC_STATIC(7, 5,   32);
328     PS_INIT_VLC_STATIC(8, 5,   32);
329     PS_INIT_VLC_STATIC(9, 5,   32);
330 }
331
332 av_cold void ff_ps_init_common(void)
333 {
334     static AVOnce init_static_once = AV_ONCE_INIT;
335     ff_thread_once(&init_static_once, ps_init_common);
336 }