Home | History | Annotate | Download | only in media 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <fcntl.h>
      6 #include <linux/videodev2.h>
      7 #include <poll.h>
      8 #include <sys/eventfd.h>
      9 #include <sys/ioctl.h>
     10 #include <sys/mman.h>
     11 
     12 #include "base/callback.h"
     13 #include "base/command_line.h"
     14 #include "base/debug/trace_event.h"
     15 #include "base/message_loop/message_loop_proxy.h"
     16 #include "base/numerics/safe_conversions.h"
     17 #include "content/common/gpu/media/v4l2_video_encode_accelerator.h"
     18 #include "content/public/common/content_switches.h"
     19 #include "media/base/bitstream_buffer.h"
     20 
     21 #define NOTIFY_ERROR(x)                            \
     22   do {                                             \
     23     SetEncoderState(kError);                       \
     24     DLOG(ERROR) << "calling NotifyError(): " << x; \
     25     NotifyError(x);                                \
     26   } while (0)
     27 
     28 #define IOCTL_OR_ERROR_RETURN_VALUE(type, arg, value)              \
     29   do {                                                             \
     30     if (device_->Ioctl(type, arg) != 0) {                          \
     31       DPLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type; \
     32       NOTIFY_ERROR(kPlatformFailureError);                         \
     33       return value;                                                \
     34     }                                                              \
     35   } while (0)
     36 
     37 #define IOCTL_OR_ERROR_RETURN(type, arg) \
     38   IOCTL_OR_ERROR_RETURN_VALUE(type, arg, ((void)0))
     39 
     40 #define IOCTL_OR_ERROR_RETURN_FALSE(type, arg) \
     41   IOCTL_OR_ERROR_RETURN_VALUE(type, arg, false)
     42 
     43 #define IOCTL_OR_LOG_ERROR(type, arg)                              \
     44   do {                                                             \
     45     if (device_->Ioctl(type, arg) != 0)                            \
     46       DPLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type; \
     47   } while (0)
     48 
     49 namespace content {
     50 
     51 struct V4L2VideoEncodeAccelerator::BitstreamBufferRef {
     52   BitstreamBufferRef(int32 id, scoped_ptr<base::SharedMemory> shm, size_t size)
     53       : id(id), shm(shm.Pass()), size(size) {}
     54   const int32 id;
     55   const scoped_ptr<base::SharedMemory> shm;
     56   const size_t size;
     57 };
     58 
     59 V4L2VideoEncodeAccelerator::InputRecord::InputRecord() : at_device(false) {
     60 }
     61 
     62 V4L2VideoEncodeAccelerator::OutputRecord::OutputRecord()
     63     : at_device(false), address(NULL), length(0) {
     64 }
     65 
     66 V4L2VideoEncodeAccelerator::V4L2VideoEncodeAccelerator(
     67     scoped_ptr<V4L2Device> device)
     68     : child_message_loop_proxy_(base::MessageLoopProxy::current()),
     69       weak_this_ptr_factory_(this),
     70       weak_this_(weak_this_ptr_factory_.GetWeakPtr()),
     71       output_buffer_byte_size_(0),
     72       device_input_format_(media::VideoFrame::UNKNOWN),
     73       input_planes_count_(0),
     74       output_format_fourcc_(0),
     75       encoder_thread_("V4L2EncoderThread"),
     76       encoder_state_(kUninitialized),
     77       stream_header_size_(0),
     78       device_(device.Pass()),
     79       input_streamon_(false),
     80       input_buffer_queued_count_(0),
     81       input_memory_type_(V4L2_MEMORY_USERPTR),
     82       output_streamon_(false),
     83       output_buffer_queued_count_(0),
     84       device_poll_thread_("V4L2EncoderDevicePollThread") {
     85 }
     86 
     87 V4L2VideoEncodeAccelerator::~V4L2VideoEncodeAccelerator() {
     88   DCHECK(!encoder_thread_.IsRunning());
     89   DCHECK(!device_poll_thread_.IsRunning());
     90   DVLOG(4) << __func__;
     91 
     92   DestroyInputBuffers();
     93   DestroyOutputBuffers();
     94 }
     95 
     96 bool V4L2VideoEncodeAccelerator::Initialize(
     97     media::VideoFrame::Format input_format,
     98     const gfx::Size& input_visible_size,
     99     media::VideoCodecProfile output_profile,
    100     uint32 initial_bitrate,
    101     Client* client) {
    102   DVLOG(3) << __func__ << ": input_format="
    103            << media::VideoFrame::FormatToString(input_format)
    104            << ", input_visible_size=" << input_visible_size.ToString()
    105            << ", output_profile=" << output_profile
    106            << ", initial_bitrate=" << initial_bitrate;
    107 
    108   visible_size_ = input_visible_size;
    109 
    110   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
    111   client_ = client_ptr_factory_->GetWeakPtr();
    112 
    113   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
    114   DCHECK_EQ(encoder_state_, kUninitialized);
    115 
    116   struct v4l2_capability caps;
    117   memset(&caps, 0, sizeof(caps));
    118   const __u32 kCapsRequired = V4L2_CAP_VIDEO_CAPTURE_MPLANE |
    119                               V4L2_CAP_VIDEO_OUTPUT_MPLANE | V4L2_CAP_STREAMING;
    120   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYCAP, &caps);
    121   if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
    122     DLOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP: "
    123                    "caps check failed: 0x" << std::hex << caps.capabilities;
    124     return false;
    125   }
    126 
    127   if (!SetFormats(input_format, output_profile)) {
    128     DLOG(ERROR) << "Failed setting up formats";
    129     return false;
    130   }
    131 
    132   if (input_format != device_input_format_) {
    133     DVLOG(1) << "Input format not supported by the HW, will convert to "
    134              << media::VideoFrame::FormatToString(device_input_format_);
    135 
    136     scoped_ptr<V4L2Device> device =
    137         V4L2Device::Create(V4L2Device::kImageProcessor);
    138     image_processor_.reset(new V4L2ImageProcessor(device.Pass()));
    139 
    140     // Convert from input_format to device_input_format_, keeping the size
    141     // at visible_size_ and requiring the output buffers to be of at least
    142     // input_allocated_size_.
    143     if (!image_processor_->Initialize(
    144             input_format,
    145             device_input_format_,
    146             visible_size_,
    147             visible_size_,
    148             input_allocated_size_,
    149             base::Bind(&V4L2VideoEncodeAccelerator::ImageProcessorError,
    150                        weak_this_))) {
    151       DLOG(ERROR) << "Failed initializing image processor";
    152       return false;
    153     }
    154   }
    155 
    156   if (!InitControls())
    157     return false;
    158 
    159   if (!CreateOutputBuffers())
    160     return false;
    161 
    162   if (!encoder_thread_.Start()) {
    163     DLOG(ERROR) << "Initialize(): encoder thread failed to start";
    164     return false;
    165   }
    166 
    167   RequestEncodingParametersChange(initial_bitrate, kInitialFramerate);
    168 
    169   SetEncoderState(kInitialized);
    170 
    171   child_message_loop_proxy_->PostTask(
    172       FROM_HERE,
    173       base::Bind(&Client::RequireBitstreamBuffers,
    174                  client_,
    175                  kInputBufferCount,
    176                  image_processor_.get() ?
    177                      image_processor_->input_allocated_size() :
    178                      input_allocated_size_,
    179                  output_buffer_byte_size_));
    180   return true;
    181 }
    182 
    183 void V4L2VideoEncodeAccelerator::ImageProcessorError() {
    184   DVLOG(1) << "Image processor error";
    185   NOTIFY_ERROR(kPlatformFailureError);
    186 }
    187 
    188 void V4L2VideoEncodeAccelerator::Encode(
    189     const scoped_refptr<media::VideoFrame>& frame,
    190     bool force_keyframe) {
    191   DVLOG(3) << "Encode(): force_keyframe=" << force_keyframe;
    192   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
    193 
    194   if (image_processor_) {
    195     image_processor_->Process(
    196         frame,
    197         base::Bind(&V4L2VideoEncodeAccelerator::FrameProcessed,
    198                    weak_this_,
    199                    force_keyframe));
    200   } else {
    201     encoder_thread_.message_loop()->PostTask(
    202         FROM_HERE,
    203         base::Bind(&V4L2VideoEncodeAccelerator::EncodeTask,
    204                    base::Unretained(this),
    205                    frame,
    206                    force_keyframe));
    207   }
    208 }
    209 
    210 void V4L2VideoEncodeAccelerator::UseOutputBitstreamBuffer(
    211     const media::BitstreamBuffer& buffer) {
    212   DVLOG(3) << "UseOutputBitstreamBuffer(): id=" << buffer.id();
    213   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
    214 
    215   if (buffer.size() < output_buffer_byte_size_) {
    216     NOTIFY_ERROR(kInvalidArgumentError);
    217     return;
    218   }
    219 
    220   scoped_ptr<base::SharedMemory> shm(
    221       new base::SharedMemory(buffer.handle(), false));
    222   if (!shm->Map(buffer.size())) {
    223     NOTIFY_ERROR(kPlatformFailureError);
    224     return;
    225   }
    226 
    227   scoped_ptr<BitstreamBufferRef> buffer_ref(
    228       new BitstreamBufferRef(buffer.id(), shm.Pass(), buffer.size()));
    229   encoder_thread_.message_loop()->PostTask(
    230       FROM_HERE,
    231       base::Bind(&V4L2VideoEncodeAccelerator::UseOutputBitstreamBufferTask,
    232                  base::Unretained(this),
    233                  base::Passed(&buffer_ref)));
    234 }
    235 
    236 void V4L2VideoEncodeAccelerator::RequestEncodingParametersChange(
    237     uint32 bitrate,
    238     uint32 framerate) {
    239   DVLOG(3) << "RequestEncodingParametersChange(): bitrate=" << bitrate
    240            << ", framerate=" << framerate;
    241   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
    242 
    243   encoder_thread_.message_loop()->PostTask(
    244       FROM_HERE,
    245       base::Bind(
    246           &V4L2VideoEncodeAccelerator::RequestEncodingParametersChangeTask,
    247           base::Unretained(this),
    248           bitrate,
    249           framerate));
    250 }
    251 
    252 void V4L2VideoEncodeAccelerator::Destroy() {
    253   DVLOG(3) << "Destroy()";
    254   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
    255 
    256   // We're destroying; cancel all callbacks.
    257   client_ptr_factory_.reset();
    258 
    259   if (image_processor_.get())
    260     image_processor_.release()->Destroy();
    261 
    262   // If the encoder thread is running, destroy using posted task.
    263   if (encoder_thread_.IsRunning()) {
    264     encoder_thread_.message_loop()->PostTask(
    265         FROM_HERE,
    266         base::Bind(&V4L2VideoEncodeAccelerator::DestroyTask,
    267                    base::Unretained(this)));
    268     // DestroyTask() will put the encoder into kError state and cause all tasks
    269     // to no-op.
    270     encoder_thread_.Stop();
    271   } else {
    272     // Otherwise, call the destroy task directly.
    273     DestroyTask();
    274   }
    275 
    276   // Set to kError state just in case.
    277   SetEncoderState(kError);
    278 
    279   delete this;
    280 }
    281 
    282 // static
    283 std::vector<media::VideoEncodeAccelerator::SupportedProfile>
    284 V4L2VideoEncodeAccelerator::GetSupportedProfiles() {
    285   std::vector<SupportedProfile> profiles;
    286   SupportedProfile profile;
    287 
    288   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
    289   if (cmd_line->HasSwitch(switches::kEnableWebRtcHWVp8Encoding)) {
    290     profile.profile = media::VP8PROFILE_MAIN;
    291     profile.max_resolution.SetSize(1920, 1088);
    292     profile.max_framerate.numerator = 30;
    293     profile.max_framerate.denominator = 1;
    294     profiles.push_back(profile);
    295   } else {
    296     profile.profile = media::H264PROFILE_MAIN;
    297     profile.max_resolution.SetSize(1920, 1088);
    298     profile.max_framerate.numerator = 30;
    299     profile.max_framerate.denominator = 1;
    300     profiles.push_back(profile);
    301   }
    302 
    303   return profiles;
    304 }
    305 
    306 void V4L2VideoEncodeAccelerator::FrameProcessed(
    307     bool force_keyframe,
    308     const scoped_refptr<media::VideoFrame>& frame) {
    309   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
    310   DVLOG(3) << "FrameProcessed(): force_keyframe=" << force_keyframe;
    311 
    312   encoder_thread_.message_loop()->PostTask(
    313       FROM_HERE,
    314       base::Bind(&V4L2VideoEncodeAccelerator::EncodeTask,
    315                  base::Unretained(this),
    316                  frame,
    317                  force_keyframe));
    318 }
    319 
    320 void V4L2VideoEncodeAccelerator::EncodeTask(
    321     const scoped_refptr<media::VideoFrame>& frame,
    322     bool force_keyframe) {
    323   DVLOG(3) << "EncodeTask(): force_keyframe=" << force_keyframe;
    324   DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
    325   DCHECK_NE(encoder_state_, kUninitialized);
    326 
    327   if (encoder_state_ == kError) {
    328     DVLOG(2) << "EncodeTask(): early out: kError state";
    329     return;
    330   }
    331 
    332   encoder_input_queue_.push_back(frame);
    333   Enqueue();
    334 
    335   if (force_keyframe) {
    336     // TODO(posciak): this presently makes for slightly imprecise encoding
    337     // parameters updates.  To precisely align the parameter updates with the
    338     // incoming input frame, we should queue the parameters together with the
    339     // frame onto encoder_input_queue_ and apply them when the input is about
    340     // to be queued to the codec.
    341     struct v4l2_ext_control ctrls[1];
    342     struct v4l2_ext_controls control;
    343     memset(&ctrls, 0, sizeof(ctrls));
    344     memset(&control, 0, sizeof(control));
    345     ctrls[0].id = V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE;
    346     ctrls[0].value = V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_I_FRAME;
    347     control.ctrl_class = V4L2_CTRL_CLASS_MPEG;
    348     control.count = 1;
    349     control.controls = ctrls;
    350     IOCTL_OR_ERROR_RETURN(VIDIOC_S_EXT_CTRLS, &control);
    351   }
    352 }
    353 
    354 void V4L2VideoEncodeAccelerator::UseOutputBitstreamBufferTask(
    355     scoped_ptr<BitstreamBufferRef> buffer_ref) {
    356   DVLOG(3) << "UseOutputBitstreamBufferTask(): id=" << buffer_ref->id;
    357   DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
    358 
    359   encoder_output_queue_.push_back(
    360       linked_ptr<BitstreamBufferRef>(buffer_ref.release()));
    361   Enqueue();
    362 
    363   if (encoder_state_ == kInitialized) {
    364     // Finish setting up our OUTPUT queue.  See: Initialize().
    365     // VIDIOC_REQBUFS on OUTPUT queue.
    366     if (!CreateInputBuffers())
    367       return;
    368     if (!StartDevicePoll())
    369       return;
    370     encoder_state_ = kEncoding;
    371   }
    372 }
    373 
    374 void V4L2VideoEncodeAccelerator::DestroyTask() {
    375   DVLOG(3) << "DestroyTask()";
    376 
    377   // DestroyTask() should run regardless of encoder_state_.
    378 
    379   // Stop streaming and the device_poll_thread_.
    380   StopDevicePoll();
    381 
    382   // Set our state to kError, and early-out all tasks.
    383   encoder_state_ = kError;
    384 }
    385 
    386 void V4L2VideoEncodeAccelerator::ServiceDeviceTask() {
    387   DVLOG(3) << "ServiceDeviceTask()";
    388   DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
    389   DCHECK_NE(encoder_state_, kUninitialized);
    390   DCHECK_NE(encoder_state_, kInitialized);
    391 
    392   if (encoder_state_ == kError) {
    393     DVLOG(2) << "ServiceDeviceTask(): early out: kError state";
    394     return;
    395   }
    396 
    397   Dequeue();
    398   Enqueue();
    399 
    400   // Clear the interrupt fd.
    401   if (!device_->ClearDevicePollInterrupt())
    402     return;
    403 
    404   // Device can be polled as soon as either input or output buffers are queued.
    405   bool poll_device =
    406       (input_buffer_queued_count_ + output_buffer_queued_count_ > 0);
    407 
    408   // ServiceDeviceTask() should only ever be scheduled from DevicePollTask(),
    409   // so either:
    410   // * device_poll_thread_ is running normally
    411   // * device_poll_thread_ scheduled us, but then a DestroyTask() shut it down,
    412   //   in which case we're in kError state, and we should have early-outed
    413   //   already.
    414   DCHECK(device_poll_thread_.message_loop());
    415   // Queue the DevicePollTask() now.
    416   device_poll_thread_.message_loop()->PostTask(
    417       FROM_HERE,
    418       base::Bind(&V4L2VideoEncodeAccelerator::DevicePollTask,
    419                  base::Unretained(this),
    420                  poll_device));
    421 
    422   DVLOG(2) << __func__ << ": buffer counts: ENC["
    423            << encoder_input_queue_.size() << "] => DEVICE["
    424            << free_input_buffers_.size() << "+"
    425            << input_buffer_queued_count_ << "/"
    426            << input_buffer_map_.size() << "->"
    427            << free_output_buffers_.size() << "+"
    428            << output_buffer_queued_count_ << "/"
    429            << output_buffer_map_.size() << "] => OUT["
    430            << encoder_output_queue_.size() << "]";
    431 }
    432 
    433 void V4L2VideoEncodeAccelerator::Enqueue() {
    434   DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
    435 
    436   DVLOG(3) << "Enqueue() "
    437            << "free_input_buffers: " << free_input_buffers_.size()
    438            << "input_queue: " << encoder_input_queue_.size();
    439 
    440   // Enqueue all the inputs we can.
    441   const int old_inputs_queued = input_buffer_queued_count_;
    442   // while (!ready_input_buffers_.empty()) {
    443   while (!encoder_input_queue_.empty() && !free_input_buffers_.empty()) {
    444     if (!EnqueueInputRecord())
    445       return;
    446   }
    447   if (old_inputs_queued == 0 && input_buffer_queued_count_ != 0) {
    448     // We just started up a previously empty queue.
    449     // Queue state changed; signal interrupt.
    450     if (!device_->SetDevicePollInterrupt())
    451       return;
    452     // Start VIDIOC_STREAMON if we haven't yet.
    453     if (!input_streamon_) {
    454       __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    455       IOCTL_OR_ERROR_RETURN(VIDIOC_STREAMON, &type);
    456       input_streamon_ = true;
    457     }
    458   }
    459 
    460   // Enqueue all the outputs we can.
    461   const int old_outputs_queued = output_buffer_queued_count_;
    462   while (!free_output_buffers_.empty() && !encoder_output_queue_.empty()) {
    463     if (!EnqueueOutputRecord())
    464       return;
    465   }
    466   if (old_outputs_queued == 0 && output_buffer_queued_count_ != 0) {
    467     // We just started up a previously empty queue.
    468     // Queue state changed; signal interrupt.
    469     if (!device_->SetDevicePollInterrupt())
    470       return;
    471     // Start VIDIOC_STREAMON if we haven't yet.
    472     if (!output_streamon_) {
    473       __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    474       IOCTL_OR_ERROR_RETURN(VIDIOC_STREAMON, &type);
    475       output_streamon_ = true;
    476     }
    477   }
    478 }
    479 
    480 void V4L2VideoEncodeAccelerator::Dequeue() {
    481   DVLOG(3) << "Dequeue()";
    482   DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
    483 
    484   // Dequeue completed input (VIDEO_OUTPUT) buffers, and recycle to the free
    485   // list.
    486   struct v4l2_buffer dqbuf;
    487   struct v4l2_plane planes[VIDEO_MAX_PLANES];
    488   while (input_buffer_queued_count_ > 0) {
    489     DVLOG(4) << "inputs queued: " << input_buffer_queued_count_;
    490     DCHECK(input_streamon_);
    491     memset(&dqbuf, 0, sizeof(dqbuf));
    492     memset(&planes, 0, sizeof(planes));
    493     dqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    494     dqbuf.memory = V4L2_MEMORY_MMAP;
    495     dqbuf.m.planes = planes;
    496     dqbuf.length = input_planes_count_;
    497     if (device_->Ioctl(VIDIOC_DQBUF, &dqbuf) != 0) {
    498       if (errno == EAGAIN) {
    499         // EAGAIN if we're just out of buffers to dequeue.
    500         break;
    501       }
    502       DPLOG(ERROR) << "Dequeue(): ioctl() failed: VIDIOC_DQBUF";
    503       NOTIFY_ERROR(kPlatformFailureError);
    504       return;
    505     }
    506     InputRecord& input_record = input_buffer_map_[dqbuf.index];
    507     DCHECK(input_record.at_device);
    508     input_record.at_device = false;
    509 
    510     input_record.frame = NULL;
    511     free_input_buffers_.push_back(dqbuf.index);
    512     input_buffer_queued_count_--;
    513   }
    514 
    515   // Dequeue completed output (VIDEO_CAPTURE) buffers, and recycle to the
    516   // free list.  Notify the client that an output buffer is complete.
    517   while (output_buffer_queued_count_ > 0) {
    518     DCHECK(output_streamon_);
    519     memset(&dqbuf, 0, sizeof(dqbuf));
    520     memset(planes, 0, sizeof(planes));
    521     dqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    522     dqbuf.memory = V4L2_MEMORY_MMAP;
    523     dqbuf.m.planes = planes;
    524     dqbuf.length = 1;
    525     if (device_->Ioctl(VIDIOC_DQBUF, &dqbuf) != 0) {
    526       if (errno == EAGAIN) {
    527         // EAGAIN if we're just out of buffers to dequeue.
    528         break;
    529       }
    530       DPLOG(ERROR) << "Dequeue(): ioctl() failed: VIDIOC_DQBUF";
    531       NOTIFY_ERROR(kPlatformFailureError);
    532       return;
    533     }
    534     const bool key_frame = ((dqbuf.flags & V4L2_BUF_FLAG_KEYFRAME) != 0);
    535     OutputRecord& output_record = output_buffer_map_[dqbuf.index];
    536     DCHECK(output_record.at_device);
    537     DCHECK(output_record.buffer_ref.get());
    538 
    539     void* output_data = output_record.address;
    540     size_t output_size = dqbuf.m.planes[0].bytesused;
    541     // This shouldn't happen, but just in case. We should be able to recover
    542     // after next keyframe after showing some corruption.
    543     DCHECK_LE(output_size, output_buffer_byte_size_);
    544     if (output_size > output_buffer_byte_size_)
    545       output_size = output_buffer_byte_size_;
    546     uint8* target_data =
    547         reinterpret_cast<uint8*>(output_record.buffer_ref->shm->memory());
    548     if (output_format_fourcc_ == V4L2_PIX_FMT_H264) {
    549       if (stream_header_size_ == 0) {
    550         // Assume that the first buffer dequeued is the stream header.
    551         stream_header_size_ = output_size;
    552         stream_header_.reset(new uint8[stream_header_size_]);
    553         memcpy(stream_header_.get(), output_data, stream_header_size_);
    554       }
    555       if (key_frame &&
    556           output_buffer_byte_size_ - stream_header_size_ >= output_size) {
    557         // Insert stream header before every keyframe.
    558         memcpy(target_data, stream_header_.get(), stream_header_size_);
    559         memcpy(target_data + stream_header_size_, output_data, output_size);
    560         output_size += stream_header_size_;
    561       } else {
    562         memcpy(target_data, output_data, output_size);
    563       }
    564     } else {
    565       memcpy(target_data, output_data, output_size);
    566     }
    567 
    568     DVLOG(3) << "Dequeue(): returning "
    569                 "bitstream_buffer_id=" << output_record.buffer_ref->id
    570              << ", size=" << output_size << ", key_frame=" << key_frame;
    571     child_message_loop_proxy_->PostTask(
    572         FROM_HERE,
    573         base::Bind(&Client::BitstreamBufferReady,
    574                    client_,
    575                    output_record.buffer_ref->id,
    576                    output_size,
    577                    key_frame));
    578     output_record.at_device = false;
    579     output_record.buffer_ref.reset();
    580     free_output_buffers_.push_back(dqbuf.index);
    581     output_buffer_queued_count_--;
    582   }
    583 }
    584 
    585 bool V4L2VideoEncodeAccelerator::EnqueueInputRecord() {
    586   DVLOG(3) << "EnqueueInputRecord()";
    587   DCHECK(!free_input_buffers_.empty());
    588   DCHECK(!encoder_input_queue_.empty());
    589 
    590   // Enqueue an input (VIDEO_OUTPUT) buffer.
    591   scoped_refptr<media::VideoFrame> frame = encoder_input_queue_.front();
    592   const int index = free_input_buffers_.back();
    593   InputRecord& input_record = input_buffer_map_[index];
    594   DCHECK(!input_record.at_device);
    595   struct v4l2_buffer qbuf;
    596   struct v4l2_plane qbuf_planes[VIDEO_MAX_PLANES];
    597   memset(&qbuf, 0, sizeof(qbuf));
    598   memset(qbuf_planes, 0, sizeof(qbuf_planes));
    599   qbuf.index = index;
    600   qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    601   qbuf.m.planes = qbuf_planes;
    602 
    603   DCHECK_EQ(device_input_format_, frame->format());
    604   for (size_t i = 0; i < input_planes_count_; ++i) {
    605     qbuf.m.planes[i].bytesused =
    606         base::checked_cast<__u32>(media::VideoFrame::PlaneAllocationSize(
    607             frame->format(), i, input_allocated_size_));
    608 
    609     switch (input_memory_type_) {
    610       case V4L2_MEMORY_USERPTR:
    611         qbuf.m.planes[i].m.userptr =
    612             reinterpret_cast<unsigned long>(frame->data(i));
    613         DCHECK(qbuf.m.planes[i].m.userptr);
    614         break;
    615 
    616       case V4L2_MEMORY_DMABUF:
    617         qbuf.m.planes[i].m.fd = frame->dmabuf_fd(i);
    618         DCHECK_NE(qbuf.m.planes[i].m.fd, -1);
    619         break;
    620 
    621       default:
    622         NOTREACHED();
    623         return false;
    624     }
    625   }
    626 
    627   qbuf.memory = input_memory_type_;
    628   qbuf.length = input_planes_count_;
    629 
    630   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QBUF, &qbuf);
    631   input_record.at_device = true;
    632   input_record.frame = frame;
    633   encoder_input_queue_.pop_front();
    634   free_input_buffers_.pop_back();
    635   input_buffer_queued_count_++;
    636   return true;
    637 }
    638 
    639 bool V4L2VideoEncodeAccelerator::EnqueueOutputRecord() {
    640   DVLOG(3) << "EnqueueOutputRecord()";
    641   DCHECK(!free_output_buffers_.empty());
    642   DCHECK(!encoder_output_queue_.empty());
    643 
    644   // Enqueue an output (VIDEO_CAPTURE) buffer.
    645   linked_ptr<BitstreamBufferRef> output_buffer = encoder_output_queue_.back();
    646   const int index = free_output_buffers_.back();
    647   OutputRecord& output_record = output_buffer_map_[index];
    648   DCHECK(!output_record.at_device);
    649   DCHECK(!output_record.buffer_ref.get());
    650   struct v4l2_buffer qbuf;
    651   struct v4l2_plane qbuf_planes[1];
    652   memset(&qbuf, 0, sizeof(qbuf));
    653   memset(qbuf_planes, 0, sizeof(qbuf_planes));
    654   qbuf.index = index;
    655   qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    656   qbuf.memory = V4L2_MEMORY_MMAP;
    657   qbuf.m.planes = qbuf_planes;
    658   qbuf.length = 1;
    659   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QBUF, &qbuf);
    660   output_record.at_device = true;
    661   output_record.buffer_ref = output_buffer;
    662   encoder_output_queue_.pop_back();
    663   free_output_buffers_.pop_back();
    664   output_buffer_queued_count_++;
    665   return true;
    666 }
    667 
    668 bool V4L2VideoEncodeAccelerator::StartDevicePoll() {
    669   DVLOG(3) << "StartDevicePoll()";
    670   DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
    671   DCHECK(!device_poll_thread_.IsRunning());
    672 
    673   // Start up the device poll thread and schedule its first DevicePollTask().
    674   if (!device_poll_thread_.Start()) {
    675     DLOG(ERROR) << "StartDevicePoll(): Device thread failed to start";
    676     NOTIFY_ERROR(kPlatformFailureError);
    677     return false;
    678   }
    679   // Enqueue a poll task with no devices to poll on -- it will wait only on the
    680   // interrupt fd.
    681   device_poll_thread_.message_loop()->PostTask(
    682       FROM_HERE,
    683       base::Bind(&V4L2VideoEncodeAccelerator::DevicePollTask,
    684                  base::Unretained(this),
    685                  false));
    686 
    687   return true;
    688 }
    689 
    690 bool V4L2VideoEncodeAccelerator::StopDevicePoll() {
    691   DVLOG(3) << "StopDevicePoll()";
    692 
    693   // Signal the DevicePollTask() to stop, and stop the device poll thread.
    694   if (!device_->SetDevicePollInterrupt())
    695     return false;
    696   device_poll_thread_.Stop();
    697   // Clear the interrupt now, to be sure.
    698   if (!device_->ClearDevicePollInterrupt())
    699     return false;
    700 
    701   if (input_streamon_) {
    702     __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    703     IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_STREAMOFF, &type);
    704   }
    705   input_streamon_ = false;
    706 
    707   if (output_streamon_) {
    708     __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    709     IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_STREAMOFF, &type);
    710   }
    711   output_streamon_ = false;
    712 
    713   // Reset all our accounting info.
    714   encoder_input_queue_.clear();
    715   free_input_buffers_.clear();
    716   for (size_t i = 0; i < input_buffer_map_.size(); ++i) {
    717     InputRecord& input_record = input_buffer_map_[i];
    718     input_record.at_device = false;
    719     input_record.frame = NULL;
    720     free_input_buffers_.push_back(i);
    721   }
    722   input_buffer_queued_count_ = 0;
    723 
    724   free_output_buffers_.clear();
    725   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
    726     OutputRecord& output_record = output_buffer_map_[i];
    727     output_record.at_device = false;
    728     output_record.buffer_ref.reset();
    729     free_output_buffers_.push_back(i);
    730   }
    731   output_buffer_queued_count_ = 0;
    732 
    733   encoder_output_queue_.clear();
    734 
    735   DVLOG(3) << "StopDevicePoll(): device poll stopped";
    736   return true;
    737 }
    738 
    739 void V4L2VideoEncodeAccelerator::DevicePollTask(bool poll_device) {
    740   DVLOG(3) << "DevicePollTask()";
    741   DCHECK_EQ(device_poll_thread_.message_loop(), base::MessageLoop::current());
    742 
    743   bool event_pending;
    744   if (!device_->Poll(poll_device, &event_pending)) {
    745     NOTIFY_ERROR(kPlatformFailureError);
    746     return;
    747   }
    748 
    749   // All processing should happen on ServiceDeviceTask(), since we shouldn't
    750   // touch encoder state from this thread.
    751   encoder_thread_.message_loop()->PostTask(
    752       FROM_HERE,
    753       base::Bind(&V4L2VideoEncodeAccelerator::ServiceDeviceTask,
    754                  base::Unretained(this)));
    755 }
    756 
    757 void V4L2VideoEncodeAccelerator::NotifyError(Error error) {
    758   DVLOG(1) << "NotifyError(): error=" << error;
    759 
    760   if (!child_message_loop_proxy_->BelongsToCurrentThread()) {
    761     child_message_loop_proxy_->PostTask(
    762         FROM_HERE,
    763         base::Bind(
    764             &V4L2VideoEncodeAccelerator::NotifyError, weak_this_, error));
    765     return;
    766   }
    767 
    768   if (client_) {
    769     client_->NotifyError(error);
    770     client_ptr_factory_.reset();
    771   }
    772 }
    773 
    774 void V4L2VideoEncodeAccelerator::SetEncoderState(State state) {
    775   DVLOG(3) << "SetEncoderState(): state=" << state;
    776 
    777   // We can touch encoder_state_ only if this is the encoder thread or the
    778   // encoder thread isn't running.
    779   if (encoder_thread_.message_loop() != NULL &&
    780       encoder_thread_.message_loop() != base::MessageLoop::current()) {
    781     encoder_thread_.message_loop()->PostTask(
    782         FROM_HERE,
    783         base::Bind(&V4L2VideoEncodeAccelerator::SetEncoderState,
    784                    base::Unretained(this),
    785                    state));
    786   } else {
    787     encoder_state_ = state;
    788   }
    789 }
    790 
    791 void V4L2VideoEncodeAccelerator::RequestEncodingParametersChangeTask(
    792     uint32 bitrate,
    793     uint32 framerate) {
    794   DVLOG(3) << "RequestEncodingParametersChangeTask(): bitrate=" << bitrate
    795            << ", framerate=" << framerate;
    796   DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
    797 
    798   if (bitrate < 1)
    799     bitrate = 1;
    800   if (framerate < 1)
    801     framerate = 1;
    802 
    803   struct v4l2_ext_control ctrls[1];
    804   struct v4l2_ext_controls control;
    805   memset(&ctrls, 0, sizeof(ctrls));
    806   memset(&control, 0, sizeof(control));
    807   ctrls[0].id = V4L2_CID_MPEG_VIDEO_BITRATE;
    808   ctrls[0].value = bitrate;
    809   control.ctrl_class = V4L2_CTRL_CLASS_MPEG;
    810   control.count = arraysize(ctrls);
    811   control.controls = ctrls;
    812   IOCTL_OR_ERROR_RETURN(VIDIOC_S_EXT_CTRLS, &control);
    813 
    814   struct v4l2_streamparm parms;
    815   memset(&parms, 0, sizeof(parms));
    816   parms.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    817   // Note that we are provided "frames per second" but V4L2 expects "time per
    818   // frame"; hence we provide the reciprocal of the framerate here.
    819   parms.parm.output.timeperframe.numerator = 1;
    820   parms.parm.output.timeperframe.denominator = framerate;
    821   IOCTL_OR_ERROR_RETURN(VIDIOC_S_PARM, &parms);
    822 }
    823 
    824 bool V4L2VideoEncodeAccelerator::SetOutputFormat(
    825     media::VideoCodecProfile output_profile) {
    826   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
    827   DCHECK(!input_streamon_);
    828   DCHECK(!output_streamon_);
    829 
    830   output_format_fourcc_ =
    831       V4L2Device::VideoCodecProfileToV4L2PixFmt(output_profile);
    832   if (!output_format_fourcc_) {
    833     DLOG(ERROR) << "Initialize(): invalid output_profile=" << output_profile;
    834     return false;
    835   }
    836 
    837   output_buffer_byte_size_ = kOutputBufferSize;
    838 
    839   struct v4l2_format format;
    840   memset(&format, 0, sizeof(format));
    841   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    842   format.fmt.pix_mp.width = visible_size_.width();
    843   format.fmt.pix_mp.height = visible_size_.height();
    844   format.fmt.pix_mp.pixelformat = output_format_fourcc_;
    845   format.fmt.pix_mp.plane_fmt[0].sizeimage =
    846       base::checked_cast<__u32>(output_buffer_byte_size_);
    847   format.fmt.pix_mp.num_planes = 1;
    848   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
    849 
    850   // Device might have adjusted the required output size.
    851   size_t adjusted_output_buffer_size =
    852       base::checked_cast<size_t>(format.fmt.pix_mp.plane_fmt[0].sizeimage);
    853   DCHECK_GE(adjusted_output_buffer_size, output_buffer_byte_size_);
    854   output_buffer_byte_size_ = adjusted_output_buffer_size;
    855 
    856   return true;
    857 }
    858 
    859 bool V4L2VideoEncodeAccelerator::NegotiateInputFormat(
    860     media::VideoFrame::Format input_format) {
    861   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
    862   DCHECK(!input_streamon_);
    863   DCHECK(!output_streamon_);
    864 
    865   device_input_format_ = media::VideoFrame::UNKNOWN;
    866   input_planes_count_ = 0;
    867 
    868   uint32 input_format_fourcc =
    869       V4L2Device::VideoFrameFormatToV4L2PixFmt(input_format);
    870   if (!input_format_fourcc) {
    871     DVLOG(1) << "Unsupported input format";
    872     return false;
    873   }
    874 
    875   size_t input_planes_count = media::VideoFrame::NumPlanes(input_format);
    876   DCHECK_LE(input_planes_count, static_cast<size_t>(VIDEO_MAX_PLANES));
    877 
    878   // First see if we the device can use the provided input_format directly.
    879   struct v4l2_format format;
    880   memset(&format, 0, sizeof(format));
    881   format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    882   format.fmt.pix_mp.width = visible_size_.width();
    883   format.fmt.pix_mp.height = visible_size_.height();
    884   format.fmt.pix_mp.pixelformat = input_format_fourcc;
    885   format.fmt.pix_mp.num_planes = input_planes_count;
    886   if (device_->Ioctl(VIDIOC_S_FMT, &format) != 0) {
    887     // Error or format unsupported by device, try to negotiate a fallback.
    888     input_format_fourcc = device_->PreferredInputFormat();
    889     input_format =
    890         V4L2Device::V4L2PixFmtToVideoFrameFormat(input_format_fourcc);
    891     if (input_format == media::VideoFrame::UNKNOWN)
    892       return false;
    893 
    894     input_planes_count = media::VideoFrame::NumPlanes(input_format);
    895     DCHECK_LE(input_planes_count, static_cast<size_t>(VIDEO_MAX_PLANES));
    896 
    897     // Device might have adjusted parameters, reset them along with the format.
    898     memset(&format, 0, sizeof(format));
    899     format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    900     format.fmt.pix_mp.width = visible_size_.width();
    901     format.fmt.pix_mp.height = visible_size_.height();
    902     format.fmt.pix_mp.pixelformat = input_format_fourcc;
    903     format.fmt.pix_mp.num_planes = input_planes_count;
    904     IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
    905     DCHECK_EQ(format.fmt.pix_mp.num_planes, input_planes_count);
    906   }
    907 
    908   // Take device-adjusted sizes for allocated size.
    909   input_allocated_size_ = V4L2Device::CodedSizeFromV4L2Format(format);
    910   DCHECK(gfx::Rect(input_allocated_size_).Contains(gfx::Rect(visible_size_)));
    911 
    912   device_input_format_ = input_format;
    913   input_planes_count_ = input_planes_count;
    914   return true;
    915 }
    916 
    917 bool V4L2VideoEncodeAccelerator::SetFormats(
    918     media::VideoFrame::Format input_format,
    919     media::VideoCodecProfile output_profile) {
    920   DVLOG(3) << "SetFormats()";
    921   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
    922   DCHECK(!input_streamon_);
    923   DCHECK(!output_streamon_);
    924 
    925   if (!SetOutputFormat(output_profile))
    926     return false;
    927 
    928   if (!NegotiateInputFormat(input_format))
    929     return false;
    930 
    931   struct v4l2_crop crop;
    932   memset(&crop, 0, sizeof(crop));
    933   crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
    934   crop.c.left = 0;
    935   crop.c.top = 0;
    936   crop.c.width = visible_size_.width();
    937   crop.c.height = visible_size_.height();
    938   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CROP, &crop);
    939 
    940   return true;
    941 }
    942 
    943 bool V4L2VideoEncodeAccelerator::InitControls() {
    944   struct v4l2_ext_control ctrls[9];
    945   struct v4l2_ext_controls control;
    946   memset(&ctrls, 0, sizeof(ctrls));
    947   memset(&control, 0, sizeof(control));
    948   // No B-frames, for lowest decoding latency.
    949   ctrls[0].id = V4L2_CID_MPEG_VIDEO_B_FRAMES;
    950   ctrls[0].value = 0;
    951   // Enable frame-level bitrate control.
    952   ctrls[1].id = V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE;
    953   ctrls[1].value = 1;
    954   // Enable "tight" bitrate mode. For this to work properly, frame- and mb-level
    955   // bitrate controls have to be enabled as well.
    956   ctrls[2].id = V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF;
    957   ctrls[2].value = 1;
    958   // Force bitrate control to average over a GOP (for tight bitrate
    959   // tolerance).
    960   ctrls[3].id = V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT;
    961   ctrls[3].value = 1;
    962   // Quantization parameter maximum value (for variable bitrate control).
    963   ctrls[4].id = V4L2_CID_MPEG_VIDEO_H264_MAX_QP;
    964   ctrls[4].value = 51;
    965   // Separate stream header so we can cache it and insert into the stream.
    966   ctrls[5].id = V4L2_CID_MPEG_VIDEO_HEADER_MODE;
    967   ctrls[5].value = V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE;
    968   // Enable macroblock-level bitrate control.
    969   ctrls[6].id = V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE;
    970   ctrls[6].value = 1;
    971   // Use H.264 level 4.0 to match the supported max resolution.
    972   ctrls[7].id = V4L2_CID_MPEG_VIDEO_H264_LEVEL;
    973   ctrls[7].value = V4L2_MPEG_VIDEO_H264_LEVEL_4_0;
    974   // Disable periodic key frames.
    975   ctrls[8].id = V4L2_CID_MPEG_VIDEO_GOP_SIZE;
    976   ctrls[8].value = 0;
    977   control.ctrl_class = V4L2_CTRL_CLASS_MPEG;
    978   control.count = arraysize(ctrls);
    979   control.controls = ctrls;
    980   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_EXT_CTRLS, &control);
    981 
    982   return true;
    983 }
    984 
    985 bool V4L2VideoEncodeAccelerator::CreateInputBuffers() {
    986   DVLOG(3) << "CreateInputBuffers()";
    987   // This function runs on encoder_thread_ after output buffers have been
    988   // provided by the client.
    989   DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
    990   DCHECK(!input_streamon_);
    991 
    992   struct v4l2_requestbuffers reqbufs;
    993   memset(&reqbufs, 0, sizeof(reqbufs));
    994   // Driver will modify to the appropriate number of buffers.
    995   reqbufs.count = 1;
    996   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    997   // TODO(posciak): Once we start doing zero-copy, we should decide based on
    998   // the current pipeline setup which memory type to use. This should probably
    999   // be decided based on an argument to Initialize().
   1000   if (image_processor_.get())
   1001     input_memory_type_ = V4L2_MEMORY_DMABUF;
   1002   else
   1003     input_memory_type_ = V4L2_MEMORY_USERPTR;
   1004 
   1005   reqbufs.memory = input_memory_type_;
   1006   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
   1007 
   1008   DCHECK(input_buffer_map_.empty());
   1009   input_buffer_map_.resize(reqbufs.count);
   1010   for (size_t i = 0; i < input_buffer_map_.size(); ++i)
   1011     free_input_buffers_.push_back(i);
   1012 
   1013   return true;
   1014 }
   1015 
   1016 bool V4L2VideoEncodeAccelerator::CreateOutputBuffers() {
   1017   DVLOG(3) << "CreateOutputBuffers()";
   1018   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   1019   DCHECK(!output_streamon_);
   1020 
   1021   struct v4l2_requestbuffers reqbufs;
   1022   memset(&reqbufs, 0, sizeof(reqbufs));
   1023   reqbufs.count = kOutputBufferCount;
   1024   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   1025   reqbufs.memory = V4L2_MEMORY_MMAP;
   1026   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
   1027 
   1028   DCHECK(output_buffer_map_.empty());
   1029   output_buffer_map_.resize(reqbufs.count);
   1030   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
   1031     struct v4l2_plane planes[1];
   1032     struct v4l2_buffer buffer;
   1033     memset(&buffer, 0, sizeof(buffer));
   1034     memset(planes, 0, sizeof(planes));
   1035     buffer.index = i;
   1036     buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   1037     buffer.memory = V4L2_MEMORY_MMAP;
   1038     buffer.m.planes = planes;
   1039     buffer.length = arraysize(planes);
   1040     IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYBUF, &buffer);
   1041     void* address = device_->Mmap(NULL,
   1042                                   buffer.m.planes[0].length,
   1043                                   PROT_READ | PROT_WRITE,
   1044                                   MAP_SHARED,
   1045                                   buffer.m.planes[0].m.mem_offset);
   1046     if (address == MAP_FAILED) {
   1047       DPLOG(ERROR) << "CreateOutputBuffers(): mmap() failed";
   1048       return false;
   1049     }
   1050     output_buffer_map_[i].address = address;
   1051     output_buffer_map_[i].length = buffer.m.planes[0].length;
   1052     free_output_buffers_.push_back(i);
   1053   }
   1054 
   1055   return true;
   1056 }
   1057 
   1058 void V4L2VideoEncodeAccelerator::DestroyInputBuffers() {
   1059   DVLOG(3) << "DestroyInputBuffers()";
   1060   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   1061   DCHECK(!input_streamon_);
   1062 
   1063   struct v4l2_requestbuffers reqbufs;
   1064   memset(&reqbufs, 0, sizeof(reqbufs));
   1065   reqbufs.count = 0;
   1066   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   1067   reqbufs.memory = input_memory_type_;
   1068   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
   1069 
   1070   input_buffer_map_.clear();
   1071   free_input_buffers_.clear();
   1072 }
   1073 
   1074 void V4L2VideoEncodeAccelerator::DestroyOutputBuffers() {
   1075   DVLOG(3) << "DestroyOutputBuffers()";
   1076   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   1077   DCHECK(!output_streamon_);
   1078 
   1079   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
   1080     if (output_buffer_map_[i].address != NULL)
   1081       device_->Munmap(output_buffer_map_[i].address,
   1082                       output_buffer_map_[i].length);
   1083   }
   1084 
   1085   struct v4l2_requestbuffers reqbufs;
   1086   memset(&reqbufs, 0, sizeof(reqbufs));
   1087   reqbufs.count = 0;
   1088   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   1089   reqbufs.memory = V4L2_MEMORY_MMAP;
   1090   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
   1091 
   1092   output_buffer_map_.clear();
   1093   free_output_buffers_.clear();
   1094 }
   1095 
   1096 }  // namespace content
   1097