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