ext-ctrls-codec-stateless.rst (59120B)
1.. SPDX-License-Identifier: GFDL-1.1-no-invariants-or-later 2 3.. _codec-stateless-controls: 4 5********************************* 6Stateless Codec Control Reference 7********************************* 8 9The Stateless Codec control class is intended to support 10stateless decoder and encoders (i.e. hardware accelerators). 11 12These drivers are typically supported by the :ref:`stateless_decoder`, 13and deal with parsed pixel formats such as V4L2_PIX_FMT_H264_SLICE. 14 15Stateless Codec Control ID 16========================== 17 18.. _codec-stateless-control-id: 19 20``V4L2_CID_CODEC_STATELESS_CLASS (class)`` 21 The Stateless Codec class descriptor. 22 23.. _v4l2-codec-stateless-h264: 24 25``V4L2_CID_STATELESS_H264_SPS (struct)`` 26 Specifies the sequence parameter set (as extracted from the 27 bitstream) for the associated H264 slice data. This includes the 28 necessary parameters for configuring a stateless hardware decoding 29 pipeline for H264. The bitstream parameters are defined according 30 to :ref:`h264`, section 7.4.2.1.1 "Sequence Parameter Set Data 31 Semantics". For further documentation, refer to the above 32 specification, unless there is an explicit comment stating 33 otherwise. 34 35.. c:type:: v4l2_ctrl_h264_sps 36 37.. raw:: latex 38 39 \small 40 41.. tabularcolumns:: |p{1.2cm}|p{8.6cm}|p{7.5cm}| 42 43.. flat-table:: struct v4l2_ctrl_h264_sps 44 :header-rows: 0 45 :stub-columns: 0 46 :widths: 1 1 2 47 48 * - __u8 49 - ``profile_idc`` 50 - 51 * - __u8 52 - ``constraint_set_flags`` 53 - See :ref:`Sequence Parameter Set Constraints Set Flags <h264_sps_constraints_set_flags>` 54 * - __u8 55 - ``level_idc`` 56 - 57 * - __u8 58 - ``seq_parameter_set_id`` 59 - 60 * - __u8 61 - ``chroma_format_idc`` 62 - 63 * - __u8 64 - ``bit_depth_luma_minus8`` 65 - 66 * - __u8 67 - ``bit_depth_chroma_minus8`` 68 - 69 * - __u8 70 - ``log2_max_frame_num_minus4`` 71 - 72 * - __u8 73 - ``pic_order_cnt_type`` 74 - 75 * - __u8 76 - ``log2_max_pic_order_cnt_lsb_minus4`` 77 - 78 * - __u8 79 - ``max_num_ref_frames`` 80 - 81 * - __u8 82 - ``num_ref_frames_in_pic_order_cnt_cycle`` 83 - 84 * - __s32 85 - ``offset_for_ref_frame[255]`` 86 - 87 * - __s32 88 - ``offset_for_non_ref_pic`` 89 - 90 * - __s32 91 - ``offset_for_top_to_bottom_field`` 92 - 93 * - __u16 94 - ``pic_width_in_mbs_minus1`` 95 - 96 * - __u16 97 - ``pic_height_in_map_units_minus1`` 98 - 99 * - __u32 100 - ``flags`` 101 - See :ref:`Sequence Parameter Set Flags <h264_sps_flags>` 102 103.. raw:: latex 104 105 \normalsize 106 107.. _h264_sps_constraints_set_flags: 108 109``Sequence Parameter Set Constraints Set Flags`` 110 111.. cssclass:: longtable 112 113.. flat-table:: 114 :header-rows: 0 115 :stub-columns: 0 116 :widths: 1 1 2 117 118 * - ``V4L2_H264_SPS_CONSTRAINT_SET0_FLAG`` 119 - 0x00000001 120 - 121 * - ``V4L2_H264_SPS_CONSTRAINT_SET1_FLAG`` 122 - 0x00000002 123 - 124 * - ``V4L2_H264_SPS_CONSTRAINT_SET2_FLAG`` 125 - 0x00000004 126 - 127 * - ``V4L2_H264_SPS_CONSTRAINT_SET3_FLAG`` 128 - 0x00000008 129 - 130 * - ``V4L2_H264_SPS_CONSTRAINT_SET4_FLAG`` 131 - 0x00000010 132 - 133 * - ``V4L2_H264_SPS_CONSTRAINT_SET5_FLAG`` 134 - 0x00000020 135 - 136 137.. _h264_sps_flags: 138 139``Sequence Parameter Set Flags`` 140 141.. cssclass:: longtable 142 143.. flat-table:: 144 :header-rows: 0 145 :stub-columns: 0 146 :widths: 1 1 2 147 148 * - ``V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE`` 149 - 0x00000001 150 - 151 * - ``V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS`` 152 - 0x00000002 153 - 154 * - ``V4L2_H264_SPS_FLAG_DELTA_PIC_ORDER_ALWAYS_ZERO`` 155 - 0x00000004 156 - 157 * - ``V4L2_H264_SPS_FLAG_GAPS_IN_FRAME_NUM_VALUE_ALLOWED`` 158 - 0x00000008 159 - 160 * - ``V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY`` 161 - 0x00000010 162 - 163 * - ``V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD`` 164 - 0x00000020 165 - 166 * - ``V4L2_H264_SPS_FLAG_DIRECT_8X8_INFERENCE`` 167 - 0x00000040 168 - 169 170``V4L2_CID_STATELESS_H264_PPS (struct)`` 171 Specifies the picture parameter set (as extracted from the 172 bitstream) for the associated H264 slice data. This includes the 173 necessary parameters for configuring a stateless hardware decoding 174 pipeline for H264. The bitstream parameters are defined according 175 to :ref:`h264`, section 7.4.2.2 "Picture Parameter Set RBSP 176 Semantics". For further documentation, refer to the above 177 specification, unless there is an explicit comment stating 178 otherwise. 179 180.. c:type:: v4l2_ctrl_h264_pps 181 182.. raw:: latex 183 184 \small 185 186.. flat-table:: struct v4l2_ctrl_h264_pps 187 :header-rows: 0 188 :stub-columns: 0 189 :widths: 1 1 2 190 191 * - __u8 192 - ``pic_parameter_set_id`` 193 - 194 * - __u8 195 - ``seq_parameter_set_id`` 196 - 197 * - __u8 198 - ``num_slice_groups_minus1`` 199 - 200 * - __u8 201 - ``num_ref_idx_l0_default_active_minus1`` 202 - 203 * - __u8 204 - ``num_ref_idx_l1_default_active_minus1`` 205 - 206 * - __u8 207 - ``weighted_bipred_idc`` 208 - 209 * - __s8 210 - ``pic_init_qp_minus26`` 211 - 212 * - __s8 213 - ``pic_init_qs_minus26`` 214 - 215 * - __s8 216 - ``chroma_qp_index_offset`` 217 - 218 * - __s8 219 - ``second_chroma_qp_index_offset`` 220 - 221 * - __u16 222 - ``flags`` 223 - See :ref:`Picture Parameter Set Flags <h264_pps_flags>` 224 225.. raw:: latex 226 227 \normalsize 228 229.. _h264_pps_flags: 230 231``Picture Parameter Set Flags`` 232 233.. raw:: latex 234 235 \begingroup 236 \scriptsize 237 \setlength{\tabcolsep}{2pt} 238 239.. tabularcolumns:: |p{9.8cm}|p{1.0cm}|p{6.5cm}| 240 241.. flat-table:: 242 :header-rows: 0 243 :stub-columns: 0 244 :widths: 10 1 4 245 246 * - ``V4L2_H264_PPS_FLAG_ENTROPY_CODING_MODE`` 247 - 0x0001 248 - 249 * - ``V4L2_H264_PPS_FLAG_BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT`` 250 - 0x0002 251 - 252 * - ``V4L2_H264_PPS_FLAG_WEIGHTED_PRED`` 253 - 0x0004 254 - 255 * - ``V4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT`` 256 - 0x0008 257 - 258 * - ``V4L2_H264_PPS_FLAG_CONSTRAINED_INTRA_PRED`` 259 - 0x0010 260 - 261 * - ``V4L2_H264_PPS_FLAG_REDUNDANT_PIC_CNT_PRESENT`` 262 - 0x0020 263 - 264 * - ``V4L2_H264_PPS_FLAG_TRANSFORM_8X8_MODE`` 265 - 0x0040 266 - 267 * - ``V4L2_H264_PPS_FLAG_SCALING_MATRIX_PRESENT`` 268 - 0x0080 269 - ``V4L2_CID_STATELESS_H264_SCALING_MATRIX`` 270 must be used for this picture. 271 272.. raw:: latex 273 274 \endgroup 275 276``V4L2_CID_STATELESS_H264_SCALING_MATRIX (struct)`` 277 Specifies the scaling matrix (as extracted from the bitstream) for 278 the associated H264 slice data. The bitstream parameters are 279 defined according to :ref:`h264`, section 7.4.2.1.1.1 "Scaling 280 List Semantics". For further documentation, refer to the above 281 specification, unless there is an explicit comment stating 282 otherwise. 283 284.. c:type:: v4l2_ctrl_h264_scaling_matrix 285 286.. raw:: latex 287 288 \small 289 290.. tabularcolumns:: |p{0.6cm}|p{4.8cm}|p{11.9cm}| 291 292.. flat-table:: struct v4l2_ctrl_h264_scaling_matrix 293 :header-rows: 0 294 :stub-columns: 0 295 :widths: 1 1 2 296 297 * - __u8 298 - ``scaling_list_4x4[6][16]`` 299 - Scaling matrix after applying the inverse scanning process. 300 Expected list order is Intra Y, Intra Cb, Intra Cr, Inter Y, 301 Inter Cb, Inter Cr. The values on each scaling list are 302 expected in raster scan order. 303 * - __u8 304 - ``scaling_list_8x8[6][64]`` 305 - Scaling matrix after applying the inverse scanning process. 306 Expected list order is Intra Y, Inter Y, Intra Cb, Inter Cb, 307 Intra Cr, Inter Cr. The values on each scaling list are 308 expected in raster scan order. 309 310``V4L2_CID_STATELESS_H264_SLICE_PARAMS (struct)`` 311 Specifies the slice parameters (as extracted from the bitstream) 312 for the associated H264 slice data. This includes the necessary 313 parameters for configuring a stateless hardware decoding pipeline 314 for H264. The bitstream parameters are defined according to 315 :ref:`h264`, section 7.4.3 "Slice Header Semantics". For further 316 documentation, refer to the above specification, unless there is 317 an explicit comment stating otherwise. 318 319.. c:type:: v4l2_ctrl_h264_slice_params 320 321.. raw:: latex 322 323 \small 324 325.. tabularcolumns:: |p{4.0cm}|p{5.9cm}|p{7.4cm}| 326 327.. flat-table:: struct v4l2_ctrl_h264_slice_params 328 :header-rows: 0 329 :stub-columns: 0 330 :widths: 1 1 2 331 332 * - __u32 333 - ``header_bit_size`` 334 - Offset in bits to slice_data() from the beginning of this slice. 335 * - __u32 336 - ``first_mb_in_slice`` 337 - 338 * - __u8 339 - ``slice_type`` 340 - 341 * - __u8 342 - ``colour_plane_id`` 343 - 344 * - __u8 345 - ``redundant_pic_cnt`` 346 - 347 * - __u8 348 - ``cabac_init_idc`` 349 - 350 * - __s8 351 - ``slice_qp_delta`` 352 - 353 * - __s8 354 - ``slice_qs_delta`` 355 - 356 * - __u8 357 - ``disable_deblocking_filter_idc`` 358 - 359 * - __s8 360 - ``slice_alpha_c0_offset_div2`` 361 - 362 * - __s8 363 - ``slice_beta_offset_div2`` 364 - 365 * - __u8 366 - ``num_ref_idx_l0_active_minus1`` 367 - If num_ref_idx_active_override_flag is not set, this field must be 368 set to the value of num_ref_idx_l0_default_active_minus1 369 * - __u8 370 - ``num_ref_idx_l1_active_minus1`` 371 - If num_ref_idx_active_override_flag is not set, this field must be 372 set to the value of num_ref_idx_l1_default_active_minus1 373 * - __u8 374 - ``reserved`` 375 - Applications and drivers must set this to zero. 376 * - struct :c:type:`v4l2_h264_reference` 377 - ``ref_pic_list0[32]`` 378 - Reference picture list after applying the per-slice modifications 379 * - struct :c:type:`v4l2_h264_reference` 380 - ``ref_pic_list1[32]`` 381 - Reference picture list after applying the per-slice modifications 382 * - __u32 383 - ``flags`` 384 - See :ref:`Slice Parameter Flags <h264_slice_flags>` 385 386.. raw:: latex 387 388 \normalsize 389 390.. _h264_slice_flags: 391 392``Slice Parameter Set Flags`` 393 394.. cssclass:: longtable 395 396.. flat-table:: 397 :header-rows: 0 398 :stub-columns: 0 399 :widths: 1 1 2 400 401 * - ``V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED`` 402 - 0x00000001 403 - 404 * - ``V4L2_H264_SLICE_FLAG_SP_FOR_SWITCH`` 405 - 0x00000002 406 - 407 408``V4L2_CID_STATELESS_H264_PRED_WEIGHTS (struct)`` 409 Prediction weight table defined according to :ref:`h264`, 410 section 7.4.3.2 "Prediction Weight Table Semantics". 411 The prediction weight table must be passed by applications 412 under the conditions explained in section 7.3.3 "Slice header 413 syntax". 414 415.. c:type:: v4l2_ctrl_h264_pred_weights 416 417.. raw:: latex 418 419 \small 420 421.. tabularcolumns:: |p{4.9cm}|p{4.9cm}|p{7.5cm}| 422 423.. flat-table:: struct v4l2_ctrl_h264_pred_weights 424 :header-rows: 0 425 :stub-columns: 0 426 :widths: 1 1 2 427 428 * - __u16 429 - ``luma_log2_weight_denom`` 430 - 431 * - __u16 432 - ``chroma_log2_weight_denom`` 433 - 434 * - struct :c:type:`v4l2_h264_weight_factors` 435 - ``weight_factors[2]`` 436 - The weight factors at index 0 are the weight factors for the reference 437 list 0, the one at index 1 for the reference list 1. 438 439.. raw:: latex 440 441 \normalsize 442 443.. c:type:: v4l2_h264_weight_factors 444 445.. raw:: latex 446 447 \small 448 449.. tabularcolumns:: |p{1.0cm}|p{4.5cm}|p{11.8cm}| 450 451.. flat-table:: struct v4l2_h264_weight_factors 452 :header-rows: 0 453 :stub-columns: 0 454 :widths: 1 1 2 455 456 * - __s16 457 - ``luma_weight[32]`` 458 - 459 * - __s16 460 - ``luma_offset[32]`` 461 - 462 * - __s16 463 - ``chroma_weight[32][2]`` 464 - 465 * - __s16 466 - ``chroma_offset[32][2]`` 467 - 468 469.. raw:: latex 470 471 \normalsize 472 473``Picture Reference`` 474 475.. c:type:: v4l2_h264_reference 476 477.. cssclass:: longtable 478 479.. flat-table:: struct v4l2_h264_reference 480 :header-rows: 0 481 :stub-columns: 0 482 :widths: 1 1 2 483 484 * - __u8 485 - ``fields`` 486 - Specifies how the picture is referenced. See :ref:`Reference Fields <h264_ref_fields>` 487 * - __u8 488 - ``index`` 489 - Index into the :c:type:`v4l2_ctrl_h264_decode_params`.dpb array. 490 491.. _h264_ref_fields: 492 493``Reference Fields`` 494 495.. raw:: latex 496 497 \small 498 499.. tabularcolumns:: |p{5.4cm}|p{0.8cm}|p{11.1cm}| 500 501.. flat-table:: 502 :header-rows: 0 503 :stub-columns: 0 504 :widths: 1 1 2 505 506 * - ``V4L2_H264_TOP_FIELD_REF`` 507 - 0x1 508 - The top field in field pair is used for short-term reference. 509 * - ``V4L2_H264_BOTTOM_FIELD_REF`` 510 - 0x2 511 - The bottom field in field pair is used for short-term reference. 512 * - ``V4L2_H264_FRAME_REF`` 513 - 0x3 514 - The frame (or the top/bottom fields, if it's a field pair) 515 is used for short-term reference. 516 517.. raw:: latex 518 519 \normalsize 520 521``V4L2_CID_STATELESS_H264_DECODE_PARAMS (struct)`` 522 Specifies the decode parameters (as extracted from the bitstream) 523 for the associated H264 slice data. This includes the necessary 524 parameters for configuring a stateless hardware decoding pipeline 525 for H264. The bitstream parameters are defined according to 526 :ref:`h264`. For further documentation, refer to the above 527 specification, unless there is an explicit comment stating 528 otherwise. 529 530.. c:type:: v4l2_ctrl_h264_decode_params 531 532.. raw:: latex 533 534 \small 535 536.. tabularcolumns:: |p{4.0cm}|p{5.9cm}|p{7.4cm}| 537 538.. flat-table:: struct v4l2_ctrl_h264_decode_params 539 :header-rows: 0 540 :stub-columns: 0 541 :widths: 1 1 2 542 543 * - struct :c:type:`v4l2_h264_dpb_entry` 544 - ``dpb[16]`` 545 - 546 * - __u16 547 - ``nal_ref_idc`` 548 - NAL reference ID value coming from the NAL Unit header 549 * - __u16 550 - ``frame_num`` 551 - 552 * - __s32 553 - ``top_field_order_cnt`` 554 - Picture Order Count for the coded top field 555 * - __s32 556 - ``bottom_field_order_cnt`` 557 - Picture Order Count for the coded bottom field 558 * - __u16 559 - ``idr_pic_id`` 560 - 561 * - __u16 562 - ``pic_order_cnt_lsb`` 563 - 564 * - __s32 565 - ``delta_pic_order_cnt_bottom`` 566 - 567 * - __s32 568 - ``delta_pic_order_cnt0`` 569 - 570 * - __s32 571 - ``delta_pic_order_cnt1`` 572 - 573 * - __u32 574 - ``dec_ref_pic_marking_bit_size`` 575 - Size in bits of the dec_ref_pic_marking() syntax element. 576 * - __u32 577 - ``pic_order_cnt_bit_size`` 578 - Combined size in bits of the picture order count related syntax 579 elements: pic_order_cnt_lsb, delta_pic_order_cnt_bottom, 580 delta_pic_order_cnt0, and delta_pic_order_cnt1. 581 * - __u32 582 - ``slice_group_change_cycle`` 583 - 584 * - __u32 585 - ``reserved`` 586 - Applications and drivers must set this to zero. 587 * - __u32 588 - ``flags`` 589 - See :ref:`Decode Parameters Flags <h264_decode_params_flags>` 590 591.. raw:: latex 592 593 \normalsize 594 595.. _h264_decode_params_flags: 596 597``Decode Parameters Flags`` 598 599.. raw:: latex 600 601 \small 602 603.. tabularcolumns:: |p{8.3cm}|p{2.1cm}|p{6.9cm}| 604 605.. flat-table:: 606 :header-rows: 0 607 :stub-columns: 0 608 :widths: 1 1 2 609 610 * - ``V4L2_H264_DECODE_PARAM_FLAG_IDR_PIC`` 611 - 0x00000001 612 - That picture is an IDR picture 613 * - ``V4L2_H264_DECODE_PARAM_FLAG_FIELD_PIC`` 614 - 0x00000002 615 - 616 * - ``V4L2_H264_DECODE_PARAM_FLAG_BOTTOM_FIELD`` 617 - 0x00000004 618 - 619 * - ``V4L2_H264_DECODE_PARAM_FLAG_PFRAME`` 620 - 0x00000008 621 - 622 * - ``V4L2_H264_DECODE_PARAM_FLAG_BFRAME`` 623 - 0x00000010 624 - 625 626.. raw:: latex 627 628 \normalsize 629 630.. c:type:: v4l2_h264_dpb_entry 631 632.. raw:: latex 633 634 \small 635 636.. tabularcolumns:: |p{1.0cm}|p{4.9cm}|p{11.4cm}| 637 638.. flat-table:: struct v4l2_h264_dpb_entry 639 :header-rows: 0 640 :stub-columns: 0 641 :widths: 1 1 2 642 643 * - __u64 644 - ``reference_ts`` 645 - Timestamp of the V4L2 capture buffer to use as reference, used 646 with B-coded and P-coded frames. The timestamp refers to the 647 ``timestamp`` field in struct :c:type:`v4l2_buffer`. Use the 648 :c:func:`v4l2_timeval_to_ns()` function to convert the struct 649 :c:type:`timeval` in struct :c:type:`v4l2_buffer` to a __u64. 650 * - __u32 651 - ``pic_num`` 652 - For short term references, this must match the derived value PicNum 653 (8-28) and for long term references it must match the derived value 654 LongTermPicNum (8-29). When decoding frames (as opposed to fields) 655 pic_num is the same as FrameNumWrap. 656 * - __u16 657 - ``frame_num`` 658 - For short term references, this must match the frame_num value from 659 the slice header syntax (the driver will wrap the value if needed). For 660 long term references, this must be set to the value of 661 long_term_frame_idx described in the dec_ref_pic_marking() syntax. 662 * - __u8 663 - ``fields`` 664 - Specifies how the DPB entry is referenced. See :ref:`Reference Fields <h264_ref_fields>` 665 * - __u8 666 - ``reserved[5]`` 667 - Applications and drivers must set this to zero. 668 * - __s32 669 - ``top_field_order_cnt`` 670 - 671 * - __s32 672 - ``bottom_field_order_cnt`` 673 - 674 * - __u32 675 - ``flags`` 676 - See :ref:`DPB Entry Flags <h264_dpb_flags>` 677 678.. raw:: latex 679 680 \normalsize 681 682.. _h264_dpb_flags: 683 684``DPB Entries Flags`` 685 686.. raw:: latex 687 688 \small 689 690.. tabularcolumns:: |p{7.7cm}|p{2.1cm}|p{7.5cm}| 691 692.. flat-table:: 693 :header-rows: 0 694 :stub-columns: 0 695 :widths: 1 1 2 696 697 * - ``V4L2_H264_DPB_ENTRY_FLAG_VALID`` 698 - 0x00000001 699 - The DPB entry is valid (non-empty) and should be considered. 700 * - ``V4L2_H264_DPB_ENTRY_FLAG_ACTIVE`` 701 - 0x00000002 702 - The DPB entry is used for reference. 703 * - ``V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM`` 704 - 0x00000004 705 - The DPB entry is used for long-term reference. 706 * - ``V4L2_H264_DPB_ENTRY_FLAG_FIELD`` 707 - 0x00000008 708 - The DPB entry is a single field or a complementary field pair. 709 710.. raw:: latex 711 712 \normalsize 713 714``V4L2_CID_STATELESS_H264_DECODE_MODE (enum)`` 715 Specifies the decoding mode to use. Currently exposes slice-based and 716 frame-based decoding but new modes might be added later on. 717 This control is used as a modifier for V4L2_PIX_FMT_H264_SLICE 718 pixel format. Applications that support V4L2_PIX_FMT_H264_SLICE 719 are required to set this control in order to specify the decoding mode 720 that is expected for the buffer. 721 Drivers may expose a single or multiple decoding modes, depending 722 on what they can support. 723 724.. c:type:: v4l2_stateless_h264_decode_mode 725 726.. raw:: latex 727 728 \scriptsize 729 730.. tabularcolumns:: |p{7.4cm}|p{0.3cm}|p{9.6cm}| 731 732.. flat-table:: 733 :header-rows: 0 734 :stub-columns: 0 735 :widths: 1 1 2 736 737 * - ``V4L2_STATELESS_H264_DECODE_MODE_SLICE_BASED`` 738 - 0 739 - Decoding is done at the slice granularity. 740 The OUTPUT buffer must contain a single slice. 741 When this mode is selected, the ``V4L2_CID_STATELESS_H264_SLICE_PARAMS`` 742 control shall be set. When multiple slices compose a frame, 743 use of ``V4L2_BUF_CAP_SUPPORTS_M2M_HOLD_CAPTURE_BUF`` flag 744 is required. 745 * - ``V4L2_STATELESS_H264_DECODE_MODE_FRAME_BASED`` 746 - 1 747 - Decoding is done at the frame granularity, 748 The OUTPUT buffer must contain all slices needed to decode the 749 frame. The OUTPUT buffer must also contain both fields. 750 This mode will be supported by devices that 751 parse the slice(s) header(s) in hardware. When this mode is 752 selected, the ``V4L2_CID_STATELESS_H264_SLICE_PARAMS`` 753 control shall not be set. 754 755.. raw:: latex 756 757 \normalsize 758 759``V4L2_CID_STATELESS_H264_START_CODE (enum)`` 760 Specifies the H264 slice start code expected for each slice. 761 This control is used as a modifier for V4L2_PIX_FMT_H264_SLICE 762 pixel format. Applications that support V4L2_PIX_FMT_H264_SLICE 763 are required to set this control in order to specify the start code 764 that is expected for the buffer. 765 Drivers may expose a single or multiple start codes, depending 766 on what they can support. 767 768.. c:type:: v4l2_stateless_h264_start_code 769 770.. raw:: latex 771 772 \small 773 774.. tabularcolumns:: |p{7.9cm}|p{0.4cm}|p{9.0cm}| 775 776.. flat-table:: 777 :header-rows: 0 778 :stub-columns: 0 779 :widths: 4 1 4 780 781 * - ``V4L2_STATELESS_H264_START_CODE_NONE`` 782 - 0 783 - Selecting this value specifies that H264 slices are passed 784 to the driver without any start code. The bitstream data should be 785 according to :ref:`h264` 7.3.1 NAL unit syntax, hence contains 786 emulation prevention bytes when required. 787 * - ``V4L2_STATELESS_H264_START_CODE_ANNEX_B`` 788 - 1 789 - Selecting this value specifies that H264 slices are expected 790 to be prefixed by Annex B start codes. According to :ref:`h264` 791 valid start codes can be 3-bytes 0x000001 or 4-bytes 0x00000001. 792 793.. raw:: latex 794 795 \normalsize 796 797.. _codec-stateless-fwht: 798 799``V4L2_CID_STATELESS_FWHT_PARAMS (struct)`` 800 Specifies the FWHT (Fast Walsh Hadamard Transform) parameters (as extracted 801 from the bitstream) for the associated FWHT data. This includes the necessary 802 parameters for configuring a stateless hardware decoding pipeline for FWHT. 803 This codec is specific to the vicodec test driver. 804 805.. c:type:: v4l2_ctrl_fwht_params 806 807.. raw:: latex 808 809 \small 810 811.. tabularcolumns:: |p{1.4cm}|p{3.9cm}|p{12.0cm}| 812 813.. flat-table:: struct v4l2_ctrl_fwht_params 814 :header-rows: 0 815 :stub-columns: 0 816 :widths: 1 1 2 817 818 * - __u64 819 - ``backward_ref_ts`` 820 - Timestamp of the V4L2 capture buffer to use as backward reference, used 821 with P-coded frames. The timestamp refers to the 822 ``timestamp`` field in struct :c:type:`v4l2_buffer`. Use the 823 :c:func:`v4l2_timeval_to_ns()` function to convert the struct 824 :c:type:`timeval` in struct :c:type:`v4l2_buffer` to a __u64. 825 * - __u32 826 - ``version`` 827 - The version of the codec. Set to ``V4L2_FWHT_VERSION``. 828 * - __u32 829 - ``width`` 830 - The width of the frame. 831 * - __u32 832 - ``height`` 833 - The height of the frame. 834 * - __u32 835 - ``flags`` 836 - The flags of the frame, see :ref:`fwht-flags`. 837 * - __u32 838 - ``colorspace`` 839 - The colorspace of the frame, from enum :c:type:`v4l2_colorspace`. 840 * - __u32 841 - ``xfer_func`` 842 - The transfer function, from enum :c:type:`v4l2_xfer_func`. 843 * - __u32 844 - ``ycbcr_enc`` 845 - The Y'CbCr encoding, from enum :c:type:`v4l2_ycbcr_encoding`. 846 * - __u32 847 - ``quantization`` 848 - The quantization range, from enum :c:type:`v4l2_quantization`. 849 850.. raw:: latex 851 852 \normalsize 853 854.. _fwht-flags: 855 856FWHT Flags 857========== 858 859.. raw:: latex 860 861 \small 862 863.. tabularcolumns:: |p{7.0cm}|p{2.3cm}|p{8.0cm}| 864 865.. flat-table:: 866 :header-rows: 0 867 :stub-columns: 0 868 :widths: 3 1 4 869 870 * - ``V4L2_FWHT_FL_IS_INTERLACED`` 871 - 0x00000001 872 - Set if this is an interlaced format. 873 * - ``V4L2_FWHT_FL_IS_BOTTOM_FIRST`` 874 - 0x00000002 875 - Set if this is a bottom-first (NTSC) interlaced format. 876 * - ``V4L2_FWHT_FL_IS_ALTERNATE`` 877 - 0x00000004 878 - Set if each 'frame' contains just one field. 879 * - ``V4L2_FWHT_FL_IS_BOTTOM_FIELD`` 880 - 0x00000008 881 - If V4L2_FWHT_FL_IS_ALTERNATE was set, then this is set if this 'frame' is the 882 bottom field, else it is the top field. 883 * - ``V4L2_FWHT_FL_LUMA_IS_UNCOMPRESSED`` 884 - 0x00000010 885 - Set if the Y' (luma) plane is uncompressed. 886 * - ``V4L2_FWHT_FL_CB_IS_UNCOMPRESSED`` 887 - 0x00000020 888 - Set if the Cb plane is uncompressed. 889 * - ``V4L2_FWHT_FL_CR_IS_UNCOMPRESSED`` 890 - 0x00000040 891 - Set if the Cr plane is uncompressed. 892 * - ``V4L2_FWHT_FL_CHROMA_FULL_HEIGHT`` 893 - 0x00000080 894 - Set if the chroma plane has the same height as the luma plane, 895 else the chroma plane is half the height of the luma plane. 896 * - ``V4L2_FWHT_FL_CHROMA_FULL_WIDTH`` 897 - 0x00000100 898 - Set if the chroma plane has the same width as the luma plane, 899 else the chroma plane is half the width of the luma plane. 900 * - ``V4L2_FWHT_FL_ALPHA_IS_UNCOMPRESSED`` 901 - 0x00000200 902 - Set if the alpha plane is uncompressed. 903 * - ``V4L2_FWHT_FL_I_FRAME`` 904 - 0x00000400 905 - Set if this is an I-frame. 906 * - ``V4L2_FWHT_FL_COMPONENTS_NUM_MSK`` 907 - 0x00070000 908 - The number of color components minus one. 909 * - ``V4L2_FWHT_FL_PIXENC_MSK`` 910 - 0x00180000 911 - The mask for the pixel encoding. 912 * - ``V4L2_FWHT_FL_PIXENC_YUV`` 913 - 0x00080000 914 - Set if the pixel encoding is YUV. 915 * - ``V4L2_FWHT_FL_PIXENC_RGB`` 916 - 0x00100000 917 - Set if the pixel encoding is RGB. 918 * - ``V4L2_FWHT_FL_PIXENC_HSV`` 919 - 0x00180000 920 - Set if the pixel encoding is HSV. 921 922.. raw:: latex 923 924 \normalsize 925 926.. _v4l2-codec-stateless-vp8: 927 928``V4L2_CID_STATELESS_VP8_FRAME (struct)`` 929 Specifies the frame parameters for the associated VP8 parsed frame data. 930 This includes the necessary parameters for 931 configuring a stateless hardware decoding pipeline for VP8. 932 The bitstream parameters are defined according to :ref:`vp8`. 933 934.. c:type:: v4l2_ctrl_vp8_frame 935 936.. raw:: latex 937 938 \small 939 940.. tabularcolumns:: |p{7.0cm}|p{4.6cm}|p{5.7cm}| 941 942.. cssclass:: longtable 943 944.. flat-table:: struct v4l2_ctrl_vp8_frame 945 :header-rows: 0 946 :stub-columns: 0 947 :widths: 1 1 2 948 949 * - struct :c:type:`v4l2_vp8_segment` 950 - ``segment`` 951 - Structure with segment-based adjustments metadata. 952 * - struct :c:type:`v4l2_vp8_loop_filter` 953 - ``lf`` 954 - Structure with loop filter level adjustments metadata. 955 * - struct :c:type:`v4l2_vp8_quantization` 956 - ``quant`` 957 - Structure with VP8 dequantization indices metadata. 958 * - struct :c:type:`v4l2_vp8_entropy` 959 - ``entropy`` 960 - Structure with VP8 entropy coder probabilities metadata. 961 * - struct :c:type:`v4l2_vp8_entropy_coder_state` 962 - ``coder_state`` 963 - Structure with VP8 entropy coder state. 964 * - __u16 965 - ``width`` 966 - The width of the frame. Must be set for all frames. 967 * - __u16 968 - ``height`` 969 - The height of the frame. Must be set for all frames. 970 * - __u8 971 - ``horizontal_scale`` 972 - Horizontal scaling factor. 973 * - __u8 974 - ``vertical_scaling factor`` 975 - Vertical scale. 976 * - __u8 977 - ``version`` 978 - Bitstream version. 979 * - __u8 980 - ``prob_skip_false`` 981 - Indicates the probability that the macroblock is not skipped. 982 * - __u8 983 - ``prob_intra`` 984 - Indicates the probability that a macroblock is intra-predicted. 985 * - __u8 986 - ``prob_last`` 987 - Indicates the probability that the last reference frame is used 988 for inter-prediction 989 * - __u8 990 - ``prob_gf`` 991 - Indicates the probability that the golden reference frame is used 992 for inter-prediction 993 * - __u8 994 - ``num_dct_parts`` 995 - Number of DCT coefficients partitions. Must be one of: 1, 2, 4, or 8. 996 * - __u32 997 - ``first_part_size`` 998 - Size of the first partition, i.e. the control partition. 999 * - __u32 1000 - ``first_part_header_bits`` 1001 - Size in bits of the first partition header portion. 1002 * - __u32 1003 - ``dct_part_sizes[8]`` 1004 - DCT coefficients sizes. 1005 * - __u64 1006 - ``last_frame_ts`` 1007 - Timestamp for the V4L2 capture buffer to use as last reference frame, used 1008 with inter-coded frames. The timestamp refers to the ``timestamp`` field in 1009 struct :c:type:`v4l2_buffer`. Use the :c:func:`v4l2_timeval_to_ns()` 1010 function to convert the struct :c:type:`timeval` in struct 1011 :c:type:`v4l2_buffer` to a __u64. 1012 * - __u64 1013 - ``golden_frame_ts`` 1014 - Timestamp for the V4L2 capture buffer to use as last reference frame, used 1015 with inter-coded frames. The timestamp refers to the ``timestamp`` field in 1016 struct :c:type:`v4l2_buffer`. Use the :c:func:`v4l2_timeval_to_ns()` 1017 function to convert the struct :c:type:`timeval` in struct 1018 :c:type:`v4l2_buffer` to a __u64. 1019 * - __u64 1020 - ``alt_frame_ts`` 1021 - Timestamp for the V4L2 capture buffer to use as alternate reference frame, used 1022 with inter-coded frames. The timestamp refers to the ``timestamp`` field in 1023 struct :c:type:`v4l2_buffer`. Use the :c:func:`v4l2_timeval_to_ns()` 1024 function to convert the struct :c:type:`timeval` in struct 1025 :c:type:`v4l2_buffer` to a __u64. 1026 * - __u64 1027 - ``flags`` 1028 - See :ref:`Frame Flags <vp8_frame_flags>` 1029 1030.. raw:: latex 1031 1032 \normalsize 1033 1034.. _vp8_frame_flags: 1035 1036``Frame Flags`` 1037 1038.. tabularcolumns:: |p{9.8cm}|p{0.8cm}|p{6.7cm}| 1039 1040.. cssclass:: longtable 1041 1042.. flat-table:: 1043 :header-rows: 0 1044 :stub-columns: 0 1045 :widths: 1 1 2 1046 1047 * - ``V4L2_VP8_FRAME_FLAG_KEY_FRAME`` 1048 - 0x01 1049 - Indicates if the frame is a key frame. 1050 * - ``V4L2_VP8_FRAME_FLAG_EXPERIMENTAL`` 1051 - 0x02 1052 - Experimental bitstream. 1053 * - ``V4L2_VP8_FRAME_FLAG_SHOW_FRAME`` 1054 - 0x04 1055 - Show frame flag, indicates if the frame is for display. 1056 * - ``V4L2_VP8_FRAME_FLAG_MB_NO_SKIP_COEFF`` 1057 - 0x08 1058 - Enable/disable skipping of macroblocks with no non-zero coefficients. 1059 * - ``V4L2_VP8_FRAME_FLAG_SIGN_BIAS_GOLDEN`` 1060 - 0x10 1061 - Sign of motion vectors when the golden frame is referenced. 1062 * - ``V4L2_VP8_FRAME_FLAG_SIGN_BIAS_ALT`` 1063 - 0x20 1064 - Sign of motion vectors when the alt frame is referenced. 1065 1066.. c:type:: v4l2_vp8_entropy_coder_state 1067 1068.. cssclass:: longtable 1069 1070.. tabularcolumns:: |p{1.0cm}|p{2.0cm}|p{14.3cm}| 1071 1072.. flat-table:: struct v4l2_vp8_entropy_coder_state 1073 :header-rows: 0 1074 :stub-columns: 0 1075 :widths: 1 1 2 1076 1077 * - __u8 1078 - ``range`` 1079 - coder state value for "Range" 1080 * - __u8 1081 - ``value`` 1082 - coder state value for "Value"- 1083 * - __u8 1084 - ``bit_count`` 1085 - number of bits left. 1086 * - __u8 1087 - ``padding`` 1088 - Applications and drivers must set this to zero. 1089 1090.. c:type:: v4l2_vp8_segment 1091 1092.. cssclass:: longtable 1093 1094.. tabularcolumns:: |p{1.2cm}|p{4.0cm}|p{12.1cm}| 1095 1096.. flat-table:: struct v4l2_vp8_segment 1097 :header-rows: 0 1098 :stub-columns: 0 1099 :widths: 1 1 2 1100 1101 * - __s8 1102 - ``quant_update[4]`` 1103 - Signed quantizer value update. 1104 * - __s8 1105 - ``lf_update[4]`` 1106 - Signed loop filter level value update. 1107 * - __u8 1108 - ``segment_probs[3]`` 1109 - Segment probabilities. 1110 * - __u8 1111 - ``padding`` 1112 - Applications and drivers must set this to zero. 1113 * - __u32 1114 - ``flags`` 1115 - See :ref:`Segment Flags <vp8_segment_flags>` 1116 1117.. _vp8_segment_flags: 1118 1119``Segment Flags`` 1120 1121.. raw:: latex 1122 1123 \small 1124 1125.. tabularcolumns:: |p{10cm}|p{1.0cm}|p{6.3cm}| 1126 1127.. flat-table:: 1128 :header-rows: 0 1129 :stub-columns: 0 1130 :widths: 1 1 2 1131 1132 * - ``V4L2_VP8_SEGMENT_FLAG_ENABLED`` 1133 - 0x01 1134 - Enable/disable segment-based adjustments. 1135 * - ``V4L2_VP8_SEGMENT_FLAG_UPDATE_MAP`` 1136 - 0x02 1137 - Indicates if the macroblock segmentation map is updated in this frame. 1138 * - ``V4L2_VP8_SEGMENT_FLAG_UPDATE_FEATURE_DATA`` 1139 - 0x04 1140 - Indicates if the segment feature data is updated in this frame. 1141 * - ``V4L2_VP8_SEGMENT_FLAG_DELTA_VALUE_MODE`` 1142 - 0x08 1143 - If is set, the segment feature data mode is delta-value. 1144 If cleared, it's absolute-value. 1145 1146.. raw:: latex 1147 1148 \normalsize 1149 1150.. c:type:: v4l2_vp8_loop_filter 1151 1152.. cssclass:: longtable 1153 1154.. tabularcolumns:: |p{1.5cm}|p{3.9cm}|p{11.9cm}| 1155 1156.. flat-table:: struct v4l2_vp8_loop_filter 1157 :header-rows: 0 1158 :stub-columns: 0 1159 :widths: 1 1 2 1160 1161 * - __s8 1162 - ``ref_frm_delta[4]`` 1163 - Reference adjustment (signed) delta value. 1164 * - __s8 1165 - ``mb_mode_delta[4]`` 1166 - Macroblock prediction mode adjustment (signed) delta value. 1167 * - __u8 1168 - ``sharpness_level`` 1169 - Sharpness level 1170 * - __u8 1171 - ``level`` 1172 - Filter level 1173 * - __u16 1174 - ``padding`` 1175 - Applications and drivers must set this to zero. 1176 * - __u32 1177 - ``flags`` 1178 - See :ref:`Loop Filter Flags <vp8_loop_filter_flags>` 1179 1180.. _vp8_loop_filter_flags: 1181 1182``Loop Filter Flags`` 1183 1184.. tabularcolumns:: |p{7.0cm}|p{1.2cm}|p{9.1cm}| 1185 1186.. flat-table:: 1187 :header-rows: 0 1188 :stub-columns: 0 1189 :widths: 1 1 2 1190 1191 * - ``V4L2_VP8_LF_ADJ_ENABLE`` 1192 - 0x01 1193 - Enable/disable macroblock-level loop filter adjustment. 1194 * - ``V4L2_VP8_LF_DELTA_UPDATE`` 1195 - 0x02 1196 - Indicates if the delta values used in an adjustment are updated. 1197 * - ``V4L2_VP8_LF_FILTER_TYPE_SIMPLE`` 1198 - 0x04 1199 - If set, indicates the filter type is simple. 1200 If cleared, the filter type is normal. 1201 1202.. c:type:: v4l2_vp8_quantization 1203 1204.. tabularcolumns:: |p{1.5cm}|p{3.5cm}|p{12.3cm}| 1205 1206.. flat-table:: struct v4l2_vp8_quantization 1207 :header-rows: 0 1208 :stub-columns: 0 1209 :widths: 1 1 2 1210 1211 * - __u8 1212 - ``y_ac_qi`` 1213 - Luma AC coefficient table index. 1214 * - __s8 1215 - ``y_dc_delta`` 1216 - Luma DC delta vaue. 1217 * - __s8 1218 - ``y2_dc_delta`` 1219 - Y2 block DC delta value. 1220 * - __s8 1221 - ``y2_ac_delta`` 1222 - Y2 block AC delta value. 1223 * - __s8 1224 - ``uv_dc_delta`` 1225 - Chroma DC delta value. 1226 * - __s8 1227 - ``uv_ac_delta`` 1228 - Chroma AC delta value. 1229 * - __u16 1230 - ``padding`` 1231 - Applications and drivers must set this to zero. 1232 1233.. c:type:: v4l2_vp8_entropy 1234 1235.. cssclass:: longtable 1236 1237.. tabularcolumns:: |p{1.5cm}|p{5.8cm}|p{10.0cm}| 1238 1239.. flat-table:: struct v4l2_vp8_entropy 1240 :header-rows: 0 1241 :stub-columns: 0 1242 :widths: 1 1 2 1243 1244 * - __u8 1245 - ``coeff_probs[4][8][3][11]`` 1246 - Coefficient update probabilities. 1247 * - __u8 1248 - ``y_mode_probs[4]`` 1249 - Luma mode update probabilities. 1250 * - __u8 1251 - ``uv_mode_probs[3]`` 1252 - Chroma mode update probabilities. 1253 * - __u8 1254 - ``mv_probs[2][19]`` 1255 - MV decoding update probabilities. 1256 * - __u8 1257 - ``padding[3]`` 1258 - Applications and drivers must set this to zero. 1259 1260.. _v4l2-codec-stateless-mpeg2: 1261 1262``V4L2_CID_STATELESS_MPEG2_SEQUENCE (struct)`` 1263 Specifies the sequence parameters (as extracted from the bitstream) for the 1264 associated MPEG-2 slice data. This includes fields matching the syntax 1265 elements from the sequence header and sequence extension parts of the 1266 bitstream as specified by :ref:`mpeg2part2`. 1267 1268.. c:type:: v4l2_ctrl_mpeg2_sequence 1269 1270.. raw:: latex 1271 1272 \small 1273 1274.. cssclass:: longtable 1275 1276.. tabularcolumns:: |p{1.4cm}|p{6.5cm}|p{9.4cm}| 1277 1278.. flat-table:: struct v4l2_ctrl_mpeg2_sequence 1279 :header-rows: 0 1280 :stub-columns: 0 1281 :widths: 1 1 2 1282 1283 * - __u16 1284 - ``horizontal_size`` 1285 - The width of the displayable part of the frame's luminance component. 1286 * - __u16 1287 - ``vertical_size`` 1288 - The height of the displayable part of the frame's luminance component. 1289 * - __u32 1290 - ``vbv_buffer_size`` 1291 - Used to calculate the required size of the video buffering verifier, 1292 defined (in bits) as: 16 * 1024 * vbv_buffer_size. 1293 * - __u16 1294 - ``profile_and_level_indication`` 1295 - The current profile and level indication as extracted from the 1296 bitstream. 1297 * - __u8 1298 - ``chroma_format`` 1299 - The chrominance sub-sampling format (1: 4:2:0, 2: 4:2:2, 3: 4:4:4). 1300 * - __u8 1301 - ``flags`` 1302 - See :ref:`MPEG-2 Sequence Flags <mpeg2_sequence_flags>`. 1303 1304.. _mpeg2_sequence_flags: 1305 1306``MPEG-2 Sequence Flags`` 1307 1308.. cssclass:: longtable 1309 1310.. flat-table:: 1311 :header-rows: 0 1312 :stub-columns: 0 1313 :widths: 1 1 2 1314 1315 * - ``V4L2_MPEG2_SEQ_FLAG_PROGRESSIVE`` 1316 - 0x01 1317 - Indication that all the frames for the sequence are progressive instead 1318 of interlaced. 1319 1320.. raw:: latex 1321 1322 \normalsize 1323 1324``V4L2_CID_STATELESS_MPEG2_PICTURE (struct)`` 1325 Specifies the picture parameters (as extracted from the bitstream) for the 1326 associated MPEG-2 slice data. This includes fields matching the syntax 1327 elements from the picture header and picture coding extension parts of the 1328 bitstream as specified by :ref:`mpeg2part2`. 1329 1330.. c:type:: v4l2_ctrl_mpeg2_picture 1331 1332.. raw:: latex 1333 1334 \small 1335 1336.. cssclass:: longtable 1337 1338.. tabularcolumns:: |p{1.0cm}|p{5.6cm}|p{10.7cm}| 1339 1340.. flat-table:: struct v4l2_ctrl_mpeg2_picture 1341 :header-rows: 0 1342 :stub-columns: 0 1343 :widths: 1 1 2 1344 1345 * - __u64 1346 - ``backward_ref_ts`` 1347 - Timestamp of the V4L2 capture buffer to use as backward reference, used 1348 with B-coded and P-coded frames. The timestamp refers to the 1349 ``timestamp`` field in struct :c:type:`v4l2_buffer`. Use the 1350 :c:func:`v4l2_timeval_to_ns()` function to convert the struct 1351 :c:type:`timeval` in struct :c:type:`v4l2_buffer` to a __u64. 1352 * - __u64 1353 - ``forward_ref_ts`` 1354 - Timestamp for the V4L2 capture buffer to use as forward reference, used 1355 with B-coded frames. The timestamp refers to the ``timestamp`` field in 1356 struct :c:type:`v4l2_buffer`. Use the :c:func:`v4l2_timeval_to_ns()` 1357 function to convert the struct :c:type:`timeval` in struct 1358 :c:type:`v4l2_buffer` to a __u64. 1359 * - __u32 1360 - ``flags`` 1361 - See :ref:`MPEG-2 Picture Flags <mpeg2_picture_flags>`. 1362 * - __u8 1363 - ``f_code[2][2]`` 1364 - Motion vector codes. 1365 * - __u8 1366 - ``picture_coding_type`` 1367 - Picture coding type for the frame covered by the current slice 1368 (V4L2_MPEG2_PIC_CODING_TYPE_I, V4L2_MPEG2_PIC_CODING_TYPE_P or 1369 V4L2_MPEG2_PIC_CODING_TYPE_B). 1370 * - __u8 1371 - ``picture_structure`` 1372 - Picture structure (1: interlaced top field, 2: interlaced bottom field, 1373 3: progressive frame). 1374 * - __u8 1375 - ``intra_dc_precision`` 1376 - Precision of Discrete Cosine transform (0: 8 bits precision, 1377 1: 9 bits precision, 2: 10 bits precision, 3: 11 bits precision). 1378 * - __u8 1379 - ``reserved[5]`` 1380 - Applications and drivers must set this to zero. 1381 1382.. _mpeg2_picture_flags: 1383 1384``MPEG-2 Picture Flags`` 1385 1386.. cssclass:: longtable 1387 1388.. flat-table:: 1389 :header-rows: 0 1390 :stub-columns: 0 1391 :widths: 1 1 2 1392 1393 * - ``V4L2_MPEG2_PIC_FLAG_TOP_FIELD_FIRST`` 1394 - 0x00000001 1395 - If set and it's an interlaced stream, top field is output first. 1396 * - ``V4L2_MPEG2_PIC_FLAG_FRAME_PRED_DCT`` 1397 - 0x00000002 1398 - If set only frame-DCT and frame prediction are used. 1399 * - ``V4L2_MPEG2_PIC_FLAG_CONCEALMENT_MV`` 1400 - 0x00000004 1401 - If set motion vectors are coded for intra macroblocks. 1402 * - ``V4L2_MPEG2_PIC_FLAG_Q_SCALE_TYPE`` 1403 - 0x00000008 1404 - This flag affects the inverse quantization process. 1405 * - ``V4L2_MPEG2_PIC_FLAG_INTRA_VLC`` 1406 - 0x00000010 1407 - This flag affects the decoding of transform coefficient data. 1408 * - ``V4L2_MPEG2_PIC_FLAG_ALT_SCAN`` 1409 - 0x00000020 1410 - This flag affects the decoding of transform coefficient data. 1411 * - ``V4L2_MPEG2_PIC_FLAG_REPEAT_FIRST`` 1412 - 0x00000040 1413 - This flag affects the decoding process of progressive frames. 1414 * - ``V4L2_MPEG2_PIC_FLAG_PROGRESSIVE`` 1415 - 0x00000080 1416 - Indicates whether the current frame is progressive. 1417 1418.. raw:: latex 1419 1420 \normalsize 1421 1422``V4L2_CID_STATELESS_MPEG2_QUANTISATION (struct)`` 1423 Specifies quantisation matrices, in zigzag scanning order, for the 1424 associated MPEG-2 slice data. This control is initialized by the kernel 1425 to the matrices default values. If a bitstream transmits a user-defined 1426 quantisation matrices load, applications are expected to use this control. 1427 Applications are also expected to set the control loading the default 1428 values, if the quantisation matrices need to be reset, for instance on a 1429 sequence header. This process is specified by section 6.3.7. 1430 "Quant matrix extension" of the specification. 1431 1432.. c:type:: v4l2_ctrl_mpeg2_quantisation 1433 1434.. tabularcolumns:: |p{0.8cm}|p{8.0cm}|p{8.5cm}| 1435 1436.. cssclass:: longtable 1437 1438.. raw:: latex 1439 1440 \small 1441 1442.. flat-table:: struct v4l2_ctrl_mpeg2_quantisation 1443 :header-rows: 0 1444 :stub-columns: 0 1445 :widths: 1 1 2 1446 1447 * - __u8 1448 - ``intra_quantiser_matrix[64]`` 1449 - The quantisation matrix coefficients for intra-coded frames, in zigzag 1450 scanning order. It is relevant for both luma and chroma components, 1451 although it can be superseded by the chroma-specific matrix for 1452 non-4:2:0 YUV formats. 1453 * - __u8 1454 - ``non_intra_quantiser_matrix[64]`` 1455 - The quantisation matrix coefficients for non-intra-coded frames, in 1456 zigzag scanning order. It is relevant for both luma and chroma 1457 components, although it can be superseded by the chroma-specific matrix 1458 for non-4:2:0 YUV formats. 1459 * - __u8 1460 - ``chroma_intra_quantiser_matrix[64]`` 1461 - The quantisation matrix coefficients for the chominance component of 1462 intra-coded frames, in zigzag scanning order. Only relevant for 1463 non-4:2:0 YUV formats. 1464 * - __u8 1465 - ``chroma_non_intra_quantiser_matrix[64]`` 1466 - The quantisation matrix coefficients for the chrominance component of 1467 non-intra-coded frames, in zigzag scanning order. Only relevant for 1468 non-4:2:0 YUV formats. 1469 1470.. raw:: latex 1471 1472 \normalsize 1473 1474.. _v4l2-codec-stateless-vp9: 1475 1476``V4L2_CID_STATELESS_VP9_COMPRESSED_HDR (struct)`` 1477 Stores VP9 probabilities updates as parsed from the current compressed frame 1478 header. A value of zero in an array element means no update of the relevant 1479 probability. Motion vector-related updates contain a new value or zero. All 1480 other updates contain values translated with inv_map_table[] (see 6.3.5 in 1481 :ref:`vp9`). 1482 1483.. c:type:: v4l2_ctrl_vp9_compressed_hdr 1484 1485.. tabularcolumns:: |p{1cm}|p{4.8cm}|p{11.4cm}| 1486 1487.. cssclass:: longtable 1488 1489.. flat-table:: struct v4l2_ctrl_vp9_compressed_hdr 1490 :header-rows: 0 1491 :stub-columns: 0 1492 :widths: 1 1 2 1493 1494 * - __u8 1495 - ``tx_mode`` 1496 - Specifies the TX mode. See :ref:`TX Mode <vp9_tx_mode>` for more details. 1497 * - __u8 1498 - ``tx8[2][1]`` 1499 - TX 8x8 probabilities delta. 1500 * - __u8 1501 - ``tx16[2][2]`` 1502 - TX 16x16 probabilities delta. 1503 * - __u8 1504 - ``tx32[2][3]`` 1505 - TX 32x32 probabilities delta. 1506 * - __u8 1507 - ``coef[4][2][2][6][6][3]`` 1508 - Coefficient probabilities delta. 1509 * - __u8 1510 - ``skip[3]`` 1511 - Skip probabilities delta. 1512 * - __u8 1513 - ``inter_mode[7][3]`` 1514 - Inter prediction mode probabilities delta. 1515 * - __u8 1516 - ``interp_filter[4][2]`` 1517 - Interpolation filter probabilities delta. 1518 * - __u8 1519 - ``is_inter[4]`` 1520 - Is inter-block probabilities delta. 1521 * - __u8 1522 - ``comp_mode[5]`` 1523 - Compound prediction mode probabilities delta. 1524 * - __u8 1525 - ``single_ref[5][2]`` 1526 - Single reference probabilities delta. 1527 * - __u8 1528 - ``comp_ref[5]`` 1529 - Compound reference probabilities delta. 1530 * - __u8 1531 - ``y_mode[4][9]`` 1532 - Y prediction mode probabilities delta. 1533 * - __u8 1534 - ``uv_mode[10][9]`` 1535 - UV prediction mode probabilities delta. 1536 * - __u8 1537 - ``partition[16][3]`` 1538 - Partition probabilities delta. 1539 * - __u8 1540 - ``mv.joint[3]`` 1541 - Motion vector joint probabilities delta. 1542 * - __u8 1543 - ``mv.sign[2]`` 1544 - Motion vector sign probabilities delta. 1545 * - __u8 1546 - ``mv.classes[2][10]`` 1547 - Motion vector class probabilities delta. 1548 * - __u8 1549 - ``mv.class0_bit[2]`` 1550 - Motion vector class0 bit probabilities delta. 1551 * - __u8 1552 - ``mv.bits[2][10]`` 1553 - Motion vector bits probabilities delta. 1554 * - __u8 1555 - ``mv.class0_fr[2][2][3]`` 1556 - Motion vector class0 fractional bit probabilities delta. 1557 * - __u8 1558 - ``mv.fr[2][3]`` 1559 - Motion vector fractional bit probabilities delta. 1560 * - __u8 1561 - ``mv.class0_hp[2]`` 1562 - Motion vector class0 high precision fractional bit probabilities delta. 1563 * - __u8 1564 - ``mv.hp[2]`` 1565 - Motion vector high precision fractional bit probabilities delta. 1566 1567.. _vp9_tx_mode: 1568 1569``TX Mode`` 1570 1571.. tabularcolumns:: |p{6.5cm}|p{0.5cm}|p{10.3cm}| 1572 1573.. flat-table:: 1574 :header-rows: 0 1575 :stub-columns: 0 1576 :widths: 1 1 2 1577 1578 * - ``V4L2_VP9_TX_MODE_ONLY_4X4`` 1579 - 0 1580 - Transform size is 4x4. 1581 * - ``V4L2_VP9_TX_MODE_ALLOW_8X8`` 1582 - 1 1583 - Transform size can be up to 8x8. 1584 * - ``V4L2_VP9_TX_MODE_ALLOW_16X16`` 1585 - 2 1586 - Transform size can be up to 16x16. 1587 * - ``V4L2_VP9_TX_MODE_ALLOW_32X32`` 1588 - 3 1589 - transform size can be up to 32x32. 1590 * - ``V4L2_VP9_TX_MODE_SELECT`` 1591 - 4 1592 - Bitstream contains the transform size for each block. 1593 1594See section '7.3.1 Tx mode semantics' of the :ref:`vp9` specification for more details. 1595 1596``V4L2_CID_STATELESS_VP9_FRAME (struct)`` 1597 Specifies the frame parameters for the associated VP9 frame decode request. 1598 This includes the necessary parameters for configuring a stateless hardware 1599 decoding pipeline for VP9. The bitstream parameters are defined according 1600 to :ref:`vp9`. 1601 1602.. c:type:: v4l2_ctrl_vp9_frame 1603 1604.. raw:: latex 1605 1606 \small 1607 1608.. tabularcolumns:: |p{4.7cm}|p{5.5cm}|p{7.1cm}| 1609 1610.. cssclass:: longtable 1611 1612.. flat-table:: struct v4l2_ctrl_vp9_frame 1613 :header-rows: 0 1614 :stub-columns: 0 1615 :widths: 1 1 2 1616 1617 * - struct :c:type:`v4l2_vp9_loop_filter` 1618 - ``lf`` 1619 - Loop filter parameters. See struct :c:type:`v4l2_vp9_loop_filter` for more details. 1620 * - struct :c:type:`v4l2_vp9_quantization` 1621 - ``quant`` 1622 - Quantization parameters. See :c:type:`v4l2_vp9_quantization` for more details. 1623 * - struct :c:type:`v4l2_vp9_segmentation` 1624 - ``seg`` 1625 - Segmentation parameters. See :c:type:`v4l2_vp9_segmentation` for more details. 1626 * - __u32 1627 - ``flags`` 1628 - Combination of V4L2_VP9_FRAME_FLAG_* flags. See :ref:`Frame Flags<vp9_frame_flags>`. 1629 * - __u16 1630 - ``compressed_header_size`` 1631 - Compressed header size in bytes. 1632 * - __u16 1633 - ``uncompressed_header_size`` 1634 - Uncompressed header size in bytes. 1635 * - __u16 1636 - ``frame_width_minus_1`` 1637 - Add 1 to get the frame width expressed in pixels. See section 7.2.3 in :ref:`vp9`. 1638 * - __u16 1639 - ``frame_height_minus_1`` 1640 - Add 1 to get the frame height expressed in pixels. See section 7.2.3 in :ref:`vp9`. 1641 * - __u16 1642 - ``render_width_minus_1`` 1643 - Add 1 to get the expected render width expressed in pixels. This is 1644 not used during the decoding process but might be used by HW scalers to 1645 prepare a frame that's ready for scanout. See section 7.2.4 in :ref:`vp9`. 1646 * - __u16 1647 - render_height_minus_1 1648 - Add 1 to get the expected render height expressed in pixels. This is 1649 not used during the decoding process but might be used by HW scalers to 1650 prepare a frame that's ready for scanout. See section 7.2.4 in :ref:`vp9`. 1651 * - __u64 1652 - ``last_frame_ts`` 1653 - "last" reference buffer timestamp. 1654 The timestamp refers to the ``timestamp`` field in 1655 struct :c:type:`v4l2_buffer`. Use the :c:func:`v4l2_timeval_to_ns()` 1656 function to convert the struct :c:type:`timeval` in struct 1657 :c:type:`v4l2_buffer` to a __u64. 1658 * - __u64 1659 - ``golden_frame_ts`` 1660 - "golden" reference buffer timestamp. 1661 The timestamp refers to the ``timestamp`` field in 1662 struct :c:type:`v4l2_buffer`. Use the :c:func:`v4l2_timeval_to_ns()` 1663 function to convert the struct :c:type:`timeval` in struct 1664 :c:type:`v4l2_buffer` to a __u64. 1665 * - __u64 1666 - ``alt_frame_ts`` 1667 - "alt" reference buffer timestamp. 1668 The timestamp refers to the ``timestamp`` field in 1669 struct :c:type:`v4l2_buffer`. Use the :c:func:`v4l2_timeval_to_ns()` 1670 function to convert the struct :c:type:`timeval` in struct 1671 :c:type:`v4l2_buffer` to a __u64. 1672 * - __u8 1673 - ``ref_frame_sign_bias`` 1674 - a bitfield specifying whether the sign bias is set for a given 1675 reference frame. See :ref:`Reference Frame Sign Bias<vp9_ref_frame_sign_bias>` 1676 for more details. 1677 * - __u8 1678 - ``reset_frame_context`` 1679 - specifies whether the frame context should be reset to default values. See 1680 :ref:`Reset Frame Context<vp9_reset_frame_context>` for more details. 1681 * - __u8 1682 - ``frame_context_idx`` 1683 - Frame context that should be used/updated. 1684 * - __u8 1685 - ``profile`` 1686 - VP9 profile. Can be 0, 1, 2 or 3. 1687 * - __u8 1688 - ``bit_depth`` 1689 - Component depth in bits. Can be 8, 10 or 12. Note that not all profiles 1690 support 10 and/or 12 bits depths. 1691 * - __u8 1692 - ``interpolation_filter`` 1693 - Specifies the filter selection used for performing inter prediction. See 1694 :ref:`Interpolation Filter<vp9_interpolation_filter>` for more details. 1695 * - __u8 1696 - ``tile_cols_log2`` 1697 - Specifies the base 2 logarithm of the width of each tile (where the 1698 width is measured in units of 8x8 blocks). Shall be less than or equal 1699 to 6. 1700 * - __u8 1701 - ``tile_rows_log2`` 1702 - Specifies the base 2 logarithm of the height of each tile (where the 1703 height is measured in units of 8x8 blocks). 1704 * - __u8 1705 - ``reference_mode`` 1706 - Specifies the type of inter prediction to be used. See 1707 :ref:`Reference Mode<vp9_reference_mode>` for more details. Note that 1708 this is derived as part of the compressed header parsing process and 1709 for this reason should have been part of 1710 :c:type: `v4l2_ctrl_vp9_compressed_hdr` optional control. It is safe to 1711 set this value to zero if the driver does not require compressed 1712 headers. 1713 * - __u8 1714 - ``reserved[7]`` 1715 - Applications and drivers must set this to zero. 1716 1717.. raw:: latex 1718 1719 \normalsize 1720 1721.. _vp9_frame_flags: 1722 1723``Frame Flags`` 1724 1725.. tabularcolumns:: |p{10.0cm}|p{1.2cm}|p{6.1cm}| 1726 1727.. flat-table:: 1728 :header-rows: 0 1729 :stub-columns: 0 1730 :widths: 1 1 2 1731 1732 * - ``V4L2_VP9_FRAME_FLAG_KEY_FRAME`` 1733 - 0x001 1734 - The frame is a key frame. 1735 * - ``V4L2_VP9_FRAME_FLAG_SHOW_FRAME`` 1736 - 0x002 1737 - The frame should be displayed. 1738 * - ``V4L2_VP9_FRAME_FLAG_ERROR_RESILIENT`` 1739 - 0x004 1740 - The decoding should be error resilient. 1741 * - ``V4L2_VP9_FRAME_FLAG_INTRA_ONLY`` 1742 - 0x008 1743 - The frame does not reference other frames. 1744 * - ``V4L2_VP9_FRAME_FLAG_ALLOW_HIGH_PREC_MV`` 1745 - 0x010 1746 - The frame can use high precision motion vectors. 1747 * - ``V4L2_VP9_FRAME_FLAG_REFRESH_FRAME_CTX`` 1748 - 0x020 1749 - Frame context should be updated after decoding. 1750 * - ``V4L2_VP9_FRAME_FLAG_PARALLEL_DEC_MODE`` 1751 - 0x040 1752 - Parallel decoding is used. 1753 * - ``V4L2_VP9_FRAME_FLAG_X_SUBSAMPLING`` 1754 - 0x080 1755 - Vertical subsampling is enabled. 1756 * - ``V4L2_VP9_FRAME_FLAG_Y_SUBSAMPLING`` 1757 - 0x100 1758 - Horizontal subsampling is enabled. 1759 * - ``V4L2_VP9_FRAME_FLAG_COLOR_RANGE_FULL_SWING`` 1760 - 0x200 1761 - The full UV range is used. 1762 1763.. _vp9_ref_frame_sign_bias: 1764 1765``Reference Frame Sign Bias`` 1766 1767.. tabularcolumns:: |p{7.0cm}|p{1.2cm}|p{9.1cm}| 1768 1769.. flat-table:: 1770 :header-rows: 0 1771 :stub-columns: 0 1772 :widths: 1 1 2 1773 1774 * - ``V4L2_VP9_SIGN_BIAS_LAST`` 1775 - 0x1 1776 - Sign bias is set for the last reference frame. 1777 * - ``V4L2_VP9_SIGN_BIAS_GOLDEN`` 1778 - 0x2 1779 - Sign bias is set for the golden reference frame. 1780 * - ``V4L2_VP9_SIGN_BIAS_ALT`` 1781 - 0x2 1782 - Sign bias is set for the alt reference frame. 1783 1784.. _vp9_reset_frame_context: 1785 1786``Reset Frame Context`` 1787 1788.. tabularcolumns:: |p{7.0cm}|p{1.2cm}|p{9.1cm}| 1789 1790.. flat-table:: 1791 :header-rows: 0 1792 :stub-columns: 0 1793 :widths: 1 1 2 1794 1795 * - ``V4L2_VP9_RESET_FRAME_CTX_NONE`` 1796 - 0 1797 - Do not reset any frame context. 1798 * - ``V4L2_VP9_RESET_FRAME_CTX_SPEC`` 1799 - 1 1800 - Reset the frame context pointed to by 1801 :c:type:`v4l2_ctrl_vp9_frame`.frame_context_idx. 1802 * - ``V4L2_VP9_RESET_FRAME_CTX_ALL`` 1803 - 2 1804 - Reset all frame contexts. 1805 1806See section '7.2 Uncompressed header semantics' of the :ref:`vp9` specification 1807for more details. 1808 1809.. _vp9_interpolation_filter: 1810 1811``Interpolation Filter`` 1812 1813.. tabularcolumns:: |p{9.0cm}|p{1.2cm}|p{7.1cm}| 1814 1815.. flat-table:: 1816 :header-rows: 0 1817 :stub-columns: 0 1818 :widths: 1 1 2 1819 1820 * - ``V4L2_VP9_INTERP_FILTER_EIGHTTAP`` 1821 - 0 1822 - Eight tap filter. 1823 * - ``V4L2_VP9_INTERP_FILTER_EIGHTTAP_SMOOTH`` 1824 - 1 1825 - Eight tap smooth filter. 1826 * - ``V4L2_VP9_INTERP_FILTER_EIGHTTAP_SHARP`` 1827 - 2 1828 - Eeight tap sharp filter. 1829 * - ``V4L2_VP9_INTERP_FILTER_BILINEAR`` 1830 - 3 1831 - Bilinear filter. 1832 * - ``V4L2_VP9_INTERP_FILTER_SWITCHABLE`` 1833 - 4 1834 - Filter selection is signaled at the block level. 1835 1836See section '7.2.7 Interpolation filter semantics' of the :ref:`vp9` specification 1837for more details. 1838 1839.. _vp9_reference_mode: 1840 1841``Reference Mode`` 1842 1843.. tabularcolumns:: |p{9.6cm}|p{0.5cm}|p{7.2cm}| 1844 1845.. flat-table:: 1846 :header-rows: 0 1847 :stub-columns: 0 1848 :widths: 1 1 2 1849 1850 * - ``V4L2_VP9_REFERENCE_MODE_SINGLE_REFERENCE`` 1851 - 0 1852 - Indicates that all the inter blocks use only a single reference frame 1853 to generate motion compensated prediction. 1854 * - ``V4L2_VP9_REFERENCE_MODE_COMPOUND_REFERENCE`` 1855 - 1 1856 - Requires all the inter blocks to use compound mode. Single reference 1857 frame prediction is not allowed. 1858 * - ``V4L2_VP9_REFERENCE_MODE_SELECT`` 1859 - 2 1860 - Allows each individual inter block to select between single and 1861 compound prediction modes. 1862 1863See section '7.3.6 Frame reference mode semantics' of the :ref:`vp9` specification for more details. 1864 1865.. c:type:: v4l2_vp9_segmentation 1866 1867Encodes the quantization parameters. See section '7.2.10 Segmentation 1868params syntax' of the :ref:`vp9` specification for more details. 1869 1870.. tabularcolumns:: |p{0.8cm}|p{5cm}|p{11.4cm}| 1871 1872.. cssclass:: longtable 1873 1874.. flat-table:: struct v4l2_vp9_segmentation 1875 :header-rows: 0 1876 :stub-columns: 0 1877 :widths: 1 1 2 1878 1879 * - __u8 1880 - ``feature_data[8][4]`` 1881 - Data attached to each feature. Data entry is only valid if the feature 1882 is enabled. The array shall be indexed with segment number as the first dimension 1883 (0..7) and one of V4L2_VP9_SEG_* as the second dimension. 1884 See :ref:`Segment Feature IDs<vp9_segment_feature>`. 1885 * - __u8 1886 - ``feature_enabled[8]`` 1887 - Bitmask defining which features are enabled in each segment. The value for each 1888 segment is a combination of V4L2_VP9_SEGMENT_FEATURE_ENABLED(id) values where id is 1889 one of V4L2_VP9_SEG_*. See :ref:`Segment Feature IDs<vp9_segment_feature>`. 1890 * - __u8 1891 - ``tree_probs[7]`` 1892 - Specifies the probability values to be used when decoding a Segment-ID. 1893 See '5.15. Segmentation map' section of :ref:`vp9` for more details. 1894 * - __u8 1895 - ``pred_probs[3]`` 1896 - Specifies the probability values to be used when decoding a 1897 Predicted-Segment-ID. See '6.4.14. Get segment id syntax' 1898 section of :ref:`vp9` for more details. 1899 * - __u8 1900 - ``flags`` 1901 - Combination of V4L2_VP9_SEGMENTATION_FLAG_* flags. See 1902 :ref:`Segmentation Flags<vp9_segmentation_flags>`. 1903 * - __u8 1904 - ``reserved[5]`` 1905 - Applications and drivers must set this to zero. 1906 1907.. _vp9_segment_feature: 1908 1909``Segment feature IDs`` 1910 1911.. tabularcolumns:: |p{6.0cm}|p{1cm}|p{10.3cm}| 1912 1913.. flat-table:: 1914 :header-rows: 0 1915 :stub-columns: 0 1916 :widths: 1 1 2 1917 1918 * - ``V4L2_VP9_SEG_LVL_ALT_Q`` 1919 - 0 1920 - Quantizer segment feature. 1921 * - ``V4L2_VP9_SEG_LVL_ALT_L`` 1922 - 1 1923 - Loop filter segment feature. 1924 * - ``V4L2_VP9_SEG_LVL_REF_FRAME`` 1925 - 2 1926 - Reference frame segment feature. 1927 * - ``V4L2_VP9_SEG_LVL_SKIP`` 1928 - 3 1929 - Skip segment feature. 1930 * - ``V4L2_VP9_SEG_LVL_MAX`` 1931 - 4 1932 - Number of segment features. 1933 1934.. _vp9_segmentation_flags: 1935 1936``Segmentation Flags`` 1937 1938.. tabularcolumns:: |p{10.6cm}|p{0.8cm}|p{5.9cm}| 1939 1940.. flat-table:: 1941 :header-rows: 0 1942 :stub-columns: 0 1943 :widths: 1 1 2 1944 1945 * - ``V4L2_VP9_SEGMENTATION_FLAG_ENABLED`` 1946 - 0x01 1947 - Indicates that this frame makes use of the segmentation tool. 1948 * - ``V4L2_VP9_SEGMENTATION_FLAG_UPDATE_MAP`` 1949 - 0x02 1950 - Indicates that the segmentation map should be updated during the 1951 decoding of this frame. 1952 * - ``V4L2_VP9_SEGMENTATION_FLAG_TEMPORAL_UPDATE`` 1953 - 0x04 1954 - Indicates that the updates to the segmentation map are coded 1955 relative to the existing segmentation map. 1956 * - ``V4L2_VP9_SEGMENTATION_FLAG_UPDATE_DATA`` 1957 - 0x08 1958 - Indicates that new parameters are about to be specified for each 1959 segment. 1960 * - ``V4L2_VP9_SEGMENTATION_FLAG_ABS_OR_DELTA_UPDATE`` 1961 - 0x10 1962 - Indicates that the segmentation parameters represent the actual values 1963 to be used. 1964 1965.. c:type:: v4l2_vp9_quantization 1966 1967Encodes the quantization parameters. See section '7.2.9 Quantization params 1968syntax' of the VP9 specification for more details. 1969 1970.. tabularcolumns:: |p{0.8cm}|p{4cm}|p{12.4cm}| 1971 1972.. cssclass:: longtable 1973 1974.. flat-table:: struct v4l2_vp9_quantization 1975 :header-rows: 0 1976 :stub-columns: 0 1977 :widths: 1 1 2 1978 1979 * - __u8 1980 - ``base_q_idx`` 1981 - Indicates the base frame qindex. 1982 * - __s8 1983 - ``delta_q_y_dc`` 1984 - Indicates the Y DC quantizer relative to base_q_idx. 1985 * - __s8 1986 - ``delta_q_uv_dc`` 1987 - Indicates the UV DC quantizer relative to base_q_idx. 1988 * - __s8 1989 - ``delta_q_uv_ac`` 1990 - Indicates the UV AC quantizer relative to base_q_idx. 1991 * - __u8 1992 - ``reserved[4]`` 1993 - Applications and drivers must set this to zero. 1994 1995.. c:type:: v4l2_vp9_loop_filter 1996 1997This structure contains all loop filter related parameters. See sections 1998'7.2.8 Loop filter semantics' of the :ref:`vp9` specification for more details. 1999 2000.. tabularcolumns:: |p{0.8cm}|p{4cm}|p{12.4cm}| 2001 2002.. cssclass:: longtable 2003 2004.. flat-table:: struct v4l2_vp9_loop_filter 2005 :header-rows: 0 2006 :stub-columns: 0 2007 :widths: 1 1 2 2008 2009 * - __s8 2010 - ``ref_deltas[4]`` 2011 - Contains the adjustment needed for the filter level based on the chosen 2012 reference frame. 2013 * - __s8 2014 - ``mode_deltas[2]`` 2015 - Contains the adjustment needed for the filter level based on the chosen 2016 mode. 2017 * - __u8 2018 - ``level`` 2019 - Indicates the loop filter strength. 2020 * - __u8 2021 - ``sharpness`` 2022 - Indicates the sharpness level. 2023 * - __u8 2024 - ``flags`` 2025 - Combination of V4L2_VP9_LOOP_FILTER_FLAG_* flags. 2026 See :ref:`Loop Filter Flags <vp9_loop_filter_flags>`. 2027 * - __u8 2028 - ``reserved[7]`` 2029 - Applications and drivers must set this to zero. 2030 2031 2032.. _vp9_loop_filter_flags: 2033 2034``Loop Filter Flags`` 2035 2036.. tabularcolumns:: |p{9.6cm}|p{0.5cm}|p{7.2cm}| 2037 2038.. flat-table:: 2039 :header-rows: 0 2040 :stub-columns: 0 2041 :widths: 1 1 2 2042 2043 * - ``V4L2_VP9_LOOP_FILTER_FLAG_DELTA_ENABLED`` 2044 - 0x1 2045 - When set, the filter level depends on the mode and reference frame used 2046 to predict a block. 2047 * - ``V4L2_VP9_LOOP_FILTER_FLAG_DELTA_UPDATE`` 2048 - 0x2 2049 - When set, the bitstream contains additional syntax elements that 2050 specify which mode and reference frame deltas are to be updated.