Seek for video track changes on FFmpegDemuxer.

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 <memory>
 #include <set>
 #include <utility>
@@ skipping 496 matching lines @@
 
   // Only allow negative timestamps past if we know they'll be fixed up by the
   // code paths below; otherwise they should be treated as a parse error.
   if (!fixup_negative_timestamps_ && buffer->timestamp() < base::TimeDelta()) {
     MEDIA_LOG(DEBUG, media_log_)
         << "FFmpegDemuxer: unfixable negative timestamp";
     demuxer_->NotifyDemuxerError(DEMUXER_ERROR_COULD_NOT_PARSE);
     return;
   }
 
+  if (is_audio && last_packet_timestamp_ != kNoTimestamp &&
+      buffer->timestamp() < last_packet_timestamp_) {
+    LOG(ERROR) << "Dropping: " << buffer->timestamp();
+    return;
+  }
+
   // If enabled, and no codec delay is present, mark audio packets with negative
   // timestamps for post-decode discard. If codec delay is present, discard is
   // handled by the decoder using that value.
   if (fixup_negative_timestamps_ && is_audio &&
       stream_timestamp < base::TimeDelta() &&
       buffer->duration() != kNoTimestamp &&
       !audio_decoder_config().codec_delay()) {
     DCHECK_EQ(buffer->discard_padding().first, base::TimeDelta());
 
     if (stream_timestamp + buffer->duration() < base::TimeDelta()) {
@@ skipping 1163 matching lines @@
   // First disable all streams that need to be disabled and then enable the
   // stream that needs to be enabled (if any).
   for (const auto& stream : streams_) {
     if (stream && stream->type() == DemuxerStream::VIDEO &&
         stream.get() != selected_stream) {
       DVLOG(1) << __func__ << ": disabling stream " << stream.get();
       stream->set_enabled(false, curr_time);
     }
   }
   if (selected_stream) {
-    DVLOG(1) << __func__ << ": enabling stream " << selected_stream;
+    LOG(ERROR) << __func__ << ": enabling stream " << selected_stream;
     selected_stream->set_enabled(true, curr_time);
+    selected_stream->FlushBuffers();
+
+    base::TimeDelta seek_time =
+        start_time_ < base::TimeDelta()
+            ? curr_time + start_time_
+            : curr_time < start_time_ ? start_time_ : curr_time;
+    blocking_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(base::IgnoreResult(&av_seek_frame), glue_->format_context(),
+                   selected_stream->av_stream()->index,
+                   ConvertToTimeBase(selected_stream->av_stream()->time_base,
+                                     seek_time),
+                   // Always seek to a timestamp <= to the desired timestamp.
+                   AVSEEK_FLAG_BACKWARD));
   }
 }
 
 void FFmpegDemuxer::ReadFrameIfNeeded() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // Make sure we have work to do before reading.
   if (stopped_ || !StreamsHaveAvailableCapacity() || pending_read_ ||
       !pending_seek_cb_.is_null()) {
     return;
@@ skipping 140 matching lines @@
 
 void FFmpegDemuxer::SetLiveness(DemuxerStream::Liveness liveness) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   for (const auto& stream : streams_) {
     if (stream)
       stream->SetLiveness(liveness);
   }
 }
 
 }  // namespace media