Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * Sony OpenMG (OMA) demuxer | ||
3 | * | ||
4 | * Copyright (c) 2008, 2013 Maxim Poliakovski | ||
5 | * 2008 Benjamin Larsson | ||
6 | * 2011 David Goldwich | ||
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 | /** | ||
26 | * @file | ||
27 | * This is a demuxer for Sony OpenMG Music files | ||
28 | * | ||
29 | * Known file extensions: ".oma", "aa3" | ||
30 | * The format of such files consists of three parts: | ||
31 | * - "ea3" header carrying overall info and metadata. Except for starting with | ||
32 | * "ea" instead of "ID", it's an ID3v2 header. | ||
33 | * - "EA3" header is a Sony-specific header containing information about | ||
34 | * the OpenMG file: codec type (usually ATRAC, can also be MP3 or WMA), | ||
35 | * codec specific info (packet size, sample rate, channels and so on) | ||
36 | * and DRM related info (file encryption, content id). | ||
37 | * - Sound data organized in packets follow the EA3 header | ||
38 | * (can be encrypted using the Sony DRM!). | ||
39 | * | ||
40 | * Supported decoders: ATRAC3, ATRAC3+, MP3, LPCM | ||
41 | */ | ||
42 | |||
43 | #include <inttypes.h> | ||
44 | |||
45 | #include "libavutil/channel_layout.h" | ||
46 | #include "libavutil/mem.h" | ||
47 | #include "avformat.h" | ||
48 | #include "demux.h" | ||
49 | #include "internal.h" | ||
50 | #include "libavutil/intreadwrite.h" | ||
51 | #include "libavutil/des.h" | ||
52 | #include "libavutil/mathematics.h" | ||
53 | #include "oma.h" | ||
54 | #include "pcm.h" | ||
55 | #include "id3v2.h" | ||
56 | |||
57 | |||
58 | static const uint64_t leaf_table[] = { | ||
59 | 0xd79e8283acea4620, 0x7a9762f445afd0d8, | ||
60 | 0x354d60a60b8c79f1, 0x584e1cde00b07aee, | ||
61 | 0x1573cd93da7df623, 0x47f98d79620dd535 | ||
62 | }; | ||
63 | |||
64 | /** map ATRAC-X channel id to internal channel layout */ | ||
65 | static const AVChannelLayout oma_chid_to_native_layout[7] = { | ||
66 | AV_CHANNEL_LAYOUT_MONO, | ||
67 | AV_CHANNEL_LAYOUT_STEREO, | ||
68 | AV_CHANNEL_LAYOUT_SURROUND, | ||
69 | AV_CHANNEL_LAYOUT_4POINT0, | ||
70 | AV_CHANNEL_LAYOUT_5POINT1_BACK, | ||
71 | AV_CHANNEL_LAYOUT_6POINT1_BACK, | ||
72 | AV_CHANNEL_LAYOUT_7POINT1 | ||
73 | }; | ||
74 | |||
75 | typedef struct OMAContext { | ||
76 | uint64_t content_start; | ||
77 | int encrypted; | ||
78 | uint16_t k_size; | ||
79 | uint16_t e_size; | ||
80 | uint16_t i_size; | ||
81 | uint16_t s_size; | ||
82 | uint32_t rid; | ||
83 | uint8_t r_val[24]; | ||
84 | uint8_t n_val[24]; | ||
85 | uint8_t m_val[8]; | ||
86 | uint8_t s_val[8]; | ||
87 | uint8_t sm_val[8]; | ||
88 | uint8_t e_val[8]; | ||
89 | uint8_t iv[8]; | ||
90 | struct AVDES *av_des; | ||
91 | |||
92 | int (*read_packet)(AVFormatContext *s, AVPacket *pkt); | ||
93 | } OMAContext; | ||
94 | |||
95 | 7 | static int oma_read_close(AVFormatContext *s) | |
96 | { | ||
97 | 7 | OMAContext *oc = s->priv_data; | |
98 | 7 | av_freep(&oc->av_des); | |
99 | 7 | return 0; | |
100 | } | ||
101 | |||
102 | ✗ | static void hex_log(AVFormatContext *s, int level, | |
103 | const char *name, const uint8_t *value, int len) | ||
104 | { | ||
105 | char buf[33]; | ||
106 | ✗ | len = FFMIN(len, 16); | |
107 | ✗ | if (av_log_get_level() < level) | |
108 | ✗ | return; | |
109 | ✗ | ff_data_to_hex(buf, value, len, 1); | |
110 | ✗ | av_log(s, level, "%s: %s\n", name, buf); | |
111 | } | ||
112 | |||
113 | ✗ | static int kset(AVFormatContext *s, const uint8_t *r_val, const uint8_t *n_val, | |
114 | int len) | ||
115 | { | ||
116 | ✗ | OMAContext *oc = s->priv_data; | |
117 | |||
118 | ✗ | if (!r_val && !n_val) | |
119 | ✗ | return -1; | |
120 | |||
121 | ✗ | len = FFMIN(len, 16); | |
122 | |||
123 | /* use first 64 bits in the third round again */ | ||
124 | ✗ | if (r_val) { | |
125 | ✗ | if (r_val != oc->r_val) { | |
126 | ✗ | memset(oc->r_val, 0, 24); | |
127 | ✗ | memcpy(oc->r_val, r_val, len); | |
128 | } | ||
129 | ✗ | memcpy(&oc->r_val[16], r_val, 8); | |
130 | } | ||
131 | ✗ | if (n_val) { | |
132 | ✗ | if (n_val != oc->n_val) { | |
133 | ✗ | memset(oc->n_val, 0, 24); | |
134 | ✗ | memcpy(oc->n_val, n_val, len); | |
135 | } | ||
136 | ✗ | memcpy(&oc->n_val[16], n_val, 8); | |
137 | } | ||
138 | |||
139 | ✗ | return 0; | |
140 | } | ||
141 | |||
142 | #define OMA_RPROBE_M_VAL 48 + 1 | ||
143 | |||
144 | ✗ | static int rprobe(AVFormatContext *s, uint8_t *enc_header, unsigned size, | |
145 | const uint8_t *r_val) | ||
146 | { | ||
147 | ✗ | OMAContext *oc = s->priv_data; | |
148 | unsigned int pos; | ||
149 | struct AVDES *av_des; | ||
150 | |||
151 | ✗ | if (!enc_header || !r_val || | |
152 | ✗ | size < OMA_ENC_HEADER_SIZE + oc->k_size + oc->e_size + oc->i_size || | |
153 | size < OMA_RPROBE_M_VAL) | ||
154 | ✗ | return -1; | |
155 | |||
156 | ✗ | av_des = av_des_alloc(); | |
157 | ✗ | if (!av_des) | |
158 | ✗ | return AVERROR(ENOMEM); | |
159 | |||
160 | /* m_val */ | ||
161 | ✗ | av_des_init(av_des, r_val, 192, 1); | |
162 | ✗ | av_des_crypt(av_des, oc->m_val, &enc_header[48], 1, NULL, 1); | |
163 | |||
164 | /* s_val */ | ||
165 | ✗ | av_des_init(av_des, oc->m_val, 64, 0); | |
166 | ✗ | av_des_crypt(av_des, oc->s_val, NULL, 1, NULL, 0); | |
167 | |||
168 | /* sm_val */ | ||
169 | ✗ | pos = OMA_ENC_HEADER_SIZE + oc->k_size + oc->e_size; | |
170 | ✗ | av_des_init(av_des, oc->s_val, 64, 0); | |
171 | ✗ | av_des_mac(av_des, oc->sm_val, &enc_header[pos], (oc->i_size >> 3)); | |
172 | |||
173 | ✗ | pos += oc->i_size; | |
174 | |||
175 | ✗ | av_free(av_des); | |
176 | |||
177 | ✗ | return memcmp(&enc_header[pos], oc->sm_val, 8) ? -1 : 0; | |
178 | } | ||
179 | |||
180 | ✗ | static int nprobe(AVFormatContext *s, uint8_t *enc_header, unsigned size, | |
181 | const uint8_t *n_val) | ||
182 | { | ||
183 | ✗ | OMAContext *oc = s->priv_data; | |
184 | uint64_t pos; | ||
185 | uint32_t taglen, datalen; | ||
186 | struct AVDES *av_des; | ||
187 | |||
188 | ✗ | if (!enc_header || !n_val || | |
189 | ✗ | size < OMA_ENC_HEADER_SIZE + oc->k_size + 4) | |
190 | ✗ | return -1; | |
191 | |||
192 | ✗ | pos = OMA_ENC_HEADER_SIZE + oc->k_size; | |
193 | ✗ | if (!memcmp(&enc_header[pos], "EKB ", 4)) | |
194 | ✗ | pos += 32; | |
195 | |||
196 | ✗ | if (size < pos + 44) | |
197 | ✗ | return -1; | |
198 | |||
199 | ✗ | if (AV_RB32(&enc_header[pos]) != oc->rid) | |
200 | ✗ | av_log(s, AV_LOG_DEBUG, "Mismatching RID\n"); | |
201 | |||
202 | ✗ | taglen = AV_RB32(&enc_header[pos + 32]); | |
203 | ✗ | datalen = AV_RB32(&enc_header[pos + 36]) >> 4; | |
204 | |||
205 | ✗ | pos += 44LL + taglen; | |
206 | |||
207 | ✗ | if (pos + (((uint64_t)datalen) << 4) > size) | |
208 | ✗ | return -1; | |
209 | |||
210 | ✗ | av_des = av_des_alloc(); | |
211 | ✗ | if (!av_des) | |
212 | ✗ | return AVERROR(ENOMEM); | |
213 | |||
214 | ✗ | av_des_init(av_des, n_val, 192, 1); | |
215 | ✗ | while (datalen-- > 0) { | |
216 | ✗ | av_des_crypt(av_des, oc->r_val, &enc_header[pos], 2, NULL, 1); | |
217 | ✗ | kset(s, oc->r_val, NULL, 16); | |
218 | ✗ | if (!rprobe(s, enc_header, size, oc->r_val)) { | |
219 | ✗ | av_free(av_des); | |
220 | ✗ | return 0; | |
221 | } | ||
222 | ✗ | pos += 16; | |
223 | } | ||
224 | |||
225 | ✗ | av_free(av_des); | |
226 | ✗ | return -1; | |
227 | } | ||
228 | |||
229 | ✗ | static int decrypt_init(AVFormatContext *s, ID3v2ExtraMeta *em, uint8_t *header) | |
230 | { | ||
231 | ✗ | OMAContext *oc = s->priv_data; | |
232 | ✗ | ID3v2ExtraMetaGEOB *geob = NULL; | |
233 | uint8_t *gdata; | ||
234 | |||
235 | ✗ | oc->encrypted = 1; | |
236 | ✗ | av_log(s, AV_LOG_INFO, "File is encrypted\n"); | |
237 | |||
238 | /* find GEOB metadata */ | ||
239 | ✗ | for (; em; em = em->next) { | |
240 | ✗ | if (strcmp(em->tag, "GEOB")) | |
241 | ✗ | continue; | |
242 | ✗ | geob = &em->data.geob; | |
243 | ✗ | if (!strcmp(geob->description, "OMG_LSI") || | |
244 | ✗ | !strcmp(geob->description, "OMG_BKLSI")) | |
245 | break; | ||
246 | } | ||
247 | ✗ | if (!em) { | |
248 | ✗ | av_log(s, AV_LOG_ERROR, "No encryption header found\n"); | |
249 | ✗ | return AVERROR_INVALIDDATA; | |
250 | } | ||
251 | |||
252 | ✗ | if (geob->datasize < 64) { | |
253 | ✗ | av_log(s, AV_LOG_ERROR, | |
254 | "Invalid GEOB data size: %"PRIu32"\n", geob->datasize); | ||
255 | ✗ | return AVERROR_INVALIDDATA; | |
256 | } | ||
257 | |||
258 | ✗ | gdata = geob->data; | |
259 | |||
260 | ✗ | if (AV_RB16(gdata) != 1) | |
261 | ✗ | av_log(s, AV_LOG_WARNING, "Unknown version in encryption header\n"); | |
262 | |||
263 | ✗ | oc->k_size = AV_RB16(&gdata[2]); | |
264 | ✗ | oc->e_size = AV_RB16(&gdata[4]); | |
265 | ✗ | oc->i_size = AV_RB16(&gdata[6]); | |
266 | ✗ | oc->s_size = AV_RB16(&gdata[8]); | |
267 | |||
268 | ✗ | if (memcmp(&gdata[OMA_ENC_HEADER_SIZE], "KEYRING ", 12)) { | |
269 | ✗ | av_log(s, AV_LOG_ERROR, "Invalid encryption header\n"); | |
270 | ✗ | return AVERROR_INVALIDDATA; | |
271 | } | ||
272 | ✗ | if (OMA_ENC_HEADER_SIZE + oc->k_size + oc->e_size + oc->i_size + 8 > geob->datasize || | |
273 | ✗ | OMA_ENC_HEADER_SIZE + 48 > geob->datasize) { | |
274 | ✗ | av_log(s, AV_LOG_ERROR, "Too little GEOB data\n"); | |
275 | ✗ | return AVERROR_INVALIDDATA; | |
276 | } | ||
277 | ✗ | oc->rid = AV_RB32(&gdata[OMA_ENC_HEADER_SIZE + 28]); | |
278 | ✗ | av_log(s, AV_LOG_DEBUG, "RID: %.8"PRIx32"\n", oc->rid); | |
279 | |||
280 | ✗ | memcpy(oc->iv, &header[0x58], 8); | |
281 | ✗ | hex_log(s, AV_LOG_DEBUG, "IV", oc->iv, 8); | |
282 | |||
283 | ✗ | hex_log(s, AV_LOG_DEBUG, "CBC-MAC", | |
284 | ✗ | &gdata[OMA_ENC_HEADER_SIZE + oc->k_size + oc->e_size + oc->i_size], | |
285 | 8); | ||
286 | |||
287 | ✗ | if (s->keylen > 0) { | |
288 | ✗ | kset(s, s->key, s->key, s->keylen); | |
289 | } | ||
290 | ✗ | if (!memcmp(oc->r_val, (const uint8_t[8]){0}, 8) || | |
291 | ✗ | rprobe(s, gdata, geob->datasize, oc->r_val) < 0 && | |
292 | ✗ | nprobe(s, gdata, geob->datasize, oc->n_val) < 0) { | |
293 | int i; | ||
294 | ✗ | for (i = 0; i < FF_ARRAY_ELEMS(leaf_table); i += 2) { | |
295 | uint8_t buf[16]; | ||
296 | ✗ | AV_WL64(buf, leaf_table[i]); | |
297 | ✗ | AV_WL64(&buf[8], leaf_table[i + 1]); | |
298 | ✗ | kset(s, buf, buf, 16); | |
299 | ✗ | if (!rprobe(s, gdata, geob->datasize, oc->r_val) || | |
300 | ✗ | !nprobe(s, gdata, geob->datasize, oc->n_val)) | |
301 | break; | ||
302 | } | ||
303 | ✗ | if (i >= FF_ARRAY_ELEMS(leaf_table)) { | |
304 | ✗ | av_log(s, AV_LOG_ERROR, "Invalid key\n"); | |
305 | ✗ | return AVERROR_INVALIDDATA; | |
306 | } | ||
307 | } | ||
308 | |||
309 | ✗ | oc->av_des = av_des_alloc(); | |
310 | ✗ | if (!oc->av_des) | |
311 | ✗ | return AVERROR(ENOMEM); | |
312 | |||
313 | /* e_val */ | ||
314 | ✗ | av_des_init(oc->av_des, oc->m_val, 64, 0); | |
315 | ✗ | av_des_crypt(oc->av_des, oc->e_val, | |
316 | ✗ | &gdata[OMA_ENC_HEADER_SIZE + 40], 1, NULL, 0); | |
317 | ✗ | hex_log(s, AV_LOG_DEBUG, "EK", oc->e_val, 8); | |
318 | |||
319 | /* init e_val */ | ||
320 | ✗ | av_des_init(oc->av_des, oc->e_val, 64, 1); | |
321 | |||
322 | ✗ | return 0; | |
323 | } | ||
324 | |||
325 | 2645 | static int read_packet(AVFormatContext *s, AVPacket *pkt) | |
326 | { | ||
327 | 2645 | OMAContext *oc = s->priv_data; | |
328 | 2645 | AVStream *st = s->streams[0]; | |
329 | 2645 | int packet_size = st->codecpar->block_align; | |
330 | 2645 | int byte_rate = st->codecpar->bit_rate >> 3; | |
331 | 2645 | int64_t pos = avio_tell(s->pb); | |
332 | 2645 | int ret = av_get_packet(s->pb, pkt, packet_size); | |
333 | |||
334 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 2639 times.
|
2645 | if (ret < packet_size) |
335 | 6 | pkt->flags |= AV_PKT_FLAG_CORRUPT; | |
336 | |||
337 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2641 times.
|
2645 | if (ret < 0) |
338 | 4 | return ret; | |
339 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2641 times.
|
2641 | if (!ret) |
340 | ✗ | return AVERROR_EOF; | |
341 | |||
342 | 2641 | pkt->stream_index = 0; | |
343 | |||
344 |
2/4✓ Branch 0 taken 2641 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2641 times.
✗ Branch 3 not taken.
|
2641 | if (pos >= oc->content_start && byte_rate > 0) { |
345 | 2641 | pkt->pts = | |
346 | 2641 | pkt->dts = av_rescale(pos - oc->content_start, st->time_base.den, | |
347 | 2641 | byte_rate * (int64_t)st->time_base.num); | |
348 | } | ||
349 | |||
350 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2641 times.
|
2641 | if (oc->encrypted) { |
351 | /* previous unencrypted block saved in IV for | ||
352 | * the next packet (CBC mode) */ | ||
353 | ✗ | if (ret == packet_size) | |
354 | ✗ | av_des_crypt(oc->av_des, pkt->data, pkt->data, | |
355 | ✗ | (packet_size >> 3), oc->iv, 1); | |
356 | else | ||
357 | ✗ | memset(oc->iv, 0, 8); | |
358 | } | ||
359 | |||
360 | 2641 | return ret; | |
361 | } | ||
362 | |||
363 | ✗ | static int aal_read_packet(AVFormatContext *s, AVPacket *pkt) | |
364 | { | ||
365 | ✗ | int64_t pos = avio_tell(s->pb); | |
366 | int ret, pts; | ||
367 | int packet_size; | ||
368 | unsigned tag; | ||
369 | |||
370 | ✗ | if (avio_feof(s->pb)) | |
371 | ✗ | return AVERROR_EOF; | |
372 | |||
373 | ✗ | tag = avio_rb24(s->pb); | |
374 | ✗ | if (tag == 0) | |
375 | ✗ | return AVERROR_EOF; | |
376 | ✗ | else if (tag != MKBETAG(0,'B','L','K')) | |
377 | ✗ | return AVERROR_INVALIDDATA; | |
378 | |||
379 | ✗ | avio_skip(s->pb, 1); | |
380 | ✗ | packet_size = avio_rb16(s->pb); | |
381 | ✗ | avio_skip(s->pb, 2); | |
382 | ✗ | pts = avio_rb32(s->pb); | |
383 | ✗ | avio_skip(s->pb, 12); | |
384 | ✗ | ret = av_get_packet(s->pb, pkt, packet_size); | |
385 | ✗ | if (ret < packet_size) | |
386 | ✗ | pkt->flags |= AV_PKT_FLAG_CORRUPT; | |
387 | |||
388 | ✗ | if (ret < 0) | |
389 | ✗ | return ret; | |
390 | ✗ | if (!ret) | |
391 | ✗ | return AVERROR_EOF; | |
392 | |||
393 | ✗ | pkt->stream_index = 0; | |
394 | ✗ | pkt->pos = pos; | |
395 | ✗ | if (s->streams[0]->codecpar->codec_id == AV_CODEC_ID_ATRAC3AL) { | |
396 | ✗ | pkt->duration = 1024; | |
397 | ✗ | pkt->pts = pts * 1024LL; | |
398 | } else { | ||
399 | ✗ | pkt->duration = 2048; | |
400 | ✗ | pkt->pts = pts * 2048LL; | |
401 | } | ||
402 | |||
403 | ✗ | return ret; | |
404 | } | ||
405 | |||
406 | 7 | static int oma_read_header(AVFormatContext *s) | |
407 | { | ||
408 | int ret, framesize, jsflag, samplerate; | ||
409 | uint32_t codec_params, channel_id; | ||
410 | int16_t eid; | ||
411 | uint8_t buf[EA3_HEADER_SIZE]; | ||
412 | uint8_t *edata; | ||
413 | AVStream *st; | ||
414 | ID3v2ExtraMeta *extra_meta; | ||
415 | 7 | OMAContext *oc = s->priv_data; | |
416 | |||
417 | 7 | ff_id3v2_read(s, ID3v2_EA3_MAGIC, &extra_meta, 0); | |
418 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 7 times.
|
7 | if ((ret = ff_id3v2_parse_chapters(s, extra_meta)) < 0) { |
419 | ✗ | ff_id3v2_free_extra_meta(&extra_meta); | |
420 | ✗ | return ret; | |
421 | } | ||
422 | |||
423 | 7 | ret = avio_read(s->pb, buf, EA3_HEADER_SIZE); | |
424 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
|
7 | if (ret < EA3_HEADER_SIZE) { |
425 | ✗ | ff_id3v2_free_extra_meta(&extra_meta); | |
426 | ✗ | return -1; | |
427 | } | ||
428 | |||
429 |
1/2✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
|
7 | if (memcmp(buf, ((const uint8_t[]){'E', 'A', '3'}), 3) || |
430 |
2/4✓ Branch 0 taken 7 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 7 times.
|
7 | buf[4] != 0 || buf[5] != EA3_HEADER_SIZE) { |
431 | ✗ | ff_id3v2_free_extra_meta(&extra_meta); | |
432 | ✗ | av_log(s, AV_LOG_ERROR, "Couldn't find the EA3 header !\n"); | |
433 | ✗ | return AVERROR_INVALIDDATA; | |
434 | } | ||
435 | |||
436 | 7 | oc->content_start = avio_tell(s->pb); | |
437 | |||
438 | /* encrypted file */ | ||
439 | 7 | eid = AV_RB16(&buf[6]); | |
440 |
1/6✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
|
7 | if (eid != -1 && eid != -128 && decrypt_init(s, extra_meta, buf) < 0) { |
441 | ✗ | ff_id3v2_free_extra_meta(&extra_meta); | |
442 | ✗ | return -1; | |
443 | } | ||
444 | |||
445 | 7 | ff_id3v2_free_extra_meta(&extra_meta); | |
446 | |||
447 | 7 | codec_params = AV_RB24(&buf[33]); | |
448 | |||
449 | 7 | st = avformat_new_stream(s, NULL); | |
450 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7 times.
|
7 | if (!st) |
451 | ✗ | return AVERROR(ENOMEM); | |
452 | |||
453 | 7 | st->start_time = 0; | |
454 | 7 | st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO; | |
455 | 7 | st->codecpar->codec_tag = buf[32]; | |
456 | 14 | st->codecpar->codec_id = ff_codec_get_id(ff_oma_codec_tags, | |
457 | 7 | st->codecpar->codec_tag); | |
458 | |||
459 | 7 | oc->read_packet = read_packet; | |
460 | |||
461 |
2/7✓ Branch 0 taken 2 times.
✓ Branch 1 taken 5 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
|
7 | switch (buf[32]) { |
462 | 2 | case OMA_CODECID_ATRAC3: | |
463 | 2 | samplerate = ff_oma_srate_tab[(codec_params >> 13) & 7] * 100; | |
464 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (!samplerate) { |
465 | ✗ | av_log(s, AV_LOG_ERROR, "Unsupported sample rate\n"); | |
466 | ✗ | return AVERROR_INVALIDDATA; | |
467 | } | ||
468 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (samplerate != 44100) |
469 | ✗ | avpriv_request_sample(s, "Sample rate %d", samplerate); | |
470 | |||
471 | 2 | framesize = (codec_params & 0x3FF) * 8; | |
472 | |||
473 | /* get stereo coding mode, 1 for joint-stereo */ | ||
474 | 2 | jsflag = (codec_params >> 17) & 1; | |
475 | |||
476 | 2 | st->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO; | |
477 | 2 | st->codecpar->sample_rate = samplerate; | |
478 | 2 | st->codecpar->bit_rate = st->codecpar->sample_rate * framesize / (1024 / 8); | |
479 | |||
480 | /* fake the ATRAC3 extradata | ||
481 | * (wav format, makes stream copy to wav work) */ | ||
482 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
|
2 | if ((ret = ff_alloc_extradata(st->codecpar, 14)) < 0) |
483 | ✗ | return ret; | |
484 | |||
485 | 2 | edata = st->codecpar->extradata; | |
486 | 2 | AV_WL16(&edata[0], 1); // always 1 | |
487 | 2 | AV_WL32(&edata[2], samplerate); // samples rate | |
488 | 2 | AV_WL16(&edata[6], jsflag); // coding mode | |
489 | 2 | AV_WL16(&edata[8], jsflag); // coding mode | |
490 | 2 | AV_WL16(&edata[10], 1); // always 1 | |
491 | 2 | AV_WL16(&edata[12], 0); // always 0 | |
492 | |||
493 | 2 | avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate); | |
494 | 2 | break; | |
495 | 5 | case OMA_CODECID_ATRAC3P: | |
496 | 5 | channel_id = (codec_params >> 10) & 7; | |
497 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
|
5 | if (!channel_id) { |
498 | ✗ | av_log(s, AV_LOG_ERROR, | |
499 | "Invalid ATRAC-X channel id: %"PRIu32"\n", channel_id); | ||
500 | ✗ | return AVERROR_INVALIDDATA; | |
501 | } | ||
502 | 5 | av_channel_layout_copy(&st->codecpar->ch_layout, | |
503 | 5 | &oma_chid_to_native_layout[channel_id - 1]); | |
504 | 5 | framesize = ((codec_params & 0x3FF) * 8) + 8; | |
505 | 5 | samplerate = ff_oma_srate_tab[(codec_params >> 13) & 7] * 100; | |
506 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
|
5 | if (!samplerate) { |
507 | ✗ | av_log(s, AV_LOG_ERROR, "Unsupported sample rate\n"); | |
508 | ✗ | return AVERROR_INVALIDDATA; | |
509 | } | ||
510 | 5 | st->codecpar->sample_rate = samplerate; | |
511 | 5 | st->codecpar->bit_rate = samplerate * framesize / (2048 / 8); | |
512 | 5 | avpriv_set_pts_info(st, 64, 1, samplerate); | |
513 | 5 | break; | |
514 | ✗ | case OMA_CODECID_AAC: | |
515 | case OMA_CODECID_MP3: | ||
516 | ✗ | ffstream(st)->need_parsing = AVSTREAM_PARSE_FULL_RAW; | |
517 | ✗ | framesize = 1024; | |
518 | ✗ | break; | |
519 | ✗ | case OMA_CODECID_LPCM: | |
520 | /* PCM 44.1 kHz 16 bit stereo big-endian */ | ||
521 | ✗ | st->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO; | |
522 | ✗ | st->codecpar->sample_rate = 44100; | |
523 | ✗ | framesize = 1024; | |
524 | /* bit rate = sample rate x PCM block align (= 4) x 8 */ | ||
525 | ✗ | st->codecpar->bit_rate = st->codecpar->sample_rate * 32; | |
526 | ✗ | st->codecpar->bits_per_coded_sample = | |
527 | ✗ | av_get_bits_per_sample(st->codecpar->codec_id); | |
528 | ✗ | avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate); | |
529 | ✗ | break; | |
530 | ✗ | case OMA_CODECID_ATRAC3AL: | |
531 | ✗ | st->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO; | |
532 | ✗ | st->codecpar->sample_rate = 44100; | |
533 | ✗ | avpriv_set_pts_info(st, 64, 1, 44100); | |
534 | ✗ | oc->read_packet = aal_read_packet; | |
535 | ✗ | framesize = 4096; | |
536 | ✗ | break; | |
537 | ✗ | case OMA_CODECID_ATRAC3PAL: | |
538 | ✗ | st->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO; | |
539 | ✗ | st->codecpar->sample_rate = 44100; | |
540 | ✗ | avpriv_set_pts_info(st, 64, 1, 44100); | |
541 | ✗ | oc->read_packet = aal_read_packet; | |
542 | ✗ | framesize = 4096; | |
543 | ✗ | break; | |
544 | ✗ | default: | |
545 | ✗ | av_log(s, AV_LOG_ERROR, "Unsupported codec %d!\n", buf[32]); | |
546 | ✗ | return AVERROR(ENOSYS); | |
547 | } | ||
548 | |||
549 | 7 | st->codecpar->block_align = framesize; | |
550 | |||
551 | 7 | return 0; | |
552 | } | ||
553 | |||
554 | 2645 | static int oma_read_packet(AVFormatContext *s, AVPacket *pkt) | |
555 | { | ||
556 | 2645 | OMAContext *oc = s->priv_data; | |
557 | 2645 | return oc->read_packet(s, pkt); | |
558 | } | ||
559 | |||
560 | 7186 | static int oma_read_probe(const AVProbeData *p) | |
561 | { | ||
562 | 7186 | const uint8_t *buf = p->buf; | |
563 | 7186 | unsigned tag_len = 0; | |
564 | |||
565 |
3/4✓ Branch 0 taken 7186 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 7180 times.
|
7186 | if (p->buf_size >= ID3v2_HEADER_SIZE && ff_id3v2_match(buf, ID3v2_EA3_MAGIC)) |
566 | 6 | tag_len = ff_id3v2_tag_len(buf); | |
567 | |||
568 | /* This check cannot overflow as tag_len has at most 28 bits */ | ||
569 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 7185 times.
|
7186 | if (p->buf_size < tag_len + 5) |
570 | /* EA3 header comes late, might be outside of the probe buffer */ | ||
571 |
1/2✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
|
1 | return tag_len ? AVPROBE_SCORE_EXTENSION/2 : 0; |
572 | |||
573 | 7185 | buf += tag_len; | |
574 | |||
575 |
4/6✓ Branch 0 taken 6 times.
✓ Branch 1 taken 7179 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
|
7185 | if (!memcmp(buf, "EA3", 3) && !buf[4] && buf[5] == EA3_HEADER_SIZE) |
576 | 6 | return AVPROBE_SCORE_MAX; | |
577 | else | ||
578 | 7179 | return 0; | |
579 | } | ||
580 | |||
581 | ✗ | static int oma_read_seek(struct AVFormatContext *s, | |
582 | int stream_index, int64_t timestamp, int flags) | ||
583 | { | ||
584 | ✗ | OMAContext *oc = s->priv_data; | |
585 | ✗ | AVStream *st = s->streams[0]; | |
586 | int64_t err; | ||
587 | |||
588 | ✗ | if (st->codecpar->codec_id == AV_CODEC_ID_ATRAC3PAL || | |
589 | ✗ | st->codecpar->codec_id == AV_CODEC_ID_ATRAC3AL) | |
590 | ✗ | return -1; | |
591 | |||
592 | ✗ | err = ff_pcm_read_seek(s, stream_index, timestamp, flags); | |
593 | ✗ | if (!oc->encrypted) | |
594 | ✗ | return err; | |
595 | |||
596 | /* readjust IV for CBC */ | ||
597 | ✗ | if (err || avio_tell(s->pb) < oc->content_start) | |
598 | ✗ | goto wipe; | |
599 | ✗ | if ((err = avio_seek(s->pb, -8, SEEK_CUR)) < 0) | |
600 | ✗ | goto wipe; | |
601 | ✗ | if ((err = avio_read(s->pb, oc->iv, 8)) < 8) { | |
602 | ✗ | if (err >= 0) | |
603 | ✗ | err = AVERROR_EOF; | |
604 | ✗ | goto wipe; | |
605 | } | ||
606 | |||
607 | ✗ | return 0; | |
608 | ✗ | wipe: | |
609 | ✗ | memset(oc->iv, 0, 8); | |
610 | ✗ | return err; | |
611 | } | ||
612 | |||
613 | const FFInputFormat ff_oma_demuxer = { | ||
614 | .p.name = "oma", | ||
615 | .p.long_name = NULL_IF_CONFIG_SMALL("Sony OpenMG audio"), | ||
616 | .p.flags = AVFMT_GENERIC_INDEX, | ||
617 | .p.extensions = "oma,omg,aa3", | ||
618 | .p.codec_tag = ff_oma_codec_tags_list, | ||
619 | .priv_data_size = sizeof(OMAContext), | ||
620 | .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP, | ||
621 | .read_probe = oma_read_probe, | ||
622 | .read_header = oma_read_header, | ||
623 | .read_packet = oma_read_packet, | ||
624 | .read_seek = oma_read_seek, | ||
625 | .read_close = oma_read_close, | ||
626 | }; | ||
627 |