media: mediatek: vcodec: decoder: Embed framesize inside mtk_video_fmt

Right now the decoder maintains two separate lists for supported pixel
formats and frame sizes. Getting the supported frame sizes for the
current set format is a bit convoluted, requiring a search through
the separate frame size list. The frame sizes are used to clamp and
align requested resolutions.

Instead, the frame size structure could be embedded inside the pixel
format structure. Getting one also gets the other. And since the
the driver already keeps pointers to the current set format, getting
the frame sizes becomes straightforward.

Do just that. Move v4l2_frmsize_stepwise inside mtk_video_fmt, and get
rid of mtk_codec_framesizes.

Signed-off-by: Chen-Yu Tsai <[e-mail]>
Tested-by: AngeloGioacchino Del Regno <[e-mail]>
Signed-off-by: Hans Verkuil <[e-mail]>
Signed-off-by: Mauro Carvalho Chehab <[e-mail]>

drivers/media/platform/mediatek/vcodec/mtk_vcodec_dec.c

···
 	}
 }
 
-static const struct v4l2_frmsize_stepwise *mtk_vdec_get_frmsize(struct mtk_vcodec_ctx *ctx,
-								u32 pixfmt)
-{
-	const struct mtk_vcodec_dec_pdata *dec_pdata = ctx->dev->vdec_pdata;
-	int i;
-
-	for (i = 0; i < *dec_pdata->num_framesizes; ++i)
-		if (pixfmt == dec_pdata->vdec_framesizes[i].fourcc)
-			return &dec_pdata->vdec_framesizes[i].stepwise;
-
-	/*
-	 * This should never happen since vidioc_try_fmt_vid_out_mplane()
-	 * always passes through a valid format for the output side, and
-	 * for the capture side, a valid output format should already have
-	 * been set.
-	 */
-	WARN_ONCE(1, "Unsupported format requested.\n");
-	return &dec_pdata->vdec_framesizes[0].stepwise;
-}
-
 static int vidioc_try_fmt(struct mtk_vcodec_ctx *ctx, struct v4l2_format *f,
 			  const struct mtk_video_fmt *fmt)
 {
 	struct v4l2_pix_format_mplane *pix_fmt_mp = &f->fmt.pix_mp;
 	const struct v4l2_frmsize_stepwise *frmsize;
-	u32 fourcc;
 
 	pix_fmt_mp->field = V4L2_FIELD_NONE;
 
 	/* Always apply frame size constraints from the coded side */
 	if (V4L2_TYPE_IS_OUTPUT(f->type))
-		fourcc = f->fmt.pix_mp.pixelformat;
+		frmsize = &fmt->frmsize;
 	else
-		fourcc = ctx->q_data[MTK_Q_DATA_SRC].fmt->fourcc;
+		frmsize = &ctx->q_data[MTK_Q_DATA_SRC].fmt->frmsize;
 
-	frmsize = mtk_vdec_get_frmsize(ctx, fourcc);
 	pix_fmt_mp->width = clamp(pix_fmt_mp->width, MTK_VDEC_MIN_W, frmsize->max_width);
 	pix_fmt_mp->height = clamp(pix_fmt_mp->height, MTK_VDEC_MIN_H, frmsize->max_height);
 
···
 	if (fsize->index != 0)
 		return -EINVAL;
 
-	for (i = 0; i < *dec_pdata->num_framesizes; ++i) {
-		if (fsize->pixel_format != dec_pdata->vdec_framesizes[i].fourcc)
+	for (i = 0; i < *dec_pdata->num_formats; i++) {
+		if (fsize->pixel_format != dec_pdata->vdec_formats[i].fourcc)
 			continue;
 
+		/* Only coded formats have frame sizes set */
+		if (!dec_pdata->vdec_formats[i].frmsize.max_width)
+			return -ENOTTY;
+
 		fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
-		fsize->stepwise = dec_pdata->vdec_framesizes[i].stepwise;
+		fsize->stepwise = dec_pdata->vdec_formats[i].frmsize;
 
 		mtk_v4l2_debug(1, "%x, %d %d %d %d %d %d",
 				ctx->dev->dec_capability,

drivers/media/platform/mediatek/vcodec/mtk_vcodec_dec_stateful.c

···
 		.type = MTK_FMT_DEC,
 		.num_planes = 1,
 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
+		.frmsize = { MTK_VDEC_MIN_W, MTK_VDEC_MAX_W, 16,
+			     MTK_VDEC_MIN_H, MTK_VDEC_MAX_H, 16 },
 	},
 	{
 		.fourcc = V4L2_PIX_FMT_VP8,
 		.type = MTK_FMT_DEC,
 		.num_planes = 1,
 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
+		.frmsize = { MTK_VDEC_MIN_W, MTK_VDEC_MAX_W, 16,
+			     MTK_VDEC_MIN_H, MTK_VDEC_MAX_H, 16 },
 	},
 	{
 		.fourcc = V4L2_PIX_FMT_VP9,
 		.type = MTK_FMT_DEC,
 		.num_planes = 1,
 		.flags = V4L2_FMT_FLAG_DYN_RESOLUTION,
+		.frmsize = { MTK_VDEC_MIN_W, MTK_VDEC_MAX_W, 16,
+			     MTK_VDEC_MIN_H, MTK_VDEC_MAX_H, 16 },
 	},
 	{
 		.fourcc = V4L2_PIX_FMT_MT21C,
···
 
 #define DEFAULT_OUT_FMT_IDX 0
 #define DEFAULT_CAP_FMT_IDX 3
-
-static const struct mtk_codec_framesizes mtk_vdec_framesizes[] = {
-	{
-		.fourcc = V4L2_PIX_FMT_H264,
-		.stepwise = { MTK_VDEC_MIN_W, MTK_VDEC_MAX_W, 16,
-			      MTK_VDEC_MIN_H, MTK_VDEC_MAX_H, 16 },
-	},
-	{
-		.fourcc = V4L2_PIX_FMT_VP8,
-		.stepwise = { MTK_VDEC_MIN_W, MTK_VDEC_MAX_W, 16,
-			      MTK_VDEC_MIN_H, MTK_VDEC_MAX_H, 16 },
-	},
-	{
-		.fourcc = V4L2_PIX_FMT_VP9,
-		.stepwise = { MTK_VDEC_MIN_W, MTK_VDEC_MAX_W, 16,
-			      MTK_VDEC_MIN_H, MTK_VDEC_MAX_H, 16 },
-	},
-};
-
-static const unsigned int num_supported_framesize =
-	ARRAY_SIZE(mtk_vdec_framesizes);
 
 /*
  * This function tries to clean all display buffers, the buffers will return
···
 	.num_formats = &num_supported_formats,
 	.default_out_fmt = &mtk_video_formats[DEFAULT_OUT_FMT_IDX],
 	.default_cap_fmt = &mtk_video_formats[DEFAULT_CAP_FMT_IDX],
-	.vdec_framesizes = mtk_vdec_framesizes,
-	.num_framesizes = &num_supported_framesize,
 	.worker = mtk_vdec_worker,
 	.flush_decoder = mtk_vdec_flush_decoder,
 	.is_subdev_supported = false,

drivers/media/platform/mediatek/vcodec/mtk_vcodec_dec_stateless.c

···
 #define NUM_CTRLS ARRAY_SIZE(mtk_stateless_controls)
 
 static struct mtk_video_fmt mtk_video_formats[5];
-static struct mtk_codec_framesizes mtk_vdec_framesizes[3];
 
 static struct mtk_video_fmt default_out_format;
 static struct mtk_video_fmt default_cap_format;
 static unsigned int num_formats;
-static unsigned int num_framesizes;
 
 static const struct v4l2_frmsize_stepwise stepwise_fhd = {
 	.min_width = MTK_VDEC_MIN_W,
···
 	struct mtk_vcodec_dev *dev = ctx->dev;
 	const struct mtk_vcodec_dec_pdata *pdata = dev->vdec_pdata;
 	int count_formats = *pdata->num_formats;
-	int count_framesizes = *pdata->num_framesizes;
 
 	switch (fourcc) {
 	case V4L2_PIX_FMT_H264_SLICE:
···
 		mtk_video_formats[count_formats].fourcc = fourcc;
 		mtk_video_formats[count_formats].type = MTK_FMT_DEC;
 		mtk_video_formats[count_formats].num_planes = 1;
+		mtk_video_formats[count_formats].frmsize = stepwise_fhd;
 
-		mtk_vdec_framesizes[count_framesizes].fourcc = fourcc;
-		mtk_vdec_framesizes[count_framesizes].stepwise = stepwise_fhd;
 		if (!(ctx->dev->dec_capability & VCODEC_CAPABILITY_4K_DISABLED) &&
 		    fourcc != V4L2_PIX_FMT_VP8_FRAME) {
-			mtk_vdec_framesizes[count_framesizes].stepwise.max_width =
+			mtk_video_formats[count_formats].frmsize.max_width =
 				VCODEC_DEC_4K_CODED_WIDTH;
-			mtk_vdec_framesizes[count_framesizes].stepwise.max_height =
+			mtk_video_formats[count_formats].frmsize.max_height =
 				VCODEC_DEC_4K_CODED_HEIGHT;
 		}
-		num_framesizes++;
 		break;
 	case V4L2_PIX_FMT_MM21:
 	case V4L2_PIX_FMT_MT21C:
···
 	}
 
 	num_formats++;
-	mtk_v4l2_debug(3, "num_formats: %d num_frames:%d dec_capability: 0x%x",
-		       count_formats, count_framesizes, ctx->dev->dec_capability);
+	mtk_v4l2_debug(3, "num_formats: %d dec_capability: 0x%x",
+		       count_formats, ctx->dev->dec_capability);
 }
 
 static void mtk_vcodec_get_supported_formats(struct mtk_vcodec_ctx *ctx)
 {
 	int cap_format_count = 0, out_format_count = 0;
 
-	if (num_formats && num_framesizes)
+	if (num_formats)
 		return;
 
 	if (ctx->dev->dec_capability & MTK_VDEC_FORMAT_MM21) {
···
 	.num_formats = &num_formats,
 	.default_out_fmt = &default_out_format,
 	.default_cap_fmt = &default_cap_format,
-	.vdec_framesizes = mtk_vdec_framesizes,
-	.num_framesizes = &num_framesizes,
 	.uses_stateless_api = true,
 	.worker = mtk_vdec_worker,
 	.flush_decoder = mtk_vdec_flush_decoder,
···
 	.num_formats = &num_formats,
 	.default_out_fmt = &default_out_format,
 	.default_cap_fmt = &default_cap_format,
-	.vdec_framesizes = mtk_vdec_framesizes,
-	.num_framesizes = &num_framesizes,
 	.uses_stateless_api = true,
 	.worker = mtk_vdec_worker,
 	.flush_decoder = mtk_vdec_flush_decoder,
···
 	.num_formats = &num_formats,
 	.default_out_fmt = &default_out_format,
 	.default_cap_fmt = &default_cap_format,
-	.vdec_framesizes = mtk_vdec_framesizes,
-	.num_framesizes = &num_framesizes,
 	.uses_stateless_api = true,
 	.worker = mtk_vdec_worker,
 	.flush_decoder = mtk_vdec_flush_decoder,

drivers/media/platform/mediatek/vcodec/mtk_vcodec_drv.h

···
 	enum mtk_fmt_type	type;
 	u32	num_planes;
 	u32	flags;
-};
-
-/*
- * struct mtk_codec_framesizes - Structure used to store information about
- *							framesizes
- */
-struct mtk_codec_framesizes {
-	u32	fourcc;
-	struct	v4l2_frmsize_stepwise	stepwise;
+	struct v4l2_frmsize_stepwise frmsize;
 };
 
 /*
···
  * @default_out_fmt: default output buffer format
  * @default_cap_fmt: default capture buffer format
  *
- * @vdec_framesizes: supported video decoder frame sizes
- * @num_framesizes: count of video decoder frame sizes
- *
  * @hw_arch: hardware arch is used to separate pure_sin_core and lat_sin_core
  *
  * @is_subdev_supported: whether support parent-node architecture(subdev)
···
 	const int *num_formats;
 	const struct mtk_video_fmt *default_out_fmt;
 	const struct mtk_video_fmt *default_cap_fmt;
-
-	const struct mtk_codec_framesizes *vdec_framesizes;
-	const int *num_framesizes;
 
 	enum mtk_vdec_hw_arch hw_arch;