xref: /freebsd/sys/dev/usb/video/uvideo_v4l2.h (revision 8bc06ffbbd80533eda0784d2a6f5a1476f9d550c)

/*-
 * SPDX-License-Identifier: BSD-3-Clause
 *
 *  Video for Linux Two header file
 *
 *  Copyright (C) 1999-2012 the contributors
 *  Copyright (C) 2012 Nokia Corporation
 *  Contact: Sakari Ailus <sakari.ailus@iki.fi>
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in
 *     the documentation and/or other materials provided with the
 *     distribution.
 *  3. The names of its contributors may not be used to endorse or promote
 *     products derived from this software without specific prior written
 *     permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 *  TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *  Minimal V4L2 definitions for the FreeBSD UVC driver.
 *  Extracted from OpenBSD sys/videoio.h.
 */

#ifndef _UVIDEO_V4L2_H_
#define _UVIDEO_V4L2_H_

#include <sys/types.h>
#include <sys/ioccom.h>
#include <sys/time.h>

/*
 *  Four-character-code (FOURCC)
 */
#define v4l2_fourcc(a, b, c, d)	\
	((u_int32_t)(a) | ((u_int32_t)(b) << 8) | \
	 ((u_int32_t)(c) << 16) | ((u_int32_t)(d) << 24))

/*
 *  Enums
 */
enum v4l2_field {
	V4L2_FIELD_ANY           = 0,
	V4L2_FIELD_NONE          = 1,
	V4L2_FIELD_TOP           = 2,
	V4L2_FIELD_BOTTOM        = 3,
	V4L2_FIELD_INTERLACED    = 4,
	V4L2_FIELD_SEQ_TB        = 5,
	V4L2_FIELD_SEQ_BT        = 6,
	V4L2_FIELD_ALTERNATE     = 7,
	V4L2_FIELD_INTERLACED_TB = 8,
	V4L2_FIELD_INTERLACED_BT = 9,
};

enum v4l2_buf_type {
	V4L2_BUF_TYPE_VIDEO_CAPTURE        = 1,
	V4L2_BUF_TYPE_VIDEO_OUTPUT         = 2,
	V4L2_BUF_TYPE_VIDEO_OVERLAY        = 3,
	V4L2_BUF_TYPE_VBI_CAPTURE          = 4,
	V4L2_BUF_TYPE_VBI_OUTPUT           = 5,
	V4L2_BUF_TYPE_SLICED_VBI_CAPTURE   = 6,
	V4L2_BUF_TYPE_SLICED_VBI_OUTPUT    = 7,
	V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY = 8,
	V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE = 9,
	V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE  = 10,
	V4L2_BUF_TYPE_SDR_CAPTURE          = 11,
	V4L2_BUF_TYPE_SDR_OUTPUT           = 12,
	V4L2_BUF_TYPE_META_CAPTURE         = 13,
	V4L2_BUF_TYPE_META_OUTPUT          = 14,
	/* Deprecated, do not use */
	V4L2_BUF_TYPE_PRIVATE              = 0x80,
};

enum v4l2_memory {
	V4L2_MEMORY_MMAP             = 1,
	V4L2_MEMORY_USERPTR          = 2,
	V4L2_MEMORY_OVERLAY          = 3,
	V4L2_MEMORY_DMABUF           = 4,
};

enum v4l2_colorspace {
	V4L2_COLORSPACE_DEFAULT       = 0,
	V4L2_COLORSPACE_SMPTE170M     = 1,
	V4L2_COLORSPACE_SMPTE240M     = 2,
	V4L2_COLORSPACE_REC709        = 3,
	V4L2_COLORSPACE_BT878         = 4,
	V4L2_COLORSPACE_470_SYSTEM_M  = 5,
	V4L2_COLORSPACE_470_SYSTEM_BG = 6,
	V4L2_COLORSPACE_JPEG          = 7,
	V4L2_COLORSPACE_SRGB          = 8,
	V4L2_COLORSPACE_OPRGB         = 9,
	V4L2_COLORSPACE_BT2020        = 10,
	V4L2_COLORSPACE_RAW           = 11,
	V4L2_COLORSPACE_DCI_P3        = 12,
};

