Fix seeking when the start time is non-zero.

media/filters/ffmpeg_demuxer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/filters/ffmpeg_demuxer.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/base64.h"
@@ skipping 37 matching lines @@
   }
 
   return base::Time();
 }
 
 static base::TimeDelta FramesToTimeDelta(int frames, double sample_rate) {
   return base::TimeDelta::FromMicroseconds(
       frames * base::Time::kMicrosecondsPerSecond / sample_rate);
 }
 
+static base::TimeDelta ExtractStartTime(AVStream* stream,
+                                        base::TimeDelta start_time_estimate) {
+  DCHECK(start_time_estimate != kNoTimestamp());
+  if (stream->start_time == static_cast<int64_t>(AV_NOPTS_VALUE)) {
+    return start_time_estimate == kInfiniteDuration() ? kNoTimestamp()
+                                                      : start_time_estimate;
+  }
+
+  // First try the lower of the estimate and the |start_time| value.
+  base::TimeDelta start_time =
+      std::min(ConvertFromTimeBase(stream->time_base, stream->start_time),
+               start_time_estimate);
+
+  // Next see if the first buffered pts value is usable.
+  if (stream->pts_buffer[0] != static_cast<int64_t>(AV_NOPTS_VALUE)) {
+    const base::TimeDelta buffered_pts =
+        ConvertFromTimeBase(stream->time_base, stream->pts_buffer[0]);
+    if (buffered_pts < start_time)
+      start_time = buffered_pts;
+  }
+
+  // NOTE: Do not use AVStream->first_dts since |start_time| should be a
+  // presentation timestamp.
+  return start_time;
+}
+
 //
 // FFmpegDemuxerStream
 //
 FFmpegDemuxerStream::FFmpegDemuxerStream(
     FFmpegDemuxer* demuxer,
-    AVStream* stream)
+    AVStream* stream,
+    bool discard_negative_timestamps)
     : demuxer_(demuxer),
       task_runner_(base::MessageLoopProxy::current()),
       stream_(stream),
       type_(UNKNOWN),
       end_of_stream_(false),
       last_packet_timestamp_(kNoTimestamp()),
