store searched distance in index, so we dont waste time searching for...

store searched distance in index, so we dont waste time searching for keyframes where we already searched
asf seek fixes & use keyframe pos/timestamp cache

Originally committed as revision 2709 to svn://svn.ffmpeg.org/ffmpeg/trunk

libavformat/asf.c

@@ -1355,11 +1355,17 @@ static int64_t asf_read_pts(AVFormatContext *s, int64_t *ppos, int stream_index)
     ASFStream *asf_st;
     int64_t pts;
     int64_t pos= *ppos;
+    int i;
+    int64_t start_pos[s->nb_streams];
+    
+    for(i=0; i<s->nb_streams; i++){
+        start_pos[i]= pos;
+    }
 
 //printf("asf_read_pts\n");
     url_fseek(&s->pb, pos*asf->packet_size + s->data_offset, SEEK_SET);
     asf_reset_header(s);
-    do{
+    for(;;){
         if (av_read_frame(s, pkt) < 0){
             printf("seek failed\n");
     	    return AV_NOPTS_VALUE;
@@ -1367,11 +1373,23 @@ static int64_t asf_read_pts(AVFormatContext *s, int64_t *ppos, int stream_index)
         pts= pkt->pts;
 
         av_free_packet(pkt);
-    }while(pkt->stream_index != stream_index || !(pkt->flags&PKT_FLAG_KEY));
-    asf_st= s->streams[stream_index]->priv_data;
+        if(pkt->flags&PKT_FLAG_KEY){
+            i= pkt->stream_index;
+
+            asf_st= s->streams[i]->priv_data;
 
             assert((asf_st->packet_pos - s->data_offset) % asf->packet_size == 0);
-    *ppos= (asf_st->packet_pos - s->data_offset) / asf->packet_size;
+            pos= (asf_st->packet_pos - s->data_offset) / asf->packet_size;
+
+            av_add_index_entry(s->streams[i], pos, pts, pos - start_pos[i] + 1, AVINDEX_KEYFRAME);
+            start_pos[i]= pos + 1;
+            
+            if(pkt->stream_index == stream_index)
+               break;
+        }
+    }
+
+    *ppos= pos;
 //printf("found keyframe at %Ld stream %d stamp:%Ld\n", *ppos, stream_index, pts);
 
     return pts;
@@ -1380,6 +1398,7 @@ static int64_t asf_read_pts(AVFormatContext *s, int64_t *ppos, int stream_index)
 static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts)
 {
     ASFContext *asf = s->priv_data;
+    AVStream *st;
     int64_t pos;
     int64_t pos_min, pos_max, pts_min, pts_max, cur_pts, pos_limit;
     
@@ -1389,24 +1408,60 @@ static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts)
     if (asf->packet_size <= 0)
         return -1;
 
