cc/resources/video_resource_updater.h

   1 // Copyright 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 CC_RESOURCES_VIDEO_RESOURCE_UPDATER_H_
   6 #define CC_RESOURCES_VIDEO_RESOURCE_UPDATER_H_
   7
   8 #include <list>
   9 #include <vector>
  10
  11 #include "base/basictypes.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/weak_ptr.h"
  14 #include "base/time/time.h"
  15 #include "cc/base/cc_export.h"
  16 #include "cc/resources/release_callback_impl.h"
  17 #include "cc/resources/resource_format.h"
  18 #include "cc/resources/texture_mailbox.h"
  19 #include "ui/gfx/geometry/size.h"
  20
  21 namespace media {
  22 class SkCanvasVideoRenderer;
  23 class VideoFrame;
  24 }
  25
  26 namespace cc {
  27 class ContextProvider;
  28 class ResourceProvider;
  29
  30 class CC_EXPORT VideoFrameExternalResources {
  31  public:
  32   // Specifies what type of data is contained in the mailboxes, as well as how
  33   // many mailboxes will be present.
  34   enum ResourceType {
  35     NONE,
  36     YUV_RESOURCE,
  37     RGB_RESOURCE,
  38     RGBA_RESOURCE,
  39     STREAM_TEXTURE_RESOURCE,
  40     IO_SURFACE,
  41
  42 #if defined(VIDEO_HOLE)
  43     // TODO(danakj): Implement this with a solid color layer instead of a video
  44     // frame and video layer.
  45     HOLE,
  46 #endif  // defined(VIDEO_HOLE)
  47
  48     // TODO(danakj): Remove this and abstract TextureMailbox into
  49     // "ExternalResource" that can hold a hardware or software backing.
  50     SOFTWARE_RESOURCE
  51   };
  52
  53   ResourceType type;
  54   std::vector<TextureMailbox> mailboxes;
  55   std::vector<ReleaseCallbackImpl> release_callbacks;
  56   bool read_lock_fences_enabled;
  57
  58   // TODO(danakj): Remove these too.
  59   std::vector<unsigned> software_resources;
  60   ReleaseCallbackImpl software_release_callback;
  61
  62   VideoFrameExternalResources();
  63   ~VideoFrameExternalResources();
  64 };
  65
  66 // VideoResourceUpdater is used by the video system to produce frame content as
  67 // resources consumable by the compositor.
  68 class CC_EXPORT VideoResourceUpdater
  69     : public base::SupportsWeakPtr<VideoResourceUpdater> {
  70  public:
  71   VideoResourceUpdater(ContextProvider* context_provider,
  72                        ResourceProvider* resource_provider);
  73   ~VideoResourceUpdater();
  74
  75   VideoFrameExternalResources CreateExternalResourcesFromVideoFrame(
  76       const scoped_refptr<media::VideoFrame>& video_frame);
  77
  78  private:
  79   struct PlaneResource {
  80     unsigned resource_id;
  81     gfx::Size resource_size;
  82     ResourceFormat resource_format;
  83     gpu::Mailbox mailbox;
  84     // The balance between the number of times this resource has been returned
  85     // from CreateForSoftwarePlanes vs released in RecycleResource.
  86     int ref_count;
  87     // These last three members will be used for identifying the data stored in
  88     // this resource, and uniquely identifies a media::VideoFrame plane. The
  89     // frame pointer will only be used for pointer comparison, i.e. the
  90     // underlying data will not be accessed.
  91     const void* frame_ptr;
  92     size_t plane_index;
  93     base::TimeDelta timestamp;
  94
  95     PlaneResource(unsigned resource_id,
  96                   const gfx::Size& resource_size,
  97                   ResourceFormat resource_format,
  98                   gpu::Mailbox mailbox);
  99   };
 100
 101   static bool PlaneResourceMatchesUniqueID(const PlaneResource& plane_resource,
 102                                            const media::VideoFrame* video_frame,
 103                                            size_t plane_index);
 104
 105   static void SetPlaneResourceUniqueId(const media::VideoFrame* video_frame,
 106                                        size_t plane_index,
 107                                        PlaneResource* plane_resource);
 108
 109   // This needs to be a container where iterators can be erased without
 110   // invalidating other iterators.
 111   typedef std::list<PlaneResource> ResourceList;
 112   ResourceList::iterator AllocateResource(const gfx::Size& plane_size,
 113                                           ResourceFormat format,
 114                                           bool has_mailbox);
 115   void DeleteResource(ResourceList::iterator resource_it);
 116   bool VerifyFrame(const scoped_refptr<media::VideoFrame>& video_frame);
 117   VideoFrameExternalResources CreateForHardwarePlanes(
 118       const scoped_refptr<media::VideoFrame>& video_frame);
 119   VideoFrameExternalResources CreateForSoftwarePlanes(
 120       const scoped_refptr<media::VideoFrame>& video_frame);
 121
 122   static void RecycleResource(base::WeakPtr<VideoResourceUpdater> updater,
 123                               unsigned resource_id,
 124                               uint32 sync_point,
 125                               bool lost_resource,
 126                               BlockingTaskRunner* main_thread_task_runner);
 127   static void ReturnTexture(base::WeakPtr<VideoResourceUpdater> updater,
 128                             const scoped_refptr<media::VideoFrame>& video_frame,
 129                             uint32 sync_point,
 130                             bool lost_resource,
 131                             BlockingTaskRunner* main_thread_task_runner);
 132
 133   ContextProvider* context_provider_;
 134   ResourceProvider* resource_provider_;
 135   scoped_ptr<media::SkCanvasVideoRenderer> video_renderer_;
 136   std::vector<uint8_t> upload_pixels_;
 137
 138   // Recycle resources so that we can reduce the number of allocations and
 139   // data transfers.
 140   ResourceList all_resources_;
 141
 142   DISALLOW_COPY_AND_ASSIGN(VideoResourceUpdater);
 143 };
 144
 145 }  // namespace cc
 146
 147 #endif  // CC_RESOURCES_VIDEO_RESOURCE_UPDATER_H_