[FFmpeg-soc] [soc]: r5864 - seek2010/seek2010_07_19_r24319.patch

mchinen subversion at mplayerhq.hu
Mon Jul 19 01:20:47 CEST 2010


Author: mchinen
Date: Mon Jul 19 01:20:46 2010
New Revision: 5864

Log:
Update av_build_index based seeking to work with FLAC.

Fix initial table seek to check for invalid start_time and data_offset before seeking.

fix broken flag saving in av_save_index

add AVSEEK_FLAG_ANY to initial seek in av_build_index

Added:
   seek2010/seek2010_07_19_r24319.patch

Added: seek2010/seek2010_07_19_r24319.patch
==============================================================================
--- /dev/null	00:00:00 1970	(empty, because file is newly added)
+++ seek2010/seek2010_07_19_r24319.patch	Mon Jul 19 01:20:46 2010	(r5864)
@@ -0,0 +1,565 @@
+Index: ffplay.c
+===================================================================
+--- ffplay.c	(revision 24319)
++++ ffplay.c	(working copy)
+@@ -2381,6 +2381,7 @@
+     AVFormatParameters params, *ap = &params;
+     int eof=0;
+     int pkt_in_play_range = 0;
++    char *index_filename = NULL;
+ 
+     ic = avformat_alloc_context();
+ 
+@@ -2497,6 +2498,18 @@
+         goto fail;
+     }
+ 
++    if(ic->filename){
++        index_filename = av_malloc(strlen(ic->filename) + 5);
++        strcpy(index_filename, ic->filename);
++        strcat(index_filename, ".fdx");
++    }
++
++    if (av_load_index_file(ic, index_filename) < 0 ) {
++        av_build_index(ic, 0); //AV_BUILD_INDEX_PARALLEL);    
++        av_save_index_file(ic, index_filename);
++    }
++    av_free(index_filename);    
++
+     for(;;) {
+         if (is->abort_request)
+             break;
+Index: libavformat/avformat.h
+===================================================================
+--- libavformat/avformat.h	(revision 24319)
++++ libavformat/avformat.h	(working copy)
+@@ -536,6 +536,16 @@
+      * Number of frames that have been demuxed during av_find_stream_info()
+      */
+     int codec_info_nb_frames;
++
++    /* new av_seek_frame_table() support */
++#define AV_SEEKTABLE_BUILDING   0x0001 ///< a flag set by av_build_index to mark that the index is being built
++#define AV_SEEKTABLE_CBR        0x0002 ///< a flag set by av_build_index to note that the file is constant bit rate
++#define AV_SEEKTABLE_FINISHED   0x0004 ///< a flag set by av_build_index to note that the complete index table is ready to use
++#define AV_SEEKTABLE_COPIED     0x0008 ///< a flag to note that the seek table has been copied.
++    int seek_table_flags;
++    AVIndexEntry* parallel_index_entries; ///used with AV_BUILD_INDEX_PARALLEL.  should not be touched by client
++    int parallel_nb_index_entries;
++    unsigned int parallel_index_entries_allocated_size;
+ } AVStream;
+ 
+ #define AV_PROGRAM_RUNNING 1
+@@ -1134,6 +1144,26 @@
+ int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags);
+ 
+ /**
++ * Builds a complete index for seeking in each stream where it is possible.
++ * Requires that the streams have been opened.
++ * Part of the new seeking api.  incomplete.
++ */
++int av_build_index(AVFormatContext *s, int flags);
++#define AV_BUILD_INDEX_PARALLEL 0x0001 ///< Builds the index via a copied demuxer streams.  av_build_index with this flag can be called on a seperate thread while decoding is happening on another.
++
++/**
++ * Saves the index table built with av_build_index to a file
++ * Returns 0 if succesful or a negative value on failure.
++ */
++int av_save_index_file(AVFormatContext *ic, const char *filename);
++
++/**
++ * Loads the index saved with av_save_index.
++ * Returns 0 if successful or a negative value on failure.
++ */
++int av_load_index_file(AVFormatContext *ic, const char *filename);
++
++/**
+  * Ensure the index uses less memory than the maximum specified in
+  * AVFormatContext.max_index_size by discarding entries if it grows
+  * too large.
+@@ -1152,6 +1182,15 @@
+                        int size, int distance, int flags);
+ 
+ /**
++ * Perform a dictionary search on the seek table.
++ * av_build_index must be successfully called before using this function.
++ * @param timestamp target timestamp in the time base of the given stream
++ * @param stream_index stream number
++ */
++int av_seek_frame_table(AVFormatContext *s,
++                        int stream_index, int64_t timestamp, int flags);
++
++/**
+  * Perform a binary search using av_index_search_timestamp() and
+  * AVCodec.read_timestamp().
+  * This is not supposed to be called directly by a user application,
+Index: libavformat/utils.c
+===================================================================
+--- libavformat/utils.c	(revision 24319)
++++ libavformat/utils.c	(working copy)
+@@ -1031,7 +1031,6 @@
+         pkt->convergence_duration = pc->convergence_duration;
+ }
+ 
+-
+ static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
+ {
+     AVStream *st;
+@@ -1355,21 +1354,28 @@
+ 
+     st->index_entries= entries;
+ 
+-    index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
++    //if we are building the table, the indicies added in order, so we don't have to do expensive searching.
++    if(st->seek_table_flags & AV_SEEKTABLE_BUILDING) {
++        index = st->nb_index_entries++;
++        ie = &st->index_entries[index];
++    }
++    else {
++        index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
+ 
+-    if(index<0){
+-        index= st->nb_index_entries++;
+-        ie= &entries[index];
+-        assert(index==0 || ie[-1].timestamp < timestamp);
+-    }else{
+-        ie= &entries[index];
+-        if(ie->timestamp != timestamp){
+-            if(ie->timestamp <= timestamp)
+-                return -1;
+-            memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
+-            st->nb_index_entries++;
+-        }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
+-            distance= ie->min_distance;
++        if(index<0){
++            index= st->nb_index_entries++;
++            ie= &entries[index];
++            assert(index==0 || ie[-1].timestamp < timestamp);
++        }else{
++            ie= &entries[index];
++            if(ie->timestamp != timestamp){
++                if(ie->timestamp <= timestamp)
++                    return -1;
++                memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
++                st->nb_index_entries++;
++            }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
++                distance= ie->min_distance;
++        }
+     }
+ 
+     ie->pos = pos;
+@@ -1705,6 +1711,11 @@
+         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
+     }
+ 
++    /* if we've built a seek table, use it. */
++    st = s->streams[stream_index];
++    if (st->seek_table_flags & AV_SEEKTABLE_FINISHED)
++        return av_seek_frame_table(s, stream_index, timestamp, flags);
++
+     /* first, we try the format specific seek */
+     if (s->iformat->read_seek)
+         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
+@@ -1742,6 +1753,402 @@
+     // try some generic seek like av_seek_frame_generic() but with new ts semantics
+ }
+ 
++int av_seek_frame_table(AVFormatContext *s,
++                                 int stream_index, int64_t timestamp, int flags)
++{
++    int index;
++    int64_t ret;
++    AVStream *st;
++    AVIndexEntry *ie;
++
++    st = s->streams[stream_index];
++
++    //TODO: see if we can do something with the CBR field.
++    if(st->seek_table_flags & AV_SEEKTABLE_CBR){
++        int64_t target_pos;
++        int64_t start_time;
++        //if there is a constant frame length, we can compute where to jump to, but CBR may not have constant frame length
++
++        start_time = st->start_time == AV_NOPTS_VALUE ? 0 : st->start_time;
++        target_pos = s->data_offset + s->file_size * (timestamp - start_time) * av_q2d(st->time_base) / (st->duration * av_q2d(st->time_base));
++        if ((ret = url_fseek(s->pb, target_pos, SEEK_SET)) < 0)
++            return ret;
++        av_update_cur_dts(s, st, timestamp);
++        av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: cbr seek ok to %lli of %lli bytes\n", target_pos, s->file_size);
++        return 0;
++    }
++
++    //see if we need to move the parallel table over
++    if(st->parallel_index_entries) {
++        av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: copying over parallel frames\n");
++        av_free(st->index_entries);
++        st->index_entries = st->parallel_index_entries;
++        st->nb_index_entries = st->parallel_nb_index_entries;
++        st->index_entries_allocated_size = st->parallel_index_entries_allocated_size;
++        st->parallel_index_entries = NULL;
++    }
++
++    index = av_index_search_timestamp(st, timestamp, flags);
++
++    /* this function should only be called after the table is complete. */
++    if(index < 0 || index >= st->nb_index_entries-1){
++        return -1;
++    }
++
++    ff_read_frame_flush(s);
++    /* we use the native seek function if it exists, (still have to modify them to use seek_table) */
++    if (s->iformat->read_seek){
++        if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0) {
++            av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: table seeked using native function\n");
++            return 0;
++        }
++    }
++
++    ie = &st->index_entries[index];
++    if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
++        return ret;
++    av_update_cur_dts(s, st, ie->timestamp);
++
++    {
++        float request_time = (((float)timestamp/st->time_base.den)*st->time_base.num);
++        float actual_time = (((float)ie->timestamp/st->time_base.den)*st->time_base.num);
++        float time_base_inv = ((float)st->time_base.den/st->time_base.num);
++        av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: table seeked to %.2fs (actual request was %.2fs), timebaseinv %f, samplerate of %d\n",actual_time, request_time, time_base_inv, st->codec->sample_rate );
++    }
++    return 0;
++}
++
++//if we don't have the number of frames, we just guess.
++#define AV_DETECT_CBR_FPS_GUESS 10
++static int av_detect_cbr(AVFormatContext *s, AVStream *st) {
++    //check the stream's codec to see if a number of frames are listed, but we can't assume that is available.
++    if(s->data_offset > 0 && s->file_size > 0 && s->data_offset != s->file_size && st->codec && st->duration > 0) {
++        double sec_duration = st->duration * av_q2d(st->time_base);
++        int nb_frames = st->nb_frames?st->nb_frames:(sec_duration*AV_DETECT_CBR_FPS_GUESS);
++        int64_t br_dur_len = (st->codec->bit_rate * sec_duration)/8;
++        int64_t min_len = (s->file_size - s->data_offset) * (1 - 2.0/nb_frames);
++        int64_t max_len = (s->file_size - s->data_offset) * (1 + 2.0/nb_frames);
++
++        if(min_len < br_dur_len && br_dur_len < max_len) {
++            av_log(s, AV_LOG_DEBUG, "cbr ok (%lli < %lli < %lli) with bitrate=%i, timebase=%i/%i, duration = %f(%lli), nb_frames = %lli, offset= %lli\n",
++                   min_len, br_dur_len, max_len, st->codec->bit_rate,st->time_base.num,st->time_base.den, st->duration*av_q2d(st->time_base),st->duration,st->nb_frames,s->data_offset);
++            return 1;
++        }
++            av_log(s, AV_LOG_DEBUG, "cbr failed !(%lli < %lli < %lli) with bitrate=%i, timebase=%i/%i, duration = %f(%lli), nb_frames = %lli, offset= %lli\n",
++                   min_len, br_dur_len, max_len, st->codec->bit_rate,st->time_base.num,st->time_base.den, st->duration*av_q2d(st->time_base),st->duration,st->nb_frames,s->data_offset);
++    }else {
++            av_log(s, AV_LOG_DEBUG, "no cbr test with bitrate=%i, timebase=%i/%i, duration = %f(%lli), nb_frames = %lli, offset= %lli\n",
++                   st->codec?st->codec->bit_rate:-1,st->time_base.num,st->time_base.den, st->duration*av_q2d(st->time_base),st->duration,st->nb_frames,s->data_offset);
++    }
++
++    return 0;
++}
++
++/**
++ * Starts building a index for seeking.
++ * TODO: use a different file pointer so we can do this in a thread-safe manner,
++ *       as there are cases when the user will want to playback while building the index
++ **/
++int av_build_index(AVFormatContext *s, int flags)
++{
++    AVStream *st;
++    int ret;
++    int stream_index;
++    int i;
++    int orig_flags;
++
++    av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: starting building index\n");
++    stream_index = av_find_default_stream_index(s);
++    if(stream_index < 0)
++        return -1;
++
++    st = s->streams[stream_index];
++    /* TODO: check if this stream is CBR and the codec has a seek by timestamp. */
++    /*       if this is true then we can set a flag and exit here. */
++    if(0 && av_detect_cbr(s,st)) {
++        st->seek_table_flags |= AV_SEEKTABLE_CBR | AV_SEEKTABLE_FINISHED;
++    } else if(0) {
++        /* TODO: for this case see if we have a special method for generating the table */
++        /*       specific to a given format. */
++    } else if(st->nb_frames!=0 && st->nb_index_entries > st->nb_frames/2) {
++        /* some demuxers load a complete index upon file open. */
++        st->seek_table_flags |= AV_SEEKTABLE_COPIED;
++    } else {
++        AVFormatContext *build_ic;
++        AVPacket pkt;
++
++        av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: building index from scratch\n");
++
++        /* if the client needs it to be threadsafe, create a new format context to read from. */
++        if(flags & AV_BUILD_INDEX_PARALLEL) {
++            av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: making thread-safe copy of streams\n");
++            build_ic = avformat_alloc_context();
++            ret = av_open_input_file(&build_ic, s->filename, s->iformat, 0, NULL);
++
++            if(ret < 0) {
++                av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: error re-opening file/streams: %i\n", ret);
++                goto cleanup;
++            }
++            if(build_ic->nb_streams != s->nb_streams) {
++                ret = -1;
++                av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: cloned AVFormatContext has different number of streams!");
++                goto cleanup;
++            }
++
++            for(i = 0; i < build_ic->nb_streams; i++) {
++                AVStream *build_st= build_ic->streams[i];
++                AVCodecContext *avctx = build_st->codec;
++                AVCodec *pcodec;
++                build_ic->streams[i]->discard = AVDISCARD_DEFAULT;
++
++                //compare with the orignal stream's context, and if opened, copy settings and open the clone
++                if(s->streams[i]->codec->priv_data) {
++                    av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: copying stream based on priv_data\n");
++                    if((ret = avcodec_copy_context(avctx, s->streams[i]->codec)) < 0) {
++                        av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: error copying codec:%i\n", ret);
++                        goto cleanup;
++                    }
++                    pcodec = avcodec_find_decoder(avctx->codec_id);
++                    if((ret = avcodec_open(avctx,pcodec)) < 0) {
++                        av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: error opening codec:%i\n", ret);
++                        goto cleanup;
++                    }
++                }
++            }
++        } else {
++            build_ic = s;
++        }
++
++        /* default table generation behavior from av_seek_frame_generic */
++        /* TODO: see why s->data_offset is the file length for avi/mp4 and others */
++        if ((ret = url_fseek(build_ic->pb, 0/*s->data_offset*/, SEEK_SET)) < 0){
++            av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: error building index: %i\n", ret);
++            goto cleanup;
++        }
++
++        orig_flags = build_ic->flags;
++        build_ic->flags |= AVFMT_FLAG_GENPTS;
++        for(i=0;; i++) {
++            do{
++                ret = av_read_frame(build_ic, &pkt);
++            }while(ret == AVERROR(EAGAIN));
++            if(ret<0)
++                break;
++            av_free_packet(&pkt);
++        }
++        build_ic->flags = orig_flags;
++        ret = 0;
++    cleanup:
++        if(flags & AV_BUILD_INDEX_PARALLEL) {
++            //TODO: delay/wait till the main index signals us that we are okay to swap
++            if(build_ic) {
++                //take the index over from our clone
++                for(i = 0; i < build_ic->nb_streams; i++) {
++                    if(ret >= 0) {
++                        av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: marking %i frames from parallel stream ready for copy\n", build_ic->streams[i]->nb_index_entries);
++                        s->streams[i]->parallel_index_entries = build_ic->streams[i]->index_entries;
++                        s->streams[i]->parallel_nb_index_entries = build_ic->streams[i]->nb_index_entries;
++                        s->streams[i]->parallel_index_entries_allocated_size = build_ic->streams[i]->index_entries_allocated_size;
++                        build_ic->streams[i]->index_entries = NULL;
++                        s->streams[i]->seek_table_flags |= AV_SEEKTABLE_FINISHED;
++                    }
++                    avcodec_close(build_ic->streams[i]->codec);
++                }
++                av_close_input_file(build_ic);
++            }
++        }
++        if(ret < 0)
++            return ret;
++    }
++
++    /* since we may have moved the read cursor to the end, return seek to start of stream for non-parallel clients.  Not sure if this the desired behavior. */
++    if( !(flags & AV_BUILD_INDEX_PARALLEL) && !(st->seek_table_flags & AV_SEEKTABLE_COPIED) ) {
++        ff_read_frame_flush(s);
++        for(i=0; i<s->nb_streams;i++)
++            if(s->streams[i]->nb_index_entries)
++                s->streams[i]->seek_table_flags |= AV_SEEKTABLE_FINISHED;
++
++        if(st->start_time == AV_NOPTS_VALUE || (ret = av_seek_frame(s, stream_index, st->start_time, AVSEEK_FLAG_ANY) ) < 0 ) {
++            int data_offset =  (s->data_offset < 0) || (s->data_offset >= s->file_size) ? 0 : s->data_offset;
++
++            av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: finished building index but error seeking: %i,trying url_fseek\n", ret);
++
++            /* last ditch effort to seek using the file pointer. */
++            if ((ret = url_fseek(s->pb, data_offset, SEEK_SET)) < 0) {
++                av_log(s,AV_LOG_DEBUG,"SEEK_TABLE_DEBUG: error seeking with url_fseek: %i\n", ret);
++                return ret;
++            }
++        }
++    }
++    av_log(s, AV_LOG_DEBUG, "SEEK_TABLE_DEBUG: finished building index\n");
++    return 0;
++}
++
++/**
++ * Save the flags, size, and differences for the index table
++ */
++#define AV_SAVEINDEX_PACKETSIZE 1000
++static int av_save_index_stream(ByteIOContext *bc, AVStream *st) {
++    AVIndexEntry start_ie;
++    AVIndexEntry *last_ie, *curr_ie;
++    int i;
++
++    //we may need to save something like codec id to be safe.
++    ff_put_v(bc, st->seek_table_flags);
++    //we only write the index if we have a finished table.
++    if(st->seek_table_flags & AV_SEEKTABLE_FINISHED) {
++        ff_put_v(bc, st->nb_index_entries);
++
++        memset(&start_ie, 0, sizeof(AVIndexEntry));
++        last_ie = &start_ie;
++        for(i = 0; i < st->nb_index_entries; i++) {
++            curr_ie = &st->index_entries[i];
++            ff_put_v(bc, curr_ie->pos - last_ie->pos);
++            ff_put_v(bc, curr_ie->timestamp - last_ie->timestamp);
++            ff_put_v(bc, curr_ie->flags - last_ie->flags);
++            ff_put_v(bc, curr_ie->size - last_ie->size);
++            ff_put_v(bc, curr_ie->min_distance - last_ie->min_distance);
++            last_ie = curr_ie;
++            if(i % AV_SAVEINDEX_PACKETSIZE == 0)
++                put_flush_packet(bc);
++        }
++        av_log(NULL, AV_LOG_DEBUG, "successfully wrote index stream with %i entries.\n", st->nb_index_entries);
++    }
++    put_flush_packet(bc);
++
++    return 0;
++}
++
++/**
++ * load the flags, size, and differences for the index table
++ */
++static int av_load_index_stream(ByteIOContext *bc, AVStream *st) {
++    AVIndexEntry *ie, *last_ie;
++    uint64_t v;
++
++    //check to see if we have a table saved in this stream.
++    v = ff_get_v(bc);
++    if(v & AV_SEEKTABLE_FINISHED) {
++        st->seek_table_flags = v;
++        st->nb_index_entries = v = ff_get_v(bc);
++
++        //dump the old index and make the new one.
++        av_free(st->index_entries);
++        st->index_entries = av_malloc(v * sizeof(AVIndexEntry));
++
++        //the first index entry is not a diff, so it gets special treatment.
++        ie = st->index_entries;
++        if(v--) {
++            ie->pos = ff_get_v(bc);
++            ie->timestamp = ff_get_v(bc);
++            ie->flags = ff_get_v(bc);
++            ie->size = ff_get_v(bc);
++            ie->min_distance = ff_get_v(bc);
++            last_ie = ie;
++            ie++;
++        }
++
++        while(v--) {
++            ie->pos =  ff_get_v(bc) + last_ie->pos;
++            ie->timestamp =  ff_get_v(bc) + last_ie->timestamp;
++            ie->flags =  ff_get_v(bc) + last_ie->flags;
++            ie->size =  ff_get_v(bc) + last_ie->size;
++            ie->min_distance =  ff_get_v(bc) + last_ie->min_distance;
++            last_ie = ie;
++            ie++;
++        }
++        av_log(NULL, AV_LOG_DEBUG, "successfully loaded index stream with %i entries.\n", st->nb_index_entries);
++    }
++    return 0;
++}
++
++/**
++ * Saves the table index built with av_build_index to a file.
++ * Returns 0 if successful, or a negative number if not.
++ *  this is not mean to be human-readable
++ * we save the following things in order:
++ * - A strz "FFmpegTableIndex" (17 bytes)
++ * - The libavformat version number
++ * - The file name (null terminated)
++ * - the number of streams (4 bytes)
++ * - each of the streams' index tables via av_save_index_stream
++ */
++#define AV_INDEX_IDENTIFIER "FFmpegTableIndex"
++#define AV_INDEX_NOFILENAME "nofilename"
++static int av_save_index(ByteIOContext *bc, AVFormatContext *ic) {
++    int i, ret;
++
++    put_strz(bc, AV_INDEX_IDENTIFIER);
++    ff_put_v(bc, LIBAVFORMAT_VERSION_INT);
++    put_strz(bc, ic->filename?ic->filename:AV_INDEX_NOFILENAME);
++    ff_put_v(bc, ic->nb_streams);
++    for(i = 0; i< ic->nb_streams; i++) {
++        ret = av_save_index_stream(bc, ic->streams[i]);
++        if(ret < 0)
++            return ret;
++    }
++    put_flush_packet(bc);
++    av_log(ic, AV_LOG_DEBUG, "successfully wrote index.\n");
++    return 0;
++}
++
++static int av_load_index(ByteIOContext *bc, AVFormatContext *ic) {
++    int i, ret;
++    uint64_t v;
++    char read_str[256];
++
++    get_strz(bc, read_str, 255);
++    if( strcmp(read_str, AV_INDEX_IDENTIFIER) )
++        return -1;
++    //version
++    v = ff_get_v(bc);
++    //make sure the filename matches the context we will write to.
++    get_strz(bc, read_str, 255);
++    if( strlen(read_str) < 255 && strcmp(read_str, ic->filename) && strcmp(read_str, AV_INDEX_NOFILENAME) )
++       return -1;
++
++    v = ff_get_v(bc);
++    if( v != ic->nb_streams)
++        return -1;
++    for(i =0; i<v; i++) {
++        ret = av_load_index_stream(bc, ic->streams[i]);
++        if(ret < 0)
++            return ret;
++    }
++    av_log(ic, AV_LOG_DEBUG, "successfully read index.\n");
++    return 0;
++}
++
++int av_save_index_file(AVFormatContext *ic, const char* filename) {
++    ByteIOContext* bc;
++    int i, ret, table_completed = 0;
++
++    //do a first pass to see if we have any tables that need saving.
++    //only write the file if it exists.
++    for(i = 0; i< ic->nb_streams; i++)
++        table_completed |= ic->streams[i]->seek_table_flags & AV_SEEKTABLE_FINISHED;
++    if(!table_completed)
++        return -1;
++
++    if ((ret=url_fopen(&bc, filename, URL_WRONLY)) < 0) {
++        return -1;
++    }
++    ret = av_save_index(bc, ic);
++    url_fclose(bc);
++    return ret;
++}
++
++int av_load_index_file(AVFormatContext *ic, const char* filename) {
++    ByteIOContext* bc;
++    int ret;
++
++    if ((ret=url_fopen(&bc, filename, URL_RDONLY)) < 0) {
++        return -1;
++    }
++    ret = av_load_index(bc, ic);
++    url_fclose(bc);
++    return ret;
++}
+ /*******************************************************/
+ 
+ /**


More information about the FFmpeg-soc mailing list