ffmpeg roll of source to mar 9 version...

patched-ffmpeg-mt/libavformat/seek.c

 /*
  * seek utility functions for use within format handlers
  *
  * Copyright (c) 2009 Ivan Schreter
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * FFmpeg is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include "seek.h"
 #include "libavutil/mem.h"
+#include "internal.h"
 
 // NOTE: implementation should be moved here in another patch, to keep patches
 // separated.
-extern void av_read_frame_flush(AVFormatContext *s);
 
 /**
  * helper structure describing keyframe search state of one stream
  */
 typedef struct {
     int64_t     pos_lo;      ///< position of the frame with low timestamp in file or INT64_MAX if not found (yet)
     int64_t     ts_lo;       ///< frame presentation timestamp or same as pos_lo for byte seeking
 
     int64_t     pos_hi;      ///< position of the frame with high timestamp in file or INT64_MAX if not found (yet)
     int64_t     ts_hi;       ///< frame presentation timestamp or same as pos_hi for byte seeking
 
     int64_t     last_pos;    ///< last known position of a frame, for multi-frame packets
 
     int64_t     term_ts;     ///< termination timestamp (which TS we already read)
     AVRational  term_ts_tb;  ///< timebase for term_ts
     int64_t     first_ts;    ///< first packet timestamp in this iteration (to fill term_ts later)
     AVRational  first_ts_tb; ///< timebase for first_ts
 
     int         terminated;  ///< termination flag for the current iteration
 } AVSyncPoint;
 
 /**
- * Compare two timestamps exactly, taking their respective time bases into account.
- *
- * @param ts_a timestamp A
- * @param tb_a time base for timestamp A
- * @param ts_b timestamp B
- * @param tb_b time base for timestamp A
- * @return -1, 0 or 1 if timestamp A is less than, equal or greater than timestamp B
- */
-static int compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
-{
-    int64_t a, b, res;
-
-    if (ts_a == INT64_MIN)
-        return ts_a < ts_b ? -1 : 0;
-    if (ts_a == INT64_MAX)
-        return ts_a > ts_b ?  1 : 0;
-    if (ts_b == INT64_MIN)
-        return ts_a > ts_b ?  1 : 0;
-    if (ts_b == INT64_MAX)
-        return ts_a < ts_b ? -1 : 0;
-
-    a = ts_a * tb_a.num * tb_b.den;
-    b = ts_b * tb_b.num * tb_a.den;
-
-    res = a - b;
-    if (!res)
-        return 0;
-    else
-        return (res >> 63) | 1;
-}
-
-/**
  * Compute a distance between timestamps.
  *
  * Distances are only comparable, if same time bases are used for computing
  * distances.
  *
  * @param ts_hi high timestamp
  * @param tb_hi high timestamp time base
  * @param ts_lo low timestamp
  * @param tb_lo low timestamp time base
  * @return representation of distance between high and low timestamps
@@ skipping 116 matching lines @@
             if (sp->first_ts == AV_NOPTS_VALUE) {
                 // Note down termination timestamp for the next iteration - when
                 // we encounter a packet with the same timestamp, we will ignore
                 // any further packets for this stream in next iteration (as they
                 // are already evaluated).
                 sp->first_ts    = ts;
                 sp->first_ts_tb = ts_tb;
             }
 
             if (sp->term_ts != AV_NOPTS_VALUE &&
-                compare_ts(ts, ts_tb, sp->term_ts, sp->term_ts_tb) > 0) {
+                av_compare_ts(ts, ts_tb, sp->term_ts, sp->term_ts_tb) > 0) {
                 // past the end position from last iteration, ignore packet
                 if (!sp->terminated) {
                     sp->terminated = 1;
                     ++terminated_count;
                     if (sp->pos_hi == INT64_MAX) {
                         // no high frame exists for this stream
                         (*found_hi)++;
                         sp->ts_hi  = INT64_MAX;
                         sp->pos_hi = INT64_MAX - 1;
                     }
                     if (terminated_count == keyframes_to_find)
                         break;  // all terminated, iteration done
                 }
                 continue;
             }
 
-            if (compare_ts(ts, ts_tb, timestamp, timebase) <= 0) {
+            if (av_compare_ts(ts, ts_tb, timestamp, timebase) <= 0) {
                 // keyframe found before target timestamp
                 if (sp->pos_lo == INT64_MAX) {
                     // found first keyframe lower than target timestamp
                     (*found_lo)++;
                     sp->ts_lo  = ts;
                     sp->pos_lo = pos;
                 } else if (sp->ts_lo < ts) {
                     // found a better match (closer to target timestamp)
                     sp->ts_lo  = ts;
                     sp->pos_lo = pos;
                 }
             }
-            if (compare_ts(ts, ts_tb, timestamp, timebase) >= 0) {
+            if (av_compare_ts(ts, ts_tb, timestamp, timebase) >= 0) {
                 // keyframe found after target timestamp
                 if (sp->pos_hi == INT64_MAX) {
                     // found first keyframe higher than target timestamp
                     (*found_hi)++;
                     sp->ts_hi  = ts;
                     sp->pos_hi = pos;
                     if (*found_hi >= keyframes_to_find && first_iter) {
                         // We found high frame for all. They may get updated
                         // to TS closer to target TS in later iterations (which
                         // will stop at start position of previous iteration).
@@ skipping 124 matching lines @@
     // closest to ts and between ts_min and ts_max.
     pos = INT64_MAX;
 
     for (i = 0; i < s->nb_streams; ++i) {
         st = s->streams[i];
         if (st->discard < AVDISCARD_ALL) {
             sp = &sync[i];
             min_distance = INT64_MAX;
             // Find timestamp closest to requested timestamp within min/max limits.
             if (sp->pos_lo != INT64_MAX
-                && compare_ts(ts_min, time_base, sp->ts_lo, st->time_base) <= 0
-                && compare_ts(sp->ts_lo, st->time_base, ts_max, time_base) <= 0) {
+                && av_compare_ts(ts_min, time_base, sp->ts_lo, st->time_base) <= 0
+                && av_compare_ts(sp->ts_lo, st->time_base, ts_max, time_base) <= 0) {
                 // low timestamp is in range
                 min_distance = ts_distance(ts, time_base, sp->ts_lo, st->time_base);
                 min_pos = sp->pos_lo;
             }
             if (sp->pos_hi != INT64_MAX
-                && compare_ts(ts_min, time_base, sp->ts_hi, st->time_base) <= 0
-                && compare_ts(sp->ts_hi, st->time_base, ts_max, time_base) <= 0) {
+                && av_compare_ts(ts_min, time_base, sp->ts_hi, st->time_base) <= 0
+                && av_compare_ts(sp->ts_hi, st->time_base, ts_max, time_base) <= 0) {
                 // high timestamp is in range, check distance
                 distance = ts_distance(sp->ts_hi, st->time_base, ts, time_base);
                 if (distance < min_distance) {
                     min_distance = distance;
                     min_pos = sp->pos_hi;
                 }
             }
             if (min_distance == INT64_MAX) {
                 // no timestamp is in range, cannot seek
                 av_free(sync);
@@ skipping 128 matching lines @@
         av_free_packet(&ss->cur_pkt);
     }
 
     free_packet_list(state->packet_buffer);
     free_packet_list(state->raw_packet_buffer);
 
     av_free(state->stream_states);
     av_free(state);
 }