Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'media/v4.20-5' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media
Pull media fixes from Mauro Carvalho Chehab:
- one regression at vsp1 driver
- some last time changes for the upcoming request API logic and for
stateless codec support. As the stateless codec "cedrus" driver is at
staging, don't apply the MPEG controls as part of the main V4L2 API,
as those may not be ready for production yet.
* tag 'media/v4.20-5' of git://git.kernel.org/pub/scm/linux/kernel/git/mchehab/linux-media:
media: Add a Kconfig option for the Request API
media: extended-controls.rst: add note to the MPEG2 state controls
media: mpeg2-ctrls.h: move MPEG2 state controls to non-public header
media: vicodec: set state resolution from raw format
media: vivid: drop v4l2_ctrl_request_complete() from start_streaming
media: vb2: don't unbind/put the object when going to state QUEUED
media: vb2: keep a reference to the request until dqbuf
media: vb2: skip request checks for VIDIOC_PREPARE_BUF
media: vb2: don't call __vb2_queue_cancel if vb2_start_streaming failed
media: cedrus: Fix a NULL vs IS_ERR() check
media: vsp1: Fix LIF buffer thresholds
+181
-103
+10
Documentation/media/uapi/v4l/extended-controls.rst
+10
Documentation/media/uapi/v4l/extended-controls.rst
···
1505
1505
configuring a stateless hardware decoding pipeline for MPEG-2.
1506
1506
The bitstream parameters are defined according to :ref:`mpeg2part2`.
1507
1507
1508
+
.. note::
1509
+
1510
+
This compound control is not yet part of the public kernel API and
1511
+
it is expected to change.
1512
+
1508
1513
.. c:type:: v4l2_ctrl_mpeg2_slice_params
1509
1514
1510
1515
.. cssclass:: longtable
···
1629
1624
``V4L2_CID_MPEG_VIDEO_MPEG2_QUANTIZATION (struct)``
1630
1625
Specifies quantization matrices (as extracted from the bitstream) for the
1631
1626
associated MPEG-2 slice data.
1627
+
1628
+
.. note::
1629
+
1630
+
This compound control is not yet part of the public kernel API and
1631
+
it is expected to change.
1632
1632
1633
1633
.. c:type:: v4l2_ctrl_mpeg2_quantization
1634
1634
+13
drivers/media/Kconfig
+13
drivers/media/Kconfig
···
110
110
111
111
This is currently experimental.
112
112
113
+
config MEDIA_CONTROLLER_REQUEST_API
114
+
bool "Enable Media controller Request API (EXPERIMENTAL)"
115
+
depends on MEDIA_CONTROLLER && STAGING_MEDIA
116
+
default n
117
+
---help---
118
+
DO NOT ENABLE THIS OPTION UNLESS YOU KNOW WHAT YOU'RE DOING.
119
+
120
+
This option enables the Request API for the Media controller and V4L2
121
+
interfaces. It is currently needed by a few stateless codec drivers.
122
+
123
+
There is currently no intention to provide API or ABI stability for
124
+
this new API as of yet.
125
+
113
126
#
114
127
# Video4Linux support
115
128
# Only enables if one of the V4L2 types (ATV, webcam, radio) is selected
+35
-9
drivers/media/common/videobuf2/videobuf2-core.c
+35
-9
drivers/media/common/videobuf2/videobuf2-core.c
···
947
947
}
948
948
atomic_dec(&q->owned_by_drv_count);
949
949
950
-
if (vb->req_obj.req) {
950
+
if (state != VB2_BUF_STATE_QUEUED && vb->req_obj.req) {
951
951
/* This is not supported at the moment */
952
952
WARN_ON(state == VB2_BUF_STATE_REQUEUEING);
953
953
media_request_object_unbind(&vb->req_obj);
···
1359
1359
{
1360
1360
struct vb2_buffer *vb = container_of(obj, struct vb2_buffer, req_obj);
1361
1361
1362
-
if (vb->state == VB2_BUF_STATE_IN_REQUEST)
1362
+
if (vb->state == VB2_BUF_STATE_IN_REQUEST) {
1363
1363
vb->state = VB2_BUF_STATE_DEQUEUED;
1364
+
if (vb->request)
1365
+
media_request_put(vb->request);
1366
+
vb->request = NULL;
1367
+
}
1364
1368
}
1365
1369
1366
1370
static const struct media_request_object_ops vb2_core_req_ops = {
···
1532
1528
return ret;
1533
1529
1534
1530
vb->state = VB2_BUF_STATE_IN_REQUEST;
1531
+
1532
+
/*
1533
+
* Increment the refcount and store the request.
1534
+
* The request refcount is decremented again when the
1535
+
* buffer is dequeued. This is to prevent vb2_buffer_done()
1536
+
* from freeing the request from interrupt context, which can
1537
+
* happen if the application closed the request fd after
1538
+
* queueing the request.
1539
+
*/
1540
+
media_request_get(req);
1541
+
vb->request = req;
1542
+
1535
1543
/* Fill buffer information for the userspace */
1536
1544
if (pb) {
1537
1545
call_void_bufop(q, copy_timestamp, vb, pb);
···
1765
1749
call_void_memop(vb, unmap_dmabuf, vb->planes[i].mem_priv);
1766
1750
vb->planes[i].dbuf_mapped = 0;
1767
1751
}
1768
-
if (vb->req_obj.req) {
1769
-
media_request_object_unbind(&vb->req_obj);
1770
-
media_request_object_put(&vb->req_obj);
1771
-
}
1772
1752
call_void_bufop(q, init_buffer, vb);
1773
1753
}
1774
1754
···
1808
1796
1809
1797
/* go back to dequeued state */
1810
1798
__vb2_dqbuf(vb);
1799
+
1800
+
if (WARN_ON(vb->req_obj.req)) {
1801
+
media_request_object_unbind(&vb->req_obj);
1802
+
media_request_object_put(&vb->req_obj);
1803
+
}
1804
+
if (vb->request)
1805
+
media_request_put(vb->request);
1806
+
vb->request = NULL;
1811
1807
1812
1808
dprintk(2, "dqbuf of buffer %d, with state %d\n",
1813
1809
vb->index, vb->state);
···
1923
1903
vb->prepared = false;
1924
1904
}
1925
1905
__vb2_dqbuf(vb);
1906
+
1907
+
if (vb->req_obj.req) {
1908
+
media_request_object_unbind(&vb->req_obj);
1909
+
media_request_object_put(&vb->req_obj);
1910
+
}
1911
+
if (vb->request)
1912
+
media_request_put(vb->request);
1913
+
vb->request = NULL;
1926
1914
}
1927
1915
}
1928
1916
···
1968
1940
if (ret)
1969
1941
return ret;
1970
1942
ret = vb2_start_streaming(q);
1971
-
if (ret) {
1972
-
__vb2_queue_cancel(q);
1943
+
if (ret)
1973
1944
return ret;
1974
-
}
1975
1945
}
1976
1946
1977
1947
q->streaming = 1;
+9
-4
drivers/media/common/videobuf2/videobuf2-v4l2.c
+9
-4
drivers/media/common/videobuf2/videobuf2-v4l2.c
···
333
333
}
334
334
335
335
static int vb2_queue_or_prepare_buf(struct vb2_queue *q, struct media_device *mdev,
336
-
struct v4l2_buffer *b,
337
-
const char *opname,
336
+
struct v4l2_buffer *b, bool is_prepare,
338
337
struct media_request **p_req)
339
338
{
339
+
const char *opname = is_prepare ? "prepare_buf" : "qbuf";
340
340
struct media_request *req;
341
341
struct vb2_v4l2_buffer *vbuf;
342
342
struct vb2_buffer *vb;
···
377
377
if (ret)
378
378
return ret;
379
379
}
380
+
381
+
if (is_prepare)
382
+
return 0;
380
383
381
384
if (!(b->flags & V4L2_BUF_FLAG_REQUEST_FD)) {
382
385
if (q->uses_requests) {
···
634
631
*caps |= V4L2_BUF_CAP_SUPPORTS_USERPTR;
635
632
if (q->io_modes & VB2_DMABUF)
636
633
*caps |= V4L2_BUF_CAP_SUPPORTS_DMABUF;
634
+
#ifdef CONFIG_MEDIA_CONTROLLER_REQUEST_API
637
635
if (q->supports_requests)
638
636
*caps |= V4L2_BUF_CAP_SUPPORTS_REQUESTS;
637
+
#endif
639
638
}
640
639
641
640
int vb2_reqbufs(struct vb2_queue *q, struct v4l2_requestbuffers *req)
···
662
657
if (b->flags & V4L2_BUF_FLAG_REQUEST_FD)
663
658
return -EINVAL;
664
659
665
-
ret = vb2_queue_or_prepare_buf(q, mdev, b, "prepare_buf", NULL);
660
+
ret = vb2_queue_or_prepare_buf(q, mdev, b, true, NULL);
666
661
667
662
return ret ? ret : vb2_core_prepare_buf(q, b->index, b);
668
663
}
···
734
729
return -EBUSY;
735
730
}
736
731
737
-
ret = vb2_queue_or_prepare_buf(q, mdev, b, "qbuf", &req);
732
+
ret = vb2_queue_or_prepare_buf(q, mdev, b, false, &req);
738
733
if (ret)
739
734
return ret;
740
735
ret = vb2_core_qbuf(q, b->index, b, req);
+4
drivers/media/media-device.c
+4
drivers/media/media-device.c
···
381
381
static long media_device_request_alloc(struct media_device *mdev,
382
382
int *alloc_fd)
383
383
{
384
+
#ifdef CONFIG_MEDIA_CONTROLLER_REQUEST_API
384
385
if (!mdev->ops || !mdev->ops->req_validate || !mdev->ops->req_queue)
385
386
return -ENOTTY;
386
387
387
388
return media_request_alloc(mdev, alloc_fd);
389
+
#else
390
+
return -ENOTTY;
391
+
#endif
388
392
}
389
393
390
394
static long copy_arg_from_user(void *karg, void __user *uarg, unsigned int cmd)
+10
-3
drivers/media/platform/vicodec/vicodec-core.c
+10
-3
drivers/media/platform/vicodec/vicodec-core.c
···
997
997
998
998
q_data->sequence = 0;
999
999
1000
-
if (!V4L2_TYPE_IS_OUTPUT(q->type))
1000
+
if (!V4L2_TYPE_IS_OUTPUT(q->type)) {
1001
+
if (!ctx->is_enc) {
1002
+
state->width = q_data->width;
1003
+
state->height = q_data->height;
1004
+
}
1001
1005
return 0;
1006
+
}
1002
1007
1003
-
state->width = q_data->width;
1004
-
state->height = q_data->height;
1008
+
if (ctx->is_enc) {
1009
+
state->width = q_data->width;
1010
+
state->height = q_data->height;
1011
+
}
1005
1012
state->ref_frame.width = state->ref_frame.height = 0;
1006
1013
state->ref_frame.luma = kvmalloc(size + 2 * size / chroma_div,
1007
1014
GFP_KERNEL);
-2
drivers/media/platform/vivid/vivid-sdr-cap.c
-2
drivers/media/platform/vivid/vivid-sdr-cap.c
-2
drivers/media/platform/vivid/vivid-vbi-cap.c
-2
drivers/media/platform/vivid/vivid-vbi-cap.c
-2
drivers/media/platform/vivid/vivid-vbi-out.c
-2
drivers/media/platform/vivid/vivid-vbi-out.c
-2
drivers/media/platform/vivid/vivid-vid-cap.c
-2
drivers/media/platform/vivid/vivid-vid-cap.c
-2
drivers/media/platform/vivid/vivid-vid-out.c
-2
drivers/media/platform/vivid/vivid-vid-out.c
+1
-1
drivers/media/platform/vsp1/vsp1_lif.c
+1
-1
drivers/media/platform/vsp1/vsp1_lif.c
···
95
95
format = vsp1_entity_get_pad_format(&lif->entity, lif->entity.config,
96
96
LIF_PAD_SOURCE);
97
97
98
-
switch (entity->vsp1->version & VI6_IP_VERSION_SOC_MASK) {
98
+
switch (entity->vsp1->version & VI6_IP_VERSION_MODEL_MASK) {
99
99
case VI6_IP_VERSION_MODEL_VSPD_GEN2:
100
100
case VI6_IP_VERSION_MODEL_VSPD_V2H:
101
101
hbth = 1536;
+2
-2
drivers/media/v4l2-core/v4l2-ctrls.c
+2
-2
drivers/media/v4l2-core/v4l2-ctrls.c
···
1563
1563
u64 offset;
1564
1564
s64 val;
1565
1565
1566
-
switch (ctrl->type) {
1566
+
switch ((u32)ctrl->type) {
1567
1567
case V4L2_CTRL_TYPE_INTEGER:
1568
1568
return ROUND_TO_RANGE(ptr.p_s32[idx], u32, ctrl);
1569
1569
case V4L2_CTRL_TYPE_INTEGER64:
···
2232
2232
is_array = nr_of_dims > 0;
2233
2233
2234
2234
/* Prefill elem_size for all types handled by std_type_ops */
2235
-
switch (type) {
2235
+
switch ((u32)type) {
2236
2236
case V4L2_CTRL_TYPE_INTEGER64:
2237
2237
elem_size = sizeof(s64);
2238
2238
break;
+1
drivers/staging/media/sunxi/cedrus/Kconfig
+1
drivers/staging/media/sunxi/cedrus/Kconfig
+2
-2
drivers/staging/media/sunxi/cedrus/cedrus_hw.c
+2
-2
drivers/staging/media/sunxi/cedrus/cedrus_hw.c
···
255
255
256
256
res = platform_get_resource(dev->pdev, IORESOURCE_MEM, 0);
257
257
dev->base = devm_ioremap_resource(dev->dev, res);
258
-
if (!dev->base) {
258
+
if (IS_ERR(dev->base)) {
259
259
v4l2_err(&dev->v4l2_dev, "Failed to map registers\n");
260
260
261
-
ret = -ENOMEM;
261
+
ret = PTR_ERR(dev->base);
262
262
goto err_sram;
263
263
}
264
264
+86
include/media/mpeg2-ctrls.h
+86
include/media/mpeg2-ctrls.h
···
1
+
/* SPDX-License-Identifier: GPL-2.0 */
2
+
/*
3
+
* These are the MPEG2 state controls for use with stateless MPEG-2
4
+
* codec drivers.
5
+
*
6
+
* It turns out that these structs are not stable yet and will undergo
7
+
* more changes. So keep them private until they are stable and ready to
8
+
* become part of the official public API.
9
+
*/
10
+
11
+
#ifndef _MPEG2_CTRLS_H_
12
+
#define _MPEG2_CTRLS_H_
13
+
14
+
#define V4L2_CID_MPEG_VIDEO_MPEG2_SLICE_PARAMS (V4L2_CID_MPEG_BASE+250)
15
+
#define V4L2_CID_MPEG_VIDEO_MPEG2_QUANTIZATION (V4L2_CID_MPEG_BASE+251)
16
+
17
+
/* enum v4l2_ctrl_type type values */
18
+
#define V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS 0x0103
19
+
#define V4L2_CTRL_TYPE_MPEG2_QUANTIZATION 0x0104
20
+
21
+
#define V4L2_MPEG2_PICTURE_CODING_TYPE_I 1
22
+
#define V4L2_MPEG2_PICTURE_CODING_TYPE_P 2
23
+
#define V4L2_MPEG2_PICTURE_CODING_TYPE_B 3
24
+
#define V4L2_MPEG2_PICTURE_CODING_TYPE_D 4
25
+
26
+
struct v4l2_mpeg2_sequence {
27
+
/* ISO/IEC 13818-2, ITU-T Rec. H.262: Sequence header */
28
+
__u16 horizontal_size;
29
+
__u16 vertical_size;
30
+
__u32 vbv_buffer_size;
31
+
32
+
/* ISO/IEC 13818-2, ITU-T Rec. H.262: Sequence extension */
33
+
__u8 profile_and_level_indication;
34
+
__u8 progressive_sequence;
35
+
__u8 chroma_format;
36
+
__u8 pad;
37
+
};
38
+
39
+
struct v4l2_mpeg2_picture {
40
+
/* ISO/IEC 13818-2, ITU-T Rec. H.262: Picture header */
41
+
__u8 picture_coding_type;
42
+
43
+
/* ISO/IEC 13818-2, ITU-T Rec. H.262: Picture coding extension */
44
+
__u8 f_code[2][2];
45
+
__u8 intra_dc_precision;
46
+
__u8 picture_structure;
47
+
__u8 top_field_first;
48
+
__u8 frame_pred_frame_dct;
49
+
__u8 concealment_motion_vectors;
50
+
__u8 q_scale_type;
51
+
__u8 intra_vlc_format;
52
+
__u8 alternate_scan;
53
+
__u8 repeat_first_field;
54
+
__u8 progressive_frame;
55
+
__u8 pad;
56
+
};
57
+
58
+
struct v4l2_ctrl_mpeg2_slice_params {
59
+
__u32 bit_size;
60
+
__u32 data_bit_offset;
61
+
62
+
struct v4l2_mpeg2_sequence sequence;
63
+
struct v4l2_mpeg2_picture picture;
64
+
65
+
/* ISO/IEC 13818-2, ITU-T Rec. H.262: Slice */
66
+
__u8 quantiser_scale_code;
67
+
68
+
__u8 backward_ref_index;
69
+
__u8 forward_ref_index;
70
+
__u8 pad;
71
+
};
72
+
73
+
struct v4l2_ctrl_mpeg2_quantization {
74
+
/* ISO/IEC 13818-2, ITU-T Rec. H.262: Quant matrix extension */
75
+
__u8 load_intra_quantiser_matrix;
76
+
__u8 load_non_intra_quantiser_matrix;
77
+
__u8 load_chroma_intra_quantiser_matrix;
78
+
__u8 load_chroma_non_intra_quantiser_matrix;
79
+
80
+
__u8 intra_quantiser_matrix[64];
81
+
__u8 non_intra_quantiser_matrix[64];
82
+
__u8 chroma_intra_quantiser_matrix[64];
83
+
__u8 chroma_non_intra_quantiser_matrix[64];
84
+
};
85
+
86
+
#endif
+6
include/media/v4l2-ctrls.h
+6
include/media/v4l2-ctrls.h
···
22
22
#include <linux/videodev2.h>
23
23
#include <media/media-request.h>
24
24
25
+
/*
26
+
* Include the mpeg2 stateless codec compound control definitions.
27
+
* This will move to the public headers once this API is fully stable.
28
+
*/
29
+
#include <media/mpeg2-ctrls.h>
30
+
25
31
/* forward references */
26
32
struct file;
27
33
struct v4l2_ctrl_handler;
+2
include/media/videobuf2-core.h
+2
include/media/videobuf2-core.h
···
239
239
* @num_planes: number of planes in the buffer
240
240
* on an internal driver queue.
241
241
* @timestamp: frame timestamp in ns.
242
+
* @request: the request this buffer is associated with.
242
243
* @req_obj: used to bind this buffer to a request. This
243
244
* request object has a refcount.
244
245
*/
···
250
249
unsigned int memory;
251
250
unsigned int num_planes;
252
251
u64 timestamp;
252
+
struct media_request *request;
253
253
struct media_request_object req_obj;
254
254
255
255
/* private: internal use only
-68
include/uapi/linux/v4l2-controls.h
-68
include/uapi/linux/v4l2-controls.h
···
404
404
#define V4L2_CID_MPEG_VIDEO_MV_V_SEARCH_RANGE (V4L2_CID_MPEG_BASE+228)
405
405
#define V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME (V4L2_CID_MPEG_BASE+229)
406
406
407
-
#define V4L2_CID_MPEG_VIDEO_MPEG2_SLICE_PARAMS (V4L2_CID_MPEG_BASE+250)
408
-
#define V4L2_CID_MPEG_VIDEO_MPEG2_QUANTIZATION (V4L2_CID_MPEG_BASE+251)
409
-
410
407
#define V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP (V4L2_CID_MPEG_BASE+300)
411
408
#define V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP (V4L2_CID_MPEG_BASE+301)
412
409
#define V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP (V4L2_CID_MPEG_BASE+302)
···
1093
1096
#define V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD (V4L2_CID_DETECT_CLASS_BASE + 2)
1094
1097
#define V4L2_CID_DETECT_MD_THRESHOLD_GRID (V4L2_CID_DETECT_CLASS_BASE + 3)
1095
1098
#define V4L2_CID_DETECT_MD_REGION_GRID (V4L2_CID_DETECT_CLASS_BASE + 4)
1096
-
1097
-
#define V4L2_MPEG2_PICTURE_CODING_TYPE_I 1
1098
-
#define V4L2_MPEG2_PICTURE_CODING_TYPE_P 2
1099
-
#define V4L2_MPEG2_PICTURE_CODING_TYPE_B 3
1100
-
#define V4L2_MPEG2_PICTURE_CODING_TYPE_D 4
1101
-
1102
-
struct v4l2_mpeg2_sequence {
1103
-
/* ISO/IEC 13818-2, ITU-T Rec. H.262: Sequence header */
1104
-
__u16 horizontal_size;
1105
-
__u16 vertical_size;
1106
-
__u32 vbv_buffer_size;
1107
-
1108
-
/* ISO/IEC 13818-2, ITU-T Rec. H.262: Sequence extension */
1109
-
__u8 profile_and_level_indication;
1110
-
__u8 progressive_sequence;
1111
-
__u8 chroma_format;
1112
-
__u8 pad;
1113
-
};
1114
-
1115
-
struct v4l2_mpeg2_picture {
1116
-
/* ISO/IEC 13818-2, ITU-T Rec. H.262: Picture header */
1117
-
__u8 picture_coding_type;
1118
-
1119
-
/* ISO/IEC 13818-2, ITU-T Rec. H.262: Picture coding extension */
1120
-
__u8 f_code[2][2];
1121
-
__u8 intra_dc_precision;
1122
-
__u8 picture_structure;
1123
-
__u8 top_field_first;
1124
-
__u8 frame_pred_frame_dct;
1125
-
__u8 concealment_motion_vectors;
1126
-
__u8 q_scale_type;
1127
-
__u8 intra_vlc_format;
1128
-
__u8 alternate_scan;
1129
-
__u8 repeat_first_field;
1130
-
__u8 progressive_frame;
1131
-
__u8 pad;
1132
-
};
1133
-
1134
-
struct v4l2_ctrl_mpeg2_slice_params {
1135
-
__u32 bit_size;
1136
-
__u32 data_bit_offset;
1137
-
1138
-
struct v4l2_mpeg2_sequence sequence;
1139
-
struct v4l2_mpeg2_picture picture;
1140
-
1141
-
/* ISO/IEC 13818-2, ITU-T Rec. H.262: Slice */
1142
-
__u8 quantiser_scale_code;
1143
-
1144
-
__u8 backward_ref_index;
1145
-
__u8 forward_ref_index;
1146
-
__u8 pad;
1147
-
};
1148
-
1149
-
struct v4l2_ctrl_mpeg2_quantization {
1150
-
/* ISO/IEC 13818-2, ITU-T Rec. H.262: Quant matrix extension */
1151
-
__u8 load_intra_quantiser_matrix;
1152
-
__u8 load_non_intra_quantiser_matrix;
1153
-
__u8 load_chroma_intra_quantiser_matrix;
1154
-
__u8 load_chroma_non_intra_quantiser_matrix;
1155
-
1156
-
__u8 intra_quantiser_matrix[64];
1157
-
__u8 non_intra_quantiser_matrix[64];
1158
-
__u8 chroma_intra_quantiser_matrix[64];
1159
-
__u8 chroma_non_intra_quantiser_matrix[64];
1160
-
};
1161
1099
1162
1100
#endif
-4
include/uapi/linux/videodev2.h
-4
include/uapi/linux/videodev2.h
···
1622
1622
__u8 __user *p_u8;
1623
1623
__u16 __user *p_u16;
1624
1624
__u32 __user *p_u32;
1625
-
struct v4l2_ctrl_mpeg2_slice_params __user *p_mpeg2_slice_params;
1626
-
struct v4l2_ctrl_mpeg2_quantization __user *p_mpeg2_quantization;
1627
1625
void __user *ptr;
1628
1626
};
1629
1627
} __attribute__ ((packed));
···
1667
1669
V4L2_CTRL_TYPE_U8 = 0x0100,
1668
1670
V4L2_CTRL_TYPE_U16 = 0x0101,
1669
1671
V4L2_CTRL_TYPE_U32 = 0x0102,
1670
-
V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS = 0x0103,
1671
-
V4L2_CTRL_TYPE_MPEG2_QUANTIZATION = 0x0104,
1672
1672
};
1673
1673
1674
1674
/* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */