Markus Heiser | 5377d91 | 2016-06-30 15:18:56 +0200 | [diff] [blame^] | 1 | .. -*- coding: utf-8; mode: rst -*- |
| 2 | |
| 3 | .. _control: |
| 4 | |
| 5 | ************* |
| 6 | User Controls |
| 7 | ************* |
| 8 | |
| 9 | Devices typically have a number of user-settable controls such as |
| 10 | brightness, saturation and so on, which would be presented to the user |
| 11 | on a graphical user interface. But, different devices will have |
| 12 | different controls available, and furthermore, the range of possible |
| 13 | values, and the default value will vary from device to device. The |
| 14 | control ioctls provide the information and a mechanism to create a nice |
| 15 | user interface for these controls that will work correctly with any |
| 16 | device. |
| 17 | |
| 18 | All controls are accessed using an ID value. V4L2 defines several IDs |
| 19 | for specific purposes. Drivers can also implement their own custom |
| 20 | controls using ``V4L2_CID_PRIVATE_BASE`` [1]_ and higher values. The |
| 21 | pre-defined control IDs have the prefix ``V4L2_CID_``, and are listed in |
| 22 | :ref:`control-id`. The ID is used when querying the attributes of a |
| 23 | control, and when getting or setting the current value. |
| 24 | |
| 25 | Generally applications should present controls to the user without |
| 26 | assumptions about their purpose. Each control comes with a name string |
| 27 | the user is supposed to understand. When the purpose is non-intuitive |
| 28 | the driver writer should provide a user manual, a user interface plug-in |
| 29 | or a driver specific panel application. Predefined IDs were introduced |
| 30 | to change a few controls programmatically, for example to mute a device |
| 31 | during a channel switch. |
| 32 | |
| 33 | Drivers may enumerate different controls after switching the current |
| 34 | video input or output, tuner or modulator, or audio input or output. |
| 35 | Different in the sense of other bounds, another default and current |
| 36 | value, step size or other menu items. A control with a certain *custom* |
| 37 | ID can also change name and type. |
| 38 | |
| 39 | If a control is not applicable to the current configuration of the |
| 40 | device (for example, it doesn't apply to the current video input) |
| 41 | drivers set the ``V4L2_CTRL_FLAG_INACTIVE`` flag. |
| 42 | |
| 43 | Control values are stored globally, they do not change when switching |
| 44 | except to stay within the reported bounds. They also do not change e. g. |
| 45 | when the device is opened or closed, when the tuner radio frequency is |
| 46 | changed or generally never without application request. |
| 47 | |
| 48 | V4L2 specifies an event mechanism to notify applications when controls |
| 49 | change value (see |
| 50 | :ref:`VIDIOC_SUBSCRIBE_EVENT <vidioc-subscribe-event>`, event |
| 51 | ``V4L2_EVENT_CTRL``), panel applications might want to make use of that |
| 52 | in order to always reflect the correct control value. |
| 53 | |
| 54 | All controls use machine endianness. |
| 55 | |
| 56 | |
| 57 | .. _control-id: |
| 58 | |
| 59 | Control IDs |
| 60 | =========== |
| 61 | |
| 62 | ``V4L2_CID_BASE`` |
| 63 | First predefined ID, equal to ``V4L2_CID_BRIGHTNESS``. |
| 64 | |
| 65 | ``V4L2_CID_USER_BASE`` |
| 66 | Synonym of ``V4L2_CID_BASE``. |
| 67 | |
| 68 | ``V4L2_CID_BRIGHTNESS`` ``(integer)`` |
| 69 | Picture brightness, or more precisely, the black level. |
| 70 | |
| 71 | ``V4L2_CID_CONTRAST`` ``(integer)`` |
| 72 | Picture contrast or luma gain. |
| 73 | |
| 74 | ``V4L2_CID_SATURATION`` ``(integer)`` |
| 75 | Picture color saturation or chroma gain. |
| 76 | |
| 77 | ``V4L2_CID_HUE`` ``(integer)`` |
| 78 | Hue or color balance. |
| 79 | |
| 80 | ``V4L2_CID_AUDIO_VOLUME`` ``(integer)`` |
| 81 | Overall audio volume. Note some drivers also provide an OSS or ALSA |
| 82 | mixer interface. |
| 83 | |
| 84 | ``V4L2_CID_AUDIO_BALANCE`` ``(integer)`` |
| 85 | Audio stereo balance. Minimum corresponds to all the way left, |
| 86 | maximum to right. |
| 87 | |
| 88 | ``V4L2_CID_AUDIO_BASS`` ``(integer)`` |
| 89 | Audio bass adjustment. |
| 90 | |
| 91 | ``V4L2_CID_AUDIO_TREBLE`` ``(integer)`` |
| 92 | Audio treble adjustment. |
| 93 | |
| 94 | ``V4L2_CID_AUDIO_MUTE`` ``(boolean)`` |
| 95 | Mute audio, i. e. set the volume to zero, however without affecting |
| 96 | ``V4L2_CID_AUDIO_VOLUME``. Like ALSA drivers, V4L2 drivers must mute |
| 97 | at load time to avoid excessive noise. Actually the entire device |
| 98 | should be reset to a low power consumption state. |
| 99 | |
| 100 | ``V4L2_CID_AUDIO_LOUDNESS`` ``(boolean)`` |
| 101 | Loudness mode (bass boost). |
| 102 | |
| 103 | ``V4L2_CID_BLACK_LEVEL`` ``(integer)`` |
| 104 | Another name for brightness (not a synonym of |
| 105 | ``V4L2_CID_BRIGHTNESS``). This control is deprecated and should not |
| 106 | be used in new drivers and applications. |
| 107 | |
| 108 | ``V4L2_CID_AUTO_WHITE_BALANCE`` ``(boolean)`` |
| 109 | Automatic white balance (cameras). |
| 110 | |
| 111 | ``V4L2_CID_DO_WHITE_BALANCE`` ``(button)`` |
| 112 | This is an action control. When set (the value is ignored), the |
| 113 | device will do a white balance and then hold the current setting. |
| 114 | Contrast this with the boolean ``V4L2_CID_AUTO_WHITE_BALANCE``, |
| 115 | which, when activated, keeps adjusting the white balance. |
| 116 | |
| 117 | ``V4L2_CID_RED_BALANCE`` ``(integer)`` |
| 118 | Red chroma balance. |
| 119 | |
| 120 | ``V4L2_CID_BLUE_BALANCE`` ``(integer)`` |
| 121 | Blue chroma balance. |
| 122 | |
| 123 | ``V4L2_CID_GAMMA`` ``(integer)`` |
| 124 | Gamma adjust. |
| 125 | |
| 126 | ``V4L2_CID_WHITENESS`` ``(integer)`` |
| 127 | Whiteness for grey-scale devices. This is a synonym for |
| 128 | ``V4L2_CID_GAMMA``. This control is deprecated and should not be |
| 129 | used in new drivers and applications. |
| 130 | |
| 131 | ``V4L2_CID_EXPOSURE`` ``(integer)`` |
| 132 | Exposure (cameras). [Unit?] |
| 133 | |
| 134 | ``V4L2_CID_AUTOGAIN`` ``(boolean)`` |
| 135 | Automatic gain/exposure control. |
| 136 | |
| 137 | ``V4L2_CID_GAIN`` ``(integer)`` |
| 138 | Gain control. |
| 139 | |
| 140 | ``V4L2_CID_HFLIP`` ``(boolean)`` |
| 141 | Mirror the picture horizontally. |
| 142 | |
| 143 | ``V4L2_CID_VFLIP`` ``(boolean)`` |
| 144 | Mirror the picture vertically. |
| 145 | |
| 146 | .. _`v4l2-power-line-frequency`: |
| 147 | |
| 148 | ``V4L2_CID_POWER_LINE_FREQUENCY`` ``(enum)`` |
| 149 | Enables a power line frequency filter to avoid flicker. Possible |
| 150 | values for ``enum v4l2_power_line_frequency`` are: |
| 151 | ``V4L2_CID_POWER_LINE_FREQUENCY_DISABLED`` (0), |
| 152 | ``V4L2_CID_POWER_LINE_FREQUENCY_50HZ`` (1), |
| 153 | ``V4L2_CID_POWER_LINE_FREQUENCY_60HZ`` (2) and |
| 154 | ``V4L2_CID_POWER_LINE_FREQUENCY_AUTO`` (3). |
| 155 | |
| 156 | ``V4L2_CID_HUE_AUTO`` ``(boolean)`` |
| 157 | Enables automatic hue control by the device. The effect of setting |
| 158 | ``V4L2_CID_HUE`` while automatic hue control is enabled is |
| 159 | undefined, drivers should ignore such request. |
| 160 | |
| 161 | ``V4L2_CID_WHITE_BALANCE_TEMPERATURE`` ``(integer)`` |
| 162 | This control specifies the white balance settings as a color |
| 163 | temperature in Kelvin. A driver should have a minimum of 2800 |
| 164 | (incandescent) to 6500 (daylight). For more information about color |
| 165 | temperature see |
| 166 | `Wikipedia <http://en.wikipedia.org/wiki/Color_temperature>`__. |
| 167 | |
| 168 | ``V4L2_CID_SHARPNESS`` ``(integer)`` |
| 169 | Adjusts the sharpness filters in a camera. The minimum value |
| 170 | disables the filters, higher values give a sharper picture. |
| 171 | |
| 172 | ``V4L2_CID_BACKLIGHT_COMPENSATION`` ``(integer)`` |
| 173 | Adjusts the backlight compensation in a camera. The minimum value |
| 174 | disables backlight compensation. |
| 175 | |
| 176 | ``V4L2_CID_CHROMA_AGC`` ``(boolean)`` |
| 177 | Chroma automatic gain control. |
| 178 | |
| 179 | ``V4L2_CID_CHROMA_GAIN`` ``(integer)`` |
| 180 | Adjusts the Chroma gain control (for use when chroma AGC is |
| 181 | disabled). |
| 182 | |
| 183 | ``V4L2_CID_COLOR_KILLER`` ``(boolean)`` |
| 184 | Enable the color killer (i. e. force a black & white image in case |
| 185 | of a weak video signal). |
| 186 | |
| 187 | .. _`v4l2-colorfx`: |
| 188 | |
| 189 | ``V4L2_CID_COLORFX`` ``(enum)`` |
| 190 | Selects a color effect. The following values are defined: |
| 191 | |
| 192 | |
| 193 | |
| 194 | .. flat-table:: |
| 195 | :header-rows: 0 |
| 196 | :stub-columns: 0 |
| 197 | |
| 198 | |
| 199 | - .. row 1 |
| 200 | |
| 201 | - ``V4L2_COLORFX_NONE`` |
| 202 | |
| 203 | - Color effect is disabled. |
| 204 | |
| 205 | - .. row 2 |
| 206 | |
| 207 | - ``V4L2_COLORFX_ANTIQUE`` |
| 208 | |
| 209 | - An aging (old photo) effect. |
| 210 | |
| 211 | - .. row 3 |
| 212 | |
| 213 | - ``V4L2_COLORFX_ART_FREEZE`` |
| 214 | |
| 215 | - Frost color effect. |
| 216 | |
| 217 | - .. row 4 |
| 218 | |
| 219 | - ``V4L2_COLORFX_AQUA`` |
| 220 | |
| 221 | - Water color, cool tone. |
| 222 | |
| 223 | - .. row 5 |
| 224 | |
| 225 | - ``V4L2_COLORFX_BW`` |
| 226 | |
| 227 | - Black and white. |
| 228 | |
| 229 | - .. row 6 |
| 230 | |
| 231 | - ``V4L2_COLORFX_EMBOSS`` |
| 232 | |
| 233 | - Emboss, the highlights and shadows replace light/dark boundaries |
| 234 | and low contrast areas are set to a gray background. |
| 235 | |
| 236 | - .. row 7 |
| 237 | |
| 238 | - ``V4L2_COLORFX_GRASS_GREEN`` |
| 239 | |
| 240 | - Grass green. |
| 241 | |
| 242 | - .. row 8 |
| 243 | |
| 244 | - ``V4L2_COLORFX_NEGATIVE`` |
| 245 | |
| 246 | - Negative. |
| 247 | |
| 248 | - .. row 9 |
| 249 | |
| 250 | - ``V4L2_COLORFX_SEPIA`` |
| 251 | |
| 252 | - Sepia tone. |
| 253 | |
| 254 | - .. row 10 |
| 255 | |
| 256 | - ``V4L2_COLORFX_SKETCH`` |
| 257 | |
| 258 | - Sketch. |
| 259 | |
| 260 | - .. row 11 |
| 261 | |
| 262 | - ``V4L2_COLORFX_SKIN_WHITEN`` |
| 263 | |
| 264 | - Skin whiten. |
| 265 | |
| 266 | - .. row 12 |
| 267 | |
| 268 | - ``V4L2_COLORFX_SKY_BLUE`` |
| 269 | |
| 270 | - Sky blue. |
| 271 | |
| 272 | - .. row 13 |
| 273 | |
| 274 | - ``V4L2_COLORFX_SOLARIZATION`` |
| 275 | |
| 276 | - Solarization, the image is partially reversed in tone, only color |
| 277 | values above or below a certain threshold are inverted. |
| 278 | |
| 279 | - .. row 14 |
| 280 | |
| 281 | - ``V4L2_COLORFX_SILHOUETTE`` |
| 282 | |
| 283 | - Silhouette (outline). |
| 284 | |
| 285 | - .. row 15 |
| 286 | |
| 287 | - ``V4L2_COLORFX_VIVID`` |
| 288 | |
| 289 | - Vivid colors. |
| 290 | |
| 291 | - .. row 16 |
| 292 | |
| 293 | - ``V4L2_COLORFX_SET_CBCR`` |
| 294 | |
| 295 | - The Cb and Cr chroma components are replaced by fixed coefficients |
| 296 | determined by ``V4L2_CID_COLORFX_CBCR`` control. |
| 297 | |
| 298 | |
| 299 | |
| 300 | ``V4L2_CID_COLORFX_CBCR`` ``(integer)`` |
| 301 | Determines the Cb and Cr coefficients for ``V4L2_COLORFX_SET_CBCR`` |
| 302 | color effect. Bits [7:0] of the supplied 32 bit value are |
| 303 | interpreted as Cr component, bits [15:8] as Cb component and bits |
| 304 | [31:16] must be zero. |
| 305 | |
| 306 | ``V4L2_CID_AUTOBRIGHTNESS`` ``(boolean)`` |
| 307 | Enable Automatic Brightness. |
| 308 | |
| 309 | ``V4L2_CID_ROTATE`` ``(integer)`` |
| 310 | Rotates the image by specified angle. Common angles are 90, 270 and |
| 311 | 180. Rotating the image to 90 and 270 will reverse the height and |
| 312 | width of the display window. It is necessary to set the new height |
| 313 | and width of the picture using the |
| 314 | :ref:`VIDIOC_S_FMT <vidioc-g-fmt>` ioctl according to the |
| 315 | rotation angle selected. |
| 316 | |
| 317 | ``V4L2_CID_BG_COLOR`` ``(integer)`` |
| 318 | Sets the background color on the current output device. Background |
| 319 | color needs to be specified in the RGB24 format. The supplied 32 bit |
| 320 | value is interpreted as bits 0-7 Red color information, bits 8-15 |
| 321 | Green color information, bits 16-23 Blue color information and bits |
| 322 | 24-31 must be zero. |
| 323 | |
| 324 | ``V4L2_CID_ILLUMINATORS_1 V4L2_CID_ILLUMINATORS_2`` ``(boolean)`` |
| 325 | Switch on or off the illuminator 1 or 2 of the device (usually a |
| 326 | microscope). |
| 327 | |
| 328 | ``V4L2_CID_MIN_BUFFERS_FOR_CAPTURE`` ``(integer)`` |
| 329 | This is a read-only control that can be read by the application and |
| 330 | used as a hint to determine the number of CAPTURE buffers to pass to |
| 331 | REQBUFS. The value is the minimum number of CAPTURE buffers that is |
| 332 | necessary for hardware to work. |
| 333 | |
| 334 | ``V4L2_CID_MIN_BUFFERS_FOR_OUTPUT`` ``(integer)`` |
| 335 | This is a read-only control that can be read by the application and |
| 336 | used as a hint to determine the number of OUTPUT buffers to pass to |
| 337 | REQBUFS. The value is the minimum number of OUTPUT buffers that is |
| 338 | necessary for hardware to work. |
| 339 | |
| 340 | .. _`v4l2-alpha-component`: |
| 341 | |
| 342 | ``V4L2_CID_ALPHA_COMPONENT`` ``(integer)`` |
| 343 | Sets the alpha color component. When a capture device (or capture |
| 344 | queue of a mem-to-mem device) produces a frame format that includes |
| 345 | an alpha component (e.g. |
| 346 | :ref:`packed RGB image formats <rgb-formats>`) and the alpha value |
| 347 | is not defined by the device or the mem-to-mem input data this |
| 348 | control lets you select the alpha component value of all pixels. |
| 349 | When an output device (or output queue of a mem-to-mem device) |
| 350 | consumes a frame format that doesn't include an alpha component and |
| 351 | the device supports alpha channel processing this control lets you |
| 352 | set the alpha component value of all pixels for further processing |
| 353 | in the device. |
| 354 | |
| 355 | ``V4L2_CID_LASTP1`` |
| 356 | End of the predefined control IDs (currently |
| 357 | ``V4L2_CID_ALPHA_COMPONENT`` + 1). |
| 358 | |
| 359 | ``V4L2_CID_PRIVATE_BASE`` |
| 360 | ID of the first custom (driver specific) control. Applications |
| 361 | depending on particular custom controls should check the driver name |
| 362 | and version, see :ref:`querycap`. |
| 363 | |
| 364 | Applications can enumerate the available controls with the |
| 365 | :ref:`VIDIOC_QUERYCTRL <vidioc-queryctrl>` and |
| 366 | :ref:`VIDIOC_QUERYMENU <vidioc-queryctrl>` ioctls, get and set a |
| 367 | control value with the :ref:`VIDIOC_G_CTRL <vidioc-g-ctrl>` and |
| 368 | :ref:`VIDIOC_S_CTRL <vidioc-g-ctrl>` ioctls. Drivers must implement |
| 369 | ``VIDIOC_QUERYCTRL``, ``VIDIOC_G_CTRL`` and ``VIDIOC_S_CTRL`` when the |
| 370 | device has one or more controls, ``VIDIOC_QUERYMENU`` when it has one or |
| 371 | more menu type controls. |
| 372 | |
| 373 | |
| 374 | .. code-block:: c |
| 375 | |
| 376 | struct v4l2_queryctrl queryctrl; |
| 377 | struct v4l2_querymenu querymenu; |
| 378 | |
| 379 | static void enumerate_menu(void) |
| 380 | { |
| 381 | printf(" Menu items:\\n"); |
| 382 | |
| 383 | memset(&querymenu, 0, sizeof(querymenu)); |
| 384 | querymenu.id = queryctrl.id; |
| 385 | |
| 386 | for (querymenu.index = queryctrl.minimum; |
| 387 | querymenu.index <= queryctrl.maximum; |
| 388 | querymenu.index++) { |
| 389 | if (0 == ioctl(fd, VIDIOC_QUERYMENU, &querymenu)) { |
| 390 | printf(" %s\\n", querymenu.name); |
| 391 | } |
| 392 | } |
| 393 | } |
| 394 | |
| 395 | memset(&queryctrl, 0, sizeof(queryctrl)); |
| 396 | |
| 397 | for (queryctrl.id = V4L2_CID_BASE; |
| 398 | queryctrl.id < V4L2_CID_LASTP1; |
| 399 | queryctrl.id++) { |
| 400 | if (0 == ioctl(fd, VIDIOC_QUERYCTRL, &queryctrl)) { |
| 401 | if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) |
| 402 | continue; |
| 403 | |
| 404 | printf("Control %s\\n", queryctrl.name); |
| 405 | |
| 406 | if (queryctrl.type == V4L2_CTRL_TYPE_MENU) |
| 407 | enumerate_menu(); |
| 408 | } else { |
| 409 | if (errno == EINVAL) |
| 410 | continue; |
| 411 | |
| 412 | perror("VIDIOC_QUERYCTRL"); |
| 413 | exit(EXIT_FAILURE); |
| 414 | } |
| 415 | } |
| 416 | |
| 417 | for (queryctrl.id = V4L2_CID_PRIVATE_BASE;; |
| 418 | queryctrl.id++) { |
| 419 | if (0 == ioctl(fd, VIDIOC_QUERYCTRL, &queryctrl)) { |
| 420 | if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) |
| 421 | continue; |
| 422 | |
| 423 | printf("Control %s\\n", queryctrl.name); |
| 424 | |
| 425 | if (queryctrl.type == V4L2_CTRL_TYPE_MENU) |
| 426 | enumerate_menu(); |
| 427 | } else { |
| 428 | if (errno == EINVAL) |
| 429 | break; |
| 430 | |
| 431 | perror("VIDIOC_QUERYCTRL"); |
| 432 | exit(EXIT_FAILURE); |
| 433 | } |
| 434 | } |
| 435 | |
| 436 | |
| 437 | .. code-block:: c |
| 438 | |
| 439 | memset(&queryctrl, 0, sizeof(queryctrl)); |
| 440 | |
| 441 | queryctrl.id = V4L2_CTRL_CLASS_USER | V4L2_CTRL_FLAG_NEXT_CTRL; |
| 442 | while (0 == ioctl(fd, VIDIOC_QUERYCTRL, &queryctrl)) { |
| 443 | if (V4L2_CTRL_ID2CLASS(queryctrl.id) != V4L2_CTRL_CLASS_USER) |
| 444 | break; |
| 445 | if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) |
| 446 | continue; |
| 447 | |
| 448 | printf("Control %s\\n", queryctrl.name); |
| 449 | |
| 450 | if (queryctrl.type == V4L2_CTRL_TYPE_MENU) |
| 451 | enumerate_menu(); |
| 452 | |
| 453 | queryctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL; |
| 454 | } |
| 455 | if (errno != EINVAL) { |
| 456 | perror("VIDIOC_QUERYCTRL"); |
| 457 | exit(EXIT_FAILURE); |
| 458 | } |
| 459 | |
| 460 | |
| 461 | .. code-block:: c |
| 462 | |
| 463 | struct v4l2_queryctrl queryctrl; |
| 464 | struct v4l2_control control; |
| 465 | |
| 466 | memset(&queryctrl, 0, sizeof(queryctrl)); |
| 467 | queryctrl.id = V4L2_CID_BRIGHTNESS; |
| 468 | |
| 469 | if (-1 == ioctl(fd, VIDIOC_QUERYCTRL, &queryctrl)) { |
| 470 | if (errno != EINVAL) { |
| 471 | perror("VIDIOC_QUERYCTRL"); |
| 472 | exit(EXIT_FAILURE); |
| 473 | } else { |
| 474 | printf("V4L2_CID_BRIGHTNESS is not supportedn"); |
| 475 | } |
| 476 | } else if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) { |
| 477 | printf("V4L2_CID_BRIGHTNESS is not supportedn"); |
| 478 | } else { |
| 479 | memset(&control, 0, sizeof (control)); |
| 480 | control.id = V4L2_CID_BRIGHTNESS; |
| 481 | control.value = queryctrl.default_value; |
| 482 | |
| 483 | if (-1 == ioctl(fd, VIDIOC_S_CTRL, &control)) { |
| 484 | perror("VIDIOC_S_CTRL"); |
| 485 | exit(EXIT_FAILURE); |
| 486 | } |
| 487 | } |
| 488 | |
| 489 | memset(&control, 0, sizeof(control)); |
| 490 | control.id = V4L2_CID_CONTRAST; |
| 491 | |
| 492 | if (0 == ioctl(fd, VIDIOC_G_CTRL, &control)) { |
| 493 | control.value += 1; |
| 494 | |
| 495 | /* The driver may clamp the value or return ERANGE, ignored here */ |
| 496 | |
| 497 | if (-1 == ioctl(fd, VIDIOC_S_CTRL, &control) |
| 498 | && errno != ERANGE) { |
| 499 | perror("VIDIOC_S_CTRL"); |
| 500 | exit(EXIT_FAILURE); |
| 501 | } |
| 502 | /* Ignore if V4L2_CID_CONTRAST is unsupported */ |
| 503 | } else if (errno != EINVAL) { |
| 504 | perror("VIDIOC_G_CTRL"); |
| 505 | exit(EXIT_FAILURE); |
| 506 | } |
| 507 | |
| 508 | control.id = V4L2_CID_AUDIO_MUTE; |
| 509 | control.value = 1; /* silence */ |
| 510 | |
| 511 | /* Errors ignored */ |
| 512 | ioctl(fd, VIDIOC_S_CTRL, &control); |
| 513 | |
| 514 | .. [1] |
| 515 | The use of ``V4L2_CID_PRIVATE_BASE`` is problematic because different |
| 516 | drivers may use the same ``V4L2_CID_PRIVATE_BASE`` ID for different |
| 517 | controls. This makes it hard to programatically set such controls |
| 518 | since the meaning of the control with that ID is driver dependent. In |
| 519 | order to resolve this drivers use unique IDs and the |
| 520 | ``V4L2_CID_PRIVATE_BASE`` IDs are mapped to those unique IDs by the |
| 521 | kernel. Consider these ``V4L2_CID_PRIVATE_BASE`` IDs as aliases to |
| 522 | the real IDs. |
| 523 | |
| 524 | Many applications today still use the ``V4L2_CID_PRIVATE_BASE`` IDs |
| 525 | instead of using :ref:`VIDIOC_QUERYCTRL <vidioc-queryctrl>` with |
| 526 | the ``V4L2_CTRL_FLAG_NEXT_CTRL`` flag to enumerate all IDs, so |
| 527 | support for ``V4L2_CID_PRIVATE_BASE`` is still around. |
| 528 | |
| 529 | |
| 530 | .. ------------------------------------------------------------------------------ |
| 531 | .. This file was automatically converted from DocBook-XML with the dbxml |
| 532 | .. library (https://github.com/return42/sphkerneldoc). The origin XML comes |
| 533 | .. from the linux kernel, refer to: |
| 534 | .. |
| 535 | .. * https://github.com/torvalds/linux/tree/master/Documentation/DocBook |
| 536 | .. ------------------------------------------------------------------------------ |