Commit | Line | Data |
---|---|---|
2ba45a60 DM |
1 | /* |
2 | * Copyright (c) 2012 Justin Ruggles | |
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 | /** | |
22 | * @file | |
23 | * Vorbis audio parser | |
24 | * | |
25 | * Determines the duration for each packet. | |
26 | */ | |
27 | ||
28 | #include "get_bits.h" | |
29 | #include "parser.h" | |
30 | #include "xiph.h" | |
31 | #include "vorbis_parser.h" | |
32 | ||
33 | static int parse_id_header(AVCodecContext *avctx, VorbisParseContext *s, | |
34 | const uint8_t *buf, int buf_size) | |
35 | { | |
36 | /* Id header should be 30 bytes */ | |
37 | if (buf_size < 30) { | |
38 | av_log(avctx, AV_LOG_ERROR, "Id header is too short\n"); | |
39 | return AVERROR_INVALIDDATA; | |
40 | } | |
41 | ||
42 | /* make sure this is the Id header */ | |
43 | if (buf[0] != 1) { | |
44 | av_log(avctx, AV_LOG_ERROR, "Wrong packet type in Id header\n"); | |
45 | return AVERROR_INVALIDDATA; | |
46 | } | |
47 | ||
48 | /* check for header signature */ | |
49 | if (memcmp(&buf[1], "vorbis", 6)) { | |
50 | av_log(avctx, AV_LOG_ERROR, "Invalid packet signature in Id header\n"); | |
51 | return AVERROR_INVALIDDATA; | |
52 | } | |
53 | ||
54 | if (!(buf[29] & 0x1)) { | |
55 | av_log(avctx, AV_LOG_ERROR, "Invalid framing bit in Id header\n"); | |
56 | return AVERROR_INVALIDDATA; | |
57 | } | |
58 | ||
59 | s->blocksize[0] = 1 << (buf[28] & 0xF); | |
60 | s->blocksize[1] = 1 << (buf[28] >> 4); | |
61 | ||
62 | return 0; | |
63 | } | |
64 | ||
65 | static int parse_setup_header(AVCodecContext *avctx, VorbisParseContext *s, | |
66 | const uint8_t *buf, int buf_size) | |
67 | { | |
68 | GetBitContext gb, gb0; | |
69 | uint8_t *rev_buf; | |
70 | int i, ret = 0; | |
71 | int got_framing_bit, mode_count, got_mode_header, last_mode_count = 0; | |
72 | ||
73 | /* avoid overread */ | |
74 | if (buf_size < 7) { | |
75 | av_log(avctx, AV_LOG_ERROR, "Setup header is too short\n"); | |
76 | return AVERROR_INVALIDDATA; | |
77 | } | |
78 | ||
79 | /* make sure this is the Setup header */ | |
80 | if (buf[0] != 5) { | |
81 | av_log(avctx, AV_LOG_ERROR, "Wrong packet type in Setup header\n"); | |
82 | return AVERROR_INVALIDDATA; | |
83 | } | |
84 | ||
85 | /* check for header signature */ | |
86 | if (memcmp(&buf[1], "vorbis", 6)) { | |
87 | av_log(avctx, AV_LOG_ERROR, "Invalid packet signature in Setup header\n"); | |
88 | return AVERROR_INVALIDDATA; | |
89 | } | |
90 | ||
91 | /* reverse bytes so we can easily read backwards with get_bits() */ | |
92 | if (!(rev_buf = av_malloc(buf_size))) { | |
93 | av_log(avctx, AV_LOG_ERROR, "Out of memory\n"); | |
94 | return AVERROR(ENOMEM); | |
95 | } | |
96 | for (i = 0; i < buf_size; i++) | |
97 | rev_buf[i] = buf[buf_size - 1 - i]; | |
98 | init_get_bits(&gb, rev_buf, buf_size * 8); | |
99 | ||
100 | got_framing_bit = 0; | |
101 | while (get_bits_left(&gb) > 97) { | |
102 | if (get_bits1(&gb)) { | |
103 | got_framing_bit = get_bits_count(&gb); | |
104 | break; | |
105 | } | |
106 | } | |
107 | if (!got_framing_bit) { | |
108 | av_log(avctx, AV_LOG_ERROR, "Invalid Setup header\n"); | |
109 | ret = AVERROR_INVALIDDATA; | |
110 | goto bad_header; | |
111 | } | |
112 | ||
113 | /* Now we search backwards to find possible valid mode counts. This is not | |
114 | * fool-proof because we could have false positive matches and read too | |
115 | * far, but there isn't really any way to be sure without parsing through | |
116 | * all the many variable-sized fields before the modes. This approach seems | |
117 | * to work well in testing, and it is similar to how it is handled in | |
118 | * liboggz. */ | |
119 | mode_count = 0; | |
120 | got_mode_header = 0; | |
121 | while (get_bits_left(&gb) >= 97) { | |
122 | if (get_bits(&gb, 8) > 63 || get_bits(&gb, 16) || get_bits(&gb, 16)) | |
123 | break; | |
124 | skip_bits(&gb, 1); | |
125 | mode_count++; | |
126 | if (mode_count > 64) | |
127 | break; | |
128 | gb0 = gb; | |
129 | if (get_bits(&gb0, 6) + 1 == mode_count) { | |
130 | got_mode_header = 1; | |
131 | last_mode_count = mode_count; | |
132 | } | |
133 | } | |
134 | if (!got_mode_header) { | |
135 | av_log(avctx, AV_LOG_ERROR, "Invalid Setup header\n"); | |
136 | ret = AVERROR_INVALIDDATA; | |
137 | goto bad_header; | |
138 | } | |
139 | /* All samples I've seen use <= 2 modes, so ask for a sample if we find | |
140 | * more than that, as it is most likely a false positive. If we get any | |
141 | * we may need to approach this the long way and parse the whole Setup | |
142 | * header, but I hope very much that it never comes to that. */ | |
143 | if (last_mode_count > 2) { | |
144 | avpriv_request_sample(avctx, | |
145 | "%d modes (either a false positive or a " | |
146 | "sample from an unknown encoder)", | |
147 | last_mode_count); | |
148 | } | |
149 | /* We're limiting the mode count to 63 so that we know that the previous | |
150 | * block flag will be in the first packet byte. */ | |
151 | if (last_mode_count > 63) { | |
152 | av_log(avctx, AV_LOG_ERROR, "Unsupported mode count: %d\n", | |
153 | last_mode_count); | |
154 | ret = AVERROR_INVALIDDATA; | |
155 | goto bad_header; | |
156 | } | |
157 | s->mode_count = mode_count = last_mode_count; | |
158 | /* Determine the number of bits required to code the mode and turn that | |
159 | * into a bitmask to directly access the mode from the first frame byte. */ | |
160 | s->mode_mask = ((1 << (av_log2(mode_count - 1) + 1)) - 1) << 1; | |
161 | /* The previous window flag is the next bit after the mode */ | |
162 | s->prev_mask = (s->mode_mask | 0x1) + 1; | |
163 | ||
164 | init_get_bits(&gb, rev_buf, buf_size * 8); | |
165 | skip_bits_long(&gb, got_framing_bit); | |
166 | for (i = mode_count - 1; i >= 0; i--) { | |
167 | skip_bits_long(&gb, 40); | |
168 | s->mode_blocksize[i] = get_bits1(&gb); | |
169 | } | |
170 | ||
171 | bad_header: | |
172 | av_free(rev_buf); | |
173 | return ret; | |
174 | } | |
175 | ||
176 | int avpriv_vorbis_parse_extradata(AVCodecContext *avctx, VorbisParseContext *s) | |
177 | { | |
178 | uint8_t *header_start[3]; | |
179 | int header_len[3]; | |
180 | int ret; | |
181 | ||
182 | s->avctx = avctx; | |
183 | s->extradata_parsed = 1; | |
184 | ||
185 | if ((ret = avpriv_split_xiph_headers(avctx->extradata, | |
186 | avctx->extradata_size, 30, | |
187 | header_start, header_len)) < 0) { | |
188 | av_log(avctx, AV_LOG_ERROR, "Extradata corrupt.\n"); | |
189 | return ret; | |
190 | } | |
191 | ||
192 | if ((ret = parse_id_header(avctx, s, header_start[0], header_len[0])) < 0) | |
193 | return ret; | |
194 | ||
195 | if ((ret = parse_setup_header(avctx, s, header_start[2], header_len[2])) < 0) | |
196 | return ret; | |
197 | ||
198 | s->valid_extradata = 1; | |
199 | s->previous_blocksize = s->blocksize[s->mode_blocksize[0]]; | |
200 | ||
201 | return 0; | |
202 | } | |
203 | ||
204 | int avpriv_vorbis_parse_frame_flags(VorbisParseContext *s, const uint8_t *buf, | |
205 | int buf_size, int *flags) | |
206 | { | |
207 | int duration = 0; | |
208 | ||
209 | if (s->valid_extradata && buf_size > 0) { | |
210 | int mode, current_blocksize; | |
211 | int previous_blocksize = s->previous_blocksize; | |
212 | ||
213 | if (buf[0] & 1) { | |
214 | /* If the user doesn't care about special packets, it's a bad one. */ | |
215 | if (!flags) | |
216 | goto bad_packet; | |
217 | ||
218 | /* Set the flag for which kind of special packet it is. */ | |
219 | if (buf[0] == 1) | |
220 | *flags |= VORBIS_FLAG_HEADER; | |
221 | else if (buf[0] == 3) | |
222 | *flags |= VORBIS_FLAG_COMMENT; | |
223 | else | |
224 | goto bad_packet; | |
225 | ||
226 | /* Special packets have no duration. */ | |
227 | return 0; | |
228 | ||
229 | bad_packet: | |
230 | av_log(s->avctx, AV_LOG_ERROR, "Invalid packet\n"); | |
231 | return AVERROR_INVALIDDATA; | |
232 | } | |
233 | if (s->mode_count == 1) | |
234 | mode = 0; | |
235 | else | |
236 | mode = (buf[0] & s->mode_mask) >> 1; | |
237 | if (mode >= s->mode_count) { | |
238 | av_log(s->avctx, AV_LOG_ERROR, "Invalid mode in packet\n"); | |
239 | return AVERROR_INVALIDDATA; | |
240 | } | |
241 | if(s->mode_blocksize[mode]){ | |
242 | int flag = !!(buf[0] & s->prev_mask); | |
243 | previous_blocksize = s->blocksize[flag]; | |
244 | } | |
245 | current_blocksize = s->blocksize[s->mode_blocksize[mode]]; | |
246 | duration = (previous_blocksize + current_blocksize) >> 2; | |
247 | s->previous_blocksize = current_blocksize; | |
248 | } | |
249 | ||
250 | return duration; | |
251 | } | |
252 | ||
253 | int avpriv_vorbis_parse_frame(VorbisParseContext *s, const uint8_t *buf, | |
254 | int buf_size) | |
255 | { | |
256 | return avpriv_vorbis_parse_frame_flags(s, buf, buf_size, NULL); | |
257 | } | |
258 | ||
259 | void avpriv_vorbis_parse_reset(VorbisParseContext *s) | |
260 | { | |
261 | if (s->valid_extradata) | |
262 | s->previous_blocksize = s->blocksize[0]; | |
263 | } | |
264 | ||
265 | #if CONFIG_VORBIS_PARSER | |
266 | static int vorbis_parse(AVCodecParserContext *s1, AVCodecContext *avctx, | |
267 | const uint8_t **poutbuf, int *poutbuf_size, | |
268 | const uint8_t *buf, int buf_size) | |
269 | { | |
270 | VorbisParseContext *s = s1->priv_data; | |
271 | int duration; | |
272 | ||
273 | if (!s->extradata_parsed && avctx->extradata && avctx->extradata_size) | |
274 | if (avpriv_vorbis_parse_extradata(avctx, s)) | |
275 | goto end; | |
276 | ||
277 | if ((duration = avpriv_vorbis_parse_frame(s, buf, buf_size)) >= 0) | |
278 | s1->duration = duration; | |
279 | ||
280 | end: | |
281 | /* always return the full packet. this parser isn't doing any splitting or | |
282 | combining, only packet analysis */ | |
283 | *poutbuf = buf; | |
284 | *poutbuf_size = buf_size; | |
285 | return buf_size; | |
286 | } | |
287 | ||
288 | AVCodecParser ff_vorbis_parser = { | |
289 | .codec_ids = { AV_CODEC_ID_VORBIS }, | |
290 | .priv_data_size = sizeof(VorbisParseContext), | |
291 | .parser_parse = vorbis_parse, | |
292 | }; | |
293 | #endif /* CONFIG_VORBIS_PARSER */ |