-      bitstream_converter_enabled_(false) {
+      bitstream_converter_enabled_(false),
+      discard_negative_timestamps_(discard_negative_timestamps) {
   DCHECK(demuxer_);
 
   bool is_encrypted = false;
 
   // Determine our media format.
   switch (stream->codec->codec_type) {
     case AVMEDIA_TYPE_AUDIO:
       type_ = AUDIO;
       AVStreamToAudioDecoderConfig(stream, &audio_config_, true);
       is_encrypted = audio_config_.is_encrypted();
@@ skipping 138 matching lines @@
           audio_decoder_config().samples_per_second();
       buffer->set_discard_padding(std::make_pair(
           FramesToTimeDelta(discard_front_samples, samples_per_second),
           FramesToTimeDelta(discard_end_samples, samples_per_second)));
     }
 
     if (decrypt_config)
       buffer->set_decrypt_config(decrypt_config.Pass());
   }
 
-  buffer->set_timestamp(ConvertStreamTimestamp(
-      stream_->time_base, packet->pts));
-  buffer->set_duration(ConvertStreamTimestamp(
-      stream_->time_base, packet->duration));
-  if (buffer->timestamp() != kNoTimestamp() &&
-      last_packet_timestamp_ != kNoTimestamp() &&
-      last_packet_timestamp_ < buffer->timestamp()) {
-    buffered_ranges_.Add(last_packet_timestamp_, buffer->timestamp());
-    demuxer_->NotifyBufferingChanged();
+  buffer->set_duration(
+      ConvertStreamTimestamp(stream_->time_base, packet->duration));
+
+  // Note: If pts is AV_NOPTS_VALUE, stream_timestamp will be kNoTimestamp().
+  const base::TimeDelta stream_timestamp =
+      ConvertStreamTimestamp(stream_->time_base, packet->pts);
+
+  if (stream_timestamp != kNoTimestamp()) {
+    buffer->set_timestamp(stream_timestamp - demuxer_->start_time());
+
+    // If enabled, mark packets with negative timestamps for post-decode
+    // discard.
+    if (discard_negative_timestamps_ && stream_timestamp < base::TimeDelta()) {
+      if (stream_timestamp + buffer->duration() < base::TimeDelta()) {
+        // Discard the entier packet if it's entirely before zero.

[acolwell GONE FROM CHROMIUM, 2014/06/17 22:58:54]

nit: s/entier/entire/

[DaleCurtis, 2014/06/17 23:04:05]

Done.

+        buffer->set_discard_padding(
+            std::make_pair(kInfiniteDuration(), base::TimeDelta()));
+      } else {
+        // Only discard part of the frame if it overlaps zero.
+        buffer->set_discard_padding(
+            std::make_pair(-stream_timestamp, base::TimeDelta()));
+      }
+    }
+
+    if (last_packet_timestamp_ != kNoTimestamp() &&
+        last_packet_timestamp_ < buffer->timestamp()) {
+      buffered_ranges_.Add(last_packet_timestamp_, buffer->timestamp());
+      demuxer_->NotifyBufferingChanged();
+    }
+
+    // The demuxer should always output positive timestamps.
+    DCHECK(buffer->timestamp() >= base::TimeDelta());
+  } else {
+    buffer->set_timestamp(kNoTimestamp());
   }
+
+  // TODO(dalecurtis): This allows transitions from <valid ts> -> <no timestamp>
+  // which shouldn't be allowed.  See http://crbug.com/384532
   last_packet_timestamp_ = buffer->timestamp();
 
   buffer_queue_.Push(buffer);
   SatisfyPendingRead();
 }
 
 void FFmpegDemuxerStream::SetEndOfStream() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   end_of_stream_ = true;
   SatisfyPendingRead();
@@ skipping 12 matching lines @@
   buffer_queue_.Clear();
   if (!read_cb_.is_null()) {
     base::ResetAndReturn(&read_cb_).Run(
         DemuxerStream::kOk, DecoderBuffer::CreateEOSBuffer());
   }
   demuxer_ = NULL;
   stream_ = NULL;
   end_of_stream_ = true;
 }
 
-base::TimeDelta FFmpegDemuxerStream::duration() {
-  return duration_;
-}
-
 DemuxerStream::Type FFmpegDemuxerStream::type() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return type_;
 }
 
 void FFmpegDemuxerStream::Read(const ReadCB& read_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   CHECK(read_cb_.is_null()) << "Overlapping reads are not supported";
   read_cb_ = BindToCurrentLoop(read_cb);
 
@@ skipping 124 matching lines @@
     const scoped_refptr<MediaLog>& media_log)
     : host_(NULL),
       task_runner_(task_runner),
       blocking_thread_("FFmpegDemuxer"),
       pending_read_(false),
       pending_seek_(false),
       data_source_(data_source),
       media_log_(media_log),
       bitrate_(0),
       start_time_(kNoTimestamp()),
