Commit | Line | Data |
---|---|---|
de6d9b64 | 1 | /* |
7fbde343 | 2 | * ASF compatible demuxer |
19720f15 | 3 | * Copyright (c) 2000, 2001 Fabrice Bellard. |
de6d9b64 | 4 | * |
b78e7197 DB |
5 | * This file is part of FFmpeg. |
6 | * | |
7 | * FFmpeg is free software; you can redistribute it and/or | |
19720f15 FB |
8 | * modify it under the terms of the GNU Lesser General Public |
9 | * License as published by the Free Software Foundation; either | |
b78e7197 | 10 | * version 2.1 of the License, or (at your option) any later version. |
de6d9b64 | 11 | * |
b78e7197 | 12 | * FFmpeg is distributed in the hope that it will be useful, |
de6d9b64 | 13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
19720f15 FB |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 | * Lesser General Public License for more details. | |
de6d9b64 | 16 | * |
19720f15 | 17 | * You should have received a copy of the GNU Lesser General Public |
b78e7197 | 18 | * License along with FFmpeg; if not, write to the Free Software |
5509bffa | 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
de6d9b64 | 20 | */ |
de6d9b64 | 21 | #include "avformat.h" |
9d9f4119 | 22 | #include "riff.h" |
f80c1ac0 | 23 | #include "mpegaudio.h" |
542993b0 | 24 | #include "asf.h" |
db5c43b4 | 25 | #include "common.h" |
de6d9b64 | 26 | |
580fb5e7 MN |
27 | #undef NDEBUG |
28 | #include <assert.h> | |
29 | ||
615b92fd | 30 | #define FRAME_HEADER_SIZE 17 |
115329f1 | 31 | // Fix Me! FRAME_HEADER_SIZE may be different. |
615b92fd | 32 | |
de6d9b64 | 33 | static const GUID index_guid = { |
24c14d6d | 34 | 0x90, 0x08, 0x00, 0x33, 0xb1, 0xe5, 0xcf, 0x11, 0x89, 0xf4, 0x00, 0xa0, 0xc9, 0x03, 0x49, 0xcb |
de6d9b64 FB |
35 | }; |
36 | ||
de6d9b64 FB |
37 | /**********************************/ |
38 | /* decoding */ | |
39 | ||
40 | //#define DEBUG | |
41 | ||
42 | #ifdef DEBUG | |
5082f759 FR |
43 | #define PRINT_IF_GUID(g,cmp) \ |
44 | if (!memcmp(g, &cmp, sizeof(GUID))) \ | |
45 | printf("(GUID: %s) ", #cmp) | |
46 | ||
de6d9b64 FB |
47 | static void print_guid(const GUID *g) |
48 | { | |
49 | int i; | |
5082f759 FR |
50 | PRINT_IF_GUID(g, asf_header); |
51 | else PRINT_IF_GUID(g, file_header); | |
52 | else PRINT_IF_GUID(g, stream_header); | |
53 | else PRINT_IF_GUID(g, audio_stream); | |
54 | else PRINT_IF_GUID(g, audio_conceal_none); | |
55 | else PRINT_IF_GUID(g, video_stream); | |
56 | else PRINT_IF_GUID(g, video_conceal_none); | |
ae38261e | 57 | else PRINT_IF_GUID(g, command_stream); |
5082f759 FR |
58 | else PRINT_IF_GUID(g, comment_header); |
59 | else PRINT_IF_GUID(g, codec_comment_header); | |
60 | else PRINT_IF_GUID(g, codec_comment1_header); | |
61 | else PRINT_IF_GUID(g, data_header); | |
62 | else PRINT_IF_GUID(g, index_guid); | |
63 | else PRINT_IF_GUID(g, head1_guid); | |
64 | else PRINT_IF_GUID(g, head2_guid); | |
65 | else PRINT_IF_GUID(g, my_guid); | |
88141c91 MN |
66 | else PRINT_IF_GUID(g, ext_stream_header); |
67 | else PRINT_IF_GUID(g, extended_content_header); | |
68 | else PRINT_IF_GUID(g, ext_stream_embed_stream_header); | |
69 | else PRINT_IF_GUID(g, ext_stream_audio_stream); | |
5082f759 FR |
70 | else |
71 | printf("(GUID: unknown) "); | |
24c14d6d MN |
72 | for(i=0;i<16;i++) |
73 | printf(" 0x%02x,", (*g)[i]); | |
de6d9b64 FB |
74 | printf("}\n"); |
75 | } | |
6df84c3a | 76 | #undef PRINT_IF_GUID |
de6d9b64 FB |
77 | #endif |
78 | ||
79 | static void get_guid(ByteIOContext *s, GUID *g) | |
80 | { | |
24c14d6d MN |
81 | assert(sizeof(*g) == 16); |
82 | get_buffer(s, g, sizeof(*g)); | |
de6d9b64 FB |
83 | } |
84 | ||
85 | #if 0 | |
86 | static void get_str16(ByteIOContext *pb, char *buf, int buf_size) | |
87 | { | |
88 | int len, c; | |
89 | char *q; | |
90 | ||
91 | len = get_le16(pb); | |
92 | q = buf; | |
93 | while (len > 0) { | |
94 | c = get_le16(pb); | |
95 | if ((q - buf) < buf_size - 1) | |
96 | *q++ = c; | |
97 | len--; | |
98 | } | |
99 | *q = '\0'; | |
100 | } | |
101 | #endif | |
102 | ||
103 | static void get_str16_nolen(ByteIOContext *pb, int len, char *buf, int buf_size) | |
104 | { | |
db5c43b4 ZM |
105 | char* q = buf; |
106 | len /= 2; | |
107 | while (len--) { | |
108 | uint8_t tmp; | |
109 | PUT_UTF8(get_le16(pb), tmp, if (q - buf < buf_size - 1) *q++ = tmp;) | |
de6d9b64 FB |
110 | } |
111 | *q = '\0'; | |
112 | } | |
113 | ||
c9a65ca8 FB |
114 | static int asf_probe(AVProbeData *pd) |
115 | { | |
c9a65ca8 FB |
116 | /* check file header */ |
117 | if (pd->buf_size <= 32) | |
118 | return 0; | |
c9a65ca8 | 119 | |
24c14d6d | 120 | if (!memcmp(pd->buf, &asf_header, sizeof(GUID))) |
c9a65ca8 FB |
121 | return AVPROBE_SCORE_MAX; |
122 | else | |
123 | return 0; | |
124 | } | |
125 | ||
de6d9b64 FB |
126 | static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap) |
127 | { | |
c9a65ca8 | 128 | ASFContext *asf = s->priv_data; |
de6d9b64 FB |
129 | GUID g; |
130 | ByteIOContext *pb = &s->pb; | |
131 | AVStream *st; | |
132 | ASFStream *asf_st; | |
e095026a | 133 | int size, i; |
0c1a9eda | 134 | int64_t gsize; |
de6d9b64 | 135 | |
de6d9b64 FB |
136 | get_guid(pb, &g); |
137 | if (memcmp(&g, &asf_header, sizeof(GUID))) | |
138 | goto fail; | |
139 | get_le64(pb); | |
140 | get_le32(pb); | |
141 | get_byte(pb); | |
142 | get_byte(pb); | |
2141dc37 | 143 | memset(&asf->asfid2avid, -1, sizeof(asf->asfid2avid)); |
de6d9b64 FB |
144 | for(;;) { |
145 | get_guid(pb, &g); | |
146 | gsize = get_le64(pb); | |
147 | #ifdef DEBUG | |
949b1a13 | 148 | printf("%08"PRIx64": ", url_ftell(pb) - 24); |
de6d9b64 | 149 | print_guid(&g); |
949b1a13 | 150 | printf(" size=0x%"PRIx64"\n", gsize); |
de6d9b64 FB |
151 | #endif |
152 | if (gsize < 24) | |
153 | goto fail; | |
154 | if (!memcmp(&g, &file_header, sizeof(GUID))) { | |
2a10020b | 155 | get_guid(pb, &asf->hdr.guid); |
bb270c08 DB |
156 | asf->hdr.file_size = get_le64(pb); |
157 | asf->hdr.create_time = get_le64(pb); | |
6bb2a2df | 158 | asf->nb_packets = get_le64(pb); |
bb270c08 DB |
159 | asf->hdr.send_time = get_le64(pb); |
160 | asf->hdr.play_time = get_le64(pb); | |
161 | asf->hdr.preroll = get_le32(pb); | |
162 | asf->hdr.ignore = get_le32(pb); | |
163 | asf->hdr.flags = get_le32(pb); | |
164 | asf->hdr.min_pktsize = get_le32(pb); | |
165 | asf->hdr.max_pktsize = get_le32(pb); | |
166 | asf->hdr.max_bitrate = get_le32(pb); | |
167 | asf->packet_size = asf->hdr.max_pktsize; | |
de6d9b64 | 168 | } else if (!memcmp(&g, &stream_header, sizeof(GUID))) { |
7ad5455c MN |
169 | int type, type_specific_size, sizeX; |
170 | uint64_t total_size; | |
de6d9b64 | 171 | unsigned int tag1; |
0c1a9eda | 172 | int64_t pos1, pos2; |
88141c91 | 173 | int test_for_ext_stream_audio; |
2a10020b | 174 | |
de6d9b64 FB |
175 | pos1 = url_ftell(pb); |
176 | ||
247eadca | 177 | st = av_new_stream(s, 0); |
de6d9b64 FB |
178 | if (!st) |
179 | goto fail; | |
9ee91c2f | 180 | av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */ |
de6d9b64 FB |
181 | asf_st = av_mallocz(sizeof(ASFStream)); |
182 | if (!asf_st) | |
183 | goto fail; | |
184 | st->priv_data = asf_st; | |
c0df9d75 | 185 | st->start_time = asf->hdr.preroll; |
73fe1052 RM |
186 | if(!(asf->hdr.flags & 0x01)) { // if we aren't streaming... |
187 | st->duration = asf->hdr.send_time / | |
188 | (10000000 / 1000) - st->start_time; | |
189 | } | |
de6d9b64 | 190 | get_guid(pb, &g); |
88141c91 MN |
191 | |
192 | test_for_ext_stream_audio = 0; | |
de6d9b64 FB |
193 | if (!memcmp(&g, &audio_stream, sizeof(GUID))) { |
194 | type = CODEC_TYPE_AUDIO; | |
195 | } else if (!memcmp(&g, &video_stream, sizeof(GUID))) { | |
196 | type = CODEC_TYPE_VIDEO; | |
ae38261e MB |
197 | } else if (!memcmp(&g, &command_stream, sizeof(GUID))) { |
198 | type = CODEC_TYPE_UNKNOWN; | |
88141c91 MN |
199 | } else if (!memcmp(&g, &ext_stream_embed_stream_header, sizeof(GUID))) { |
200 | test_for_ext_stream_audio = 1; | |
201 | type = CODEC_TYPE_UNKNOWN; | |
de6d9b64 FB |
202 | } else { |
203 | goto fail; | |
204 | } | |
205 | get_guid(pb, &g); | |
206 | total_size = get_le64(pb); | |
2e7973bb | 207 | type_specific_size = get_le32(pb); |
de6d9b64 | 208 | get_le32(pb); |
bb270c08 | 209 | st->id = get_le16(pb) & 0x7f; /* stream id */ |
2a10020b | 210 | // mapping of asf ID to AV stream ID; |
247eadca | 211 | asf->asfid2avid[st->id] = s->nb_streams - 1; |
2a10020b | 212 | |
de6d9b64 | 213 | get_le32(pb); |
88141c91 MN |
214 | |
215 | if (test_for_ext_stream_audio) { | |
216 | get_guid(pb, &g); | |
217 | if (!memcmp(&g, &ext_stream_audio_stream, sizeof(GUID))) { | |
218 | type = CODEC_TYPE_AUDIO; | |
219 | get_guid(pb, &g); | |
220 | get_le32(pb); | |
221 | get_le32(pb); | |
222 | get_le32(pb); | |
223 | get_guid(pb, &g); | |
224 | get_le32(pb); | |
225 | } | |
226 | } | |
227 | ||
bb270c08 | 228 | st->codec->codec_type = type; |
de6d9b64 | 229 | if (type == CODEC_TYPE_AUDIO) { |
01f4895c | 230 | get_wav_header(pb, st->codec, type_specific_size); |
afda223c | 231 | st->need_parsing = 1; |
bb270c08 DB |
232 | /* We have to init the frame size at some point .... */ |
233 | pos2 = url_ftell(pb); | |
234 | if (gsize > (pos2 + 8 - pos1 + 24)) { | |
235 | asf_st->ds_span = get_byte(pb); | |
236 | asf_st->ds_packet_size = get_le16(pb); | |
237 | asf_st->ds_chunk_size = get_le16(pb); | |
6bb2a2df MN |
238 | get_le16(pb); //ds_data_size |
239 | get_byte(pb); //ds_silence_data | |
bb270c08 DB |
240 | } |
241 | //printf("Descrambling: ps:%d cs:%d ds:%d s:%d sd:%d\n", | |
242 | // asf_st->ds_packet_size, asf_st->ds_chunk_size, | |
243 | // asf_st->ds_data_size, asf_st->ds_span, asf_st->ds_silence_data); | |
244 | if (asf_st->ds_span > 1) { | |
245 | if (!asf_st->ds_chunk_size | |
05219463 MN |
246 | || (asf_st->ds_packet_size/asf_st->ds_chunk_size <= 1) |
247 | || asf_st->ds_packet_size % asf_st->ds_chunk_size) | |
bb270c08 DB |
248 | asf_st->ds_span = 0; // disable descrambling |
249 | } | |
01f4895c | 250 | switch (st->codec->codec_id) { |
80783dc2 | 251 | case CODEC_ID_MP3: |
01f4895c | 252 | st->codec->frame_size = MPA_FRAME_SIZE; |
f80c1ac0 PG |
253 | break; |
254 | case CODEC_ID_PCM_S16LE: | |
255 | case CODEC_ID_PCM_S16BE: | |
256 | case CODEC_ID_PCM_U16LE: | |
257 | case CODEC_ID_PCM_U16BE: | |
258 | case CODEC_ID_PCM_S8: | |
259 | case CODEC_ID_PCM_U8: | |
260 | case CODEC_ID_PCM_ALAW: | |
261 | case CODEC_ID_PCM_MULAW: | |
01f4895c | 262 | st->codec->frame_size = 1; |
f80c1ac0 PG |
263 | break; |
264 | default: | |
265 | /* This is probably wrong, but it prevents a crash later */ | |
01f4895c | 266 | st->codec->frame_size = 1; |
f80c1ac0 PG |
267 | break; |
268 | } | |
88141c91 | 269 | } else if (type == CODEC_TYPE_VIDEO) { |
bb270c08 | 270 | get_le32(pb); |
de6d9b64 FB |
271 | get_le32(pb); |
272 | get_byte(pb); | |
273 | size = get_le16(pb); /* size */ | |
0ffd77b9 | 274 | sizeX= get_le32(pb); /* size */ |
01f4895c | 275 | st->codec->width = get_le32(pb); |
bb270c08 | 276 | st->codec->height = get_le32(pb); |
2a10020b | 277 | /* not available for asf */ |
de6d9b64 | 278 | get_le16(pb); /* panes */ |
bb270c08 | 279 | st->codec->bits_per_sample = get_le16(pb); /* depth */ |
de6d9b64 | 280 | tag1 = get_le32(pb); |
bb270c08 | 281 | url_fskip(pb, 20); |
0ffd77b9 MN |
282 | // av_log(NULL, AV_LOG_DEBUG, "size:%d tsize:%d sizeX:%d\n", size, total_size, sizeX); |
283 | size= sizeX; | |
bb270c08 DB |
284 | if (size > 40) { |
285 | st->codec->extradata_size = size - 40; | |
286 | st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE); | |
287 | get_buffer(pb, st->codec->extradata, st->codec->extradata_size); | |
288 | } | |
5e29abf8 RT |
289 | |
290 | /* Extract palette from extradata if bpp <= 8 */ | |
291 | /* This code assumes that extradata contains only palette */ | |
292 | /* This is true for all paletted codecs implemented in ffmpeg */ | |
01f4895c MN |
293 | if (st->codec->extradata_size && (st->codec->bits_per_sample <= 8)) { |
294 | st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl)); | |
5e29abf8 | 295 | #ifdef WORDS_BIGENDIAN |
01f4895c MN |
296 | for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++) |
297 | st->codec->palctrl->palette[i] = bswap_32(((uint32_t*)st->codec->extradata)[i]); | |
5e29abf8 | 298 | #else |
01f4895c MN |
299 | memcpy(st->codec->palctrl->palette, st->codec->extradata, |
300 | FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)); | |
5e29abf8 | 301 | #endif |
01f4895c | 302 | st->codec->palctrl->palette_changed = 1; |
5e29abf8 RT |
303 | } |
304 | ||
01f4895c | 305 | st->codec->codec_tag = tag1; |
bb270c08 | 306 | st->codec->codec_id = codec_get_id(codec_bmp_tags, tag1); |
afbb5ce4 MN |
307 | if(tag1 == MKTAG('D', 'V', 'R', ' ')) |
308 | st->need_parsing = 1; | |
de6d9b64 FB |
309 | } |
310 | pos2 = url_ftell(pb); | |
311 | url_fskip(pb, gsize - (pos2 - pos1 + 24)); | |
312 | } else if (!memcmp(&g, &data_header, sizeof(GUID))) { | |
b6eaae39 | 313 | asf->data_object_offset = url_ftell(pb); |
73fe1052 RM |
314 | // if not streaming, gsize is not unlimited (how?), and there is enough space in the file.. |
315 | if (!(asf->hdr.flags & 0x01) && gsize != (uint64_t)-1 && gsize >= 24) { | |
b6eaae39 KED |
316 | asf->data_object_size = gsize - 24; |
317 | } else { | |
318 | asf->data_object_size = (uint64_t)-1; | |
319 | } | |
de6d9b64 FB |
320 | break; |
321 | } else if (!memcmp(&g, &comment_header, sizeof(GUID))) { | |
322 | int len1, len2, len3, len4, len5; | |
323 | ||
324 | len1 = get_le16(pb); | |
325 | len2 = get_le16(pb); | |
326 | len3 = get_le16(pb); | |
327 | len4 = get_le16(pb); | |
328 | len5 = get_le16(pb); | |
4e15cc8b MN |
329 | get_str16_nolen(pb, len1, s->title , sizeof(s->title)); |
330 | get_str16_nolen(pb, len2, s->author , sizeof(s->author)); | |
de6d9b64 | 331 | get_str16_nolen(pb, len3, s->copyright, sizeof(s->copyright)); |
4e15cc8b | 332 | get_str16_nolen(pb, len4, s->comment , sizeof(s->comment)); |
bb270c08 | 333 | url_fskip(pb, len5); |
d13431cd KK |
334 | } else if (!memcmp(&g, &extended_content_header, sizeof(GUID))) { |
335 | int desc_count, i; | |
336 | ||
337 | desc_count = get_le16(pb); | |
338 | for(i=0;i<desc_count;i++) | |
339 | { | |
052aa2ad SH |
340 | int name_len,value_type,value_len; |
341 | uint64_t value_num = 0; | |
d045b8c1 | 342 | char name[1024]; |
d13431cd KK |
343 | |
344 | name_len = get_le16(pb); | |
d045b8c1 | 345 | get_str16_nolen(pb, name_len, name, sizeof(name)); |
d13431cd KK |
346 | value_type = get_le16(pb); |
347 | value_len = get_le16(pb); | |
348 | if ((value_type == 0) || (value_type == 1)) // unicode or byte | |
349 | { | |
5e2a4855 MN |
350 | if (!strcmp(name,"WM/AlbumTitle")) get_str16_nolen(pb, value_len, s->album, sizeof(s->album)); |
351 | else if(!strcmp(name,"WM/Genre" )) get_str16_nolen(pb, value_len, s->genre, sizeof(s->genre)); | |
352 | else url_fskip(pb, value_len); | |
d13431cd | 353 | } |
724dc20c | 354 | if ((value_type >= 2) && (value_type <= 5)) // boolean or DWORD or QWORD or WORD |
d13431cd KK |
355 | { |
356 | if (value_type==2) value_num = get_le32(pb); | |
357 | if (value_type==3) value_num = get_le32(pb); | |
358 | if (value_type==4) value_num = get_le64(pb); | |
359 | if (value_type==5) value_num = get_le16(pb); | |
4e15cc8b MN |
360 | if (!strcmp(name,"WM/Track" )) s->track = value_num + 1; |
361 | if (!strcmp(name,"WM/TrackNumber")) s->track = value_num; | |
d13431cd | 362 | } |
d13431cd | 363 | } |
88141c91 MN |
364 | } else if (!memcmp(&g, &ext_stream_header, sizeof(GUID))) { |
365 | int ext_len, payload_ext_ct, stream_ct; | |
366 | uint32_t ext_d; | |
1bd86246 | 367 | int64_t pos_ex_st; |
88141c91 MN |
368 | pos_ex_st = url_ftell(pb); |
369 | ||
370 | get_le64(pb); | |
371 | get_le64(pb); | |
372 | get_le32(pb); | |
373 | get_le32(pb); | |
374 | get_le32(pb); | |
375 | get_le32(pb); | |
376 | get_le32(pb); | |
377 | get_le32(pb); | |
378 | get_le32(pb); | |
379 | get_le32(pb); | |
380 | get_le16(pb); | |
381 | get_le16(pb); | |
382 | get_le64(pb); | |
383 | stream_ct = get_le16(pb); | |
384 | payload_ext_ct = get_le16(pb); | |
385 | ||
386 | for (i=0; i<stream_ct; i++){ | |
387 | get_le16(pb); | |
388 | ext_len = get_le16(pb); | |
389 | url_fseek(pb, ext_len, SEEK_CUR); | |
390 | } | |
391 | ||
392 | for (i=0; i<payload_ext_ct; i++){ | |
393 | get_guid(pb, &g); | |
394 | ext_d=get_le16(pb); | |
395 | ext_len=get_le32(pb); | |
396 | url_fseek(pb, ext_len, SEEK_CUR); | |
397 | } | |
398 | ||
399 | // there could be a optional stream properties object to follow | |
400 | // if so the next iteration will pick it up | |
de6d9b64 FB |
401 | } else if (!memcmp(&g, &head1_guid, sizeof(GUID))) { |
402 | int v1, v2; | |
403 | get_guid(pb, &g); | |
404 | v1 = get_le32(pb); | |
405 | v2 = get_le16(pb); | |
88141c91 | 406 | #if 0 |
de6d9b64 FB |
407 | } else if (!memcmp(&g, &codec_comment_header, sizeof(GUID))) { |
408 | int len, v1, n, num; | |
409 | char str[256], *q; | |
410 | char tag[16]; | |
411 | ||
412 | get_guid(pb, &g); | |
413 | print_guid(&g); | |
2a10020b | 414 | |
de6d9b64 FB |
415 | n = get_le32(pb); |
416 | for(i=0;i<n;i++) { | |
417 | num = get_le16(pb); /* stream number */ | |
418 | get_str16(pb, str, sizeof(str)); | |
419 | get_str16(pb, str, sizeof(str)); | |
420 | len = get_le16(pb); | |
421 | q = tag; | |
422 | while (len > 0) { | |
423 | v1 = get_byte(pb); | |
424 | if ((q - tag) < sizeof(tag) - 1) | |
425 | *q++ = v1; | |
426 | len--; | |
427 | } | |
428 | *q = '\0'; | |
429 | } | |
430 | #endif | |
431 | } else if (url_feof(pb)) { | |
432 | goto fail; | |
433 | } else { | |
434 | url_fseek(pb, gsize - 24, SEEK_CUR); | |
435 | } | |
436 | } | |
437 | get_guid(pb, &g); | |
438 | get_le64(pb); | |
439 | get_byte(pb); | |
440 | get_byte(pb); | |
2141dc37 ZK |
441 | if (url_feof(pb)) |
442 | goto fail; | |
443 | asf->data_offset = url_ftell(pb); | |
de6d9b64 FB |
444 | asf->packet_size_left = 0; |
445 | ||
446 | return 0; | |
447 | ||
448 | fail: | |
4c3dff6d | 449 | for(i=0;i<s->nb_streams;i++) { |
de6d9b64 | 450 | AVStream *st = s->streams[i]; |
bb270c08 DB |
451 | if (st) { |
452 | av_free(st->priv_data); | |
01f4895c | 453 | av_free(st->codec->extradata); |
bb270c08 | 454 | } |
1ea4f593 | 455 | av_free(st); |
de6d9b64 | 456 | } |
de6d9b64 FB |
457 | return -1; |
458 | } | |
459 | ||
2a10020b ZK |
460 | #define DO_2BITS(bits, var, defval) \ |
461 | switch (bits & 3) \ | |
462 | { \ | |
463 | case 3: var = get_le32(pb); rsize += 4; break; \ | |
464 | case 2: var = get_le16(pb); rsize += 2; break; \ | |
465 | case 1: var = get_byte(pb); rsize++; break; \ | |
466 | default: var = defval; break; \ | |
467 | } | |
468 | ||
f7835507 MN |
469 | /** |
470 | * | |
471 | * @return <0 in case of an error | |
472 | */ | |
de6d9b64 FB |
473 | static int asf_get_packet(AVFormatContext *s) |
474 | { | |
475 | ASFContext *asf = s->priv_data; | |
476 | ByteIOContext *pb = &s->pb; | |
2a10020b | 477 | uint32_t packet_length, padsize; |
29962fea MN |
478 | int rsize = 9; |
479 | int c; | |
115329f1 | 480 | |
29962fea | 481 | c = get_byte(pb); |
1359c2d4 | 482 | if (c != 0x82) { |
5acdd6e6 | 483 | if (!url_feof(pb)) |
bb270c08 | 484 | av_log(s, AV_LOG_ERROR, "ff asf bad header %x at:%"PRId64"\n", c, url_ftell(pb)); |
2a10020b ZK |
485 | } |
486 | if ((c & 0x0f) == 2) { // always true for now | |
bb270c08 | 487 | if (get_le16(pb) != 0) { |
5acdd6e6 | 488 | if (!url_feof(pb)) |
bb270c08 | 489 | av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n"); |
f7835507 | 490 | return -1; |
bb270c08 | 491 | } |
29962fea MN |
492 | rsize+=2; |
493 | /* }else{ | |
494 | if (!url_feof(pb)) | |
949b1a13 | 495 | printf("ff asf bad header %x at:%"PRId64"\n", c, url_ftell(pb)); |
bb270c08 | 496 | return AVERROR_IO;*/ |
de6d9b64 | 497 | } |
2a10020b ZK |
498 | |
499 | asf->packet_flags = get_byte(pb); | |
500 | asf->packet_property = get_byte(pb); | |
501 | ||
502 | DO_2BITS(asf->packet_flags >> 5, packet_length, asf->packet_size); | |
503 | DO_2BITS(asf->packet_flags >> 1, padsize, 0); // sequence ignored | |
504 | DO_2BITS(asf->packet_flags >> 3, padsize, 0); // padding length | |
505 | ||
5b11e081 MN |
506 | //the following checks prevent overflows and infinite loops |
507 | if(packet_length >= (1U<<29)){ | |
508 | av_log(s, AV_LOG_ERROR, "invalid packet_length %d at:%"PRId64"\n", packet_length, url_ftell(pb)); | |
ceba96cb | 509 | return -1; |
5b11e081 | 510 | } |
92216453 | 511 | if(padsize >= packet_length){ |
5b11e081 | 512 | av_log(s, AV_LOG_ERROR, "invalid padsize %d at:%"PRId64"\n", padsize, url_ftell(pb)); |
ceba96cb | 513 | return -1; |
5b11e081 MN |
514 | } |
515 | ||
2a10020b | 516 | asf->packet_timestamp = get_le32(pb); |
de6d9b64 | 517 | get_le16(pb); /* duration */ |
2141dc37 | 518 | // rsize has at least 11 bytes which have to be present |
2a10020b ZK |
519 | |
520 | if (asf->packet_flags & 0x01) { | |
bb270c08 | 521 | asf->packet_segsizetype = get_byte(pb); rsize++; |
2a10020b ZK |
522 | asf->packet_segments = asf->packet_segsizetype & 0x3f; |
523 | } else { | |
bb270c08 | 524 | asf->packet_segments = 1; |
2a10020b ZK |
525 | asf->packet_segsizetype = 0x80; |
526 | } | |
527 | asf->packet_size_left = packet_length - padsize - rsize; | |
acbe6cfa ZK |
528 | if (packet_length < asf->hdr.min_pktsize) |
529 | padsize += asf->hdr.min_pktsize - packet_length; | |
2a10020b | 530 | asf->packet_padsize = padsize; |
de6d9b64 | 531 | #ifdef DEBUG |
2a10020b | 532 | printf("packet: size=%d padsize=%d left=%d\n", asf->packet_size, asf->packet_padsize, asf->packet_size_left); |
de6d9b64 | 533 | #endif |
de6d9b64 FB |
534 | return 0; |
535 | } | |
536 | ||
ae60a857 MN |
537 | /** |
538 | * | |
539 | * @return <0 if error | |
540 | */ | |
541 | static int asf_read_frame_header(AVFormatContext *s){ | |
542 | ASFContext *asf = s->priv_data; | |
543 | ByteIOContext *pb = &s->pb; | |
544 | int rsize = 1; | |
545 | int num = get_byte(pb); | |
546 | ||
547 | asf->packet_segments--; | |
548 | asf->packet_key_frame = num >> 7; | |
549 | asf->stream_index = asf->asfid2avid[num & 0x7f]; | |
550 | // sequence should be ignored! | |
551 | DO_2BITS(asf->packet_property >> 4, asf->packet_seq, 0); | |
552 | DO_2BITS(asf->packet_property >> 2, asf->packet_frag_offset, 0); | |
553 | DO_2BITS(asf->packet_property, asf->packet_replic_size, 0); | |
554 | //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); | |
555 | if (asf->packet_replic_size >= 8) { | |
556 | asf->packet_obj_size = get_le32(pb); | |
557 | if(asf->packet_obj_size >= (1<<24) || asf->packet_obj_size <= 0){ | |
558 | av_log(s, AV_LOG_ERROR, "packet_obj_size invalid\n"); | |
559 | return -1; | |
560 | } | |
561 | asf->packet_frag_timestamp = get_le32(pb); // timestamp | |
562 | url_fskip(pb, asf->packet_replic_size - 8); | |
563 | rsize += asf->packet_replic_size; // FIXME - check validity | |
564 | } else if (asf->packet_replic_size==1){ | |
565 | // multipacket - frag_offset is begining timestamp | |
566 | asf->packet_time_start = asf->packet_frag_offset; | |
567 | asf->packet_frag_offset = 0; | |
568 | asf->packet_frag_timestamp = asf->packet_timestamp; | |
569 | ||
570 | asf->packet_time_delta = get_byte(pb); | |
571 | rsize++; | |
572 | }else if(asf->packet_replic_size!=0){ | |
573 | av_log(s, AV_LOG_ERROR, "unexpected packet_replic_size of %d\n", asf->packet_replic_size); | |
574 | return -1; | |
575 | } | |
576 | if (asf->packet_flags & 0x01) { | |
577 | DO_2BITS(asf->packet_segsizetype >> 6, asf->packet_frag_size, 0); // 0 is illegal | |
13f7e4b9 MN |
578 | if(asf->packet_frag_size > asf->packet_size_left - rsize){ |
579 | av_log(s, AV_LOG_ERROR, "packet_frag_size is invalid\n"); | |
580 | return -1; | |
581 | } | |
ae60a857 MN |
582 | //printf("Fragsize %d\n", asf->packet_frag_size); |
583 | } else { | |
584 | asf->packet_frag_size = asf->packet_size_left - rsize; | |
585 | //printf("Using rest %d %d %d\n", asf->packet_frag_size, asf->packet_size_left, rsize); | |
586 | } | |
587 | if (asf->packet_replic_size == 1) { | |
588 | asf->packet_multi_size = asf->packet_frag_size; | |
589 | if (asf->packet_multi_size > asf->packet_size_left) | |
590 | return -1; | |
591 | } | |
592 | asf->packet_size_left -= rsize; | |
593 | //printf("___objsize____ %d %d rs:%d\n", asf->packet_obj_size, asf->packet_frag_offset, rsize); | |
594 | ||
595 | return 0; | |
596 | } | |
597 | ||
de6d9b64 FB |
598 | static int asf_read_packet(AVFormatContext *s, AVPacket *pkt) |
599 | { | |
600 | ASFContext *asf = s->priv_data; | |
2a10020b | 601 | ASFStream *asf_st = 0; |
de6d9b64 | 602 | ByteIOContext *pb = &s->pb; |
1359c2d4 | 603 | //static int pc = 0; |
2a10020b | 604 | for (;;) { |
ceba96cb MN |
605 | if(url_feof(pb)) |
606 | return AVERROR_IO; | |
bb270c08 DB |
607 | if (asf->packet_size_left < FRAME_HEADER_SIZE |
608 | || asf->packet_segments < 1) { | |
609 | //asf->packet_size_left <= asf->packet_padsize) { | |
610 | int ret = asf->packet_size_left + asf->packet_padsize; | |
949b1a13 | 611 | //printf("PacketLeftSize:%d Pad:%d Pos:%"PRId64"\n", asf->packet_size_left, asf->packet_padsize, url_ftell(pb)); |
5b11e081 | 612 | assert(ret>=0); |
bb270c08 DB |
613 | /* fail safe */ |
614 | url_fskip(pb, ret); | |
b04d5d31 MN |
615 | |
616 | ret= (url_ftell(&s->pb) - s->data_offset) % asf->packet_size; | |
617 | if(asf->hdr.max_pktsize == asf->hdr.min_pktsize && ret){ | |
618 | av_log(s, AV_LOG_ERROR, "packet end missaligned skiping %d\n", ret); | |
619 | url_fskip(pb, asf->packet_size - ret); | |
620 | } | |
621 | ||
82b9e4a2 | 622 | asf->packet_pos= url_ftell(&s->pb); |
b6eaae39 KED |
623 | if (asf->data_object_size != (uint64_t)-1 && |
624 | (asf->packet_pos - asf->data_object_offset >= asf->data_object_size)) | |
625 | return AVERROR_IO; /* Do not exceed the size of the data object */ | |
bb270c08 DB |
626 | ret = asf_get_packet(s); |
627 | //printf("READ ASF PACKET %d r:%d c:%d\n", ret, asf->packet_size_left, pc++); | |
ceba96cb MN |
628 | if (ret < 0) |
629 | assert(asf->packet_size_left < FRAME_HEADER_SIZE || asf->packet_segments < 1); | |
2141dc37 | 630 | asf->packet_time_start = 0; |
2a10020b | 631 | continue; |
bb270c08 DB |
632 | } |
633 | if (asf->packet_time_start == 0) { | |
ae60a857 MN |
634 | if(asf_read_frame_header(s) < 0){ |
635 | asf->packet_segments= 0; | |
236116cb | 636 | continue; |
1305a9d5 | 637 | } |
bb270c08 | 638 | if (asf->stream_index < 0 |
f3356e9c MN |
639 | || s->streams[asf->stream_index]->discard >= AVDISCARD_ALL |
640 | || (!asf->packet_key_frame && s->streams[asf->stream_index]->discard >= AVDISCARD_NONKEY) | |
641 | ) { | |
1359c2d4 | 642 | asf->packet_time_start = 0; |
bb270c08 DB |
643 | /* unhandled packet (should not happen) */ |
644 | url_fskip(pb, asf->packet_frag_size); | |
645 | asf->packet_size_left -= asf->packet_frag_size; | |
b9866ebc | 646 | if(asf->stream_index < 0) |
ae60a857 | 647 | av_log(s, AV_LOG_ERROR, "ff asf skip %d (unknown stream)\n", asf->packet_frag_size); |
1359c2d4 | 648 | continue; |
bb270c08 DB |
649 | } |
650 | asf->asf_st = s->streams[asf->stream_index]->priv_data; | |
651 | } | |
652 | asf_st = asf->asf_st; | |
653 | ||
bb270c08 DB |
654 | if (asf->packet_replic_size == 1) { |
655 | // frag_offset is here used as the begining timestamp | |
656 | asf->packet_frag_timestamp = asf->packet_time_start; | |
657 | asf->packet_time_start += asf->packet_time_delta; | |
658 | asf->packet_obj_size = asf->packet_frag_size = get_byte(pb); | |
659 | asf->packet_size_left--; | |
2141dc37 | 660 | asf->packet_multi_size--; |
bb270c08 DB |
661 | if (asf->packet_multi_size < asf->packet_obj_size) |
662 | { | |
663 | asf->packet_time_start = 0; | |
664 | url_fskip(pb, asf->packet_multi_size); | |
665 | asf->packet_size_left -= asf->packet_multi_size; | |
2141dc37 | 666 | continue; |
bb270c08 DB |
667 | } |
668 | asf->packet_multi_size -= asf->packet_obj_size; | |
669 | //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); | |
670 | } | |
200026aa MN |
671 | if (asf_st->pkt.size != asf->packet_obj_size) { //FIXME is this condition sufficient? |
672 | if(asf_st->pkt.data){ | |
673 | av_log(s, AV_LOG_INFO, "freeing incomplete packet size %d, new %d\n", asf_st->pkt.size, asf->packet_obj_size); | |
674 | asf_st->frag_offset = 0; | |
675 | av_free_packet(&asf_st->pkt); | |
676 | } | |
bb270c08 DB |
677 | /* new packet */ |
678 | av_new_packet(&asf_st->pkt, asf->packet_obj_size); | |
679 | asf_st->seq = asf->packet_seq; | |
680 | asf_st->pkt.pts = asf->packet_frag_timestamp; | |
681 | asf_st->pkt.stream_index = asf->stream_index; | |
115329f1 DB |
682 | asf_st->pkt.pos = |
683 | asf_st->packet_pos= asf->packet_pos; | |
684 | //printf("new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n", | |
82b9e4a2 | 685 | //asf->stream_index, asf->packet_key_frame, asf_st->pkt.flags & PKT_FLAG_KEY, |
01f4895c | 686 | //s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO, asf->packet_obj_size); |
bb270c08 DB |
687 | if (s->streams[asf->stream_index]->codec->codec_type == CODEC_TYPE_AUDIO) |
688 | asf->packet_key_frame = 1; | |
689 | if (asf->packet_key_frame) | |
690 | asf_st->pkt.flags |= PKT_FLAG_KEY; | |
691 | } | |
692 | ||
693 | /* read data */ | |
694 | //printf("READ PACKET s:%d os:%d o:%d,%d l:%d DATA:%p\n", | |
695 | // asf->packet_size, asf_st->pkt.size, asf->packet_frag_offset, | |
696 | // asf_st->frag_offset, asf->packet_frag_size, asf_st->pkt.data); | |
697 | asf->packet_size_left -= asf->packet_frag_size; | |
698 | if (asf->packet_size_left < 0) | |
2141dc37 | 699 | continue; |
4c71d727 MN |
700 | |
701 | if( asf->packet_frag_offset >= asf_st->pkt.size | |
702 | || asf->packet_frag_size > asf_st->pkt.size - asf->packet_frag_offset){ | |
703 | av_log(s, AV_LOG_ERROR, "packet fragment position invalid %u,%u not in %u\n", | |
704 | asf->packet_frag_offset, asf->packet_frag_size, asf_st->pkt.size); | |
705 | continue; | |
706 | } | |
707 | ||
bb270c08 DB |
708 | get_buffer(pb, asf_st->pkt.data + asf->packet_frag_offset, |
709 | asf->packet_frag_size); | |
710 | asf_st->frag_offset += asf->packet_frag_size; | |
711 | /* test if whole packet is read */ | |
712 | if (asf_st->frag_offset == asf_st->pkt.size) { | |
713 | /* return packet */ | |
714 | if (asf_st->ds_span > 1) { | |
05219463 MN |
715 | if(asf_st->pkt.size != asf_st->ds_packet_size * asf_st->ds_span){ |
716 | av_log(s, AV_LOG_ERROR, "pkt.size != ds_packet_size * ds_span\n"); | |
717 | }else{ | |
bb270c08 | 718 | /* packet descrambling */ |
191e8ca7 | 719 | uint8_t *newdata = av_malloc(asf_st->pkt.size); |
bb270c08 DB |
720 | if (newdata) { |
721 | int offset = 0; | |
722 | while (offset < asf_st->pkt.size) { | |
723 | int off = offset / asf_st->ds_chunk_size; | |
724 | int row = off / asf_st->ds_span; | |
725 | int col = off % asf_st->ds_span; | |
726 | int idx = row + col * asf_st->ds_packet_size / asf_st->ds_chunk_size; | |
727 | //printf("off:%d row:%d col:%d idx:%d\n", off, row, col, idx); | |
05219463 MN |
728 | |
729 | assert(offset + asf_st->ds_chunk_size <= asf_st->pkt.size); | |
730 | assert(idx+1 <= asf_st->pkt.size / asf_st->ds_chunk_size); | |
bb270c08 DB |
731 | memcpy(newdata + offset, |
732 | asf_st->pkt.data + idx * asf_st->ds_chunk_size, | |
733 | asf_st->ds_chunk_size); | |
734 | offset += asf_st->ds_chunk_size; | |
735 | } | |
736 | av_free(asf_st->pkt.data); | |
737 | asf_st->pkt.data = newdata; | |
738 | } | |
05219463 | 739 | } |
bb270c08 DB |
740 | } |
741 | asf_st->frag_offset = 0; | |
b83e83b9 | 742 | *pkt= asf_st->pkt; |
bb270c08 DB |
743 | //printf("packet %d %d\n", asf_st->pkt.size, asf->packet_frag_size); |
744 | asf_st->pkt.size = 0; | |
745 | asf_st->pkt.data = 0; | |
746 | break; // packet completed | |
747 | } | |
de6d9b64 | 748 | } |
de6d9b64 FB |
749 | return 0; |
750 | } | |
751 | ||
752 | static int asf_read_close(AVFormatContext *s) | |
753 | { | |
de6d9b64 FB |
754 | int i; |
755 | ||
756 | for(i=0;i<s->nb_streams;i++) { | |
bb270c08 DB |
757 | AVStream *st = s->streams[i]; |
758 | av_free(st->priv_data); | |
1ae7518d | 759 | av_free(st->codec->palctrl); |
de6d9b64 | 760 | } |
de6d9b64 FB |
761 | return 0; |
762 | } | |
763 | ||
38376f00 KK |
764 | // Added to support seeking after packets have been read |
765 | // If information is not reset, read_packet fails due to | |
766 | // leftover information from previous reads | |
767 | static void asf_reset_header(AVFormatContext *s) | |
768 | { | |
769 | ASFContext *asf = s->priv_data; | |
82b9e4a2 MN |
770 | ASFStream *asf_st; |
771 | int i; | |
38376f00 KK |
772 | |
773 | asf->packet_nb_frames = 0; | |
38376f00 KK |
774 | asf->packet_size_left = 0; |
775 | asf->packet_segments = 0; | |
776 | asf->packet_flags = 0; | |
777 | asf->packet_property = 0; | |
778 | asf->packet_timestamp = 0; | |
779 | asf->packet_segsizetype = 0; | |
780 | asf->packet_segments = 0; | |
781 | asf->packet_seq = 0; | |
782 | asf->packet_replic_size = 0; | |
783 | asf->packet_key_frame = 0; | |
784 | asf->packet_padsize = 0; | |
785 | asf->packet_frag_offset = 0; | |
786 | asf->packet_frag_size = 0; | |
787 | asf->packet_frag_timestamp = 0; | |
788 | asf->packet_multi_size = 0; | |
789 | asf->packet_obj_size = 0; | |
790 | asf->packet_time_delta = 0; | |
791 | asf->packet_time_start = 0; | |
115329f1 | 792 | |
82b9e4a2 MN |
793 | for(i=0; i<s->nb_streams; i++){ |
794 | asf_st= s->streams[i]->priv_data; | |
795 | av_free_packet(&asf_st->pkt); | |
796 | asf_st->frag_offset=0; | |
797 | asf_st->seq=0; | |
798 | } | |
799 | asf->asf_st= NULL; | |
38376f00 KK |
800 | } |
801 | ||
8d14a25c | 802 | static int64_t asf_read_pts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit) |
38376f00 KK |
803 | { |
804 | ASFContext *asf = s->priv_data; | |
805 | AVPacket pkt1, *pkt = &pkt1; | |
82b9e4a2 | 806 | ASFStream *asf_st; |
580fb5e7 | 807 | int64_t pts; |
82b9e4a2 | 808 | int64_t pos= *ppos; |
3e9245a9 MN |
809 | int i; |
810 | int64_t start_pos[s->nb_streams]; | |
115329f1 | 811 | |
3e9245a9 MN |
812 | for(i=0; i<s->nb_streams; i++){ |
813 | start_pos[i]= pos; | |
814 | } | |
115329f1 | 815 | |
8d14a25c MN |
816 | pos= (pos+asf->packet_size-1-s->data_offset)/asf->packet_size*asf->packet_size+ s->data_offset; |
817 | *ppos= pos; | |
818 | url_fseek(&s->pb, pos, SEEK_SET); | |
115329f1 | 819 | |
82b9e4a2 | 820 | //printf("asf_read_pts\n"); |
82b9e4a2 | 821 | asf_reset_header(s); |
3e9245a9 | 822 | for(;;){ |
82b9e4a2 | 823 | if (av_read_frame(s, pkt) < 0){ |
0b93103a | 824 | av_log(s, AV_LOG_INFO, "asf_read_pts failed\n"); |
bb270c08 | 825 | return AV_NOPTS_VALUE; |
82b9e4a2 | 826 | } |
115329f1 | 827 | |
38cf2a72 | 828 | pts= pkt->pts; |
580fb5e7 MN |
829 | |
830 | av_free_packet(pkt); | |
3e9245a9 MN |
831 | if(pkt->flags&PKT_FLAG_KEY){ |
832 | i= pkt->stream_index; | |
833 | ||
834 | asf_st= s->streams[i]->priv_data; | |
835 | ||
836 | assert((asf_st->packet_pos - s->data_offset) % asf->packet_size == 0); | |
8d14a25c | 837 | pos= asf_st->packet_pos; |
09646bab | 838 | |
52e54612 | 839 | av_add_index_entry(s->streams[i], pos, pts, pkt->size, pos - start_pos[i] + 1, AVINDEX_KEYFRAME); |
8d14a25c | 840 | start_pos[i]= asf_st->packet_pos + 1; |
115329f1 | 841 | |
3e9245a9 MN |
842 | if(pkt->stream_index == stream_index) |
843 | break; | |
844 | } | |
845 | } | |
846 | ||
847 | *ppos= pos; | |
949b1a13 | 848 | //printf("found keyframe at %"PRId64" stream %d stamp:%"PRId64"\n", *ppos, stream_index, pts); |
580fb5e7 MN |
849 | |
850 | return pts; | |
38376f00 KK |
851 | } |
852 | ||
56c96a22 MN |
853 | static void asf_build_simple_index(AVFormatContext *s, int stream_index) |
854 | { | |
855 | GUID g; | |
856 | ASFContext *asf = s->priv_data; | |
857 | int64_t gsize, itime; | |
858 | int64_t pos, current_pos, index_pts; | |
859 | int i; | |
860 | int pct,ict; | |
861 | ||
862 | current_pos = url_ftell(&s->pb); | |
863 | ||
864 | url_fseek(&s->pb, asf->data_object_offset + asf->data_object_size, SEEK_SET); | |
865 | get_guid(&s->pb, &g); | |
866 | if (!memcmp(&g, &index_guid, sizeof(GUID))) { | |
867 | gsize = get_le64(&s->pb); | |
868 | get_guid(&s->pb, &g); | |
869 | itime=get_le64(&s->pb); | |
870 | pct=get_le32(&s->pb); | |
871 | ict=get_le32(&s->pb); | |
ccd3228e | 872 | av_log(NULL, AV_LOG_DEBUG, "itime:0x%"PRIx64", pct:%d, ict:%d\n",itime,pct,ict); |
56c96a22 MN |
873 | |
874 | for (i=0;i<ict;i++){ | |
875 | int pktnum=get_le32(&s->pb); | |
876 | int pktct =get_le16(&s->pb); | |
877 | av_log(NULL, AV_LOG_DEBUG, "pktnum:%d, pktct:%d\n", pktnum, pktct); | |
878 | ||
879 | pos=s->data_offset + asf->packet_size*(int64_t)pktnum; | |
880 | index_pts=av_rescale(itime, i, 10000); | |
881 | ||
882 | av_add_index_entry(s->streams[stream_index], pos, index_pts, asf->packet_size, 0, AVINDEX_KEYFRAME); | |
883 | } | |
52e54612 | 884 | asf->index_read= 1; |
56c96a22 MN |
885 | } |
886 | url_fseek(&s->pb, current_pos, SEEK_SET); | |
887 | } | |
888 | ||
3ba1438d | 889 | static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags) |
2a10020b | 890 | { |
afda223c | 891 | ASFContext *asf = s->priv_data; |
56c96a22 MN |
892 | AVStream *st = s->streams[stream_index]; |
893 | int64_t pos; | |
894 | int index; | |
115329f1 | 895 | |
a602556e | 896 | if (asf->packet_size <= 0) |
38376f00 KK |
897 | return -1; |
898 | ||
52e54612 | 899 | if (!asf->index_read) |
56c96a22 MN |
900 | asf_build_simple_index(s, stream_index); |
901 | ||
52e54612 | 902 | if(!(asf->index_read && st->index_entries)){ |
56c96a22 MN |
903 | if(av_seek_frame_binary(s, stream_index, pts, flags)<0) |
904 | return -1; | |
905 | }else{ | |
906 | index= av_index_search_timestamp(st, pts, flags); | |
907 | if(index<0) | |
908 | return -1; | |
909 | ||
910 | /* find the position */ | |
911 | pos = st->index_entries[index].pos; | |
912 | pts = st->index_entries[index].timestamp; | |
913 | ||
914 | // various attempts to find key frame have failed so far | |
915 | // asf_reset_header(s); | |
916 | // url_fseek(&s->pb, pos, SEEK_SET); | |
917 | // key_pos = pos; | |
918 | // for(i=0;i<16;i++){ | |
919 | // pos = url_ftell(&s->pb); | |
920 | // if (av_read_frame(s, &pkt) < 0){ | |
921 | // av_log(s, AV_LOG_INFO, "seek failed\n"); | |
922 | // return -1; | |
923 | // } | |
924 | // asf_st = s->streams[stream_index]->priv_data; | |
925 | // pos += st->parser->frame_offset; | |
926 | // | |
927 | // if (pkt.size > b) { | |
928 | // b = pkt.size; | |
929 | // key_pos = pos; | |
930 | // } | |
931 | // | |
932 | // av_free_packet(&pkt); | |
933 | // } | |
934 | ||
935 | /* do the seek */ | |
ccd3228e | 936 | av_log(NULL, AV_LOG_DEBUG, "SEEKTO: %"PRId64"\n", pos); |
56c96a22 MN |
937 | url_fseek(&s->pb, pos, SEEK_SET); |
938 | } | |
38376f00 KK |
939 | asf_reset_header(s); |
940 | return 0; | |
2a10020b ZK |
941 | } |
942 | ||
ff70e601 | 943 | AVInputFormat asf_demuxer = { |
c9a65ca8 FB |
944 | "asf", |
945 | "asf format", | |
946 | sizeof(ASFContext), | |
947 | asf_probe, | |
948 | asf_read_header, | |
949 | asf_read_packet, | |
950 | asf_read_close, | |
2a10020b | 951 | asf_read_seek, |
8d14a25c | 952 | asf_read_pts, |
c9a65ca8 | 953 | }; |