enum v4l2_xfer_func {
	V4L2_XFER_FUNC_DEFAULT     = 0,
	V4L2_XFER_FUNC_709         = 1,
	V4L2_XFER_FUNC_SRGB        = 2,
	V4L2_XFER_FUNC_OPRGB       = 3,
	V4L2_XFER_FUNC_SMPTE240M   = 4,
	V4L2_XFER_FUNC_NONE        = 5,
	V4L2_XFER_FUNC_DCI_P3      = 6,
	V4L2_XFER_FUNC_SMPTE2084   = 7,
};

enum v4l2_ycbcr_encoding {
	V4L2_YCBCR_ENC_DEFAULT        = 0,
	V4L2_YCBCR_ENC_601            = 1,
	V4L2_YCBCR_ENC_709            = 2,
	V4L2_YCBCR_ENC_XV601          = 3,
	V4L2_YCBCR_ENC_XV709          = 4,
	V4L2_YCBCR_ENC_SYCC           = 5,
	V4L2_YCBCR_ENC_BT2020         = 6,
	V4L2_YCBCR_ENC_BT2020_CONST_LUM = 7,
	V4L2_YCBCR_ENC_SMPTE240M      = 8,
};

enum v4l2_ctrl_type {
	V4L2_CTRL_TYPE_INTEGER       = 1,
	V4L2_CTRL_TYPE_BOOLEAN       = 2,
	V4L2_CTRL_TYPE_MENU          = 3,
	V4L2_CTRL_TYPE_BUTTON        = 4,
	V4L2_CTRL_TYPE_INTEGER64     = 5,
	V4L2_CTRL_TYPE_CTRL_CLASS    = 6,
	V4L2_CTRL_TYPE_STRING        = 7,
	V4L2_CTRL_TYPE_BITMASK       = 8,
	V4L2_CTRL_TYPE_INTEGER_MENU  = 9,
};

enum v4l2_frmsizetypes {
	V4L2_FRMSIZE_TYPE_DISCRETE   = 1,
	V4L2_FRMSIZE_TYPE_CONTINUOUS = 2,
	V4L2_FRMSIZE_TYPE_STEPWISE   = 3,
};

enum v4l2_frmivaltypes {
	V4L2_FRMIVAL_TYPE_DISCRETE   = 1,
	V4L2_FRMIVAL_TYPE_CONTINUOUS = 2,
	V4L2_FRMIVAL_TYPE_STEPWISE   = 3,
};

/*
 *  Structures
 */
struct v4l2_fract {
	u_int32_t   numerator;
	u_int32_t   denominator;
};

struct v4l2_capability {
	u_int8_t	driver[16];
	u_int8_t	card[32];
	u_int8_t	bus_info[32];
	u_int32_t	version;
	u_int32_t	capabilities;
	u_int32_t	device_caps;
	u_int32_t	reserved[3];
};

struct v4l2_pix_format {
	u_int32_t		width;
	u_int32_t		height;
	u_int32_t		pixelformat;
	u_int32_t		field;		/* enum v4l2_field */
	u_int32_t		bytesperline;	/* for padding, zero if unused */
	u_int32_t		sizeimage;
	u_int32_t		colorspace;	/* enum v4l2_colorspace */
	u_int32_t		priv;		/* private data, depends on pixelformat */
	u_int32_t		flags;		/* format flags (V4L2_PIX_FMT_FLAG_*) */
	union {
		/* enum v4l2_ycbcr_encoding */
		u_int32_t	ycbcr_enc;
		/* enum v4l2_hsv_encoding */
		u_int32_t	hsv_enc;
	};
	u_int32_t		quantization;	/* enum v4l2_quantization */
	u_int32_t		xfer_func;	/* enum v4l2_xfer_func */
};