+      preferred_stream_for_seeking_(-1, kNoTimestamp()),
+      fallback_stream_for_seeking_(-1, kNoTimestamp()),
       liveness_(LIVENESS_UNKNOWN),
       text_enabled_(false),
       duration_known_(false),
       need_key_cb_(need_key_cb),
       weak_factory_(this) {
   DCHECK(task_runner_.get());
   DCHECK(data_source_);
 }
 
 FFmpegDemuxer::~FFmpegDemuxer() {}
 
 void FFmpegDemuxer::Stop(const base::Closure& callback) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   url_protocol_->Abort();
   data_source_->Stop(
       BindToCurrentLoop(base::Bind(&FFmpegDemuxer::OnDataSourceStopped,
                                    weak_factory_.GetWeakPtr(),
                                    BindToCurrentLoop(callback))));
   data_source_ = NULL;
 }
 
 void FFmpegDemuxer::Seek(base::TimeDelta time, const PipelineStatusCB& cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   CHECK(!pending_seek_);
 
   // TODO(scherkus): Inspect |pending_read_| and cancel IO via |blocking_url_|,
   // otherwise we can end up waiting for a pre-seek read to complete even though
   // we know we're going to drop it on the floor.
 
-  // Always seek to a timestamp less than or equal to the desired timestamp.
-  int flags = AVSEEK_FLAG_BACKWARD;
+  // FFmpeg requires seeks to be adjusted according to the lowest starting time.
+  const base::TimeDelta seek_time = time + start_time_;
 
-  // Passing -1 as our stream index lets FFmpeg pick a default stream.  FFmpeg
-  // will attempt to use the lowest-index video stream, if present, followed by
-  // the lowest-index audio stream.
+  // Choose the preferred stream if |seek_time| occurs after its starting time,
+  // otherwise use the fallback stream.
+  DCHECK(preferred_stream_for_seeking_.second != kNoTimestamp());
+  const int stream_index = seek_time >= preferred_stream_for_seeking_.second
+                               ? preferred_stream_for_seeking_.first
+                               : fallback_stream_for_seeking_.first;
+  DCHECK_NE(stream_index, -1);
+
+  const AVStream* seeking_stream =
+      glue_->format_context()->streams[stream_index];
+
   pending_seek_ = true;
   base::PostTaskAndReplyWithResult(
       blocking_thread_.message_loop_proxy().get(),
       FROM_HERE,
       base::Bind(&av_seek_frame,
                  glue_->format_context(),
-                 -1,
-                 time.InMicroseconds(),
-                 flags),
+                 seeking_stream->index,
+                 ConvertToTimeBase(seeking_stream->time_base, seek_time),
+                 // Always seek to a timestamp <= to the desired timestamp.
+                 AVSEEK_FLAG_BACKWARD),
       base::Bind(
           &FFmpegDemuxer::OnSeekFrameDone, weak_factory_.GetWeakPtr(), cb));
 }
 
 void FFmpegDemuxer::Initialize(DemuxerHost* host,
                                const PipelineStatusCB& status_cb,
                                bool enable_text_tracks) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   host_ = host;
   text_enabled_ = enable_text_tracks;
@@ skipping 28 matching lines @@
     DemuxerStream::Type type) const {
   StreamVector::const_iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if (*iter && (*iter)->type() == type) {
       return *iter;
     }
   }
   return NULL;
 }
 
-base::TimeDelta FFmpegDemuxer::GetStartTime() const {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  return start_time_;
-}
-
 base::Time FFmpegDemuxer::GetTimelineOffset() const {
   return timeline_offset_;
 }
 
 Demuxer::Liveness FFmpegDemuxer::GetLiveness() const {
   DCHECK(task_runner_->BelongsToCurrentThread());
   return liveness_;
 }
 
 void FFmpegDemuxer::AddTextStreams() {
@@ skipping 89 matching lines @@
     return;
   }
 
   // Create demuxer stream entries for each possible AVStream. Each stream
   // is examined to determine if it is supported or not (is the codec enabled
   // for it in this release?). Unsupported streams are skipped, allowing for
   // partial playback. At least one audio or video stream must be playable.
   AVFormatContext* format_context = glue_->format_context();
   streams_.resize(format_context->nb_streams);
 
+  // Estimate the start time for each stream by looking through the packets
+  // buffered during avformat_find_stream_info().  These values will be
+  // considered later when determining the actual stream start time.
+  //
+  // These packets haven't been completely processed yet, so only look through
+  // these values if the AVFormatContext has a valid start time.
+  //
+  // If no estimate is found, the stream entry will be kInfiniteDuration().
+  std::vector<base::TimeDelta> start_time_estimates(format_context->nb_streams,
+                                                    kInfiniteDuration());
+  if (format_context->packet_buffer &&
+      format_context->start_time != static_cast<int64>(AV_NOPTS_VALUE)) {
+    struct AVPacketList* packet_buffer = format_context->packet_buffer;
+    while (packet_buffer != format_context->packet_buffer_end) {
+      DCHECK_LT(static_cast<size_t>(packet_buffer->pkt.stream_index),
+                start_time_estimates.size());
+      const AVStream* stream =
+          format_context->streams[packet_buffer->pkt.stream_index];
+      if (packet_buffer->pkt.pts != static_cast<int64>(AV_NOPTS_VALUE)) {
+        const base::TimeDelta packet_pts =
+            ConvertFromTimeBase(stream->time_base, packet_buffer->pkt.pts);
+        if (packet_pts < start_time_estimates[stream->index])
+          start_time_estimates[stream->index] = packet_pts;
+      }
+      packet_buffer = packet_buffer->next;
+    }
+  }
+
   AVStream* audio_stream = NULL;
   AudioDecoderConfig audio_config;
 
   AVStream* video_stream = NULL;
   VideoDecoderConfig video_config;
 
