Deal with AllocateGpuMemoryBuffer returning null.

media/video/gpu_memory_buffer_video_frame_pool.cc

 // Copyright 2015 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/gpu_memory_buffer_video_frame_pool.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
 #include <algorithm>
@@ skipping 86 matching lines @@
   // This has to be run on |media_task_runner_| where |frame_ready_cb| will also
   // be run.
   void BindAndCreateMailboxesHardwareFrameResources(
       const scoped_refptr<VideoFrame>& video_frame,
       FrameResources* frame_resources,
       const FrameReadyCB& frame_ready_cb);
 
   // Return true if |resources| can be used to represent a frame for
   // specific |format| and |size|.
   static bool AreFrameResourcesCompatible(const FrameResources* resources,
-                                          const gfx::Size& size) {
-    return size == resources->size;
-  }
+                                          const gfx::Size& size);
 
   // Get the resources needed for a frame out of the pool, or create them if
   // necessary.
   // This also drops the LRU resources that can't be reuse for this frame.
   FrameResources* GetOrCreateFrameResources(const gfx::Size& size,
                                             VideoPixelFormat format);
 
   // Callback called when a VideoFrame generated with GetFrameResources is no
   // longer referenced.
   // This could be called by any thread.
@@ skipping 99 matching lines @@
 void CopyRowsToI420Buffer(int first_row,
                           int rows,
                           int bytes_per_row,
                           const uint8* source,
                           int source_stride,
                           uint8* output,
                           int dest_stride,
                           const base::Closure& done) {
   TRACE_EVENT2("media", "CopyRowsToI420Buffer", "bytes_per_row", bytes_per_row,
                "rows", rows);
-  DCHECK_NE(dest_stride, 0);
-  DCHECK_LE(bytes_per_row, std::abs(dest_stride));
-  DCHECK_LE(bytes_per_row, source_stride);
-  for (int row = first_row; row < first_row + rows; ++row) {
-    memcpy(output + dest_stride * row, source + source_stride * row,
-           bytes_per_row);
+  if (output) {
+    DCHECK_NE(dest_stride, 0);
+    DCHECK_LE(bytes_per_row, std::abs(dest_stride));
+    DCHECK_LE(bytes_per_row, source_stride);
+    for (int row = first_row; row < first_row + rows; ++row) {
+      memcpy(output + dest_stride * row, source + source_stride * row,
+             bytes_per_row);
+    }
   }
   done.Run();
 }
 
 void CopyRowsToNV12Buffer(int first_row,
                           int rows,
                           int bytes_per_row,
                           const scoped_refptr<VideoFrame>& source_frame,
                           uint8* dest_y,
                           int dest_stride_y,
                           uint8* dest_uv,
                           int dest_stride_uv,
                           const base::Closure& done) {
   TRACE_EVENT2("media", "CopyRowsToNV12Buffer", "bytes_per_row", bytes_per_row,
                "rows", rows);
-  DCHECK_NE(dest_stride_y, 0);
-  DCHECK_NE(dest_stride_uv, 0);
-  DCHECK_LE(bytes_per_row, std::abs(dest_stride_y));
-  DCHECK_LE(bytes_per_row, std::abs(dest_stride_uv));
-  DCHECK_EQ(0, first_row % 2);
-  libyuv::I420ToNV12(
-      source_frame->data(VideoFrame::kYPlane) +
-          first_row * source_frame->stride(VideoFrame::kYPlane),
-      source_frame->stride(VideoFrame::kYPlane),
-      source_frame->data(VideoFrame::kUPlane) +
-          first_row / 2 * source_frame->stride(VideoFrame::kUPlane),
-      source_frame->stride(VideoFrame::kUPlane),
-      source_frame->data(VideoFrame::kVPlane) +
-          first_row / 2 * source_frame->stride(VideoFrame::kVPlane),
-      source_frame->stride(VideoFrame::kVPlane),
-      dest_y + first_row * dest_stride_y, dest_stride_y,
-      dest_uv + first_row / 2 * dest_stride_uv, dest_stride_uv,
-      bytes_per_row, rows);
+  if (dest_y && dest_uv) {
+    DCHECK_NE(dest_stride_y, 0);
+    DCHECK_NE(dest_stride_uv, 0);
+    DCHECK_LE(bytes_per_row, std::abs(dest_stride_y));
+    DCHECK_LE(bytes_per_row, std::abs(dest_stride_uv));
+    DCHECK_EQ(0, first_row % 2);
+
+    libyuv::I420ToNV12(
+        source_frame->data(VideoFrame::kYPlane) +
+            first_row * source_frame->stride(VideoFrame::kYPlane),
+        source_frame->stride(VideoFrame::kYPlane),
+        source_frame->data(VideoFrame::kUPlane) +
+            first_row / 2 * source_frame->stride(VideoFrame::kUPlane),
+        source_frame->stride(VideoFrame::kUPlane),
+        source_frame->data(VideoFrame::kVPlane) +
+            first_row / 2 * source_frame->stride(VideoFrame::kVPlane),
+        source_frame->stride(VideoFrame::kVPlane),
+        dest_y + first_row * dest_stride_y, dest_stride_y,
+        dest_uv + first_row / 2 * dest_stride_uv, dest_stride_uv, bytes_per_row,
+        rows);
+  }
   done.Run();
 }
 
 void CopyRowsToUYVYBuffer(int first_row,
                           int rows,
                           int width,
                           const scoped_refptr<VideoFrame>& source_frame,
                           uint8* output,
                           int dest_stride,
                           const base::Closure& done) {
   TRACE_EVENT2("media", "CopyRowsToUYVYBuffer", "bytes_per_row", width * 2,
                "rows", rows);
-  DCHECK_NE(dest_stride, 0);
-  DCHECK_LE(width, std::abs(dest_stride / 2));
-  DCHECK_EQ(0, first_row % 2);
-  libyuv::I420ToUYVY(
-      source_frame->data(VideoFrame::kYPlane) +
-          first_row * source_frame->stride(VideoFrame::kYPlane),
-      source_frame->stride(VideoFrame::kYPlane),
-      source_frame->data(VideoFrame::kUPlane) +
-          first_row / 2 * source_frame->stride(VideoFrame::kUPlane),
-      source_frame->stride(VideoFrame::kUPlane),
-      source_frame->data(VideoFrame::kVPlane) +
-          first_row / 2 * source_frame->stride(VideoFrame::kVPlane),
-      source_frame->stride(VideoFrame::kVPlane),
-      output + first_row * dest_stride, dest_stride, width, rows);
+  if (output) {
+    DCHECK_NE(dest_stride, 0);
+    DCHECK_LE(width, std::abs(dest_stride / 2));
+    DCHECK_EQ(0, first_row % 2);
+    libyuv::I420ToUYVY(
+        source_frame->data(VideoFrame::kYPlane) +
+            first_row * source_frame->stride(VideoFrame::kYPlane),
+        source_frame->stride(VideoFrame::kYPlane),
+        source_frame->data(VideoFrame::kUPlane) +
+            first_row / 2 * source_frame->stride(VideoFrame::kUPlane),
+        source_frame->stride(VideoFrame::kUPlane),
+        source_frame->data(VideoFrame::kVPlane) +
+            first_row / 2 * source_frame->stride(VideoFrame::kVPlane),
+        source_frame->stride(VideoFrame::kVPlane),
+        output + first_row * dest_stride, dest_stride, width, rows);
+  }
   done.Run();
 }
 
 }  // unnamed namespace
 
 // Creates a VideoFrame backed by native textures starting from a software
 // VideoFrame.
 // The data contained in |video_frame| is copied into the VideoFrame passed to
 // |frame_ready_cb|.
 // This has to be called on the thread where |media_task_runner_| is current.