/*
 * v4l2_format: the system header (v4l_compat) includes struct v4l2_window
 * (which contains a pointer) in the fmt union, forcing 8-byte alignment.
 * This creates 4 bytes of implicit padding after 'type' on LP64.
 * We must match this layout for ioctl ABI compatibility.
 * Total size: 4 (type) + 4 (pad) + 200 (union) = 208.
 */
struct v4l2_format {
	u_int32_t	type;
	u_int32_t	_pad;
	union {
		struct v4l2_pix_format	pix;
		u_int8_t		raw_data[200];
	} fmt;
};

struct v4l2_fmtdesc {
	u_int32_t		index;		/* Format number      */
	u_int32_t		type;		/* enum v4l2_buf_type */
	u_int32_t		flags;
	u_int8_t		description[32]; /* Description string */
	u_int32_t		pixelformat;	/* Format fourcc      */
	u_int32_t		mbus_code;	/* Media bus code    */
	u_int32_t		reserved[3];
};

struct v4l2_timecode {
	u_int32_t	type;
	u_int32_t	flags;
	u_int8_t	frames;
	u_int8_t	seconds;
	u_int8_t	minutes;
	u_int8_t	hours;
	u_int8_t	userbits[4];
};

struct v4l2_buffer {
	u_int32_t			index;
	u_int32_t			type;
	u_int32_t			bytesused;
	u_int32_t			flags;
	u_int32_t			field;
	struct timeval			timestamp;
	struct v4l2_timecode		timecode;
	u_int32_t			sequence;

	/* memory location */
	u_int32_t			memory;
	union {
		u_int32_t		offset;
		unsigned long		userptr;
		int32_t			fd;
	} m;
	u_int32_t			length;
	u_int32_t			reserved2;
	union {
		int32_t			request_fd;
		u_int32_t		reserved;
	};
};

struct v4l2_requestbuffers {
	u_int32_t		count;
	u_int32_t		type;		/* enum v4l2_buf_type */
	u_int32_t		memory;		/* enum v4l2_memory */
	u_int32_t		capabilities;
	u_int8_t		flags;
	u_int8_t		reserved[3];
};

struct v4l2_captureparm {
	u_int32_t		capability;	/*  Supported modes */
	u_int32_t		capturemode;	/*  Current mode */
	struct v4l2_fract	timeperframe;	/*  Time per frame in seconds */
	u_int32_t		extendedmode;	/*  Driver-specific extensions */
	u_int32_t		readbuffers;	/*  # of buffers for read */
	u_int32_t		reserved[4];
};

/* Simplified v4l2_streamparm: only the capture member is included */
struct v4l2_streamparm {
	u_int32_t	type;			/* enum v4l2_buf_type */
	union {
		struct v4l2_captureparm	capture;
		u_int8_t		raw_data[200];
	} parm;
};

struct v4l2_input {
	u_int32_t	index;		/*  Which input */
	u_int8_t	name[32];	/*  Label */
	u_int32_t	type;		/*  Type of input */
	u_int32_t	audioset;	/*  Associated audios (bitfield) */
	u_int32_t	tuner;		/*  Tuner index */
	u_int64_t	std;
	u_int32_t	status;
	u_int32_t	capabilities;
	u_int32_t	reserved[3];
};

struct v4l2_control {
	u_int32_t	id;
	int32_t		value;
};

struct v4l2_queryctrl {
	u_int32_t	id;
	u_int32_t	type;		/* enum v4l2_ctrl_type */
	u_int8_t	name[32];	/* Whatever */
	int32_t		minimum;	/* Note signedness */
	int32_t		maximum;
	int32_t		step;
	int32_t		default_value;
	u_int32_t	flags;
	u_int32_t	reserved[2];
};

struct v4l2_frmsize_discrete {
	u_int32_t	width;		/* Frame width [pixel] */
	u_int32_t	height;		/* Frame height [pixel] */
};

