00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include "libavutil/common.h"
00025 #include "libavutil/avstring.h"
00026 #include "libavcodec/mpegaudio.h"
00027 #include "avformat.h"
00028 #include "riff.h"
00029 #include "asf.h"
00030 #include "asfcrypt.h"
00031 #include "avlanguage.h"
00032
00033 void ff_mms_set_stream_selection(URLContext *h, AVFormatContext *format);
00034
00035 typedef struct {
00036 int asfid2avid[128];
00037 ASFStream streams[128];
00038 uint32_t stream_bitrates[128];
00039 AVRational dar[128];
00040 char stream_languages[128][6];
00041
00042
00043 int packet_size_left;
00044
00045 uint64_t data_offset;
00046 uint64_t data_object_offset;
00047 uint64_t data_object_size;
00048 int index_read;
00049
00050 ASFMainHeader hdr;
00051
00052 int packet_flags;
00053 int packet_property;
00054 int packet_timestamp;
00055 int packet_segsizetype;
00056 int packet_segments;
00057 int packet_seq;
00058 int packet_replic_size;
00059 int packet_key_frame;
00060 int packet_padsize;
00061 unsigned int packet_frag_offset;
00062 unsigned int packet_frag_size;
00063 int64_t packet_frag_timestamp;
00064 int packet_multi_size;
00065 int packet_obj_size;
00066 int packet_time_delta;
00067 int packet_time_start;
00068 int64_t packet_pos;
00069
00070 int stream_index;
00071
00072 ASFStream* asf_st;
00073 } ASFContext;
00074
00075 #undef NDEBUG
00076 #include <assert.h>
00077
00078 #define ASF_MAX_STREAMS 127
00079 #define FRAME_HEADER_SIZE 17
00080
00081
00082 static const ff_asf_guid index_guid = {
00083 0x90, 0x08, 0x00, 0x33, 0xb1, 0xe5, 0xcf, 0x11, 0x89, 0xf4, 0x00, 0xa0, 0xc9, 0x03, 0x49, 0xcb
00084 };
00085
00086 static const ff_asf_guid stream_bitrate_guid = {
00087 0xce, 0x75, 0xf8, 0x7b, 0x8d, 0x46, 0xd1, 0x11, 0x8d, 0x82, 0x00, 0x60, 0x97, 0xc9, 0xa2, 0xb2
00088 };
00089
00090
00091
00092 #ifdef DEBUG
00093 #define PRINT_IF_GUID(g,cmp) \
00094 if (!ff_guidcmp(g, &cmp)) \
00095 av_dlog(NULL, "(GUID: %s) ", #cmp)
00096
00097 static void print_guid(const ff_asf_guid *g)
00098 {
00099 int i;
00100 PRINT_IF_GUID(g, ff_asf_header);
00101 else PRINT_IF_GUID(g, ff_asf_file_header);
00102 else PRINT_IF_GUID(g, ff_asf_stream_header);
00103 else PRINT_IF_GUID(g, ff_asf_audio_stream);
00104 else PRINT_IF_GUID(g, ff_asf_audio_conceal_none);
00105 else PRINT_IF_GUID(g, ff_asf_video_stream);
00106 else PRINT_IF_GUID(g, ff_asf_video_conceal_none);
00107 else PRINT_IF_GUID(g, ff_asf_command_stream);
00108 else PRINT_IF_GUID(g, ff_asf_comment_header);
00109 else PRINT_IF_GUID(g, ff_asf_codec_comment_header);
00110 else PRINT_IF_GUID(g, ff_asf_codec_comment1_header);
00111 else PRINT_IF_GUID(g, ff_asf_data_header);
00112 else PRINT_IF_GUID(g, index_guid);
00113 else PRINT_IF_GUID(g, ff_asf_head1_guid);
00114 else PRINT_IF_GUID(g, ff_asf_head2_guid);
00115 else PRINT_IF_GUID(g, ff_asf_my_guid);
00116 else PRINT_IF_GUID(g, ff_asf_ext_stream_header);
00117 else PRINT_IF_GUID(g, ff_asf_extended_content_header);
00118 else PRINT_IF_GUID(g, ff_asf_ext_stream_embed_stream_header);
00119 else PRINT_IF_GUID(g, ff_asf_ext_stream_audio_stream);
00120 else PRINT_IF_GUID(g, ff_asf_metadata_header);
00121 else PRINT_IF_GUID(g, ff_asf_marker_header);
00122 else PRINT_IF_GUID(g, stream_bitrate_guid);
00123 else PRINT_IF_GUID(g, ff_asf_language_guid);
00124 else
00125 av_dlog(NULL, "(GUID: unknown) ");
00126 for(i=0;i<16;i++)
00127 av_dlog(NULL, " 0x%02x,", (*g)[i]);
00128 av_dlog(NULL, "}\n");
00129 }
00130 #undef PRINT_IF_GUID
00131 #else
00132 #define print_guid(g)
00133 #endif
00134
00135 void ff_get_guid(AVIOContext *s, ff_asf_guid *g)
00136 {
00137 assert(sizeof(*g) == 16);
00138 avio_read(s, *g, sizeof(*g));
00139 }
00140
00141 static int asf_probe(AVProbeData *pd)
00142 {
00143
00144 if (!ff_guidcmp(pd->buf, &ff_asf_header))
00145 return AVPROBE_SCORE_MAX;
00146 else
00147 return 0;
00148 }
00149
00150 static int get_value(AVIOContext *pb, int type){
00151 switch(type){
00152 case 2: return avio_rl32(pb);
00153 case 3: return avio_rl32(pb);
00154 case 4: return avio_rl64(pb);
00155 case 5: return avio_rl16(pb);
00156 default:return INT_MIN;
00157 }
00158 }
00159
00160 static void get_tag(AVFormatContext *s, const char *key, int type, int len)
00161 {
00162 char *value;
00163 int64_t off = avio_tell(s->pb);
00164
00165 if ((unsigned)len >= (UINT_MAX - 1)/2)
00166 return;
00167
00168 value = av_malloc(2*len+1);
00169 if (!value)
00170 goto finish;
00171
00172 if (type == 0) {
00173 avio_get_str16le(s->pb, len, value, 2*len + 1);
00174 } else if (type > 1 && type <= 5) {
00175 uint64_t num = get_value(s->pb, type);
00176 snprintf(value, len, "%"PRIu64, num);
00177 } else {
00178 av_log(s, AV_LOG_DEBUG, "Unsupported value type %d in tag %s.\n", type, key);
00179 goto finish;
00180 }
00181 if (*value)
00182 av_metadata_set2(&s->metadata, key, value, 0);
00183 finish:
00184 av_freep(&value);
00185 avio_seek(s->pb, off + len, SEEK_SET);
00186 }
00187
00188 static int asf_read_file_properties(AVFormatContext *s, int64_t size)
00189 {
00190 ASFContext *asf = s->priv_data;
00191 AVIOContext *pb = s->pb;
00192
00193 ff_get_guid(pb, &asf->hdr.guid);
00194 asf->hdr.file_size = avio_rl64(pb);
00195 asf->hdr.create_time = avio_rl64(pb);
00196 avio_rl64(pb);
00197 asf->hdr.play_time = avio_rl64(pb);
00198 asf->hdr.send_time = avio_rl64(pb);
00199 asf->hdr.preroll = avio_rl32(pb);
00200 asf->hdr.ignore = avio_rl32(pb);
00201 asf->hdr.flags = avio_rl32(pb);
00202 asf->hdr.min_pktsize = avio_rl32(pb);
00203 asf->hdr.max_pktsize = avio_rl32(pb);
00204 asf->hdr.max_bitrate = avio_rl32(pb);
00205 s->packet_size = asf->hdr.max_pktsize;
00206
00207 return 0;
00208 }
00209
00210 static int asf_read_stream_properties(AVFormatContext *s, int64_t size)
00211 {
00212 ASFContext *asf = s->priv_data;
00213 AVIOContext *pb = s->pb;
00214 AVStream *st;
00215 ASFStream *asf_st;
00216 ff_asf_guid g;
00217 enum AVMediaType type;
00218 int type_specific_size, sizeX;
00219 uint64_t total_size;
00220 unsigned int tag1;
00221 int64_t pos1, pos2, start_time;
00222 int test_for_ext_stream_audio, is_dvr_ms_audio=0;
00223
00224 if (s->nb_streams == ASF_MAX_STREAMS) {
00225 av_log(s, AV_LOG_ERROR, "too many streams\n");
00226 return AVERROR(EINVAL);
00227 }
00228
00229 pos1 = avio_tell(pb);
00230
00231 st = av_new_stream(s, 0);
00232 if (!st)
00233 return AVERROR(ENOMEM);
00234 av_set_pts_info(st, 32, 1, 1000);
00235 asf_st = av_mallocz(sizeof(ASFStream));
00236 if (!asf_st)
00237 return AVERROR(ENOMEM);
00238 st->priv_data = asf_st;
00239 start_time = asf->hdr.preroll;
00240
00241 asf_st->stream_language_index = 128;
00242
00243 if(!(asf->hdr.flags & 0x01)) {
00244 st->duration = asf->hdr.play_time /
00245 (10000000 / 1000) - start_time;
00246 }
00247 ff_get_guid(pb, &g);
00248
00249 test_for_ext_stream_audio = 0;
00250 if (!ff_guidcmp(&g, &ff_asf_audio_stream)) {
00251 type = AVMEDIA_TYPE_AUDIO;
00252 } else if (!ff_guidcmp(&g, &ff_asf_video_stream)) {
00253 type = AVMEDIA_TYPE_VIDEO;
00254 } else if (!ff_guidcmp(&g, &ff_asf_jfif_media)) {
00255 type = AVMEDIA_TYPE_VIDEO;
00256 st->codec->codec_id = CODEC_ID_MJPEG;
00257 } else if (!ff_guidcmp(&g, &ff_asf_command_stream)) {
00258 type = AVMEDIA_TYPE_DATA;
00259 } else if (!ff_guidcmp(&g, &ff_asf_ext_stream_embed_stream_header)) {
00260 test_for_ext_stream_audio = 1;
00261 type = AVMEDIA_TYPE_UNKNOWN;
00262 } else {
00263 return -1;
00264 }
00265 ff_get_guid(pb, &g);
00266 total_size = avio_rl64(pb);
00267 type_specific_size = avio_rl32(pb);
00268 avio_rl32(pb);
00269 st->id = avio_rl16(pb) & 0x7f;
00270
00271 asf->asfid2avid[st->id] = s->nb_streams - 1;
00272
00273 avio_rl32(pb);
00274
00275 if (test_for_ext_stream_audio) {
00276 ff_get_guid(pb, &g);
00277 if (!ff_guidcmp(&g, &ff_asf_ext_stream_audio_stream)) {
00278 type = AVMEDIA_TYPE_AUDIO;
00279 is_dvr_ms_audio=1;
00280 ff_get_guid(pb, &g);
00281 avio_rl32(pb);
00282 avio_rl32(pb);
00283 avio_rl32(pb);
00284 ff_get_guid(pb, &g);
00285 avio_rl32(pb);
00286 }
00287 }
00288
00289 st->codec->codec_type = type;
00290 if (type == AVMEDIA_TYPE_AUDIO) {
00291 ff_get_wav_header(pb, st->codec, type_specific_size);
00292 if (is_dvr_ms_audio) {
00293
00294
00295 st->codec->codec_id = CODEC_ID_PROBE;
00296 st->codec->codec_tag = 0;
00297 }
00298 if (st->codec->codec_id == CODEC_ID_AAC) {
00299 st->need_parsing = AVSTREAM_PARSE_NONE;
00300 } else {
00301 st->need_parsing = AVSTREAM_PARSE_FULL;
00302 }
00303
00304 pos2 = avio_tell(pb);
00305 if (size >= (pos2 + 8 - pos1 + 24)) {
00306 asf_st->ds_span = avio_r8(pb);
00307 asf_st->ds_packet_size = avio_rl16(pb);
00308 asf_st->ds_chunk_size = avio_rl16(pb);
00309 avio_rl16(pb);
00310 avio_r8(pb);
00311 }
00312
00313
00314
00315 if (asf_st->ds_span > 1) {
00316 if (!asf_st->ds_chunk_size
00317 || (asf_st->ds_packet_size/asf_st->ds_chunk_size <= 1)
00318 || asf_st->ds_packet_size % asf_st->ds_chunk_size)
00319 asf_st->ds_span = 0;
00320 }
00321 switch (st->codec->codec_id) {
00322 case CODEC_ID_MP3:
00323 st->codec->frame_size = MPA_FRAME_SIZE;
00324 break;
00325 case CODEC_ID_PCM_S16LE:
00326 case CODEC_ID_PCM_S16BE:
00327 case CODEC_ID_PCM_U16LE:
00328 case CODEC_ID_PCM_U16BE:
00329 case CODEC_ID_PCM_S8:
00330 case CODEC_ID_PCM_U8:
00331 case CODEC_ID_PCM_ALAW:
00332 case CODEC_ID_PCM_MULAW:
00333 st->codec->frame_size = 1;
00334 break;
00335 default:
00336
00337 st->codec->frame_size = 1;
00338 break;
00339 }
00340 } else if (type == AVMEDIA_TYPE_VIDEO &&
00341 size - (avio_tell(pb) - pos1 + 24) >= 51) {
00342 avio_rl32(pb);
00343 avio_rl32(pb);
00344 avio_r8(pb);
00345 avio_rl16(pb);
00346 sizeX= avio_rl32(pb);
00347 st->codec->width = avio_rl32(pb);
00348 st->codec->height = avio_rl32(pb);
00349
00350 avio_rl16(pb);
00351 st->codec->bits_per_coded_sample = avio_rl16(pb);
00352 tag1 = avio_rl32(pb);
00353 avio_seek(pb, 20, SEEK_CUR);
00354
00355 if (sizeX > 40) {
00356 st->codec->extradata_size = sizeX - 40;
00357 st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
00358 avio_read(pb, st->codec->extradata, st->codec->extradata_size);
00359 }
00360
00361
00362
00363
00364 if (st->codec->extradata_size && (st->codec->bits_per_coded_sample <= 8)) {
00365 int av_unused i;
00366 st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl));
00367 #if HAVE_BIGENDIAN
00368 for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++)
00369 st->codec->palctrl->palette[i] = av_bswap32(((uint32_t*)st->codec->extradata)[i]);
00370 #else
00371 memcpy(st->codec->palctrl->palette, st->codec->extradata,
00372 FFMIN(st->codec->extradata_size, AVPALETTE_SIZE));
00373 #endif
00374 st->codec->palctrl->palette_changed = 1;
00375 }
00376
00377 st->codec->codec_tag = tag1;
00378 st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, tag1);
00379 if(tag1 == MKTAG('D', 'V', 'R', ' ')){
00380 st->need_parsing = AVSTREAM_PARSE_FULL;
00381
00382 st->codec->width =
00383 st->codec->height = 0;
00384 av_freep(&st->codec->extradata);
00385 st->codec->extradata_size=0;
00386 }
00387 if(st->codec->codec_id == CODEC_ID_H264)
00388 st->need_parsing = AVSTREAM_PARSE_FULL_ONCE;
00389 }
00390 pos2 = avio_tell(pb);
00391 avio_seek(pb, size - (pos2 - pos1 + 24), SEEK_CUR);
00392
00393 return 0;
00394 }
00395
00396 static int asf_read_ext_stream_properties(AVFormatContext *s, int64_t size)
00397 {
00398 ASFContext *asf = s->priv_data;
00399 AVIOContext *pb = s->pb;
00400 ff_asf_guid g;
00401 int ext_len, payload_ext_ct, stream_ct, i;
00402 uint32_t ext_d, leak_rate, stream_num;
00403 unsigned int stream_languageid_index;
00404
00405 avio_rl64(pb);
00406 avio_rl64(pb);
00407 leak_rate = avio_rl32(pb);
00408 avio_rl32(pb);
00409 avio_rl32(pb);
00410 avio_rl32(pb);
00411 avio_rl32(pb);
00412 avio_rl32(pb);
00413 avio_rl32(pb);
00414 avio_rl32(pb);
00415 stream_num = avio_rl16(pb);
00416
00417 stream_languageid_index = avio_rl16(pb);
00418 if (stream_num < 128)
00419 asf->streams[stream_num].stream_language_index = stream_languageid_index;
00420
00421 avio_rl64(pb);
00422 stream_ct = avio_rl16(pb);
00423 payload_ext_ct = avio_rl16(pb);
00424
00425 if (stream_num < 128)
00426 asf->stream_bitrates[stream_num] = leak_rate;
00427
00428 for (i=0; i<stream_ct; i++){
00429 avio_rl16(pb);
00430 ext_len = avio_rl16(pb);
00431 avio_seek(pb, ext_len, SEEK_CUR);
00432 }
00433
00434 for (i=0; i<payload_ext_ct; i++){
00435 ff_get_guid(pb, &g);
00436 ext_d=avio_rl16(pb);
00437 ext_len=avio_rl32(pb);
00438 avio_seek(pb, ext_len, SEEK_CUR);
00439 }
00440
00441 return 0;
00442 }
00443
00444 static int asf_read_content_desc(AVFormatContext *s, int64_t size)
00445 {
00446 AVIOContext *pb = s->pb;
00447 int len1, len2, len3, len4, len5;
00448
00449 len1 = avio_rl16(pb);
00450 len2 = avio_rl16(pb);
00451 len3 = avio_rl16(pb);
00452 len4 = avio_rl16(pb);
00453 len5 = avio_rl16(pb);
00454 get_tag(s, "title" , 0, len1);
00455 get_tag(s, "author" , 0, len2);
00456 get_tag(s, "copyright", 0, len3);
00457 get_tag(s, "comment" , 0, len4);
00458 avio_seek(pb, len5, SEEK_CUR);
00459
00460 return 0;
00461 }
00462
00463 static int asf_read_ext_content_desc(AVFormatContext *s, int64_t size)
00464 {
00465 AVIOContext *pb = s->pb;
00466 ASFContext *asf = s->priv_data;
00467 int desc_count, i, ret;
00468
00469 desc_count = avio_rl16(pb);
00470 for(i=0;i<desc_count;i++) {
00471 int name_len,value_type,value_len;
00472 char name[1024];
00473
00474 name_len = avio_rl16(pb);
00475 if (name_len%2)
00476 name_len += 1;
00477 if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len)
00478 avio_seek(pb, name_len - ret, SEEK_CUR);
00479 value_type = avio_rl16(pb);
00480 value_len = avio_rl16(pb);
00481 if (!value_type && value_len%2)
00482 value_len += 1;
00487 if (!strcmp(name, "AspectRatioX")){
00488 asf->dar[0].num= get_value(s->pb, value_type);
00489 } else if(!strcmp(name, "AspectRatioY")){
00490 asf->dar[0].den= get_value(s->pb, value_type);
00491 } else
00492 get_tag(s, name, value_type, value_len);
00493 }
00494
00495 return 0;
00496 }
00497
00498 static int asf_read_language_list(AVFormatContext *s, int64_t size)
00499 {
00500 AVIOContext *pb = s->pb;
00501 ASFContext *asf = s->priv_data;
00502 int j, ret;
00503 int stream_count = avio_rl16(pb);
00504 for(j = 0; j < stream_count; j++) {
00505 char lang[6];
00506 unsigned int lang_len = avio_r8(pb);
00507 if ((ret = avio_get_str16le(pb, lang_len, lang, sizeof(lang))) < lang_len)
00508 avio_seek(pb, lang_len - ret, SEEK_CUR);
00509 if (j < 128)
00510 av_strlcpy(asf->stream_languages[j], lang, sizeof(*asf->stream_languages));
00511 }
00512
00513 return 0;
00514 }
00515
00516 static int asf_read_metadata(AVFormatContext *s, int64_t size)
00517 {
00518 AVIOContext *pb = s->pb;
00519 ASFContext *asf = s->priv_data;
00520 int n, stream_num, name_len, value_len, value_type, value_num;
00521 int ret, i;
00522 n = avio_rl16(pb);
00523
00524 for(i=0;i<n;i++) {
00525 char name[1024];
00526
00527 avio_rl16(pb);
00528 stream_num= avio_rl16(pb);
00529 name_len= avio_rl16(pb);
00530 value_type= avio_rl16(pb);
00531 value_len= avio_rl32(pb);
00532
00533 if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len)
00534 avio_seek(pb, name_len - ret, SEEK_CUR);
00535
00536 value_num= avio_rl16(pb);
00537 avio_seek(pb, value_len - 2, SEEK_CUR);
00538
00539 if(stream_num<128){
00540 if (!strcmp(name, "AspectRatioX")) asf->dar[stream_num].num= value_num;
00541 else if(!strcmp(name, "AspectRatioY")) asf->dar[stream_num].den= value_num;
00542 }
00543 }
00544
00545 return 0;
00546 }
00547
00548 static int asf_read_marker(AVFormatContext *s, int64_t size)
00549 {
00550 AVIOContext *pb = s->pb;
00551 int i, count, name_len, ret;
00552 char name[1024];
00553
00554 avio_rl64(pb);
00555 avio_rl64(pb);
00556 count = avio_rl32(pb);
00557 avio_rl16(pb);
00558 name_len = avio_rl16(pb);
00559 for(i=0;i<name_len;i++){
00560 avio_r8(pb);
00561 }
00562
00563 for(i=0;i<count;i++){
00564 int64_t pres_time;
00565 int name_len;
00566
00567 avio_rl64(pb);
00568 pres_time = avio_rl64(pb);
00569 avio_rl16(pb);
00570 avio_rl32(pb);
00571 avio_rl32(pb);
00572 name_len = avio_rl32(pb);
00573 if ((ret = avio_get_str16le(pb, name_len * 2, name, sizeof(name))) < name_len)
00574 avio_seek(pb, name_len - ret, SEEK_CUR);
00575 ff_new_chapter(s, i, (AVRational){1, 10000000}, pres_time, AV_NOPTS_VALUE, name );
00576 }
00577
00578 return 0;
00579 }
00580
00581 static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
00582 {
00583 ASFContext *asf = s->priv_data;
00584 ff_asf_guid g;
00585 AVIOContext *pb = s->pb;
00586 int i;
00587 int64_t gsize;
00588
00589 ff_get_guid(pb, &g);
00590 if (ff_guidcmp(&g, &ff_asf_header))
00591 return -1;
00592 avio_rl64(pb);
00593 avio_rl32(pb);
00594 avio_r8(pb);
00595 avio_r8(pb);
00596 memset(&asf->asfid2avid, -1, sizeof(asf->asfid2avid));
00597 for(;;) {
00598 uint64_t gpos= avio_tell(pb);
00599 ff_get_guid(pb, &g);
00600 gsize = avio_rl64(pb);
00601 av_dlog(s, "%08"PRIx64": ", gpos);
00602 print_guid(&g);
00603 av_dlog(s, " size=0x%"PRIx64"\n", gsize);
00604 if (!ff_guidcmp(&g, &ff_asf_data_header)) {
00605 asf->data_object_offset = avio_tell(pb);
00606
00607 if (!(asf->hdr.flags & 0x01) && gsize >= 100) {
00608 asf->data_object_size = gsize - 24;
00609 } else {
00610 asf->data_object_size = (uint64_t)-1;
00611 }
00612 break;
00613 }
00614 if (gsize < 24)
00615 return -1;
00616 if (!ff_guidcmp(&g, &ff_asf_file_header)) {
00617 asf_read_file_properties(s, gsize);
00618 } else if (!ff_guidcmp(&g, &ff_asf_stream_header)) {
00619 asf_read_stream_properties(s, gsize);
00620 } else if (!ff_guidcmp(&g, &ff_asf_comment_header)) {
00621 asf_read_content_desc(s, gsize);
00622 } else if (!ff_guidcmp(&g, &ff_asf_language_guid)) {
00623 asf_read_language_list(s, gsize);
00624 } else if (!ff_guidcmp(&g, &ff_asf_extended_content_header)) {
00625 asf_read_ext_content_desc(s, gsize);
00626 } else if (!ff_guidcmp(&g, &ff_asf_metadata_header)) {
00627 asf_read_metadata(s, gsize);
00628 } else if (!ff_guidcmp(&g, &ff_asf_ext_stream_header)) {
00629 asf_read_ext_stream_properties(s, gsize);
00630
00631
00632
00633 continue;
00634 } else if (!ff_guidcmp(&g, &ff_asf_head1_guid)) {
00635 int v1, v2;
00636 ff_get_guid(pb, &g);
00637 v1 = avio_rl32(pb);
00638 v2 = avio_rl16(pb);
00639 continue;
00640 } else if (!ff_guidcmp(&g, &ff_asf_marker_header)) {
00641 asf_read_marker(s, gsize);
00642 } else if (url_feof(pb)) {
00643 return -1;
00644 } else {
00645 if (!s->keylen) {
00646 if (!ff_guidcmp(&g, &ff_asf_content_encryption)) {
00647 av_log(s, AV_LOG_WARNING, "DRM protected stream detected, decoding will likely fail!\n");
00648 } else if (!ff_guidcmp(&g, &ff_asf_ext_content_encryption)) {
00649 av_log(s, AV_LOG_WARNING, "Ext DRM protected stream detected, decoding will likely fail!\n");
00650 } else if (!ff_guidcmp(&g, &ff_asf_digital_signature)) {
00651 av_log(s, AV_LOG_WARNING, "Digital signature detected, decoding will likely fail!\n");
00652 }
00653 }
00654 }
00655 if(avio_tell(pb) != gpos + gsize)
00656 av_log(s, AV_LOG_DEBUG, "gpos mismatch our pos=%"PRIu64", end=%"PRIu64"\n", avio_tell(pb)-gpos, gsize);
00657 avio_seek(pb, gpos + gsize, SEEK_SET);
00658 }
00659 ff_get_guid(pb, &g);
00660 avio_rl64(pb);
00661 avio_r8(pb);
00662 avio_r8(pb);
00663 if (url_feof(pb))
00664 return -1;
00665 asf->data_offset = avio_tell(pb);
00666 asf->packet_size_left = 0;
00667
00668
00669 for(i=0; i<128; i++){
00670 int stream_num= asf->asfid2avid[i];
00671 if(stream_num>=0){
00672 AVStream *st = s->streams[stream_num];
00673 if (!st->codec->bit_rate)
00674 st->codec->bit_rate = asf->stream_bitrates[i];
00675 if (asf->dar[i].num > 0 && asf->dar[i].den > 0){
00676 av_reduce(&st->sample_aspect_ratio.num,
00677 &st->sample_aspect_ratio.den,
00678 asf->dar[i].num, asf->dar[i].den, INT_MAX);
00679 } else if ((asf->dar[0].num > 0) && (asf->dar[0].den > 0) && (st->codec->codec_type==AVMEDIA_TYPE_VIDEO))
00680 av_reduce(&st->sample_aspect_ratio.num,
00681 &st->sample_aspect_ratio.den,
00682 asf->dar[0].num, asf->dar[0].den, INT_MAX);
00683
00684
00685
00686
00687 if (asf->streams[i].stream_language_index < 128) {
00688 const char *rfc1766 = asf->stream_languages[asf->streams[i].stream_language_index];
00689 if (rfc1766 && strlen(rfc1766) > 1) {
00690 const char primary_tag[3] = { rfc1766[0], rfc1766[1], '\0' };
00691 const char *iso6392 = av_convert_lang_to(primary_tag, AV_LANG_ISO639_2_BIBL);
00692 if (iso6392)
00693 av_metadata_set2(&st->metadata, "language", iso6392, 0);
00694 }
00695 }
00696 }
00697 }
00698
00699 ff_metadata_conv(&s->metadata, NULL, ff_asf_metadata_conv);
00700
00701 return 0;
00702 }
00703
00704 #define DO_2BITS(bits, var, defval) \
00705 switch (bits & 3) \
00706 { \
00707 case 3: var = avio_rl32(pb); rsize += 4; break; \
00708 case 2: var = avio_rl16(pb); rsize += 2; break; \
00709 case 1: var = avio_r8(pb); rsize++; break; \
00710 default: var = defval; break; \
00711 }
00712
00719 static int ff_asf_get_packet(AVFormatContext *s, AVIOContext *pb)
00720 {
00721 ASFContext *asf = s->priv_data;
00722 uint32_t packet_length, padsize;
00723 int rsize = 8;
00724 int c, d, e, off;
00725
00726
00727 off= 32768;
00728 if (s->packet_size > 0)
00729 off= (avio_tell(pb) - s->data_offset) % s->packet_size + 3;
00730
00731 c=d=e=-1;
00732 while(off-- > 0){
00733 c=d; d=e;
00734 e= avio_r8(pb);
00735 if(c == 0x82 && !d && !e)
00736 break;
00737 }
00738
00739 if (c != 0x82) {
00746 if (url_ferror(pb) == AVERROR(EAGAIN))
00747 return AVERROR(EAGAIN);
00748 if (!url_feof(pb))
00749 av_log(s, AV_LOG_ERROR, "ff asf bad header %x at:%"PRId64"\n", c, avio_tell(pb));
00750 }
00751 if ((c & 0x8f) == 0x82) {
00752 if (d || e) {
00753 if (!url_feof(pb))
00754 av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n");
00755 return -1;
00756 }
00757 c= avio_r8(pb);
00758 d= avio_r8(pb);
00759 rsize+=3;
00760 }else{
00761 avio_seek(pb, -1, SEEK_CUR);
00762 }
00763
00764 asf->packet_flags = c;
00765 asf->packet_property = d;
00766
00767 DO_2BITS(asf->packet_flags >> 5, packet_length, s->packet_size);
00768 DO_2BITS(asf->packet_flags >> 1, padsize, 0);
00769 DO_2BITS(asf->packet_flags >> 3, padsize, 0);
00770
00771
00772 if(!packet_length || packet_length >= (1U<<29)){
00773 av_log(s, AV_LOG_ERROR, "invalid packet_length %d at:%"PRId64"\n", packet_length, avio_tell(pb));
00774 return -1;
00775 }
00776 if(padsize >= packet_length){
00777 av_log(s, AV_LOG_ERROR, "invalid padsize %d at:%"PRId64"\n", padsize, avio_tell(pb));
00778 return -1;
00779 }
00780
00781 asf->packet_timestamp = avio_rl32(pb);
00782 avio_rl16(pb);
00783
00784
00785 if (asf->packet_flags & 0x01) {
00786 asf->packet_segsizetype = avio_r8(pb); rsize++;
00787 asf->packet_segments = asf->packet_segsizetype & 0x3f;
00788 } else {
00789 asf->packet_segments = 1;
00790 asf->packet_segsizetype = 0x80;
00791 }
00792 asf->packet_size_left = packet_length - padsize - rsize;
00793 if (packet_length < asf->hdr.min_pktsize)
00794 padsize += asf->hdr.min_pktsize - packet_length;
00795 asf->packet_padsize = padsize;
00796 av_dlog(s, "packet: size=%d padsize=%d left=%d\n", s->packet_size, asf->packet_padsize, asf->packet_size_left);
00797 return 0;
00798 }
00799
00804 static int asf_read_frame_header(AVFormatContext *s, AVIOContext *pb){
00805 ASFContext *asf = s->priv_data;
00806 int rsize = 1;
00807 int num = avio_r8(pb);
00808 int64_t ts0, ts1;
00809
00810 asf->packet_segments--;
00811 asf->packet_key_frame = num >> 7;
00812 asf->stream_index = asf->asfid2avid[num & 0x7f];
00813
00814 DO_2BITS(asf->packet_property >> 4, asf->packet_seq, 0);
00815 DO_2BITS(asf->packet_property >> 2, asf->packet_frag_offset, 0);
00816 DO_2BITS(asf->packet_property, asf->packet_replic_size, 0);
00817
00818 if (asf->packet_replic_size >= 8) {
00819 asf->packet_obj_size = avio_rl32(pb);
00820 if(asf->packet_obj_size >= (1<<24) || asf->packet_obj_size <= 0){
00821 av_log(s, AV_LOG_ERROR, "packet_obj_size invalid\n");
00822 return -1;
00823 }
00824 asf->packet_frag_timestamp = avio_rl32(pb);
00825 if(asf->packet_replic_size >= 8+38+4){
00826
00827
00828
00829 avio_seek(pb, 10, SEEK_CUR);
00830 ts0= avio_rl64(pb);
00831 ts1= avio_rl64(pb);
00832 avio_seek(pb, 12, SEEK_CUR);
00833 avio_rl32(pb);
00834 avio_seek(pb, asf->packet_replic_size - 8 - 38 - 4, SEEK_CUR);
00835 if(ts0!= -1) asf->packet_frag_timestamp= ts0/10000;
00836 else asf->packet_frag_timestamp= AV_NOPTS_VALUE;
00837 }else
00838 avio_seek(pb, asf->packet_replic_size - 8, SEEK_CUR);
00839 rsize += asf->packet_replic_size;
00840 } else if (asf->packet_replic_size==1){
00841
00842 asf->packet_time_start = asf->packet_frag_offset;
00843 asf->packet_frag_offset = 0;
00844 asf->packet_frag_timestamp = asf->packet_timestamp;
00845
00846 asf->packet_time_delta = avio_r8(pb);
00847 rsize++;
00848 }else if(asf->packet_replic_size!=0){
00849 av_log(s, AV_LOG_ERROR, "unexpected packet_replic_size of %d\n", asf->packet_replic_size);
00850 return -1;
00851 }
00852 if (asf->packet_flags & 0x01) {
00853 DO_2BITS(asf->packet_segsizetype >> 6, asf->packet_frag_size, 0);
00854 if(asf->packet_frag_size > asf->packet_size_left - rsize){
00855 av_log(s, AV_LOG_ERROR, "packet_frag_size is invalid\n");
00856 return -1;
00857 }
00858
00859 } else {
00860 asf->packet_frag_size = asf->packet_size_left - rsize;
00861
00862 }
00863 if (asf->packet_replic_size == 1) {
00864 asf->packet_multi_size = asf->packet_frag_size;
00865 if (asf->packet_multi_size > asf->packet_size_left)
00866 return -1;
00867 }
00868 asf->packet_size_left -= rsize;
00869
00870
00871 return 0;
00872 }
00873
00883 static int ff_asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
00884 {
00885 ASFContext *asf = s->priv_data;
00886 ASFStream *asf_st = 0;
00887 for (;;) {
00888 int ret;
00889 if(url_feof(pb))
00890 return AVERROR_EOF;
00891 if (asf->packet_size_left < FRAME_HEADER_SIZE
00892 || asf->packet_segments < 1) {
00893
00894 int ret = asf->packet_size_left + asf->packet_padsize;
00895
00896 assert(ret>=0);
00897
00898 avio_seek(pb, ret, SEEK_CUR);
00899
00900 asf->packet_pos= avio_tell(pb);
00901 if (asf->data_object_size != (uint64_t)-1 &&
00902 (asf->packet_pos - asf->data_object_offset >= asf->data_object_size))
00903 return AVERROR_EOF;
00904 return 1;
00905 }
00906 if (asf->packet_time_start == 0) {
00907 if(asf_read_frame_header(s, pb) < 0){
00908 asf->packet_segments= 0;
00909 continue;
00910 }
00911 if (asf->stream_index < 0
00912 || s->streams[asf->stream_index]->discard >= AVDISCARD_ALL
00913 || (!asf->packet_key_frame && s->streams[asf->stream_index]->discard >= AVDISCARD_NONKEY)
00914 ) {
00915 asf->packet_time_start = 0;
00916
00917 avio_seek(pb, asf->packet_frag_size, SEEK_CUR);
00918 asf->packet_size_left -= asf->packet_frag_size;
00919 if(asf->stream_index < 0)
00920 av_log(s, AV_LOG_ERROR, "ff asf skip %d (unknown stream)\n", asf->packet_frag_size);
00921 continue;
00922 }
00923 asf->asf_st = s->streams[asf->stream_index]->priv_data;
00924 }
00925 asf_st = asf->asf_st;
00926
00927 if (asf->packet_replic_size == 1) {
00928
00929 asf->packet_frag_timestamp = asf->packet_time_start;
00930 asf->packet_time_start += asf->packet_time_delta;
00931 asf->packet_obj_size = asf->packet_frag_size = avio_r8(pb);
00932 asf->packet_size_left--;
00933 asf->packet_multi_size--;
00934 if (asf->packet_multi_size < asf->packet_obj_size)
00935 {
00936 asf->packet_time_start = 0;
00937 avio_seek(pb, asf->packet_multi_size, SEEK_CUR);
00938 asf->packet_size_left -= asf->packet_multi_size;
00939 continue;
00940 }
00941 asf->packet_multi_size -= asf->packet_obj_size;
00942
00943 }
00944 if(
00945 asf_st->frag_offset + asf->packet_frag_size <= asf_st->pkt.size
00946 && asf_st->frag_offset + asf->packet_frag_size > asf->packet_obj_size){
00947 av_log(s, AV_LOG_INFO, "ignoring invalid packet_obj_size (%d %d %d %d)\n",
00948 asf_st->frag_offset, asf->packet_frag_size,
00949 asf->packet_obj_size, asf_st->pkt.size);
00950 asf->packet_obj_size= asf_st->pkt.size;
00951 }
00952
00953 if ( asf_st->pkt.size != asf->packet_obj_size
00954 || asf_st->frag_offset + asf->packet_frag_size > asf_st->pkt.size) {
00955 if(asf_st->pkt.data){
00956 av_log(s, AV_LOG_INFO, "freeing incomplete packet size %d, new %d\n", asf_st->pkt.size, asf->packet_obj_size);
00957 asf_st->frag_offset = 0;
00958 av_free_packet(&asf_st->pkt);
00959 }
00960
00961 av_new_packet(&asf_st->pkt, asf->packet_obj_size);
00962 asf_st->seq = asf->packet_seq;
00963 asf_st->pkt.dts = asf->packet_frag_timestamp;
00964 asf_st->pkt.stream_index = asf->stream_index;
00965 asf_st->pkt.pos =
00966 asf_st->packet_pos= asf->packet_pos;
00967
00968
00969
00970 if (s->streams[asf->stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
00971 asf->packet_key_frame = 1;
00972 if (asf->packet_key_frame)
00973 asf_st->pkt.flags |= AV_PKT_FLAG_KEY;
00974 }
00975
00976
00977
00978
00979
00980 asf->packet_size_left -= asf->packet_frag_size;
00981 if (asf->packet_size_left < 0)
00982 continue;
00983
00984 if( asf->packet_frag_offset >= asf_st->pkt.size
00985 || asf->packet_frag_size > asf_st->pkt.size - asf->packet_frag_offset){
00986 av_log(s, AV_LOG_ERROR, "packet fragment position invalid %u,%u not in %u\n",
00987 asf->packet_frag_offset, asf->packet_frag_size, asf_st->pkt.size);
00988 continue;
00989 }
00990
00991 ret = avio_read(pb, asf_st->pkt.data + asf->packet_frag_offset,
00992 asf->packet_frag_size);
00993 if (ret != asf->packet_frag_size) {
00994 if (ret < 0 || asf->packet_frag_offset + ret == 0)
00995 return ret < 0 ? ret : AVERROR_EOF;
00996 if (asf_st->ds_span > 1) {
00997
00998
00999
01000 memset(asf_st->pkt.data + asf->packet_frag_offset + ret, 0,
01001 asf->packet_frag_size - ret);
01002 ret = asf->packet_frag_size;
01003 } else
01004
01005 av_shrink_packet(&asf_st->pkt, asf->packet_frag_offset + ret);
01006 }
01007 if (s->key && s->keylen == 20)
01008 ff_asfcrypt_dec(s->key, asf_st->pkt.data + asf->packet_frag_offset,
01009 ret);
01010 asf_st->frag_offset += ret;
01011
01012 if (asf_st->frag_offset == asf_st->pkt.size) {
01013
01014 if( s->streams[asf->stream_index]->codec->codec_id == CODEC_ID_MPEG2VIDEO
01015 && asf_st->pkt.size > 100){
01016 int i;
01017 for(i=0; i<asf_st->pkt.size && !asf_st->pkt.data[i]; i++);
01018 if(i == asf_st->pkt.size){
01019 av_log(s, AV_LOG_DEBUG, "discarding ms fart\n");
01020 asf_st->frag_offset = 0;
01021 av_free_packet(&asf_st->pkt);
01022 continue;
01023 }
01024 }
01025
01026
01027 if (asf_st->ds_span > 1) {
01028 if(asf_st->pkt.size != asf_st->ds_packet_size * asf_st->ds_span){
01029 av_log(s, AV_LOG_ERROR, "pkt.size != ds_packet_size * ds_span (%d %d %d)\n", asf_st->pkt.size, asf_st->ds_packet_size, asf_st->ds_span);
01030 }else{
01031
01032 uint8_t *newdata = av_malloc(asf_st->pkt.size + FF_INPUT_BUFFER_PADDING_SIZE);
01033 if (newdata) {
01034 int offset = 0;
01035 memset(newdata + asf_st->pkt.size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
01036 while (offset < asf_st->pkt.size) {
01037 int off = offset / asf_st->ds_chunk_size;
01038 int row = off / asf_st->ds_span;
01039 int col = off % asf_st->ds_span;
01040 int idx = row + col * asf_st->ds_packet_size / asf_st->ds_chunk_size;
01041
01042
01043 assert(offset + asf_st->ds_chunk_size <= asf_st->pkt.size);
01044 assert(idx+1 <= asf_st->pkt.size / asf_st->ds_chunk_size);
01045 memcpy(newdata + offset,
01046 asf_st->pkt.data + idx * asf_st->ds_chunk_size,
01047 asf_st->ds_chunk_size);
01048 offset += asf_st->ds_chunk_size;
01049 }
01050 av_free(asf_st->pkt.data);
01051 asf_st->pkt.data = newdata;
01052 }
01053 }
01054 }
01055 asf_st->frag_offset = 0;
01056 *pkt= asf_st->pkt;
01057
01058 asf_st->pkt.size = 0;
01059 asf_st->pkt.data = 0;
01060 break;
01061 }
01062 }
01063 return 0;
01064 }
01065
01066 static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)
01067 {
01068 ASFContext *asf = s->priv_data;
01069
01070 for (;;) {
01071 int ret;
01072
01073
01074 if ((ret = ff_asf_parse_packet(s, s->pb, pkt)) <= 0)
01075 return ret;
01076 if ((ret = ff_asf_get_packet(s, s->pb)) < 0)
01077 assert(asf->packet_size_left < FRAME_HEADER_SIZE || asf->packet_segments < 1);
01078 asf->packet_time_start = 0;
01079 }
01080
01081 return 0;
01082 }
01083
01084
01085
01086
01087 static void asf_reset_header(AVFormatContext *s)
01088 {
01089 ASFContext *asf = s->priv_data;
01090 ASFStream *asf_st;
01091 int i;
01092
01093 asf->packet_size_left = 0;
01094 asf->packet_segments = 0;
01095 asf->packet_flags = 0;
01096 asf->packet_property = 0;
01097 asf->packet_timestamp = 0;
01098 asf->packet_segsizetype = 0;
01099 asf->packet_segments = 0;
01100 asf->packet_seq = 0;
01101 asf->packet_replic_size = 0;
01102 asf->packet_key_frame = 0;
01103 asf->packet_padsize = 0;
01104 asf->packet_frag_offset = 0;
01105 asf->packet_frag_size = 0;
01106 asf->packet_frag_timestamp = 0;
01107 asf->packet_multi_size = 0;
01108 asf->packet_obj_size = 0;
01109 asf->packet_time_delta = 0;
01110 asf->packet_time_start = 0;
01111
01112 for(i=0; i<s->nb_streams; i++){
01113 asf_st= s->streams[i]->priv_data;
01114 av_free_packet(&asf_st->pkt);
01115 asf_st->frag_offset=0;
01116 asf_st->seq=0;
01117 }
01118 asf->asf_st= NULL;
01119 }
01120
01121 static int asf_read_close(AVFormatContext *s)
01122 {
01123 int i;
01124
01125 asf_reset_header(s);
01126 for(i=0;i<s->nb_streams;i++) {
01127 AVStream *st = s->streams[i];
01128 av_free(st->codec->palctrl);
01129 }
01130 return 0;
01131 }
01132
01133 static int64_t asf_read_pts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
01134 {
01135 AVPacket pkt1, *pkt = &pkt1;
01136 ASFStream *asf_st;
01137 int64_t pts;
01138 int64_t pos= *ppos;
01139 int i;
01140 int64_t start_pos[ASF_MAX_STREAMS];
01141
01142 for(i=0; i<s->nb_streams; i++){
01143 start_pos[i]= pos;
01144 }
01145
01146 if (s->packet_size > 0)
01147 pos= (pos+s->packet_size-1-s->data_offset)/s->packet_size*s->packet_size+ s->data_offset;
01148 *ppos= pos;
01149 avio_seek(s->pb, pos, SEEK_SET);
01150
01151
01152 asf_reset_header(s);
01153 for(;;){
01154 if (av_read_frame(s, pkt) < 0){
01155 av_log(s, AV_LOG_INFO, "asf_read_pts failed\n");
01156 return AV_NOPTS_VALUE;
01157 }
01158
01159 pts= pkt->pts;
01160
01161 av_free_packet(pkt);
01162 if(pkt->flags&AV_PKT_FLAG_KEY){
01163 i= pkt->stream_index;
01164
01165 asf_st= s->streams[i]->priv_data;
01166
01167
01168 pos= asf_st->packet_pos;
01169
01170 av_add_index_entry(s->streams[i], pos, pts, pkt->size, pos - start_pos[i] + 1, AVINDEX_KEYFRAME);
01171 start_pos[i]= asf_st->packet_pos + 1;
01172
01173 if(pkt->stream_index == stream_index)
01174 break;
01175 }
01176 }
01177
01178 *ppos= pos;
01179
01180
01181 return pts;
01182 }
01183
01184 static void asf_build_simple_index(AVFormatContext *s, int stream_index)
01185 {
01186 ff_asf_guid g;
01187 ASFContext *asf = s->priv_data;
01188 int64_t current_pos= avio_tell(s->pb);
01189 int i;
01190
01191 avio_seek(s->pb, asf->data_object_offset + asf->data_object_size, SEEK_SET);
01192 ff_get_guid(s->pb, &g);
01193
01194
01195
01196 while (ff_guidcmp(&g, &index_guid)) {
01197 int64_t gsize= avio_rl64(s->pb);
01198 if (gsize < 24 || url_feof(s->pb)) {
01199 avio_seek(s->pb, current_pos, SEEK_SET);
01200 return;
01201 }
01202 avio_seek(s->pb, gsize-24, SEEK_CUR);
01203 ff_get_guid(s->pb, &g);
01204 }
01205
01206 {
01207 int64_t itime, last_pos=-1;
01208 int pct, ict;
01209 int64_t av_unused gsize= avio_rl64(s->pb);
01210 ff_get_guid(s->pb, &g);
01211 itime=avio_rl64(s->pb);
01212 pct=avio_rl32(s->pb);
01213 ict=avio_rl32(s->pb);
01214 av_log(s, AV_LOG_DEBUG, "itime:0x%"PRIx64", pct:%d, ict:%d\n",itime,pct,ict);
01215
01216 for (i=0;i<ict;i++){
01217 int pktnum=avio_rl32(s->pb);
01218 int pktct =avio_rl16(s->pb);
01219 int64_t pos = s->data_offset + s->packet_size*(int64_t)pktnum;
01220 int64_t index_pts= av_rescale(itime, i, 10000);
01221
01222 if(pos != last_pos){
01223 av_log(s, AV_LOG_DEBUG, "pktnum:%d, pktct:%d\n", pktnum, pktct);
01224 av_add_index_entry(s->streams[stream_index], pos, index_pts, s->packet_size, 0, AVINDEX_KEYFRAME);
01225 last_pos=pos;
01226 }
01227 }
01228 asf->index_read= 1;
01229 }
01230 avio_seek(s->pb, current_pos, SEEK_SET);
01231 }
01232
01233 static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags)
01234 {
01235 ASFContext *asf = s->priv_data;
01236 AVStream *st = s->streams[stream_index];
01237 int64_t pos;
01238 int index;
01239
01240 if (s->packet_size <= 0)
01241 return -1;
01242
01243
01244 if(s->pb) {
01245 int ret = av_url_read_fseek(s->pb, stream_index, pts, flags);
01246 if(ret >= 0)
01247 asf_reset_header(s);
01248 if (ret != AVERROR(ENOSYS))
01249 return ret;
01250 }
01251
01252 if (!asf->index_read)
01253 asf_build_simple_index(s, stream_index);
01254
01255 if(!(asf->index_read && st->index_entries)){
01256 if(av_seek_frame_binary(s, stream_index, pts, flags)<0)
01257 return -1;
01258 }else{
01259 index= av_index_search_timestamp(st, pts, flags);
01260 if(index<0)
01261 return -1;
01262
01263
01264 pos = st->index_entries[index].pos;
01265
01266
01267
01268
01269
01270
01271
01272
01273
01274
01275
01276
01277
01278
01279
01280
01281
01282
01283
01284
01285
01286
01287
01288 av_log(s, AV_LOG_DEBUG, "SEEKTO: %"PRId64"\n", pos);
01289 avio_seek(s->pb, pos, SEEK_SET);
01290 }
01291 asf_reset_header(s);
01292 return 0;
01293 }
01294
01295 AVInputFormat ff_asf_demuxer = {
01296 "asf",
01297 NULL_IF_CONFIG_SMALL("ASF format"),
01298 sizeof(ASFContext),
01299 asf_probe,
01300 asf_read_header,
01301 asf_read_packet,
01302 asf_read_close,
01303 asf_read_seek,
01304 asf_read_pts,
01305 };