v4l2_capture_delegate.cc | Explore in Territory

// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "media/capture/video/linux/v4l2_capture_delegate.h"

#include <fcntl.h>
#include <linux/version.h>
#include <linux/videodev2.h>
#include <poll.h>
#include <sys/ioctl.h>
#include <sys/mman.h>

#include <algorithm>
#include <utility>

#include "base/functional/bind.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/raw_ptr_exclusion.h"
#include "base/posix/eintr_wrapper.h"
#include "base/task/single_thread_task_runner.h"
#include "base/trace_event/trace_event.h"
#include "build/build_config.h"
#include "media/base/video_frame.h"
#include "media/base/video_types.h"
#include "media/capture/mojom/image_capture_types.h"
#include "media/capture/video/blob_utils.h"
#include "media/capture/video/linux/video_capture_device_linux.h"

#if BUILDFLAG(IS_LINUX)
#include "media/capture/capture_switches.h"
#include "media/capture/video/linux/v4l2_capture_delegate_gpu_helper.h"
#endif  // BUILDFLAG(IS_LINUX)

MeteringMode;

#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 6, 0)
// 16 bit depth, Realsense F200.
#define V4L2_PIX_FMT_Z16 …
#endif

// TODO(aleksandar.stojiljkovic): Wrap this with kernel version check once the
// format is introduced to kernel.
// See https://crbug.com/661877
#ifndef V4L2_PIX_FMT_INVZ
// 16 bit depth, Realsense SR300.
#define V4L2_PIX_FMT_INVZ …
#endif