@@ skipping 90 matching lines @@
   }
   base::Closure copies_done =
       base::Bind(&PoolImpl::OnCopiesDone, this, video_frame, frame_resources,
                  frame_ready_cb);
   base::Closure barrier = base::BarrierClosure(copies, copies_done);
 
   // Post all the async tasks.
   for (size_t i = 0; i < num_planes; i += planes_per_copy) {
     gfx::GpuMemoryBuffer* buffer =
         frame_resources->plane_resources[i].gpu_memory_buffer.get();
-    DCHECK(buffer);
-    DCHECK_EQ(planes_per_copy,
-              gfx::NumberOfPlanesForBufferFormat(buffer->GetFormat()));
-    uint8* dest_buffers[VideoFrame::kMaxPlanes];
-    int dest_strides[VideoFrame::kMaxPlanes];
-    bool rv = buffer->Map(reinterpret_cast<void**>(dest_buffers));
-    DCHECK(rv);
-    buffer->GetStride(dest_strides);
+    uint8* dest_buffers[VideoFrame::kMaxPlanes] = {0};
+    int dest_strides[VideoFrame::kMaxPlanes] = {0};
+    if (buffer) {
+      DCHECK_EQ(planes_per_copy,
+                gfx::NumberOfPlanesForBufferFormat(buffer->GetFormat()));
+      bool rv = buffer->Map(reinterpret_cast<void**>(dest_buffers));
+      DCHECK(rv);
+      buffer->GetStride(dest_strides);
+    }
 
     const int rows = VideoFrame::Rows(i, output_format_, size.height());
     const int rows_per_copy = RowsPerCopy(i, output_format_, size.width());
 
     for (int row = 0; row < rows; row += rows_per_copy) {
       const int rows_to_copy = std::min(rows_per_copy, rows - row);
       switch (output_format_) {
         case PIXEL_FORMAT_I420: {
           const int bytes_per_row =
               VideoFrame::RowBytes(i, output_format_, size.width());
@@ skipping 38 matching lines @@
     return;
   }
 
   const size_t num_planes = VideoFrame::NumPlanes(output_format_);
   const size_t planes_per_copy = PlanesPerCopy(output_format_);
   const gfx::Size size = video_frame->visible_rect().size();
   gpu::MailboxHolder mailbox_holders[VideoFrame::kMaxPlanes];
   // Set up the planes creating the mailboxes needed to refer to the textures.
   for (size_t i = 0; i < num_planes; i += planes_per_copy) {
     PlaneResource& plane_resource = frame_resources->plane_resources[i];
-    DCHECK(plane_resource.gpu_memory_buffer);
     // Bind the texture and create or rebind the image.
     gles2->BindTexture(texture_target_, plane_resource.texture_id);
 
-    if (!plane_resource.image_id) {
+    if (plane_resource.gpu_memory_buffer && !plane_resource.image_id) {
       const size_t width = VideoFrame::Columns(i, output_format_, size.width());
       const size_t height = VideoFrame::Rows(i, output_format_, size.height());
       plane_resource.image_id = gles2->CreateImageCHROMIUM(
           plane_resource.gpu_memory_buffer->AsClientBuffer(), width, height,
           ImageInternalFormat(output_format_, i));
-    } else {
+    } else if (plane_resource.image_id) {
       gles2->ReleaseTexImage2DCHROMIUM(texture_target_,
                                        plane_resource.image_id);
     }
-    gles2->BindTexImage2DCHROMIUM(texture_target_, plane_resource.image_id);
+    if (plane_resource.image_id)
+      gles2->BindTexImage2DCHROMIUM(texture_target_, plane_resource.image_id);
     mailbox_holders[i] =
         gpu::MailboxHolder(plane_resource.mailbox, texture_target_, 0);
   }
 
   // Insert a sync_point, this is needed to make sure that the textures the
   // mailboxes refer to will be used only after all the previous commands posted
   // in the command buffer have been processed.
   unsigned sync_point = gles2->InsertSyncPointCHROMIUM();
   for (size_t i = 0; i < num_planes; i += planes_per_copy)
     mailbox_holders[i].sync_point = sync_point;
@@ skipping 20 matching lines @@
           size, video_frame->visible_rect(), video_frame->natural_size(),
           video_frame->timestamp());
       frame->metadata()->SetBoolean(VideoFrameMetadata::ALLOW_OVERLAY, true);
       break;
     default:
       NOTREACHED();
   }
   frame_ready_cb.Run(frame);
 }
 
+// static
+bool GpuMemoryBufferVideoFramePool::PoolImpl::AreFrameResourcesCompatible(
+    const FrameResources* resources,
+    const gfx::Size& size) {
+  if (size != resources->size)
+    return false;
+  for (const PlaneResource& plane : resources->plane_resources) {
+    if (!plane.gpu_memory_buffer &&
+        plane.texture_id)  // This happens if we failed to allocate a GMB
+      return false;

[reveman, 2015/09/09 22:45:28]

Not needed as discussed.

[Daniele Castagna, 2015/09/10 00:04:20]

Done. Also removed the second part of the test that depended on this.

+  }
+  return true;
+}
+
 // Destroy all the resources posting one task per FrameResources
 // to the |media_task_runner_|.
 GpuMemoryBufferVideoFramePool::PoolImpl::~PoolImpl() {
   // Delete all the resources on the media thread.
   while (!resources_pool_.empty()) {
     FrameResources* frame_resources = resources_pool_.front();
     resources_pool_.pop_front();
     media_task_runner_->PostTask(
         FROM_HERE, base::Bind(&PoolImpl::DeleteFrameResources, gpu_factories_,
                               base::Owned(frame_resources)));
@@ skipping 109 matching lines @@
 }
 
 void GpuMemoryBufferVideoFramePool::MaybeCreateHardwareFrame(
     const scoped_refptr<VideoFrame>& video_frame,
     const FrameReadyCB& frame_ready_cb) {
   DCHECK(video_frame);
   pool_impl_->CreateHardwareFrame(video_frame, frame_ready_cb);
 }
 
 }  // namespace media