Fix MP4 mid-stream resolution changes for MSE on android spitzer.

content/common/gpu/media/android_video_decode_accelerator.cc

 // Copyright (c) 2013 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 "content/common/gpu/media/android_video_decode_accelerator.h"
 
 #include <stddef.h>
 
+#include "base/android/build_info.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/media/android_copying_backing_strategy.h"
 #include "content/common/gpu/media/android_deferred_rendering_backing_strategy.h"
 #include "content/common/gpu/media/avda_return_on_failure.h"
@@ skipping 327 matching lines @@
   }
 
   bool eos = false;
   base::TimeDelta presentation_timestamp;
   int32_t buf_index = 0;
   bool should_try_again = false;
   do {
     size_t offset = 0;
     size_t size = 0;
 
-    TRACE_EVENT_BEGIN0("media", "AVDA::DequeueOutputBuffer");
+    TRACE_EVENT_BEGIN0("media", "AVDA::DequeueOutput");
     media::MediaCodecStatus status = media_codec_->DequeueOutputBuffer(
         NoWaitTimeOut(), &buf_index, &offset, &size, &presentation_timestamp,
         &eos, NULL);
-    TRACE_EVENT_END2("media", "AVDA::DequeueOutputBuffer", "status", status,
+    TRACE_EVENT_END2("media", "AVDA::DequeueOutput", "status", status,
                      "presentation_timestamp (ms)",
                      presentation_timestamp.InMilliseconds());
 
-    DVLOG(3) << "AVDA::DequeueOutputBuffer: pts:" << presentation_timestamp
+    DVLOG(3) << "AVDA::DequeueOutput: pts:" << presentation_timestamp
              << " buf_index:" << buf_index << " offset:" << offset
              << " size:" << size << " eos:" << eos;
 
     switch (status) {
       case media::MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
       case media::MEDIA_CODEC_ERROR:
         return false;
 
       case media::MEDIA_CODEC_OUTPUT_FORMAT_CHANGED: {
         int32_t width, height;
         media_codec_->GetOutputFormat(&width, &height);
 
         if (!picturebuffers_requested_) {
           picturebuffers_requested_ = true;
           size_ = gfx::Size(width, height);
           base::MessageLoop::current()->PostTask(
               FROM_HERE,
               base::Bind(&AndroidVideoDecodeAccelerator::RequestPictureBuffers,
                          weak_this_factory_.GetWeakPtr()));
         } else {
           // Dynamic resolution change support is not specified by the Android
           // platform at and before JB-MR1, so it's not possible to smoothly
           // continue playback at this point.  Instead, error out immediately,
-          // expecting clients to Reset() as appropriate to avoid this.
-          // b/7093648
+          // expecting clients to Flush() or Reset() as appropriate to avoid
+          // this. b/7093648
           RETURN_ON_FAILURE(this, size_ == gfx::Size(width, height),
                             "Dynamic resolution change is not supported.",
                             PLATFORM_FAILURE, false);
         }
         return false;
       }
 
       case media::MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED:
         break;
 
@@ skipping 13 matching lines @@
   // corresponding output frame.
 
   // However MediaCodecBridge uses timestamp correction and provides
   // non-decreasing timestamp sequence, which might result in timestamp
   // duplicates. Discard the frame if we cannot get corresponding buffer id.
 
   // Get the bitstream buffer id from the timestamp.
   auto it = eos ? bitstream_buffers_in_decoder_.end()
                 : bitstream_buffers_in_decoder_.find(presentation_timestamp);
 
-  if (it == bitstream_buffers_in_decoder_.end()) {
-    media_codec_->ReleaseOutputBuffer(buf_index, false);
+  if (eos) {
+    DVLOG(3) << "AVDA::DequeueOutput: Resetting output state after EOS";
+    ResetCodecState();
+
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&AndroidVideoDecodeAccelerator::NotifyFlushDone,
                    weak_this_factory_.GetWeakPtr()));
-  } else {
+  } else if (it != bitstream_buffers_in_decoder_.end()) {
     const int32_t bitstream_buffer_id = it->second;
     bitstream_buffers_in_decoder_.erase(bitstream_buffers_in_decoder_.begin(),
                                         ++it);
     SendCurrentSurfaceToClient(buf_index, bitstream_buffer_id);
 
     // If we decoded a frame this time, then try for another.
     should_try_again = true;
 
     // Removes ids former or equal than the id from decoder. Note that
     // |bitstreams_notified_in_advance_| does not mean bitstream ids in decoder
     // because of frame reordering issue. We just maintain this roughly and use
     // for the throttling purpose.
     for (auto bitstream_it = bitstreams_notified_in_advance_.begin();
          bitstream_it != bitstreams_notified_in_advance_.end();
          ++bitstream_it) {
       if (*bitstream_it == bitstream_buffer_id) {
         bitstreams_notified_in_advance_.erase(
             bitstreams_notified_in_advance_.begin(), ++bitstream_it);
         break;
       }
     }
+  } else {
+    DVLOG(3) << "AVDA::DequeueOutput: Releasing buffer with unexpected PTS: "
+             << presentation_timestamp;
+    media_codec_->ReleaseOutputBuffer(buf_index, false);
+    should_try_again = true;
   }
 
   return should_try_again;
 }
 
 void AndroidVideoDecodeAccelerator::SendCurrentSurfaceToClient(
     int32_t codec_buffer_index,
     int32_t bitstream_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(bitstream_id, -1);
@@ skipping 122 matching lines @@
   media_codec_.reset(media::VideoCodecBridge::CreateDecoder(
       codec_, false, gfx::Size(320, 240), surface.j_surface().obj(), NULL));
   strategy_->CodecChanged(media_codec_.get(), output_picture_buffers_);
   if (!media_codec_)
     return false;
 
   ManageTimer(true);
   return true;
 }
 
+void AndroidVideoDecodeAccelerator::ResetCodecState() {
+  // TODO(chcunningham): This will likely dismiss a handful of decoded frames
+  // that have not yet been drawn and returned to us for re-use. Consider
+  // a more complicated design that would wait for these to be drawn before
+  // dismissing.
+  for (const auto& it : output_picture_buffers_) {
+    strategy_->DismissOnePictureBuffer(it.second);
+    client_->DismissPictureBuffer(it.first);
+    dismissed_picture_ids_.insert(it.first);
+  }
+  output_picture_buffers_.clear();
+  std::queue<int32_t> empty;
+  std::swap(free_picture_ids_, empty);
+  CHECK(free_picture_ids_.empty());
+  picturebuffers_requested_ = false;
+  bitstream_buffers_in_decoder_.clear();
+
+  // When codec is not in error state we can quickly reset (internally calls
+  // flush()) for JB-MR2 and beyond. Prior to JB-MR2, flush() had several bugs
+  // (b/8125974, b/8347958) so we must stop() and reconfigure MediaCodec. The
+  // full reconfigure is much slower and may cause visible freezing if done
+  // mid-stream.
+  if (state_ == NO_ERROR &&
+      base::android::BuildInfo::GetInstance()->sdk_int() >= 18) {
+    DVLOG(3) << __FUNCTION__ << " Doing fast MediaCodec reset (flush).";
+    media_codec_->Reset();
+  } else {
+    DVLOG(3) << __FUNCTION__
+             << " Doing slow MediaCodec reset (stop/re-configure).";
+    io_timer_.Stop();
+    media_codec_->Stop();
+    ConfigureMediaCodec();
+    state_ = NO_ERROR;
+  }
+}
+
 void AndroidVideoDecodeAccelerator::Reset() {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("media", "AVDA::Reset");
 
   while (!pending_bitstream_buffers_.empty()) {
     int32_t bitstream_buffer_id = pending_bitstream_buffers_.front().first.id();
     pending_bitstream_buffers_.pop();
 
     if (bitstream_buffer_id != -1) {
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&AndroidVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer,
                      weak_this_factory_.GetWeakPtr(), bitstream_buffer_id));
     }
   }
   TRACE_COUNTER1("media", "AVDA::PendingBitstreamBufferCount", 0);
   bitstreams_notified_in_advance_.clear();
 
