media: Implement zero-copy video playback for ffmpeg.

media/video/hybrid_video_frame_pool.cc

+// Copyright 2016 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.
+
+#include "media/video/hybrid_video_frame_pool.h"
+
+#include "media/base/video_frame_pool.h"
+
+namespace media {
+
+namespace {
+
+class VideoFrameFutureImpl : public VideoFrameFuture {
+ public:
+  explicit VideoFrameFutureImpl(const scoped_refptr<VideoFrame>& video_frame)
+      : VideoFrameFuture(), video_frame_(video_frame) {}
+
+  ~VideoFrameFutureImpl() override {}
+
+  scoped_refptr<VideoFrame> Release() override {
+    DCHECK(!released_);
+    released_ = true;
+    return video_frame_;
+  }
+
+  uint8_t* data(size_t plane) const override {
+    DCHECK(!released_);
+    return video_frame_->data(plane);
+  }
+
+  int stride(size_t plane) const override {
+    DCHECK(!released_);
+    return video_frame_->stride(plane);
+  }
+
+  const gfx::Size& coded_size() const override {
+    DCHECK(!released_);
+    return video_frame_->coded_size();
+  }
+
+ private:
+  scoped_refptr<VideoFrame> video_frame_;
+  bool released_ = false;
+};
+
+}  // unnamed namespace
+
+class HybridVideoFramePool::PoolImpl {
+ public:
+  PoolImpl(std::unique_ptr<GpuMemoryBufferVideoFramePool> gpu_video_frame_pool)
+      : gpu_video_frame_pool_(std::move(gpu_video_frame_pool)),
+        video_frame_pool_(new VideoFramePool) {}
+  ~PoolImpl() {}
+
+  std::unique_ptr<VideoFrameFuture> CreateFrame(VideoPixelFormat format,
+                                                const gfx::Size& coded_size,
+                                                const gfx::Rect& visible_rect,
+                                                const gfx::Size& natural_size,
+                                                base::TimeDelta timestamp) {
+    if (IsGpuSupported(format)) {
+      return gpu_video_frame_pool_->CreateFrame(
+          format, coded_size, visible_rect, natural_size, timestamp);
+    }
+
+    scoped_refptr<VideoFrame> video_frame = video_frame_pool_->CreateFrame(
+        format, coded_size, visible_rect, natural_size, timestamp);
+    DCHECK(video_frame);
+    return std::unique_ptr<VideoFrameFuture>(
+        new VideoFrameFutureImpl(video_frame));
+  }
+
+ private:
+  bool IsGpuSupported(VideoPixelFormat format) {
+    if (!gpu_video_frame_pool_)
+      return false;
+
+#if defined(OS_MACOSX)
+    // TODO(dshwang): Currently GpuMemoryBufferVideoFrameCopier converts
+    // VideoFrame backed by system memory to hardware VideoFrame backed by
+    // YUV_420_BIPLANAR/UYVY_422. GpuMemoryBufferVideoFrameCopier will convert
+    // it by GPU-GPU copy. crbug.com/356871
+    return false;
+#endif
+
+    switch (format) {
+      // TODO(dshwang): support more YUV format. crbug.com/356871
+      case PIXEL_FORMAT_I420:
+      case PIXEL_FORMAT_YV12:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  // When GpuMemoryBuffer support the given format, it produces new
+  // VideoFrameFuture.
+  std::unique_ptr<GpuMemoryBufferVideoFramePool> gpu_video_frame_pool_;
+
+  // Otherwise, it produces new VideoFrameFuture.
+  std::unique_ptr<VideoFramePool> video_frame_pool_;
+
+  DISALLOW_COPY_AND_ASSIGN(PoolImpl);
+};
+
+HybridVideoFramePool::HybridVideoFramePool(
+    std::unique_ptr<GpuMemoryBufferVideoFramePool> gpu_video_frame_pool)
+    : pool_impl_(new PoolImpl(std::move(gpu_video_frame_pool))) {}
+
+HybridVideoFramePool::~HybridVideoFramePool() {}
+
+std::unique_ptr<VideoFrameFuture> HybridVideoFramePool::CreateFrame(
+    VideoPixelFormat format,
+    const gfx::Size& coded_size,
+    const gfx::Rect& visible_rect,
+    const gfx::Size& natural_size,
+    base::TimeDelta timestamp) {
+  return pool_impl_->CreateFrame(format, coded_size, visible_rect, natural_size,
+                                 timestamp);
+}
+
+}  // namespace media