struct v4l2_frmsize_stepwise {
	u_int32_t	min_width;	/* Minimum frame width [pixel] */
	u_int32_t	max_width;	/* Maximum frame width [pixel] */
	u_int32_t	step_width;	/* Frame width step size [pixel] */
	u_int32_t	min_height;	/* Minimum frame height [pixel] */
	u_int32_t	max_height;	/* Maximum frame height [pixel] */
	u_int32_t	step_height;	/* Frame height step size [pixel] */
};

struct v4l2_frmsizeenum {
	u_int32_t	index;		/* Frame size number */
	u_int32_t	pixel_format;	/* Pixel format */
	u_int32_t	type;		/* Frame size type the device supports. */

	union {				/* Frame size */
		struct v4l2_frmsize_discrete	discrete;
		struct v4l2_frmsize_stepwise	stepwise;
	};

	u_int32_t	reserved[2];	/* Reserved space for future use */
};

struct v4l2_frmival_stepwise {
	struct v4l2_fract	min;	/* Minimum frame interval [s] */
	struct v4l2_fract	max;	/* Maximum frame interval [s] */
	struct v4l2_fract	step;	/* Frame interval step size [s] */
};

struct v4l2_frmivalenum {
	u_int32_t	index;		/* Frame format index */
	u_int32_t	pixel_format;	/* Pixel format */
	u_int32_t	width;		/* Frame width */
	u_int32_t	height;		/* Frame height */
	u_int32_t	type;		/* Frame interval type the device supports. */

	union {				/* Frame interval */
		struct v4l2_fract		discrete;
		struct v4l2_frmival_stepwise	stepwise;
	};

	u_int32_t	reserved[2];	/* Reserved space for future use */
};

/*
 *  Pixel formats
 */

/* Luminance+Chrominance formats */
#define V4L2_PIX_FMT_YUYV	v4l2_fourcc('Y', 'U', 'Y', 'V')
#define V4L2_PIX_FMT_UYVY	v4l2_fourcc('U', 'Y', 'V', 'Y')
#define V4L2_PIX_FMT_NV12	v4l2_fourcc('N', 'V', '1', '2')
#define V4L2_PIX_FMT_NV21	v4l2_fourcc('N', 'V', '2', '1')
#define V4L2_PIX_FMT_M420	v4l2_fourcc('M', '4', '2', '0')
#define V4L2_PIX_FMT_YVU420	v4l2_fourcc('Y', 'V', '1', '2')
#define V4L2_PIX_FMT_YUV420	v4l2_fourcc('Y', 'U', '1', '2')

/* Compressed formats */
#define V4L2_PIX_FMT_MJPEG	v4l2_fourcc('M', 'J', 'P', 'G')
#define V4L2_PIX_FMT_H264	v4l2_fourcc('H', '2', '6', '4')
#define V4L2_PIX_FMT_HEVC	v4l2_fourcc('H', 'E', 'V', 'C')

/* Grey formats */
#define V4L2_PIX_FMT_GREY	v4l2_fourcc('G', 'R', 'E', 'Y')
#define V4L2_PIX_FMT_Y10	v4l2_fourcc('Y', '1', '0', ' ')
#define V4L2_PIX_FMT_Y12	v4l2_fourcc('Y', '1', '2', ' ')
#define V4L2_PIX_FMT_Y16	v4l2_fourcc('Y', '1', '6', ' ')

/* RGB formats */
#define V4L2_PIX_FMT_RGB565	v4l2_fourcc('R', 'G', 'B', 'P')
#define V4L2_PIX_FMT_BGR24	v4l2_fourcc('B', 'G', 'R', '3')
#define V4L2_PIX_FMT_XBGR32	v4l2_fourcc('X', 'R', '2', '4')

