projects / openwrt / staging / luka.git / blob
? search:


0fe0f8cea40e1a6aee101a8ddc3c23df51c4c8c0
[openwrt/staging/luka.git] /
1 From 5f6c08984a6578201fe3a2394ccb0d3a30fdf027 Mon Sep 17 00:00:00 2001
2 From: Paul Kocialkowski <paul.kocialkowski@bootlin.com>
3 Date: Tue, 22 Oct 2019 12:26:52 -0300
4 Subject: [PATCH] media: v4l: Add definitions for HEVC stateless
5 decoding
6
7 This introduces the required definitions for HEVC decoding support with
8 stateless VPUs. The controls associated to the HEVC slice format provide
9 the required meta-data for decoding slices extracted from the bitstream.
10
11 They are not exported to the public V4L2 API since reworking this API
12 will likely be needed for covering various use-cases and new hardware.
13
14 Multi-slice decoding is exposed as a valid decoding mode to match current
15 H.264 support but it is not yet implemented.
16
17 The interface comes with the following limitations:
18 * No custom quantization matrices (scaling lists);
19 * Support for a single temporal layer only;
20 * No slice entry point offsets support;
21 * No conformance window support;
22 * No VUI parameters support;
23 * No support for SPS extensions: range, multilayer, 3d, scc, 4 bits;
24 * No support for PPS extensions: range, multilayer, 3d, scc, 4 bits.
25
26 Signed-off-by: Paul Kocialkowski <paul.kocialkowski@bootlin.com>
27 [hverkuil-cisco@xs4all.nl: use 1ULL in flags defines in hevc-ctrls.h]
28 Signed-off-by: Hans Verkuil <hverkuil-cisco@xs4all.nl>
29 Signed-off-by: Mauro Carvalho Chehab <mchehab+samsung@kernel.org>
30 ---
31 Documentation/media/uapi/v4l/biblio.rst | 9 +
32 .../media/uapi/v4l/ext-ctrls-codec.rst | 553 +++++++++++++++++-
33 .../media/uapi/v4l/vidioc-queryctrl.rst | 18 +
34 .../media/videodev2.h.rst.exceptions | 3 +
35 drivers/media/v4l2-core/v4l2-ctrls.c | 109 +++-
36 drivers/media/v4l2-core/v4l2-ioctl.c | 1 +
37 include/media/hevc-ctrls.h | 212 +++++++
38 include/media/v4l2-ctrls.h | 7 +
39 8 files changed, 908 insertions(+), 4 deletions(-)
40 create mode 100644 include/media/hevc-ctrls.h
41
42 --- a/Documentation/media/uapi/v4l/biblio.rst
43 +++ b/Documentation/media/uapi/v4l/biblio.rst
44 @@ -131,6 +131,15 @@ ITU-T Rec. H.264 Specification (04/2017
45
46 :author: International Telecommunication Union (http://www.itu.ch)
47
48 +.. _hevc:
49 +
50 +ITU H.265/HEVC
51 +==============
52 +
53 +:title: ITU-T Rec. H.265 | ISO/IEC 23008-2 "High Efficiency Video Coding"
54 +
55 +:author: International Telecommunication Union (http://www.itu.ch), International Organisation for Standardisation (http://www.iso.ch)
56 +
57 .. _jfif:
58
59 JFIF
60 --- a/Documentation/media/uapi/v4l/ext-ctrls-codec.rst
61 +++ b/Documentation/media/uapi/v4l/ext-ctrls-codec.rst
62 @@ -1983,9 +1983,9 @@ enum v4l2_mpeg_video_h264_hierarchical_c
63 - ``reference_ts``
64 - Timestamp of the V4L2 capture buffer to use as reference, used
65 with B-coded and P-coded frames. The timestamp refers to the
66 - ``timestamp`` field in struct :c:type:`v4l2_buffer`. Use the
67 - :c:func:`v4l2_timeval_to_ns()` function to convert the struct
68 - :c:type:`timeval` in struct :c:type:`v4l2_buffer` to a __u64.
69 + ``timestamp`` field in struct :c:type:`v4l2_buffer`. Use the
70 + :c:func:`v4l2_timeval_to_ns()` function to convert the struct
71 + :c:type:`timeval` in struct :c:type:`v4l2_buffer` to a __u64.
72 * - __u16
73 - ``frame_num``
74 -
75 @@ -3693,3 +3693,550 @@ enum v4l2_mpeg_video_hevc_size_of_length
76 Indicates whether to generate SPS and PPS at every IDR. Setting it to 0
77 disables generating SPS and PPS at every IDR. Setting it to one enables
78 generating SPS and PPS at every IDR.
79 +
80 +.. _v4l2-mpeg-hevc:
81 +
82 +``V4L2_CID_MPEG_VIDEO_HEVC_SPS (struct)``
83 + Specifies the Sequence Parameter Set fields (as extracted from the
84 + bitstream) for the associated HEVC slice data.
85 + These bitstream parameters are defined according to :ref:`hevc`.
86 + They are described in section 7.4.3.2 "Sequence parameter set RBSP
87 + semantics" of the specification.
88 +
89 +.. c:type:: v4l2_ctrl_hevc_sps
90 +
91 +.. cssclass:: longtable
92 +
93 +.. flat-table:: struct v4l2_ctrl_hevc_sps
94 + :header-rows: 0
95 + :stub-columns: 0
96 + :widths: 1 1 2
97 +
98 + * - __u16
99 + - ``pic_width_in_luma_samples``
100 + -
101 + * - __u16
102 + - ``pic_height_in_luma_samples``
103 + -
104 + * - __u8
105 + - ``bit_depth_luma_minus8``
106 + -
107 + * - __u8
108 + - ``bit_depth_chroma_minus8``
109 + -
110 + * - __u8
111 + - ``log2_max_pic_order_cnt_lsb_minus4``
112 + -
113 + * - __u8
114 + - ``sps_max_dec_pic_buffering_minus1``
115 + -
116 + * - __u8
117 + - ``sps_max_num_reorder_pics``
118 + -
119 + * - __u8
120 + - ``sps_max_latency_increase_plus1``
121 + -
122 + * - __u8
123 + - ``log2_min_luma_coding_block_size_minus3``
124 + -
125 + * - __u8
126 + - ``log2_diff_max_min_luma_coding_block_size``
127 + -
128 + * - __u8
129 + - ``log2_min_luma_transform_block_size_minus2``
130 + -
131 + * - __u8
132 + - ``log2_diff_max_min_luma_transform_block_size``
133 + -
134 + * - __u8
135 + - ``max_transform_hierarchy_depth_inter``
136 + -
137 + * - __u8
138 + - ``max_transform_hierarchy_depth_intra``
139 + -
140 + * - __u8
141 + - ``pcm_sample_bit_depth_luma_minus1``
142 + -
143 + * - __u8
144 + - ``pcm_sample_bit_depth_chroma_minus1``
145 + -
146 + * - __u8
147 + - ``log2_min_pcm_luma_coding_block_size_minus3``
148 + -
149 + * - __u8
150 + - ``log2_diff_max_min_pcm_luma_coding_block_size``
151 + -
152 + * - __u8
153 + - ``num_short_term_ref_pic_sets``
154 + -
155 + * - __u8
156 + - ``num_long_term_ref_pics_sps``
157 + -
158 + * - __u8
159 + - ``chroma_format_idc``
160 + -
161 + * - __u64
162 + - ``flags``
163 + - See :ref:`Sequence Parameter Set Flags <hevc_sps_flags>`
164 +
165 +.. _hevc_sps_flags:
166 +
167 +``Sequence Parameter Set Flags``
168 +
169 +.. cssclass:: longtable
170 +
171 +.. flat-table::
172 + :header-rows: 0
173 + :stub-columns: 0
174 + :widths: 1 1 2
175 +
176 + * - ``V4L2_HEVC_SPS_FLAG_SEPARATE_COLOUR_PLANE``
177 + - 0x00000001
178 + -
179 + * - ``V4L2_HEVC_SPS_FLAG_SCALING_LIST_ENABLED``
180 + - 0x00000002
181 + -
182 + * - ``V4L2_HEVC_SPS_FLAG_AMP_ENABLED``
183 + - 0x00000004
184 + -
185 + * - ``V4L2_HEVC_SPS_FLAG_SAMPLE_ADAPTIVE_OFFSET``
186 + - 0x00000008
187 + -
188 + * - ``V4L2_HEVC_SPS_FLAG_PCM_ENABLED``
189 + - 0x00000010
190 + -
191 + * - ``V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED``
192 + - 0x00000020
193 + -
194 + * - ``V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT``
195 + - 0x00000040
196 + -
197 + * - ``V4L2_HEVC_SPS_FLAG_SPS_TEMPORAL_MVP_ENABLED``
198 + - 0x00000080
199 + -
200 + * - ``V4L2_HEVC_SPS_FLAG_STRONG_INTRA_SMOOTHING_ENABLED``
201 + - 0x00000100
202 + -
203 +
204 +``V4L2_CID_MPEG_VIDEO_HEVC_PPS (struct)``
205 + Specifies the Picture Parameter Set fields (as extracted from the
206 + bitstream) for the associated HEVC slice data.
207 + These bitstream parameters are defined according to :ref:`hevc`.
208 + They are described in section 7.4.3.3 "Picture parameter set RBSP
209 + semantics" of the specification.
210 +
211 +.. c:type:: v4l2_ctrl_hevc_pps
212 +
213 +.. cssclass:: longtable
214 +
215 +.. flat-table:: struct v4l2_ctrl_hevc_pps
216 + :header-rows: 0
217 + :stub-columns: 0
218 + :widths: 1 1 2
219 +
220 + * - __u8
221 + - ``num_extra_slice_header_bits``
222 + -
223 + * - __s8
224 + - ``init_qp_minus26``
225 + -
226 + * - __u8
227 + - ``diff_cu_qp_delta_depth``
228 + -
229 + * - __s8
230 + - ``pps_cb_qp_offset``
231 + -
232 + * - __s8
233 + - ``pps_cr_qp_offset``
234 + -
235 + * - __u8
236 + - ``num_tile_columns_minus1``
237 + -
238 + * - __u8
239 + - ``num_tile_rows_minus1``
240 + -
241 + * - __u8
242 + - ``column_width_minus1[20]``
243 + -
244 + * - __u8
245 + - ``row_height_minus1[22]``
246 + -
247 + * - __s8
248 + - ``pps_beta_offset_div2``
249 + -
250 + * - __s8
251 + - ``pps_tc_offset_div2``
252 + -
253 + * - __u8
254 + - ``log2_parallel_merge_level_minus2``
255 + -
256 + * - __u8
257 + - ``padding[4]``
258 + - Applications and drivers must set this to zero.
259 + * - __u64
260 + - ``flags``
261 + - See :ref:`Picture Parameter Set Flags <hevc_pps_flags>`
262 +
263 +.. _hevc_pps_flags:
264 +
265 +``Picture Parameter Set Flags``
266 +
267 +.. cssclass:: longtable
268 +
269 +.. flat-table::
270 + :header-rows: 0
271 + :stub-columns: 0
272 + :widths: 1 1 2
273 +
274 + * - ``V4L2_HEVC_PPS_FLAG_DEPENDENT_SLICE_SEGMENT``
275 + - 0x00000001
276 + -
277 + * - ``V4L2_HEVC_PPS_FLAG_OUTPUT_FLAG_PRESENT``
278 + - 0x00000002
279 + -
280 + * - ``V4L2_HEVC_PPS_FLAG_SIGN_DATA_HIDING_ENABLED``
281 + - 0x00000004
282 + -
283 + * - ``V4L2_HEVC_PPS_FLAG_CABAC_INIT_PRESENT``
284 + - 0x00000008
285 + -
286 + * - ``V4L2_HEVC_PPS_FLAG_CONSTRAINED_INTRA_PRED``
287 + - 0x00000010
288 + -
289 + * - ``V4L2_HEVC_PPS_FLAG_TRANSFORM_SKIP_ENABLED``
290 + - 0x00000020
291 + -
292 + * - ``V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED``
293 + - 0x00000040
294 + -
295 + * - ``V4L2_HEVC_PPS_FLAG_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT``
296 + - 0x00000080
297 + -
298 + * - ``V4L2_HEVC_PPS_FLAG_WEIGHTED_PRED``
299 + - 0x00000100
300 + -
301 + * - ``V4L2_HEVC_PPS_FLAG_WEIGHTED_BIPRED``
302 + - 0x00000200
303 + -
304 + * - ``V4L2_HEVC_PPS_FLAG_TRANSQUANT_BYPASS_ENABLED``
305 + - 0x00000400
306 + -
307 + * - ``V4L2_HEVC_PPS_FLAG_TILES_ENABLED``
308 + - 0x00000800
309 + -
310 + * - ``V4L2_HEVC_PPS_FLAG_ENTROPY_CODING_SYNC_ENABLED``
311 + - 0x00001000
312 + -
313 + * - ``V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED``
314 + - 0x00002000
315 + -
316 + * - ``V4L2_HEVC_PPS_FLAG_PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED``
317 + - 0x00004000
318 + -
319 + * - ``V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_OVERRIDE_ENABLED``
320 + - 0x00008000
321 + -
322 + * - ``V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER``
323 + - 0x00010000
324 + -
325 + * - ``V4L2_HEVC_PPS_FLAG_LISTS_MODIFICATION_PRESENT``
326 + - 0x00020000
327 + -
328 + * - ``V4L2_HEVC_PPS_FLAG_SLICE_SEGMENT_HEADER_EXTENSION_PRESENT``
329 + - 0x00040000
330 + -
331 +
332 +``V4L2_CID_MPEG_VIDEO_HEVC_SLICE_PARAMS (struct)``
333 + Specifies various slice-specific parameters, especially from the NAL unit
334 + header, general slice segment header and weighted prediction parameter
335 + parts of the bitstream.
336 + These bitstream parameters are defined according to :ref:`hevc`.
337 + They are described in section 7.4.7 "General slice segment header
338 + semantics" of the specification.
339 +
340 +.. c:type:: v4l2_ctrl_hevc_slice_params
341 +
342 +.. cssclass:: longtable
343 +
344 +.. flat-table:: struct v4l2_ctrl_hevc_slice_params
345 + :header-rows: 0
346 + :stub-columns: 0
347 + :widths: 1 1 2
348 +
349 + * - __u32
350 + - ``bit_size``
351 + - Size (in bits) of the current slice data.
352 + * - __u32
353 + - ``data_bit_offset``
354 + - Offset (in bits) to the video data in the current slice data.
355 + * - __u8
356 + - ``nal_unit_type``
357 + -
358 + * - __u8
359 + - ``nuh_temporal_id_plus1``
360 + -
361 + * - __u8
362 + - ``slice_type``
363 + -
364 + (V4L2_HEVC_SLICE_TYPE_I, V4L2_HEVC_SLICE_TYPE_P or
365 + V4L2_HEVC_SLICE_TYPE_B).
366 + * - __u8
367 + - ``colour_plane_id``
368 + -
369 + * - __u16
370 + - ``slice_pic_order_cnt``
371 + -
372 + * - __u8
373 + - ``num_ref_idx_l0_active_minus1``
374 + -
375 + * - __u8
376 + - ``num_ref_idx_l1_active_minus1``
377 + -
378 + * - __u8
379 + - ``collocated_ref_idx``
380 + -
381 + * - __u8
382 + - ``five_minus_max_num_merge_cand``
383 + -
384 + * - __s8
385 + - ``slice_qp_delta``
386 + -
387 + * - __s8
388 + - ``slice_cb_qp_offset``
389 + -
390 + * - __s8
391 + - ``slice_cr_qp_offset``
392 + -
393 + * - __s8
394 + - ``slice_act_y_qp_offset``
395 + -
396 + * - __s8
397 + - ``slice_act_cb_qp_offset``
398 + -
399 + * - __s8
400 + - ``slice_act_cr_qp_offset``
401 + -
402 + * - __s8
403 + - ``slice_beta_offset_div2``
404 + -
405 + * - __s8
406 + - ``slice_tc_offset_div2``
407 + -
408 + * - __u8
409 + - ``pic_struct``
410 + -
411 + * - __u8
412 + - ``num_active_dpb_entries``
413 + - The number of entries in ``dpb``.
414 + * - __u8
415 + - ``ref_idx_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]``
416 + - The list of L0 reference elements as indices in the DPB.
417 + * - __u8
418 + - ``ref_idx_l1[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]``
419 + - The list of L1 reference elements as indices in the DPB.
420 + * - __u8
421 + - ``num_rps_poc_st_curr_before``
422 + - The number of reference pictures in the short-term set that come before
423 + the current frame.
424 + * - __u8
425 + - ``num_rps_poc_st_curr_after``
426 + - The number of reference pictures in the short-term set that come after
427 + the current frame.
428 + * - __u8
429 + - ``num_rps_poc_lt_curr``
430 + - The number of reference pictures in the long-term set.
431 + * - __u8
432 + - ``padding[7]``
433 + - Applications and drivers must set this to zero.
434 + * - struct :c:type:`v4l2_hevc_dpb_entry`
435 + - ``dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]``
436 + - The decoded picture buffer, for meta-data about reference frames.
437 + * - struct :c:type:`v4l2_hevc_pred_weight_table`
438 + - ``pred_weight_table``
439 + - The prediction weight coefficients for inter-picture prediction.
440 + * - __u64
441 + - ``flags``
442 + - See :ref:`Slice Parameters Flags <hevc_slice_params_flags>`
443 +
444 +.. _hevc_slice_params_flags:
445 +
446 +``Slice Parameters Flags``
447 +
448 +.. cssclass:: longtable
449 +
450 +.. flat-table::
451 + :header-rows: 0
452 + :stub-columns: 0
453 + :widths: 1 1 2
454 +
455 + * - ``V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_LUMA``
456 + - 0x00000001
457 + -
458 + * - ``V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_CHROMA``
459 + - 0x00000002
460 + -
461 + * - ``V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_TEMPORAL_MVP_ENABLED``
462 + - 0x00000004
463 + -
464 + * - ``V4L2_HEVC_SLICE_PARAMS_FLAG_MVD_L1_ZERO``
465 + - 0x00000008
466 + -
467 + * - ``V4L2_HEVC_SLICE_PARAMS_FLAG_CABAC_INIT``
468 + - 0x00000010
469 + -
470 + * - ``V4L2_HEVC_SLICE_PARAMS_FLAG_COLLOCATED_FROM_L0``
471 + - 0x00000020
472 + -
473 + * - ``V4L2_HEVC_SLICE_PARAMS_FLAG_USE_INTEGER_MV``
474 + - 0x00000040
475 + -
476 + * - ``V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_DEBLOCKING_FILTER_DISABLED``
477 + - 0x00000080
478 + -
479 + * - ``V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED``
480 + - 0x00000100
481 + -
482 +
483 +.. c:type:: v4l2_hevc_dpb_entry
484 +
485 +.. cssclass:: longtable
486 +
487 +.. flat-table:: struct v4l2_hevc_dpb_entry
488 + :header-rows: 0
489 + :stub-columns: 0
490 + :widths: 1 1 2
491 +
492 + * - __u64
493 + - ``timestamp``
494 + - Timestamp of the V4L2 capture buffer to use as reference, used
495 + with B-coded and P-coded frames. The timestamp refers to the
496 + ``timestamp`` field in struct :c:type:`v4l2_buffer`. Use the
497 + :c:func:`v4l2_timeval_to_ns()` function to convert the struct
498 + :c:type:`timeval` in struct :c:type:`v4l2_buffer` to a __u64.
499 + * - __u8
500 + - ``rps``
501 + - The reference set for the reference frame
502 + (V4L2_HEVC_DPB_ENTRY_RPS_ST_CURR_BEFORE,
503 + V4L2_HEVC_DPB_ENTRY_RPS_ST_CURR_AFTER or
504 + V4L2_HEVC_DPB_ENTRY_RPS_LT_CURR)
505 + * - __u8
506 + - ``field_pic``
507 + - Whether the reference is a field picture or a frame.
508 + * - __u16
509 + - ``pic_order_cnt[2]``
510 + - The picture order count of the reference. Only the first element of the
511 + array is used for frame pictures, while the first element identifies the
512 + top field and the second the bottom field in field-coded pictures.
513 + * - __u8
514 + - ``padding[2]``
515 + - Applications and drivers must set this to zero.
516 +
517 +.. c:type:: v4l2_hevc_pred_weight_table
518 +
519 +.. cssclass:: longtable
520 +
521 +.. flat-table:: struct v4l2_hevc_pred_weight_table
522 + :header-rows: 0
523 + :stub-columns: 0
524 + :widths: 1 1 2
525 +
526 + * - __u8
527 + - ``luma_log2_weight_denom``
528 + -
529 + * - __s8
530 + - ``delta_chroma_log2_weight_denom``
531 + -
532 + * - __s8
533 + - ``delta_luma_weight_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]``
534 + -
535 + * - __s8
536 + - ``luma_offset_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]``
537 + -
538 + * - __s8
539 + - ``delta_chroma_weight_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX][2]``
540 + -
541 + * - __s8
542 + - ``chroma_offset_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX][2]``
543 + -
544 + * - __s8
545 + - ``delta_luma_weight_l1[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]``
546 + -
547 + * - __s8
548 + - ``luma_offset_l1[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]``
549 + -
550 + * - __s8
551 + - ``delta_chroma_weight_l1[V4L2_HEVC_DPB_ENTRIES_NUM_MAX][2]``
552 + -
553 + * - __s8
554 + - ``chroma_offset_l1[V4L2_HEVC_DPB_ENTRIES_NUM_MAX][2]``
555 + -
556 + * - __u8
557 + - ``padding[6]``
558 + - Applications and drivers must set this to zero.
559 +
560 +``V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE (enum)``
561 + Specifies the decoding mode to use. Currently exposes slice-based and
562 + frame-based decoding but new modes might be added later on.
563 + This control is used as a modifier for V4L2_PIX_FMT_HEVC_SLICE
564 + pixel format. Applications that support V4L2_PIX_FMT_HEVC_SLICE
565 + are required to set this control in order to specify the decoding mode
566 + that is expected for the buffer.
567 + Drivers may expose a single or multiple decoding modes, depending
568 + on what they can support.
569 +
570 + .. note::
571 +
572 + This menu control is not yet part of the public kernel API and
573 + it is expected to change.
574 +
575 +.. c:type:: v4l2_mpeg_video_hevc_decode_mode
576 +
577 +.. cssclass:: longtable
578 +
579 +.. flat-table::
580 + :header-rows: 0
581 + :stub-columns: 0
582 + :widths: 1 1 2
583 +
584 + * - ``V4L2_MPEG_VIDEO_HEVC_DECODE_MODE_SLICE_BASED``
585 + - 0
586 + - Decoding is done at the slice granularity.
587 + The OUTPUT buffer must contain a single slice.
588 + * - ``V4L2_MPEG_VIDEO_HEVC_DECODE_MODE_FRAME_BASED``
589 + - 1
590 + - Decoding is done at the frame granularity.
591 + The OUTPUT buffer must contain all slices needed to decode the
592 + frame. The OUTPUT buffer must also contain both fields.
593 +
594 +``V4L2_CID_MPEG_VIDEO_HEVC_START_CODE (enum)``
595 + Specifies the HEVC slice start code expected for each slice.
596 + This control is used as a modifier for V4L2_PIX_FMT_HEVC_SLICE
597 + pixel format. Applications that support V4L2_PIX_FMT_HEVC_SLICE
598 + are required to set this control in order to specify the start code
599 + that is expected for the buffer.
600 + Drivers may expose a single or multiple start codes, depending
601 + on what they can support.
602 +
603 + .. note::
604 +
605 + This menu control is not yet part of the public kernel API and
606 + it is expected to change.
607 +
608 +.. c:type:: v4l2_mpeg_video_hevc_start_code
609 +
610 +.. cssclass:: longtable
611 +
612 +.. flat-table::
613 + :header-rows: 0
614 + :stub-columns: 0
615 + :widths: 1 1 2
616 +
617 + * - ``V4L2_MPEG_VIDEO_HEVC_START_CODE_NONE``
618 + - 0
619 + - Selecting this value specifies that HEVC slices are passed
620 + to the driver without any start code.
621 + * - ``V4L2_MPEG_VIDEO_HEVC_START_CODE_ANNEX_B``
622 + - 1
623 + - Selecting this value specifies that HEVC slices are expected
624 + to be prefixed by Annex B start codes. According to :ref:`hevc`
625 + valid start codes can be 3-bytes 0x000001 or 4-bytes 0x00000001.
626 --- a/Documentation/media/uapi/v4l/vidioc-queryctrl.rst
627 +++ b/Documentation/media/uapi/v4l/vidioc-queryctrl.rst
628 @@ -479,6 +479,24 @@ See also the examples in :ref:`control`.
629 - n/a
630 - A struct :c:type:`v4l2_ctrl_h264_decode_params`, containing H264
631 decode parameters for stateless video decoders.
632 + * - ``V4L2_CTRL_TYPE_HEVC_SPS``
633 + - n/a
634 + - n/a
635 + - n/a
636 + - A struct :c:type:`v4l2_ctrl_hevc_sps`, containing HEVC Sequence
637 + Parameter Set for stateless video decoders.
638 + * - ``V4L2_CTRL_TYPE_HEVC_PPS``
639 + - n/a
640 + - n/a
641 + - n/a
642 + - A struct :c:type:`v4l2_ctrl_hevc_pps`, containing HEVC Picture
643 + Parameter Set for stateless video decoders.
644 + * - ``V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS``
645 + - n/a
646 + - n/a
647 + - n/a
648 + - A struct :c:type:`v4l2_ctrl_hevc_slice_params`, containing HEVC
649 + slice parameters for stateless video decoders.
650
651 .. tabularcolumns:: |p{6.6cm}|p{2.2cm}|p{8.7cm}|
652
653 --- a/Documentation/media/videodev2.h.rst.exceptions
654 +++ b/Documentation/media/videodev2.h.rst.exceptions
655 @@ -141,6 +141,9 @@ replace symbol V4L2_CTRL_TYPE_H264_PPS :
656 replace symbol V4L2_CTRL_TYPE_H264_SCALING_MATRIX :c:type:`v4l2_ctrl_type`
657 replace symbol V4L2_CTRL_TYPE_H264_SLICE_PARAMS :c:type:`v4l2_ctrl_type`
658 replace symbol V4L2_CTRL_TYPE_H264_DECODE_PARAMS :c:type:`v4l2_ctrl_type`
659 +replace symbol V4L2_CTRL_TYPE_HEVC_SPS :c:type:`v4l2_ctrl_type`
660 +replace symbol V4L2_CTRL_TYPE_HEVC_PPS :c:type:`v4l2_ctrl_type`
661 +replace symbol V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS :c:type:`v4l2_ctrl_type`
662 replace symbol V4L2_CTRL_TYPE_AREA :c:type:`v4l2_ctrl_type`
663
664 # V4L2 capability defines
665 --- a/drivers/media/v4l2-core/v4l2-ctrls.c
666 +++ b/drivers/media/v4l2-core/v4l2-ctrls.c
667 @@ -567,6 +567,16 @@ const char * const *v4l2_ctrl_get_menu(u
668 "Disabled at slice boundary",
669 "NULL",
670 };
671 + static const char * const hevc_decode_mode[] = {
672 + "Slice-Based",
673 + "Frame-Based",
674 + NULL,
675 + };
676 + static const char * const hevc_start_code[] = {
677 + "No Start Code",
678 + "Annex B Start Code",
679 + NULL,
680 + };
681
682 switch (id) {
683 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
684 @@ -688,7 +698,10 @@ const char * const *v4l2_ctrl_get_menu(u
685 return hevc_tier;
686 case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE:
687 return hevc_loop_filter_mode;
688 -
689 + case V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE:
690 + return hevc_decode_mode;
691 + case V4L2_CID_MPEG_VIDEO_HEVC_START_CODE:
692 + return hevc_start_code;
693 default:
694 return NULL;
695 }
696 @@ -958,6 +971,11 @@ const char *v4l2_ctrl_get_name(u32 id)
697 case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD: return "HEVC Size of Length Field";
698 case V4L2_CID_MPEG_VIDEO_REF_NUMBER_FOR_PFRAMES: return "Reference Frames for a P-Frame";
699 case V4L2_CID_MPEG_VIDEO_PREPEND_SPSPPS_TO_IDR: return "Prepend SPS and PPS to IDR";
700 + case V4L2_CID_MPEG_VIDEO_HEVC_SPS: return "HEVC Sequence Parameter Set";
701 + case V4L2_CID_MPEG_VIDEO_HEVC_PPS: return "HEVC Picture Parameter Set";
702 + case V4L2_CID_MPEG_VIDEO_HEVC_SLICE_PARAMS: return "HEVC Slice Parameters";
703 + case V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE: return "HEVC Decode Mode";
704 + case V4L2_CID_MPEG_VIDEO_HEVC_START_CODE: return "HEVC Start Code";
705
706 /* CAMERA controls */
707 /* Keep the order of the 'case's the same as in v4l2-controls.h! */
708 @@ -1267,6 +1285,8 @@ void v4l2_ctrl_fill(u32 id, const char *
709 case V4L2_CID_MPEG_VIDEO_HEVC_SIZE_OF_LENGTH_FIELD:
710 case V4L2_CID_MPEG_VIDEO_HEVC_TIER:
711 case V4L2_CID_MPEG_VIDEO_HEVC_LOOP_FILTER_MODE:
712 + case V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE:
713 + case V4L2_CID_MPEG_VIDEO_HEVC_START_CODE:
714 *type = V4L2_CTRL_TYPE_MENU;
715 break;
716 case V4L2_CID_LINK_FREQ:
717 @@ -1377,6 +1397,15 @@ void v4l2_ctrl_fill(u32 id, const char *
718 case V4L2_CID_MPEG_VIDEO_VP8_FRAME_HEADER:
719 *type = V4L2_CTRL_TYPE_VP8_FRAME_HEADER;
720 break;
721 + case V4L2_CID_MPEG_VIDEO_HEVC_SPS:
722 + *type = V4L2_CTRL_TYPE_HEVC_SPS;
723 + break;
724 + case V4L2_CID_MPEG_VIDEO_HEVC_PPS:
725 + *type = V4L2_CTRL_TYPE_HEVC_PPS;
726 + break;
727 + case V4L2_CID_MPEG_VIDEO_HEVC_SLICE_PARAMS:
728 + *type = V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS;
729 + break;
730 case V4L2_CID_UNIT_CELL_SIZE:
731 *type = V4L2_CTRL_TYPE_AREA;
732 *flags |= V4L2_CTRL_FLAG_READ_ONLY;
733 @@ -1678,8 +1707,12 @@ static int std_validate_compound(const s
734 {
735 struct v4l2_ctrl_mpeg2_slice_params *p_mpeg2_slice_params;
736 struct v4l2_ctrl_vp8_frame_header *p_vp8_frame_header;
737 + struct v4l2_ctrl_hevc_sps *p_hevc_sps;
738 + struct v4l2_ctrl_hevc_pps *p_hevc_pps;
739 + struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params;
740 struct v4l2_area *area;
741 void *p = ptr.p + idx * ctrl->elem_size;
742 + unsigned int i;
743
744 switch ((u32)ctrl->type) {
745 case V4L2_CTRL_TYPE_MPEG2_SLICE_PARAMS:
746 @@ -1755,11 +1788,76 @@ static int std_validate_compound(const s
747 zero_padding(p_vp8_frame_header->entropy_header);
748 zero_padding(p_vp8_frame_header->coder_state);
749 break;
750 +
751 + case V4L2_CTRL_TYPE_HEVC_SPS:
752 + p_hevc_sps = p;
753 +
754 + if (!(p_hevc_sps->flags & V4L2_HEVC_SPS_FLAG_PCM_ENABLED)) {
755 + p_hevc_sps->pcm_sample_bit_depth_luma_minus1 = 0;
756 + p_hevc_sps->pcm_sample_bit_depth_chroma_minus1 = 0;
757 + p_hevc_sps->log2_min_pcm_luma_coding_block_size_minus3 = 0;
758 + p_hevc_sps->log2_diff_max_min_pcm_luma_coding_block_size = 0;
759 + }
760 +
761 + if (!(p_hevc_sps->flags &
762 + V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT))
763 + p_hevc_sps->num_long_term_ref_pics_sps = 0;
764 + break;
765 +
766 + case V4L2_CTRL_TYPE_HEVC_PPS:
767 + p_hevc_pps = p;
768 +
769 + if (!(p_hevc_pps->flags &
770 + V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED))
771 + p_hevc_pps->diff_cu_qp_delta_depth = 0;
772 +
773 + if (!(p_hevc_pps->flags & V4L2_HEVC_PPS_FLAG_TILES_ENABLED)) {
774 + p_hevc_pps->num_tile_columns_minus1 = 0;
775 + p_hevc_pps->num_tile_rows_minus1 = 0;
776 + memset(&p_hevc_pps->column_width_minus1, 0,
777 + sizeof(p_hevc_pps->column_width_minus1));
778 + memset(&p_hevc_pps->row_height_minus1, 0,
779 + sizeof(p_hevc_pps->row_height_minus1));
780 +
781 + p_hevc_pps->flags &=
782 + ~V4L2_HEVC_PPS_FLAG_PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED;
783 + }
784 +
785 + if (p_hevc_pps->flags &
786 + V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER) {
787 + p_hevc_pps->pps_beta_offset_div2 = 0;
788 + p_hevc_pps->pps_tc_offset_div2 = 0;
789 + }
790 +
791 + zero_padding(*p_hevc_pps);
792 + break;
793 +
794 + case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS:
795 + p_hevc_slice_params = p;
796 +
797 + if (p_hevc_slice_params->num_active_dpb_entries >
798 + V4L2_HEVC_DPB_ENTRIES_NUM_MAX)
799 + return -EINVAL;
800 +
801 + zero_padding(p_hevc_slice_params->pred_weight_table);
802 +
803 + for (i = 0; i < p_hevc_slice_params->num_active_dpb_entries;
804 + i++) {
805 + struct v4l2_hevc_dpb_entry *dpb_entry =
806 + &p_hevc_slice_params->dpb[i];
807 +
808 + zero_padding(*dpb_entry);
809 + }
810 +
811 + zero_padding(*p_hevc_slice_params);
812 + break;
813 +
814 case V4L2_CTRL_TYPE_AREA:
815 area = p;
816 if (!area->width || !area->height)
817 return -EINVAL;
818 break;
819 +
820 default:
821 return -EINVAL;
822 }
823 @@ -2433,6 +2531,15 @@ static struct v4l2_ctrl *v4l2_ctrl_new(s
824 case V4L2_CTRL_TYPE_VP8_FRAME_HEADER:
825 elem_size = sizeof(struct v4l2_ctrl_vp8_frame_header);
826 break;
827 + case V4L2_CTRL_TYPE_HEVC_SPS:
828 + elem_size = sizeof(struct v4l2_ctrl_hevc_sps);
829 + break;
830 + case V4L2_CTRL_TYPE_HEVC_PPS:
831 + elem_size = sizeof(struct v4l2_ctrl_hevc_pps);
832 + break;
833 + case V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS:
834 + elem_size = sizeof(struct v4l2_ctrl_hevc_slice_params);
835 + break;
836 case V4L2_CTRL_TYPE_AREA:
837 elem_size = sizeof(struct v4l2_area);
838 break;
839 --- a/drivers/media/v4l2-core/v4l2-ioctl.c
840 +++ b/drivers/media/v4l2-core/v4l2-ioctl.c
841 @@ -1356,6 +1356,7 @@ static void v4l_fill_fmtdesc(struct v4l2
842 case V4L2_PIX_FMT_VP8_FRAME: descr = "VP8 Frame"; break;
843 case V4L2_PIX_FMT_VP9: descr = "VP9"; break;
844 case V4L2_PIX_FMT_HEVC: descr = "HEVC"; break; /* aka H.265 */
845 + case V4L2_PIX_FMT_HEVC_SLICE: descr = "HEVC Parsed Slice Data"; break;
846 case V4L2_PIX_FMT_FWHT: descr = "FWHT"; break; /* used in vicodec */
847 case V4L2_PIX_FMT_FWHT_STATELESS: descr = "FWHT Stateless"; break; /* used in vicodec */
848 case V4L2_PIX_FMT_CPIA1: descr = "GSPCA CPiA YUV"; break;
849 --- /dev/null
850 +++ b/include/media/hevc-ctrls.h
851 @@ -0,0 +1,212 @@
852 +/* SPDX-License-Identifier: GPL-2.0 */
853 +/*
854 + * These are the HEVC state controls for use with stateless HEVC
855 + * codec drivers.
856 + *
857 + * It turns out that these structs are not stable yet and will undergo
858 + * more changes. So keep them private until they are stable and ready to
859 + * become part of the official public API.
860 + */
861 +
862 +#ifndef _HEVC_CTRLS_H_
863 +#define _HEVC_CTRLS_H_
864 +
865 +#include <linux/videodev2.h>
866 +
867 +/* The pixel format isn't stable at the moment and will likely be renamed. */
868 +#define V4L2_PIX_FMT_HEVC_SLICE v4l2_fourcc('S', '2', '6', '5') /* HEVC parsed slices */
869 +
870 +#define V4L2_CID_MPEG_VIDEO_HEVC_SPS (V4L2_CID_MPEG_BASE + 1008)
871 +#define V4L2_CID_MPEG_VIDEO_HEVC_PPS (V4L2_CID_MPEG_BASE + 1009)
872 +#define V4L2_CID_MPEG_VIDEO_HEVC_SLICE_PARAMS (V4L2_CID_MPEG_BASE + 1010)
873 +#define V4L2_CID_MPEG_VIDEO_HEVC_DECODE_MODE (V4L2_CID_MPEG_BASE + 1015)
874 +#define V4L2_CID_MPEG_VIDEO_HEVC_START_CODE (V4L2_CID_MPEG_BASE + 1016)
875 +
876 +/* enum v4l2_ctrl_type type values */
877 +#define V4L2_CTRL_TYPE_HEVC_SPS 0x0120
878 +#define V4L2_CTRL_TYPE_HEVC_PPS 0x0121
879 +#define V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS 0x0122
880 +
881 +enum v4l2_mpeg_video_hevc_decode_mode {
882 + V4L2_MPEG_VIDEO_HEVC_DECODE_MODE_SLICE_BASED,
883 + V4L2_MPEG_VIDEO_HEVC_DECODE_MODE_FRAME_BASED,
884 +};
885 +
886 +enum v4l2_mpeg_video_hevc_start_code {
887 + V4L2_MPEG_VIDEO_HEVC_START_CODE_NONE,
888 + V4L2_MPEG_VIDEO_HEVC_START_CODE_ANNEX_B,
889 +};
890 +
891 +#define V4L2_HEVC_SLICE_TYPE_B 0
892 +#define V4L2_HEVC_SLICE_TYPE_P 1
893 +#define V4L2_HEVC_SLICE_TYPE_I 2
894 +
895 +#define V4L2_HEVC_SPS_FLAG_SEPARATE_COLOUR_PLANE (1ULL << 0)
896 +#define V4L2_HEVC_SPS_FLAG_SCALING_LIST_ENABLED (1ULL << 1)
897 +#define V4L2_HEVC_SPS_FLAG_AMP_ENABLED (1ULL << 2)
898 +#define V4L2_HEVC_SPS_FLAG_SAMPLE_ADAPTIVE_OFFSET (1ULL << 3)
899 +#define V4L2_HEVC_SPS_FLAG_PCM_ENABLED (1ULL << 4)
900 +#define V4L2_HEVC_SPS_FLAG_PCM_LOOP_FILTER_DISABLED (1ULL << 5)
901 +#define V4L2_HEVC_SPS_FLAG_LONG_TERM_REF_PICS_PRESENT (1ULL << 6)
902 +#define V4L2_HEVC_SPS_FLAG_SPS_TEMPORAL_MVP_ENABLED (1ULL << 7)
903 +#define V4L2_HEVC_SPS_FLAG_STRONG_INTRA_SMOOTHING_ENABLED (1ULL << 8)
904 +
905 +/* The controls are not stable at the moment and will likely be reworked. */
906 +struct v4l2_ctrl_hevc_sps {
907 + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Sequence parameter set */
908 + __u16 pic_width_in_luma_samples;
909 + __u16 pic_height_in_luma_samples;
910 + __u8 bit_depth_luma_minus8;
911 + __u8 bit_depth_chroma_minus8;
912 + __u8 log2_max_pic_order_cnt_lsb_minus4;
913 + __u8 sps_max_dec_pic_buffering_minus1;
914 + __u8 sps_max_num_reorder_pics;
915 + __u8 sps_max_latency_increase_plus1;
916 + __u8 log2_min_luma_coding_block_size_minus3;
917 + __u8 log2_diff_max_min_luma_coding_block_size;
918 + __u8 log2_min_luma_transform_block_size_minus2;
919 + __u8 log2_diff_max_min_luma_transform_block_size;
920 + __u8 max_transform_hierarchy_depth_inter;
921 + __u8 max_transform_hierarchy_depth_intra;
922 + __u8 pcm_sample_bit_depth_luma_minus1;
923 + __u8 pcm_sample_bit_depth_chroma_minus1;
924 + __u8 log2_min_pcm_luma_coding_block_size_minus3;
925 + __u8 log2_diff_max_min_pcm_luma_coding_block_size;
926 + __u8 num_short_term_ref_pic_sets;
927 + __u8 num_long_term_ref_pics_sps;
928 + __u8 chroma_format_idc;
929 +
930 + __u8 padding;
931 +
932 + __u64 flags;
933 +};
934 +
935 +#define V4L2_HEVC_PPS_FLAG_DEPENDENT_SLICE_SEGMENT (1ULL << 0)
936 +#define V4L2_HEVC_PPS_FLAG_OUTPUT_FLAG_PRESENT (1ULL << 1)
937 +#define V4L2_HEVC_PPS_FLAG_SIGN_DATA_HIDING_ENABLED (1ULL << 2)
938 +#define V4L2_HEVC_PPS_FLAG_CABAC_INIT_PRESENT (1ULL << 3)
939 +#define V4L2_HEVC_PPS_FLAG_CONSTRAINED_INTRA_PRED (1ULL << 4)
940 +#define V4L2_HEVC_PPS_FLAG_TRANSFORM_SKIP_ENABLED (1ULL << 5)
941 +#define V4L2_HEVC_PPS_FLAG_CU_QP_DELTA_ENABLED (1ULL << 6)
942 +#define V4L2_HEVC_PPS_FLAG_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT (1ULL << 7)
943 +#define V4L2_HEVC_PPS_FLAG_WEIGHTED_PRED (1ULL << 8)
944 +#define V4L2_HEVC_PPS_FLAG_WEIGHTED_BIPRED (1ULL << 9)
945 +#define V4L2_HEVC_PPS_FLAG_TRANSQUANT_BYPASS_ENABLED (1ULL << 10)
946 +#define V4L2_HEVC_PPS_FLAG_TILES_ENABLED (1ULL << 11)
947 +#define V4L2_HEVC_PPS_FLAG_ENTROPY_CODING_SYNC_ENABLED (1ULL << 12)
948 +#define V4L2_HEVC_PPS_FLAG_LOOP_FILTER_ACROSS_TILES_ENABLED (1ULL << 13)
949 +#define V4L2_HEVC_PPS_FLAG_PPS_LOOP_FILTER_ACROSS_SLICES_ENABLED (1ULL << 14)
950 +#define V4L2_HEVC_PPS_FLAG_DEBLOCKING_FILTER_OVERRIDE_ENABLED (1ULL << 15)
951 +#define V4L2_HEVC_PPS_FLAG_PPS_DISABLE_DEBLOCKING_FILTER (1ULL << 16)
952 +#define V4L2_HEVC_PPS_FLAG_LISTS_MODIFICATION_PRESENT (1ULL << 17)
953 +#define V4L2_HEVC_PPS_FLAG_SLICE_SEGMENT_HEADER_EXTENSION_PRESENT (1ULL << 18)
954 +
955 +struct v4l2_ctrl_hevc_pps {
956 + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Picture parameter set */
957 + __u8 num_extra_slice_header_bits;
958 + __s8 init_qp_minus26;
959 + __u8 diff_cu_qp_delta_depth;
960 + __s8 pps_cb_qp_offset;
961 + __s8 pps_cr_qp_offset;
962 + __u8 num_tile_columns_minus1;
963 + __u8 num_tile_rows_minus1;
964 + __u8 column_width_minus1[20];
965 + __u8 row_height_minus1[22];
966 + __s8 pps_beta_offset_div2;
967 + __s8 pps_tc_offset_div2;
968 + __u8 log2_parallel_merge_level_minus2;
969 +
970 + __u8 padding[4];
971 + __u64 flags;
972 +};
973 +
974 +#define V4L2_HEVC_DPB_ENTRY_RPS_ST_CURR_BEFORE 0x01
975 +#define V4L2_HEVC_DPB_ENTRY_RPS_ST_CURR_AFTER 0x02
976 +#define V4L2_HEVC_DPB_ENTRY_RPS_LT_CURR 0x03
977 +
978 +#define V4L2_HEVC_DPB_ENTRIES_NUM_MAX 16
979 +
980 +struct v4l2_hevc_dpb_entry {
981 + __u64 timestamp;
982 + __u8 rps;
983 + __u8 field_pic;
984 + __u16 pic_order_cnt[2];
985 + __u8 padding[2];
986 +};
987 +
988 +struct v4l2_hevc_pred_weight_table {
989 + __s8 delta_luma_weight_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX];
990 + __s8 luma_offset_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX];
991 + __s8 delta_chroma_weight_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX][2];
992 + __s8 chroma_offset_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX][2];
993 +
994 + __s8 delta_luma_weight_l1[V4L2_HEVC_DPB_ENTRIES_NUM_MAX];
995 + __s8 luma_offset_l1[V4L2_HEVC_DPB_ENTRIES_NUM_MAX];
996 + __s8 delta_chroma_weight_l1[V4L2_HEVC_DPB_ENTRIES_NUM_MAX][2];
997 + __s8 chroma_offset_l1[V4L2_HEVC_DPB_ENTRIES_NUM_MAX][2];
998 +
999 + __u8 padding[6];
1000 +
1001 + __u8 luma_log2_weight_denom;
1002 + __s8 delta_chroma_log2_weight_denom;
1003 +};
1004 +
1005 +#define V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_LUMA (1ULL << 0)
1006 +#define V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_SAO_CHROMA (1ULL << 1)
1007 +#define V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_TEMPORAL_MVP_ENABLED (1ULL << 2)
1008 +#define V4L2_HEVC_SLICE_PARAMS_FLAG_MVD_L1_ZERO (1ULL << 3)
1009 +#define V4L2_HEVC_SLICE_PARAMS_FLAG_CABAC_INIT (1ULL << 4)
1010 +#define V4L2_HEVC_SLICE_PARAMS_FLAG_COLLOCATED_FROM_L0 (1ULL << 5)
1011 +#define V4L2_HEVC_SLICE_PARAMS_FLAG_USE_INTEGER_MV (1ULL << 6)
1012 +#define V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_DEBLOCKING_FILTER_DISABLED (1ULL << 7)
1013 +#define V4L2_HEVC_SLICE_PARAMS_FLAG_SLICE_LOOP_FILTER_ACROSS_SLICES_ENABLED (1ULL << 8)
1014 +
1015 +struct v4l2_ctrl_hevc_slice_params {
1016 + __u32 bit_size;
1017 + __u32 data_bit_offset;
1018 +
1019 + /* ISO/IEC 23008-2, ITU-T Rec. H.265: NAL unit header */
1020 + __u8 nal_unit_type;
1021 + __u8 nuh_temporal_id_plus1;
1022 +
1023 + /* ISO/IEC 23008-2, ITU-T Rec. H.265: General slice segment header */
1024 + __u8 slice_type;
1025 + __u8 colour_plane_id;
1026 + __u16 slice_pic_order_cnt;
1027 + __u8 num_ref_idx_l0_active_minus1;
1028 + __u8 num_ref_idx_l1_active_minus1;
1029 + __u8 collocated_ref_idx;
1030 + __u8 five_minus_max_num_merge_cand;
1031 + __s8 slice_qp_delta;
1032 + __s8 slice_cb_qp_offset;
1033 + __s8 slice_cr_qp_offset;
1034 + __s8 slice_act_y_qp_offset;
1035 + __s8 slice_act_cb_qp_offset;
1036 + __s8 slice_act_cr_qp_offset;
1037 + __s8 slice_beta_offset_div2;
1038 + __s8 slice_tc_offset_div2;
1039 +
1040 + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Picture timing SEI message */
1041 + __u8 pic_struct;
1042 +
1043 + /* ISO/IEC 23008-2, ITU-T Rec. H.265: General slice segment header */
1044 + __u8 num_active_dpb_entries;
1045 + __u8 ref_idx_l0[V4L2_HEVC_DPB_ENTRIES_NUM_MAX];
1046 + __u8 ref_idx_l1[V4L2_HEVC_DPB_ENTRIES_NUM_MAX];
1047 +
1048 + __u8 num_rps_poc_st_curr_before;
1049 + __u8 num_rps_poc_st_curr_after;
1050 + __u8 num_rps_poc_lt_curr;
1051 +
1052 + __u8 padding;
1053 +
1054 + /* ISO/IEC 23008-2, ITU-T Rec. H.265: General slice segment header */
1055 + struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX];
1056 +
1057 + /* ISO/IEC 23008-2, ITU-T Rec. H.265: Weighted prediction parameter */
1058 + struct v4l2_hevc_pred_weight_table pred_weight_table;
1059 +
1060 + __u64 flags;
1061 +};
1062 +
1063 +#endif
1064 --- a/include/media/v4l2-ctrls.h
1065 +++ b/include/media/v4l2-ctrls.h
1066 @@ -21,6 +21,7 @@
1067 #include <media/fwht-ctrls.h>
1068 #include <media/h264-ctrls.h>
1069 #include <media/vp8-ctrls.h>
1070 +#include <media/hevc-ctrls.h>
1071
1072 /* forward references */
1073 struct file;
1074 @@ -50,6 +51,9 @@ struct poll_table_struct;
1075 * @p_h264_slice_params: Pointer to a struct v4l2_ctrl_h264_slice_params.
1076 * @p_h264_decode_params: Pointer to a struct v4l2_ctrl_h264_decode_params.
1077 * @p_vp8_frame_header: Pointer to a VP8 frame header structure.
1078 + * @p_hevc_sps: Pointer to an HEVC sequence parameter set structure.
1079 + * @p_hevc_pps: Pointer to an HEVC picture parameter set structure.
1080 + * @p_hevc_slice_params: Pointer to an HEVC slice parameters structure.
1081 * @p_area: Pointer to an area.
1082 * @p: Pointer to a compound value.
1083 */
1084 @@ -69,6 +73,9 @@ union v4l2_ctrl_ptr {
1085 struct v4l2_ctrl_h264_slice_params *p_h264_slice_params;
1086 struct v4l2_ctrl_h264_decode_params *p_h264_decode_params;
1087 struct v4l2_ctrl_vp8_frame_header *p_vp8_frame_header;
1088 + struct v4l2_ctrl_hevc_sps *p_hevc_sps;
1089 + struct v4l2_ctrl_hevc_pps *p_hevc_pps;
1090 + struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params;
1091 struct v4l2_area *p_area;
1092 void *p;
1093 };
tree of Luka Perkov resides here