Le mercredi 23 février 2022 à 11:40 +0800, Yunfei Dong a écrit :
> Mt8192 can use some of common code with mt8183. Moves them to
> a new file in order to reuse.
With the documentation fixed as per my comments below, you can add:
Reviewed-by: Nicolas Dufresne <nicolas.dufresne@xxxxxxxxxxxxx>
>
> Signed-off-by: Yunfei Dong <yunfei.dong@xxxxxxxxxxxx>
> ---
> drivers/media/platform/mtk-vcodec/Makefile | 1 +
> .../mtk-vcodec/vdec/vdec_h264_req_common.c | 310 +++++++++++++
> .../mtk-vcodec/vdec/vdec_h264_req_common.h | 253 +++++++++++
> .../mtk-vcodec/vdec/vdec_h264_req_if.c | 424 ++----------------
> 4 files changed, 606 insertions(+), 382 deletions(-)
> create mode 100644 drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.c
> create mode 100644 drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.h
>
> diff --git a/drivers/media/platform/mtk-vcodec/Makefile b/drivers/media/platform/mtk-vcodec/Makefile
> index 359619653a0e..3f41d748eee5 100644
> --- a/drivers/media/platform/mtk-vcodec/Makefile
> +++ b/drivers/media/platform/mtk-vcodec/Makefile
> @@ -9,6 +9,7 @@ mtk-vcodec-dec-y := vdec/vdec_h264_if.o \
> vdec/vdec_vp8_if.o \
> vdec/vdec_vp9_if.o \
> vdec/vdec_h264_req_if.o \
> + vdec/vdec_h264_req_common.o \
> mtk_vcodec_dec_drv.o \
> vdec_drv_if.o \
> vdec_vpu_if.o \
> diff --git a/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.c b/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.c
> new file mode 100644
> index 000000000000..6c68bee632d6
> --- /dev/null
> +++ b/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.c
> @@ -0,0 +1,310 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (c) 2021 MediaTek Inc.
> + * Author: Yunfei Dong <yunfei.dong@xxxxxxxxxxxx>
> + */
> +
> +#include "vdec_h264_req_common.h"
> +
> +/* get used parameters for sps/pps */
> +#define GET_MTK_VDEC_FLAG(cond, flag) \
> + { dst_param->cond = ((src_param->flags & flag) ? (1) : (0)); }
> +#define GET_MTK_VDEC_PARAM(param) \
> + { dst_param->param = src_param->param; }
> +
> +/*
> + * The firmware expects unused reflist entries to have the value 0x20.
> + */
> +void mtk_vdec_h264_fixup_ref_list(u8 *ref_list, size_t num_valid)
> +{
> + memset_io(&ref_list[num_valid], 0x20, 32 - num_valid);
> +}
> +
> +void *mtk_vdec_h264_get_ctrl_ptr(struct mtk_vcodec_ctx *ctx, int id)
> +{
> + struct v4l2_ctrl *ctrl = v4l2_ctrl_find(&ctx->ctrl_hdl, id);
> +
> + if (!ctrl)
> + return ERR_PTR(-EINVAL);
> +
> + return ctrl->p_cur.p;
> +}
> +
> +void mtk_vdec_h264_fill_dpb_info(struct mtk_vcodec_ctx *ctx,
> + struct slice_api_h264_decode_param *decode_params,
> + struct mtk_h264_dpb_info *h264_dpb_info)
> +{
> + const struct slice_h264_dpb_entry *dpb;
> + struct vb2_queue *vq;
> + struct vb2_buffer *vb;
> + struct vb2_v4l2_buffer *vb2_v4l2;
> + int index, vb2_index;
> +
> + vq = v4l2_m2m_get_vq(ctx->m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
> +
> + for (index = 0; index < V4L2_H264_NUM_DPB_ENTRIES; index++) {
> + dpb = &decode_params->dpb[index];
> + if (!(dpb->flags & V4L2_H264_DPB_ENTRY_FLAG_ACTIVE)) {
> + h264_dpb_info[index].reference_flag = 0;
> + continue;
> + }
> +
> + vb2_index = vb2_find_timestamp(vq, dpb->reference_ts, 0);
> + if (vb2_index < 0) {
> + dev_err(&ctx->dev->plat_dev->dev,
> + "Reference invalid: dpb_index(%d) reference_ts(%lld)",
> + index, dpb->reference_ts);
> + continue;
> + }
> +
> + /* 1 for short term reference, 2 for long term reference */
> + if (!(dpb->flags & V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM))
> + h264_dpb_info[index].reference_flag = 1;
> + else
> + h264_dpb_info[index].reference_flag = 2;
> +
> + vb = vq->bufs[vb2_index];
> + vb2_v4l2 = container_of(vb, struct vb2_v4l2_buffer, vb2_buf);
> + h264_dpb_info[index].field = vb2_v4l2->field;
> +
> + h264_dpb_info[index].y_dma_addr =
> + vb2_dma_contig_plane_dma_addr(vb, 0);
> + if (ctx->q_data[MTK_Q_DATA_DST].fmt->num_planes == 2)
> + h264_dpb_info[index].c_dma_addr =
> + vb2_dma_contig_plane_dma_addr(vb, 1);
> + else
> + h264_dpb_info[index].c_dma_addr =
> + h264_dpb_info[index].y_dma_addr +
> + ctx->picinfo.fb_sz[0];
> + }
> +}
> +
> +void mtk_vdec_h264_copy_sps_params(struct mtk_h264_sps_param *dst_param,
> + const struct v4l2_ctrl_h264_sps *src_param)
> +{
> + GET_MTK_VDEC_PARAM(chroma_format_idc);
> + GET_MTK_VDEC_PARAM(bit_depth_luma_minus8);
> + GET_MTK_VDEC_PARAM(bit_depth_chroma_minus8);
> + GET_MTK_VDEC_PARAM(log2_max_frame_num_minus4);
> + GET_MTK_VDEC_PARAM(pic_order_cnt_type);
> + GET_MTK_VDEC_PARAM(log2_max_pic_order_cnt_lsb_minus4);
> + GET_MTK_VDEC_PARAM(max_num_ref_frames);
> + GET_MTK_VDEC_PARAM(pic_width_in_mbs_minus1);
> + GET_MTK_VDEC_PARAM(pic_height_in_map_units_minus1);
> +
> + GET_MTK_VDEC_FLAG(separate_colour_plane_flag,
> + V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE);
> + GET_MTK_VDEC_FLAG(qpprime_y_zero_transform_bypass_flag,
> + V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS);
> + GET_MTK_VDEC_FLAG(delta_pic_order_always_zero_flag,
> + V4L2_H264_SPS_FLAG_DELTA_PIC_ORDER_ALWAYS_ZERO);
> + GET_MTK_VDEC_FLAG(frame_mbs_only_flag,
> + V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY);
> + GET_MTK_VDEC_FLAG(mb_adaptive_frame_field_flag,
> + V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD);
> + GET_MTK_VDEC_FLAG(direct_8x8_inference_flag,
> + V4L2_H264_SPS_FLAG_DIRECT_8X8_INFERENCE);
> +}
> +
> +void mtk_vdec_h264_copy_pps_params(struct mtk_h264_pps_param *dst_param,
> + const struct v4l2_ctrl_h264_pps *src_param)
> +{
> + GET_MTK_VDEC_PARAM(num_ref_idx_l0_default_active_minus1);
> + GET_MTK_VDEC_PARAM(num_ref_idx_l1_default_active_minus1);
> + GET_MTK_VDEC_PARAM(weighted_bipred_idc);
> + GET_MTK_VDEC_PARAM(pic_init_qp_minus26);
> + GET_MTK_VDEC_PARAM(chroma_qp_index_offset);
> + GET_MTK_VDEC_PARAM(second_chroma_qp_index_offset);
> +
> + GET_MTK_VDEC_FLAG(entropy_coding_mode_flag,
> + V4L2_H264_PPS_FLAG_ENTROPY_CODING_MODE);
> + GET_MTK_VDEC_FLAG(pic_order_present_flag,
> + V4L2_H264_PPS_FLAG_BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT);
> + GET_MTK_VDEC_FLAG(weighted_pred_flag,
> + V4L2_H264_PPS_FLAG_WEIGHTED_PRED);
> + GET_MTK_VDEC_FLAG(deblocking_filter_control_present_flag,
> + V4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT);
> + GET_MTK_VDEC_FLAG(constrained_intra_pred_flag,
> + V4L2_H264_PPS_FLAG_CONSTRAINED_INTRA_PRED);
> + GET_MTK_VDEC_FLAG(redundant_pic_cnt_present_flag,
> + V4L2_H264_PPS_FLAG_REDUNDANT_PIC_CNT_PRESENT);
> + GET_MTK_VDEC_FLAG(transform_8x8_mode_flag,
> + V4L2_H264_PPS_FLAG_TRANSFORM_8X8_MODE);
> + GET_MTK_VDEC_FLAG(scaling_matrix_present_flag,
> + V4L2_H264_PPS_FLAG_SCALING_MATRIX_PRESENT);
> +}
> +
> +void mtk_vdec_h264_copy_slice_hd_params(struct mtk_h264_slice_hd_param *dst_param,
> + const struct v4l2_ctrl_h264_slice_params *src_param,
> + const struct v4l2_ctrl_h264_decode_params *dec_param)
> +{
> + int temp;
> +
> + GET_MTK_VDEC_PARAM(first_mb_in_slice);
> + GET_MTK_VDEC_PARAM(slice_type);
> + GET_MTK_VDEC_PARAM(cabac_init_idc);
> + GET_MTK_VDEC_PARAM(slice_qp_delta);
> + GET_MTK_VDEC_PARAM(disable_deblocking_filter_idc);
> + GET_MTK_VDEC_PARAM(slice_alpha_c0_offset_div2);
> + GET_MTK_VDEC_PARAM(slice_beta_offset_div2);
> + GET_MTK_VDEC_PARAM(num_ref_idx_l0_active_minus1);
> + GET_MTK_VDEC_PARAM(num_ref_idx_l1_active_minus1);
> +
> + dst_param->frame_num = dec_param->frame_num;
> + dst_param->pic_order_cnt_lsb = dec_param->pic_order_cnt_lsb;
> +
> + dst_param->delta_pic_order_cnt_bottom =
> + dec_param->delta_pic_order_cnt_bottom;
> + dst_param->delta_pic_order_cnt0 =
> + dec_param->delta_pic_order_cnt0;
> + dst_param->delta_pic_order_cnt1 =
> + dec_param->delta_pic_order_cnt1;
> +
> + temp = dec_param->flags & V4L2_H264_DECODE_PARAM_FLAG_FIELD_PIC;
> + dst_param->field_pic_flag = temp ? 1 : 0;
> +
> + temp = dec_param->flags & V4L2_H264_DECODE_PARAM_FLAG_BOTTOM_FIELD;
> + dst_param->bottom_field_flag = temp ? 1 : 0;
> +
> + GET_MTK_VDEC_FLAG(direct_spatial_mv_pred_flag,
> + V4L2_H264_SLICE_FLAG_DIRECT_SPATIAL_MV_PRED);
> +}
> +
> +void mtk_vdec_h264_copy_scaling_matrix(struct slice_api_h264_scaling_matrix *dst_matrix,
> + const struct v4l2_ctrl_h264_scaling_matrix *src_matrix)
> +{
> + memcpy_toio(dst_matrix->scaling_list_4x4, src_matrix->scaling_list_4x4,
> + sizeof(dst_matrix->scaling_list_4x4));
> +
> + memcpy_toio(dst_matrix->scaling_list_8x8, src_matrix->scaling_list_8x8,
> + sizeof(dst_matrix->scaling_list_8x8));
> +}
> +
> +void
> +mtk_vdec_h264_copy_decode_params(struct slice_api_h264_decode_param *dst_params,
> + const struct v4l2_ctrl_h264_decode_params *src_params,
> + const struct v4l2_h264_dpb_entry dpb[V4L2_H264_NUM_DPB_ENTRIES])
> +{
> + struct slice_h264_dpb_entry *dst_entry;
> + const struct v4l2_h264_dpb_entry *src_entry;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(dst_params->dpb); i++) {
> + dst_entry = &dst_params->dpb[i];
> + src_entry = &dpb[i];
> +
> + dst_entry->reference_ts = src_entry->reference_ts;
> + dst_entry->frame_num = src_entry->frame_num;
> + dst_entry->pic_num = src_entry->pic_num;
> + dst_entry->top_field_order_cnt = src_entry->top_field_order_cnt;
> + dst_entry->bottom_field_order_cnt =
> + src_entry->bottom_field_order_cnt;
> + dst_entry->flags = src_entry->flags;
> + }
> +
> + /* num_slices is a leftover from the old H.264 support and is ignored
> + * by the firmware.
> + */
> + dst_params->num_slices = 0;
> + dst_params->nal_ref_idc = src_params->nal_ref_idc;
> + dst_params->top_field_order_cnt = src_params->top_field_order_cnt;
> + dst_params->bottom_field_order_cnt = src_params->bottom_field_order_cnt;
> + dst_params->flags = src_params->flags;
> +}
> +
> +static bool mtk_vdec_h264_dpb_entry_match(const struct v4l2_h264_dpb_entry *a,
> + const struct v4l2_h264_dpb_entry *b)
> +{
> + return a->top_field_order_cnt == b->top_field_order_cnt &&
> + a->bottom_field_order_cnt == b->bottom_field_order_cnt;
> +}
> +
> +/*
> + * Move DPB entries of dec_param that refer to a frame already existing in dpb
> + * into the already existing slot in dpb, and move other entries into new slots.
> + *
> + * This function is an adaptation of the similarly-named function in
> + * hantro_h264.c.
> + */
> +void mtk_vdec_h264_update_dpb(const struct v4l2_ctrl_h264_decode_params *dec_param,
> + struct v4l2_h264_dpb_entry *dpb)
> +{
> + DECLARE_BITMAP(new, ARRAY_SIZE(dec_param->dpb)) = { 0, };
> + DECLARE_BITMAP(in_use, ARRAY_SIZE(dec_param->dpb)) = { 0, };
> + DECLARE_BITMAP(used, ARRAY_SIZE(dec_param->dpb)) = { 0, };
> + unsigned int i, j;
> +
> + /* Disable all entries by default, and mark the ones in use. */
> + for (i = 0; i < ARRAY_SIZE(dec_param->dpb); i++) {
> + if (dpb[i].flags & V4L2_H264_DPB_ENTRY_FLAG_ACTIVE)
> + set_bit(i, in_use);
> + dpb[i].flags &= ~V4L2_H264_DPB_ENTRY_FLAG_ACTIVE;
> + }
> +
> + /* Try to match new DPB entries with existing ones by their POCs. */
> + for (i = 0; i < ARRAY_SIZE(dec_param->dpb); i++) {
> + const struct v4l2_h264_dpb_entry *ndpb = &dec_param->dpb[i];
> +
> + if (!(ndpb->flags & V4L2_H264_DPB_ENTRY_FLAG_ACTIVE))
> + continue;
> +
> + /*
> + * To cut off some comparisons, iterate only on target DPB
> + * entries were already used.
> + */
> + for_each_set_bit(j, in_use, ARRAY_SIZE(dec_param->dpb)) {
> + struct v4l2_h264_dpb_entry *cdpb;
> +
> + cdpb = &dpb[j];
> + if (!mtk_vdec_h264_dpb_entry_match(cdpb, ndpb))
> + continue;
> +
> + *cdpb = *ndpb;
> + set_bit(j, used);
> + /* Don't reiterate on this one. */
> + clear_bit(j, in_use);
> + break;
> + }
> +
> + if (j == ARRAY_SIZE(dec_param->dpb))
> + set_bit(i, new);
> + }
> +
> + /* For entries that could not be matched, use remaining free slots. */
> + for_each_set_bit(i, new, ARRAY_SIZE(dec_param->dpb)) {
> + const struct v4l2_h264_dpb_entry *ndpb = &dec_param->dpb[i];
> + struct v4l2_h264_dpb_entry *cdpb;
> +
> + /*
> + * Both arrays are of the same sizes, so there is no way
> + * we can end up with no space in target array, unless
> + * something is buggy.
> + */
> + j = find_first_zero_bit(used, ARRAY_SIZE(dec_param->dpb));
> + if (WARN_ON(j >= ARRAY_SIZE(dec_param->dpb)))
> + return;
> +
> + cdpb = &dpb[j];
> + *cdpb = *ndpb;
> + set_bit(j, used);
> + }
> +}
> +
> +unsigned int mtk_vdec_h264_get_mv_buf_size(unsigned int width, unsigned int height)
> +{
> + int unit_size = (width / MB_UNIT_LEN) * (height / MB_UNIT_LEN) + 8;
> +
> + return HW_MB_STORE_SZ * unit_size;
> +}
> +
> +int mtk_vdec_h264_find_start_code(unsigned char *data, unsigned int data_sz)
> +{
> + if (data_sz > 3 && data[0] == 0 && data[1] == 0 && data[2] == 1)
> + return 3;
> +
> + if (data_sz > 4 && data[0] == 0 && data[1] == 0 && data[2] == 0 &&
> + data[3] == 1)
> + return 4;
> +
> + return -1;
> +}
> diff --git a/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.h b/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.h
> new file mode 100644
> index 000000000000..2d731bc777ca
> --- /dev/null
> +++ b/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_common.h
> @@ -0,0 +1,253 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/*
> + * Copyright (c) 2021 MediaTek Inc.
> + * Author: Yunfei Dong <yunfei.dong@xxxxxxxxxxxx>
> + */
> +
> +#ifndef _VDEC_H264_REQ_COMMON_H_
> +#define _VDEC_H264_REQ_COMMON_H_
> +
> +#include <linux/module.h>
> +#include <linux/slab.h>
> +#include <media/v4l2-h264.h>
> +#include <media/v4l2-mem2mem.h>
> +#include <media/videobuf2-dma-contig.h>
> +
> +#include "../mtk_vcodec_drv.h"
> +
> +#define NAL_NON_IDR_SLICE 0x01
> +#define NAL_IDR_SLICE 0x05
> +#define NAL_TYPE(value) ((value) & 0x1F)
> +
> +#define BUF_PREDICTION_SZ (64 * 4096)
> +#define MB_UNIT_LEN 16
> +
> +/* motion vector size (bytes) for every macro block */
> +#define HW_MB_STORE_SZ 64
> +
> +#define H264_MAX_MV_NUM 32
> +
> +/**
> + * struct mtk_h264_dpb_info - h264 dpb information
All other doc I have seen will add an empty line between this and the first
parameter.
> + * @y_dma_addr: Y bitstream physical address
> + * @c_dma_addr: CbCr bitstream physical address
> + * @reference_flag: reference picture flag (short/long term reference picture)
> + * @field: field picture flag
> + */
> +struct mtk_h264_dpb_info {
> + dma_addr_t y_dma_addr;
> + dma_addr_t c_dma_addr;
> + int reference_flag;
> + int field;
> +};
> +
> +/**
> + * struct mtk_h264_sps_param - parameters for sps
Each member is documented in previous structure, why not this one ? Same apply
in many places.
> + */
> +struct mtk_h264_sps_param {
> + unsigned char chroma_format_idc;
> + unsigned char bit_depth_luma_minus8;
> + unsigned char bit_depth_chroma_minus8;
> + unsigned char log2_max_frame_num_minus4;
> + unsigned char pic_order_cnt_type;
> + unsigned char log2_max_pic_order_cnt_lsb_minus4;
> + unsigned char max_num_ref_frames;
> + unsigned char separate_colour_plane_flag;
> + unsigned short pic_width_in_mbs_minus1;
> + unsigned short pic_height_in_map_units_minus1;
> + unsigned int max_frame_nums;
> + unsigned char qpprime_y_zero_transform_bypass_flag;
> + unsigned char delta_pic_order_always_zero_flag;
> + unsigned char frame_mbs_only_flag;
> + unsigned char mb_adaptive_frame_field_flag;
> + unsigned char direct_8x8_inference_flag;
> + unsigned char reserved[3];
> +};
> +
> +/**
> + * struct mtk_h264_pps_param - parameters for pps
> + */
> +struct mtk_h264_pps_param {
> + unsigned char num_ref_idx_l0_default_active_minus1;
> + unsigned char num_ref_idx_l1_default_active_minus1;
> + unsigned char weighted_bipred_idc;
> + char pic_init_qp_minus26;
> + char chroma_qp_index_offset;
> + char second_chroma_qp_index_offset;
> + unsigned char entropy_coding_mode_flag;
> + unsigned char pic_order_present_flag;
> + unsigned char deblocking_filter_control_present_flag;
> + unsigned char constrained_intra_pred_flag;
> + unsigned char weighted_pred_flag;
> + unsigned char redundant_pic_cnt_present_flag;
> + unsigned char transform_8x8_mode_flag;
> + unsigned char scaling_matrix_present_flag;
> + unsigned char reserved[2];
> +};
> +
> +/**
> + * struct mtk_h264_slice_hd_param - parameters for slice header
> + */
> +struct mtk_h264_slice_hd_param {
> + unsigned int first_mb_in_slice;
> + unsigned int field_pic_flag;
> + unsigned int slice_type;
> + unsigned int frame_num;
> + int pic_order_cnt_lsb;
> + int delta_pic_order_cnt_bottom;
> + unsigned int bottom_field_flag;
> + unsigned int direct_spatial_mv_pred_flag;
> + int delta_pic_order_cnt0;
> + int delta_pic_order_cnt1;
> + unsigned int cabac_init_idc;
> + int slice_qp_delta;
> + unsigned int disable_deblocking_filter_idc;
> + int slice_alpha_c0_offset_div2;
> + int slice_beta_offset_div2;
> + unsigned int num_ref_idx_l0_active_minus1;
> + unsigned int num_ref_idx_l1_active_minus1;
> + unsigned int reserved;
> +};
> +
And why these two don't have doc now ?
> +struct slice_api_h264_scaling_matrix {
> + unsigned char scaling_list_4x4[6][16];
> + unsigned char scaling_list_8x8[6][64];
> +};
> +
> +struct slice_h264_dpb_entry {
> + unsigned long long reference_ts;
> + unsigned short frame_num;
> + unsigned short pic_num;
> + /* Note that field is indicated by v4l2_buffer.field */
> + int top_field_order_cnt;
> + int bottom_field_order_cnt;
> + unsigned int flags; /* V4L2_H264_DPB_ENTRY_FLAG_* */
You could move that into a doc block ?
> +};
> +
> +/**
> + * struct slice_api_h264_decode_param - parameters for decode.
> + */
> +struct slice_api_h264_decode_param {
> + struct slice_h264_dpb_entry dpb[V4L2_H264_NUM_DPB_ENTRIES];
> + unsigned short num_slices;
> + unsigned short nal_ref_idc;
> + unsigned char ref_pic_list_p0[32];
> + unsigned char ref_pic_list_b0[32];
> + unsigned char ref_pic_list_b1[32];
> + int top_field_order_cnt;
> + int bottom_field_order_cnt;
> + unsigned int flags; /* V4L2_H264_DECODE_PARAM_FLAG_* */
> +};
> +
> +/**
> + * struct h264_fb - h264 decode frame buffer information
> + * @vdec_fb_va : virtual address of struct vdec_fb
> + * @y_fb_dma : dma address of Y frame buffer (luma)
> + * @c_fb_dma : dma address of C frame buffer (chroma)
> + * @poc : picture order count of frame buffer
> + * @reserved : for 8 bytes alignment
This style does not match what came before.
> + */
> +struct h264_fb {
> + u64 vdec_fb_va;
> + u64 y_fb_dma;
> + u64 c_fb_dma;
> + s32 poc;
> + u32 reserved;
> +};
> +
> +/**
> + * mtk_vdec_h264_fixup_ref_list - fixup unused reference to 0x20.
> + * @ref_list: reference picture list
> + * @num_valid: used reference number
> + */
> +void mtk_vdec_h264_fixup_ref_list(u8 *ref_list, size_t num_valid);
> +
> +/**
> + * mtk_vdec_h264_get_ctrl_ptr - get each CID contrl address.
> + * @ctx: v4l2 ctx
> + * @id: CID control ID
> + */
> +void *mtk_vdec_h264_get_ctrl_ptr(struct mtk_vcodec_ctx *ctx, int id);
> +
> +/**
> + * mtk_vdec_h264_fill_dpb_info - get each CID contrl address.
> + * @ctx: v4l2 ctx
> + * @decode_params: slice decode params
> + * @h264_dpb_info: dpb buffer information
> + */
> +void mtk_vdec_h264_fill_dpb_info(struct mtk_vcodec_ctx *ctx,
> + struct slice_api_h264_decode_param *decode_params,
> + struct mtk_h264_dpb_info *h264_dpb_info);
> +
> +/**
> + * mtk_vdec_h264_copy_sps_params - get sps params.
> + * @dst_params: sps params for hw decoder
> + * @src_params: sps params from user driver
> + */
> +void mtk_vdec_h264_copy_sps_params(struct mtk_h264_sps_param *dst_param,
> + const struct v4l2_ctrl_h264_sps *src_param);
> +
> +/**
> + * mtk_vdec_h264_copy_pps_params - get pps params.
> + * @dst_params: pps params for hw decoder
> + * @src_params: pps params from user driver
> + */
> +void mtk_vdec_h264_copy_pps_params(struct mtk_h264_pps_param *dst_param,
> + const struct v4l2_ctrl_h264_pps *src_param);
> +
> +/**
> + * mtk_vdec_h264_copy_slice_hd_params - get slice header params.
> + * @dst_params: slice params for hw decoder
> + * @src_params: slice params from user driver
> + * @dec_param: decode params from user driver
> + */
> +void mtk_vdec_h264_copy_slice_hd_params(struct mtk_h264_slice_hd_param *dst_param,
> + const struct v4l2_ctrl_h264_slice_params *src_param,
> + const struct v4l2_ctrl_h264_decode_params *dec_param);
> +
> +/**
> + * mtk_vdec_h264_copy_scaling_matrix - get each CID contrl address.
> + * @dst_matrix: scaling list params for hw decoder
> + * @src_matrix: scaling list params from user driver
> + */
> +void mtk_vdec_h264_copy_scaling_matrix(struct slice_api_h264_scaling_matrix *dst_matrix,
> + const struct v4l2_ctrl_h264_scaling_matrix *src_matrix);
> +
> +/**
> + * mtk_vdec_h264_copy_decode_params - get decode params.
> + * @dst_params: dst params for hw decoder
> + * @src_params: decode params from user driver
> + * @dpb: dpb information
> + */
> +void
> +mtk_vdec_h264_copy_decode_params(struct slice_api_h264_decode_param *dst_params,
> + const struct v4l2_ctrl_h264_decode_params *src_params,
> + const struct v4l2_h264_dpb_entry dpb[V4L2_H264_NUM_DPB_ENTRIES]);
> +
> +/**
> + * mtk_vdec_h264_update_dpb - updata dpb list.
> + * @dec_param: v4l2 control decode params
> + * @dpb: dpb entry informaton
> + */
> +void mtk_vdec_h264_update_dpb(const struct v4l2_ctrl_h264_decode_params *dec_param,
> + struct v4l2_h264_dpb_entry *dpb);
> +
> +/**
> + * mtk_vdec_h264_find_start_code - find h264 start code using sofeware.
> + * @data: input buffer address
> + * @data_sz: input buffer size
> + *
> + * Return: returns start code position.
> + */
> +int mtk_vdec_h264_find_start_code(unsigned char *data, unsigned int data_sz);
> +
> +/**
> + * mtk_vdec_h264_get_mv_buf_size - get mv buffer size.
> + * @width: picture width
> + * @height: picture height
> + *
> + * Return: returns mv buffer size.
> + */
> +unsigned int mtk_vdec_h264_get_mv_buf_size(unsigned int width, unsigned int height);
> +
> +#endif
> diff --git a/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_if.c b/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_if.c
> index 36f3dc1fbe3b..87e0b2f95572 100644
> --- a/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_if.c
> +++ b/drivers/media/platform/mtk-vcodec/vdec/vdec_h264_req_if.c
> @@ -12,109 +12,7 @@
> #include "../vdec_drv_base.h"
> #include "../vdec_drv_if.h"
> #include "../vdec_vpu_if.h"
> -
> -#define BUF_PREDICTION_SZ (64 * 4096)
> -#define MB_UNIT_LEN 16
> -
> -/* get used parameters for sps/pps */
> -#define GET_MTK_VDEC_FLAG(cond, flag) \
> - { dst_param->cond = ((src_param->flags & (flag)) ? (1) : (0)); }
> -#define GET_MTK_VDEC_PARAM(param) \
> - { dst_param->param = src_param->param; }
> -/* motion vector size (bytes) for every macro block */
> -#define HW_MB_STORE_SZ 64
> -
> -#define H264_MAX_FB_NUM 17
> -#define H264_MAX_MV_NUM 32
> -#define HDR_PARSING_BUF_SZ 1024
> -
> -/**
> - * struct mtk_h264_dpb_info - h264 dpb information
> - * @y_dma_addr: Y bitstream physical address
> - * @c_dma_addr: CbCr bitstream physical address
> - * @reference_flag: reference picture flag (short/long term reference picture)
> - * @field: field picture flag
> - */
> -struct mtk_h264_dpb_info {
> - dma_addr_t y_dma_addr;
> - dma_addr_t c_dma_addr;
> - int reference_flag;
> - int field;
> -};
> -
> -/*
> - * struct mtk_h264_sps_param - parameters for sps
> - */
> -struct mtk_h264_sps_param {
> - unsigned char chroma_format_idc;
> - unsigned char bit_depth_luma_minus8;
> - unsigned char bit_depth_chroma_minus8;
> - unsigned char log2_max_frame_num_minus4;
> - unsigned char pic_order_cnt_type;
> - unsigned char log2_max_pic_order_cnt_lsb_minus4;
> - unsigned char max_num_ref_frames;
> - unsigned char separate_colour_plane_flag;
> - unsigned short pic_width_in_mbs_minus1;
> - unsigned short pic_height_in_map_units_minus1;
> - unsigned int max_frame_nums;
> - unsigned char qpprime_y_zero_transform_bypass_flag;
> - unsigned char delta_pic_order_always_zero_flag;
> - unsigned char frame_mbs_only_flag;
> - unsigned char mb_adaptive_frame_field_flag;
> - unsigned char direct_8x8_inference_flag;
> - unsigned char reserved[3];
> -};
> -
> -/*
> - * struct mtk_h264_pps_param - parameters for pps
> - */
> -struct mtk_h264_pps_param {
> - unsigned char num_ref_idx_l0_default_active_minus1;
> - unsigned char num_ref_idx_l1_default_active_minus1;
> - unsigned char weighted_bipred_idc;
> - char pic_init_qp_minus26;
> - char chroma_qp_index_offset;
> - char second_chroma_qp_index_offset;
> - unsigned char entropy_coding_mode_flag;
> - unsigned char pic_order_present_flag;
> - unsigned char deblocking_filter_control_present_flag;
> - unsigned char constrained_intra_pred_flag;
> - unsigned char weighted_pred_flag;
> - unsigned char redundant_pic_cnt_present_flag;
> - unsigned char transform_8x8_mode_flag;
> - unsigned char scaling_matrix_present_flag;
> - unsigned char reserved[2];
> -};
> -
> -struct slice_api_h264_scaling_matrix {
> - unsigned char scaling_list_4x4[6][16];
> - unsigned char scaling_list_8x8[6][64];
> -};
> -
> -struct slice_h264_dpb_entry {
> - unsigned long long reference_ts;
> - unsigned short frame_num;
> - unsigned short pic_num;
> - /* Note that field is indicated by v4l2_buffer.field */
> - int top_field_order_cnt;
> - int bottom_field_order_cnt;
> - unsigned int flags; /* V4L2_H264_DPB_ENTRY_FLAG_* */
> -};
> -
> -/*
> - * struct slice_api_h264_decode_param - parameters for decode.
> - */
> -struct slice_api_h264_decode_param {
> - struct slice_h264_dpb_entry dpb[16];
> - unsigned short num_slices;
> - unsigned short nal_ref_idc;
> - unsigned char ref_pic_list_p0[32];
> - unsigned char ref_pic_list_b0[32];
> - unsigned char ref_pic_list_b1[32];
> - int top_field_order_cnt;
> - int bottom_field_order_cnt;
> - unsigned int flags; /* V4L2_H264_DECODE_PARAM_FLAG_* */
> -};
> +#include "vdec_h264_req_common.h"
>
> /*
> * struct mtk_h264_dec_slice_param - parameters for decode current frame
> @@ -127,22 +25,6 @@ struct mtk_h264_dec_slice_param {
> struct mtk_h264_dpb_info h264_dpb_info[16];
> };
>
> -/**
> - * struct h264_fb - h264 decode frame buffer information
> - * @vdec_fb_va : virtual address of struct vdec_fb
> - * @y_fb_dma : dma address of Y frame buffer (luma)
> - * @c_fb_dma : dma address of C frame buffer (chroma)
> - * @poc : picture order count of frame buffer
> - * @reserved : for 8 bytes alignment
> - */
> -struct h264_fb {
> - u64 vdec_fb_va;
> - u64 y_fb_dma;
> - u64 c_fb_dma;
> - s32 poc;
> - u32 reserved;
> -};
> -
> /**
> * struct vdec_h264_dec_info - decode information
> * @dpb_sz : decoding picture buffer size
> @@ -212,265 +94,45 @@ struct vdec_h264_slice_inst {
> struct v4l2_h264_dpb_entry dpb[16];
> };
>
> -static void *get_ctrl_ptr(struct mtk_vcodec_ctx *ctx, int id)
> -{
> - struct v4l2_ctrl *ctrl = v4l2_ctrl_find(&ctx->ctrl_hdl, id);
> -
> - return ctrl->p_cur.p;
> -}
> -
> -static void get_h264_dpb_list(struct vdec_h264_slice_inst *inst,
> - struct mtk_h264_dec_slice_param *slice_param)
> -{
> - struct vb2_queue *vq;
> - struct vb2_buffer *vb;
> - struct vb2_v4l2_buffer *vb2_v4l2;
> - u64 index;
> -
> - vq = v4l2_m2m_get_vq(inst->ctx->m2m_ctx, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
> -
> - for (index = 0; index < ARRAY_SIZE(slice_param->decode_params.dpb); index++) {
> - const struct slice_h264_dpb_entry *dpb;
> - int vb2_index;
> -
> - dpb = &slice_param->decode_params.dpb[index];
> - if (!(dpb->flags & V4L2_H264_DPB_ENTRY_FLAG_ACTIVE)) {
> - slice_param->h264_dpb_info[index].reference_flag = 0;
> - continue;
> - }
> -
> - vb2_index = vb2_find_timestamp(vq, dpb->reference_ts, 0);
> - if (vb2_index < 0) {
> - mtk_vcodec_err(inst, "Reference invalid: dpb_index(%lld) reference_ts(%lld)",
> - index, dpb->reference_ts);
> - continue;
> - }
> - /* 1 for short term reference, 2 for long term reference */
> - if (!(dpb->flags & V4L2_H264_DPB_ENTRY_FLAG_LONG_TERM))
> - slice_param->h264_dpb_info[index].reference_flag = 1;
> - else
> - slice_param->h264_dpb_info[index].reference_flag = 2;
> -
> - vb = vq->bufs[vb2_index];
> - vb2_v4l2 = container_of(vb, struct vb2_v4l2_buffer, vb2_buf);
> - slice_param->h264_dpb_info[index].field = vb2_v4l2->field;
> -
> - slice_param->h264_dpb_info[index].y_dma_addr =
> - vb2_dma_contig_plane_dma_addr(vb, 0);
> - if (inst->ctx->q_data[MTK_Q_DATA_DST].fmt->num_planes == 2) {
> - slice_param->h264_dpb_info[index].c_dma_addr =
> - vb2_dma_contig_plane_dma_addr(vb, 1);
> - }
> - }
> -}
> -
> -static void get_h264_sps_parameters(struct mtk_h264_sps_param *dst_param,
> - const struct v4l2_ctrl_h264_sps *src_param)
> -{
> - GET_MTK_VDEC_PARAM(chroma_format_idc);
> - GET_MTK_VDEC_PARAM(bit_depth_luma_minus8);
> - GET_MTK_VDEC_PARAM(bit_depth_chroma_minus8);
> - GET_MTK_VDEC_PARAM(log2_max_frame_num_minus4);
> - GET_MTK_VDEC_PARAM(pic_order_cnt_type);
> - GET_MTK_VDEC_PARAM(log2_max_pic_order_cnt_lsb_minus4);
> - GET_MTK_VDEC_PARAM(max_num_ref_frames);
> - GET_MTK_VDEC_PARAM(pic_width_in_mbs_minus1);
> - GET_MTK_VDEC_PARAM(pic_height_in_map_units_minus1);
> -
> - GET_MTK_VDEC_FLAG(separate_colour_plane_flag,
> - V4L2_H264_SPS_FLAG_SEPARATE_COLOUR_PLANE);
> - GET_MTK_VDEC_FLAG(qpprime_y_zero_transform_bypass_flag,
> - V4L2_H264_SPS_FLAG_QPPRIME_Y_ZERO_TRANSFORM_BYPASS);
> - GET_MTK_VDEC_FLAG(delta_pic_order_always_zero_flag,
> - V4L2_H264_SPS_FLAG_DELTA_PIC_ORDER_ALWAYS_ZERO);
> - GET_MTK_VDEC_FLAG(frame_mbs_only_flag,
> - V4L2_H264_SPS_FLAG_FRAME_MBS_ONLY);
> - GET_MTK_VDEC_FLAG(mb_adaptive_frame_field_flag,
> - V4L2_H264_SPS_FLAG_MB_ADAPTIVE_FRAME_FIELD);
> - GET_MTK_VDEC_FLAG(direct_8x8_inference_flag,
> - V4L2_H264_SPS_FLAG_DIRECT_8X8_INFERENCE);
> -}
> -
> -static void get_h264_pps_parameters(struct mtk_h264_pps_param *dst_param,
> - const struct v4l2_ctrl_h264_pps *src_param)
> +static int get_vdec_decode_parameters(struct vdec_h264_slice_inst *inst)
> {
> - GET_MTK_VDEC_PARAM(num_ref_idx_l0_default_active_minus1);
> - GET_MTK_VDEC_PARAM(num_ref_idx_l1_default_active_minus1);
> - GET_MTK_VDEC_PARAM(weighted_bipred_idc);
> - GET_MTK_VDEC_PARAM(pic_init_qp_minus26);
> - GET_MTK_VDEC_PARAM(chroma_qp_index_offset);
> - GET_MTK_VDEC_PARAM(second_chroma_qp_index_offset);
> -
> - GET_MTK_VDEC_FLAG(entropy_coding_mode_flag,
> - V4L2_H264_PPS_FLAG_ENTROPY_CODING_MODE);
> - GET_MTK_VDEC_FLAG(pic_order_present_flag,
> - V4L2_H264_PPS_FLAG_BOTTOM_FIELD_PIC_ORDER_IN_FRAME_PRESENT);
> - GET_MTK_VDEC_FLAG(weighted_pred_flag,
> - V4L2_H264_PPS_FLAG_WEIGHTED_PRED);
> - GET_MTK_VDEC_FLAG(deblocking_filter_control_present_flag,
> - V4L2_H264_PPS_FLAG_DEBLOCKING_FILTER_CONTROL_PRESENT);
> - GET_MTK_VDEC_FLAG(constrained_intra_pred_flag,
> - V4L2_H264_PPS_FLAG_CONSTRAINED_INTRA_PRED);
> - GET_MTK_VDEC_FLAG(redundant_pic_cnt_present_flag,
> - V4L2_H264_PPS_FLAG_REDUNDANT_PIC_CNT_PRESENT);
> - GET_MTK_VDEC_FLAG(transform_8x8_mode_flag,
> - V4L2_H264_PPS_FLAG_TRANSFORM_8X8_MODE);
> - GET_MTK_VDEC_FLAG(scaling_matrix_present_flag,
> - V4L2_H264_PPS_FLAG_SCALING_MATRIX_PRESENT);
> -}
> -
> -static void
> -get_h264_scaling_matrix(struct slice_api_h264_scaling_matrix *dst_matrix,
> - const struct v4l2_ctrl_h264_scaling_matrix *src_matrix)
> -{
> - memcpy(dst_matrix->scaling_list_4x4, src_matrix->scaling_list_4x4,
> - sizeof(dst_matrix->scaling_list_4x4));
> -
> - memcpy(dst_matrix->scaling_list_8x8, src_matrix->scaling_list_8x8,
> - sizeof(dst_matrix->scaling_list_8x8));
> -}
> -
> -static void
> -get_h264_decode_parameters(struct slice_api_h264_decode_param *dst_params,
> - const struct v4l2_ctrl_h264_decode_params *src_params,
> - const struct v4l2_h264_dpb_entry dpb[V4L2_H264_NUM_DPB_ENTRIES])
> -{
> - int i;
> -
> - for (i = 0; i < ARRAY_SIZE(dst_params->dpb); i++) {
> - struct slice_h264_dpb_entry *dst_entry = &dst_params->dpb[i];
> - const struct v4l2_h264_dpb_entry *src_entry = &dpb[i];
> -
> - dst_entry->reference_ts = src_entry->reference_ts;
> - dst_entry->frame_num = src_entry->frame_num;
> - dst_entry->pic_num = src_entry->pic_num;
> - dst_entry->top_field_order_cnt = src_entry->top_field_order_cnt;
> - dst_entry->bottom_field_order_cnt =
> - src_entry->bottom_field_order_cnt;
> - dst_entry->flags = src_entry->flags;
> - }
> -
> - /*
> - * num_slices is a leftover from the old H.264 support and is ignored
> - * by the firmware.
> - */
> - dst_params->num_slices = 0;
> - dst_params->nal_ref_idc = src_params->nal_ref_idc;
> - dst_params->top_field_order_cnt = src_params->top_field_order_cnt;
> - dst_params->bottom_field_order_cnt = src_params->bottom_field_order_cnt;
> - dst_params->flags = src_params->flags;
> -}
> -
> -static bool dpb_entry_match(const struct v4l2_h264_dpb_entry *a,
> - const struct v4l2_h264_dpb_entry *b)
> -{
> - return a->top_field_order_cnt == b->top_field_order_cnt &&
> - a->bottom_field_order_cnt == b->bottom_field_order_cnt;
> -}
> -
> -/*
> - * Move DPB entries of dec_param that refer to a frame already existing in dpb
> - * into the already existing slot in dpb, and move other entries into new slots.
> - *
> - * This function is an adaptation of the similarly-named function in
> - * hantro_h264.c.
> - */
> -static void update_dpb(const struct v4l2_ctrl_h264_decode_params *dec_param,
> - struct v4l2_h264_dpb_entry *dpb)
> -{
> - DECLARE_BITMAP(new, ARRAY_SIZE(dec_param->dpb)) = { 0, };
> - DECLARE_BITMAP(in_use, ARRAY_SIZE(dec_param->dpb)) = { 0, };
> - DECLARE_BITMAP(used, ARRAY_SIZE(dec_param->dpb)) = { 0, };
> - unsigned int i, j;
> -
> - /* Disable all entries by default, and mark the ones in use. */
> - for (i = 0; i < ARRAY_SIZE(dec_param->dpb); i++) {
> - if (dpb[i].flags & V4L2_H264_DPB_ENTRY_FLAG_ACTIVE)
> - set_bit(i, in_use);
> - dpb[i].flags &= ~V4L2_H264_DPB_ENTRY_FLAG_ACTIVE;
> - }
> -
> - /* Try to match new DPB entries with existing ones by their POCs. */
> - for (i = 0; i < ARRAY_SIZE(dec_param->dpb); i++) {
> - const struct v4l2_h264_dpb_entry *ndpb = &dec_param->dpb[i];
> -
> - if (!(ndpb->flags & V4L2_H264_DPB_ENTRY_FLAG_ACTIVE))
> - continue;
> -
> - /*
> - * To cut off some comparisons, iterate only on target DPB
> - * entries were already used.
> - */
> - for_each_set_bit(j, in_use, ARRAY_SIZE(dec_param->dpb)) {
> - struct v4l2_h264_dpb_entry *cdpb;
> -
> - cdpb = &dpb[j];
> - if (!dpb_entry_match(cdpb, ndpb))
> - continue;
> -
> - *cdpb = *ndpb;
> - set_bit(j, used);
> - /* Don't reiterate on this one. */
> - clear_bit(j, in_use);
> - break;
> - }
> -
> - if (j == ARRAY_SIZE(dec_param->dpb))
> - set_bit(i, new);
> - }
> -
> - /* For entries that could not be matched, use remaining free slots. */
> - for_each_set_bit(i, new, ARRAY_SIZE(dec_param->dpb)) {
> - const struct v4l2_h264_dpb_entry *ndpb = &dec_param->dpb[i];
> - struct v4l2_h264_dpb_entry *cdpb;
> -
> - /*
> - * Both arrays are of the same sizes, so there is no way
> - * we can end up with no space in target array, unless
> - * something is buggy.
> - */
> - j = find_first_zero_bit(used, ARRAY_SIZE(dec_param->dpb));
> - if (WARN_ON(j >= ARRAY_SIZE(dec_param->dpb)))
> - return;
> -
> - cdpb = &dpb[j];
> - *cdpb = *ndpb;
> - set_bit(j, used);
> - }
> -}
> -
> -/*
> - * The firmware expects unused reflist entries to have the value 0x20.
> - */
> -static void fixup_ref_list(u8 *ref_list, size_t num_valid)
> -{
> - memset(&ref_list[num_valid], 0x20, 32 - num_valid);
> -}
> -
> -static void get_vdec_decode_parameters(struct vdec_h264_slice_inst *inst)
> -{
> - const struct v4l2_ctrl_h264_decode_params *dec_params =
> - get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_DECODE_PARAMS);
> - const struct v4l2_ctrl_h264_sps *sps =
> - get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_SPS);
> - const struct v4l2_ctrl_h264_pps *pps =
> - get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_PPS);
> - const struct v4l2_ctrl_h264_scaling_matrix *scaling_matrix =
> - get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_SCALING_MATRIX);
> + const struct v4l2_ctrl_h264_decode_params *dec_params;
> + const struct v4l2_ctrl_h264_sps *sps;
> + const struct v4l2_ctrl_h264_pps *pps;
> + const struct v4l2_ctrl_h264_scaling_matrix *scaling_matrix;
> struct mtk_h264_dec_slice_param *slice_param = &inst->h264_slice_param;
> struct v4l2_h264_reflist_builder reflist_builder;
> u8 *p0_reflist = slice_param->decode_params.ref_pic_list_p0;
> u8 *b0_reflist = slice_param->decode_params.ref_pic_list_b0;
> u8 *b1_reflist = slice_param->decode_params.ref_pic_list_b1;
>
> - update_dpb(dec_params, inst->dpb);
> + dec_params =
> + mtk_vdec_h264_get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_DECODE_PARAMS);
> + if (IS_ERR(dec_params))
> + return PTR_ERR(dec_params);
> +
> + sps = mtk_vdec_h264_get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_SPS);
> + if (IS_ERR(sps))
> + return PTR_ERR(sps);
> +
> + pps = mtk_vdec_h264_get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_PPS);
> + if (IS_ERR(pps))
> + return PTR_ERR(pps);
>
> - get_h264_sps_parameters(&slice_param->sps, sps);
> - get_h264_pps_parameters(&slice_param->pps, pps);
> - get_h264_scaling_matrix(&slice_param->scaling_matrix, scaling_matrix);
> - get_h264_decode_parameters(&slice_param->decode_params, dec_params,
> - inst->dpb);
> - get_h264_dpb_list(inst, slice_param);
> + scaling_matrix =
> + mtk_vdec_h264_get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_SCALING_MATRIX);
> + if (IS_ERR(scaling_matrix))
> + return PTR_ERR(scaling_matrix);
> +
> + mtk_vdec_h264_update_dpb(dec_params, inst->dpb);
> +
> + mtk_vdec_h264_copy_sps_params(&slice_param->sps, sps);
> + mtk_vdec_h264_copy_pps_params(&slice_param->pps, pps);
> + mtk_vdec_h264_copy_scaling_matrix(&slice_param->scaling_matrix, scaling_matrix);
> + mtk_vdec_h264_copy_decode_params(&slice_param->decode_params,
> + dec_params, inst->dpb);
> + mtk_vdec_h264_fill_dpb_info(inst->ctx, &slice_param->decode_params,
> + slice_param->h264_dpb_info);
>
> /* Build the reference lists */
> v4l2_h264_init_reflist_builder(&reflist_builder, dec_params, sps,
> @@ -478,19 +140,14 @@ static void get_vdec_decode_parameters(struct vdec_h264_slice_inst *inst)
> v4l2_h264_build_p_ref_list(&reflist_builder, p0_reflist);
> v4l2_h264_build_b_ref_lists(&reflist_builder, b0_reflist, b1_reflist);
> /* Adapt the built lists to the firmware's expectations */
> - fixup_ref_list(p0_reflist, reflist_builder.num_valid);
> - fixup_ref_list(b0_reflist, reflist_builder.num_valid);
> - fixup_ref_list(b1_reflist, reflist_builder.num_valid);
> + mtk_vdec_h264_fixup_ref_list(p0_reflist, reflist_builder.num_valid);
> + mtk_vdec_h264_fixup_ref_list(b0_reflist, reflist_builder.num_valid);
> + mtk_vdec_h264_fixup_ref_list(b1_reflist, reflist_builder.num_valid);
>
> memcpy(&inst->vsi_ctx.h264_slice_params, slice_param,
> sizeof(inst->vsi_ctx.h264_slice_params));
> -}
>
> -static unsigned int get_mv_buf_size(unsigned int width, unsigned int height)
> -{
> - int unit_size = (width / MB_UNIT_LEN) * (height / MB_UNIT_LEN) + 8;
> -
> - return HW_MB_STORE_SZ * unit_size;
> + return 0;
> }
>
> static int allocate_predication_buf(struct vdec_h264_slice_inst *inst)
> @@ -525,7 +182,7 @@ static int alloc_mv_buf(struct vdec_h264_slice_inst *inst,
> int i;
> int err;
> struct mtk_vcodec_mem *mem = NULL;
> - unsigned int buf_sz = get_mv_buf_size(pic->buf_w, pic->buf_h);
> + unsigned int buf_sz = mtk_vdec_h264_get_mv_buf_size(pic->buf_w, pic->buf_h);
>
> mtk_v4l2_debug(3, "size = 0x%x", buf_sz);
> for (i = 0; i < H264_MAX_MV_NUM; i++) {
> @@ -674,7 +331,7 @@ static int vdec_h264_slice_decode(void *h_vdec, struct mtk_vcodec_mem *bs,
> {
> struct vdec_h264_slice_inst *inst = h_vdec;
> const struct v4l2_ctrl_h264_decode_params *dec_params =
> - get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_DECODE_PARAMS);
> + mtk_vdec_h264_get_ctrl_ptr(inst->ctx, V4L2_CID_STATELESS_H264_DECODE_PARAMS);
> struct vdec_vpu_inst *vpu = &inst->vpu;
> struct mtk_video_dec_buf *src_buf_info;
> struct mtk_video_dec_buf *dst_buf_info;
> @@ -706,7 +363,10 @@ static int vdec_h264_slice_decode(void *h_vdec, struct mtk_vcodec_mem *bs,
>
> v4l2_m2m_buf_copy_metadata(&src_buf_info->m2m_buf.vb,
> &dst_buf_info->m2m_buf.vb, true);
> - get_vdec_decode_parameters(inst);
> + err = get_vdec_decode_parameters(inst);
> + if (err)
> + goto err_free_fb_out;
> +
> data[0] = bs->size;
> /*
> * Reconstruct the first byte of the NAL unit, as the firmware requests