+  // If available, |start_time_| will be set to the lowest stream start time.
+  start_time_ = kInfiniteDuration();
+
   base::TimeDelta max_duration;
   for (size_t i = 0; i < format_context->nb_streams; ++i) {
     AVStream* stream = format_context->streams[i];
-    AVCodecContext* codec_context = stream->codec;
-    AVMediaType codec_type = codec_context->codec_type;
+    const AVCodecContext* codec_context = stream->codec;
+    const AVMediaType codec_type = codec_context->codec_type;
+    bool discard_negative_timestamps = false;
 
     if (codec_type == AVMEDIA_TYPE_AUDIO) {
       if (audio_stream)
         continue;
 
       // Log the codec detected, whether it is supported or not.
       UMA_HISTOGRAM_SPARSE_SLOWLY("Media.DetectedAudioCodec",
                                   codec_context->codec_id);
       // Ensure the codec is supported. IsValidConfig() also checks that the
       // channel layout and sample format are valid.
       AVStreamToAudioDecoderConfig(stream, &audio_config, false);
       if (!audio_config.IsValidConfig())
         continue;
       audio_stream = stream;
+
+      // Enable post-decode frame dropping for packets with negative timestamps
+      // as outlined in section A.2 in the Ogg Vorbis spec:
+      // http://xiph.org/vorbis/doc/Vorbis_I_spec.html
+      discard_negative_timestamps =
+          audio_config.codec() == kCodecVorbis &&
+          strcmp(glue_->format_context()->iformat->name, "ogg") == 0;
     } else if (codec_type == AVMEDIA_TYPE_VIDEO) {
       if (video_stream)
         continue;
 
       // Log the codec detected, whether it is supported or not.
       UMA_HISTOGRAM_SPARSE_SLOWLY("Media.DetectedVideoCodec",
                                   codec_context->codec_id);
       // Ensure the codec is supported. IsValidConfig() also checks that the
       // frame size and visible size are valid.
       AVStreamToVideoDecoderConfig(stream, &video_config, false);
 
       if (!video_config.IsValidConfig())
         continue;
       video_stream = stream;
     } else if (codec_type == AVMEDIA_TYPE_SUBTITLE) {
       if (codec_context->codec_id != AV_CODEC_ID_WEBVTT || !text_enabled_) {
         continue;
       }
     } else {
       continue;
     }
 
-    streams_[i] = new FFmpegDemuxerStream(this, stream);
+    streams_[i] =
+        new FFmpegDemuxerStream(this, stream, discard_negative_timestamps);
     max_duration = std::max(max_duration, streams_[i]->duration());
 
-    if (stream->first_dts != static_cast<int64_t>(AV_NOPTS_VALUE)) {
-      const base::TimeDelta first_dts = ConvertFromTimeBase(
-          stream->time_base, stream->first_dts);
-      if (start_time_ == kNoTimestamp() || first_dts < start_time_)
-        start_time_ = first_dts;
+    const base::TimeDelta start_time =
+        ExtractStartTime(stream, start_time_estimates[i]);
+    if (start_time == kNoTimestamp())
+      continue;
+
+    if (start_time < start_time_) {
+      start_time_ = start_time;
+
+      // Choose the stream with the lowest starting time as the fallback stream
+      // for seeking.  Video should always be preferred.
+      fallback_stream_for_seeking_ = std::make_pair(i, start_time);
     }
+
+    // Always prefer the video stream for seeking.  If none exists, we'll swap
+    // the fallback stream with the preferred stream below.
+    if (codec_type == AVMEDIA_TYPE_VIDEO)
+      preferred_stream_for_seeking_ = std::make_pair(i, start_time);
   }
 
   if (!audio_stream && !video_stream) {
     status_cb.Run(DEMUXER_ERROR_NO_SUPPORTED_STREAMS);
     return;
   }
 
   if (text_enabled_)
     AddTextStreams();
 
   if (format_context->duration != static_cast<int64_t>(AV_NOPTS_VALUE)) {
     // If there is a duration value in the container use that to find the
     // maximum between it and the duration from A/V streams.
     const AVRational av_time_base = {1, AV_TIME_BASE};
     max_duration =
         std::max(max_duration,
                  ConvertFromTimeBase(av_time_base, format_context->duration));
   } else {
     // The duration is unknown, in which case this is likely a live stream.
     max_duration = kInfiniteDuration();
   }
 
-  // Some demuxers, like WAV, do not put timestamps on their frames. We
-  // assume the the start time is 0.
-  if (start_time_ == kNoTimestamp())
+  // If no start time could be determined, default to zero and prefer the video
+  // stream over the audio stream for seeking.  E.g., The WAV demuxer does not
+  // put timestamps on its frames.
+  if (start_time_ == kInfiniteDuration()) {
     start_time_ = base::TimeDelta();
+    preferred_stream_for_seeking_ = std::make_pair(
+        video_stream ? video_stream->index : audio_stream->index, start_time_);
+  } else if (!video_stream) {
+    // If no video stream exists, use the audio or text stream found above.
+    preferred_stream_for_seeking_ = fallback_stream_for_seeking_;
+  }
 
   // MPEG-4 B-frames cause grief for a simple container like AVI. Enable PTS
   // generation so we always get timestamps, see http://crbug.com/169570
   if (strcmp(format_context->iformat->name, "avi") == 0)
     format_context->flags |= AVFMT_FLAG_GENPTS;
 
-  timeline_offset_ = ExtractTimelineOffset(format_context);
+  // For testing purposes, don't overwrite the timeline offset if set already.
+  if (timeline_offset_.is_null())
+    timeline_offset_ = ExtractTimelineOffset(format_context);
+
+  // Since we're shifting the externally visible start time to zero, we need to
+  // adjust the timeline offset to compensate.
+  if (!timeline_offset_.is_null())
+    timeline_offset_ += start_time_;
 
   if (max_duration == kInfiniteDuration() && !timeline_offset_.is_null()) {
     liveness_ = LIVENESS_LIVE;
   } else if (max_duration != kInfiniteDuration()) {
     liveness_ = LIVENESS_RECORDED;
   } else {
     liveness_ = LIVENESS_UNKNOWN;
   }
 
   // Good to go: set the duration and bitrate and notify we're done
@@ skipping 52 matching lines @@
                            video_codec->time_base.num,
                            video_codec->time_base.den));
     media_log_->SetStringProperty(
         "video_format", VideoFrame::FormatToString(video_config.format()));
     media_log_->SetBooleanProperty("video_is_encrypted",
                                    video_config.is_encrypted());
   } else {
     media_log_->SetBooleanProperty("found_video_stream", false);
   }
 
-
   media_log_->SetTimeProperty("max_duration", max_duration);
   media_log_->SetTimeProperty("start_time", start_time_);
   media_log_->SetIntegerProperty("bitrate", bitrate_);
 
   status_cb.Run(PIPELINE_OK);
 }
 
 void FFmpegDemuxer::OnSeekFrameDone(const PipelineStatusCB& cb, int result) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   CHECK(pending_seek_);
@@ skipping 215 matching lines @@
   }
   for (size_t i = 0; i < buffered.size(); ++i)
     host_->AddBufferedTimeRange(buffered.start(i), buffered.end(i));
 }
 
 void FFmpegDemuxer::OnDataSourceError() {
   host_->OnDemuxerError(PIPELINE_ERROR_READ);
 }
 
 }  // namespace media