FFmpeg: libavformat/asfdec.c Source File

00001 /*
00002  * ASF compatible demuxer
00003  * Copyright (c) 2000, 2001 Fabrice Bellard
00004  *
00005  * This file is part of FFmpeg.
00006  *
00007  * FFmpeg is free software; you can redistribute it and/or
00008  * modify it under the terms of the GNU Lesser General Public
00009  * License as published by the Free Software Foundation; either
00010  * version 2.1 of the License, or (at your option) any later version.
00011  *
00012  * FFmpeg is distributed in the hope that it will be useful,
00013  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00014  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00015  * Lesser General Public License for more details.
00016  *
00017  * You should have received a copy of the GNU Lesser General Public
00018  * License along with FFmpeg; if not, write to the Free Software
00019  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020  */
00021 
00022 //#define DEBUG
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     /* non streamed additonnal info */
00042     /* packet filling */
00043     int packet_size_left;
00044     /* only for reading */
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 // Fix Me! FRAME_HEADER_SIZE may be different.
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 = { /* (http://get.to/sdp) */
00087     0xce, 0x75, 0xf8, 0x7b, 0x8d, 0x46, 0xd1, 0x11, 0x8d, 0x82, 0x00, 0x60, 0x97, 0xc9, 0xa2, 0xb2
00088 };
00089 /**********************************/
00090 /* decoding */
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     /* check file header */
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) {         // UTF16-LE
00173         avio_get_str16le(s->pb, len, value, 2*len + 1);
00174     } else if (type > 1 && type <= 5) {  // boolean or DWORD or QWORD or WORD
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     av_metadata_set2(&s->metadata, key, value, 0);
00182 finish:
00183     av_freep(&value);
00184     avio_seek(s->pb, off + len, SEEK_SET);
00185 }
00186 
00187 static int asf_read_file_properties(AVFormatContext *s, int64_t size)
00188 {
00189     ASFContext *asf = s->priv_data;
00190     AVIOContext *pb = s->pb;
00191 
00192     ff_get_guid(pb, &asf->hdr.guid);
00193     asf->hdr.file_size          = avio_rl64(pb);
00194     asf->hdr.create_time        = avio_rl64(pb);
00195     avio_rl64(pb);                               /* number of packets */
00196     asf->hdr.play_time          = avio_rl64(pb);
00197     asf->hdr.send_time          = avio_rl64(pb);
00198     asf->hdr.preroll            = avio_rl32(pb);
00199     asf->hdr.ignore             = avio_rl32(pb);
00200     asf->hdr.flags              = avio_rl32(pb);
00201     asf->hdr.min_pktsize        = avio_rl32(pb);
00202     asf->hdr.max_pktsize        = avio_rl32(pb);
00203     asf->hdr.max_bitrate        = avio_rl32(pb);
00204     s->packet_size = asf->hdr.max_pktsize;
00205 
00206     return 0;
00207 }
00208 
00209 static int asf_read_stream_properties(AVFormatContext *s, int64_t size)
00210 {
00211     ASFContext *asf = s->priv_data;
00212     AVIOContext *pb = s->pb;
00213     AVStream *st;
00214     ASFStream *asf_st;
00215     ff_asf_guid g;
00216     enum AVMediaType type;
00217     int type_specific_size, sizeX;
00218     uint64_t total_size;
00219     unsigned int tag1;
00220     int64_t pos1, pos2, start_time;
00221     int test_for_ext_stream_audio, is_dvr_ms_audio=0;
00222 
00223     if (s->nb_streams == ASF_MAX_STREAMS) {
00224         av_log(s, AV_LOG_ERROR, "too many streams\n");
00225         return AVERROR(EINVAL);
00226     }
00227 
00228     pos1 = avio_tell(pb);
00229 
00230     st = av_new_stream(s, 0);
00231     if (!st)
00232         return AVERROR(ENOMEM);
00233     av_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
00234     asf_st = av_mallocz(sizeof(ASFStream));
00235     if (!asf_st)
00236         return AVERROR(ENOMEM);
00237     st->priv_data = asf_st;
00238     start_time = asf->hdr.preroll;
00239 
00240     asf_st->stream_language_index = 128; // invalid stream index means no language info
00241 
00242     if(!(asf->hdr.flags & 0x01)) { // if we aren't streaming...
00243         st->duration = asf->hdr.play_time /
00244             (10000000 / 1000) - start_time;
00245     }
00246     ff_get_guid(pb, &g);
00247 
00248     test_for_ext_stream_audio = 0;
00249     if (!ff_guidcmp(&g, &ff_asf_audio_stream)) {
00250         type = AVMEDIA_TYPE_AUDIO;
00251     } else if (!ff_guidcmp(&g, &ff_asf_video_stream)) {
00252         type = AVMEDIA_TYPE_VIDEO;
00253     } else if (!ff_guidcmp(&g, &ff_asf_jfif_media)) {
00254         type = AVMEDIA_TYPE_VIDEO;
00255         st->codec->codec_id = CODEC_ID_MJPEG;
00256     } else if (!ff_guidcmp(&g, &ff_asf_command_stream)) {
00257         type = AVMEDIA_TYPE_DATA;
00258     } else if (!ff_guidcmp(&g, &ff_asf_ext_stream_embed_stream_header)) {
00259         test_for_ext_stream_audio = 1;
00260         type = AVMEDIA_TYPE_UNKNOWN;
00261     } else {
00262         return -1;
00263     }
00264     ff_get_guid(pb, &g);
00265     total_size = avio_rl64(pb);
00266     type_specific_size = avio_rl32(pb);
00267     avio_rl32(pb);
00268     st->id = avio_rl16(pb) & 0x7f; /* stream id */
00269     // mapping of asf ID to AV stream ID;
00270     asf->asfid2avid[st->id] = s->nb_streams - 1;
00271 
00272     avio_rl32(pb);
00273 
00274     if (test_for_ext_stream_audio) {
00275         ff_get_guid(pb, &g);
00276         if (!ff_guidcmp(&g, &ff_asf_ext_stream_audio_stream)) {
00277             type = AVMEDIA_TYPE_AUDIO;
00278             is_dvr_ms_audio=1;
00279             ff_get_guid(pb, &g);
00280             avio_rl32(pb);
00281             avio_rl32(pb);
00282             avio_rl32(pb);
00283             ff_get_guid(pb, &g);
00284             avio_rl32(pb);
00285         }
00286     }
00287 
00288     st->codec->codec_type = type;
00289     if (type == AVMEDIA_TYPE_AUDIO) {
00290         ff_get_wav_header(pb, st->codec, type_specific_size);
00291         if (is_dvr_ms_audio) {
00292             // codec_id and codec_tag are unreliable in dvr_ms
00293             // files. Set them later by probing stream.
00294             st->codec->codec_id = CODEC_ID_PROBE;
00295             st->codec->codec_tag = 0;
00296         }
00297         if (st->codec->codec_id == CODEC_ID_AAC) {
00298             st->need_parsing = AVSTREAM_PARSE_NONE;
00299         } else {
00300             st->need_parsing = AVSTREAM_PARSE_FULL;
00301         }
00302         /* We have to init the frame size at some point .... */
00303         pos2 = avio_tell(pb);
00304         if (size >= (pos2 + 8 - pos1 + 24)) {
00305             asf_st->ds_span = avio_r8(pb);
00306             asf_st->ds_packet_size = avio_rl16(pb);
00307             asf_st->ds_chunk_size = avio_rl16(pb);
00308             avio_rl16(pb); //ds_data_size
00309             avio_r8(pb);   //ds_silence_data
00310         }
00311         //printf("Descrambling: ps:%d cs:%d ds:%d s:%d  sd:%d\n",
00312         //       asf_st->ds_packet_size, asf_st->ds_chunk_size,
00313         //       asf_st->ds_data_size, asf_st->ds_span, asf_st->ds_silence_data);
00314         if (asf_st->ds_span > 1) {
00315             if (!asf_st->ds_chunk_size
00316                     || (asf_st->ds_packet_size/asf_st->ds_chunk_size <= 1)
00317                     || asf_st->ds_packet_size % asf_st->ds_chunk_size)
00318                 asf_st->ds_span = 0; // disable descrambling
00319         }
00320         switch (st->codec->codec_id) {
00321             case CODEC_ID_MP3:
00322                 st->codec->frame_size = MPA_FRAME_SIZE;
00323                 break;
00324             case CODEC_ID_PCM_S16LE:
00325             case CODEC_ID_PCM_S16BE:
00326             case CODEC_ID_PCM_U16LE:
00327             case CODEC_ID_PCM_U16BE:
00328             case CODEC_ID_PCM_S8:
00329             case CODEC_ID_PCM_U8:
00330             case CODEC_ID_PCM_ALAW:
00331             case CODEC_ID_PCM_MULAW:
00332                 st->codec->frame_size = 1;
00333                 break;
00334             default:
00335                 /* This is probably wrong, but it prevents a crash later */
00336                 st->codec->frame_size = 1;
00337                 break;
00338         }
00339     } else if (type == AVMEDIA_TYPE_VIDEO &&
00340             size - (avio_tell(pb) - pos1 + 24) >= 51) {
00341         avio_rl32(pb);
00342         avio_rl32(pb);
00343         avio_r8(pb);
00344         avio_rl16(pb);        /* size */
00345         sizeX= avio_rl32(pb); /* size */
00346         st->codec->width = avio_rl32(pb);
00347         st->codec->height = avio_rl32(pb);
00348         /* not available for asf */
00349         avio_rl16(pb); /* panes */
00350         st->codec->bits_per_coded_sample = avio_rl16(pb); /* depth */
00351         tag1 = avio_rl32(pb);
00352         avio_skip(pb, 20);
00353         //                av_log(s, AV_LOG_DEBUG, "size:%d tsize:%d sizeX:%d\n", size, total_size, sizeX);
00354         if (sizeX > 40) {
00355             st->codec->extradata_size = sizeX - 40;
00356             st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
00357             avio_read(pb, st->codec->extradata, st->codec->extradata_size);
00358         }
00359 
00360         /* Extract palette from extradata if bpp <= 8 */
00361         /* This code assumes that extradata contains only palette */
00362         /* This is true for all paletted codecs implemented in ffmpeg */
00363         if (st->codec->extradata_size && (st->codec->bits_per_coded_sample <= 8)) {
00364             int av_unused i;
00365             st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl));
00366 #if HAVE_BIGENDIAN
00367             for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++)
00368                 st->codec->palctrl->palette[i] = av_bswap32(((uint32_t*)st->codec->extradata)[i]);
00369 #else
00370             memcpy(st->codec->palctrl->palette, st->codec->extradata,
00371                     FFMIN(st->codec->extradata_size, AVPALETTE_SIZE));
00372 #endif
00373             st->codec->palctrl->palette_changed = 1;
00374         }
00375 
00376         st->codec->codec_tag = tag1;
00377         st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, tag1);
00378         if(tag1 == MKTAG('D', 'V', 'R', ' ')){
00379             st->need_parsing = AVSTREAM_PARSE_FULL;
00380             // issue658 containse wrong w/h and MS even puts a fake seq header with wrong w/h in extradata while a correct one is in te stream. maximum lameness
00381             st->codec->width  =
00382                 st->codec->height = 0;
00383             av_freep(&st->codec->extradata);
00384             st->codec->extradata_size=0;
00385         }
00386         if(st->codec->codec_id == CODEC_ID_H264)
00387             st->need_parsing = AVSTREAM_PARSE_FULL_ONCE;
00388     }
00389     pos2 = avio_tell(pb);
00390     avio_skip(pb, size - (pos2 - pos1 + 24));
00391 
00392     return 0;
00393 }
00394 
00395 static int asf_read_ext_stream_properties(AVFormatContext *s, int64_t size)
00396 {
00397     ASFContext *asf = s->priv_data;
00398     AVIOContext *pb = s->pb;
00399     ff_asf_guid g;
00400     int ext_len, payload_ext_ct, stream_ct, i;
00401     uint32_t ext_d, leak_rate, stream_num;
00402     unsigned int stream_languageid_index;
00403 
00404     avio_rl64(pb); // starttime
00405     avio_rl64(pb); // endtime
00406     leak_rate = avio_rl32(pb); // leak-datarate
00407     avio_rl32(pb); // bucket-datasize
00408     avio_rl32(pb); // init-bucket-fullness
00409     avio_rl32(pb); // alt-leak-datarate
00410     avio_rl32(pb); // alt-bucket-datasize
00411     avio_rl32(pb); // alt-init-bucket-fullness
00412     avio_rl32(pb); // max-object-size
00413     avio_rl32(pb); // flags (reliable,seekable,no_cleanpoints?,resend-live-cleanpoints, rest of bits reserved)
00414     stream_num = avio_rl16(pb); // stream-num
00415 
00416     stream_languageid_index = avio_rl16(pb); // stream-language-id-index
00417     if (stream_num < 128)
00418         asf->streams[stream_num].stream_language_index = stream_languageid_index;
00419 
00420     avio_rl64(pb); // avg frametime in 100ns units
00421     stream_ct = avio_rl16(pb); //stream-name-count
00422     payload_ext_ct = avio_rl16(pb); //payload-extension-system-count
00423 
00424     if (stream_num < 128)
00425         asf->stream_bitrates[stream_num] = leak_rate;
00426 
00427     for (i=0; i<stream_ct; i++){
00428         avio_rl16(pb);
00429         ext_len = avio_rl16(pb);
00430         avio_skip(pb, ext_len);
00431     }
00432 
00433     for (i=0; i<payload_ext_ct; i++){
00434         ff_get_guid(pb, &g);
00435         ext_d=avio_rl16(pb);
00436         ext_len=avio_rl32(pb);
00437         avio_skip(pb, ext_len);
00438     }
00439 
00440     return 0;
00441 }
00442 
00443 static int asf_read_content_desc(AVFormatContext *s, int64_t size)
00444 {
00445     AVIOContext *pb = s->pb;
00446     int len1, len2, len3, len4, len5;
00447 
00448     len1 = avio_rl16(pb);
00449     len2 = avio_rl16(pb);
00450     len3 = avio_rl16(pb);
00451     len4 = avio_rl16(pb);
00452     len5 = avio_rl16(pb);
00453     get_tag(s, "title"    , 0, len1);
00454     get_tag(s, "author"   , 0, len2);
00455     get_tag(s, "copyright", 0, len3);
00456     get_tag(s, "comment"  , 0, len4);
00457     avio_skip(pb, len5);
00458 
00459     return 0;
00460 }
00461 
00462 static int asf_read_ext_content_desc(AVFormatContext *s, int64_t size)
00463 {
00464     AVIOContext *pb = s->pb;
00465     ASFContext *asf = s->priv_data;
00466     int desc_count, i, ret;
00467 
00468     desc_count = avio_rl16(pb);
00469     for(i=0;i<desc_count;i++) {
00470         int name_len,value_type,value_len;
00471         char name[1024];
00472 
00473         name_len = avio_rl16(pb);
00474         if (name_len%2)     // must be even, broken lavf versions wrote len-1
00475             name_len += 1;
00476         if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len)
00477             avio_skip(pb, name_len - ret);
00478         value_type = avio_rl16(pb);
00479         value_len  = avio_rl16(pb);
00480         if (!value_type && value_len%2)
00481             value_len += 1;
00486         if (!strcmp(name, "AspectRatioX")){
00487             asf->dar[0].num= get_value(s->pb, value_type);
00488         } else if(!strcmp(name, "AspectRatioY")){
00489             asf->dar[0].den= get_value(s->pb, value_type);
00490         } else
00491             get_tag(s, name, value_type, value_len);
00492     }
00493 
00494     return 0;
00495 }
00496 
00497 static int asf_read_language_list(AVFormatContext *s, int64_t size)
00498 {
00499     AVIOContext *pb = s->pb;
00500     ASFContext *asf = s->priv_data;
00501     int j, ret;
00502     int stream_count = avio_rl16(pb);
00503     for(j = 0; j < stream_count; j++) {
00504         char lang[6];
00505         unsigned int lang_len = avio_r8(pb);
00506         if ((ret = avio_get_str16le(pb, lang_len, lang, sizeof(lang))) < lang_len)
00507             avio_skip(pb, lang_len - ret);
00508         if (j < 128)
00509             av_strlcpy(asf->stream_languages[j], lang, sizeof(*asf->stream_languages));
00510     }
00511 
00512     return 0;
00513 }
00514 
00515 static int asf_read_metadata(AVFormatContext *s, int64_t size)
00516 {
00517     AVIOContext *pb = s->pb;
00518     ASFContext *asf = s->priv_data;
00519     int n, stream_num, name_len, value_len, value_type, value_num;
00520     int ret, i;
00521     n = avio_rl16(pb);
00522 
00523     for(i=0;i<n;i++) {
00524         char name[1024];
00525 
00526         avio_rl16(pb); //lang_list_index
00527         stream_num= avio_rl16(pb);
00528         name_len=   avio_rl16(pb);
00529         value_type= avio_rl16(pb);
00530         value_len=  avio_rl32(pb);
00531 
00532         if ((ret = avio_get_str16le(pb, name_len, name, sizeof(name))) < name_len)
00533             avio_skip(pb, name_len - ret);
00534         //av_log(s, AV_LOG_ERROR, "%d %d %d %d %d <%s>\n", i, stream_num, name_len, value_type, value_len, name);
00535         value_num= avio_rl16(pb);//we should use get_value() here but it does not work 2 is le16 here but le32 elsewhere
00536         avio_skip(pb, value_len - 2);
00537 
00538         if(stream_num<128){
00539             if     (!strcmp(name, "AspectRatioX")) asf->dar[stream_num].num= value_num;
00540             else if(!strcmp(name, "AspectRatioY")) asf->dar[stream_num].den= value_num;
00541         }
00542     }
00543 
00544     return 0;
00545 }
00546 
00547 static int asf_read_marker(AVFormatContext *s, int64_t size)
00548 {
00549     AVIOContext *pb = s->pb;
00550     int i, count, name_len, ret;
00551     char name[1024];
00552 
00553     avio_rl64(pb);            // reserved 16 bytes
00554     avio_rl64(pb);            // ...
00555     count = avio_rl32(pb);    // markers count
00556     avio_rl16(pb);            // reserved 2 bytes
00557     name_len = avio_rl16(pb); // name length
00558     for(i=0;i<name_len;i++){
00559         avio_r8(pb); // skip the name
00560     }
00561 
00562     for(i=0;i<count;i++){
00563         int64_t pres_time;
00564         int name_len;
00565 
00566         avio_rl64(pb);             // offset, 8 bytes
00567         pres_time = avio_rl64(pb); // presentation time
00568         avio_rl16(pb);             // entry length
00569         avio_rl32(pb);             // send time
00570         avio_rl32(pb);             // flags
00571         name_len = avio_rl32(pb);  // name length
00572         if ((ret = avio_get_str16le(pb, name_len * 2, name, sizeof(name))) < name_len)
00573             avio_skip(pb, name_len - ret);
00574         ff_new_chapter(s, i, (AVRational){1, 10000000}, pres_time, AV_NOPTS_VALUE, name );
00575     }
00576 
00577     return 0;
00578 }
00579 
00580 static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
00581 {
00582     ASFContext *asf = s->priv_data;
00583     ff_asf_guid g;
00584     AVIOContext *pb = s->pb;
00585     int i;
00586     int64_t gsize;
00587 
00588     ff_get_guid(pb, &g);
00589     if (ff_guidcmp(&g, &ff_asf_header))
00590         return -1;
00591     avio_rl64(pb);
00592     avio_rl32(pb);
00593     avio_r8(pb);
00594     avio_r8(pb);
00595     memset(&asf->asfid2avid, -1, sizeof(asf->asfid2avid));
00596     for(;;) {
00597         uint64_t gpos= avio_tell(pb);
00598         ff_get_guid(pb, &g);
00599         gsize = avio_rl64(pb);
00600         av_dlog(s, "%08"PRIx64": ", gpos);
00601         print_guid(&g);
00602         av_dlog(s, "  size=0x%"PRIx64"\n", gsize);
00603         if (!ff_guidcmp(&g, &ff_asf_data_header)) {
00604             asf->data_object_offset = avio_tell(pb);
00605             // if not streaming, gsize is not unlimited (how?), and there is enough space in the file..
00606             if (!(asf->hdr.flags & 0x01) && gsize >= 100) {
00607                 asf->data_object_size = gsize - 24;
00608             } else {
00609                 asf->data_object_size = (uint64_t)-1;
00610             }
00611             break;
00612         }
00613         if (gsize < 24)
00614             return -1;
00615         if (!ff_guidcmp(&g, &ff_asf_file_header)) {
00616             asf_read_file_properties(s, gsize);
00617         } else if (!ff_guidcmp(&g, &ff_asf_stream_header)) {
00618             asf_read_stream_properties(s, gsize);
00619         } else if (!ff_guidcmp(&g, &ff_asf_comment_header)) {
00620             asf_read_content_desc(s, gsize);
00621         } else if (!ff_guidcmp(&g, &ff_asf_language_guid)) {
00622             asf_read_language_list(s, gsize);
00623         } else if (!ff_guidcmp(&g, &ff_asf_extended_content_header)) {
00624             asf_read_ext_content_desc(s, gsize);
00625         } else if (!ff_guidcmp(&g, &ff_asf_metadata_header)) {
00626             asf_read_metadata(s, gsize);
00627         } else if (!ff_guidcmp(&g, &ff_asf_ext_stream_header)) {
00628             asf_read_ext_stream_properties(s, gsize);
00629 
00630             // there could be a optional stream properties object to follow
00631             // if so the next iteration will pick it up
00632             continue;
00633         } else if (!ff_guidcmp(&g, &ff_asf_head1_guid)) {
00634             int v1, v2;
00635             ff_get_guid(pb, &g);
00636             v1 = avio_rl32(pb);
00637             v2 = avio_rl16(pb);
00638             continue;
00639         } else if (!ff_guidcmp(&g, &ff_asf_marker_header)) {
00640             asf_read_marker(s, gsize);
00641         } else if (url_feof(pb)) {
00642             return -1;
00643         } else {
00644             if (!s->keylen) {
00645                 if (!ff_guidcmp(&g, &ff_asf_content_encryption)) {
00646                     av_log(s, AV_LOG_WARNING, "DRM protected stream detected, decoding will likely fail!\n");
00647                 } else if (!ff_guidcmp(&g, &ff_asf_ext_content_encryption)) {
00648                     av_log(s, AV_LOG_WARNING, "Ext DRM protected stream detected, decoding will likely fail!\n");
00649                 } else if (!ff_guidcmp(&g, &ff_asf_digital_signature)) {
00650                     av_log(s, AV_LOG_WARNING, "Digital signature detected, decoding will likely fail!\n");
00651                 }
00652             }
00653         }
00654         if(avio_tell(pb) != gpos + gsize)
00655             av_log(s, AV_LOG_DEBUG, "gpos mismatch our pos=%"PRIu64", end=%"PRIu64"\n", avio_tell(pb)-gpos, gsize);
00656         avio_seek(pb, gpos + gsize, SEEK_SET);
00657     }
00658     ff_get_guid(pb, &g);
00659     avio_rl64(pb);
00660     avio_r8(pb);
00661     avio_r8(pb);
00662     if (url_feof(pb))
00663         return -1;
00664     asf->data_offset = avio_tell(pb);
00665     asf->packet_size_left = 0;
00666 
00667 
00668     for(i=0; i<128; i++){
00669         int stream_num= asf->asfid2avid[i];
00670         if(stream_num>=0){
00671             AVStream *st = s->streams[stream_num];
00672             if (!st->codec->bit_rate)
00673                 st->codec->bit_rate = asf->stream_bitrates[i];
00674             if (asf->dar[i].num > 0 && asf->dar[i].den > 0){
00675                 av_reduce(&st->sample_aspect_ratio.num,
00676                           &st->sample_aspect_ratio.den,
00677                           asf->dar[i].num, asf->dar[i].den, INT_MAX);
00678             } else if ((asf->dar[0].num > 0) && (asf->dar[0].den > 0) && (st->codec->codec_type==AVMEDIA_TYPE_VIDEO)) // Use ASF container value if the stream doesn't AR set.
00679                 av_reduce(&st->sample_aspect_ratio.num,
00680                           &st->sample_aspect_ratio.den,
00681                           asf->dar[0].num, asf->dar[0].den, INT_MAX);
00682 
00683 //av_log(s, AV_LOG_INFO, "i=%d, st->codec->codec_type:%d, dar %d:%d sar=%d:%d\n", i, st->codec->codec_type, dar[i].num, dar[i].den, st->sample_aspect_ratio.num, st->sample_aspect_ratio.den);
00684 
00685             // copy and convert language codes to the frontend
00686             if (asf->streams[i].stream_language_index < 128) {
00687                 const char *rfc1766 = asf->stream_languages[asf->streams[i].stream_language_index];
00688                 if (rfc1766 && strlen(rfc1766) > 1) {
00689                     const char primary_tag[3] = { rfc1766[0], rfc1766[1], '\0' }; // ignore country code if any
00690                     const char *iso6392 = av_convert_lang_to(primary_tag, AV_LANG_ISO639_2_BIBL);
00691                     if (iso6392)
00692                         av_metadata_set2(&st->metadata, "language", iso6392, 0);
00693                 }
00694             }
00695         }
00696     }
00697 
00698     ff_metadata_conv(&s->metadata, NULL, ff_asf_metadata_conv);
00699 
00700     return 0;
00701 }
00702 
00703 #define DO_2BITS(bits, var, defval) \
00704     switch (bits & 3) \
00705     { \
00706     case 3: var = avio_rl32(pb); rsize += 4; break; \
00707     case 2: var = avio_rl16(pb); rsize += 2; break; \
00708     case 1: var = avio_r8(pb);   rsize++; break; \
00709     default: var = defval; break; \
00710     }
00711 
00718 static int ff_asf_get_packet(AVFormatContext *s, AVIOContext *pb)
00719 {
00720     ASFContext *asf = s->priv_data;
00721     uint32_t packet_length, padsize;
00722     int rsize = 8;
00723     int c, d, e, off;
00724 
00725     // if we do not know packet size, allow skipping up to 32 kB
00726     off= 32768;
00727     if (s->packet_size > 0)
00728         off= (avio_tell(pb) - s->data_offset) % s->packet_size + 3;
00729 
00730     c=d=e=-1;
00731     while(off-- > 0){
00732         c=d; d=e;
00733         e= avio_r8(pb);
00734         if(c == 0x82 && !d && !e)
00735             break;
00736     }
00737 
00738     if (c != 0x82) {
00745         if (pb->error == AVERROR(EAGAIN))
00746             return AVERROR(EAGAIN);
00747         if (!url_feof(pb))
00748             av_log(s, AV_LOG_ERROR, "ff asf bad header %x  at:%"PRId64"\n", c, avio_tell(pb));
00749     }
00750     if ((c & 0x8f) == 0x82) {
00751         if (d || e) {
00752             if (!url_feof(pb))
00753                 av_log(s, AV_LOG_ERROR, "ff asf bad non zero\n");
00754             return -1;
00755         }
00756         c= avio_r8(pb);
00757         d= avio_r8(pb);
00758         rsize+=3;
00759     }else{
00760         avio_seek(pb, -1, SEEK_CUR); //FIXME
00761     }
00762 
00763     asf->packet_flags    = c;
00764     asf->packet_property = d;
00765 
00766     DO_2BITS(asf->packet_flags >> 5, packet_length, s->packet_size);
00767     DO_2BITS(asf->packet_flags >> 1, padsize, 0); // sequence ignored
00768     DO_2BITS(asf->packet_flags >> 3, padsize, 0); // padding length
00769 
00770     //the following checks prevent overflows and infinite loops
00771     if(!packet_length || packet_length >= (1U<<29)){
00772         av_log(s, AV_LOG_ERROR, "invalid packet_length %d at:%"PRId64"\n", packet_length, avio_tell(pb));
00773         return -1;
00774     }
00775     if(padsize >= packet_length){
00776         av_log(s, AV_LOG_ERROR, "invalid padsize %d at:%"PRId64"\n", padsize, avio_tell(pb));
00777         return -1;
00778     }
00779 
00780     asf->packet_timestamp = avio_rl32(pb);
00781     avio_rl16(pb); /* duration */
00782     // rsize has at least 11 bytes which have to be present
00783 
00784     if (asf->packet_flags & 0x01) {
00785         asf->packet_segsizetype = avio_r8(pb); rsize++;
00786         asf->packet_segments = asf->packet_segsizetype & 0x3f;
00787     } else {
00788         asf->packet_segments = 1;
00789         asf->packet_segsizetype = 0x80;
00790     }
00791     asf->packet_size_left = packet_length - padsize - rsize;
00792     if (packet_length < asf->hdr.min_pktsize)
00793         padsize += asf->hdr.min_pktsize - packet_length;
00794     asf->packet_padsize = padsize;
00795     av_dlog(s, "packet: size=%d padsize=%d  left=%d\n", s->packet_size, asf->packet_padsize, asf->packet_size_left);
00796     return 0;
00797 }
00798 
00803 static int asf_read_frame_header(AVFormatContext *s, AVIOContext *pb){
00804     ASFContext *asf = s->priv_data;
00805     int rsize = 1;
00806     int num = avio_r8(pb);
00807     int64_t ts0, ts1;
00808 
00809     asf->packet_segments--;
00810     asf->packet_key_frame = num >> 7;
00811     asf->stream_index = asf->asfid2avid[num & 0x7f];
00812     // sequence should be ignored!
00813     DO_2BITS(asf->packet_property >> 4, asf->packet_seq, 0);
00814     DO_2BITS(asf->packet_property >> 2, asf->packet_frag_offset, 0);
00815     DO_2BITS(asf->packet_property, asf->packet_replic_size, 0);
00816 //printf("key:%d stream:%d seq:%d offset:%d replic_size:%d\n", asf->packet_key_frame, asf->stream_index, asf->packet_seq, //asf->packet_frag_offset, asf->packet_replic_size);
00817     if (asf->packet_replic_size >= 8) {
00818         asf->packet_obj_size = avio_rl32(pb);
00819         if(asf->packet_obj_size >= (1<<24) || asf->packet_obj_size <= 0){
00820             av_log(s, AV_LOG_ERROR, "packet_obj_size invalid\n");
00821             return -1;
00822         }
00823         asf->packet_frag_timestamp = avio_rl32(pb); // timestamp
00824         if(asf->packet_replic_size >= 8+38+4){
00825 //            for(i=0; i<asf->packet_replic_size-8; i++)
00826 //                av_log(s, AV_LOG_DEBUG, "%02X ",avio_r8(pb));
00827 //            av_log(s, AV_LOG_DEBUG, "\n");
00828             avio_skip(pb, 10);
00829             ts0= avio_rl64(pb);
00830             ts1= avio_rl64(pb);
00831             avio_skip(pb, 12);
00832             avio_rl32(pb);
00833             avio_skip(pb, asf->packet_replic_size - 8 - 38 - 4);
00834             if(ts0!= -1) asf->packet_frag_timestamp= ts0/10000;
00835             else         asf->packet_frag_timestamp= AV_NOPTS_VALUE;
00836         }else
00837             avio_skip(pb, asf->packet_replic_size - 8);
00838         rsize += asf->packet_replic_size; // FIXME - check validity
00839     } else if (asf->packet_replic_size==1){
00840         // multipacket - frag_offset is beginning timestamp
00841         asf->packet_time_start = asf->packet_frag_offset;
00842         asf->packet_frag_offset = 0;
00843         asf->packet_frag_timestamp = asf->packet_timestamp;
00844 
00845         asf->packet_time_delta = avio_r8(pb);
00846         rsize++;
00847     }else if(asf->packet_replic_size!=0){
00848         av_log(s, AV_LOG_ERROR, "unexpected packet_replic_size of %d\n", asf->packet_replic_size);
00849         return -1;
00850     }
00851     if (asf->packet_flags & 0x01) {
00852         DO_2BITS(asf->packet_segsizetype >> 6, asf->packet_frag_size, 0); // 0 is illegal
00853         if(asf->packet_frag_size > asf->packet_size_left - rsize){
00854             av_log(s, AV_LOG_ERROR, "packet_frag_size is invalid\n");
00855             return -1;
00856         }
00857         //printf("Fragsize %d\n", asf->packet_frag_size);
00858     } else {
00859         asf->packet_frag_size = asf->packet_size_left - rsize;
00860         //printf("Using rest  %d %d %d\n", asf->packet_frag_size, asf->packet_size_left, rsize);
00861     }
00862     if (asf->packet_replic_size == 1) {
00863         asf->packet_multi_size = asf->packet_frag_size;
00864         if (asf->packet_multi_size > asf->packet_size_left)
00865             return -1;
00866     }
00867     asf->packet_size_left -= rsize;
00868     //printf("___objsize____  %d   %d    rs:%d\n", asf->packet_obj_size, asf->packet_frag_offset, rsize);
00869 
00870     return 0;
00871 }
00872 
00882 static int ff_asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
00883 {
00884     ASFContext *asf = s->priv_data;
00885     ASFStream *asf_st = 0;
00886     for (;;) {
00887         int ret;
00888         if(url_feof(pb))
00889             return AVERROR_EOF;
00890         if (asf->packet_size_left < FRAME_HEADER_SIZE
00891             || asf->packet_segments < 1) {
00892             //asf->packet_size_left <= asf->packet_padsize) {
00893             int ret = asf->packet_size_left + asf->packet_padsize;
00894             //printf("PacketLeftSize:%d  Pad:%d Pos:%"PRId64"\n", asf->packet_size_left, asf->packet_padsize, avio_tell(pb));
00895             assert(ret>=0);
00896             /* fail safe */
00897             avio_skip(pb, ret);
00898 
00899             asf->packet_pos= avio_tell(pb);
00900             if (asf->data_object_size != (uint64_t)-1 &&
00901                 (asf->packet_pos - asf->data_object_offset >= asf->data_object_size))
00902                 return AVERROR_EOF; /* Do not exceed the size of the data object */
00903             return 1;
00904         }
00905         if (asf->packet_time_start == 0) {
00906             if(asf_read_frame_header(s, pb) < 0){
00907                 asf->packet_segments= 0;
00908                 continue;
00909             }
00910             if (asf->stream_index < 0
00911                 || s->streams[asf->stream_index]->discard >= AVDISCARD_ALL
00912                 || (!asf->packet_key_frame && s->streams[asf->stream_index]->discard >= AVDISCARD_NONKEY)
00913                 ) {
00914                 asf->packet_time_start = 0;
00915                 /* unhandled packet (should not happen) */
00916                 avio_skip(pb, asf->packet_frag_size);
00917                 asf->packet_size_left -= asf->packet_frag_size;
00918                 if(asf->stream_index < 0)
00919                     av_log(s, AV_LOG_ERROR, "ff asf skip %d (unknown stream)\n", asf->packet_frag_size);
00920                 continue;
00921             }
00922             asf->asf_st = s->streams[asf->stream_index]->priv_data;
00923         }
00924         asf_st = asf->asf_st;
00925 
00926         if (asf->packet_replic_size == 1) {
00927             // frag_offset is here used as the beginning timestamp
00928             asf->packet_frag_timestamp = asf->packet_time_start;
00929             asf->packet_time_start += asf->packet_time_delta;
00930             asf->packet_obj_size = asf->packet_frag_size = avio_r8(pb);
00931             asf->packet_size_left--;
00932             asf->packet_multi_size--;
00933             if (asf->packet_multi_size < asf->packet_obj_size)
00934             {
00935                 asf->packet_time_start = 0;
00936                 avio_skip(pb, asf->packet_multi_size);
00937                 asf->packet_size_left -= asf->packet_multi_size;
00938                 continue;
00939             }
00940             asf->packet_multi_size -= asf->packet_obj_size;
00941             //printf("COMPRESS size  %d  %d  %d   ms:%d\n", asf->packet_obj_size, asf->packet_frag_timestamp, asf->packet_size_left, asf->packet_multi_size);
00942         }
00943         if(   /*asf->packet_frag_size == asf->packet_obj_size*/
00944               asf_st->frag_offset + asf->packet_frag_size <= asf_st->pkt.size
00945            && asf_st->frag_offset + asf->packet_frag_size > asf->packet_obj_size){
00946             av_log(s, AV_LOG_INFO, "ignoring invalid packet_obj_size (%d %d %d %d)\n",
00947                 asf_st->frag_offset, asf->packet_frag_size,
00948                 asf->packet_obj_size, asf_st->pkt.size);
00949             asf->packet_obj_size= asf_st->pkt.size;
00950         }
00951 
00952         if (   asf_st->pkt.size != asf->packet_obj_size
00953             || asf_st->frag_offset + asf->packet_frag_size > asf_st->pkt.size) { //FIXME is this condition sufficient?
00954             if(asf_st->pkt.data){
00955                 av_log(s, AV_LOG_INFO, "freeing incomplete packet size %d, new %d\n", asf_st->pkt.size, asf->packet_obj_size);
00956                 asf_st->frag_offset = 0;
00957                 av_free_packet(&asf_st->pkt);
00958             }
00959             /* new packet */
00960             av_new_packet(&asf_st->pkt, asf->packet_obj_size);
00961             asf_st->seq = asf->packet_seq;
00962             asf_st->pkt.dts = asf->packet_frag_timestamp - asf->hdr.preroll;
00963             asf_st->pkt.stream_index = asf->stream_index;
00964             asf_st->pkt.pos =
00965             asf_st->packet_pos= asf->packet_pos;
00966 //printf("new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n",
00967 //asf->stream_index, asf->packet_key_frame, asf_st->pkt.flags & AV_PKT_FLAG_KEY,
00968 //s->streams[asf->stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO, asf->packet_obj_size);
00969             if (s->streams[asf->stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
00970                 asf->packet_key_frame = 1;
00971             if (asf->packet_key_frame)
00972                 asf_st->pkt.flags |= AV_PKT_FLAG_KEY;
00973         }
00974 
00975         /* read data */
00976         //printf("READ PACKET s:%d  os:%d  o:%d,%d  l:%d   DATA:%p\n",
00977         //       s->packet_size, asf_st->pkt.size, asf->packet_frag_offset,
00978         //       asf_st->frag_offset, asf->packet_frag_size, asf_st->pkt.data);
00979         asf->packet_size_left -= asf->packet_frag_size;
00980         if (asf->packet_size_left < 0)
00981             continue;
00982 
00983         if(   asf->packet_frag_offset >= asf_st->pkt.size
00984            || asf->packet_frag_size > asf_st->pkt.size - asf->packet_frag_offset){
00985             av_log(s, AV_LOG_ERROR, "packet fragment position invalid %u,%u not in %u\n",
00986                 asf->packet_frag_offset, asf->packet_frag_size, asf_st->pkt.size);
00987             continue;
00988         }
00989 
00990         ret = avio_read(pb, asf_st->pkt.data + asf->packet_frag_offset,
00991                          asf->packet_frag_size);
00992         if (ret != asf->packet_frag_size) {
00993             if (ret < 0 || asf->packet_frag_offset + ret == 0)
00994                 return ret < 0 ? ret : AVERROR_EOF;
00995             if (asf_st->ds_span > 1) {
00996                 // scrambling, we can either drop it completely or fill the remainder
00997                 // TODO: should we fill the whole packet instead of just the current
00998                 // fragment?
00999                 memset(asf_st->pkt.data + asf->packet_frag_offset + ret, 0,
01000                        asf->packet_frag_size - ret);
01001                 ret = asf->packet_frag_size;
01002             } else
01003                 // no scrambling, so we can return partial packets
01004                 av_shrink_packet(&asf_st->pkt, asf->packet_frag_offset + ret);
01005         }
01006         if (s->key && s->keylen == 20)
01007             ff_asfcrypt_dec(s->key, asf_st->pkt.data + asf->packet_frag_offset,
01008                             ret);
01009         asf_st->frag_offset += ret;
01010         /* test if whole packet is read */
01011         if (asf_st->frag_offset == asf_st->pkt.size) {
01012             //workaround for macroshit radio DVR-MS files
01013             if(   s->streams[asf->stream_index]->codec->codec_id == CODEC_ID_MPEG2VIDEO
01014                && asf_st->pkt.size > 100){
01015                 int i;
01016                 for(i=0; i<asf_st->pkt.size && !asf_st->pkt.data[i]; i++);
01017                 if(i == asf_st->pkt.size){
01018                     av_log(s, AV_LOG_DEBUG, "discarding ms fart\n");
01019                     asf_st->frag_offset = 0;
01020                     av_free_packet(&asf_st->pkt);
01021                     continue;
01022                 }
01023             }
01024 
01025             /* return packet */
01026             if (asf_st->ds_span > 1) {
01027               if(asf_st->pkt.size != asf_st->ds_packet_size * asf_st->ds_span){
01028                     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);
01029               }else{
01030                 /* packet descrambling */
01031                 uint8_t *newdata = av_malloc(asf_st->pkt.size + FF_INPUT_BUFFER_PADDING_SIZE);
01032                 if (newdata) {
01033                     int offset = 0;
01034                     memset(newdata + asf_st->pkt.size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
01035                     while (offset < asf_st->pkt.size) {
01036                         int off = offset / asf_st->ds_chunk_size;
01037                         int row = off / asf_st->ds_span;
01038                         int col = off % asf_st->ds_span;
01039                         int idx = row + col * asf_st->ds_packet_size / asf_st->ds_chunk_size;
01040                         //printf("off:%d  row:%d  col:%d  idx:%d\n", off, row, col, idx);
01041 
01042                         assert(offset + asf_st->ds_chunk_size <= asf_st->pkt.size);
01043                         assert(idx+1 <= asf_st->pkt.size / asf_st->ds_chunk_size);
01044                         memcpy(newdata + offset,
01045                                asf_st->pkt.data + idx * asf_st->ds_chunk_size,
01046                                asf_st->ds_chunk_size);
01047                         offset += asf_st->ds_chunk_size;
01048                     }
01049                     av_free(asf_st->pkt.data);
01050                     asf_st->pkt.data = newdata;
01051                 }
01052               }
01053             }
01054             asf_st->frag_offset = 0;
01055             *pkt= asf_st->pkt;
01056             //printf("packet %d %d\n", asf_st->pkt.size, asf->packet_frag_size);
01057             asf_st->pkt.size = 0;
01058             asf_st->pkt.data = 0;
01059             break; // packet completed
01060         }
01061     }
01062     return 0;
01063 }
01064 
01065 static int asf_read_packet(AVFormatContext *s, AVPacket *pkt)
01066 {
01067     ASFContext *asf = s->priv_data;
01068 
01069     for (;;) {
01070         int ret;
01071 
01072         /* parse cached packets, if any */
01073         if ((ret = ff_asf_parse_packet(s, s->pb, pkt)) <= 0)
01074             return ret;
01075         if ((ret = ff_asf_get_packet(s, s->pb)) < 0)
01076             assert(asf->packet_size_left < FRAME_HEADER_SIZE || asf->packet_segments < 1);
01077         asf->packet_time_start = 0;
01078     }
01079 
01080     return 0;
01081 }
01082 
01083 // Added to support seeking after packets have been read
01084 // If information is not reset, read_packet fails due to
01085 // leftover information from previous reads
01086 static void asf_reset_header(AVFormatContext *s)
01087 {
01088     ASFContext *asf = s->priv_data;
01089     ASFStream *asf_st;
01090     int i;
01091 
01092     asf->packet_size_left = 0;
01093     asf->packet_segments = 0;
01094     asf->packet_flags = 0;
01095     asf->packet_property = 0;
01096     asf->packet_timestamp = 0;
01097     asf->packet_segsizetype = 0;
01098     asf->packet_segments = 0;
01099     asf->packet_seq = 0;
01100     asf->packet_replic_size = 0;
01101     asf->packet_key_frame = 0;
01102     asf->packet_padsize = 0;
01103     asf->packet_frag_offset = 0;
01104     asf->packet_frag_size = 0;
01105     asf->packet_frag_timestamp = 0;
01106     asf->packet_multi_size = 0;
01107     asf->packet_obj_size = 0;
01108     asf->packet_time_delta = 0;
01109     asf->packet_time_start = 0;
01110 
01111     for(i=0; i<s->nb_streams; i++){
01112         asf_st= s->streams[i]->priv_data;
01113         av_free_packet(&asf_st->pkt);
01114         asf_st->frag_offset=0;
01115         asf_st->seq=0;
01116     }
01117     asf->asf_st= NULL;
01118 }
01119 
01120 static int asf_read_close(AVFormatContext *s)
01121 {
01122     int i;
01123 
01124     asf_reset_header(s);
01125     for(i=0;i<s->nb_streams;i++) {
01126         AVStream *st = s->streams[i];
01127         av_free(st->codec->palctrl);
01128     }
01129     return 0;
01130 }
01131 
01132 static int64_t asf_read_pts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
01133 {
01134     AVPacket pkt1, *pkt = &pkt1;
01135     ASFStream *asf_st;
01136     int64_t pts;
01137     int64_t pos= *ppos;
01138     int i;
01139     int64_t start_pos[ASF_MAX_STREAMS];
01140 
01141     for(i=0; i<s->nb_streams; i++){
01142         start_pos[i]= pos;
01143     }
01144 
01145     if (s->packet_size > 0)
01146         pos= (pos+s->packet_size-1-s->data_offset)/s->packet_size*s->packet_size+ s->data_offset;
01147     *ppos= pos;
01148     avio_seek(s->pb, pos, SEEK_SET);
01149 
01150 //printf("asf_read_pts\n");
01151     asf_reset_header(s);
01152     for(;;){
01153         if (av_read_frame(s, pkt) < 0){
01154             av_log(s, AV_LOG_INFO, "asf_read_pts failed\n");
01155             return AV_NOPTS_VALUE;
01156         }
01157 
01158         pts= pkt->pts;
01159 
01160         av_free_packet(pkt);
01161         if(pkt->flags&AV_PKT_FLAG_KEY){
01162             i= pkt->stream_index;
01163 
01164             asf_st= s->streams[i]->priv_data;
01165 
01166 //            assert((asf_st->packet_pos - s->data_offset) % s->packet_size == 0);
01167             pos= asf_st->packet_pos;
01168 
01169             av_add_index_entry(s->streams[i], pos, pts, pkt->size, pos - start_pos[i] + 1, AVINDEX_KEYFRAME);
01170             start_pos[i]= asf_st->packet_pos + 1;
01171 
01172             if(pkt->stream_index == stream_index)
01173                break;
01174         }
01175     }
01176 
01177     *ppos= pos;
01178 //printf("found keyframe at %"PRId64" stream %d stamp:%"PRId64"\n", *ppos, stream_index, pts);
01179 
01180     return pts;
01181 }
01182 
01183 static void asf_build_simple_index(AVFormatContext *s, int stream_index)
01184 {
01185     ff_asf_guid g;
01186     ASFContext *asf = s->priv_data;
01187     int64_t current_pos= avio_tell(s->pb);
01188     int i;
01189 
01190     avio_seek(s->pb, asf->data_object_offset + asf->data_object_size, SEEK_SET);
01191     ff_get_guid(s->pb, &g);
01192 
01193     /* the data object can be followed by other top-level objects,
01194        skip them until the simple index object is reached */
01195     while (ff_guidcmp(&g, &index_guid)) {
01196         int64_t gsize= avio_rl64(s->pb);
01197         if (gsize < 24 || url_feof(s->pb)) {
01198             avio_seek(s->pb, current_pos, SEEK_SET);
01199             return;
01200         }
01201         avio_skip(s->pb, gsize-24);
01202         ff_get_guid(s->pb, &g);
01203     }
01204 
01205     {
01206         int64_t itime, last_pos=-1;
01207         int pct, ict;
01208         int64_t av_unused gsize= avio_rl64(s->pb);
01209         ff_get_guid(s->pb, &g);
01210         itime=avio_rl64(s->pb);
01211         pct=avio_rl32(s->pb);
01212         ict=avio_rl32(s->pb);
01213         av_log(s, AV_LOG_DEBUG, "itime:0x%"PRIx64", pct:%d, ict:%d\n",itime,pct,ict);
01214 
01215         for (i=0;i<ict;i++){
01216             int pktnum=avio_rl32(s->pb);
01217             int pktct =avio_rl16(s->pb);
01218             int64_t pos      = s->data_offset + s->packet_size*(int64_t)pktnum;
01219             int64_t index_pts= av_rescale(itime, i, 10000);
01220 
01221             if(pos != last_pos){
01222             av_log(s, AV_LOG_DEBUG, "pktnum:%d, pktct:%d\n", pktnum, pktct);
01223             av_add_index_entry(s->streams[stream_index], pos, index_pts, s->packet_size, 0, AVINDEX_KEYFRAME);
01224             last_pos=pos;
01225             }
01226         }
01227         asf->index_read= 1;
01228     }
01229     avio_seek(s->pb, current_pos, SEEK_SET);
01230 }
01231 
01232 static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags)
01233 {
01234     ASFContext *asf = s->priv_data;
01235     AVStream *st = s->streams[stream_index];
01236     int64_t pos;
01237     int index;
01238 
01239     if (s->packet_size <= 0)
01240         return -1;
01241 
01242     /* Try using the protocol's read_seek if available */
01243     if(s->pb) {
01244         int ret = av_url_read_fseek(s->pb, stream_index, pts, flags);
01245         if(ret >= 0)
01246             asf_reset_header(s);
01247         if (ret != AVERROR(ENOSYS))
01248             return ret;
01249     }
01250 
01251     if (!asf->index_read)
01252         asf_build_simple_index(s, stream_index);
01253 
01254     if(!(asf->index_read && st->index_entries)){
01255         if(av_seek_frame_binary(s, stream_index, pts, flags)<0)
01256             return -1;
01257     }else{
01258         index= av_index_search_timestamp(st, pts, flags);
01259         if(index<0)
01260             return -1;
01261 
01262         /* find the position */
01263         pos = st->index_entries[index].pos;
01264 
01265     // various attempts to find key frame have failed so far
01266     //    asf_reset_header(s);
01267     //    avio_seek(s->pb, pos, SEEK_SET);
01268     //    key_pos = pos;
01269     //     for(i=0;i<16;i++){
01270     //         pos = avio_tell(s->pb);
01271     //         if (av_read_frame(s, &pkt) < 0){
01272     //             av_log(s, AV_LOG_INFO, "seek failed\n");
01273     //             return -1;
01274     //         }
01275     //         asf_st = s->streams[stream_index]->priv_data;
01276     //         pos += st->parser->frame_offset;
01277     //
01278     //         if (pkt.size > b) {
01279     //             b = pkt.size;
01280     //             key_pos = pos;
01281     //         }
01282     //
01283     //         av_free_packet(&pkt);
01284     //     }
01285 
01286         /* do the seek */
01287         av_log(s, AV_LOG_DEBUG, "SEEKTO: %"PRId64"\n", pos);
01288         avio_seek(s->pb, pos, SEEK_SET);
01289     }
01290     asf_reset_header(s);
01291     return 0;
01292 }
01293 
01294 AVInputFormat ff_asf_demuxer = {
01295     "asf",
01296     NULL_IF_CONFIG_SMALL("ASF format"),
01297     sizeof(ASFContext),
01298     asf_probe,
01299     asf_read_header,
01300     asf_read_packet,
01301     asf_read_close,
01302     asf_read_seek,
01303     asf_read_pts,
01304 };