content/renderer/pepper/video_decoder_shim.h

   1 // Copyright 2014 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_RENDERER_PEPPER_VIDEO_DECODER_SHIM_H_
   6 #define CONTENT_RENDERER_PEPPER_VIDEO_DECODER_SHIM_H_
   7
   8 #include <queue>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/containers/hash_tables.h"
  13 #include "base/memory/linked_ptr.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/memory/weak_ptr.h"
  16 #include "gpu/command_buffer/common/mailbox.h"
  17 #include "media/base/video_decoder_config.h"
  18 #include "media/video/video_decode_accelerator.h"
  19
  20 #include "ppapi/c/pp_codecs.h"
  21
  22 namespace base {
  23 class SingleThreadTaskRunner;
  24 }
  25
  26 namespace cc_blink {
  27 class ContextProviderWebContext;
  28 }
  29
  30 namespace gpu {
  31 namespace gles2 {
  32 class GLES2Interface;
  33 }
  34 }
  35
  36 namespace media {
  37 class DecoderBuffer;
  38 }
  39
  40 namespace content {
  41
  42 class PepperVideoDecoderHost;
  43
  44 // This class is a shim to wrap a media::VideoDecoder so that it can be used
  45 // by PepperVideoDecoderHost in place of a media::VideoDecodeAccelerator.
  46 // This class should be constructed, used, and destructed on the main (render)
  47 // thread.
  48 class VideoDecoderShim : public media::VideoDecodeAccelerator {
  49  public:
  50   VideoDecoderShim(PepperVideoDecoderHost* host, uint32_t texture_pool_size);
  51   ~VideoDecoderShim() override;
  52
  53   // media::VideoDecodeAccelerator implementation.
  54   bool Initialize(media::VideoCodecProfile profile,
  55                   media::VideoDecodeAccelerator::Client* client) override;
  56   void Decode(const media::BitstreamBuffer& bitstream_buffer) override;
  57   void AssignPictureBuffers(
  58       const std::vector<media::PictureBuffer>& buffers) override;
  59   void ReusePictureBuffer(int32 picture_buffer_id) override;
  60   void Flush() override;
  61   void Reset() override;
  62   void Destroy() override;
  63
  64  private:
  65   enum State {
  66     UNINITIALIZED,
  67     DECODING,
  68     FLUSHING,
  69     RESETTING,
  70   };
  71
  72   struct PendingDecode;
  73   struct PendingFrame;
  74   class DecoderImpl;
  75   class YUVConverter;
  76
  77   void OnInitializeFailed();
  78   void OnDecodeComplete(int32_t result, uint32_t decode_id);
  79   void OnOutputComplete(scoped_ptr<PendingFrame> frame);
  80   void SendPictures();
  81   void OnResetComplete();
  82   void NotifyCompletedDecodes();
  83   void DismissTexture(uint32_t texture_id);
  84   void DeleteTexture(uint32_t texture_id);
  85   // Call this whenever we change GL state that the plugin relies on, such as
  86   // creating picture textures.
  87   void FlushCommandBuffer();
  88
  89   scoped_ptr<DecoderImpl> decoder_impl_;
  90   State state_;
  91
  92   PepperVideoDecoderHost* host_;
  93   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner_;
  94   scoped_refptr<cc_blink::ContextProviderWebContext> context_provider_;
  95
  96   // The current decoded frame size.
  97   gfx::Size texture_size_;
  98   // Map that takes the plugin's GL texture id to the renderer's GL texture id.
  99   typedef base::hash_map<uint32_t, uint32_t> TextureIdMap;
 100   TextureIdMap texture_id_map_;
 101   // Available textures (these are plugin ids.)
 102   typedef base::hash_set<uint32_t> TextureIdSet;
 103   TextureIdSet available_textures_;
 104   // Track textures that are no longer needed (these are plugin ids.)
 105   TextureIdSet textures_to_dismiss_;
 106   // Mailboxes for pending texture requests, to write to plugin's textures.
 107   std::vector<gpu::Mailbox> pending_texture_mailboxes_;
 108
 109   // Queue of completed decode ids, for notifying the host.
 110   typedef std::queue<uint32_t> CompletedDecodeQueue;
 111   CompletedDecodeQueue completed_decodes_;
 112
 113   // Queue of decoded frames that await rgb->yuv conversion.
 114   typedef std::queue<linked_ptr<PendingFrame> > PendingFrameQueue;
 115   PendingFrameQueue pending_frames_;
 116
 117   // The optimal number of textures to allocate for decoder_impl_.
 118   uint32_t texture_pool_size_;
 119
 120   uint32_t num_pending_decodes_;
 121
 122   scoped_ptr<YUVConverter> yuv_converter_;
 123
 124   base::WeakPtrFactory<VideoDecoderShim> weak_ptr_factory_;
 125
 126   DISALLOW_COPY_AND_ASSIGN(VideoDecoderShim);
 127 };
 128
 129 }  // namespace content
 130
 131 #endif  // CONTENT_RENDERER_PEPPER_VIDEO_DECODER_SHIM_H_