Revert of 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) {
-  if (stream->start_time == static_cast<int64_t>(AV_NOPTS_VALUE))
-    return kNoTimestamp();
-
-  // First try to use the |start_time| value directly.
-  const base::TimeDelta start_time =
-      ConvertFromTimeBase(stream->time_base, stream->start_time);
-
-  // Then compare against the first timestamp to see if adjustment is required.
-  if (stream->first_dts == static_cast<int64_t>(AV_NOPTS_VALUE))
-    return start_time;
-
-  const base::TimeDelta first_dts =
-      ConvertFromTimeBase(stream->time_base, stream->first_dts);
-
-  return first_dts < start_time ? first_dts : start_time;
-}
-
 //
 // FFmpegDemuxerStream
 //
 FFmpegDemuxerStream::FFmpegDemuxerStream(
     FFmpegDemuxer* demuxer,
-    AVStream* stream,
-    bool discard_negative_timestamps)
+    AVStream* stream)
     : demuxer_(demuxer),
       task_runner_(base::MessageLoopProxy::current()),
       stream_(stream),
       type_(UNKNOWN),
       end_of_stream_(false),
       last_packet_timestamp_(kNoTimestamp()),
-      bitstream_converter_enabled_(false),
-      discard_negative_timestamps_(discard_negative_timestamps) {
+      bitstream_converter_enabled_(false) {
   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_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.
-        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());
+  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();
   }
-
-  // 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 128 matching lines @@
       pending_read_(false),
       pending_seek_(false),
       data_source_(data_source),
       media_log_(media_log),
       bitrate_(0),
       start_time_(kNoTimestamp()),
       liveness_(LIVENESS_UNKNOWN),
       text_enabled_(false),
       duration_known_(false),
       need_key_cb_(need_key_cb),
-      stream_index_for_seeking_(0),
       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.
 
-  const AVStream* seeking_stream =
-      glue_->format_context()->streams[stream_index_for_seeking_];
+  // Always seek to a timestamp less than or equal to the desired timestamp.
+  int flags = AVSEEK_FLAG_BACKWARD;
 
+  // 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.
   pending_seek_ = true;
   base::PostTaskAndReplyWithResult(
       blocking_thread_.message_loop_proxy().get(),
       FROM_HERE,
-      base::Bind(
-          &av_seek_frame,
-          glue_->format_context(),
-          stream_index_for_seeking_,
-          ConvertToTimeBase(seeking_stream->time_base, time + start_time()),
-          // Always seek to a timestamp <= to the desired timestamp.
-          AVSEEK_FLAG_BACKWARD),
+      base::Bind(&av_seek_frame,
+                 glue_->format_context(),
+                 -1,
+                 time.InMicroseconds(),
+                 flags),
       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 95 matching lines @@
   // partial playback. At least one audio or video stream must be playable.
   AVFormatContext* format_context = glue_->format_context();
   streams_.resize(format_context->nb_streams);
 
   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];
-    const AVCodecContext* codec_context = stream->codec;
-    const AVMediaType codec_type = codec_context->codec_type;
-    bool discard_negative_timestamps = false;
+    AVCodecContext* codec_context = stream->codec;
+    AVMediaType codec_type = codec_context->codec_type;
 
     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, discard_negative_timestamps);
+    streams_[i] = new FFmpegDemuxerStream(this, stream);
     max_duration = std::max(max_duration, streams_[i]->duration());
 
-    const base::TimeDelta start_time = ExtractStartTime(stream);
-    if (start_time == kNoTimestamp())
-      continue;
-
-    // Find the lowest stream start time.  Prefer the video stream for seeking
-    // in the event of matching stream start times.
-    if (start_time < start_time_ ||
-        (codec_type == AVMEDIA_TYPE_VIDEO && start_time <= start_time_)) {
-      stream_index_for_seeking_ = i;
-      start_time_ = start_time;
+    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;
     }
   }
 
   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();
   }
 
-  // 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()) {
+  // Some demuxers, like WAV, do not put timestamps on their frames. We
+  // assume the the start time is 0.
+  if (start_time_ == kNoTimestamp())
     start_time_ = base::TimeDelta();
-    stream_index_for_seeking_ =
-        video_stream ? video_stream->index : audio_stream->index;
-  }
 
   // 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);
 
-  // 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
   // initializing.
@@ skipping 51 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