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 208 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 37 matching lines @@
       frame_ready_cb.Run(video_frame);
       return;
   }
 
   DCHECK(video_frame->visible_rect().origin().IsOrigin());
   const gfx::Size size = video_frame->visible_rect().size();
 
   // Acquire resources. Incompatible ones will be dropped from the pool.
   FrameResources* frame_resources =
       GetOrCreateFrameResources(size, output_format_);
   if (!frame_resources) {

[DaleCurtis, 2015/09/13 18:48:47]

I don't understand how this crashed before? Shouldn't this line have protected
us against a failed allocation?

[Daniele Castagna, 2015/09/13 19:31:06]

What I think was happening before is the frame_resources allocation worked, but
AllocateGpuMemoryBuffer returned nullptr.
That caused an access violation later when we try to call Map on a nullptr in
CopyVideoFrameToGpuMemoryBuffers.

     frame_ready_cb.Run(video_frame);
     return;
   }
 
   worker_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PoolImpl::CopyVideoFrameToGpuMemoryBuffers, this,
                             video_frame, frame_resources, frame_ready_cb));
 }
 
 void GpuMemoryBufferVideoFramePool::PoolImpl::OnCopiesDone(
@@ skipping 32 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 149 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