/* Bayer formats */
#define V4L2_PIX_FMT_SBGGR8	v4l2_fourcc('B', 'A', '8', '1')
#define V4L2_PIX_FMT_SGBRG8	v4l2_fourcc('G', 'B', 'R', 'G')
#define V4L2_PIX_FMT_SGRBG8	v4l2_fourcc('G', 'R', 'B', 'G')
#define V4L2_PIX_FMT_SRGGB8	v4l2_fourcc('R', 'G', 'G', 'B')
#define V4L2_PIX_FMT_SBGGR16	v4l2_fourcc('B', 'Y', 'R', '2')
#define V4L2_PIX_FMT_SGBRG16	v4l2_fourcc('G', 'B', '1', '6')
#define V4L2_PIX_FMT_SRGGB16	v4l2_fourcc('R', 'G', '1', '6')
#define V4L2_PIX_FMT_SGRBG16	v4l2_fourcc('G', 'R', '1', '6')
#define V4L2_PIX_FMT_SRGGB10P	v4l2_fourcc('p', 'R', 'A', 'A')

/* Depth format */
#define V4L2_PIX_FMT_Z16	v4l2_fourcc('Z', '1', '6', ' ')

/*
 *  Capability flags
 */
#define V4L2_CAP_VIDEO_CAPTURE		0x00000001
#define V4L2_CAP_STREAMING		0x04000000
#define V4L2_CAP_EXT_PIX_FORMAT		0x00200000
#define V4L2_CAP_READWRITE		0x01000000
#define V4L2_CAP_DEVICE_CAPS		0x80000000
#define V4L2_CAP_TIMEPERFRAME		0x1000

/*
 *  Buffer flags
 */
#define V4L2_BUF_FLAG_MAPPED		0x00000001
#define V4L2_BUF_FLAG_QUEUED		0x00000002
#define V4L2_BUF_FLAG_DONE		0x00000004
#define V4L2_BUF_FLAG_ERROR		0x00000040
#define V4L2_BUF_FLAG_TIMESTAMP_MASK	0x0000e000
#define V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC 0x00002000
#define V4L2_BUF_FLAG_TSTAMP_SRC_MASK	0x00070000
#define V4L2_BUF_FLAG_TSTAMP_SRC_EOF	0x00000000
#define V4L2_BUF_FLAG_TIMECODE		0x00000100

/*
 *  Format flags
 */
#define V4L2_FMT_FLAG_COMPRESSED	0x0001

/*
 *  Buffer capabilities
 */
#define V4L2_BUF_CAP_SUPPORTS_MMAP	(1 << 0)

/*
 *  Input types
 */
#define V4L2_INPUT_TYPE_CAMERA		2

/*
 *  Control IDs
 */
#define V4L2_CTRL_CLASS_USER		0x00980000
#define V4L2_CID_BASE			(V4L2_CTRL_CLASS_USER | 0x900)
#define V4L2_CID_BRIGHTNESS		(V4L2_CID_BASE + 0)
#define V4L2_CID_CONTRAST		(V4L2_CID_BASE + 1)
#define V4L2_CID_SATURATION		(V4L2_CID_BASE + 2)
#define V4L2_CID_HUE			(V4L2_CID_BASE + 3)
#define V4L2_CID_AUTO_WHITE_BALANCE	(V4L2_CID_BASE + 12)
#define V4L2_CID_RED_BALANCE		(V4L2_CID_BASE + 14)
#define V4L2_CID_BLUE_BALANCE		(V4L2_CID_BASE + 15)
#define V4L2_CID_GAMMA			(V4L2_CID_BASE + 16)
#define V4L2_CID_GAIN			(V4L2_CID_BASE + 19)
#define V4L2_CID_POWER_LINE_FREQUENCY	(V4L2_CID_BASE + 24)
#define V4L2_CID_HUE_AUTO		(V4L2_CID_BASE + 25)
#define V4L2_CID_WHITE_BALANCE_TEMPERATURE (V4L2_CID_BASE + 26)
#define V4L2_CID_SHARPNESS		(V4L2_CID_BASE + 27)
#define V4L2_CID_BACKLIGHT_COMPENSATION	(V4L2_CID_BASE + 28)

