Add offset support to BitstreamBuffer.

content/common/gpu/media/vaapi_video_encode_accelerator.cc

 // Copyright 2014 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 "content/common/gpu/media/vaapi_video_encode_accelerator.h"
 
 #include <string.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_conversions.h"
 #include "content/common/gpu/media/h264_dpb.h"
+#include "content/common/gpu/media/shared_memory_region.h"
 #include "media/base/bind_to_current_loop.h"
 #include "third_party/libva/va/va_enc_h264.h"
 
 #define DVLOGF(level) DVLOG(level) << __FUNCTION__ << "(): "
 
 #define NOTIFY_ERROR(error, msg)                         \
   do {                                                   \
     SetState(kError);                                    \
     LOG(ERROR) << msg;                                   \
     LOG(ERROR) << "Calling NotifyError(" << error << ")";\
@@ skipping 67 matching lines @@
 
 struct VaapiVideoEncodeAccelerator::InputFrameRef {
   InputFrameRef(const scoped_refptr<media::VideoFrame>& frame,
                 bool force_keyframe)
       : frame(frame), force_keyframe(force_keyframe) {}
   const scoped_refptr<media::VideoFrame> frame;
   const bool force_keyframe;
 };
 
 struct VaapiVideoEncodeAccelerator::BitstreamBufferRef {
-  BitstreamBufferRef(int32_t id,
-                     scoped_ptr<base::SharedMemory> shm,
-                     size_t size)
-      : id(id), shm(std::move(shm)), size(size) {}
+  BitstreamBufferRef(int32_t id, scoped_ptr<SharedMemoryRegion> shm)
+      : id(id), shm(std::move(shm)) {}
   const int32_t id;
-  const scoped_ptr<base::SharedMemory> shm;
-  const size_t size;
+  const scoped_ptr<SharedMemoryRegion> shm;
 };
 
 media::VideoEncodeAccelerator::SupportedProfiles
 VaapiVideoEncodeAccelerator::GetSupportedProfiles() {
   return VaapiWrapper::GetSupportedEncodeProfiles();
 }
 
 static unsigned int Log2OfPowerOf2(unsigned int x) {
   CHECK_GT(x, 0u);
   DCHECK_EQ(x & (x - 1), 0u);
@@ skipping 419 matching lines @@
   linked_ptr<BitstreamBufferRef> buffer = available_bitstream_buffers_.front();
   available_bitstream_buffers_.pop();
 
   uint8_t* target_data = reinterpret_cast<uint8_t*>(buffer->shm->memory());
 
   linked_ptr<EncodeJob> encode_job = submitted_encode_jobs_.front();
   submitted_encode_jobs_.pop();
 
   size_t data_size = 0;
   if (!vaapi_wrapper_->DownloadAndDestroyCodedBuffer(
-          encode_job->coded_buffer,
-          encode_job->input_surface->id(),
-          target_data,
-          buffer->size,
-          &data_size)) {
+          encode_job->coded_buffer, encode_job->input_surface->id(),
+          target_data, buffer->shm->size(), &data_size)) {
     NOTIFY_ERROR(kPlatformFailureError, "Failed downloading coded buffer");
     return;
   }
 
   DVLOGF(3) << "Returning bitstream buffer "
             << (encode_job->keyframe ? "(keyframe)" : "")
             << " id: " << buffer->id << " size: " << data_size;
 
   child_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Client::BitstreamBufferReady, client_, buffer->id,
@@ skipping 98 matching lines @@
 void VaapiVideoEncodeAccelerator::UseOutputBitstreamBuffer(
     const media::BitstreamBuffer& buffer) {
   DVLOGF(4) << "id: " << buffer.id();
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   if (buffer.size() < output_buffer_byte_size_) {
     NOTIFY_ERROR(kInvalidArgumentError, "Provided bitstream buffer too small");
     return;
   }
 
-  scoped_ptr<base::SharedMemory> shm(
-      new base::SharedMemory(buffer.handle(), false));
-  if (!shm->Map(buffer.size())) {
+  scoped_ptr<SharedMemoryRegion> shm(new SharedMemoryRegion(buffer, false));
+  if (!shm->Map()) {
     NOTIFY_ERROR(kPlatformFailureError, "Failed mapping shared memory.");
     return;
   }
 
   scoped_ptr<BitstreamBufferRef> buffer_ref(
-      new BitstreamBufferRef(buffer.id(), std::move(shm), buffer.size()));
+      new BitstreamBufferRef(buffer.id(), std::move(shm)));
 
   encoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VaapiVideoEncodeAccelerator::UseOutputBitstreamBufferTask,
                  base::Unretained(this), base::Passed(&buffer_ref)));
 }
 
 void VaapiVideoEncodeAccelerator::UseOutputBitstreamBufferTask(
     scoped_ptr<BitstreamBufferRef> buffer_ref) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
@@ skipping 367 matching lines @@
 }
 
 VaapiVideoEncodeAccelerator::EncodeJob::EncodeJob()
     : coded_buffer(VA_INVALID_ID), keyframe(false) {
 }
 
 VaapiVideoEncodeAccelerator::EncodeJob::~EncodeJob() {
 }
 
 }  // namespace content