avcodec/dca: move EXSS sampling frequency arrays to dca.c
[ffmpeg.git] / libavcodec / dca_parser.c
1 /*
2  * DCA parser
3  * Copyright (C) 2004 Gildas Bazin
4  * Copyright (C) 2004 Benjamin Zores
5  * Copyright (C) 2006 Benjamin Larsson
6  * Copyright (C) 2007 Konstantin Shishkov
7  *
8  * This file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24
25 #include "dca.h"
26 #include "dca_exss.h"
27 #include "dca_syncwords.h"
28 #include "get_bits.h"
29 #include "parser.h"
30
31 typedef struct DCAParseContext {
32     ParseContext pc;
33     uint32_t lastmarker;
34     int size;
35     int framesize;
36     DCAExssParser exss;
37     unsigned int sr_code;
38 } DCAParseContext;
39
40 #define IS_CORE_MARKER(state) \
41     (((state & 0xFFFFFFFFF0FF) == (((uint64_t)DCA_SYNCWORD_CORE_14B_LE << 16) | 0xF007)) || \
42      ((state & 0xFFFFFFFFFFF0) == (((uint64_t)DCA_SYNCWORD_CORE_14B_BE << 16) | 0x07F0)) || \
43      ((state & 0xFFFFFFFF00FC) == (((uint64_t)DCA_SYNCWORD_CORE_LE     << 16) | 0x00FC)) || \
44      ((state & 0xFFFFFFFFFC00) == (((uint64_t)DCA_SYNCWORD_CORE_BE     << 16) | 0xFC00)))
45
46 #define IS_EXSS_MARKER(state)   ((state & 0xFFFFFFFF) == DCA_SYNCWORD_SUBSTREAM)
47
48 #define IS_MARKER(state)        (IS_CORE_MARKER(state) || IS_EXSS_MARKER(state))
49
50 #define CORE_MARKER(state)      ((state >> 16) & 0xFFFFFFFF)
51 #define EXSS_MARKER(state)      (state & 0xFFFFFFFF)
52
53 #define STATE_LE(state)     (((state & 0xFF00FF00) >> 8) | ((state & 0x00FF00FF) << 8))
54 #define STATE_14(state)     (((state & 0x3FFF0000) >> 8) | ((state & 0x00003FFF) >> 6))
55
56 #define CORE_FRAMESIZE(state)   (((state >> 4) & 0x3FFF) + 1)
57 #define EXSS_FRAMESIZE(state)   ((state & 0x2000000000) ? \
58                                  ((state >>  5) & 0xFFFFF) + 1 : \
59                                  ((state >> 13) & 0x0FFFF) + 1)
60
61 /**
62  * Find the end of the current frame in the bitstream.
63  * @return the position of the first byte of the next frame, or -1
64  */
65 static int dca_find_frame_end(DCAParseContext *pc1, const uint8_t *buf,
66                               int buf_size)
67 {
68     int start_found, size, i;
69     uint64_t state;
70     ParseContext *pc = &pc1->pc;
71
72     start_found = pc->frame_start_found;
73     state       = pc->state64;
74     size        = pc1->size;
75
76     i = 0;
77     if (!start_found) {
78         for (i = 0; i < buf_size; i++) {
79             state = (state << 8) | buf[i];
80             if (IS_MARKER(state)) {
81                 if (!pc1->lastmarker ||
82                     pc1->lastmarker == CORE_MARKER(state) ||
83                     pc1->lastmarker == DCA_SYNCWORD_SUBSTREAM) {
84                     start_found = 1;
85                     if (IS_EXSS_MARKER(state))
86                         pc1->lastmarker = EXSS_MARKER(state);
87                     else
88                         pc1->lastmarker = CORE_MARKER(state);
89                     i++;
90                     break;
91                 }
92             }
93         }
94     }
95
96     if (start_found) {
97         for (; i < buf_size; i++) {
98             size++;
99             state = (state << 8) | buf[i];
100
101             if (start_found == 1) {
102                 switch (pc1->lastmarker) {
103                 case DCA_SYNCWORD_CORE_BE:
104                     if (size == 2) {
105                         pc1->framesize = CORE_FRAMESIZE(state);
106                         start_found    = 2;
107                     }
108                     break;
109                 case DCA_SYNCWORD_CORE_LE:
110                     if (size == 2) {
111                         pc1->framesize = CORE_FRAMESIZE(STATE_LE(state));
112                         start_found    = 2;
113                     }
114                     break;
115                 case DCA_SYNCWORD_CORE_14B_BE:
116                     if (size == 4) {
117                         pc1->framesize = CORE_FRAMESIZE(STATE_14(state)) * 8 / 14 * 2;
118                         start_found    = 2;
119                     }
120                     break;
121                 case DCA_SYNCWORD_CORE_14B_LE:
122                     if (size == 4) {
123                         pc1->framesize = CORE_FRAMESIZE(STATE_14(STATE_LE(state))) * 8 / 14 * 2;
124                         start_found    = 2;
125                     }
126                     break;
127                 case DCA_SYNCWORD_SUBSTREAM:
128                     if (size == 6) {
129                         pc1->framesize = EXSS_FRAMESIZE(state);
130                         start_found    = 2;
131                     }
132                     break;
133                 default:
134                     av_assert0(0);
135                 }
136                 continue;
137             }
138
139             if (pc1->lastmarker == DCA_SYNCWORD_CORE_BE) {
140                 if (pc1->framesize > size + 2)
141                     continue;
142
143                 if (start_found == 2 && IS_EXSS_MARKER(state)) {
144                     pc1->framesize = size + 2;
145                     start_found    = 3;
146                     continue;
147                 }
148
149                 if (start_found == 3) {
150                     if (size == pc1->framesize + 4) {
151                         pc1->framesize += EXSS_FRAMESIZE(state);
152                         start_found     = 4;
153                     }
154                     continue;
155                 }
156             }
157
158             if (pc1->framesize > size)
159                 continue;
160
161             if (IS_MARKER(state) &&
162                 (pc1->lastmarker == CORE_MARKER(state) ||
163                  pc1->lastmarker == DCA_SYNCWORD_SUBSTREAM)) {
164                 pc->frame_start_found = 0;
165                 pc->state64           = -1;
166                 pc1->size             = 0;
167                 return IS_EXSS_MARKER(state) ? i - 3 : i - 5;
168             }
169         }
170     }
171
172     pc->frame_start_found = start_found;
173     pc->state64           = state;
174     pc1->size             = size;
175     return END_NOT_FOUND;
176 }
177
178 static av_cold int dca_parse_init(AVCodecParserContext *s)
179 {
180     DCAParseContext *pc1 = s->priv_data;
181
182     pc1->lastmarker = 0;
183     pc1->sr_code = -1;
184     return 0;
185 }
186
187 static int dca_parse_params(DCAParseContext *pc1, const uint8_t *buf,
188                             int buf_size, int *duration, int *sample_rate)
189 {
190     GetBitContext gb;
191     uint8_t hdr[12 + AV_INPUT_BUFFER_PADDING_SIZE] = { 0 };
192     int ret, sample_blocks;
193
194     if (buf_size < 12)
195         return AVERROR_INVALIDDATA;
196
197     if (AV_RB32(buf) == DCA_SYNCWORD_SUBSTREAM) {
198         DCAExssAsset *asset = &pc1->exss.assets[0];
199
200         if ((ret = ff_dca_exss_parse(&pc1->exss, buf, buf_size)) < 0)
201             return ret;
202
203         if (asset->extension_mask & DCA_EXSS_LBR) {
204             if ((ret = init_get_bits8(&gb, buf + asset->lbr_offset, asset->lbr_size)) < 0)
205                 return ret;
206
207             if (get_bits_long(&gb, 32) != DCA_SYNCWORD_LBR)
208                 return AVERROR_INVALIDDATA;
209
210             switch (get_bits(&gb, 8)) {
211             case 2:
212                 pc1->sr_code = get_bits(&gb, 8);
213             case 1:
214                 break;
215             default:
216                 return AVERROR_INVALIDDATA;
217             }
218
219             if (pc1->sr_code >= FF_ARRAY_ELEMS(ff_dca_sampling_freqs))
220                 return AVERROR_INVALIDDATA;
221
222             *sample_rate = ff_dca_sampling_freqs[pc1->sr_code];
223             *duration = 1024 << ff_dca_freq_ranges[pc1->sr_code];
224             return 0;
225         }
226
227         if (asset->extension_mask & DCA_EXSS_XLL) {
228             int nsamples_log2;
229
230             if ((ret = init_get_bits8(&gb, buf + asset->xll_offset, asset->xll_size)) < 0)
231                 return ret;
232
233             if (get_bits_long(&gb, 32) != DCA_SYNCWORD_XLL)
234                 return AVERROR_INVALIDDATA;
235
236             if (get_bits(&gb, 4))
237                 return AVERROR_INVALIDDATA;
238
239             skip_bits(&gb, 8);
240             skip_bits_long(&gb, get_bits(&gb, 5) + 1);
241             skip_bits(&gb, 4);
242             nsamples_log2 = get_bits(&gb, 4) + get_bits(&gb, 4);
243             if (nsamples_log2 > 24)
244                 return AVERROR_INVALIDDATA;
245
246             *sample_rate = asset->max_sample_rate;
247             *duration = (1 + (*sample_rate > 96000)) << nsamples_log2;
248             return 0;
249         }
250
251         return AVERROR_INVALIDDATA;
252     }
253
254     if ((ret = avpriv_dca_convert_bitstream(buf, 12, hdr, 12)) < 0)
255         return ret;
256
257     init_get_bits(&gb, hdr, 96);
258
259     skip_bits_long(&gb, 39);
260     sample_blocks = get_bits(&gb, 7) + 1;
261     if (sample_blocks < 8)
262         return AVERROR_INVALIDDATA;
263     *duration = 256 * (sample_blocks / 8);
264
265     skip_bits(&gb, 20);
266     *sample_rate = avpriv_dca_sample_rates[get_bits(&gb, 4)];
267     if (*sample_rate == 0)
268         return AVERROR_INVALIDDATA;
269
270     return 0;
271 }
272
273 static int dca_parse(AVCodecParserContext *s, AVCodecContext *avctx,
274                      const uint8_t **poutbuf, int *poutbuf_size,
275                      const uint8_t *buf, int buf_size)
276 {
277     DCAParseContext *pc1 = s->priv_data;
278     ParseContext *pc = &pc1->pc;
279     int next, duration, sample_rate;
280
281     if (s->flags & PARSER_FLAG_COMPLETE_FRAMES) {
282         next = buf_size;
283     } else {
284         next = dca_find_frame_end(pc1, buf, buf_size);
285
286         if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
287             *poutbuf      = NULL;
288             *poutbuf_size = 0;
289             return buf_size;
290         }
291     }
292
293     /* read the duration and sample rate from the frame header */
294     if (!dca_parse_params(pc1, buf, buf_size, &duration, &sample_rate)) {
295         if (!avctx->sample_rate)
296             avctx->sample_rate = sample_rate;
297         s->duration = av_rescale(duration, avctx->sample_rate, sample_rate);
298     } else
299         s->duration = 0;
300
301     *poutbuf      = buf;
302     *poutbuf_size = buf_size;
303     return next;
304 }
305
306 AVCodecParser ff_dca_parser = {
307     .codec_ids      = { AV_CODEC_ID_DTS },
308     .priv_data_size = sizeof(DCAParseContext),
309     .parser_init    = dca_parse_init,
310     .parser_parse   = dca_parse,
311     .parser_close   = ff_parse_close,
312 };