Delay actual flush and reset in AVDA

content/common/gpu/media/android_video_decode_accelerator.h

 // 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.
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_ANDROID_VIDEO_DECODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_ANDROID_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <stdint.h>
 
 #include <list>
@@ skipping 68 matching lines @@
 
     // Notify strategy that a picture buffer has been assigned.
     virtual void AssignOnePictureBuffer(
         const media::PictureBuffer& picture_buffer,
         bool have_context) {}
 
     // Notify strategy that a picture buffer has been reused.
     virtual void ReuseOnePictureBuffer(
         const media::PictureBuffer& picture_buffer) {}
 
+    // Release MediaCodec buffers.
+    virtual void ReleaseCodecBuffers(
+        const AndroidVideoDecodeAccelerator::OutputBufferMap& buffers) {}
+
     // Notify strategy that we have a new android MediaCodec instance.  This
     // happens when we're starting up or re-configuring mid-stream.  Any
     // previously provided codec should no longer be referenced.
     // For convenience, a container of PictureBuffers is provided in case
     // per-image cleanup is needed.
     virtual void CodecChanged(media::VideoCodecBridge* codec,
                               const OutputBufferMap& buffer_map) = 0;
 
     // Notify the strategy that a frame is available.  This callback can happen
     // on any thread at any time.
@@ skipping 53 matching lines @@
 
   // TODO(timav): evaluate the need for more states in the AVDA state machine.
   enum State {
     NO_ERROR,
     ERROR,
     // Set when we are asynchronously constructing the codec.  Will transition
     // to NO_ERROR or ERROR depending on success.
     WAITING_FOR_CODEC,
     // Set when we have a codec, but it doesn't yet have a key.
     WAITING_FOR_KEY,
-    WAITING_FOR_EOS,
+  };
+
+  enum DrainType {
+    DRAIN_TYPE_NONE,
+    DRAIN_FOR_FLUSH,
+    DRAIN_FOR_RESET,
+    DRAIN_FOR_DESTROY,
   };
 
   // Configuration info for MediaCodec.
   // This is used to shuttle configuration info between threads without needing
   // to worry about the lifetime of the AVDA instance.  All of these should not
   // be modified while |state_| is WAITING_FOR_CODEC.
   class CodecConfig : public base::RefCountedThreadSafe<CodecConfig> {
    public:
     CodecConfig();
 
@@ skipping 16 matching lines @@
     gfx::Size initial_expected_coded_size_;
 
    protected:
     friend class base::RefCountedThreadSafe<CodecConfig>;
     virtual ~CodecConfig();
 
    private:
     DISALLOW_COPY_AND_ASSIGN(CodecConfig);
   };
 
+  // A part of destruction process that is sometimes postponed after the drain.
+  void ActualDestroy();
+
   // Configures |media_codec_| with the given codec parameters from the client.
   // This configuration will (probably) not be complete before this call
   // returns.  Multiple calls before completion will be ignored.  |state_|
   // must be NO_ERROR or WAITING_FOR_CODEC.  Note that, once you call this,
   // you should be careful to avoid modifying members of |codec_config_| until
   // |state_| is no longer WAITING_FOR_CODEC.
   void ConfigureMediaCodecAsynchronously();
 
   // Like ConfigureMediaCodecAsynchronously, but synchronous.  Returns true if
   // and only if |media_codec_| is non-null.  Since all configuration is done
@@ skipping 66 matching lines @@
   // from breaking.  NotifyError will do so immediately, PostError may wait.
   // |token| has to match |error_sequence_token_|, or else it's assumed to be
   // from a post that's prior to a previous reset, and ignored.
   void NotifyError(media::VideoDecodeAccelerator::Error error, int token);
 
   // Start or stop our work-polling timer based on whether we did any work, and
   // how long it has been since we've done work.  Calling this with true will
   // start the timer.  Calling it with false may stop the timer.
   void ManageTimer(bool did_work);
 
+  // Request the MediaCodec drain by adding end_of_stream() buffer to the
+  // encoded buffers queue. When the drain completes the |drain_completed_cb|
+  // will be called.
+  void RequestDrain(DrainType drain_type, base::Closure drain_completed_cb);
+
+  // Returns true if we are currently draining the codec and doing that as part
+  // of Reset() or Destroy() VP8 workaround. (http://598963). We won't display
+  // any frames and disable normal errors handling.
+  bool IsDrainingForReset() const;
+
   // Resets MediaCodec and buffers/containers used for storing output. These
   // components need to be reset upon EOS to decode a later stream. Input state
   // (e.g. queued BitstreamBuffers) is not reset, as input following an EOS
   // is still valid and should be processed.
-  void ResetCodecState();
+  void ResetCodecState(base::Closure notification_cb);
 
   // Return true if and only if we should use deferred rendering.
   static bool UseDeferredRenderingStrategy(
       const gpu::GpuPreferences& gpu_preferences);
 
   // Used to DCHECK that we are called on the correct thread.
   base::ThreadChecker thread_checker_;
 
   // To expose client callbacks from VideoDecodeAccelerator.
   Client* client_;
@@ skipping 45 matching lines @@
   // Backing strategy that we'll use to connect PictureBuffers to frames.
   std::unique_ptr<BackingStrategy> strategy_;
 
   // Helper class that manages asynchronous OnFrameAvailable callbacks.
   class OnFrameAvailableHandler;
   scoped_refptr<OnFrameAvailableHandler> on_frame_available_handler_;
 
   // Time at which we last did useful work on io_timer_.
   base::TimeTicks most_recent_work_;
 
+  // MediaCodec drain mechanism.
+
+  // A callback to be called on the end of the decoder drain process, i.e.
+  // after EOS comes from decoder's output.
+  base::Closure drain_completed_cb_;
+
+  // We have to distinguish between various drain requests since the next might
+  // come while prior is still being processed.

[watk, 2016/04/18 21:12:18]

It might be worth mentioning that we need to be able to distinguish flush drains
from reset/destroy drains because we release the codec buffers immediately for
the latter case.

[Tima Vaisburd, 2016/04/20 01:54:19]

I referred to IsDrainingForresetOrDestroy() where I updated the description.

+  DrainType drain_type_;
+
   // CDM related stuff.
 
   // Holds a ref-count to the CDM to avoid using the CDM after it's destroyed.
   scoped_refptr<media::MediaKeys> cdm_for_reference_holding_only_;
 
   media::MediaDrmBridgeCdmContext* media_drm_bridge_cdm_context_;
 
   // MediaDrmBridge requires registration/unregistration of the player, this
   // registration id is used for this.
   int cdm_registration_id_;
@@ skipping 19 matching lines @@
 
   // WeakPtrFactory for posting tasks back to |this|.
   base::WeakPtrFactory<AndroidVideoDecodeAccelerator> weak_this_factory_;
 
   friend class AndroidVideoDecodeAcceleratorTest;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_ANDROID_VIDEO_DECODE_ACCELERATOR_H_