namespace media {

namespace {

// Desired number of video buffers to allocate. The actual number of allocated
// buffers by v4l2 driver can be higher or lower than this number.
// kNumVideoBuffers should not be too small, or Chrome may not return enough
// buffers back to driver in time.
constexpr uint32_t kNumVideoBuffers = …;
// Timeout in milliseconds v4l2_thread_ blocks waiting for a frame from the hw.
// This value has been fine tuned. Before changing or modifying it see
// https://crbug.com/470717
constexpr int kCaptureTimeoutMs = …;
// The number of continuous timeouts tolerated before treated as error.
constexpr int kContinuousTimeoutLimit = …;
// MJPEG is preferred if the requested width or height is larger than this.
constexpr int kMjpegWidth = …;
constexpr int kMjpegHeight = …;
// Typical framerate, in fps
constexpr int kTypicalFramerate = …;

// V4L2 color formats supported by V4L2CaptureDelegate derived classes.
// This list is ordered by precedence of use -- but see caveats for MJPEG.
struct { … } constexpr kSupportedFormatsAndPlanarity[] = …;

// Maximum number of ioctl retries before giving up trying to reset controls.
constexpr int kMaxIOCtrlRetries = …;

// Base id and class identifier for Controls to be reset.
struct { … } constexpr kControls[] = …;

// Fill in |format| with the given parameters.
void FillV4L2Format(v4l2_format* format,
                    uint32_t width,
                    uint32_t height,
                    uint32_t pixelformat_fourcc) { … }

// Fills all parts of |buffer|.
void FillV4L2Buffer(v4l2_buffer* buffer, int index) { … }

void FillV4L2RequestBuffer(v4l2_requestbuffers* request_buffer, int count) { … }

// Determines if |control_id| is controlled by a special control and
// determines the control ID of that special control.
int GetControllingSpecialControl(int control_id) { … }

// Determines if |control_id| is special, i.e. controls another one's state.
bool IsSpecialControl(int control_id) { … }

bool IsNonEmptyRange(const mojom::RangePtr& range) { … }

}  // namespace

// Class keeping track of a SPLANE V4L2 buffer, mmap()ed on construction and
// munmap()ed on destruction.
class V4L2CaptureDelegate::BufferTracker
    : public base::RefCounted<BufferTracker> { … };

// static
size_t V4L2CaptureDelegate::GetNumPlanesForFourCc(uint32_t fourcc) { … }

// static
VideoPixelFormat V4L2CaptureDelegate::V4l2FourCcToChromiumPixelFormat(
    uint32_t v4l2_fourcc) { … }

// static
std::vector<uint32_t> V4L2CaptureDelegate::GetListOfUsableFourCcs(
    bool prefer_mjpeg) { … }

// Determines if |control_id| should be skipped, https://crbug.com/697885.
#if !defined(V4L2_CID_PAN_SPEED)
#define V4L2_CID_PAN_SPEED …
#endif
#if !defined(V4L2_CID_TILT_SPEED)
#define V4L2_CID_TILT_SPEED …
#endif
#if !defined(V4L2_CID_PANTILT_CMD)
#define V4L2_CID_PANTILT_CMD …
#endif
// static
bool V4L2CaptureDelegate::IsBlockedControl(int control_id) { … }

// static
bool V4L2CaptureDelegate::IsControllableControl(
    int control_id,
    const base::RepeatingCallback<int(int, void*)>& do_ioctl) { … }

V4L2CaptureDelegate::V4L2CaptureDelegate(
    V4L2CaptureDevice* v4l2,
    const VideoCaptureDeviceDescriptor& device_descriptor,
    const scoped_refptr<base::SingleThreadTaskRunner>& v4l2_task_runner,
    int power_line_frequency,
    int rotation)
    : … { … }

void V4L2CaptureDelegate::AllocateAndStart(
    int width,
    int height,
    float frame_rate,
    std::unique_ptr<VideoCaptureDevice::Client> client) { … }

void V4L2CaptureDelegate::StopAndDeAllocate() { … }

void V4L2CaptureDelegate::TakePhoto(
    VideoCaptureDevice::TakePhotoCallback callback) { … }

void V4L2CaptureDelegate::GetPhotoState(
    VideoCaptureDevice::GetPhotoStateCallback callback) { … }

void V4L2CaptureDelegate::SetPhotoOptions(
    mojom::PhotoSettingsPtr settings,
    VideoCaptureDevice::SetPhotoOptionsCallback callback) { … }

void V4L2CaptureDelegate::SetRotation(int rotation) { … }

base::WeakPtr<V4L2CaptureDelegate> V4L2CaptureDelegate::GetWeakPtr() { … }

void V4L2CaptureDelegate::SetGPUEnvironmentForTesting(
    std::unique_ptr<gpu::GpuMemoryBufferSupport> gmb_support) { … }

V4L2CaptureDelegate::~V4L2CaptureDelegate() = default;

bool V4L2CaptureDelegate::RunIoctl(int request, void* argp) { … }

int V4L2CaptureDelegate::DoIoctl(int request, void* argp) { … }

bool V4L2CaptureDelegate::IsControllableControl(int control_id) { … }

void V4L2CaptureDelegate::ReplaceControlEventSubscriptions() { … }

mojom::RangePtr V4L2CaptureDelegate::RetrieveUserControlRange(int control_id) { … }

void V4L2CaptureDelegate::ResetUserAndCameraControlsToDefault() { … }

bool V4L2CaptureDelegate::MapAndQueueBuffer(int index) { … }

bool V4L2CaptureDelegate::StartStream() { … }

void V4L2CaptureDelegate::DoCapture() { … }

bool V4L2CaptureDelegate::StopStream() { … }

void V4L2CaptureDelegate::SetErrorState(VideoCaptureError error,
                                        const base::Location& from_here,
                                        const std::string& reason) { … }

#if BUILDFLAG(IS_LINUX)
gfx::ColorSpace V4L2CaptureDelegate::BuildColorSpaceFromv4l2() { … }
#endif

V4L2CaptureDelegate::BufferTracker::BufferTracker(V4L2CaptureDevice* v4l2)
    : … { … }

V4L2CaptureDelegate::BufferTracker::~BufferTracker() { … }

bool V4L2CaptureDelegate::BufferTracker::Init(int fd,
                                              const v4l2_buffer& buffer) { … }

}  // namespace media
chromium/media/capture/video/linux/v4l2_capture_delegate.cc
