ffmpeg / libavformat / asf.c @ 5509bffa
History | View | Annotate | Download (28.7 KB)
1 |
/*
|
---|---|
2 |
* ASF compatible decoder.
|
3 |
* Copyright (c) 2000, 2001 Fabrice Bellard.
|
4 |
*
|
5 |
* This library is free software; you can redistribute it and/or
|
6 |
* modify it under the terms of the GNU Lesser General Public
|
7 |
* License as published by the Free Software Foundation; either
|
8 |
* version 2 of the License, or (at your option) any later version.
|
9 |
*
|
10 |
* This library is distributed in the hope that it will be useful,
|
11 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
12 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
13 |
* Lesser General Public License for more details.
|
14 |
*
|
15 |
* You should have received a copy of the GNU Lesser General Public
|
16 |
* License along with this library; if not, write to the Free Software
|
17 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
18 |
*/
|
19 |
#include "avformat.h" |
20 |
#include "avi.h" |
21 |
#include "mpegaudio.h" |
22 |
#include "asf.h" |
23 |
|
24 |
#undef NDEBUG
|
25 |
#include <assert.h> |
26 |
|
27 |
#define FRAME_HEADER_SIZE 17 |
28 |
// Fix Me! FRAME_HEADER_SIZE may be different.
|
29 |
|
30 |
static const GUID index_guid = { |
31 |
0x33000890, 0xe5b1, 0x11cf, { 0x89, 0xf4, 0x00, 0xa0, 0xc9, 0x03, 0x49, 0xcb }, |
32 |
}; |
33 |
|
34 |
/**********************************/
|
35 |
/* decoding */
|
36 |
|
37 |
//#define DEBUG
|
38 |
|
39 |
#ifdef DEBUG
|
40 |
#define PRINT_IF_GUID(g,cmp) \
|
41 |
if (!memcmp(g, &cmp, sizeof(GUID))) \ |
42 |
printf("(GUID: %s) ", #cmp) |
43 |
|
44 |
static void print_guid(const GUID *g) |
45 |
{ |
46 |
int i;
|
47 |
PRINT_IF_GUID(g, asf_header); |
48 |
else PRINT_IF_GUID(g, file_header);
|
49 |
else PRINT_IF_GUID(g, stream_header);
|
50 |
else PRINT_IF_GUID(g, audio_stream);
|
51 |
else PRINT_IF_GUID(g, audio_conceal_none);
|
52 |
else PRINT_IF_GUID(g, video_stream);
|
53 |
else PRINT_IF_GUID(g, video_conceal_none);
|
54 |
else PRINT_IF_GUID(g, command_stream);
|
55 |
else PRINT_IF_GUID(g, comment_header);
|
56 |
else PRINT_IF_GUID(g, codec_comment_header);
|
57 |
else PRINT_IF_GUID(g, codec_comment1_header);
|
58 |
else PRINT_IF_GUID(g, data_header);
|
59 |
else PRINT_IF_GUID(g, index_guid);
|
60 |
else PRINT_IF_GUID(g, head1_guid);
|
61 |
else PRINT_IF_GUID(g, head2_guid);
|
62 |
else PRINT_IF_GUID(g, my_guid);
|
63 |
else
|
64 |
printf("(GUID: unknown) ");
|
65 |
printf("0x%08x, 0x%04x, 0x%04x, {", g->v1, g->v2, g->v3);
|
66 |
for(i=0;i<8;i++) |
67 |
printf(" 0x%02x,", g->v4[i]);
|
68 |
printf("}\n");
|
69 |
} |
70 |
#undef PRINT_IF_GUID(g,cmp)
|
71 |
#endif
|
72 |
|
73 |
static void get_guid(ByteIOContext *s, GUID *g) |
74 |
{ |
75 |
int i;
|
76 |
|
77 |
g->v1 = get_le32(s); |
78 |
g->v2 = get_le16(s); |
79 |
g->v3 = get_le16(s); |
80 |
for(i=0;i<8;i++) |
81 |
g->v4[i] = get_byte(s); |
82 |
} |
83 |
|
84 |
#if 0
|
85 |
static void get_str16(ByteIOContext *pb, char *buf, int buf_size)
|
86 |
{
|
87 |
int len, c;
|
88 |
char *q;
|
89 |
|
90 |
len = get_le16(pb);
|
91 |
q = buf;
|
92 |
while (len > 0) {
|
93 |
c = get_le16(pb);
|
94 |
if ((q - buf) < buf_size - 1)
|
95 |
*q++ = c;
|
96 |
len--;
|
97 |
}
|
98 |
*q = '\0';
|
99 |
}
|
100 |
#endif
|
101 |
|
102 |
static void get_str16_nolen(ByteIOContext *pb, int len, char *buf, int buf_size) |
103 |
{ |
104 |
int c;
|
105 |
char *q;
|
106 |
|
107 |
q = buf; |
108 |
while (len > 0) { |
109 |
c = get_le16(pb); |
110 |
if ((q - buf) < buf_size - 1) |
111 |
*q++ = c; |
112 |
len-=2;
|
113 |
} |
114 |
*q = '\0';
|
115 |
} |
116 |
|
117 |
static int asf_probe(AVProbeData *pd) |
118 |
{ |
119 |
GUID g; |
120 |
const unsigned char *p; |
121 |
int i;
|
122 |
|
123 |
/* check file header */
|
124 |
if (pd->buf_size <= 32) |
125 |
return 0; |
126 |
p = pd->buf; |
127 |
g.v1 = p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24); |
128 |
p += 4;
|
129 |
g.v2 = p[0] | (p[1] << 8); |
130 |
p += 2;
|
131 |
g.v3 = p[0] | (p[1] << 8); |
132 |
p += 2;
|
133 |
for(i=0;i<8;i++) |
134 |
g.v4[i] = *p++; |
135 |
|
136 |
if (!memcmp(&g, &asf_header, sizeof(GUID))) |
137 |
return AVPROBE_SCORE_MAX;
|
138 |
else
|
139 |
return 0; |
140 |
} |
141 |
|
142 |
static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap) |
143 |
{ |
144 |
ASFContext *asf = s->priv_data; |
145 |
GUID g; |
146 |
ByteIOContext *pb = &s->pb; |
147 |
AVStream *st; |
148 |
ASFStream *asf_st; |
149 |
int size, i;
|
150 |
int64_t gsize; |
151 |
|
152 |
get_guid(pb, &g); |
153 |
if (memcmp(&g, &asf_header, sizeof(GUID))) |
154 |
goto fail;
|
155 |
get_le64(pb); |
156 |
get_le32(pb); |
157 |
get_byte(pb); |
158 |
get_byte(pb); |
159 |
memset(&asf->asfid2avid, -1, sizeof(asf->asfid2avid)); |
160 |
for(;;) {
|
161 |
get_guid(pb, &g); |
162 |
gsize = get_le64(pb); |
163 |
#ifdef DEBUG
|
164 |
printf("%08Lx: ", url_ftell(pb) - 24); |
165 |
print_guid(&g); |
166 |
printf(" size=0x%Lx\n", gsize);
|
167 |
#endif
|
168 |
if (gsize < 24) |
169 |
goto fail;
|
170 |
if (!memcmp(&g, &file_header, sizeof(GUID))) { |
171 |
get_guid(pb, &asf->hdr.guid); |
172 |
asf->hdr.file_size = get_le64(pb); |
173 |
asf->hdr.create_time = get_le64(pb); |
174 |
asf->hdr.packets_count = get_le64(pb); |
175 |
asf->hdr.send_time = get_le64(pb); |
176 |
asf->hdr.play_time = get_le64(pb); |
177 |
asf->hdr.preroll = get_le32(pb); |
178 |
asf->hdr.ignore = get_le32(pb); |
179 |
asf->hdr.flags = get_le32(pb); |
180 |
asf->hdr.min_pktsize = get_le32(pb); |
181 |
asf->hdr.max_pktsize = get_le32(pb); |
182 |
asf->hdr.max_bitrate = get_le32(pb); |
183 |
asf->packet_size = asf->hdr.max_pktsize; |
184 |
asf->nb_packets = asf->hdr.packets_count; |
185 |
} else if (!memcmp(&g, &stream_header, sizeof(GUID))) { |
186 |
int type, total_size, type_specific_size, sizeX;
|
187 |
unsigned int tag1; |
188 |
int64_t pos1, pos2; |
189 |
|
190 |
pos1 = url_ftell(pb); |
191 |
|
192 |
st = av_new_stream(s, 0);
|
193 |
if (!st)
|
194 |
goto fail;
|
195 |
av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */ |
196 |
asf_st = av_mallocz(sizeof(ASFStream));
|
197 |
if (!asf_st)
|
198 |
goto fail;
|
199 |
st->priv_data = asf_st; |
200 |
st->start_time = asf->hdr.preroll; |
201 |
st->duration = asf->hdr.send_time / |
202 |
(10000000 / 1000) - st->start_time; |
203 |
get_guid(pb, &g); |
204 |
if (!memcmp(&g, &audio_stream, sizeof(GUID))) { |
205 |
type = CODEC_TYPE_AUDIO; |
206 |
} else if (!memcmp(&g, &video_stream, sizeof(GUID))) { |
207 |
type = CODEC_TYPE_VIDEO; |
208 |
} else if (!memcmp(&g, &command_stream, sizeof(GUID))) { |
209 |
type = CODEC_TYPE_UNKNOWN; |
210 |
} else {
|
211 |
goto fail;
|
212 |
} |
213 |
get_guid(pb, &g); |
214 |
total_size = get_le64(pb); |
215 |
type_specific_size = get_le32(pb); |
216 |
get_le32(pb); |
217 |
st->id = get_le16(pb) & 0x7f; /* stream id */ |
218 |
// mapping of asf ID to AV stream ID;
|
219 |
asf->asfid2avid[st->id] = s->nb_streams - 1;
|
220 |
|
221 |
get_le32(pb); |
222 |
st->codec->codec_type = type; |
223 |
if (type == CODEC_TYPE_AUDIO) {
|
224 |
get_wav_header(pb, st->codec, type_specific_size); |
225 |
st->need_parsing = 1;
|
226 |
/* We have to init the frame size at some point .... */
|
227 |
pos2 = url_ftell(pb); |
228 |
if (gsize > (pos2 + 8 - pos1 + 24)) { |
229 |
asf_st->ds_span = get_byte(pb); |
230 |
asf_st->ds_packet_size = get_le16(pb); |
231 |
asf_st->ds_chunk_size = get_le16(pb); |
232 |
asf_st->ds_data_size = get_le16(pb); |
233 |
asf_st->ds_silence_data = get_byte(pb); |
234 |
} |
235 |
//printf("Descrambling: ps:%d cs:%d ds:%d s:%d sd:%d\n",
|
236 |
// asf_st->ds_packet_size, asf_st->ds_chunk_size,
|
237 |
// asf_st->ds_data_size, asf_st->ds_span, asf_st->ds_silence_data);
|
238 |
if (asf_st->ds_span > 1) { |
239 |
if (!asf_st->ds_chunk_size
|
240 |
|| (asf_st->ds_packet_size/asf_st->ds_chunk_size <= 1))
|
241 |
asf_st->ds_span = 0; // disable descrambling |
242 |
} |
243 |
switch (st->codec->codec_id) {
|
244 |
case CODEC_ID_MP3:
|
245 |
st->codec->frame_size = MPA_FRAME_SIZE; |
246 |
break;
|
247 |
case CODEC_ID_PCM_S16LE:
|
248 |
case CODEC_ID_PCM_S16BE:
|
249 |
case CODEC_ID_PCM_U16LE:
|
250 |
case CODEC_ID_PCM_U16BE:
|
251 |
case CODEC_ID_PCM_S8:
|
252 |
case CODEC_ID_PCM_U8:
|
253 |
case CODEC_ID_PCM_ALAW:
|
254 |
case CODEC_ID_PCM_MULAW:
|
255 |
st->codec->frame_size = 1;
|
256 |
break;
|
257 |
default:
|
258 |
/* This is probably wrong, but it prevents a crash later */
|
259 |
st->codec->frame_size = 1;
|
260 |
break;
|
261 |
} |
262 |
} else {
|
263 |
get_le32(pb); |
264 |
get_le32(pb); |
265 |
get_byte(pb); |
266 |
size = get_le16(pb); /* size */
|
267 |
sizeX= get_le32(pb); /* size */
|
268 |
st->codec->width = get_le32(pb); |
269 |
st->codec->height = get_le32(pb); |
270 |
/* not available for asf */
|
271 |
get_le16(pb); /* panes */
|
272 |
st->codec->bits_per_sample = get_le16(pb); /* depth */
|
273 |
tag1 = get_le32(pb); |
274 |
url_fskip(pb, 20);
|
275 |
// av_log(NULL, AV_LOG_DEBUG, "size:%d tsize:%d sizeX:%d\n", size, total_size, sizeX);
|
276 |
size= sizeX; |
277 |
if (size > 40) { |
278 |
st->codec->extradata_size = size - 40;
|
279 |
st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); |
280 |
get_buffer(pb, st->codec->extradata, st->codec->extradata_size); |
281 |
} |
282 |
|
283 |
/* Extract palette from extradata if bpp <= 8 */
|
284 |
/* This code assumes that extradata contains only palette */
|
285 |
/* This is true for all paletted codecs implemented in ffmpeg */
|
286 |
if (st->codec->extradata_size && (st->codec->bits_per_sample <= 8)) { |
287 |
st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl));
|
288 |
#ifdef WORDS_BIGENDIAN
|
289 |
for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++) |
290 |
st->codec->palctrl->palette[i] = bswap_32(((uint32_t*)st->codec->extradata)[i]); |
291 |
#else
|
292 |
memcpy(st->codec->palctrl->palette, st->codec->extradata, |
293 |
FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)); |
294 |
#endif
|
295 |
st->codec->palctrl->palette_changed = 1;
|
296 |
} |
297 |
|
298 |
st->codec->codec_tag = tag1; |
299 |
st->codec->codec_id = codec_get_id(codec_bmp_tags, tag1); |
300 |
if(tag1 == MKTAG('D', 'V', 'R', ' ')) |
301 |
st->need_parsing = 1;
|
302 |
} |
303 |
pos2 = url_ftell(pb); |
304 |
url_fskip(pb, gsize - (pos2 - pos1 + 24));
|
305 |
} else if (!memcmp(&g, &data_header, sizeof(GUID))) { |
306 |
break;
|
307 |
} else if (!memcmp(&g, &comment_header, sizeof(GUID))) { |
308 |
int len1, len2, len3, len4, len5;
|
309 |
|
310 |
len1 = get_le16(pb); |
311 |
len2 = get_le16(pb); |
312 |
len3 = get_le16(pb); |
313 |
len4 = get_le16(pb); |
314 |
len5 = get_le16(pb); |
315 |
get_str16_nolen(pb, len1, s->title, sizeof(s->title));
|
316 |
get_str16_nolen(pb, len2, s->author, sizeof(s->author));
|
317 |
get_str16_nolen(pb, len3, s->copyright, sizeof(s->copyright));
|
318 |
get_str16_nolen(pb, len4, s->comment, sizeof(s->comment));
|
319 |
url_fskip(pb, len5); |
320 |
} else if (!memcmp(&g, &extended_content_header, sizeof(GUID))) { |
321 |
int desc_count, i;
|
322 |
|
323 |
desc_count = get_le16(pb); |
324 |
for(i=0;i<desc_count;i++) |
325 |
{ |
326 |
int name_len,value_type,value_len,value_num = 0; |
327 |
char *name, *value;
|
328 |
|
329 |
name_len = get_le16(pb); |
330 |
name = (char *)av_mallocz(name_len);
|
331 |
get_str16_nolen(pb, name_len, name, name_len); |
332 |
value_type = get_le16(pb); |
333 |
value_len = get_le16(pb); |
334 |
if ((value_type == 0) || (value_type == 1)) // unicode or byte |
335 |
{ |
336 |
value = (char *)av_mallocz(value_len);
|
337 |
get_str16_nolen(pb, value_len, value, value_len); |
338 |
if (strcmp(name,"WM/AlbumTitle")==0) { pstrcpy(s->album, sizeof(s->album), value); } |
339 |
av_free(value); |
340 |
} |
341 |
if ((value_type >= 2) && (value_type <= 5)) // boolean or DWORD or QWORD or WORD |
342 |
{ |
343 |
if (value_type==2) value_num = get_le32(pb); |
344 |
if (value_type==3) value_num = get_le32(pb); |
345 |
if (value_type==4) value_num = get_le64(pb); |
346 |
if (value_type==5) value_num = get_le16(pb); |
347 |
if (strcmp(name,"WM/Track")==0) s->track = value_num + 1; |
348 |
if (strcmp(name,"WM/TrackNumber")==0) s->track = value_num; |
349 |
} |
350 |
av_free(name); |
351 |
} |
352 |
#if 0
|
353 |
} else if (!memcmp(&g, &head1_guid, sizeof(GUID))) {
|
354 |
int v1, v2;
|
355 |
get_guid(pb, &g);
|
356 |
v1 = get_le32(pb);
|
357 |
v2 = get_le16(pb);
|
358 |
} else if (!memcmp(&g, &codec_comment_header, sizeof(GUID))) {
|
359 |
int len, v1, n, num;
|
360 |
char str[256], *q;
|
361 |
char tag[16];
|
362 |
|
363 |
get_guid(pb, &g);
|
364 |
print_guid(&g);
|
365 |
|
366 |
n = get_le32(pb);
|
367 |
for(i=0;i<n;i++) {
|
368 |
num = get_le16(pb); /* stream number */
|
369 |
get_str16(pb, str, sizeof(str));
|
370 |
get_str16(pb, str, sizeof(str));
|
371 |
len = get_le16(pb);
|
372 |
q = tag;
|
373 |
while (len > 0) {
|
374 |
v1 = get_byte(pb);
|
375 |
if ((q - tag) < sizeof(tag) - 1)
|
376 |
*q++ = v1;
|
377 |
len--;
|
378 |
}
|
379 |
*q = '\0';
|
380 |
}
|
381 |
#endif
|
382 |
} else if (url_feof(pb)) { |
383 |
goto fail;
|
384 |
} else {
|
385 |
url_fseek(pb, gsize - 24, SEEK_CUR);
|
386 |
} |
387 |
} |
388 |
get_guid(pb, &g); |
389 |
get_le64(pb); |
390 |
get_byte(pb); |
391 |
get_byte(pb); |
392 |
if (url_feof(pb))
|
393 |
goto fail;
|
394 |
asf->data_offset = url_ftell(pb); |
395 |
asf->packet_size_left = 0;
|
396 |
|
397 |
return 0; |
398 |
|
399 |
fail:
|
400 |
for(i=0;i<s->nb_streams;i++) { |
401 |
AVStream *st = s->streams[i]; |
402 |
if (st) {
|
403 |
av_free(st->priv_data); |
404 |
av_free(st->codec->extradata); |
405 |
} |
406 |
av_free(st); |
407 |
} |
408 |
return -1; |
409 |
} |
410 |
|
411 |
#define DO_2BITS(bits, var, defval) \
|
412 |
switch (bits & 3) \ |
413 |
{ \ |
414 |
case 3: var = get_le32(pb); rsize += 4; break; \ |
415 |
case 2: var = get_le16(pb); rsize += 2; break; \ |
416 |
case 1: var = get_byte(pb); rsize++; break; \ |
417 |
default: var = defval; break; \ |
418 |
} |
419 |
|
420 |
static int asf_get_packet(AVFormatContext *s) |
421 |
{ |
422 |
ASFContext *asf = s->priv_data; |
423 |
ByteIOContext *pb = &s->pb; |
424 |
uint32_t packet_length, padsize; |
425 |
int rsize = 9; |
426 |
int c;
|
427 |
|
428 |
assert((url_ftell(&s->pb) - s->data_offset) % asf->packet_size == 0);
|
429 |
|
430 |
c = get_byte(pb); |
431 |
if (c != 0x82) { |
432 |
if (!url_feof(pb))
|
433 |
av_log(s, AV_LOG_ERROR, "ff asf bad header %x at:%"PRId64"\n", c, url_ftell(pb)); |
434 |
} |
435 |
if ((c & 0x0f) == 2) { // always true for now |
436 |
if (get_le16(pb) != 0) { |
437 |
if (!url_feof(pb))
|
438 |
av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n");
|
439 |
return AVERROR_IO;
|
440 |
} |
441 |
rsize+=2;
|
442 |
/* }else{
|
443 |
if (!url_feof(pb))
|
444 |
printf("ff asf bad header %x at:%lld\n", c, url_ftell(pb));
|
445 |
return AVERROR_IO;*/
|
446 |
} |
447 |
|
448 |
asf->packet_flags = get_byte(pb); |
449 |
asf->packet_property = get_byte(pb); |
450 |
|
451 |
DO_2BITS(asf->packet_flags >> 5, packet_length, asf->packet_size);
|
452 |
DO_2BITS(asf->packet_flags >> 1, padsize, 0); // sequence ignored |
453 |
DO_2BITS(asf->packet_flags >> 3, padsize, 0); // padding length |
454 |
|
455 |
asf->packet_timestamp = get_le32(pb); |
456 |
get_le16(pb); /* duration */
|
457 |
// rsize has at least 11 bytes which have to be present
|
458 |
|
459 |
if (asf->packet_flags & 0x01) { |
460 |
asf->packet_segsizetype = get_byte(pb); rsize++; |
461 |
asf->packet_segments = asf->packet_segsizetype & 0x3f;
|
462 |
} else {
|
463 |
asf->packet_segments = 1;
|
464 |
asf->packet_segsizetype = 0x80;
|
465 |
} |
466 |
asf->packet_size_left = packet_length - padsize - rsize; |
467 |
if (packet_length < asf->hdr.min_pktsize)
|
468 |
padsize += asf->hdr.min_pktsize - packet_length; |
469 |
asf->packet_padsize = padsize; |
470 |
#ifdef DEBUG
|
471 |
printf("packet: size=%d padsize=%d left=%d\n", asf->packet_size, asf->packet_padsize, asf->packet_size_left);
|
472 |
#endif
|
473 |
return 0; |
474 |
} |
475 |
|
476 |
static int asf_read_packet(AVFormatContext *s, AVPacket *pkt) |
477 |
{ |
478 |
ASFContext *asf = s->priv_data; |
479 |
ASFStream *asf_st = 0;
|
480 |
ByteIOContext *pb = &s->pb; |
481 |
//static int pc = 0;
|
482 |
for (;;) {
|
483 |
int rsize = 0; |
484 |
if (asf->packet_size_left < FRAME_HEADER_SIZE
|
485 |
|| asf->packet_segments < 1) {
|
486 |
//asf->packet_size_left <= asf->packet_padsize) {
|
487 |
int ret = asf->packet_size_left + asf->packet_padsize;
|
488 |
//printf("PacketLeftSize:%d Pad:%d Pos:%Ld\n", asf->packet_size_left, asf->packet_padsize, url_ftell(pb));
|
489 |
if((url_ftell(&s->pb) + ret - s->data_offset) % asf->packet_size)
|
490 |
ret += asf->packet_size - ((url_ftell(&s->pb) + ret - s->data_offset) % asf->packet_size); |
491 |
/* fail safe */
|
492 |
url_fskip(pb, ret); |
493 |
asf->packet_pos= url_ftell(&s->pb); |
494 |
ret = asf_get_packet(s); |
495 |
//printf("READ ASF PACKET %d r:%d c:%d\n", ret, asf->packet_size_left, pc++);
|
496 |
if (ret < 0 || url_feof(pb)) |
497 |
return AVERROR_IO;
|
498 |
asf->packet_time_start = 0;
|
499 |
continue;
|
500 |
} |
501 |
if (asf->packet_time_start == 0) { |
502 |
/* read frame header */
|
503 |
int num = get_byte(pb);
|
504 |
asf->packet_segments--; |
505 |
rsize++; |
506 |
asf->packet_key_frame = (num & 0x80) >> 7; |
507 |
asf->stream_index = asf->asfid2avid[num & 0x7f];
|
508 |
// sequence should be ignored!
|
509 |
DO_2BITS(asf->packet_property >> 4, asf->packet_seq, 0); |
510 |
DO_2BITS(asf->packet_property >> 2, asf->packet_frag_offset, 0); |
511 |
DO_2BITS(asf->packet_property, asf->packet_replic_size, 0);
|
512 |
//printf("key:%d stream:%d seq:%d offset:%d replic_size:%d\n", asf->packet_key_frame, asf->stream_index, asf->packet_seq, //asf->packet_frag_offset, asf->packet_replic_size);
|
513 |
if (asf->packet_replic_size > 1) { |
514 |
assert(asf->packet_replic_size >= 8);
|
515 |
// it should be always at least 8 bytes - FIXME validate
|
516 |
asf->packet_obj_size = get_le32(pb); |
517 |
asf->packet_frag_timestamp = get_le32(pb); // timestamp
|
518 |
if (asf->packet_replic_size > 8) |
519 |
url_fskip(pb, asf->packet_replic_size - 8);
|
520 |
rsize += asf->packet_replic_size; // FIXME - check validity
|
521 |
} else if (asf->packet_replic_size==1){ |
522 |
// multipacket - frag_offset is begining timestamp
|
523 |
asf->packet_time_start = asf->packet_frag_offset; |
524 |
asf->packet_frag_offset = 0;
|
525 |
asf->packet_frag_timestamp = asf->packet_timestamp; |
526 |
|
527 |
asf->packet_time_delta = get_byte(pb); |
528 |
rsize++; |
529 |
}else{
|
530 |
assert(asf->packet_replic_size==0);
|
531 |
} |
532 |
if (asf->packet_flags & 0x01) { |
533 |
DO_2BITS(asf->packet_segsizetype >> 6, asf->packet_frag_size, 0); // 0 is illegal |
534 |
#undef DO_2BITS
|
535 |
//printf("Fragsize %d\n", asf->packet_frag_size);
|
536 |
} else {
|
537 |
asf->packet_frag_size = asf->packet_size_left - rsize; |
538 |
//printf("Using rest %d %d %d\n", asf->packet_frag_size, asf->packet_size_left, rsize);
|
539 |
} |
540 |
if (asf->packet_replic_size == 1) { |
541 |
asf->packet_multi_size = asf->packet_frag_size; |
542 |
if (asf->packet_multi_size > asf->packet_size_left) {
|
543 |
asf->packet_segments = 0;
|
544 |
continue;
|
545 |
} |
546 |
} |
547 |
asf->packet_size_left -= rsize; |
548 |
//printf("___objsize____ %d %d rs:%d\n", asf->packet_obj_size, asf->packet_frag_offset, rsize);
|
549 |
|
550 |
if (asf->stream_index < 0 |
551 |
|| s->streams[asf->stream_index]->discard >= AVDISCARD_ALL |
552 |
|| (!asf->packet_key_frame && s->streams[asf->stream_index]->discard >= AVDISCARD_NONKEY) |
553 |
) { |
554 |
asf->packet_time_start = 0;
|
555 |
/* unhandled packet (should not happen) */
|
556 |
url_fskip(pb, asf->packet_frag_size); |
557 |
asf->packet_size_left -= asf->packet_frag_size; |
558 |
if(asf->stream_index < 0) |
559 |
av_log(s, AV_LOG_ERROR, "ff asf skip %d %d\n", asf->packet_frag_size, num & 0x7f); |
560 |
continue;
|
561 |
} |
562 |
asf->asf_st = s->streams[asf->stream_index]->priv_data; |
563 |
} |
564 |
asf_st = asf->asf_st; |
565 |
|
566 |
if ((asf->packet_frag_offset != asf_st->frag_offset
|
567 |
|| (asf->packet_frag_offset |
568 |
&& asf->packet_seq != asf_st->seq)) // seq should be ignored
|
569 |
) { |
570 |
/* cannot continue current packet: free it */
|
571 |
// FIXME better check if packet was already allocated
|
572 |
av_log(s, AV_LOG_INFO, "ff asf parser skips: %d - %d o:%d - %d %d %d fl:%d\n",
|
573 |
asf_st->pkt.size, |
574 |
asf->packet_obj_size, |
575 |
asf->packet_frag_offset, asf_st->frag_offset, |
576 |
asf->packet_seq, asf_st->seq, asf->packet_frag_size); |
577 |
if (asf_st->pkt.size)
|
578 |
av_free_packet(&asf_st->pkt); |
579 |
asf_st->frag_offset = 0;
|
580 |
if (asf->packet_frag_offset != 0) { |
581 |
url_fskip(pb, asf->packet_frag_size); |
582 |
av_log(s, AV_LOG_INFO, "ff asf parser skipping %db\n", asf->packet_frag_size);
|
583 |
asf->packet_size_left -= asf->packet_frag_size; |
584 |
continue;
|
585 |
} |
586 |
} |
587 |
if (asf->packet_replic_size == 1) { |
588 |
// frag_offset is here used as the begining timestamp
|
589 |
asf->packet_frag_timestamp = asf->packet_time_start; |
590 |
asf->packet_time_start += asf->packet_time_delta; |
591 |
asf->packet_obj_size = asf->packet_frag_size = get_byte(pb); |
592 |
asf->packet_size_left--; |
593 |
asf->packet_multi_size--; |
594 |
if (asf->packet_multi_size < asf->packet_obj_size)
|
595 |
{ |
596 |
asf->packet_time_start = 0;
|
597 |
url_fskip(pb, asf->packet_multi_size); |
598 |
asf->packet_size_left -= asf->packet_multi_size; |
599 |
continue;
|
600 |
} |
601 |
asf->packet_multi_size -= asf->packet_obj_size; |
602 |
//printf("COMPRESS size %d %d %d ms:%d\n", asf->packet_obj_size, asf->packet_frag_timestamp, asf->packet_size_left, asf->packet_multi_size);
|
603 |
} |
604 |
if (asf_st->frag_offset == 0) { |
605 |
/* new packet */
|
606 |
av_new_packet(&asf_st->pkt, asf->packet_obj_size); |
607 |
asf_st->seq = asf->packet_seq; |
608 |
asf_st->pkt.pts = asf->packet_frag_timestamp; |
609 |
asf_st->pkt.stream_index = asf->stream_index; |
610 |
asf_st->pkt.pos = |
611 |
asf_st->packet_pos= asf->packet_pos; |
612 |
//printf("new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n",
|
613 |
//asf->stream_index, asf->packet_key_frame, asf_st->pkt.flags & PKT_FLAG_KEY,
|
614 |
//s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO, asf->packet_obj_size);
|
615 |
if (s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO)
|
616 |
asf->packet_key_frame = 1;
|
617 |
if (asf->packet_key_frame)
|
618 |
asf_st->pkt.flags |= PKT_FLAG_KEY; |
619 |
} |
620 |
|
621 |
/* read data */
|
622 |
//printf("READ PACKET s:%d os:%d o:%d,%d l:%d DATA:%p\n",
|
623 |
// asf->packet_size, asf_st->pkt.size, asf->packet_frag_offset,
|
624 |
// asf_st->frag_offset, asf->packet_frag_size, asf_st->pkt.data);
|
625 |
asf->packet_size_left -= asf->packet_frag_size; |
626 |
if (asf->packet_size_left < 0) |
627 |
continue;
|
628 |
get_buffer(pb, asf_st->pkt.data + asf->packet_frag_offset, |
629 |
asf->packet_frag_size); |
630 |
asf_st->frag_offset += asf->packet_frag_size; |
631 |
/* test if whole packet is read */
|
632 |
if (asf_st->frag_offset == asf_st->pkt.size) {
|
633 |
/* return packet */
|
634 |
if (asf_st->ds_span > 1) { |
635 |
/* packet descrambling */
|
636 |
char* newdata = av_malloc(asf_st->pkt.size);
|
637 |
if (newdata) {
|
638 |
int offset = 0; |
639 |
while (offset < asf_st->pkt.size) {
|
640 |
int off = offset / asf_st->ds_chunk_size;
|
641 |
int row = off / asf_st->ds_span;
|
642 |
int col = off % asf_st->ds_span;
|
643 |
int idx = row + col * asf_st->ds_packet_size / asf_st->ds_chunk_size;
|
644 |
//printf("off:%d row:%d col:%d idx:%d\n", off, row, col, idx);
|
645 |
memcpy(newdata + offset, |
646 |
asf_st->pkt.data + idx * asf_st->ds_chunk_size, |
647 |
asf_st->ds_chunk_size); |
648 |
offset += asf_st->ds_chunk_size; |
649 |
} |
650 |
av_free(asf_st->pkt.data); |
651 |
asf_st->pkt.data = newdata; |
652 |
} |
653 |
} |
654 |
asf_st->frag_offset = 0;
|
655 |
memcpy(pkt, &asf_st->pkt, sizeof(AVPacket));
|
656 |
//printf("packet %d %d\n", asf_st->pkt.size, asf->packet_frag_size);
|
657 |
asf_st->pkt.size = 0;
|
658 |
asf_st->pkt.data = 0;
|
659 |
break; // packet completed |
660 |
} |
661 |
} |
662 |
return 0; |
663 |
} |
664 |
|
665 |
static int asf_read_close(AVFormatContext *s) |
666 |
{ |
667 |
int i;
|
668 |
|
669 |
for(i=0;i<s->nb_streams;i++) { |
670 |
AVStream *st = s->streams[i]; |
671 |
av_free(st->priv_data); |
672 |
av_free(st->codec->extradata); |
673 |
av_free(st->codec->palctrl); |
674 |
} |
675 |
return 0; |
676 |
} |
677 |
|
678 |
// Added to support seeking after packets have been read
|
679 |
// If information is not reset, read_packet fails due to
|
680 |
// leftover information from previous reads
|
681 |
static void asf_reset_header(AVFormatContext *s) |
682 |
{ |
683 |
ASFContext *asf = s->priv_data; |
684 |
ASFStream *asf_st; |
685 |
int i;
|
686 |
|
687 |
asf->packet_nb_frames = 0;
|
688 |
asf->packet_timestamp_start = -1;
|
689 |
asf->packet_timestamp_end = -1;
|
690 |
asf->packet_size_left = 0;
|
691 |
asf->packet_segments = 0;
|
692 |
asf->packet_flags = 0;
|
693 |
asf->packet_property = 0;
|
694 |
asf->packet_timestamp = 0;
|
695 |
asf->packet_segsizetype = 0;
|
696 |
asf->packet_segments = 0;
|
697 |
asf->packet_seq = 0;
|
698 |
asf->packet_replic_size = 0;
|
699 |
asf->packet_key_frame = 0;
|
700 |
asf->packet_padsize = 0;
|
701 |
asf->packet_frag_offset = 0;
|
702 |
asf->packet_frag_size = 0;
|
703 |
asf->packet_frag_timestamp = 0;
|
704 |
asf->packet_multi_size = 0;
|
705 |
asf->packet_obj_size = 0;
|
706 |
asf->packet_time_delta = 0;
|
707 |
asf->packet_time_start = 0;
|
708 |
|
709 |
for(i=0; i<s->nb_streams; i++){ |
710 |
asf_st= s->streams[i]->priv_data; |
711 |
av_free_packet(&asf_st->pkt); |
712 |
asf_st->frag_offset=0;
|
713 |
asf_st->seq=0;
|
714 |
} |
715 |
asf->asf_st= NULL;
|
716 |
} |
717 |
|
718 |
static int64_t asf_read_pts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit) |
719 |
{ |
720 |
ASFContext *asf = s->priv_data; |
721 |
AVPacket pkt1, *pkt = &pkt1; |
722 |
ASFStream *asf_st; |
723 |
int64_t pts; |
724 |
int64_t pos= *ppos; |
725 |
int i;
|
726 |
int64_t start_pos[s->nb_streams]; |
727 |
|
728 |
for(i=0; i<s->nb_streams; i++){ |
729 |
start_pos[i]= pos; |
730 |
} |
731 |
|
732 |
pos= (pos+asf->packet_size-1-s->data_offset)/asf->packet_size*asf->packet_size+ s->data_offset;
|
733 |
*ppos= pos; |
734 |
url_fseek(&s->pb, pos, SEEK_SET); |
735 |
|
736 |
//printf("asf_read_pts\n");
|
737 |
asf_reset_header(s); |
738 |
for(;;){
|
739 |
if (av_read_frame(s, pkt) < 0){ |
740 |
av_log(s, AV_LOG_INFO, "seek failed\n");
|
741 |
return AV_NOPTS_VALUE;
|
742 |
} |
743 |
|
744 |
pts= pkt->pts * 1000 / AV_TIME_BASE;
|
745 |
|
746 |
av_free_packet(pkt); |
747 |
if(pkt->flags&PKT_FLAG_KEY){
|
748 |
i= pkt->stream_index; |
749 |
|
750 |
asf_st= s->streams[i]->priv_data; |
751 |
|
752 |
assert((asf_st->packet_pos - s->data_offset) % asf->packet_size == 0);
|
753 |
pos= asf_st->packet_pos; |
754 |
|
755 |
av_add_index_entry(s->streams[i], pos, pts, pos - start_pos[i] + 1, AVINDEX_KEYFRAME);
|
756 |
start_pos[i]= asf_st->packet_pos + 1;
|
757 |
|
758 |
if(pkt->stream_index == stream_index)
|
759 |
break;
|
760 |
} |
761 |
} |
762 |
|
763 |
*ppos= pos; |
764 |
//printf("found keyframe at %Ld stream %d stamp:%Ld\n", *ppos, stream_index, pts);
|
765 |
|
766 |
return pts;
|
767 |
} |
768 |
|
769 |
static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags) |
770 |
{ |
771 |
ASFContext *asf = s->priv_data; |
772 |
|
773 |
if (asf->packet_size <= 0) |
774 |
return -1; |
775 |
|
776 |
if(av_seek_frame_binary(s, stream_index, pts, flags)<0) |
777 |
return -1; |
778 |
|
779 |
asf_reset_header(s); |
780 |
return 0; |
781 |
} |
782 |
|
783 |
static AVInputFormat asf_iformat = {
|
784 |
"asf",
|
785 |
"asf format",
|
786 |
sizeof(ASFContext),
|
787 |
asf_probe, |
788 |
asf_read_header, |
789 |
asf_read_packet, |
790 |
asf_read_close, |
791 |
asf_read_seek, |
792 |
asf_read_pts, |
793 |
}; |
794 |
|
795 |
#ifdef CONFIG_MUXERS
|
796 |
extern AVOutputFormat asf_oformat;
|
797 |
extern AVOutputFormat asf_stream_oformat;
|
798 |
#endif //CONFIG_MUXERS |
799 |
|
800 |
int asf_init(void) |
801 |
{ |
802 |
av_register_input_format(&asf_iformat); |
803 |
#ifdef CONFIG_MUXERS
|
804 |
av_register_output_format(&asf_oformat); |
805 |
av_register_output_format(&asf_stream_oformat); |
806 |
#endif //CONFIG_MUXERS |
807 |
return 0; |
808 |
} |