-  for (OutputBufferMap::iterator it = output_picture_buffers_.begin();
-       it != output_picture_buffers_.end();
-       ++it) {
-    strategy_->DismissOnePictureBuffer(it->second);
-    client_->DismissPictureBuffer(it->first);
-    dismissed_picture_ids_.insert(it->first);
-  }
-  output_picture_buffers_.clear();
-  std::queue<int32_t> empty;
-  std::swap(free_picture_ids_, empty);
-  CHECK(free_picture_ids_.empty());
-  picturebuffers_requested_ = false;
-  bitstream_buffers_in_decoder_.clear();
-
-  // On some devices, and up to at least JB-MR1,
-  // - flush() can fail after EOS (b/8125974); and
-  // - mid-stream resolution change is unsupported (b/7093648).
-  // To cope with these facts, we always stop & restart the codec on Reset().
-  io_timer_.Stop();
-  media_codec_->Stop();
-  ConfigureMediaCodec();
-  state_ = NO_ERROR;
+  ResetCodecState();
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&AndroidVideoDecodeAccelerator::NotifyResetDone,
                  weak_this_factory_.GetWeakPtr()));
 }
 
 void AndroidVideoDecodeAccelerator::Destroy() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 136 matching lines @@
 
   if (UseDeferredRenderingStrategy()) {
     capabilities.flags = media::VideoDecodeAccelerator::Capabilities::
         NEEDS_ALL_PICTURE_BUFFERS_TO_DECODE;
   }
 
   return capabilities;
 }
 
 }  // namespace content