mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
194 lines
5.3 KiB
194 lines
5.3 KiB
.. SPDX-License-Identifier: GFDL-1.1-no-invariants-or-later |
|
.. c:namespace:: V4L |
|
|
|
.. _VIDIOC_ENUM_FRAMESIZES: |
|
|
|
**************************** |
|
ioctl VIDIOC_ENUM_FRAMESIZES |
|
**************************** |
|
|
|
Name |
|
==== |
|
|
|
VIDIOC_ENUM_FRAMESIZES - Enumerate frame sizes |
|
|
|
Synopsis |
|
======== |
|
|
|
.. c:macro:: VIDIOC_ENUM_FRAMESIZES |
|
|
|
``int ioctl(int fd, VIDIOC_ENUM_FRAMESIZES, struct v4l2_frmsizeenum *argp)`` |
|
|
|
Arguments |
|
========= |
|
|
|
``fd`` |
|
File descriptor returned by :c:func:`open()`. |
|
|
|
``argp`` |
|
Pointer to struct :c:type:`v4l2_frmsizeenum` |
|
that contains an index and pixel format and receives a frame width |
|
and height. |
|
|
|
Description |
|
=========== |
|
|
|
This ioctl allows applications to enumerate all frame sizes (i. e. width |
|
and height in pixels) that the device supports for the given pixel |
|
format. |
|
|
|
The supported pixel formats can be obtained by using the |
|
:ref:`VIDIOC_ENUM_FMT` function. |
|
|
|
The return value and the content of the ``v4l2_frmsizeenum.type`` field |
|
depend on the type of frame sizes the device supports. Here are the |
|
semantics of the function for the different cases: |
|
|
|
- **Discrete:** The function returns success if the given index value |
|
(zero-based) is valid. The application should increase the index by |
|
one for each call until ``EINVAL`` is returned. The |
|
``v4l2_frmsizeenum.type`` field is set to |
|
``V4L2_FRMSIZE_TYPE_DISCRETE`` by the driver. Of the union only the |
|
``discrete`` member is valid. |
|
|
|
- **Step-wise:** The function returns success if the given index value |
|
is zero and ``EINVAL`` for any other index value. The |
|
``v4l2_frmsizeenum.type`` field is set to |
|
``V4L2_FRMSIZE_TYPE_STEPWISE`` by the driver. Of the union only the |
|
``stepwise`` member is valid. |
|
|
|
- **Continuous:** This is a special case of the step-wise type above. |
|
The function returns success if the given index value is zero and |
|
``EINVAL`` for any other index value. The ``v4l2_frmsizeenum.type`` |
|
field is set to ``V4L2_FRMSIZE_TYPE_CONTINUOUS`` by the driver. Of |
|
the union only the ``stepwise`` member is valid and the |
|
``step_width`` and ``step_height`` values are set to 1. |
|
|
|
When the application calls the function with index zero, it must check |
|
the ``type`` field to determine the type of frame size enumeration the |
|
device supports. Only for the ``V4L2_FRMSIZE_TYPE_DISCRETE`` type does |
|
it make sense to increase the index value to receive more frame sizes. |
|
|
|
.. note:: |
|
|
|
The order in which the frame sizes are returned has no special |
|
meaning. In particular does it not say anything about potential default |
|
format sizes. |
|
|
|
Applications can assume that the enumeration data does not change |
|
without any interaction from the application itself. This means that the |
|
enumeration data is consistent if the application does not perform any |
|
other ioctl calls while it runs the frame size enumeration. |
|
|
|
Structs |
|
======= |
|
|
|
In the structs below, *IN* denotes a value that has to be filled in by |
|
the application, *OUT* denotes values that the driver fills in. The |
|
application should zero out all members except for the *IN* fields. |
|
|
|
.. c:type:: v4l2_frmsize_discrete |
|
|
|
.. flat-table:: struct v4l2_frmsize_discrete |
|
:header-rows: 0 |
|
:stub-columns: 0 |
|
:widths: 1 1 2 |
|
|
|
* - __u32 |
|
- ``width`` |
|
- Width of the frame [pixel]. |
|
* - __u32 |
|
- ``height`` |
|
- Height of the frame [pixel]. |
|
|
|
|
|
.. c:type:: v4l2_frmsize_stepwise |
|
|
|
.. flat-table:: struct v4l2_frmsize_stepwise |
|
:header-rows: 0 |
|
:stub-columns: 0 |
|
:widths: 1 1 2 |
|
|
|
* - __u32 |
|
- ``min_width`` |
|
- Minimum frame width [pixel]. |
|
* - __u32 |
|
- ``max_width`` |
|
- Maximum frame width [pixel]. |
|
* - __u32 |
|
- ``step_width`` |
|
- Frame width step size [pixel]. |
|
* - __u32 |
|
- ``min_height`` |
|
- Minimum frame height [pixel]. |
|
* - __u32 |
|
- ``max_height`` |
|
- Maximum frame height [pixel]. |
|
* - __u32 |
|
- ``step_height`` |
|
- Frame height step size [pixel]. |
|
|
|
|
|
.. c:type:: v4l2_frmsizeenum |
|
|
|
.. tabularcolumns:: |p{6.4cm}|p{2.8cm}|p{8.1cm}| |
|
|
|
.. flat-table:: struct v4l2_frmsizeenum |
|
:header-rows: 0 |
|
:stub-columns: 0 |
|
|
|
* - __u32 |
|
- ``index`` |
|
- IN: Index of the given frame size in the enumeration. |
|
* - __u32 |
|
- ``pixel_format`` |
|
- IN: Pixel format for which the frame sizes are enumerated. |
|
* - __u32 |
|
- ``type`` |
|
- OUT: Frame size type the device supports. |
|
* - union { |
|
- (anonymous) |
|
- OUT: Frame size with the given index. |
|
* - struct :c:type:`v4l2_frmsize_discrete` |
|
- ``discrete`` |
|
- |
|
* - struct :c:type:`v4l2_frmsize_stepwise` |
|
- ``stepwise`` |
|
- |
|
* - } |
|
- |
|
- |
|
* - __u32 |
|
- ``reserved[2]`` |
|
- Reserved space for future use. Must be zeroed by drivers and |
|
applications. |
|
|
|
|
|
Enums |
|
===== |
|
|
|
.. c:type:: v4l2_frmsizetypes |
|
|
|
.. tabularcolumns:: |p{6.6cm}|p{2.2cm}|p{8.5cm}| |
|
|
|
.. flat-table:: enum v4l2_frmsizetypes |
|
:header-rows: 0 |
|
:stub-columns: 0 |
|
:widths: 3 1 4 |
|
|
|
* - ``V4L2_FRMSIZE_TYPE_DISCRETE`` |
|
- 1 |
|
- Discrete frame size. |
|
* - ``V4L2_FRMSIZE_TYPE_CONTINUOUS`` |
|
- 2 |
|
- Continuous frame size. |
|
* - ``V4L2_FRMSIZE_TYPE_STEPWISE`` |
|
- 3 |
|
- Step-wise defined frame size. |
|
|
|
Return Value |
|
============ |
|
|
|
On success 0 is returned, on error -1 and the ``errno`` variable is set |
|
appropriately. The generic error codes are described at the |
|
:ref:`Generic Error Codes <gen-errors>` chapter.
|
|
|