Re: [PATCH v2 1/8] media: uapi: vp8: Remove "header" from symbol names and macros

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Thu, Mar 4, 2021 at 5:27 AM Ezequiel Garcia <ezequiel@xxxxxxxxxxxxx> wrote:
>
> It doesn't seem to add any clarity to have a "header" suffix in controls,
> struct names and flags.
>
> Since this just makes names too long without any benefit, just drop it.
>
> Signed-off-by: Ezequiel Garcia <ezequiel@xxxxxxxxxxxxx>
> ---
>  .../media/v4l/ext-ctrls-codec.rst             | 80 +++++++--------
>  .../media/v4l/pixfmt-compressed.rst           |  2 +-
>  drivers/media/v4l2-core/v4l2-ctrls.c          | 36 +++----
>  drivers/staging/media/hantro/hantro_drv.c     |  2 +-
>  .../staging/media/hantro/hantro_g1_vp8_dec.c  | 48 ++++-----
>  drivers/staging/media/hantro/hantro_hw.h      |  2 +-
>  drivers/staging/media/hantro/hantro_vp8.c     | 10 +-
>  .../media/hantro/rk3399_vpu_hw_vp8_dec.c      | 48 ++++-----
>  drivers/staging/media/sunxi/cedrus/cedrus.c   |  2 +-
>  drivers/staging/media/sunxi/cedrus/cedrus.h   |  2 +-
>  .../staging/media/sunxi/cedrus/cedrus_dec.c   |  2 +-
>  .../staging/media/sunxi/cedrus/cedrus_vp8.c   | 98 +++++++++----------
>  include/media/v4l2-ctrls.h                    |  4 +-
>  include/media/vp8-ctrls.h                     | 48 ++++-----
>  14 files changed, 192 insertions(+), 192 deletions(-)
>
> diff --git a/Documentation/userspace-api/media/v4l/ext-ctrls-codec.rst b/Documentation/userspace-api/media/v4l/ext-ctrls-codec.rst
> index 00944e97d638..006301e88554 100644
> --- a/Documentation/userspace-api/media/v4l/ext-ctrls-codec.rst
> +++ b/Documentation/userspace-api/media/v4l/ext-ctrls-codec.rst
> @@ -1749,7 +1749,7 @@ enum v4l2_mpeg_video_h264_hierarchical_coding_type -
>
>  .. _v4l2-mpeg-vp8:
>
> -``V4L2_CID_MPEG_VIDEO_VP8_FRAME_HEADER (struct)``
> +``V4L2_CID_MPEG_VIDEO_VP8_FRAME (struct)``
>      Specifies the frame parameters for the associated VP8 parsed frame data.
>      This includes the necessary parameters for
>      configuring a stateless hardware decoding pipeline for VP8.
> @@ -1760,28 +1760,28 @@ enum v4l2_mpeg_video_h264_hierarchical_coding_type -
>         This compound control is not yet part of the public kernel API and
>         it is expected to change.
>
> -.. c:type:: v4l2_ctrl_vp8_frame_header
> +.. c:type:: v4l2_ctrl_vp8_frame
>
>  .. cssclass:: longtable
>
>  .. tabularcolumns:: |p{5.8cm}|p{4.8cm}|p{6.6cm}|
>
> -.. flat-table:: struct v4l2_ctrl_vp8_frame_header
> +.. flat-table:: struct v4l2_ctrl_vp8_frame
>      :header-rows:  0
>      :stub-columns: 0
>      :widths:       1 1 2
>
> -    * - struct :c:type:`v4l2_vp8_segment_header`
> -      - ``segment_header``
> +    * - struct :c:type:`v4l2_vp8_segment`
> +      - ``seg``
>        - Structure with segment-based adjustments metadata.
> -    * - struct :c:type:`v4l2_vp8_loopfilter_header`
> -      - ``loopfilter_header``
> +    * - struct :c:type:`v4l2_vp8_loopfilter`
> +      - ``lf``
>        - Structure with loop filter level adjustments metadata.
> -    * - struct :c:type:`v4l2_vp8_quantization_header`
> -      - ``quant_header``
> +    * - struct :c:type:`v4l2_vp8_quantization`
> +      - ``quant``
>        - Structure with VP8 dequantization indices metadata.
> -    * - struct :c:type:`v4l2_vp8_entropy_header`
> -      - ``entropy_header``
> +    * - struct :c:type:`v4l2_vp8_entropy`
> +      - ``entropy``
>        - Structure with VP8 entropy coder probabilities metadata.
>      * - struct :c:type:`v4l2_vp8_entropy_coder_state`
>        - ``coder_state``
> @@ -1850,11 +1850,11 @@ enum v4l2_mpeg_video_h264_hierarchical_coding_type -
>         :c:type:`v4l2_buffer` to a __u64.
>      * - __u64
>        - ``flags``
> -      - See :ref:`Frame Header Flags <vp8_frame_header_flags>`
> +      - See :ref:`Frame Flags <vp8_frame_flags>`
>
> -.. _vp8_frame_header_flags:
> +.. _vp8_frame_flags:
>
> -``Frame Header Flags``
> +``Frame Flags``
>
>  .. cssclass:: longtable
>
> @@ -1863,22 +1863,22 @@ enum v4l2_mpeg_video_h264_hierarchical_coding_type -
>      :stub-columns: 0
>      :widths:       1 1 2
>
> -    * - ``V4L2_VP8_FRAME_HEADER_FLAG_KEY_FRAME``
> +    * - ``V4L2_VP8_FRAME_FLAG_KEY_FRAME``
>        - 0x01
>        - Indicates if the frame is a key frame.
> -    * - ``V4L2_VP8_FRAME_HEADER_FLAG_EXPERIMENTAL``
> +    * - ``V4L2_VP8_FRAME_FLAG_EXPERIMENTAL``
>        - 0x02
>        - Experimental bitstream.
> -    * - ``V4L2_VP8_FRAME_HEADER_FLAG_SHOW_FRAME``
> +    * - ``V4L2_VP8_FRAME_FLAG_SHOW_FRAME``
>        - 0x04
>        - Show frame flag, indicates if the frame is for display.
> -    * - ``V4L2_VP8_FRAME_HEADER_FLAG_MB_NO_SKIP_COEFF``
> +    * - ``V4L2_VP8_FRAME_FLAG_MB_NO_SKIP_COEFF``
>        - 0x08
>        - Enable/disable skipping of macroblocks with no non-zero coefficients.
> -    * - ``V4L2_VP8_FRAME_HEADER_FLAG_SIGN_BIAS_GOLDEN``
> +    * - ``V4L2_VP8_FRAME_FLAG_SIGN_BIAS_GOLDEN``
>        - 0x10
>        - Sign of motion vectors when the golden frame is referenced.
> -    * - ``V4L2_VP8_FRAME_HEADER_FLAG_SIGN_BIAS_ALT``
> +    * - ``V4L2_VP8_FRAME_FLAG_SIGN_BIAS_ALT``
>        - 0x20
>        - Sign of motion vectors when the alt frame is referenced.
>
> @@ -1906,13 +1906,13 @@ enum v4l2_mpeg_video_h264_hierarchical_coding_type -
>        - ``padding``
>        - Applications and drivers must set this to zero.
>
> -.. c:type:: v4l2_vp8_segment_header
> +.. c:type:: v4l2_vp8_segment
>
>  .. cssclass:: longtable
>
>  .. tabularcolumns:: |p{1.5cm}|p{6.3cm}|p{9.4cm}|
>
> -.. flat-table:: struct v4l2_vp8_segment_header
> +.. flat-table:: struct v4l2_vp8_segment
>      :header-rows:  0
>      :stub-columns: 0
>      :widths:       1 1 2
> @@ -1931,11 +1931,11 @@ enum v4l2_mpeg_video_h264_hierarchical_coding_type -
>        - Applications and drivers must set this to zero.
>      * - __u32
>        - ``flags``
> -      - See :ref:`Segment Header Flags <vp8_segment_header_flags>`
> +      - See :ref:`Segment Flags <vp8_segment_flags>`
>
> -.. _vp8_segment_header_flags:
> +.. _vp8_segment_flags:
>
> -``Segment Header Flags``
> +``Segment Flags``
>
>  .. cssclass:: longtable
>
> @@ -1944,27 +1944,27 @@ enum v4l2_mpeg_video_h264_hierarchical_coding_type -
>      :stub-columns: 0
>      :widths:       1 1 2
>
> -    * - ``V4L2_VP8_SEGMENT_HEADER_FLAG_ENABLED``
> +    * - ``V4L2_VP8_SEGMENT_FLAG_ENABLED``
>        - 0x01
>        - Enable/disable segment-based adjustments.
> -    * - ``V4L2_VP8_SEGMENT_HEADER_FLAG_UPDATE_MAP``
> +    * - ``V4L2_VP8_SEGMENT_FLAG_UPDATE_MAP``
>        - 0x02
>        - Indicates if the macroblock segmentation map is updated in this frame.
> -    * - ``V4L2_VP8_SEGMENT_HEADER_FLAG_UPDATE_FEATURE_DATA``
> +    * - ``V4L2_VP8_SEGMENT_FLAG_UPDATE_FEATURE_DATA``
>        - 0x04
>        - Indicates if the segment feature data is updated in this frame.
> -    * - ``V4L2_VP8_SEGMENT_HEADER_FLAG_DELTA_VALUE_MODE``
> +    * - ``V4L2_VP8_SEGMENT_FLAG_DELTA_VALUE_MODE``
>        - 0x08
>        - If is set, the segment feature data mode is delta-value.
>          If cleared, it's absolute-value.
>
> -.. c:type:: v4l2_vp8_loopfilter_header
> +.. c:type:: v4l2_vp8_loopfilter
>
>  .. cssclass:: longtable
>
>  .. tabularcolumns:: |p{1.5cm}|p{6.3cm}|p{9.4cm}|
>
> -.. flat-table:: struct v4l2_vp8_loopfilter_header
> +.. flat-table:: struct v4l2_vp8_loopfilter
>      :header-rows:  0
>      :stub-columns: 0
>      :widths:       1 1 2
> @@ -1986,11 +1986,11 @@ enum v4l2_mpeg_video_h264_hierarchical_coding_type -
>        - Applications and drivers must set this to zero.
>      * - __u32
>        - ``flags``
> -      - See :ref:`Loopfilter Header Flags <vp8_loopfilter_header_flags>`
> +      - See :ref:`Loopfilter Flags <vp8_loopfilter_flags>`
>
> -.. _vp8_loopfilter_header_flags:
> +.. _vp8_loopfilter_flags:
>
> -``Loopfilter Header Flags``
> +``Loopfilter Flags``
>
>  .. cssclass:: longtable
>
> @@ -1999,10 +1999,10 @@ enum v4l2_mpeg_video_h264_hierarchical_coding_type -
>      :stub-columns: 0
>      :widths:       1 1 2
>
> -    * - ``V4L2_VP8_LF_HEADER_ADJ_ENABLE``
> +    * - ``V4L2_VP8_LF_ADJ_ENABLE``
>        - 0x01
>        - Enable/disable macroblock-level loop filter adjustment.
> -    * - ``V4L2_VP8_LF_HEADER_DELTA_UPDATE``
> +    * - ``V4L2_VP8_LF_DELTA_UPDATE``
>        - 0x02
>        - Indicates if the delta values used in an adjustment are updated.
>      * - ``V4L2_VP8_LF_FILTER_TYPE_SIMPLE``
> @@ -2010,13 +2010,13 @@ enum v4l2_mpeg_video_h264_hierarchical_coding_type -
>        - If set, indicates the filter type is simple.
>          If cleared, the filter type is normal.
>
> -.. c:type:: v4l2_vp8_quantization_header
> +.. c:type:: v4l2_vp8_quantization
>
>  .. cssclass:: longtable
>
>  .. tabularcolumns:: |p{1.5cm}|p{6.3cm}|p{9.4cm}|
>
> -.. flat-table:: struct v4l2_vp8_quantization_header
> +.. flat-table:: struct v4l2_vp8_quantization
>      :header-rows:  0
>      :stub-columns: 0
>      :widths:       1 1 2
> @@ -2043,13 +2043,13 @@ enum v4l2_mpeg_video_h264_hierarchical_coding_type -
>        - ``padding``
>        - Applications and drivers must set this to zero.
>
> -.. c:type:: v4l2_vp8_entropy_header
> +.. c:type:: v4l2_vp8_entropy
>
>  .. cssclass:: longtable
>
>  .. tabularcolumns:: |p{1.5cm}|p{6.3cm}|p{9.4cm}|
>
> -.. flat-table:: struct v4l2_vp8_entropy_header
> +.. flat-table:: struct v4l2_vp8_entropy
>      :header-rows:  0
>      :stub-columns: 0
>      :widths:       1 1 2
> diff --git a/Documentation/userspace-api/media/v4l/pixfmt-compressed.rst b/Documentation/userspace-api/media/v4l/pixfmt-compressed.rst
> index acad5f3ca0c1..2e07e48053d6 100644
> --- a/Documentation/userspace-api/media/v4l/pixfmt-compressed.rst
> +++ b/Documentation/userspace-api/media/v4l/pixfmt-compressed.rst
> @@ -151,7 +151,7 @@ Compressed Formats
>         This format is adapted for stateless video decoders that implement a
>         VP8 pipeline (using the :ref:`mem2mem` and :ref:`media-request-api`).
>         Metadata associated with the frame to decode is required to be passed
> -       through the ``V4L2_CID_MPEG_VIDEO_VP8_FRAME_HEADER`` control.
> +       through the ``V4L2_CID_MPEG_VIDEO_VP8_FRAME`` control.
>         See the :ref:`associated Codec Control IDs <v4l2-mpeg-vp8>`.
>         Exactly one output and one capture buffer must be provided for use with
>         this pixel format. The output buffer must contain the appropriate number
> diff --git a/drivers/media/v4l2-core/v4l2-ctrls.c b/drivers/media/v4l2-core/v4l2-ctrls.c
> index 016cf6204cbb..1a683f4fa978 100644
> --- a/drivers/media/v4l2-core/v4l2-ctrls.c
> +++ b/drivers/media/v4l2-core/v4l2-ctrls.c
> @@ -971,7 +971,7 @@ const char *v4l2_ctrl_get_name(u32 id)
>         case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:                   return "VP8 Profile";
>         case V4L2_CID_MPEG_VIDEO_VP9_PROFILE:                   return "VP9 Profile";
>         case V4L2_CID_MPEG_VIDEO_VP9_LEVEL:                     return "VP9 Level";
> -       case V4L2_CID_MPEG_VIDEO_VP8_FRAME_HEADER:              return "VP8 Frame Header";
> +       case V4L2_CID_MPEG_VIDEO_VP8_FRAME:                     return "VP8 Frame Parameters";
>
>         /* HEVC controls */
>         case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP:               return "HEVC I-Frame QP Value";
> @@ -1470,8 +1470,8 @@ void v4l2_ctrl_fill(u32 id, const char **name, enum v4l2_ctrl_type *type,
>         case V4L2_CID_STATELESS_H264_PRED_WEIGHTS:
>                 *type = V4L2_CTRL_TYPE_H264_PRED_WEIGHTS;
>                 break;
> -       case V4L2_CID_MPEG_VIDEO_VP8_FRAME_HEADER:
> -               *type = V4L2_CTRL_TYPE_VP8_FRAME_HEADER;
> +       case V4L2_CID_MPEG_VIDEO_VP8_FRAME:
> +               *type = V4L2_CTRL_TYPE_VP8_FRAME;
>                 break;
>         case V4L2_CID_MPEG_VIDEO_HEVC_SPS:
>                 *type = V4L2_CTRL_TYPE_HEVC_SPS;
> @@ -1642,7 +1642,7 @@ static void std_init_compound(const struct v4l2_ctrl *ctrl, u32 idx,
>                               union v4l2_ctrl_ptr ptr)
>  {
>         struct v4l2_ctrl_mpeg2_slice_params *p_mpeg2_slice_params;
> -       struct v4l2_ctrl_vp8_frame_header *p_vp8_frame_header;
> +       struct v4l2_ctrl_vp8_frame *p_vp8_frame;
>         struct v4l2_ctrl_fwht_params *p_fwht_params;
>         void *p = ptr.p + idx * ctrl->elem_size;
>
> @@ -1666,9 +1666,9 @@ static void std_init_compound(const struct v4l2_ctrl *ctrl, u32 idx,
>                 p_mpeg2_slice_params->picture.picture_coding_type =
>                                         V4L2_MPEG2_PICTURE_CODING_TYPE_I;
>                 break;
> -       case V4L2_CTRL_TYPE_VP8_FRAME_HEADER:
> -               p_vp8_frame_header = p;
> -               p_vp8_frame_header->num_dct_parts = 1;
> +       case V4L2_CTRL_TYPE_VP8_FRAME:
> +               p_vp8_frame = p;
> +               p_vp8_frame->num_dct_parts = 1;
>                 break;
>         case V4L2_CTRL_TYPE_FWHT_PARAMS:
>                 p_fwht_params = p;
> @@ -1823,7 +1823,7 @@ static int std_validate_compound(const struct v4l2_ctrl *ctrl, u32 idx,
>                                  union v4l2_ctrl_ptr ptr)
>  {
>         struct v4l2_ctrl_mpeg2_slice_params *p_mpeg2_slice_params;
> -       struct v4l2_ctrl_vp8_frame_header *p_vp8_frame_header;
> +       struct v4l2_ctrl_vp8_frame *p_vp8_frame;
>         struct v4l2_ctrl_fwht_params *p_fwht_params;
>         struct v4l2_ctrl_h264_sps *p_h264_sps;
>         struct v4l2_ctrl_h264_pps *p_h264_pps;
> @@ -2046,10 +2046,10 @@ static int std_validate_compound(const struct v4l2_ctrl *ctrl, u32 idx,
>                 zero_reserved(*p_h264_dec_params);
>                 break;
>
> -       case V4L2_CTRL_TYPE_VP8_FRAME_HEADER:
> -               p_vp8_frame_header = p;
> +       case V4L2_CTRL_TYPE_VP8_FRAME:
> +               p_vp8_frame = p;
>
> -               switch (p_vp8_frame_header->num_dct_parts) {
> +               switch (p_vp8_frame->num_dct_parts) {
>                 case 1:
>                 case 2:
>                 case 4:
> @@ -2058,11 +2058,11 @@ static int std_validate_compound(const struct v4l2_ctrl *ctrl, u32 idx,
>                 default:
>                         return -EINVAL;
>                 }
> -               zero_padding(p_vp8_frame_header->segment_header);
> -               zero_padding(p_vp8_frame_header->lf_header);
> -               zero_padding(p_vp8_frame_header->quant_header);
> -               zero_padding(p_vp8_frame_header->entropy_header);
> -               zero_padding(p_vp8_frame_header->coder_state);
> +               zero_padding(p_vp8_frame->seg);
> +               zero_padding(p_vp8_frame->lf);
> +               zero_padding(p_vp8_frame->quant);
> +               zero_padding(p_vp8_frame->entropy);
> +               zero_padding(p_vp8_frame->coder_state);
>                 break;
>
>         case V4L2_CTRL_TYPE_HEVC_SPS:
> @@ -2809,8 +2809,8 @@ static struct v4l2_ctrl *v4l2_ctrl_new(struct v4l2_ctrl_handler *hdl,
>         case V4L2_CTRL_TYPE_H264_PRED_WEIGHTS:
>                 elem_size = sizeof(struct v4l2_ctrl_h264_pred_weights);
>                 break;
> -       case V4L2_CTRL_TYPE_VP8_FRAME_HEADER:
> -               elem_size = sizeof(struct v4l2_ctrl_vp8_frame_header);
> +       case V4L2_CTRL_TYPE_VP8_FRAME:
> +               elem_size = sizeof(struct v4l2_ctrl_vp8_frame);
>                 break;
>         case V4L2_CTRL_TYPE_HEVC_SPS:
>                 elem_size = sizeof(struct v4l2_ctrl_hevc_sps);
> diff --git a/drivers/staging/media/hantro/hantro_drv.c b/drivers/staging/media/hantro/hantro_drv.c
> index e5f200e64993..f1e7f0732e27 100644
> --- a/drivers/staging/media/hantro/hantro_drv.c
> +++ b/drivers/staging/media/hantro/hantro_drv.c
> @@ -299,7 +299,7 @@ static const struct hantro_ctrl controls[] = {
>         }, {
>                 .codec = HANTRO_VP8_DECODER,
>                 .cfg = {
> -                       .id = V4L2_CID_MPEG_VIDEO_VP8_FRAME_HEADER,
> +                       .id = V4L2_CID_MPEG_VIDEO_VP8_FRAME,
>                 },
>         }, {
>                 .codec = HANTRO_H264_DECODER,
> diff --git a/drivers/staging/media/hantro/hantro_g1_vp8_dec.c b/drivers/staging/media/hantro/hantro_g1_vp8_dec.c
> index a5cdf150cd16..3f4311c1dab8 100644
> --- a/drivers/staging/media/hantro/hantro_g1_vp8_dec.c
> +++ b/drivers/staging/media/hantro/hantro_g1_vp8_dec.c
> @@ -133,17 +133,17 @@ static const struct hantro_reg vp8_dec_pred_bc_tap[8][4] = {
>   * Set loop filters
>   */
>  static void cfg_lf(struct hantro_ctx *ctx,
> -                  const struct v4l2_ctrl_vp8_frame_header *hdr)
> +                  const struct v4l2_ctrl_vp8_frame *hdr)
>  {
> -       const struct v4l2_vp8_segment_header *seg = &hdr->segment_header;
> -       const struct v4l2_vp8_loopfilter_header *lf = &hdr->lf_header;
> +       const struct v4l2_vp8_segment *seg = &hdr->seg;
> +       const struct v4l2_vp8_loopfilter *lf = &hdr->lf;
>         struct hantro_dev *vpu = ctx->dev;
>         unsigned int i;
>         u32 reg;
>
> -       if (!(seg->flags & V4L2_VP8_SEGMENT_HEADER_FLAG_ENABLED)) {
> +       if (!(seg->flags & V4L2_VP8_SEGMENT_FLAG_ENABLED)) {
>                 hantro_reg_write(vpu, &vp8_dec_lf_level[0], lf->level);
> -       } else if (seg->flags & V4L2_VP8_SEGMENT_HEADER_FLAG_DELTA_VALUE_MODE) {
> +       } else if (seg->flags & V4L2_VP8_SEGMENT_FLAG_DELTA_VALUE_MODE) {
>                 for (i = 0; i < 4; i++) {
>                         u32 lf_level = clamp(lf->level + seg->lf_update[i],
>                                              0, 63);
> @@ -161,7 +161,7 @@ static void cfg_lf(struct hantro_ctx *ctx,
>                 reg |= G1_REG_REF_PIC_FILT_TYPE_E;
>         vdpu_write_relaxed(vpu, reg, G1_REG_REF_PIC(0));
>
> -       if (lf->flags & V4L2_VP8_LF_HEADER_ADJ_ENABLE) {
> +       if (lf->flags & V4L2_VP8_LF_ADJ_ENABLE) {
>                 for (i = 0; i < 4; i++) {
>                         hantro_reg_write(vpu, &vp8_dec_mb_adj[i],
>                                          lf->mb_mode_delta[i]);
> @@ -175,16 +175,16 @@ static void cfg_lf(struct hantro_ctx *ctx,
>   * Set quantization parameters
>   */
>  static void cfg_qp(struct hantro_ctx *ctx,
> -                  const struct v4l2_ctrl_vp8_frame_header *hdr)
> +                  const struct v4l2_ctrl_vp8_frame *hdr)
>  {
> -       const struct v4l2_vp8_quantization_header *q = &hdr->quant_header;
> -       const struct v4l2_vp8_segment_header *seg = &hdr->segment_header;
> +       const struct v4l2_vp8_quantization *q = &hdr->quant;
> +       const struct v4l2_vp8_segment *seg = &hdr->seg;
>         struct hantro_dev *vpu = ctx->dev;
>         unsigned int i;
>
> -       if (!(seg->flags & V4L2_VP8_SEGMENT_HEADER_FLAG_ENABLED)) {
> +       if (!(seg->flags & V4L2_VP8_SEGMENT_FLAG_ENABLED)) {
>                 hantro_reg_write(vpu, &vp8_dec_quant[0], q->y_ac_qi);
> -       } else if (seg->flags & V4L2_VP8_SEGMENT_HEADER_FLAG_DELTA_VALUE_MODE) {
> +       } else if (seg->flags & V4L2_VP8_SEGMENT_FLAG_DELTA_VALUE_MODE) {
>                 for (i = 0; i < 4; i++) {
>                         u32 quant = clamp(q->y_ac_qi + seg->quant_update[i],
>                                           0, 127);
> @@ -230,7 +230,7 @@ static void cfg_qp(struct hantro_ctx *ctx,
>   *   4. the addresses set to the VPU must be 64-bits aligned
>   */
>  static void cfg_parts(struct hantro_ctx *ctx,
> -                     const struct v4l2_ctrl_vp8_frame_header *hdr)
> +                     const struct v4l2_ctrl_vp8_frame *hdr)
>  {
>         struct hantro_dev *vpu = ctx->dev;
>         struct vb2_v4l2_buffer *vb2_src;
> @@ -328,7 +328,7 @@ static void cfg_parts(struct hantro_ctx *ctx,
>   * normal 6-tap filters
>   */
>  static void cfg_tap(struct hantro_ctx *ctx,
> -                   const struct v4l2_ctrl_vp8_frame_header *hdr)
> +                   const struct v4l2_ctrl_vp8_frame *hdr)
>  {
>         struct hantro_dev *vpu = ctx->dev;
>         struct hantro_reg reg;
> @@ -368,7 +368,7 @@ static void cfg_tap(struct hantro_ctx *ctx,
>  }
>
>  static void cfg_ref(struct hantro_ctx *ctx,
> -                   const struct v4l2_ctrl_vp8_frame_header *hdr)
> +                   const struct v4l2_ctrl_vp8_frame *hdr)
>  {
>         struct hantro_dev *vpu = ctx->dev;
>         struct vb2_v4l2_buffer *vb2_dst;
> @@ -385,7 +385,7 @@ static void cfg_ref(struct hantro_ctx *ctx,
>         WARN_ON(!ref && hdr->golden_frame_ts);
>         if (!ref)
>                 ref = vb2_dma_contig_plane_dma_addr(&vb2_dst->vb2_buf, 0);
> -       if (hdr->flags & V4L2_VP8_FRAME_HEADER_FLAG_SIGN_BIAS_GOLDEN)
> +       if (hdr->flags & V4L2_VP8_FRAME_FLAG_SIGN_BIAS_GOLDEN)
>                 ref |= G1_REG_ADDR_REF_TOPC_E;
>         vdpu_write_relaxed(vpu, ref, G1_REG_ADDR_REF(4));
>
> @@ -393,15 +393,15 @@ static void cfg_ref(struct hantro_ctx *ctx,
>         WARN_ON(!ref && hdr->alt_frame_ts);
>         if (!ref)
>                 ref = vb2_dma_contig_plane_dma_addr(&vb2_dst->vb2_buf, 0);
> -       if (hdr->flags & V4L2_VP8_FRAME_HEADER_FLAG_SIGN_BIAS_ALT)
> +       if (hdr->flags & V4L2_VP8_FRAME_FLAG_SIGN_BIAS_ALT)
>                 ref |= G1_REG_ADDR_REF_TOPC_E;
>         vdpu_write_relaxed(vpu, ref, G1_REG_ADDR_REF(5));
>  }
>
>  static void cfg_buffers(struct hantro_ctx *ctx,
> -                       const struct v4l2_ctrl_vp8_frame_header *hdr)
> +                       const struct v4l2_ctrl_vp8_frame *hdr)
>  {
> -       const struct v4l2_vp8_segment_header *seg = &hdr->segment_header;
> +       const struct v4l2_vp8_segment *seg = &hdr->seg;
>         struct hantro_dev *vpu = ctx->dev;
>         struct vb2_v4l2_buffer *vb2_dst;
>         dma_addr_t dst_dma;
> @@ -415,9 +415,9 @@ static void cfg_buffers(struct hantro_ctx *ctx,
>
>         /* Set segment map address */
>         reg = G1_REG_FWD_PIC1_SEGMENT_BASE(ctx->vp8_dec.segment_map.dma);
> -       if (seg->flags & V4L2_VP8_SEGMENT_HEADER_FLAG_ENABLED) {
> +       if (seg->flags & V4L2_VP8_SEGMENT_FLAG_ENABLED) {
>                 reg |= G1_REG_FWD_PIC1_SEGMENT_E;
> -               if (seg->flags & V4L2_VP8_SEGMENT_HEADER_FLAG_UPDATE_MAP)
> +               if (seg->flags & V4L2_VP8_SEGMENT_FLAG_UPDATE_MAP)
>                         reg |= G1_REG_FWD_PIC1_SEGMENT_UPD_E;
>         }
>         vdpu_write_relaxed(vpu, reg, G1_REG_FWD_PIC(0));
> @@ -428,7 +428,7 @@ static void cfg_buffers(struct hantro_ctx *ctx,
>
>  void hantro_g1_vp8_dec_run(struct hantro_ctx *ctx)
>  {
> -       const struct v4l2_ctrl_vp8_frame_header *hdr;
> +       const struct v4l2_ctrl_vp8_frame *hdr;
>         struct hantro_dev *vpu = ctx->dev;
>         size_t height = ctx->dst_fmt.height;
>         size_t width = ctx->dst_fmt.width;
> @@ -437,7 +437,7 @@ void hantro_g1_vp8_dec_run(struct hantro_ctx *ctx)
>
>         hantro_start_prepare_run(ctx);
>
> -       hdr = hantro_get_ctrl(ctx, V4L2_CID_MPEG_VIDEO_VP8_FRAME_HEADER);
> +       hdr = hantro_get_ctrl(ctx, V4L2_CID_MPEG_VIDEO_VP8_FRAME);
>         if (WARN_ON(!hdr))
>                 return;
>
> @@ -462,9 +462,9 @@ void hantro_g1_vp8_dec_run(struct hantro_ctx *ctx)
>         reg = G1_REG_DEC_CTRL0_DEC_MODE(10);
>         if (!VP8_FRAME_IS_KEY_FRAME(hdr))
>                 reg |= G1_REG_DEC_CTRL0_PIC_INTER_E;
> -       if (!(hdr->flags & V4L2_VP8_FRAME_HEADER_FLAG_MB_NO_SKIP_COEFF))
> +       if (!(hdr->flags & V4L2_VP8_FRAME_FLAG_MB_NO_SKIP_COEFF))
>                 reg |= G1_REG_DEC_CTRL0_SKIP_MODE;
> -       if (hdr->lf_header.level == 0)
> +       if (hdr->lf.level == 0)
>                 reg |= G1_REG_DEC_CTRL0_FILTERING_DIS;
>         vdpu_write_relaxed(vpu, reg, G1_REG_DEC_CTRL0);
>
> diff --git a/drivers/staging/media/hantro/hantro_hw.h b/drivers/staging/media/hantro/hantro_hw.h
> index 34c9e4649a25..ada482e514b8 100644
> --- a/drivers/staging/media/hantro/hantro_hw.h
> +++ b/drivers/staging/media/hantro/hantro_hw.h
> @@ -216,6 +216,6 @@ void rk3399_vpu_vp8_dec_run(struct hantro_ctx *ctx);
>  int hantro_vp8_dec_init(struct hantro_ctx *ctx);
>  void hantro_vp8_dec_exit(struct hantro_ctx *ctx);
>  void hantro_vp8_prob_update(struct hantro_ctx *ctx,
> -                           const struct v4l2_ctrl_vp8_frame_header *hdr);
> +                           const struct v4l2_ctrl_vp8_frame *hdr);
>
>  #endif /* HANTRO_HW_H_ */
> diff --git a/drivers/staging/media/hantro/hantro_vp8.c b/drivers/staging/media/hantro/hantro_vp8.c
> index 91ec9a05645b..f5bd32b6be95 100644
> --- a/drivers/staging/media/hantro/hantro_vp8.c
> +++ b/drivers/staging/media/hantro/hantro_vp8.c
> @@ -47,9 +47,9 @@ const u32 hantro_vp8_dec_mc_filter[8][6] = {
>  };
>
>  void hantro_vp8_prob_update(struct hantro_ctx *ctx,
> -                           const struct v4l2_ctrl_vp8_frame_header *hdr)
> +                           const struct v4l2_ctrl_vp8_frame *hdr)
>  {
> -       const struct v4l2_vp8_entropy_header *entropy = &hdr->entropy_header;
> +       const struct v4l2_vp8_entropy *entropy = &hdr->entropy;
>         u32 i, j, k;
>         u8 *dst;
>
> @@ -60,9 +60,9 @@ void hantro_vp8_prob_update(struct hantro_ctx *ctx,
>         dst[1] = hdr->prob_intra;
>         dst[2] = hdr->prob_last;
>         dst[3] = hdr->prob_gf;
> -       dst[4] = hdr->segment_header.segment_probs[0];
> -       dst[5] = hdr->segment_header.segment_probs[1];
> -       dst[6] = hdr->segment_header.segment_probs[2];
> +       dst[4] = hdr->seg.segment_probs[0];
> +       dst[5] = hdr->seg.segment_probs[1];
> +       dst[6] = hdr->seg.segment_probs[2];
>         dst[7] = 0;
>
>         dst += 8;
> diff --git a/drivers/staging/media/hantro/rk3399_vpu_hw_vp8_dec.c b/drivers/staging/media/hantro/rk3399_vpu_hw_vp8_dec.c
> index a4a792f00b11..5c43f59ad531 100644
> --- a/drivers/staging/media/hantro/rk3399_vpu_hw_vp8_dec.c
> +++ b/drivers/staging/media/hantro/rk3399_vpu_hw_vp8_dec.c
> @@ -274,17 +274,17 @@ static const struct hantro_reg vp8_dec_start_dec = {
>  };
>
>  static void cfg_lf(struct hantro_ctx *ctx,
> -                  const struct v4l2_ctrl_vp8_frame_header *hdr)
> +                  const struct v4l2_ctrl_vp8_frame *hdr)
>  {
> -       const struct v4l2_vp8_segment_header *seg = &hdr->segment_header;
> -       const struct v4l2_vp8_loopfilter_header *lf = &hdr->lf_header;
> +       const struct v4l2_vp8_segment *seg = &hdr->seg;
> +       const struct v4l2_vp8_loopfilter *lf = &hdr->lf;
>         struct hantro_dev *vpu = ctx->dev;
>         unsigned int i;
>         u32 reg;
>
> -       if (!(seg->flags & V4L2_VP8_SEGMENT_HEADER_FLAG_ENABLED)) {
> +       if (!(seg->flags & V4L2_VP8_SEGMENT_FLAG_ENABLED)) {
>                 hantro_reg_write(vpu, &vp8_dec_lf_level[0], lf->level);
> -       } else if (seg->flags & V4L2_VP8_SEGMENT_HEADER_FLAG_DELTA_VALUE_MODE) {
> +       } else if (seg->flags & V4L2_VP8_SEGMENT_FLAG_DELTA_VALUE_MODE) {
>                 for (i = 0; i < 4; i++) {
>                         u32 lf_level = clamp(lf->level + seg->lf_update[i],
>                                              0, 63);
> @@ -302,7 +302,7 @@ static void cfg_lf(struct hantro_ctx *ctx,
>                 reg |= VDPU_REG_REF_PIC_FILT_TYPE_E;
>         vdpu_write_relaxed(vpu, reg, VDPU_REG_FILTER_MB_ADJ);
>
> -       if (lf->flags & V4L2_VP8_LF_HEADER_ADJ_ENABLE) {
> +       if (lf->flags & V4L2_VP8_LF_ADJ_ENABLE) {
>                 for (i = 0; i < 4; i++) {
>                         hantro_reg_write(vpu, &vp8_dec_mb_adj[i],
>                                          lf->mb_mode_delta[i]);
> @@ -313,16 +313,16 @@ static void cfg_lf(struct hantro_ctx *ctx,
>  }
>
>  static void cfg_qp(struct hantro_ctx *ctx,
> -                  const struct v4l2_ctrl_vp8_frame_header *hdr)
> +                  const struct v4l2_ctrl_vp8_frame *hdr)
>  {
> -       const struct v4l2_vp8_quantization_header *q = &hdr->quant_header;
> -       const struct v4l2_vp8_segment_header *seg = &hdr->segment_header;
> +       const struct v4l2_vp8_quantization *q = &hdr->quant;
> +       const struct v4l2_vp8_segment *seg = &hdr->seg;
>         struct hantro_dev *vpu = ctx->dev;
>         unsigned int i;
>
> -       if (!(seg->flags & V4L2_VP8_SEGMENT_HEADER_FLAG_ENABLED)) {
> +       if (!(seg->flags & V4L2_VP8_SEGMENT_FLAG_ENABLED)) {
>                 hantro_reg_write(vpu, &vp8_dec_quant[0], q->y_ac_qi);
> -       } else if (seg->flags & V4L2_VP8_SEGMENT_HEADER_FLAG_DELTA_VALUE_MODE) {
> +       } else if (seg->flags & V4L2_VP8_SEGMENT_FLAG_DELTA_VALUE_MODE) {
>                 for (i = 0; i < 4; i++) {
>                         u32 quant = clamp(q->y_ac_qi + seg->quant_update[i],
>                                           0, 127);
> @@ -343,7 +343,7 @@ static void cfg_qp(struct hantro_ctx *ctx,
>  }
>
>  static void cfg_parts(struct hantro_ctx *ctx,
> -                     const struct v4l2_ctrl_vp8_frame_header *hdr)
> +                     const struct v4l2_ctrl_vp8_frame *hdr)
>  {
>         struct hantro_dev *vpu = ctx->dev;
>         struct vb2_v4l2_buffer *vb2_src;
> @@ -426,7 +426,7 @@ static void cfg_parts(struct hantro_ctx *ctx,
>   * normal 6-tap filters
>   */
>  static void cfg_tap(struct hantro_ctx *ctx,
> -                   const struct v4l2_ctrl_vp8_frame_header *hdr)
> +                   const struct v4l2_ctrl_vp8_frame *hdr)
>  {
>         struct hantro_dev *vpu = ctx->dev;
>         int i, j;
> @@ -445,7 +445,7 @@ static void cfg_tap(struct hantro_ctx *ctx,
>  }
>
>  static void cfg_ref(struct hantro_ctx *ctx,
> -                   const struct v4l2_ctrl_vp8_frame_header *hdr)
> +                   const struct v4l2_ctrl_vp8_frame *hdr)
>  {
>         struct hantro_dev *vpu = ctx->dev;
>         struct vb2_v4l2_buffer *vb2_dst;
> @@ -462,7 +462,7 @@ static void cfg_ref(struct hantro_ctx *ctx,
>         WARN_ON(!ref && hdr->golden_frame_ts);
>         if (!ref)
>                 ref = vb2_dma_contig_plane_dma_addr(&vb2_dst->vb2_buf, 0);
> -       if (hdr->flags & V4L2_VP8_FRAME_HEADER_FLAG_SIGN_BIAS_GOLDEN)
> +       if (hdr->flags & V4L2_VP8_FRAME_FLAG_SIGN_BIAS_GOLDEN)
>                 ref |= VDPU_REG_VP8_GREF_SIGN_BIAS;
>         vdpu_write_relaxed(vpu, ref, VDPU_REG_VP8_ADDR_REF2_5(2));
>
> @@ -470,15 +470,15 @@ static void cfg_ref(struct hantro_ctx *ctx,
>         WARN_ON(!ref && hdr->alt_frame_ts);
>         if (!ref)
>                 ref = vb2_dma_contig_plane_dma_addr(&vb2_dst->vb2_buf, 0);
> -       if (hdr->flags & V4L2_VP8_FRAME_HEADER_FLAG_SIGN_BIAS_ALT)
> +       if (hdr->flags & V4L2_VP8_FRAME_FLAG_SIGN_BIAS_ALT)
>                 ref |= VDPU_REG_VP8_AREF_SIGN_BIAS;
>         vdpu_write_relaxed(vpu, ref, VDPU_REG_VP8_ADDR_REF2_5(3));
>  }
>
>  static void cfg_buffers(struct hantro_ctx *ctx,
> -                       const struct v4l2_ctrl_vp8_frame_header *hdr)
> +                       const struct v4l2_ctrl_vp8_frame *hdr)
>  {
> -       const struct v4l2_vp8_segment_header *seg = &hdr->segment_header;
> +       const struct v4l2_vp8_segment *seg = &hdr->seg;
>         struct hantro_dev *vpu = ctx->dev;
>         struct vb2_v4l2_buffer *vb2_dst;
>         dma_addr_t dst_dma;
> @@ -492,9 +492,9 @@ static void cfg_buffers(struct hantro_ctx *ctx,
>
>         /* Set segment map address */
>         reg = VDPU_REG_FWD_PIC1_SEGMENT_BASE(ctx->vp8_dec.segment_map.dma);
> -       if (seg->flags & V4L2_VP8_SEGMENT_HEADER_FLAG_ENABLED) {
> +       if (seg->flags & V4L2_VP8_SEGMENT_FLAG_ENABLED) {
>                 reg |= VDPU_REG_FWD_PIC1_SEGMENT_E;
> -               if (seg->flags & V4L2_VP8_SEGMENT_HEADER_FLAG_UPDATE_MAP)
> +               if (seg->flags & V4L2_VP8_SEGMENT_FLAG_UPDATE_MAP)
>                         reg |= VDPU_REG_FWD_PIC1_SEGMENT_UPD_E;
>         }
>         vdpu_write_relaxed(vpu, reg, VDPU_REG_VP8_SEGMENT_VAL);
> @@ -506,7 +506,7 @@ static void cfg_buffers(struct hantro_ctx *ctx,
>
>  void rk3399_vpu_vp8_dec_run(struct hantro_ctx *ctx)
>  {
> -       const struct v4l2_ctrl_vp8_frame_header *hdr;
> +       const struct v4l2_ctrl_vp8_frame *hdr;
>         struct hantro_dev *vpu = ctx->dev;
>         size_t height = ctx->dst_fmt.height;
>         size_t width = ctx->dst_fmt.width;
> @@ -515,7 +515,7 @@ void rk3399_vpu_vp8_dec_run(struct hantro_ctx *ctx)
>
>         hantro_start_prepare_run(ctx);
>
> -       hdr = hantro_get_ctrl(ctx, V4L2_CID_MPEG_VIDEO_VP8_FRAME_HEADER);
> +       hdr = hantro_get_ctrl(ctx, V4L2_CID_MPEG_VIDEO_VP8_FRAME);
>         if (WARN_ON(!hdr))
>                 return;
>
> @@ -555,9 +555,9 @@ void rk3399_vpu_vp8_dec_run(struct hantro_ctx *ctx)
>         reg = VDPU_REG_DEC_CTRL0_DEC_MODE(10);
>         vdpu_write_relaxed(vpu, reg, VDPU_REG_DEC_FORMAT);
>
> -       if (!(hdr->flags & V4L2_VP8_FRAME_HEADER_FLAG_MB_NO_SKIP_COEFF))
> +       if (!(hdr->flags & V4L2_VP8_FRAME_FLAG_MB_NO_SKIP_COEFF))
>                 hantro_reg_write(vpu, &vp8_dec_skip_mode, 1);
> -       if (hdr->lf_header.level == 0)
> +       if (hdr->lf.level == 0)
>                 hantro_reg_write(vpu, &vp8_dec_filter_disable, 1);
>
>         /* Frame dimensions */
> diff --git a/drivers/staging/media/sunxi/cedrus/cedrus.c b/drivers/staging/media/sunxi/cedrus/cedrus.c
> index 7bd9291c8d5f..e233feb49c9c 100644
> --- a/drivers/staging/media/sunxi/cedrus/cedrus.c
> +++ b/drivers/staging/media/sunxi/cedrus/cedrus.c
> @@ -147,7 +147,7 @@ static const struct cedrus_control cedrus_controls[] = {
>         },
>         {
>                 .cfg = {
> -                       .id             = V4L2_CID_MPEG_VIDEO_VP8_FRAME_HEADER,
> +                       .id     = V4L2_CID_MPEG_VIDEO_VP8_FRAME,
>                 },
>                 .codec          = CEDRUS_CODEC_VP8,
>         },
> diff --git a/drivers/staging/media/sunxi/cedrus/cedrus.h b/drivers/staging/media/sunxi/cedrus/cedrus.h
> index 251a6a660351..15f147dad4cb 100644
> --- a/drivers/staging/media/sunxi/cedrus/cedrus.h
> +++ b/drivers/staging/media/sunxi/cedrus/cedrus.h
> @@ -79,7 +79,7 @@ struct cedrus_h265_run {
>  };
>
>  struct cedrus_vp8_run {
> -       const struct v4l2_ctrl_vp8_frame_header         *frame_params;
> +       const struct v4l2_ctrl_vp8_frame                *frame_params;
>  };
>
>  struct cedrus_run {
> diff --git a/drivers/staging/media/sunxi/cedrus/cedrus_dec.c b/drivers/staging/media/sunxi/cedrus/cedrus_dec.c
> index a9090daf626a..b0a0559cd0eb 100644
> --- a/drivers/staging/media/sunxi/cedrus/cedrus_dec.c
> +++ b/drivers/staging/media/sunxi/cedrus/cedrus_dec.c
> @@ -72,7 +72,7 @@ void cedrus_device_run(void *priv)
>
>         case V4L2_PIX_FMT_VP8_FRAME:
>                 run.vp8.frame_params = cedrus_find_control_data(ctx,
> -                       V4L2_CID_MPEG_VIDEO_VP8_FRAME_HEADER);
> +                       V4L2_CID_MPEG_VIDEO_VP8_FRAME);
>                 break;
>
>         default:
> diff --git a/drivers/staging/media/sunxi/cedrus/cedrus_vp8.c b/drivers/staging/media/sunxi/cedrus/cedrus_vp8.c
> index ff613ebd1180..cab0770515c5 100644
> --- a/drivers/staging/media/sunxi/cedrus/cedrus_vp8.c
> +++ b/drivers/staging/media/sunxi/cedrus/cedrus_vp8.c
> @@ -522,7 +522,7 @@ static void cedrus_irq_clear(struct cedrus_dev *dev)
>  }
>
>  static void cedrus_read_header(struct cedrus_dev *dev,
> -                              const struct v4l2_ctrl_vp8_frame_header *slice)
> +                              const struct v4l2_ctrl_vp8_frame *slice)
>  {
>         int i, j;
>
> @@ -590,34 +590,34 @@ static void cedrus_read_header(struct cedrus_dev *dev,
>         }
>  }
>
> -static void cedrus_vp8_update_probs(const struct v4l2_ctrl_vp8_frame_header *slice,
> +static void cedrus_vp8_update_probs(const struct v4l2_ctrl_vp8_frame *slice,
>                                     u8 *prob_table)
>  {
>         int i, j, k;
>
> -       memcpy(&prob_table[0x1008], slice->entropy_header.y_mode_probs,
> -              sizeof(slice->entropy_header.y_mode_probs));
> -       memcpy(&prob_table[0x1010], slice->entropy_header.uv_mode_probs,
> -              sizeof(slice->entropy_header.uv_mode_probs));
> +       memcpy(&prob_table[0x1008], slice->entropy.y_mode_probs,
> +              sizeof(slice->entropy.y_mode_probs));
> +       memcpy(&prob_table[0x1010], slice->entropy.uv_mode_probs,
> +              sizeof(slice->entropy.uv_mode_probs));
>
> -       memcpy(&prob_table[0x1018], slice->segment_header.segment_probs,
> -              sizeof(slice->segment_header.segment_probs));
> +       memcpy(&prob_table[0x1018], slice->seg.segment_probs,
> +              sizeof(slice->seg.segment_probs));
>
>         prob_table[0x101c] = slice->prob_skip_false;
>         prob_table[0x101d] = slice->prob_intra;
>         prob_table[0x101e] = slice->prob_last;
>         prob_table[0x101f] = slice->prob_gf;
>
> -       memcpy(&prob_table[0x1020], slice->entropy_header.mv_probs[0],
> +       memcpy(&prob_table[0x1020], slice->entropy.mv_probs[0],
>                V4L2_VP8_MV_PROB_CNT);
> -       memcpy(&prob_table[0x1040], slice->entropy_header.mv_probs[1],
> +       memcpy(&prob_table[0x1040], slice->entropy.mv_probs[1],
>                V4L2_VP8_MV_PROB_CNT);
>
>         for (i = 0; i < 4; ++i)
>                 for (j = 0; j < 8; ++j)
>                         for (k = 0; k < 3; ++k)
>                                 memcpy(&prob_table[i * 512 + j * 64 + k * 16],
> -                                      slice->entropy_header.coeff_probs[i][j][k], 11);
> +                                      slice->entropy.coeff_probs[i][j][k], 11);
>  }
>
>  static enum cedrus_irq_status
> @@ -653,7 +653,7 @@ static void cedrus_vp8_irq_disable(struct cedrus_ctx *ctx)
>  static void cedrus_vp8_setup(struct cedrus_ctx *ctx,
>                              struct cedrus_run *run)
>  {
> -       const struct v4l2_ctrl_vp8_frame_header *slice = run->vp8.frame_params;
> +       const struct v4l2_ctrl_vp8_frame *slice = run->vp8.frame_params;
>         struct vb2_queue *cap_q = &ctx->fh.m2m_ctx->cap_q_ctx.q;
>         struct vb2_buffer *src_buf = &run->src->vb2_buf;
>         struct cedrus_dev *dev = ctx->dev;
> @@ -719,34 +719,34 @@ static void cedrus_vp8_setup(struct cedrus_ctx *ctx,
>                 reg |= VE_VP8_PPS_FULL_PIXEL;
>                 break;
>         }
> -       if (slice->segment_header.flags & V4L2_VP8_SEGMENT_HEADER_FLAG_UPDATE_MAP)
> +       if (slice->seg.flags & V4L2_VP8_SEGMENT_FLAG_UPDATE_MAP)
>                 reg |= VE_VP8_PPS_UPDATE_MB_SEGMENTATION_MAP;
> -       if (!(slice->segment_header.flags & V4L2_VP8_SEGMENT_HEADER_FLAG_DELTA_VALUE_MODE))
> +       if (!(slice->seg.flags & V4L2_VP8_SEGMENT_FLAG_DELTA_VALUE_MODE))
>                 reg |= VE_VP8_PPS_MB_SEGMENT_ABS_DELTA;
> -       if (slice->segment_header.flags & V4L2_VP8_SEGMENT_HEADER_FLAG_ENABLED)
> +       if (slice->seg.flags & V4L2_VP8_SEGMENT_FLAG_ENABLED)
>                 reg |= VE_VP8_PPS_SEGMENTATION_ENABLE;
>         if (ctx->codec.vp8.last_filter_type)
>                 reg |= VE_VP8_PPS_LAST_LOOP_FILTER_SIMPLE;
> -       reg |= VE_VP8_PPS_SHARPNESS_LEVEL(slice->lf_header.sharpness_level);
> -       if (slice->lf_header.flags & V4L2_VP8_LF_FILTER_TYPE_SIMPLE)
> +       reg |= VE_VP8_PPS_SHARPNESS_LEVEL(slice->lf.sharpness_level);
> +       if (slice->lf.flags & V4L2_VP8_LF_FILTER_TYPE_SIMPLE)
>                 reg |= VE_VP8_PPS_LOOP_FILTER_SIMPLE;
> -       reg |= VE_VP8_PPS_LOOP_FILTER_LEVEL(slice->lf_header.level);
> -       if (slice->lf_header.flags & V4L2_VP8_LF_HEADER_ADJ_ENABLE)
> +       reg |= VE_VP8_PPS_LOOP_FILTER_LEVEL(slice->lf.level);
> +       if (slice->lf.flags & V4L2_VP8_LF_ADJ_ENABLE)
>                 reg |= VE_VP8_PPS_MODE_REF_LF_DELTA_ENABLE;
> -       if (slice->lf_header.flags & V4L2_VP8_LF_HEADER_DELTA_UPDATE)
> +       if (slice->lf.flags & V4L2_VP8_LF_DELTA_UPDATE)
>                 reg |= VE_VP8_PPS_MODE_REF_LF_DELTA_UPDATE;
>         reg |= VE_VP8_PPS_TOKEN_PARTITION(ilog2(slice->num_dct_parts));
> -       if (slice->flags & V4L2_VP8_FRAME_HEADER_FLAG_MB_NO_SKIP_COEFF)
> +       if (slice->flags & V4L2_VP8_FRAME_FLAG_MB_NO_SKIP_COEFF)
>                 reg |= VE_VP8_PPS_MB_NO_COEFF_SKIP;
>         reg |= VE_VP8_PPS_RELOAD_ENTROPY_PROBS;
> -       if (slice->flags & V4L2_VP8_FRAME_HEADER_FLAG_SIGN_BIAS_GOLDEN)
> +       if (slice->flags & V4L2_VP8_FRAME_FLAG_SIGN_BIAS_GOLDEN)
>                 reg |= VE_VP8_PPS_GOLDEN_SIGN_BIAS;
> -       if (slice->flags & V4L2_VP8_FRAME_HEADER_FLAG_SIGN_BIAS_ALT)
> +       if (slice->flags & V4L2_VP8_FRAME_FLAG_SIGN_BIAS_ALT)
>                 reg |= VE_VP8_PPS_ALTREF_SIGN_BIAS;
>         if (ctx->codec.vp8.last_frame_p_type)
>                 reg |= VE_VP8_PPS_LAST_PIC_TYPE_P_FRAME;
>         reg |= VE_VP8_PPS_LAST_SHARPNESS_LEVEL(ctx->codec.vp8.last_sharpness_level);
> -       if (!(slice->flags & V4L2_VP8_FRAME_HEADER_FLAG_KEY_FRAME))
> +       if (!(slice->flags & V4L2_VP8_FRAME_FLAG_KEY_FRAME))
>                 reg |= VE_VP8_PPS_PIC_TYPE_P_FRAME;
>         cedrus_write(dev, VE_VP8_PPS, reg);
>
> @@ -758,12 +758,12 @@ static void cedrus_vp8_setup(struct cedrus_ctx *ctx,
>         cedrus_write(dev, VE_H264_ERROR_CASE, 0);
>
>         reg = 0;
> -       reg |= VE_VP8_QP_INDEX_DELTA_UVAC(slice->quant_header.uv_ac_delta);
> -       reg |= VE_VP8_QP_INDEX_DELTA_UVDC(slice->quant_header.uv_dc_delta);
> -       reg |= VE_VP8_QP_INDEX_DELTA_Y2AC(slice->quant_header.y2_ac_delta);
> -       reg |= VE_VP8_QP_INDEX_DELTA_Y2DC(slice->quant_header.y2_dc_delta);
> -       reg |= VE_VP8_QP_INDEX_DELTA_Y1DC(slice->quant_header.y_dc_delta);
> -       reg |= VE_VP8_QP_INDEX_DELTA_BASE_QINDEX(slice->quant_header.y_ac_qi);
> +       reg |= VE_VP8_QP_INDEX_DELTA_UVAC(slice->quant.uv_ac_delta);
> +       reg |= VE_VP8_QP_INDEX_DELTA_UVDC(slice->quant.uv_dc_delta);
> +       reg |= VE_VP8_QP_INDEX_DELTA_Y2AC(slice->quant.y2_ac_delta);
> +       reg |= VE_VP8_QP_INDEX_DELTA_Y2DC(slice->quant.y2_dc_delta);
> +       reg |= VE_VP8_QP_INDEX_DELTA_Y1DC(slice->quant.y_dc_delta);
> +       reg |= VE_VP8_QP_INDEX_DELTA_BASE_QINDEX(slice->quant.y_ac_qi);
>         cedrus_write(dev, VE_VP8_QP_INDEX_DELTA, reg);
>
>         reg = 0;
> @@ -777,31 +777,31 @@ static void cedrus_vp8_setup(struct cedrus_ctx *ctx,
>         cedrus_write(dev, VE_VP8_PICSIZE, reg);
>
>         reg = 0;
> -       reg |= VE_VP8_SEGMENT3(slice->segment_header.quant_update[3]);
> -       reg |= VE_VP8_SEGMENT2(slice->segment_header.quant_update[2]);
> -       reg |= VE_VP8_SEGMENT1(slice->segment_header.quant_update[1]);
> -       reg |= VE_VP8_SEGMENT0(slice->segment_header.quant_update[0]);
> +       reg |= VE_VP8_SEGMENT3(slice->seg.quant_update[3]);
> +       reg |= VE_VP8_SEGMENT2(slice->seg.quant_update[2]);
> +       reg |= VE_VP8_SEGMENT1(slice->seg.quant_update[1]);
> +       reg |= VE_VP8_SEGMENT0(slice->seg.quant_update[0]);
>         cedrus_write(dev, VE_VP8_SEGMENT_FEAT_MB_LV0, reg);
>
>         reg = 0;
> -       reg |= VE_VP8_SEGMENT3(slice->segment_header.lf_update[3]);
> -       reg |= VE_VP8_SEGMENT2(slice->segment_header.lf_update[2]);
> -       reg |= VE_VP8_SEGMENT1(slice->segment_header.lf_update[1]);
> -       reg |= VE_VP8_SEGMENT0(slice->segment_header.lf_update[0]);
> +       reg |= VE_VP8_SEGMENT3(slice->seg.lf_update[3]);
> +       reg |= VE_VP8_SEGMENT2(slice->seg.lf_update[2]);
> +       reg |= VE_VP8_SEGMENT1(slice->seg.lf_update[1]);
> +       reg |= VE_VP8_SEGMENT0(slice->seg.lf_update[0]);
>         cedrus_write(dev, VE_VP8_SEGMENT_FEAT_MB_LV1, reg);
>
>         reg = 0;
> -       reg |= VE_VP8_LF_DELTA3(slice->lf_header.ref_frm_delta[3]);
> -       reg |= VE_VP8_LF_DELTA2(slice->lf_header.ref_frm_delta[2]);
> -       reg |= VE_VP8_LF_DELTA1(slice->lf_header.ref_frm_delta[1]);
> -       reg |= VE_VP8_LF_DELTA0(slice->lf_header.ref_frm_delta[0]);
> +       reg |= VE_VP8_LF_DELTA3(slice->lf.ref_frm_delta[3]);
> +       reg |= VE_VP8_LF_DELTA2(slice->lf.ref_frm_delta[2]);
> +       reg |= VE_VP8_LF_DELTA1(slice->lf.ref_frm_delta[1]);
> +       reg |= VE_VP8_LF_DELTA0(slice->lf.ref_frm_delta[0]);
>         cedrus_write(dev, VE_VP8_REF_LF_DELTA, reg);
>
>         reg = 0;
> -       reg |= VE_VP8_LF_DELTA3(slice->lf_header.mb_mode_delta[3]);
> -       reg |= VE_VP8_LF_DELTA2(slice->lf_header.mb_mode_delta[2]);
> -       reg |= VE_VP8_LF_DELTA1(slice->lf_header.mb_mode_delta[1]);
> -       reg |= VE_VP8_LF_DELTA0(slice->lf_header.mb_mode_delta[0]);
> +       reg |= VE_VP8_LF_DELTA3(slice->lf.mb_mode_delta[3]);
> +       reg |= VE_VP8_LF_DELTA2(slice->lf.mb_mode_delta[2]);
> +       reg |= VE_VP8_LF_DELTA1(slice->lf.mb_mode_delta[1]);
> +       reg |= VE_VP8_LF_DELTA0(slice->lf.mb_mode_delta[0]);
>         cedrus_write(dev, VE_VP8_MODE_LF_DELTA, reg);
>
>         luma_addr = cedrus_dst_buf_addr(ctx, run->dst->vb2_buf.index, 0);
> @@ -846,13 +846,13 @@ static void cedrus_vp8_setup(struct cedrus_ctx *ctx,
>                      VE_H264_CTRL_DECODE_ERR_INT |
>                      VE_H264_CTRL_SLICE_DECODE_INT);
>
> -       if (slice->lf_header.level) {
> +       if (slice->lf.level) {
>                 ctx->codec.vp8.last_filter_type =
> -                       !!(slice->lf_header.flags & V4L2_VP8_LF_FILTER_TYPE_SIMPLE);
> +                       !!(slice->lf.flags & V4L2_VP8_LF_FILTER_TYPE_SIMPLE);
>                 ctx->codec.vp8.last_frame_p_type =
>                         !VP8_FRAME_IS_KEY_FRAME(slice);
>                 ctx->codec.vp8.last_sharpness_level =
> -                       slice->lf_header.sharpness_level;
> +                       slice->lf.sharpness_level;
>         }
>  }
>
> diff --git a/include/media/v4l2-ctrls.h b/include/media/v4l2-ctrls.h
> index 167ca8c8424f..aa06ff1695fe 100644
> --- a/include/media/v4l2-ctrls.h
> +++ b/include/media/v4l2-ctrls.h
> @@ -50,7 +50,7 @@ struct video_device;
>   * @p_h264_slice_params:       Pointer to a struct v4l2_ctrl_h264_slice_params.
>   * @p_h264_decode_params:      Pointer to a struct v4l2_ctrl_h264_decode_params.
>   * @p_h264_pred_weights:       Pointer to a struct v4l2_ctrl_h264_pred_weights.
> - * @p_vp8_frame_header:                Pointer to a VP8 frame header structure.
> + * @p_vp8_frame:               Pointer to a VP8 frame params structure.
>   * @p_hevc_sps:                        Pointer to an HEVC sequence parameter set structure.
>   * @p_hevc_pps:                        Pointer to an HEVC picture parameter set structure.
>   * @p_hevc_slice_params:       Pointer to an HEVC slice parameters structure.
> @@ -74,7 +74,7 @@ union v4l2_ctrl_ptr {
>         struct v4l2_ctrl_h264_slice_params *p_h264_slice_params;
>         struct v4l2_ctrl_h264_decode_params *p_h264_decode_params;
>         struct v4l2_ctrl_h264_pred_weights *p_h264_pred_weights;
> -       struct v4l2_ctrl_vp8_frame_header *p_vp8_frame_header;
> +       struct v4l2_ctrl_vp8_frame *p_vp8_frame;
>         struct v4l2_ctrl_hevc_sps *p_hevc_sps;
>         struct v4l2_ctrl_hevc_pps *p_hevc_pps;
>         struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params;
> diff --git a/include/media/vp8-ctrls.h b/include/media/vp8-ctrls.h
> index 3969550df148..86bb6e774604 100644
> --- a/include/media/vp8-ctrls.h
> +++ b/include/media/vp8-ctrls.h
> @@ -15,15 +15,15 @@
>
>  #define V4L2_PIX_FMT_VP8_FRAME v4l2_fourcc('V', 'P', '8', 'F')
>
> -#define V4L2_CID_MPEG_VIDEO_VP8_FRAME_HEADER (V4L2_CID_CODEC_BASE + 2000)
> -#define V4L2_CTRL_TYPE_VP8_FRAME_HEADER 0x301
> +#define V4L2_CID_MPEG_VIDEO_VP8_FRAME (V4L2_CID_CODEC_BASE + 2000)
> +#define V4L2_CTRL_TYPE_VP8_FRAME 0x301
>
> -#define V4L2_VP8_SEGMENT_HEADER_FLAG_ENABLED              0x01
> -#define V4L2_VP8_SEGMENT_HEADER_FLAG_UPDATE_MAP           0x02
> -#define V4L2_VP8_SEGMENT_HEADER_FLAG_UPDATE_FEATURE_DATA  0x04
> -#define V4L2_VP8_SEGMENT_HEADER_FLAG_DELTA_VALUE_MODE     0x08
> +#define V4L2_VP8_SEGMENT_FLAG_ENABLED              0x01
> +#define V4L2_VP8_SEGMENT_FLAG_UPDATE_MAP           0x02
> +#define V4L2_VP8_SEGMENT_FLAG_UPDATE_FEATURE_DATA  0x04
> +#define V4L2_VP8_SEGMENT_FLAG_DELTA_VALUE_MODE     0x08
>
> -struct v4l2_vp8_segment_header {
> +struct v4l2_vp8_segment {
>         __s8 quant_update[4];
>         __s8 lf_update[4];
>         __u8 segment_probs[3];
> @@ -31,10 +31,10 @@ struct v4l2_vp8_segment_header {
>         __u32 flags;
>  };
>
> -#define V4L2_VP8_LF_HEADER_ADJ_ENABLE  0x01
> -#define V4L2_VP8_LF_HEADER_DELTA_UPDATE        0x02
> +#define V4L2_VP8_LF_ADJ_ENABLE 0x01
> +#define V4L2_VP8_LF_DELTA_UPDATE       0x02
>  #define V4L2_VP8_LF_FILTER_TYPE_SIMPLE 0x04
> -struct v4l2_vp8_loopfilter_header {
> +struct v4l2_vp8_loopfilter {
>         __s8 ref_frm_delta[4];
>         __s8 mb_mode_delta[4];
>         __u8 sharpness_level;
> @@ -43,7 +43,7 @@ struct v4l2_vp8_loopfilter_header {
>         __u32 flags;
>  };
>
> -struct v4l2_vp8_quantization_header {
> +struct v4l2_vp8_quantization {
>         __u8 y_ac_qi;
>         __s8 y_dc_delta;
>         __s8 y2_dc_delta;
> @@ -55,7 +55,7 @@ struct v4l2_vp8_quantization_header {
>
>  #define V4L2_VP8_COEFF_PROB_CNT 11
>  #define V4L2_VP8_MV_PROB_CNT 19
> -struct v4l2_vp8_entropy_header {
> +struct v4l2_vp8_entropy {
>         __u8 coeff_probs[4][8][3][V4L2_VP8_COEFF_PROB_CNT];
>         __u8 y_mode_probs[4];
>         __u8 uv_mode_probs[3];
> @@ -70,21 +70,21 @@ struct v4l2_vp8_entropy_coder_state {
>         __u8 padding;
>  };
>
> -#define V4L2_VP8_FRAME_HEADER_FLAG_KEY_FRAME           0x01
> -#define V4L2_VP8_FRAME_HEADER_FLAG_EXPERIMENTAL                0x02
> -#define V4L2_VP8_FRAME_HEADER_FLAG_SHOW_FRAME          0x04
> -#define V4L2_VP8_FRAME_HEADER_FLAG_MB_NO_SKIP_COEFF    0x08
> -#define V4L2_VP8_FRAME_HEADER_FLAG_SIGN_BIAS_GOLDEN    0x10
> -#define V4L2_VP8_FRAME_HEADER_FLAG_SIGN_BIAS_ALT       0x20
> +#define V4L2_VP8_FRAME_FLAG_KEY_FRAME          0x01
> +#define V4L2_VP8_FRAME_FLAG_EXPERIMENTAL               0x02
> +#define V4L2_VP8_FRAME_FLAG_SHOW_FRAME         0x04
> +#define V4L2_VP8_FRAME_FLAG_MB_NO_SKIP_COEFF   0x08
> +#define V4L2_VP8_FRAME_FLAG_SIGN_BIAS_GOLDEN   0x10
> +#define V4L2_VP8_FRAME_FLAG_SIGN_BIAS_ALT      0x20
>
>  #define VP8_FRAME_IS_KEY_FRAME(hdr) \
> -       (!!((hdr)->flags & V4L2_VP8_FRAME_HEADER_FLAG_KEY_FRAME))
> +       (!!((hdr)->flags & V4L2_VP8_FRAME_FLAG_KEY_FRAME))
>
> -struct v4l2_ctrl_vp8_frame_header {
> -       struct v4l2_vp8_segment_header segment_header;
> -       struct v4l2_vp8_loopfilter_header lf_header;
> -       struct v4l2_vp8_quantization_header quant_header;
> -       struct v4l2_vp8_entropy_header entropy_header;
> +struct v4l2_ctrl_vp8_frame {
> +       struct v4l2_vp8_segment seg;

Sorry, I see the PR for this has already been sent, but why rename it
to "seg" instead of "segment"?

> +       struct v4l2_vp8_loopfilter lf;
> +       struct v4l2_vp8_quantization quant;
> +       struct v4l2_vp8_entropy entropy;
>         struct v4l2_vp8_entropy_coder_state coder_state;
>
>         __u16 width;
> --
> 2.30.0
>



[Index of Archives]     [Linux Input]     [Video for Linux]     [Gstreamer Embedded]     [Mplayer Users]     [Linux USB Devel]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [Yosemite Backpacking]

  Powered by Linux