Add offset support to BitstreamBuffer.

content/common/gpu/media/vaapi_jpeg_decode_accelerator.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 "content/common/gpu/media/vaapi_jpeg_decode_accelerator.h"
 
 #include <stddef.h>
 #include <string.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/gpu_channel.h"
+#include "content/common/gpu/media/shared_memory_region.h"
 #include "content/common/gpu/media/vaapi_picture.h"
 #include "media/base/video_frame.h"
 #include "media/filters/jpeg_parser.h"
 #include "third_party/libyuv/include/libyuv.h"
 
 namespace content {
 
 namespace {
 // UMA errors that the VaapiJpegDecodeAccelerator class reports.
 enum VAJDADecoderFailure {
@@ skipping 42 matching lines @@
   DVLOG(1) << "Unsupported sampling factor: num_components="
            << frame_header.num_components << ", h=" << std::hex << h
            << ", v=" << v;
 
   return 0;
 }
 
 }  // namespace
 
 VaapiJpegDecodeAccelerator::DecodeRequest::DecodeRequest(
-    const media::BitstreamBuffer& bitstream_buffer,
-    scoped_ptr<base::SharedMemory> shm,
+    int32_t bitstream_buffer_id,
+    scoped_ptr<SharedMemoryRegion> shm,
     const scoped_refptr<media::VideoFrame>& video_frame)
-    : bitstream_buffer(bitstream_buffer),
+    : bitstream_buffer_id(bitstream_buffer_id),
       shm(std::move(shm)),
       video_frame(video_frame) {}
 
 VaapiJpegDecodeAccelerator::DecodeRequest::~DecodeRequest() {
 }
 
 void VaapiJpegDecodeAccelerator::NotifyError(int32_t bitstream_buffer_id,
                                              Error error) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DLOG(ERROR) << "Notifying of error " << error;
@@ skipping 126 matching lines @@
 
 void VaapiJpegDecodeAccelerator::DecodeTask(
     const scoped_ptr<DecodeRequest>& request) {
   DVLOG(3) << __func__;
   DCHECK(decoder_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT0("jpeg", "DecodeTask");
 
   media::JpegParseResult parse_result;
   if (!media::ParseJpegPicture(
           reinterpret_cast<const uint8_t*>(request->shm->memory()),
-          request->bitstream_buffer.size(), &parse_result)) {
+          request->shm->size(), &parse_result)) {
     DLOG(ERROR) << "ParseJpegPicture failed";
-    NotifyErrorFromDecoderThread(request->bitstream_buffer.id(),
+    NotifyErrorFromDecoderThread(request->bitstream_buffer_id,
                                  PARSE_JPEG_FAILED);
     return;
   }
 
   unsigned int new_va_rt_format =
       VaSurfaceFormatForJpeg(parse_result.frame_header);
   if (!new_va_rt_format) {
     DLOG(ERROR) << "Unsupported subsampling";
-    NotifyErrorFromDecoderThread(request->bitstream_buffer.id(),
+    NotifyErrorFromDecoderThread(request->bitstream_buffer_id,
                                  UNSUPPORTED_JPEG);
     return;
   }
 
   // Reuse VASurface if size doesn't change.
   gfx::Size new_coded_size(parse_result.frame_header.coded_width,
                            parse_result.frame_header.coded_height);
   if (new_coded_size != coded_size_ || va_surface_id_ == VA_INVALID_SURFACE ||
       new_va_rt_format != va_rt_format_) {
     vaapi_wrapper_->DestroySurfaces();
     va_surface_id_ = VA_INVALID_SURFACE;
     va_rt_format_ = new_va_rt_format;
 
     std::vector<VASurfaceID> va_surfaces;
     if (!vaapi_wrapper_->CreateSurfaces(va_rt_format_, new_coded_size, 1,
                                         &va_surfaces)) {
       LOG(ERROR) << "Create VA surface failed";
-      NotifyErrorFromDecoderThread(request->bitstream_buffer.id(),
+      NotifyErrorFromDecoderThread(request->bitstream_buffer_id,
                                    PLATFORM_FAILURE);
       return;
     }
     va_surface_id_ = va_surfaces[0];
     coded_size_ = new_coded_size;
   }
 
   if (!VaapiJpegDecoder::Decode(vaapi_wrapper_.get(), parse_result,
                                 va_surface_id_)) {
     LOG(ERROR) << "Decode JPEG failed";
-    NotifyErrorFromDecoderThread(request->bitstream_buffer.id(),
+    NotifyErrorFromDecoderThread(request->bitstream_buffer_id,
                                  PLATFORM_FAILURE);
     return;
   }
 
-  if (!OutputPicture(va_surface_id_, request->bitstream_buffer.id(),
+  if (!OutputPicture(va_surface_id_, request->bitstream_buffer_id,
                      request->video_frame)) {
     LOG(ERROR) << "Output picture failed";
-    NotifyErrorFromDecoderThread(request->bitstream_buffer.id(),
+    NotifyErrorFromDecoderThread(request->bitstream_buffer_id,
                                  PLATFORM_FAILURE);
     return;
   }
 }
 
 void VaapiJpegDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer,
     const scoped_refptr<media::VideoFrame>& video_frame) {
   DVLOG(3) << __func__;
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   TRACE_EVENT1("jpeg", "Decode", "input_id", bitstream_buffer.id());
 
   DVLOG(4) << "Mapping new input buffer id: " << bitstream_buffer.id()
            << " size: " << bitstream_buffer.size();
 
+  // SharedMemoryRegion will take over the |bitstream_buffer.handle()|.
+  scoped_ptr<SharedMemoryRegion> shm(
+      new SharedMemoryRegion(bitstream_buffer, true));
+
   if (bitstream_buffer.id() < 0) {
     LOG(ERROR) << "Invalid bitstream_buffer, id: " << bitstream_buffer.id();
-    if (base::SharedMemory::IsHandleValid(bitstream_buffer.handle()))
-      base::SharedMemory::CloseHandle(bitstream_buffer.handle());
     NotifyErrorFromDecoderThread(bitstream_buffer.id(), INVALID_ARGUMENT);
     return;
   }
 
-  scoped_ptr<base::SharedMemory> shm(
-      new base::SharedMemory(bitstream_buffer.handle(), true));
-
-  if (!shm->Map(bitstream_buffer.size())) {
+  if (!shm->Map()) {
     LOG(ERROR) << "Failed to map input buffer";
     NotifyErrorFromDecoderThread(bitstream_buffer.id(), UNREADABLE_INPUT);
     return;
   }
 
   scoped_ptr<DecodeRequest> request(
-      new DecodeRequest(bitstream_buffer, std::move(shm), video_frame));
+      new DecodeRequest(bitstream_buffer.id(), std::move(shm), video_frame));
 
   decoder_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VaapiJpegDecodeAccelerator::DecodeTask,
                             base::Unretained(this), base::Passed(&request)));
 }
 
 bool VaapiJpegDecodeAccelerator::IsSupported() {
   return VaapiWrapper::IsJpegDecodeSupported();
 }
 
 }  // namespace content