#define V4L2_CID_CAMERA_CLASS_BASE	0x009a0000
#define V4L2_CID_EXPOSURE_AUTO		(V4L2_CID_CAMERA_CLASS_BASE + 1)
#define V4L2_CID_EXPOSURE_ABSOLUTE	(V4L2_CID_CAMERA_CLASS_BASE + 2)
#define V4L2_CID_EXPOSURE_AUTO_PRIORITY	(V4L2_CID_CAMERA_CLASS_BASE + 3)
#define V4L2_CID_FOCUS_ABSOLUTE		(V4L2_CID_CAMERA_CLASS_BASE + 4)
#define V4L2_CID_FOCUS_RELATIVE		(V4L2_CID_CAMERA_CLASS_BASE + 5)
#define V4L2_CID_PAN_ABSOLUTE		(V4L2_CID_CAMERA_CLASS_BASE + 8)
#define V4L2_CID_TILT_ABSOLUTE		(V4L2_CID_CAMERA_CLASS_BASE + 9)
#define V4L2_CID_FOCUS_AUTO		(V4L2_CID_CAMERA_CLASS_BASE + 12)
#define V4L2_CID_ZOOM_ABSOLUTE		(V4L2_CID_CAMERA_CLASS_BASE + 13)
#define V4L2_CID_ZOOM_CONTINUOUS	(V4L2_CID_CAMERA_CLASS_BASE + 15)
#define V4L2_CID_PRIVACY		(V4L2_CID_CAMERA_CLASS_BASE + 16)

/*
 *  V4L2 ioctl definitions
 */
#define VIDIOC_QUERYCAP		_IOR('V',  0, struct v4l2_capability)
#define VIDIOC_ENUM_FMT		_IOWR('V',  2, struct v4l2_fmtdesc)
#define VIDIOC_G_FMT		_IOWR('V',  4, struct v4l2_format)
#define VIDIOC_S_FMT		_IOWR('V',  5, struct v4l2_format)
#define VIDIOC_REQBUFS		_IOWR('V',  8, struct v4l2_requestbuffers)
#define VIDIOC_QUERYBUF		_IOWR('V',  9, struct v4l2_buffer)
#define VIDIOC_QBUF		_IOWR('V', 15, struct v4l2_buffer)
#define VIDIOC_DQBUF		_IOWR('V', 17, struct v4l2_buffer)
#define VIDIOC_STREAMON		_IOW('V', 18, int)
#define VIDIOC_STREAMOFF	_IOW('V', 19, int)
#define VIDIOC_G_PARM		_IOWR('V', 21, struct v4l2_streamparm)
#define VIDIOC_S_PARM		_IOWR('V', 22, struct v4l2_streamparm)
#define VIDIOC_ENUMINPUT	_IOWR('V', 26, struct v4l2_input)
#define VIDIOC_G_CTRL		_IOWR('V', 27, struct v4l2_control)
#define VIDIOC_S_CTRL		_IOWR('V', 28, struct v4l2_control)
#define VIDIOC_QUERYCTRL	_IOWR('V', 36, struct v4l2_queryctrl)
#define VIDIOC_G_INPUT		_IOR('V', 38, int)
#define VIDIOC_S_INPUT		_IOWR('V', 39, int)
#define VIDIOC_G_PRIORITY	_IOR('V', 67, u_int32_t)
#define VIDIOC_S_PRIORITY	_IOW('V', 68, u_int32_t)
#define VIDIOC_TRY_FMT		_IOWR('V', 64, struct v4l2_format)
#define VIDIOC_ENUM_FRAMESIZES	_IOWR('V', 74, struct v4l2_frmsizeenum)
#define VIDIOC_ENUM_FRAMEINTERVALS _IOWR('V', 75, struct v4l2_frmivalenum)

#endif /* _UVIDEO_V4L2_H_ */