+    pts_max=
+    pts_min= AV_NOPTS_VALUE;
+    pos_max= pos_limit= -1; // gcc thinks its uninitalized
+
+    st= s->streams[stream_index];
+    if(st->index_entries){
+        AVIndexEntry *e;
+        int index;
+
+        index= av_index_search_timestamp(st, pts);
+        e= &st->index_entries[index];
+        if(e->timestamp <= pts){
+            pos_min= e->pos;
+            pts_min= e->timestamp;
+#ifdef DEBUG_SEEK
+        printf("unsing cached pos_min=0x%llx dts_min=%0.3f\n", 
+               pos_min,pts_min / 90000.0);
+#endif
+        }else{
+            assert(index==0);
+        }
+        index++;
+        if(index < st->nb_index_entries){
+            e= &st->index_entries[index];
+            assert(e->timestamp >= pts);
+            pos_max= e->pos;
+            pts_max= e->timestamp;
+            pos_limit= pos_max - e->min_distance;
+#ifdef DEBUG_SEEK
+        printf("unsing cached pos_max=0x%llx dts_max=%0.3f\n", 
+               pos_max,pts_max / 90000.0);
+#endif
+        }
+    }
+
+    if(pts_min == AV_NOPTS_VALUE){
         pos_min = 0;
         pts_min = asf_read_pts(s, &pos_min, stream_index);
         if (pts_min == AV_NOPTS_VALUE) return -1;
-   
+    }
+    if(pts_max == AV_NOPTS_VALUE){
         pos_max = (url_filesize(url_fileno(&s->pb)) - 1 - s->data_offset) / asf->packet_size; //FIXME wrong
-    pts_max = pts_min + s->duration;
+        pts_max = s->duration; //FIXME wrong
         pos_limit= pos_max;
+    } 
 
     while (pos_min < pos_limit) {
         int64_t start_pos;
-
         assert(pos_limit <= pos_max);
 
         // interpolate position (better than dichotomy)
         pos = (int64_t)((double)(pos_limit - pos_min) *
                         (double)(pts - pts_min) /
                         (double)(pts_max - pts_min)) + pos_min;
-        pos/= asf->packet_size;
         if(pos <= pos_min)
             pos= pos_min + 1;
         else if(pos > pos_limit)
@@ -1415,8 +1470,11 @@ static int asf_read_seek(AVFormatContext *s, int stream_index, int64_t pts)
 
         // read the next timestamp 
     	cur_pts = asf_read_pts(s, &pos, stream_index);    
-
+#ifdef DEBUG_SEEK
+printf("%Ld %Ld %Ld / %Ld %Ld %Ld target:%Ld limit:%Ld start:%Ld\n", pos_min, pos, pos_max, pts_min, cur_pts, pts_max, pts, pos_limit, start_pos);
+#endif
         if (cur_pts == AV_NOPTS_VALUE) {
+            printf("NOPTS\n");
             return -1;
         } else if (pts < cur_pts) {
             pos_limit = start_pos - 1;

libavformat/avformat.h

@@ -196,9 +196,8 @@ typedef struct AVIndexEntry {
     int64_t timestamp;
 #define AVINDEX_KEYFRAME 0x0001
 /* the following 2 flags indicate that the next/prev keyframe is known, and scaning for it isnt needed */
-#define AVINDEX_NEXT_KNOWN 0x0002
-#define AVINDEX_PREV_KNOWN 0x0004
     int flags;
+    int min_distance;         /* min distance between this and the previous keyframe, used to avoid unneeded searching */
 } AVIndexEntry;
 
 typedef struct AVStream {
@@ -549,8 +548,8 @@ void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
 
 int av_find_default_stream_index(AVFormatContext *s);
 int av_index_search_timestamp(AVStream *st, int timestamp);
-void av_add_index_entry(AVStream *st,
-                            int64_t pos, int64_t timestamp, int flags);
+int av_add_index_entry(AVStream *st,
+                       int64_t pos, int64_t timestamp, int distance, int flags);
 
 /* media file output */
 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap);

libavformat/mpeg.c

@@ -909,7 +909,7 @@ static int mpegps_read_pes_header(AVFormatContext *s,
         int i;
         for(i=0; i<s->nb_streams; i++){
             if(startcode == s->streams[i]->id) {
-                av_add_index_entry(s->streams[i], *ppos, dts, 0 /* FIXME keyframe? */);
+                av_add_index_entry(s->streams[i], *ppos, dts, 0, 0 /* FIXME keyframe? */);
             }
         }
     }

libavformat/utils.c

@@ -861,8 +861,8 @@ static void av_read_frame_flush(AVFormatContext *s)
 }
 
 /* add a index entry into a sorted list updateing if it is already there */
-void av_add_index_entry(AVStream *st,
-                            int64_t pos, int64_t timestamp, int flags)
+int av_add_index_entry(AVStream *st,
+                            int64_t pos, int64_t timestamp, int distance, int flags)
 {
     AVIndexEntry *entries, *ie;
     int index;
@@ -890,12 +890,17 @@ void av_add_index_entry(AVStream *st,
             }
             st->nb_index_entries++;
         }
-    }else
-        ie= &entries[st->nb_index_entries++];
+    }else{
+        index= st->nb_index_entries++;
+        ie= &entries[index];
+    }
     
     ie->pos = pos;
     ie->timestamp = timestamp;
+    ie->min_distance= distance;
     ie->flags = flags;
+    
+    return index;
 }
 
 /* build an index for raw streams using a parser */
@@ -916,7 +921,7 @@ static void av_build_index_raw(AVFormatContext *s)
         if (pkt->stream_index == 0 && st->parser &&
             (pkt->flags & PKT_FLAG_KEY)) {
             av_add_index_entry(st, st->parser->frame_offset, pkt->dts, 
-                            AVINDEX_KEYFRAME);
+                            0, AVINDEX_KEYFRAME);
         }
         av_free_packet(pkt);
     }