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