| // 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 <errno.h> |
| #include <fcntl.h> |
| #include <linux/videodev2.h> |
| #include <poll.h> |
| #include <string.h> |
| #include <sys/eventfd.h> |
| #include <sys/ioctl.h> |
| #include <sys/mman.h> |
| |
| #include "base/bind.h" |
| #include "base/bind_helpers.h" |
| #include "base/callback.h" |
| #include "base/numerics/safe_conversions.h" |
| #include "base/single_thread_task_runner.h" |
| #include "base/threading/thread_task_runner_handle.h" |
| #include "media/gpu/v4l2_image_processor.h" |
| |
| #define IOCTL_OR_ERROR_RETURN_VALUE(type, arg, value, type_str) \ |
| do { \ |
| if (device_->Ioctl(type, arg) != 0) { \ |
| PLOG(ERROR) << __func__ << "(): ioctl() failed: " << type_str; \ |
| return value; \ |
| } \ |
| } while (0) |
| |
| #define IOCTL_OR_ERROR_RETURN(type, arg) \ |
| IOCTL_OR_ERROR_RETURN_VALUE(type, arg, ((void)0), #type) |
| |
| #define IOCTL_OR_ERROR_RETURN_FALSE(type, arg) \ |
| IOCTL_OR_ERROR_RETURN_VALUE(type, arg, false, #type) |
| |
| #define IOCTL_OR_LOG_ERROR(type, arg) \ |
| do { \ |
| if (device_->Ioctl(type, arg) != 0) \ |
| PLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type; \ |
| } while (0) |
| |
| namespace media { |
| |
| V4L2ImageProcessor::InputRecord::InputRecord() : at_device(false) {} |
| |
| V4L2ImageProcessor::InputRecord::~InputRecord() {} |
| |
| V4L2ImageProcessor::OutputRecord::OutputRecord() : at_device(false) {} |
| |
| V4L2ImageProcessor::OutputRecord::~OutputRecord() {} |
| |
| V4L2ImageProcessor::JobRecord::JobRecord() : output_buffer_index(-1) {} |
| |
| V4L2ImageProcessor::JobRecord::~JobRecord() {} |
| |
| V4L2ImageProcessor::V4L2ImageProcessor(const scoped_refptr<V4L2Device>& device) |
| : input_format_(PIXEL_FORMAT_UNKNOWN), |
| output_format_(PIXEL_FORMAT_UNKNOWN), |
| input_memory_type_(V4L2_MEMORY_USERPTR), |
| output_memory_type_(V4L2_MEMORY_MMAP), |
| input_format_fourcc_(0), |
| output_format_fourcc_(0), |
| input_planes_count_(0), |
| output_planes_count_(0), |
| child_task_runner_(base::ThreadTaskRunnerHandle::Get()), |
| device_(device), |
| device_thread_("V4L2ImageProcessorThread"), |
| device_poll_thread_("V4L2ImageProcessorDevicePollThread"), |
| input_streamon_(false), |
| input_buffer_queued_count_(0), |
| output_streamon_(false), |
| output_buffer_queued_count_(0), |
| num_buffers_(0), |
| weak_this_factory_(this) { |
| weak_this_ = weak_this_factory_.GetWeakPtr(); |
| } |
| |
| V4L2ImageProcessor::~V4L2ImageProcessor() { |
| DCHECK(child_task_runner_->BelongsToCurrentThread()); |
| DCHECK(!device_thread_.IsRunning()); |
| DCHECK(!device_poll_thread_.IsRunning()); |
| |
| DestroyInputBuffers(); |
| DestroyOutputBuffers(); |
| } |
| |
| void V4L2ImageProcessor::NotifyError() { |
| LOG(ERROR) << __func__; |
| DCHECK(!child_task_runner_->BelongsToCurrentThread()); |
| child_task_runner_->PostTask( |
| FROM_HERE, base::Bind(&V4L2ImageProcessor::NotifyErrorOnChildThread, |
| weak_this_, error_cb_)); |
| } |
| |
| void V4L2ImageProcessor::NotifyErrorOnChildThread( |
| const base::Closure& error_cb) { |
| DCHECK(child_task_runner_->BelongsToCurrentThread()); |
| error_cb_.Run(); |
| } |
| |
| bool V4L2ImageProcessor::Initialize(VideoPixelFormat input_format, |
| VideoPixelFormat output_format, |
| v4l2_memory input_memory_type, |
| v4l2_memory output_memory_type, |
| gfx::Size input_visible_size, |
| gfx::Size input_allocated_size, |
| gfx::Size output_visible_size, |
| gfx::Size output_allocated_size, |
| int num_buffers, |
| const base::Closure& error_cb) { |
| DCHECK(!error_cb.is_null()); |
| DCHECK_GT(num_buffers, 0); |
| DCHECK(input_memory_type == V4L2_MEMORY_USERPTR || |
| input_memory_type == V4L2_MEMORY_DMABUF); |
| DCHECK(output_memory_type == V4L2_MEMORY_MMAP || |
| output_memory_type == V4L2_MEMORY_DMABUF); |
| error_cb_ = error_cb; |
| |
| input_format_ = input_format; |
| output_format_ = output_format; |
| input_format_fourcc_ = V4L2Device::VideoPixelFormatToV4L2PixFmt(input_format); |
| output_format_fourcc_ = |
| V4L2Device::VideoPixelFormatToV4L2PixFmt(output_format); |
| num_buffers_ = num_buffers; |
| |
| if (!input_format_fourcc_ || !output_format_fourcc_) { |
| LOG(ERROR) << "Unrecognized format(s)"; |
| return false; |
| } |
| |
| input_memory_type_ = input_memory_type; |
| output_memory_type_ = output_memory_type; |
| input_visible_size_ = input_visible_size; |
| input_allocated_size_ = input_allocated_size; |
| output_visible_size_ = output_visible_size; |
| output_allocated_size_ = output_allocated_size; |
| |
| if (!device_->Open(V4L2Device::Type::kImageProcessor, input_format_fourcc_)) { |
| LOG(ERROR) << "Failed to open device for input format: " |
| << VideoPixelFormatToString(input_format) |
| << " fourcc: " << std::hex << "0x" << input_format_fourcc_; |
| return false; |
| } |
| |
| // Capabilities check. |
| struct v4l2_capability caps; |
| memset(&caps, 0, sizeof(caps)); |
| const __u32 kCapsRequired = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING; |
| IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYCAP, &caps); |
| if ((caps.capabilities & kCapsRequired) != kCapsRequired) { |
| LOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP: " |
| << "caps check failed: 0x" << std::hex << caps.capabilities; |
| return false; |
| } |
| |
| if (!CreateInputBuffers() || !CreateOutputBuffers()) |
| return false; |
| |
| if (!device_thread_.Start()) { |
| LOG(ERROR) << "Initialize(): device thread failed to start"; |
| return false; |
| } |
| |
| // StartDevicePoll will NotifyError on failure. |
| device_thread_.task_runner()->PostTask( |
| FROM_HERE, |
| base::Bind(&V4L2ImageProcessor::StartDevicePoll, base::Unretained(this))); |
| |
| DVLOG(1) << "V4L2ImageProcessor initialized for " |
| << " input_format:" << VideoPixelFormatToString(input_format) |
| << ", output_format:" << VideoPixelFormatToString(output_format) |
| << ", input_visible_size: " << input_visible_size.ToString() |
| << ", input_allocated_size: " << input_allocated_size_.ToString() |
| << ", input_planes_count: " << input_planes_count_ |
| << ", output_visible_size: " << output_visible_size.ToString() |
| << ", output_allocated_size: " << output_allocated_size_.ToString() |
| << ", output_planes_count: " << output_planes_count_; |
| |
| return true; |
| } |
| |
| std::vector<base::ScopedFD> V4L2ImageProcessor::GetDmabufsForOutputBuffer( |
| int output_buffer_index) { |
| DCHECK_GE(output_buffer_index, 0); |
| DCHECK_LT(output_buffer_index, num_buffers_); |
| return device_->GetDmabufsForV4L2Buffer(output_buffer_index, |
| output_planes_count_, |
| V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); |
| } |
| |
| // static |
| bool V4L2ImageProcessor::IsSupported() { |
| scoped_refptr<V4L2Device> device = V4L2Device::Create(); |
| if (!device) |
| return false; |
| |
| return device->IsImageProcessingSupported(); |
| } |
| |
| // static |
| std::vector<uint32_t> V4L2ImageProcessor::GetSupportedInputFormats() { |
| scoped_refptr<V4L2Device> device = V4L2Device::Create(); |
| if (!device) |
| return std::vector<uint32_t>(); |
| |
| return device->GetSupportedImageProcessorPixelformats( |
| V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); |
| } |
| |
| // static |
| std::vector<uint32_t> V4L2ImageProcessor::GetSupportedOutputFormats() { |
| scoped_refptr<V4L2Device> device = V4L2Device::Create(); |
| if (!device) |
| return std::vector<uint32_t>(); |
| |
| return device->GetSupportedImageProcessorPixelformats( |
| V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); |
| } |
| |
| // static |
| bool V4L2ImageProcessor::TryOutputFormat(uint32_t input_pixelformat, |
| uint32_t output_pixelformat, |
| gfx::Size* size, |
| size_t* num_planes) { |
| DVLOG(1) << __func__ << ": size=" << size->ToString(); |
| scoped_refptr<V4L2Device> device = V4L2Device::Create(); |
| if (!device || |
| !device->Open(V4L2Device::Type::kImageProcessor, input_pixelformat)) |
| return false; |
| |
| struct v4l2_format format; |
| memset(&format, 0, sizeof(format)); |
| format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; |
| format.fmt.pix_mp.width = size->width(); |
| format.fmt.pix_mp.height = size->height(); |
| format.fmt.pix_mp.pixelformat = output_pixelformat; |
| if (device->Ioctl(VIDIOC_TRY_FMT, &format) != 0) |
| return false; |
| |
| *num_planes = format.fmt.pix_mp.num_planes; |
| *size = V4L2Device::CodedSizeFromV4L2Format(format); |
| DVLOG(1) << __func__ << ": adjusted output coded size=" << size->ToString() |
| << ", num_planes=" << *num_planes; |
| return true; |
| } |
| |
| bool V4L2ImageProcessor::Process(const scoped_refptr<VideoFrame>& frame, |
| int output_buffer_index, |
| std::vector<base::ScopedFD> output_dmabuf_fds, |
| const FrameReadyCB& cb) { |
| DVLOG(3) << __func__ << ": ts=" << frame->timestamp().InMilliseconds(); |
| size_t expected_num_fds = |
| (output_memory_type_ == V4L2_MEMORY_DMABUF ? output_planes_count_ : 0); |
| if (expected_num_fds != output_dmabuf_fds.size()) { |
| LOG(ERROR) << __func__ << ": wrong number of output fds. Expected " |
| << expected_num_fds << ", actual " << output_dmabuf_fds.size(); |
| return false; |
| } |
| |
| std::unique_ptr<JobRecord> job_record(new JobRecord()); |
| job_record->frame = frame; |
| job_record->output_buffer_index = output_buffer_index; |
| job_record->output_dmabuf_fds = std::move(output_dmabuf_fds); |
| job_record->ready_cb = cb; |
| |
| device_thread_.task_runner()->PostTask( |
| FROM_HERE, base::Bind(&V4L2ImageProcessor::ProcessTask, |
| base::Unretained(this), base::Passed(&job_record))); |
| return true; |
| } |
| |
| void V4L2ImageProcessor::ProcessTask(std::unique_ptr<JobRecord> job_record) { |
| int index = job_record->output_buffer_index; |
| DVLOG(3) << __func__ << ": Reusing output buffer, index=" << index; |
| DCHECK(device_thread_.task_runner()->BelongsToCurrentThread()); |
| DCHECK(output_buffer_map_[index].dmabuf_fds.empty()); |
| output_buffer_map_[index].dmabuf_fds = |
| std::move(job_record->output_dmabuf_fds); |
| |
| EnqueueOutput(index); |
| input_queue_.push(make_linked_ptr(job_record.release())); |
| EnqueueInput(); |
| } |
| |
| bool V4L2ImageProcessor::Reset() { |
| DVLOG(3) << __func__; |
| DCHECK(child_task_runner_->BelongsToCurrentThread()); |
| DCHECK(device_thread_.IsRunning()); |
| |
| weak_this_factory_.InvalidateWeakPtrs(); |
| device_thread_.task_runner()->PostTask( |
| FROM_HERE, |
| base::Bind(&V4L2ImageProcessor::StopDevicePoll, base::Unretained(this))); |
| device_thread_.Stop(); |
| |
| weak_this_ = weak_this_factory_.GetWeakPtr(); |
| if (!device_thread_.Start()) { |
| LOG(ERROR) << "Reset(): device thread failed to start"; |
| return false; |
| } |
| device_thread_.task_runner()->PostTask( |
| FROM_HERE, |
| base::Bind(&V4L2ImageProcessor::StartDevicePoll, base::Unretained(this))); |
| return true; |
| } |
| |
| void V4L2ImageProcessor::Destroy() { |
| DVLOG(3) << __func__; |
| DCHECK(child_task_runner_->BelongsToCurrentThread()); |
| |
| weak_this_factory_.InvalidateWeakPtrs(); |
| |
| // If the device thread is running, destroy using posted task. |
| if (device_thread_.IsRunning()) { |
| device_thread_.task_runner()->PostTask( |
| FROM_HERE, base::Bind(&V4L2ImageProcessor::StopDevicePoll, |
| base::Unretained(this))); |
| // Wait for tasks to finish/early-exit. |
| device_thread_.Stop(); |
| } else { |
| // Otherwise DestroyTask() is not needed. |
| DCHECK(!device_poll_thread_.IsRunning()); |
| } |
| |
| delete this; |
| } |
| |
| bool V4L2ImageProcessor::CreateInputBuffers() { |
| DVLOG(3) << __func__; |
| DCHECK(child_task_runner_->BelongsToCurrentThread()); |
| DCHECK(!input_streamon_); |
| |
| struct v4l2_control control; |
| memset(&control, 0, sizeof(control)); |
| control.id = V4L2_CID_ROTATE; |
| control.value = 0; |
| IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CTRL, &control); |
| |
| memset(&control, 0, sizeof(control)); |
| control.id = V4L2_CID_HFLIP; |
| control.value = 0; |
| IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CTRL, &control); |
| |
| memset(&control, 0, sizeof(control)); |
| control.id = V4L2_CID_VFLIP; |
| control.value = 0; |
| IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CTRL, &control); |
| |
| memset(&control, 0, sizeof(control)); |
| control.id = V4L2_CID_ALPHA_COMPONENT; |
| control.value = 255; |
| IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CTRL, &control); |
| |
| struct v4l2_format format; |
| memset(&format, 0, sizeof(format)); |
| format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; |
| format.fmt.pix_mp.width = input_allocated_size_.width(); |
| format.fmt.pix_mp.height = input_allocated_size_.height(); |
| format.fmt.pix_mp.pixelformat = input_format_fourcc_; |
| IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format); |
| |
| input_planes_count_ = format.fmt.pix_mp.num_planes; |
| DCHECK_LE(input_planes_count_, static_cast<size_t>(VIDEO_MAX_PLANES)); |
| input_allocated_size_ = V4L2Device::CodedSizeFromV4L2Format(format); |
| DCHECK(gfx::Rect(input_allocated_size_) |
| .Contains(gfx::Rect(input_visible_size_))); |
| |
| struct v4l2_crop crop; |
| memset(&crop, 0, sizeof(crop)); |
| crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; |
| crop.c.left = 0; |
| crop.c.top = 0; |
| crop.c.width = base::checked_cast<__u32>(input_visible_size_.width()); |
| crop.c.height = base::checked_cast<__u32>(input_visible_size_.height()); |
| IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CROP, &crop); |
| |
| struct v4l2_requestbuffers reqbufs; |
| memset(&reqbufs, 0, sizeof(reqbufs)); |
| reqbufs.count = num_buffers_; |
| reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; |
| reqbufs.memory = input_memory_type_; |
| IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs); |
| if (static_cast<int>(reqbufs.count) != num_buffers_) { |
| LOG(ERROR) << "Failed to allocate input buffers. reqbufs.count=" |
| << reqbufs.count << ", num_buffers=" << num_buffers_; |
| return false; |
| } |
| |
| DCHECK(input_buffer_map_.empty()); |
| input_buffer_map_.resize(reqbufs.count); |
| |
| for (size_t i = 0; i < input_buffer_map_.size(); ++i) |
| free_input_buffers_.push_back(i); |
| |
| return true; |
| } |
| |
| bool V4L2ImageProcessor::CreateOutputBuffers() { |
| DVLOG(3) << __func__; |
| DCHECK(child_task_runner_->BelongsToCurrentThread()); |
| DCHECK(!output_streamon_); |
| |
| struct v4l2_format format; |
| memset(&format, 0, sizeof(format)); |
| format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; |
| format.fmt.pix_mp.width = output_allocated_size_.width(); |
| format.fmt.pix_mp.height = output_allocated_size_.height(); |
| format.fmt.pix_mp.pixelformat = output_format_fourcc_; |
| IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format); |
| |
| output_planes_count_ = format.fmt.pix_mp.num_planes; |
| DCHECK_LE(output_planes_count_, static_cast<size_t>(VIDEO_MAX_PLANES)); |
| gfx::Size adjusted_allocated_size = |
| V4L2Device::CodedSizeFromV4L2Format(format); |
| DCHECK(gfx::Rect(adjusted_allocated_size) |
| .Contains(gfx::Rect(output_allocated_size_))); |
| output_allocated_size_ = adjusted_allocated_size; |
| |
| struct v4l2_crop crop; |
| memset(&crop, 0, sizeof(crop)); |
| crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; |
| crop.c.left = 0; |
| crop.c.top = 0; |
| crop.c.width = base::checked_cast<__u32>(output_visible_size_.width()); |
| crop.c.height = base::checked_cast<__u32>(output_visible_size_.height()); |
| IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CROP, &crop); |
| |
| struct v4l2_requestbuffers reqbufs; |
| memset(&reqbufs, 0, sizeof(reqbufs)); |
| reqbufs.count = num_buffers_; |
| reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; |
| reqbufs.memory = output_memory_type_; |
| IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs); |
| if (static_cast<int>(reqbufs.count) != num_buffers_) { |
| LOG(ERROR) << "Failed to allocate output buffers. reqbufs.count=" |
| << reqbufs.count << ", num_buffers=" << num_buffers_; |
| return false; |
| } |
| |
| DCHECK(output_buffer_map_.empty()); |
| output_buffer_map_.resize(reqbufs.count); |
| |
| return true; |
| } |
| |
| void V4L2ImageProcessor::DestroyInputBuffers() { |
| DCHECK(child_task_runner_->BelongsToCurrentThread()); |
| DCHECK(!input_streamon_); |
| |
| struct v4l2_requestbuffers reqbufs; |
| memset(&reqbufs, 0, sizeof(reqbufs)); |
| reqbufs.count = 0; |
| reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; |
| reqbufs.memory = input_memory_type_; |
| IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs); |
| |
| input_buffer_map_.clear(); |
| free_input_buffers_.clear(); |
| } |
| |
| void V4L2ImageProcessor::DestroyOutputBuffers() { |
| DCHECK(child_task_runner_->BelongsToCurrentThread()); |
| DCHECK(!output_streamon_); |
| |
| struct v4l2_requestbuffers reqbufs; |
| memset(&reqbufs, 0, sizeof(reqbufs)); |
| reqbufs.count = 0; |
| reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; |
| reqbufs.memory = output_memory_type_; |
| IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs); |
| |
| output_buffer_map_.clear(); |
| } |
| |
| void V4L2ImageProcessor::DevicePollTask(bool poll_device) { |
| DCHECK(device_poll_thread_.task_runner()->BelongsToCurrentThread()); |
| |
| bool event_pending; |
| if (!device_->Poll(poll_device, &event_pending)) { |
| NotifyError(); |
| return; |
| } |
| |
| // All processing should happen on ServiceDeviceTask(), since we shouldn't |
| // touch processor state from this thread. |
| device_thread_.task_runner()->PostTask( |
| FROM_HERE, base::Bind(&V4L2ImageProcessor::ServiceDeviceTask, |
| base::Unretained(this))); |
| } |
| |
| void V4L2ImageProcessor::ServiceDeviceTask() { |
| DCHECK(device_thread_.task_runner()->BelongsToCurrentThread()); |
| // ServiceDeviceTask() should only ever be scheduled from DevicePollTask(), |
| // so either: |
| // * device_poll_thread_ is running normally |
| // * device_poll_thread_ scheduled us, but then a DestroyTask() shut it down, |
| // in which case we should early-out. |
| if (!device_poll_thread_.message_loop()) |
| return; |
| |
| Dequeue(); |
| EnqueueInput(); |
| |
| if (!device_->ClearDevicePollInterrupt()) { |
| NotifyError(); |
| return; |
| } |
| |
| bool poll_device = |
| (input_buffer_queued_count_ > 0 || output_buffer_queued_count_ > 0); |
| |
| device_poll_thread_.task_runner()->PostTask( |
| FROM_HERE, base::Bind(&V4L2ImageProcessor::DevicePollTask, |
| base::Unretained(this), poll_device)); |
| |
| DVLOG(2) << __func__ << ": buffer counts: INPUT[" << input_queue_.size() |
| << "] => DEVICE[" << free_input_buffers_.size() << "+" |
| << input_buffer_queued_count_ << "/" << input_buffer_map_.size() |
| << "->" << output_buffer_map_.size() - output_buffer_queued_count_ |
| << "+" << output_buffer_queued_count_ << "/" |
| << output_buffer_map_.size() << "]"; |
| } |
| |
| void V4L2ImageProcessor::EnqueueInput() { |
| DCHECK(device_thread_.task_runner()->BelongsToCurrentThread()); |
| |
| const int old_inputs_queued = input_buffer_queued_count_; |
| while (!input_queue_.empty() && !free_input_buffers_.empty()) { |
| if (!EnqueueInputRecord()) |
| return; |
| } |
| if (old_inputs_queued == 0 && input_buffer_queued_count_ != 0) { |
| // We started up a previously empty queue. |
| // Queue state changed; signal interrupt. |
| if (!device_->SetDevicePollInterrupt()) { |
| NotifyError(); |
| return; |
| } |
| // VIDIOC_STREAMON if we haven't yet. |
| if (!input_streamon_) { |
| __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; |
| IOCTL_OR_ERROR_RETURN(VIDIOC_STREAMON, &type); |
| input_streamon_ = true; |
| } |
| } |
| } |
| |
| void V4L2ImageProcessor::EnqueueOutput(int index) { |
| DCHECK(device_thread_.task_runner()->BelongsToCurrentThread()); |
| |
| const int old_outputs_queued = output_buffer_queued_count_; |
| if (!EnqueueOutputRecord(index)) |
| return; |
| |
| if (old_outputs_queued == 0 && output_buffer_queued_count_ != 0) { |
| // We just started up a previously empty queue. |
| // Queue state changed; signal interrupt. |
| if (!device_->SetDevicePollInterrupt()) { |
| NotifyError(); |
| return; |
| } |
| // Start VIDIOC_STREAMON if we haven't yet. |
| if (!output_streamon_) { |
| __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; |
| IOCTL_OR_ERROR_RETURN(VIDIOC_STREAMON, &type); |
| output_streamon_ = true; |
| } |
| } |
| } |
| |
| void V4L2ImageProcessor::Dequeue() { |
| DCHECK(device_thread_.task_runner()->BelongsToCurrentThread()); |
| |
| // Dequeue completed input (VIDEO_OUTPUT) buffers, |
| // and recycle to the free list. |
| struct v4l2_buffer dqbuf; |
| struct v4l2_plane planes[VIDEO_MAX_PLANES]; |
| while (input_buffer_queued_count_ > 0) { |
| DCHECK(input_streamon_); |
| memset(&dqbuf, 0, sizeof(dqbuf)); |
| memset(&planes, 0, sizeof(planes)); |
| dqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; |
| dqbuf.memory = input_memory_type_; |
| dqbuf.m.planes = planes; |
| dqbuf.length = input_planes_count_; |
| if (device_->Ioctl(VIDIOC_DQBUF, &dqbuf) != 0) { |
| if (errno == EAGAIN) { |
| // EAGAIN if we're just out of buffers to dequeue. |
| break; |
| } |
| PLOG(ERROR) << "ioctl() failed: VIDIOC_DQBUF"; |
| NotifyError(); |
| return; |
| } |
| InputRecord& input_record = input_buffer_map_[dqbuf.index]; |
| DCHECK(input_record.at_device); |
| input_record.at_device = false; |
| input_record.frame = NULL; |
| free_input_buffers_.push_back(dqbuf.index); |
| input_buffer_queued_count_--; |
| } |
| |
| // Dequeue completed output (VIDEO_CAPTURE) buffers, recycle to the free list. |
| // Return the finished buffer to the client via the job ready callback. |
| while (output_buffer_queued_count_ > 0) { |
| DCHECK(output_streamon_); |
| memset(&dqbuf, 0, sizeof(dqbuf)); |
| memset(&planes, 0, sizeof(planes)); |
| dqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; |
| dqbuf.memory = output_memory_type_; |
| dqbuf.m.planes = planes; |
| dqbuf.length = output_planes_count_; |
| if (device_->Ioctl(VIDIOC_DQBUF, &dqbuf) != 0) { |
| if (errno == EAGAIN) { |
| // EAGAIN if we're just out of buffers to dequeue. |
| break; |
| } |
| PLOG(ERROR) << "ioctl() failed: VIDIOC_DQBUF"; |
| NotifyError(); |
| return; |
| } |
| OutputRecord& output_record = output_buffer_map_[dqbuf.index]; |
| DCHECK(output_record.at_device); |
| output_record.at_device = false; |
| output_record.dmabuf_fds.clear(); |
| output_buffer_queued_count_--; |
| |
| // Jobs are always processed in FIFO order. |
| DCHECK(!running_jobs_.empty()); |
| linked_ptr<JobRecord> job_record = running_jobs_.front(); |
| running_jobs_.pop(); |
| |
| DVLOG(3) << "Processing finished, returning frame, index=" << dqbuf.index; |
| |
| child_task_runner_->PostTask( |
| FROM_HERE, base::Bind(&V4L2ImageProcessor::FrameReady, weak_this_, |
| job_record->ready_cb, dqbuf.index)); |
| } |
| } |
| |
| bool V4L2ImageProcessor::EnqueueInputRecord() { |
| DCHECK(!input_queue_.empty()); |
| DCHECK(!free_input_buffers_.empty()); |
| |
| // Enqueue an input (VIDEO_OUTPUT) buffer for an input video frame. |
| linked_ptr<JobRecord> job_record = input_queue_.front(); |
| input_queue_.pop(); |
| const int index = free_input_buffers_.back(); |
| InputRecord& input_record = input_buffer_map_[index]; |
| DCHECK(!input_record.at_device); |
| input_record.frame = job_record->frame; |
| struct v4l2_buffer qbuf; |
| struct v4l2_plane qbuf_planes[VIDEO_MAX_PLANES]; |
| memset(&qbuf, 0, sizeof(qbuf)); |
| memset(qbuf_planes, 0, sizeof(qbuf_planes)); |
| qbuf.index = index; |
| qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; |
| qbuf.memory = input_memory_type_; |
| qbuf.m.planes = qbuf_planes; |
| qbuf.length = input_planes_count_; |
| for (size_t i = 0; i < input_planes_count_; ++i) { |
| qbuf.m.planes[i].bytesused = |
| VideoFrame::PlaneSize(input_record.frame->format(), i, |
| input_allocated_size_) |
| .GetArea(); |
| qbuf.m.planes[i].length = qbuf.m.planes[i].bytesused; |
| if (input_memory_type_ == V4L2_MEMORY_USERPTR) { |
| qbuf.m.planes[i].m.userptr = |
| reinterpret_cast<unsigned long>(input_record.frame->data(i)); |
| } else { |
| qbuf.m.planes[i].m.fd = input_record.frame->DmabufFd(i); |
| } |
| } |
| IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QBUF, &qbuf); |
| input_record.at_device = true; |
| running_jobs_.push(job_record); |
| free_input_buffers_.pop_back(); |
| input_buffer_queued_count_++; |
| |
| DVLOG(3) << __func__ << ": enqueued frame ts=" |
| << job_record->frame->timestamp().InMilliseconds() << " to device."; |
| |
| return true; |
| } |
| |
| bool V4L2ImageProcessor::EnqueueOutputRecord(int index) { |
| DCHECK_GE(index, 0); |
| DCHECK_LT(static_cast<size_t>(index), output_buffer_map_.size()); |
| // Enqueue an output (VIDEO_CAPTURE) buffer. |
| OutputRecord& output_record = output_buffer_map_[index]; |
| DCHECK(!output_record.at_device); |
| struct v4l2_buffer qbuf; |
| struct v4l2_plane qbuf_planes[VIDEO_MAX_PLANES]; |
| memset(&qbuf, 0, sizeof(qbuf)); |
| memset(qbuf_planes, 0, sizeof(qbuf_planes)); |
| qbuf.index = index; |
| qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; |
| qbuf.memory = output_memory_type_; |
| if (output_memory_type_ == V4L2_MEMORY_DMABUF) { |
| for (size_t i = 0; i < output_record.dmabuf_fds.size(); ++i) |
| qbuf_planes[i].m.fd = output_record.dmabuf_fds[i].get(); |
| } |
| qbuf.m.planes = qbuf_planes; |
| qbuf.length = output_planes_count_; |
| IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QBUF, &qbuf); |
| output_record.at_device = true; |
| output_buffer_queued_count_++; |
| return true; |
| } |
| |
| void V4L2ImageProcessor::StartDevicePoll() { |
| DVLOG(3) << __func__ << ": starting device poll"; |
| DCHECK(device_thread_.task_runner()->BelongsToCurrentThread()); |
| DCHECK(!device_poll_thread_.IsRunning()); |
| |
| // Start up the device poll thread and schedule its first DevicePollTask(). |
| if (!device_poll_thread_.Start()) { |
| LOG(ERROR) << "StartDevicePoll(): Device thread failed to start"; |
| NotifyError(); |
| return; |
| } |
| // Enqueue a poll task with no devices to poll on - will wait only for the |
| // poll interrupt |
| device_poll_thread_.task_runner()->PostTask( |
| FROM_HERE, base::Bind(&V4L2ImageProcessor::DevicePollTask, |
| base::Unretained(this), false)); |
| } |
| |
| void V4L2ImageProcessor::StopDevicePoll() { |
| DVLOG(3) << __func__ << ": stopping device poll"; |
| DCHECK(device_thread_.task_runner()->BelongsToCurrentThread()); |
| |
| // Signal the DevicePollTask() to stop, and stop the device poll thread. |
| bool result = device_->SetDevicePollInterrupt(); |
| device_poll_thread_.Stop(); |
| if (!result) { |
| NotifyError(); |
| return; |
| } |
| |
| // Clear the interrupt now, to be sure. |
| if (!device_->ClearDevicePollInterrupt()) { |
| NotifyError(); |
| return; |
| } |
| |
| if (input_streamon_) { |
| __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; |
| IOCTL_OR_ERROR_RETURN(VIDIOC_STREAMOFF, &type); |
| } |
| input_streamon_ = false; |
| |
| if (output_streamon_) { |
| __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; |
| IOCTL_OR_ERROR_RETURN(VIDIOC_STREAMOFF, &type); |
| } |
| output_streamon_ = false; |
| |
| // Reset all our accounting info. |
| while (!input_queue_.empty()) |
| input_queue_.pop(); |
| |
| while (!running_jobs_.empty()) |
| running_jobs_.pop(); |
| |
| free_input_buffers_.clear(); |
| for (size_t i = 0; i < input_buffer_map_.size(); ++i) { |
| InputRecord& input_record = input_buffer_map_[i]; |
| input_record.at_device = false; |
| input_record.frame = NULL; |
| free_input_buffers_.push_back(i); |
| } |
| input_buffer_queued_count_ = 0; |
| |
| output_buffer_map_.clear(); |
| output_buffer_map_.resize(num_buffers_); |
| output_buffer_queued_count_ = 0; |
| } |
| |
| void V4L2ImageProcessor::FrameReady(const FrameReadyCB& cb, |
| int output_buffer_index) { |
| DCHECK(child_task_runner_->BelongsToCurrentThread()); |
| cb.Run(output_buffer_index); |
| } |
| |
| } // namespace media |