Add offset support to BitstreamBuffer.

content/common/gpu/media/v4l2_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 <errno.h>
 #include <linux/videodev2.h>
 #include <string.h>
 #include <sys/mman.h>
 
 #include "base/big_endian.h"
@@ skipping 94 matching lines @@
 };
 
 V4L2JpegDecodeAccelerator::BufferRecord::BufferRecord()
     : address(nullptr), length(0), at_device(false) {
 }
 
 V4L2JpegDecodeAccelerator::BufferRecord::~BufferRecord() {
 }
 
 V4L2JpegDecodeAccelerator::JobRecord::JobRecord(
-    media::BitstreamBuffer bitstream_buffer,
+    const media::BitstreamBuffer& bitstream_buffer,
     scoped_refptr<media::VideoFrame> video_frame)
-    : bitstream_buffer(bitstream_buffer), out_frame(video_frame) {
-}
+    : bitstream_buffer_id(bitstream_buffer.id()),
+      shm(bitstream_buffer, true),
+      out_frame(video_frame) {}
 
 V4L2JpegDecodeAccelerator::JobRecord::~JobRecord() {
 }
 
 V4L2JpegDecodeAccelerator::V4L2JpegDecodeAccelerator(
     const scoped_refptr<V4L2Device>& device,
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
     : output_buffer_pixelformat_(0),
       child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       io_task_runner_(io_task_runner),
@@ skipping 124 matching lines @@
 
   for (; device_->Ioctl(VIDIOC_ENUM_FMT, &fmtdesc) == 0; ++fmtdesc.index) {
     if (fmtdesc.pixelformat == V4L2_PIX_FMT_JPEG)
       return true;
   }
   return false;
 }
 
 void V4L2JpegDecodeAccelerator::DecodeTask(scoped_ptr<JobRecord> job_record) {
   DCHECK(decoder_task_runner_->BelongsToCurrentThread());
-  job_record->shm.reset(
-      new base::SharedMemory(job_record->bitstream_buffer.handle(), true));
-  if (!job_record->shm->Map(job_record->bitstream_buffer.size())) {
+  if (!job_record->shm.Map()) {
     PLOG(ERROR) << __func__ << ": could not map bitstream_buffer";
-    PostNotifyError(job_record->bitstream_buffer.id(), UNREADABLE_INPUT);
+    PostNotifyError(job_record->bitstream_buffer_id, UNREADABLE_INPUT);
     return;
   }
   input_jobs_.push(make_linked_ptr(job_record.release()));
 
   ServiceDeviceTask(false);
 }
 
 size_t V4L2JpegDecodeAccelerator::InputBufferQueuedCount() {
   return input_buffer_map_.size() - free_input_buffers_.size();
 }
 
 size_t V4L2JpegDecodeAccelerator::OutputBufferQueuedCount() {
   return output_buffer_map_.size() - free_output_buffers_.size();
 }
 
 bool V4L2JpegDecodeAccelerator::ShouldRecreateInputBuffers() {
   DCHECK(decoder_task_runner_->BelongsToCurrentThread());
   if (input_jobs_.empty())
     return false;
 
   linked_ptr<JobRecord> job_record = input_jobs_.front();
   // Check input buffer size is enough
   return (input_buffer_map_.empty() ||
-          (job_record->bitstream_buffer.size() + sizeof(kDefaultDhtSeg)) >
+          (job_record->shm.size() + sizeof(kDefaultDhtSeg)) >
               input_buffer_map_.front().length);
 }
 
 bool V4L2JpegDecodeAccelerator::RecreateInputBuffers() {
   DVLOG(3) << __func__;
   DCHECK(decoder_task_runner_->BelongsToCurrentThread());
 
   // If running queue is not empty, we should wait until pending frames finish.
   if (!running_jobs_.empty())
     return true;
@@ skipping 24 matching lines @@
 
 bool V4L2JpegDecodeAccelerator::CreateInputBuffers() {
   DVLOG(3) << __func__;
   DCHECK(decoder_task_runner_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
   DCHECK(!input_jobs_.empty());
   linked_ptr<JobRecord> job_record = input_jobs_.front();
   // The input image may miss huffman table. We didn't parse the image before,
   // so we create more to avoid the situation of not enough memory.
   // Reserve twice size to avoid recreating input buffer frequently.
-  size_t reserve_size =
-      (job_record->bitstream_buffer.size() + sizeof(kDefaultDhtSeg)) * 2;
+  size_t reserve_size = (job_record->shm.size() + sizeof(kDefaultDhtSeg)) * 2;
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
   format.fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG;
   format.fmt.pix.sizeimage = reserve_size;
   format.fmt.pix.field = V4L2_FIELD_ANY;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
@@ skipping 356 matching lines @@
 
     if (dqbuf.flags & V4L2_BUF_FLAG_ERROR) {
       DVLOG(1) << "Dequeue output buffer error.";
       PostNotifyError(kInvalidBitstreamBufferId, UNSUPPORTED_JPEG);
     } else {
       // Copy the decoded data from output buffer to the buffer provided by the
       // client. Do format conversion when output format is not
       // V4L2_PIX_FMT_YUV420.
       if (!CopyOutputImage(output_buffer_pixelformat_, output_record.address,
                            output_buffer_coded_size_, job_record->out_frame)) {
-        PostNotifyError(job_record->bitstream_buffer.id(), PLATFORM_FAILURE);
+        PostNotifyError(job_record->bitstream_buffer_id, PLATFORM_FAILURE);
         return;
       }
 
       DVLOG(3) << "Decoding finished, returning bitstream buffer, id="
-               << job_record->bitstream_buffer.id();
+               << job_record->bitstream_buffer_id;
 
       child_task_runner_->PostTask(
-          FROM_HERE,
-          base::Bind(&V4L2JpegDecodeAccelerator::VideoFrameReady, weak_ptr_,
-                     job_record->bitstream_buffer.id()));
+          FROM_HERE, base::Bind(&V4L2JpegDecodeAccelerator::VideoFrameReady,
+                                weak_ptr_, job_record->bitstream_buffer_id));
     }
   }
 }
 
 static bool AddHuffmanTable(const void* input_ptr,
                             size_t input_size,
                             void* output_ptr,
                             size_t output_size) {
   DCHECK(input_ptr);
   DCHECK(output_ptr);
@@ skipping 77 matching lines @@
   DCHECK(!free_input_buffers_.empty());
 
   // Enqueue an input (VIDEO_OUTPUT) buffer for an input video frame.
   linked_ptr<JobRecord> job_record = input_jobs_.front();
   input_jobs_.pop();
   const int index = free_input_buffers_.back();
   BufferRecord& input_record = input_buffer_map_[index];
   DCHECK(!input_record.at_device);
 
   // It will add default huffman segment if it's missing.
-  if (!AddHuffmanTable(job_record->shm->memory(),
-                       job_record->bitstream_buffer.size(),
+  if (!AddHuffmanTable(job_record->shm.memory(), job_record->shm.size(),
                        input_record.address, input_record.length)) {
-    PostNotifyError(job_record->bitstream_buffer.id(), PARSE_JPEG_FAILED);
+    PostNotifyError(job_record->bitstream_buffer_id, PARSE_JPEG_FAILED);
     return false;
   }
 
   struct v4l2_buffer qbuf;
   memset(&qbuf, 0, sizeof(qbuf));
   qbuf.index = index;
   qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
   qbuf.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QBUF, &qbuf);
   input_record.at_device = true;
   running_jobs_.push(job_record);
   free_input_buffers_.pop_back();
 
-  DVLOG(3) << __func__ << ": enqueued frame id="
-           << job_record->bitstream_buffer.id() << " to device.";
+  DVLOG(3) << __func__
+           << ": enqueued frame id=" << job_record->bitstream_buffer_id
+           << " to device.";
   return true;
 }
 
 bool V4L2JpegDecodeAccelerator::EnqueueOutputRecord() {
   DCHECK(!free_output_buffers_.empty());
 
   // Enqueue an output (VIDEO_CAPTURE) buffer.
   const int index = free_output_buffers_.back();
   BufferRecord& output_record = output_buffer_map_[index];
   DCHECK(!output_record.at_device);
@@ skipping 33 matching lines @@
   device_poll_thread_.Stop();
 
   // Clear the interrupt now, to be sure.
   if (!device_->ClearDevicePollInterrupt())
     return false;
 
   return true;
 }
 
 }  // namespace content