Commit d04c114e authored by Ezequiel Garcia's avatar Ezequiel Garcia Committed by Mauro Carvalho Chehab
Browse files

media: uapi: vp8: Remove "header" from symbol names and macros 



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: default avatarEzequiel Garcia <ezequiel@collabora.com>
Signed-off-by: default avatarHans Verkuil <hverkuil-cisco@xs4all.nl>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab+huawei@kernel.org>
parent 18a6262b

Documentation/userspace-api/media/v4l/ext-ctrls-codec.rst

+40 −40
Original line number Diff line number Diff line
@@ -1800,7 +1800,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.
@@ -1811,7 +1811,7 @@ 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



.. raw:: latex
@@ -1821,22 +1821,22 @@ enum v4l2_mpeg_video_h264_hierarchical_coding_type - 


.. cssclass:: longtable



.. 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`

      - ``segment``

      - 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``
@@ -1905,15 +1905,15 @@ 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>`



.. raw:: latex



    \normalsize



.. _vp8_frame_header_flags:

.. _vp8_frame_flags:



``Frame Header Flags``

``Frame Flags``



.. tabularcolumns:: |p{9.8cm}|p{0.8cm}|p{6.7cm}|
@@ -1924,22 +1924,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.
@@ -1967,13 +1967,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.2cm}|p{4.0cm}|p{12.1cm}|



.. flat-table:: struct v4l2_vp8_segment_header

.. flat-table:: struct v4l2_vp8_segment

    :header-rows:  0

    :stub-columns: 0

    :widths:       1 1 2
@@ -1992,11 +1992,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``



.. raw:: latex
@@ -2009,16 +2009,16 @@ 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.
@@ -2027,13 +2027,13 @@ enum v4l2_mpeg_video_h264_hierarchical_coding_type - 


    \normalsize



.. c:type:: v4l2_vp8_loopfilter_header

.. c:type:: v4l2_vp8_loopfilter



.. cssclass:: longtable



.. tabularcolumns:: |p{1.5cm}|p{3.9cm}|p{11.9cm}|



.. flat-table:: struct v4l2_vp8_loopfilter_header

.. flat-table:: struct v4l2_vp8_loopfilter

    :header-rows:  0

    :stub-columns: 0

    :widths:       1 1 2
@@ -2055,11 +2055,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``



.. tabularcolumns:: |p{7.0cm}|p{1.2cm}|p{9.1cm}|
@@ -2068,10 +2068,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``
@@ -2079,11 +2079,11 @@ 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



.. tabularcolumns:: |p{1.5cm}|p{3.5cm}|p{12.3cm}|



.. flat-table:: struct v4l2_vp8_quantization_header

.. flat-table:: struct v4l2_vp8_quantization

    :header-rows:  0

    :stub-columns: 0

    :widths:       1 1 2
@@ -2110,13 +2110,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{5.8cm}|p{10.0cm}|



.. flat-table:: struct v4l2_vp8_entropy_header

.. flat-table:: struct v4l2_vp8_entropy

    :header-rows:  0

    :stub-columns: 0

    :widths:       1 1 2

Documentation/userspace-api/media/v4l/pixfmt-compressed.rst

+1 −1
Original line number Diff line number Diff line
@@ -157,7 +157,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

drivers/media/v4l2-core/v4l2-ctrls.c

+18 −18
Original line number Diff line number Diff line
@@ -974,7 +974,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";
@@ -1476,8 +1476,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;
@@ -1648,7 +1648,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;
@@ -1672,9 +1672,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;
@@ -1829,7 +1829,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;
@@ -2052,10 +2052,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:
@@ -2064,11 +2064,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->segment);

		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:
@@ -2815,8 +2815,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);

drivers/staging/media/hantro/hantro_drv.c

+1 −1
Original line number Diff line number Diff line
@@ -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,

drivers/staging/media/hantro/hantro_g1_vp8_dec.c

+24 −24
Original line number Diff line number Diff line
@@ -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->segment;

	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->segment;

	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->segment;

	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);