content/common/gpu/media/android_video_decode_accelerator.h

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_COMMON_GPU_MEDIA_ANDROID_VIDEO_DECODE_ACCELERATOR_H_
   6 #define CONTENT_COMMON_GPU_MEDIA_ANDROID_VIDEO_DECODE_ACCELERATOR_H_
   7
   8 #include <list>
   9 #include <map>
  10 #include <queue>
  11 #include <string>
  12 #include <vector>
  13
  14 #include "base/compiler_specific.h"
  15 #include "base/threading/thread_checker.h"
  16 #include "base/timer/timer.h"
  17 #include "content/common/content_export.h"
  18 #include "gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h"
  19 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
  20 #include "media/base/android/media_codec_bridge.h"
  21 #include "media/video/video_decode_accelerator.h"
  22
  23 namespace gfx {
  24 class SurfaceTexture;
  25 }
  26
  27 namespace content {
  28 // A VideoDecodeAccelerator implementation for Android.
  29 // This class decodes the input encoded stream by using Android's MediaCodec
  30 // class. http://developer.android.com/reference/android/media/MediaCodec.html
  31 class CONTENT_EXPORT AndroidVideoDecodeAccelerator
  32     : public media::VideoDecodeAccelerator {
  33  public:
  34   // Does not take ownership of |client| which must outlive |*this|.
  35   AndroidVideoDecodeAccelerator(
  36       const base::WeakPtr<gpu::gles2::GLES2Decoder> decoder,
  37       const base::Callback<bool(void)>& make_context_current);
  38
  39   // media::VideoDecodeAccelerator implementation.
  40   bool Initialize(media::VideoCodecProfile profile, Client* client) override;
  41   void Decode(const media::BitstreamBuffer& bitstream_buffer) override;
  42   void AssignPictureBuffers(
  43       const std::vector<media::PictureBuffer>& buffers) override;
  44   void ReusePictureBuffer(int32 picture_buffer_id) override;
  45   void Flush() override;
  46   void Reset() override;
  47   void Destroy() override;
  48   bool CanDecodeOnIOThread() override;
  49
  50  private:
  51   enum State {
  52     NO_ERROR,
  53     ERROR,
  54   };
  55
  56   static const base::TimeDelta kDecodePollDelay;
  57
  58   ~AndroidVideoDecodeAccelerator() override;
  59
  60   // Configures |media_codec_| with the given codec parameters from the client.
  61   bool ConfigureMediaCodec();
  62
  63   // Sends the current picture on the surface to the client.
  64   void SendCurrentSurfaceToClient(int32 bitstream_id);
  65
  66   // Does pending IO tasks if any. Once this is called, it polls |media_codec_|
  67   // until it finishes pending tasks. For the polling, |kDecodePollDelay| is
  68   // used.
  69   void DoIOTask();
  70
  71   // Feeds input data to |media_codec_|. This checks
  72   // |pending_bitstream_buffers_| and queues a buffer to |media_codec_|.
  73   void QueueInput();
  74
  75   // Dequeues output from |media_codec_| and feeds the decoded frame to the
  76   // client.
  77   void DequeueOutput();
  78
  79   // Requests picture buffers from the client.
  80   void RequestPictureBuffers();
  81
  82   // Notifies the client about the availability of a picture.
  83   void NotifyPictureReady(const media::Picture& picture);
  84
  85   // Notifies the client that the input buffer identifed by input_buffer_id has
  86   // been processed.
  87   void NotifyEndOfBitstreamBuffer(int input_buffer_id);
  88
  89   // Notifies the client that the decoder was flushed.
  90   void NotifyFlushDone();
  91
  92   // Notifies the client that the decoder was reset.
  93   void NotifyResetDone();
  94
  95   // Notifies about decoding errors.
  96   void NotifyError(media::VideoDecodeAccelerator::Error error);
  97
  98   // Used to DCHECK that we are called on the correct thread.
  99   base::ThreadChecker thread_checker_;
 100
 101   // To expose client callbacks from VideoDecodeAccelerator.
 102   Client* client_;
 103
 104   // Callback to set the correct gl context.
 105   base::Callback<bool(void)> make_context_current_;
 106
 107   // Codec type. Used when we configure media codec.
 108   media::VideoCodec codec_;
 109
 110   // The current state of this class. For now, this is used only for setting
 111   // error state.
 112   State state_;
 113
 114   // This map maintains the picture buffers passed to the client for decoding.
 115   // The key is the picture buffer id.
 116   typedef std::map<int32, media::PictureBuffer> OutputBufferMap;
 117   OutputBufferMap output_picture_buffers_;
 118
 119   // This keeps the free picture buffer ids which can be used for sending
 120   // decoded frames to the client.
 121   std::queue<int32> free_picture_ids_;
 122
 123   // Picture buffer ids which have been dismissed and not yet re-assigned.  Used
 124   // to ignore ReusePictureBuffer calls that were in flight when the
 125   // DismissPictureBuffer call was made.
 126   std::set<int32> dismissed_picture_ids_;
 127
 128   // The low-level decoder which Android SDK provides.
 129   scoped_ptr<media::VideoCodecBridge> media_codec_;
 130
 131   // A container of texture. Used to set a texture to |media_codec_|.
 132   scoped_refptr<gfx::SurfaceTexture> surface_texture_;
 133
 134   // The texture id which is set to |surface_texture_|.
 135   uint32 surface_texture_id_;
 136
 137   // Set to true after requesting picture buffers to the client.
 138   bool picturebuffers_requested_;
 139
 140   // The resolution of the stream.
 141   gfx::Size size_;
 142
 143   // Encoded bitstream buffers to be passed to media codec, queued until an
 144   // input buffer is available, along with the time when they were first
 145   // enqueued.
 146   typedef std::queue<std::pair<media::BitstreamBuffer, base::Time> >
 147       PendingBitstreamBuffers;
 148   PendingBitstreamBuffers pending_bitstream_buffers_;
 149
 150   // Keeps track of bitstream ids notified to the client with
 151   // NotifyEndOfBitstreamBuffer() before getting output from the bitstream.
 152   std::list<int32> bitstreams_notified_in_advance_;
 153
 154   // Owner of the GL context. Used to restore the context state.
 155   base::WeakPtr<gpu::gles2::GLES2Decoder> gl_decoder_;
 156
 157   // Used for copy the texture from |surface_texture_| to picture buffers.
 158   scoped_ptr<gpu::CopyTextureCHROMIUMResourceManager> copier_;
 159
 160   // Repeating timer responsible for draining pending IO to the codec.
 161   base::RepeatingTimer<AndroidVideoDecodeAccelerator> io_timer_;
 162
 163   // WeakPtrFactory for posting tasks back to |this|.
 164   base::WeakPtrFactory<AndroidVideoDecodeAccelerator> weak_this_factory_;
 165
 166   friend class AndroidVideoDecodeAcceleratorTest;
 167 };
 168
 169 }  // namespace content
 170
 171 #endif  // CONTENT_COMMON_GPU_MEDIA_ANDROID_VIDEO_DECODE_ACCELERATOR_H_