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 int ret = asf_read_stream_properties(s, gsize);
00626 if (ret < 0)
00627 return ret;
00628 } else if (!ff_guidcmp(&g, &ff_asf_comment_header)) {
00629 asf_read_content_desc(s, gsize);
00630 } else if (!ff_guidcmp(&g, &ff_asf_language_guid)) {
00631 asf_read_language_list(s, gsize);
00632 } else if (!ff_guidcmp(&g, &ff_asf_extended_content_header)) {
00633 asf_read_ext_content_desc(s, gsize);
00634 } else if (!ff_guidcmp(&g, &ff_asf_metadata_header)) {
00635 asf_read_metadata(s, gsize);
00636 } else if (!ff_guidcmp(&g, &ff_asf_ext_stream_header)) {
00637 asf_read_ext_stream_properties(s, gsize);
00638
00639
00640
00641 continue;
00642 } else if (!ff_guidcmp(&g, &ff_asf_head1_guid)) {
00643 ff_get_guid(pb, &g);
00644 avio_skip(pb, 6);
00645 continue;
00646 } else if (!ff_guidcmp(&g, &ff_asf_marker_header)) {
00647 asf_read_marker(s, gsize);
00648 } else if (pb->eof_reached) {
00649 return -1;
00650 } else {
00651 if (!s->keylen) {
00652 if (!ff_guidcmp(&g, &ff_asf_content_encryption)) {
00653 av_log(s, AV_LOG_WARNING, "DRM protected stream detected, decoding will likely fail!\n");
00654 } else if (!ff_guidcmp(&g, &ff_asf_ext_content_encryption)) {
00655 av_log(s, AV_LOG_WARNING, "Ext DRM protected stream detected, decoding will likely fail!\n");
00656 } else if (!ff_guidcmp(&g, &ff_asf_digital_signature)) {
00657 av_log(s, AV_LOG_WARNING, "Digital signature detected, decoding will likely fail!\n");
00658 }
00659 }
00660 }
00661 if(avio_tell(pb) != gpos + gsize)
00662 av_log(s, AV_LOG_DEBUG, "gpos mismatch our pos=%"PRIu64", end=%"PRIu64"\n", avio_tell(pb)-gpos, gsize);
00663 avio_seek(pb, gpos + gsize, SEEK_SET);
00664 }
00665 ff_get_guid(pb, &g);
00666 avio_rl64(pb);
00667 avio_r8(pb);
00668 avio_r8(pb);
00669 if (pb->eof_reached)
00670 return -1;
00671 asf->data_offset = avio_tell(pb);
00672 asf->packet_size_left = 0;
00673
00674
00675 for(i=0; i<128; i++){
00676 int stream_num= asf->asfid2avid[i];
00677 if(stream_num>=0){
00678 AVStream *st = s->streams[stream_num];
00679 if (!st->codec->bit_rate)
00680 st->codec->bit_rate = asf->stream_bitrates[i];
00681 if (asf->dar[i].num > 0 && asf->dar[i].den > 0){
00682 av_reduce(&st->sample_aspect_ratio.num,
00683 &st->sample_aspect_ratio.den,
00684 asf->dar[i].num, asf->dar[i].den, INT_MAX);
00685 } else if ((asf->dar[0].num > 0) && (asf->dar[0].den > 0) && (st->codec->codec_type==AVMEDIA_TYPE_VIDEO))
00686 av_reduce(&st->sample_aspect_ratio.num,
00687 &st->sample_aspect_ratio.den,
00688 asf->dar[0].num, asf->dar[0].den, INT_MAX);
00689
00690
00691
00692
00693 if (asf->streams[i].stream_language_index < 128) {
00694 const char *rfc1766 = asf->stream_languages[asf->streams[i].stream_language_index];
00695 if (rfc1766 && strlen(rfc1766) > 1) {
00696 const char primary_tag[3] = { rfc1766[0], rfc1766[1], '\0' };
00697 const char *iso6392 = av_convert_lang_to(primary_tag, AV_LANG_ISO639_2_BIBL);
00698 if (iso6392)
00699 av_dict_set(&st->metadata, "language", iso6392, 0);
00700 }
00701 }
00702 }
00703 }
00704
00705 ff_metadata_conv(&s->metadata, NULL, ff_asf_metadata_conv);
00706
00707 return 0;
00708 }
00709
00710 #define DO_2BITS(bits, var, defval) \
00711 switch (bits & 3) \
00712 { \
00713 case 3: var = avio_rl32(pb); rsize += 4; break; \
00714 case 2: var = avio_rl16(pb); rsize += 2; break; \
00715 case 1: var = avio_r8(pb); rsize++; break; \
00716 default: var = defval; break; \
00717 }
00718
00725 static int ff_asf_get_packet(AVFormatContext *s, AVIOContext *pb)
00726 {
00727 ASFContext *asf = s->priv_data;
00728 uint32_t packet_length, padsize;
00729 int rsize = 8;
00730 int c, d, e, off;
00731
00732
00733 off= 32768;
00734 if (s->packet_size > 0)
00735 off= (avio_tell(pb) - s->data_offset) % s->packet_size + 3;
00736
00737 c=d=e=-1;
00738 while(off-- > 0){
00739 c=d; d=e;
00740 e= avio_r8(pb);
00741 if(c == 0x82 && !d && !e)
00742 break;
00743 }
00744
00745 if (c != 0x82) {
00752 if (pb->error == AVERROR(EAGAIN))
00753 return AVERROR(EAGAIN);
00754 if (!pb->eof_reached)
00755 av_log(s, AV_LOG_ERROR, "ff asf bad header %x at:%"PRId64"\n", c, avio_tell(pb));
00756 }
00757 if ((c & 0x8f) == 0x82) {
00758 if (d || e) {
00759 if (!pb->eof_reached)
00760 av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n");
00761 return -1;
00762 }
00763 c= avio_r8(pb);
00764 d= avio_r8(pb);
00765 rsize+=3;
00766 } else if (!pb->eof_reached) {
00767 avio_seek(pb, -1, SEEK_CUR);
00768 }
00769
00770 asf->packet_flags = c;
00771 asf->packet_property = d;
00772
00773 DO_2BITS(asf->packet_flags >> 5, packet_length, s->packet_size);
00774 DO_2BITS(asf->packet_flags >> 1, padsize, 0);
00775 DO_2BITS(asf->packet_flags >> 3, padsize, 0);
00776
00777
00778 if(!packet_length || packet_length >= (1U<<29)){
00779 av_log(s, AV_LOG_ERROR, "invalid packet_length %d at:%"PRId64"\n", packet_length, avio_tell(pb));
00780 return -1;
00781 }
00782 if(padsize >= packet_length){
00783 av_log(s, AV_LOG_ERROR, "invalid padsize %d at:%"PRId64"\n", padsize, avio_tell(pb));
00784 return -1;
00785 }
00786
00787 asf->packet_timestamp = avio_rl32(pb);
00788 avio_rl16(pb);
00789
00790
00791 if (asf->packet_flags & 0x01) {
00792 asf->packet_segsizetype = avio_r8(pb); rsize++;
00793 asf->packet_segments = asf->packet_segsizetype & 0x3f;
00794 } else {
00795 asf->packet_segments = 1;
00796 asf->packet_segsizetype = 0x80;
00797 }
00798 if (rsize > packet_length - padsize) {
00799 asf->packet_size_left = 0;
00800 av_log(s, AV_LOG_ERROR,
00801 "invalid packet header length %d for pktlen %d-%d at %"PRId64"\n",
00802 rsize, packet_length, padsize, avio_tell(pb));
00803 return -1;
00804 }
00805 asf->packet_size_left = packet_length - padsize - rsize;
00806 if (packet_length < asf->hdr.min_pktsize)
00807 padsize += asf->hdr.min_pktsize - packet_length;
00808 asf->packet_padsize = padsize;
00809 av_dlog(s, "packet: size=%d padsize=%d left=%d\n", s->packet_size, asf->packet_padsize, asf->packet_size_left);
00810 return 0;
00811 }
00812
00817 static int asf_read_frame_header(AVFormatContext *s, AVIOContext *pb){
00818 ASFContext *asf = s->priv_data;
00819 int rsize = 1;
00820 int num = avio_r8(pb);
00821 int64_t ts0;
00822
00823 asf->packet_segments--;
00824 asf->packet_key_frame = num >> 7;
00825 asf->stream_index = asf->asfid2avid[num & 0x7f];
00826
00827 DO_2BITS(asf->packet_property >> 4, asf->packet_seq, 0);
00828 DO_2BITS(asf->packet_property >> 2, asf->packet_frag_offset, 0);
00829 DO_2BITS(asf->packet_property, asf->packet_replic_size, 0);
00830
00831 if (asf->packet_replic_size >= 8) {
00832 asf->packet_obj_size = avio_rl32(pb);
00833 if(asf->packet_obj_size >= (1<<24) || asf->packet_obj_size <= 0){
00834 av_log(s, AV_LOG_ERROR, "packet_obj_size invalid\n");
00835 return -1;
00836 }
00837 asf->packet_frag_timestamp = avio_rl32(pb);
00838 if(asf->packet_replic_size >= 8+38+4){
00839
00840
00841
00842 avio_skip(pb, 10);
00843 ts0= avio_rl64(pb);
00844 avio_skip(pb, 8);;
00845 avio_skip(pb, 12);
00846 avio_rl32(pb);
00847 avio_skip(pb, asf->packet_replic_size - 8 - 38 - 4);
00848 if(ts0!= -1) asf->packet_frag_timestamp= ts0/10000;
00849 else asf->packet_frag_timestamp= AV_NOPTS_VALUE;
00850 }else
00851 avio_skip(pb, asf->packet_replic_size - 8);
00852 rsize += asf->packet_replic_size;
00853 } else if (asf->packet_replic_size==1){
00854
00855 asf->packet_time_start = asf->packet_frag_offset;
00856 asf->packet_frag_offset = 0;
00857 asf->packet_frag_timestamp = asf->packet_timestamp;
00858
00859 asf->packet_time_delta = avio_r8(pb);
00860 rsize++;
00861 }else if(asf->packet_replic_size!=0){
00862 av_log(s, AV_LOG_ERROR, "unexpected packet_replic_size of %d\n", asf->packet_replic_size);
00863 return -1;
00864 }
00865 if (asf->packet_flags & 0x01) {
00866 DO_2BITS(asf->packet_segsizetype >> 6, asf->packet_frag_size, 0);
00867 if (rsize > asf->packet_size_left) {
00868 av_log(s, AV_LOG_ERROR, "packet_replic_size is invalid\n");
00869 return -1;
00870 } else if(asf->packet_frag_size > asf->packet_size_left - rsize){
00871 if (asf->packet_frag_size > asf->packet_size_left - rsize + asf->packet_padsize) {
00872 av_log(s, AV_LOG_ERROR, "packet_frag_size is invalid (%d-%d)\n", asf->packet_size_left, rsize);
00873 return -1;
00874 } else {
00875 int diff = asf->packet_frag_size - (asf->packet_size_left - rsize);
00876 asf->packet_size_left += diff;
00877 asf->packet_padsize -= diff;
00878 }
00879 }
00880
00881 } else {
00882 if (rsize > asf->packet_size_left) {
00883 av_log(s, AV_LOG_ERROR, "packet_replic_size is invalid\n");
00884 return -1;
00885 }
00886 asf->packet_frag_size = asf->packet_size_left - rsize;
00887
00888 }
00889 if (asf->packet_replic_size == 1) {
00890 asf->packet_multi_size = asf->packet_frag_size;
00891 if (asf->packet_multi_size > asf->packet_size_left)
00892 return -1;
00893 }
00894 asf->packet_size_left -= rsize;
00895
00896
00897 return 0;
00898 }
00899
00909 static int ff_asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
00910 {
00911 ASFContext *asf = s->priv_data;
00912 ASFStream *asf_st = 0;
00913 for (;;) {
00914 int ret;
00915 if(pb->eof_reached)
00916 return AVERROR_EOF;
00917 if (asf->packet_size_left < FRAME_HEADER_SIZE
00918 || asf->packet_segments < 1) {
00919
00920 int ret = asf->packet_size_left + asf->packet_padsize;
00921
00922 assert(ret>=0);
00923
00924 avio_skip(pb, ret);
00925
00926 asf->packet_pos= avio_tell(pb);
00927 if (asf->data_object_size != (uint64_t)-1 &&
00928 (asf->packet_pos - asf->data_object_offset >= asf->data_object_size))
00929 return AVERROR_EOF;
00930 return 1;
00931 }
00932 if (asf->packet_time_start == 0) {
00933 if(asf_read_frame_header(s, pb) < 0){
00934 asf->packet_segments= 0;
00935 continue;
00936 }
00937 if (asf->stream_index < 0
00938 || s->streams[asf->stream_index]->discard >= AVDISCARD_ALL
00939 || (!asf->packet_key_frame && s->streams[asf->stream_index]->discard >= AVDISCARD_NONKEY)
00940 ) {
00941 asf->packet_time_start = 0;
00942
00943 avio_skip(pb, asf->packet_frag_size);
00944 asf->packet_size_left -= asf->packet_frag_size;
00945 if(asf->stream_index < 0)
00946 av_log(s, AV_LOG_ERROR, "ff asf skip %d (unknown stream)\n", asf->packet_frag_size);
00947 continue;
00948 }
00949 asf->asf_st = s->streams[asf->stream_index]->priv_data;
00950 }
00951 asf_st = asf->asf_st;
00952
00953 if (asf->packet_replic_size == 1) {
00954
00955 asf->packet_frag_timestamp = asf->packet_time_start;
00956 asf->packet_time_start += asf->packet_time_delta;
00957 asf->packet_obj_size = asf->packet_frag_size = avio_r8(pb);
00958 asf->packet_size_left--;
00959 asf->packet_multi_size--;
00960 if (asf->packet_multi_size < asf->packet_obj_size)
00961 {
00962 asf->packet_time_start = 0;
00963 avio_skip(pb, asf->packet_multi_size);
00964 asf->packet_size_left -= asf->packet_multi_size;
00965 continue;
00966 }
00967 asf->packet_multi_size -= asf->packet_obj_size;
00968
00969 }
00970 if(
00971 asf_st->frag_offset + asf->packet_frag_size <= asf_st->pkt.size
00972 && asf_st->frag_offset + asf->packet_frag_size > asf->packet_obj_size){
00973 av_log(s, AV_LOG_INFO, "ignoring invalid packet_obj_size (%d %d %d %d)\n",
00974 asf_st->frag_offset, asf->packet_frag_size,
00975 asf->packet_obj_size, asf_st->pkt.size);
00976 asf->packet_obj_size= asf_st->pkt.size;
00977 }
00978
00979 if ( asf_st->pkt.size != asf->packet_obj_size
00980 || asf_st->frag_offset + asf->packet_frag_size > asf_st->pkt.size) {
00981 if(asf_st->pkt.data){
00982 av_log(s, AV_LOG_INFO, "freeing incomplete packet size %d, new %d\n", asf_st->pkt.size, asf->packet_obj_size);
00983 asf_st->frag_offset = 0;
00984 av_free_packet(&asf_st->pkt);
00985 }
00986
00987 av_new_packet(&asf_st->pkt, asf->packet_obj_size);
00988 asf_st->seq = asf->packet_seq;
00989 asf_st->pkt.dts = asf->packet_frag_timestamp - asf->hdr.preroll;
00990 asf_st->pkt.stream_index = asf->stream_index;
00991 asf_st->pkt.pos =
00992 asf_st->packet_pos= asf->packet_pos;
00993 if (asf_st->pkt.data && asf_st->palette_changed) {
00994 uint8_t *pal;
00995 pal = av_packet_new_side_data(&asf_st->pkt, AV_PKT_DATA_PALETTE,
00996 AVPALETTE_SIZE);
00997 if (!pal) {
00998 av_log(s, AV_LOG_ERROR, "Cannot append palette to packet\n");
00999 } else {
01000 memcpy(pal, asf_st->palette, AVPALETTE_SIZE);
01001 asf_st->palette_changed = 0;
01002 }
01003 }
01004
01005
01006
01007 if (s->streams[asf->stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
01008 asf->packet_key_frame = 1;
01009 if (asf->packet_key_frame)
01010 asf_st->pkt.flags |= AV_PKT_FLAG_KEY;
01011 }
01012
01013
01014
01015
01016
01017 asf->packet_size_left -= asf->packet_frag_size;
01018 if (asf->packet_size_left < 0)
01019 continue;
01020
01021 if( asf->packet_frag_offset >= asf_st->pkt.size
01022 || asf->packet_frag_size > asf_st->pkt.size - asf->packet_frag_offset){
01023 av_log(s, AV_LOG_ERROR, "packet fragment position invalid %u,%u not in %u\n",
01024 asf->packet_frag_offset, asf->packet_frag_size, asf_st->pkt.size);
01025 continue;
01026 }
01027
01028 ret = avio_read(pb, asf_st->pkt.data + asf->packet_frag_offset,
01029 asf->packet_frag_size);
01030 if (ret != asf->packet_frag_size) {
01031 if (ret < 0 || asf->packet_frag_offset + ret == 0)
01032 return ret < 0 ? ret : AVERROR_EOF;
01033 if (asf_st->ds_span > 1) {
01034
01035
01036
01037 memset(asf_st->pkt.data + asf->packet_frag_offset + ret, 0,
01038 asf->packet_frag_size - ret);
01039 ret = asf->packet_frag_size;
01040 } else
01041
01042 av_shrink_packet(&asf_st->pkt, asf->packet_frag_offset + ret);
01043 }
01044 if (s->key && s->keylen == 20)
01045 ff_asfcrypt_dec(s->key, asf_st->pkt.data + asf->packet_frag_offset,
01046 ret);
01047 asf_st->frag_offset += ret;
01048
01049 if (asf_st->frag_offset == asf_st->pkt.size) {
01050
01051 if( s->streams[asf->stream_index]->codec->codec_id == CODEC_ID_MPEG2VIDEO
01052 && asf_st->pkt.size > 100){
01053 int i;
01054 for(i=0; i<asf_st->pkt.size && !asf_st->pkt.data[i]; i++);
01055 if(i == asf_st->pkt.size){
01056 av_log(s, AV_LOG_DEBUG, "discarding ms fart\n");
01057 asf_st->frag_offset = 0;
01058 av_free_packet(&asf_st->pkt);
01059 continue;
01060 }
01061 }
01062
01063
01064 if (asf_st->ds_span > 1) {
01065 if(asf_st->pkt.size != asf_st->ds_packet_size * asf_st->ds_span){
01066 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);
01067 }else{
01068
01069 uint8_t *newdata = av_malloc(asf_st->pkt.size + FF_INPUT_BUFFER_PADDING_SIZE);
01070 if (newdata) {
01071 int offset = 0;
01072 memset(newdata + asf_st->pkt.size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
01073 while (offset < asf_st->pkt.size) {
01074 int off = offset / asf_st->ds_chunk_size;
01075 int row = off / asf_st->ds_span;
01076 int col = off % asf_st->ds_span;
01077 int idx = row + col * asf_st->ds_packet_size / asf_st->ds_chunk_size;
01078
01079
01080 assert(offset + asf_st->ds_chunk_size <= asf_st->pkt.size);
01081 assert(idx+1 <= asf_st->pkt.size / asf_st->ds_chunk_size);
01082 memcpy(newdata + offset,
01083 asf_st->pkt.data + idx * asf_st->ds_chunk_size,
01084 asf_st->ds_chunk_size);
01085 offset += asf_st->ds_chunk_size;
01086 }
01087 av_free(asf_st->pkt.data);
01088 asf_st->pkt.data = newdata;
01089 }
01090 }
01091 }
01092 asf_st->frag_offset = 0;
01093 *pkt= asf_st->pkt;
01094
01095 asf_st->pkt.size = 0;
01096 asf_st->pkt.data = 0;
01097 asf_st->pkt.side_data_elems = 0;
01098 asf_st->pkt.side_data = NULL;
01099 break;
01100 }
01101 }
01102 return 0;
01103 }
01104
01105 static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)
01106 {
01107 ASFContext *asf = s->priv_data;
01108
01109 for (;;) {
01110 int ret;
01111
01112
01113 if ((ret = ff_asf_parse_packet(s, s->pb, pkt)) <= 0)
01114 return ret;
01115 if ((ret = ff_asf_get_packet(s, s->pb)) < 0)
01116 assert(asf->packet_size_left < FRAME_HEADER_SIZE || asf->packet_segments < 1);
01117 asf->packet_time_start = 0;
01118 }
01119 }
01120
01121
01122
01123
01124 static void asf_reset_header(AVFormatContext *s)
01125 {
01126 ASFContext *asf = s->priv_data;
01127 ASFStream *asf_st;
01128 int i;
01129
01130 asf->packet_size_left = 0;
01131 asf->packet_segments = 0;
01132 asf->packet_flags = 0;
01133 asf->packet_property = 0;
01134 asf->packet_timestamp = 0;
01135 asf->packet_segsizetype = 0;
01136 asf->packet_segments = 0;
01137 asf->packet_seq = 0;
01138 asf->packet_replic_size = 0;
01139 asf->packet_key_frame = 0;
01140 asf->packet_padsize = 0;
01141 asf->packet_frag_offset = 0;
01142 asf->packet_frag_size = 0;
01143 asf->packet_frag_timestamp = 0;
01144 asf->packet_multi_size = 0;
01145 asf->packet_obj_size = 0;
01146 asf->packet_time_delta = 0;
01147 asf->packet_time_start = 0;
01148
01149 for(i=0; i<s->nb_streams; i++){
01150 asf_st= s->streams[i]->priv_data;
01151 av_free_packet(&asf_st->pkt);
01152 asf_st->frag_offset=0;
01153 asf_st->seq=0;
01154 }
01155 asf->asf_st= NULL;
01156 }
01157
01158 static int asf_read_close(AVFormatContext *s)
01159 {
01160 asf_reset_header(s);
01161
01162 return 0;
01163 }
01164
01165 static int64_t asf_read_pts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
01166 {
01167 AVPacket pkt1, *pkt = &pkt1;
01168 ASFStream *asf_st;
01169 int64_t pts;
01170 int64_t pos= *ppos;
01171 int i;
01172 int64_t start_pos[ASF_MAX_STREAMS];
01173
01174 for(i=0; i<s->nb_streams; i++){
01175 start_pos[i]= pos;
01176 }
01177
01178 if (s->packet_size > 0)
01179 pos= (pos+s->packet_size-1-s->data_offset)/s->packet_size*s->packet_size+ s->data_offset;
01180 *ppos= pos;
01181 avio_seek(s->pb, pos, SEEK_SET);
01182
01183
01184 asf_reset_header(s);
01185 for(;;){
01186 if (asf_read_packet(s, pkt) < 0){
01187 av_log(s, AV_LOG_INFO, "asf_read_pts failed\n");
01188 return AV_NOPTS_VALUE;
01189 }
01190
01191 pts = pkt->dts;
01192
01193 av_free_packet(pkt);
01194 if(pkt->flags&AV_PKT_FLAG_KEY){
01195 i= pkt->stream_index;
01196
01197 asf_st= s->streams[i]->priv_data;
01198
01199
01200 pos= asf_st->packet_pos;
01201
01202 av_add_index_entry(s->streams[i], pos, pts, pkt->size, pos - start_pos[i] + 1, AVINDEX_KEYFRAME);
01203 start_pos[i]= asf_st->packet_pos + 1;
01204
01205 if(pkt->stream_index == stream_index)
01206 break;
01207 }
01208 }
01209
01210 *ppos= pos;
01211
01212
01213 return pts;
01214 }
01215
01216 static void asf_build_simple_index(AVFormatContext *s, int stream_index)
01217 {
01218 ff_asf_guid g;
01219 ASFContext *asf = s->priv_data;
01220 int64_t current_pos= avio_tell(s->pb);
01221 int i;
01222
01223 avio_seek(s->pb, asf->data_object_offset + asf->data_object_size, SEEK_SET);
01224 ff_get_guid(s->pb, &g);
01225
01226
01227
01228 while (ff_guidcmp(&g, &index_guid)) {
01229 int64_t gsize= avio_rl64(s->pb);
01230 if (gsize < 24 || s->pb->eof_reached) {
01231 avio_seek(s->pb, current_pos, SEEK_SET);
01232 return;
01233 }
01234 avio_skip(s->pb, gsize-24);
01235 ff_get_guid(s->pb, &g);
01236 }
01237
01238 {
01239 int64_t itime, last_pos=-1;
01240 int pct, ict;
01241 int64_t av_unused gsize= avio_rl64(s->pb);
01242 ff_get_guid(s->pb, &g);
01243 itime=avio_rl64(s->pb);
01244 pct=avio_rl32(s->pb);
01245 ict=avio_rl32(s->pb);
01246 av_log(s, AV_LOG_DEBUG, "itime:0x%"PRIx64", pct:%d, ict:%d\n",itime,pct,ict);
01247
01248 for (i=0;i<ict;i++){
01249 int pktnum=avio_rl32(s->pb);
01250 int pktct =avio_rl16(s->pb);
01251 int64_t pos = s->data_offset + s->packet_size*(int64_t)pktnum;
01252 int64_t index_pts= FFMAX(av_rescale(itime, i, 10000) - asf->hdr.preroll, 0);
01253
01254 if(pos != last_pos){
01255 av_log(s, AV_LOG_DEBUG, "pktnum:%d, pktct:%d pts: %"PRId64"\n", pktnum, pktct, index_pts);
01256 av_add_index_entry(s->streams[stream_index], pos, index_pts, s->packet_size, 0, AVINDEX_KEYFRAME);
01257 last_pos=pos;
01258 }
01259 }
01260 asf->index_read= 1;
01261 }
01262 avio_seek(s->pb, current_pos, SEEK_SET);
01263 }
01264
01265 static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags)
01266 {
01267 ASFContext *asf = s->priv_data;
01268 AVStream *st = s->streams[stream_index];
01269 int64_t pos;
01270 int index;
01271
01272 if (s->packet_size <= 0)
01273 return -1;
01274
01275
01276 if(s->pb) {
01277 int ret = avio_seek_time(s->pb, stream_index, pts, flags);
01278 if(ret >= 0)
01279 asf_reset_header(s);
01280 if (ret != AVERROR(ENOSYS))
01281 return ret;
01282 }
01283
01284 if (!asf->index_read)
01285 asf_build_simple_index(s, stream_index);
01286
01287 if((asf->index_read && st->index_entries)){
01288 index= av_index_search_timestamp(st, pts, flags);
01289 if(index >= 0) {
01290
01291 pos = st->index_entries[index].pos;
01292
01293
01294 av_log(s, AV_LOG_DEBUG, "SEEKTO: %"PRId64"\n", pos);
01295 avio_seek(s->pb, pos, SEEK_SET);
01296 asf_reset_header(s);
01297 return 0;
01298 }
01299 }
01300
01301 if (ff_seek_frame_binary(s, stream_index, pts, flags) < 0)
01302 return -1;
01303 asf_reset_header(s);
01304 return 0;
01305 }
01306
01307 AVInputFormat ff_asf_demuxer = {
01308 .name = "asf",
01309 .long_name = NULL_IF_CONFIG_SMALL("ASF format"),
01310 .priv_data_size = sizeof(ASFContext),
01311 .read_probe = asf_probe,
01312 .read_header = asf_read_header,
01313 .read_packet = asf_read_packet,
01314 .read_close = asf_read_close,
01315 .read_seek = asf_read_seek,
01316 .read_timestamp = asf_read_pts,
01317 .flags = AVFMT_NOBINSEARCH | AVFMT_NOGENSEARCH,
01318 };