mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-09-30 22:26:55 +00:00
Code Issues Releases Wiki Activity

media: verisilicon: Conditionally ignore native formats

Browse source 
AV1 film grain feature requires to use the postprocessor to produce
valid frames. In such case the driver shouldn't propose native pixels
format but only post-processed pixels format.
Additionally if when setting a control a value could change capture
queue pixels formats it is needed to call hantro_reset_raw_fmt().

Signed-off-by: Benjamin Gaignard <benjamin.gaignard@collabora.com>
Reviewed-by: Nicolas Dufresne <nicolas.dufresne@collabora.com>
Signed-off-by: Hans Verkuil <hverkuil-cisco@xs4all.nl>
Signed-off-by: Mauro Carvalho Chehab <mchehab@kernel.org>
This commit is contained in:
Benjamin Gaignard 2023-05-03 09:34:38 +01:00 committed by Mauro Carvalho Chehab
parent 003afda97c
commit 80c7373a45
5 changed files with 63 additions and 25 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
drivers/media/platform/verisilicon/hantro.h
View file

@ -231,6 +231,8 @@ struct hantro_dev {
* @ctrl_handler: Control handler used to register controls. * @ctrl_handler: Control handler used to register controls.
* @jpeg_quality: User-specified JPEG compression quality. * @jpeg_quality: User-specified JPEG compression quality.
* @bit_depth: Bit depth of current frame * @bit_depth: Bit depth of current frame
* @need_postproc: Set to true if the bitstream features require to
* use the post-processor.
* *
* @codec_ops: Set of operations related to codec mode. * @codec_ops: Set of operations related to codec mode.
* @postproc: Post-processing context. * @postproc: Post-processing context.
@ -261,6 +263,7 @@ struct hantro_ctx {
const struct hantro_codec_ops *codec_ops; const struct hantro_codec_ops *codec_ops;
struct hantro_postproc_ctx postproc; struct hantro_postproc_ctx postproc;
bool need_postproc;
/* Specific for particular codec modes. */ /* Specific for particular codec modes. */
union { union {

14
drivers/media/platform/verisilicon/hantro_drv.c
View file

@ -319,7 +319,7 @@ static int hantro_vp9_s_ctrl(struct v4l2_ctrl *ctrl)
if (ctx->bit_depth == bit_depth) if (ctx->bit_depth == bit_depth)
return 0; return 0;
return hantro_reset_raw_fmt(ctx, bit_depth); return hantro_reset_raw_fmt(ctx, bit_depth, HANTRO_AUTO_POSTPROC);
} }
default: default:
return -EINVAL; return -EINVAL;
@ -343,7 +343,7 @@ static int hantro_hevc_s_ctrl(struct v4l2_ctrl *ctrl)
if (ctx->bit_depth == bit_depth) if (ctx->bit_depth == bit_depth)
return 0; return 0;
return hantro_reset_raw_fmt(ctx, bit_depth); return hantro_reset_raw_fmt(ctx, bit_depth, HANTRO_AUTO_POSTPROC);
} }
default: default:
return -EINVAL; return -EINVAL;
@ -363,11 +363,17 @@ static int hantro_av1_s_ctrl(struct v4l2_ctrl *ctrl)
case V4L2_CID_STATELESS_AV1_SEQUENCE: case V4L2_CID_STATELESS_AV1_SEQUENCE:
{ {
int bit_depth = ctrl->p_new.p_av1_sequence->bit_depth; int bit_depth = ctrl->p_new.p_av1_sequence->bit_depth;
bool need_postproc = HANTRO_AUTO_POSTPROC;
if (ctx->bit_depth == bit_depth) if (ctrl->p_new.p_av1_sequence->flags
& V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT)
need_postproc = HANTRO_FORCE_POSTPROC;
if (ctx->bit_depth == bit_depth &&
ctx->need_postproc == need_postproc)
return 0; return 0;
return hantro_reset_raw_fmt(ctx, bit_depth); return hantro_reset_raw_fmt(ctx, bit_depth, need_postproc);
} }
default: default:
return -EINVAL; return -EINVAL;

6
drivers/media/platform/verisilicon/hantro_postproc.c
View file

@ -57,6 +57,10 @@ bool hantro_needs_postproc(const struct hantro_ctx *ctx,
{ {
if (ctx->is_encoder) if (ctx->is_encoder)
return false; return false;
if (ctx->need_postproc)
return true;
return fmt->postprocessed; return fmt->postprocessed;
} }
@ -197,7 +201,7 @@ int hantro_postproc_alloc(struct hantro_ctx *ctx)
unsigned int i, buf_size; unsigned int i, buf_size;
/* this should always pick native format */ /* this should always pick native format */
fmt = hantro_get_default_fmt(ctx, false, ctx->bit_depth); fmt = hantro_get_default_fmt(ctx, false, ctx->bit_depth, HANTRO_AUTO_POSTPROC);
if (!fmt) if (!fmt)
return -EINVAL; return -EINVAL;
v4l2_fill_pixfmt_mp(&pix_mp, fmt->fourcc, ctx->src_fmt.width, v4l2_fill_pixfmt_mp(&pix_mp, fmt->fourcc, ctx->src_fmt.width,

57
drivers/media/platform/verisilicon/hantro_v4l2.c
View file

@ -31,15 +31,21 @@
#define HANTRO_DEFAULT_BIT_DEPTH 8 #define HANTRO_DEFAULT_BIT_DEPTH 8
static int hantro_set_fmt_out(struct hantro_ctx *ctx, static int hantro_set_fmt_out(struct hantro_ctx *ctx,
struct v4l2_pix_format_mplane *pix_mp); struct v4l2_pix_format_mplane *pix_mp,
bool need_postproc);
static int hantro_set_fmt_cap(struct hantro_ctx *ctx, static int hantro_set_fmt_cap(struct hantro_ctx *ctx,
struct v4l2_pix_format_mplane *pix_mp); struct v4l2_pix_format_mplane *pix_mp);
static const struct hantro_fmt * static const struct hantro_fmt *
hantro_get_formats(const struct hantro_ctx *ctx, unsigned int *num_fmts) hantro_get_formats(const struct hantro_ctx *ctx, unsigned int *num_fmts, bool need_postproc)
{ {
const struct hantro_fmt *formats; const struct hantro_fmt *formats;
if (need_postproc) {
*num_fmts = 0;
return NULL;
}
if (ctx->is_encoder) { if (ctx->is_encoder) {
formats = ctx->dev->variant->enc_fmts; formats = ctx->dev->variant->enc_fmts;
*num_fmts = ctx->dev->variant->num_enc_fmts; *num_fmts = ctx->dev->variant->num_enc_fmts;
@ -108,7 +114,7 @@ hantro_find_format(const struct hantro_ctx *ctx, u32 fourcc)
const struct hantro_fmt *formats; const struct hantro_fmt *formats;
unsigned int i, num_fmts; unsigned int i, num_fmts;
formats = hantro_get_formats(ctx, &num_fmts); formats = hantro_get_formats(ctx, &num_fmts, HANTRO_AUTO_POSTPROC);
for (i = 0; i < num_fmts; i++) for (i = 0; i < num_fmts; i++)
if (formats[i].fourcc == fourcc) if (formats[i].fourcc == fourcc)
return &formats[i]; return &formats[i];
@ -121,18 +127,28 @@ hantro_find_format(const struct hantro_ctx *ctx, u32 fourcc)
} }
const struct hantro_fmt * const struct hantro_fmt *
hantro_get_default_fmt(const struct hantro_ctx *ctx, bool bitstream, int bit_depth) hantro_get_default_fmt(const struct hantro_ctx *ctx, bool bitstream,
int bit_depth, bool need_postproc)
{ {
const struct hantro_fmt *formats; const struct hantro_fmt *formats;
unsigned int i, num_fmts; unsigned int i, num_fmts;
formats = hantro_get_formats(ctx, &num_fmts); formats = hantro_get_formats(ctx, &num_fmts, need_postproc);
for (i = 0; i < num_fmts; i++) { for (i = 0; i < num_fmts; i++) {
if (bitstream == (formats[i].codec_mode != if (bitstream == (formats[i].codec_mode !=
HANTRO_MODE_NONE) && HANTRO_MODE_NONE) &&
hantro_check_depth_match(&formats[i], bit_depth)) hantro_check_depth_match(&formats[i], bit_depth))
return &formats[i]; return &formats[i];
} }
formats = hantro_get_postproc_formats(ctx, &num_fmts);
for (i = 0; i < num_fmts; i++) {
if (bitstream == (formats[i].codec_mode !=
HANTRO_MODE_NONE) &&
hantro_check_depth_match(&formats[i], bit_depth))
return &formats[i];
}
return NULL; return NULL;
} }
@ -199,7 +215,7 @@ static int vidioc_enum_fmt(struct file *file, void *priv,
*/ */
skip_mode_none = capture == ctx->is_encoder; skip_mode_none = capture == ctx->is_encoder;
formats = hantro_get_formats(ctx, &num_fmts); formats = hantro_get_formats(ctx, &num_fmts, HANTRO_AUTO_POSTPROC);
for (i = 0; i < num_fmts; i++) { for (i = 0; i < num_fmts; i++) {
bool mode_none = formats[i].codec_mode == HANTRO_MODE_NONE; bool mode_none = formats[i].codec_mode == HANTRO_MODE_NONE;
fmt = &formats[i]; fmt = &formats[i];
@ -294,7 +310,7 @@ static int hantro_try_fmt(const struct hantro_ctx *ctx,
fmt = hantro_find_format(ctx, pix_mp->pixelformat); fmt = hantro_find_format(ctx, pix_mp->pixelformat);
if (!fmt) { if (!fmt) {
fmt = hantro_get_default_fmt(ctx, coded, HANTRO_DEFAULT_BIT_DEPTH); fmt = hantro_get_default_fmt(ctx, coded, HANTRO_DEFAULT_BIT_DEPTH, HANTRO_AUTO_POSTPROC);
pix_mp->pixelformat = fmt->fourcc; pix_mp->pixelformat = fmt->fourcc;
} }
@ -383,7 +399,7 @@ hantro_reset_encoded_fmt(struct hantro_ctx *ctx)
const struct hantro_fmt *vpu_fmt; const struct hantro_fmt *vpu_fmt;
struct v4l2_pix_format_mplane fmt; struct v4l2_pix_format_mplane fmt;
vpu_fmt = hantro_get_default_fmt(ctx, true, HANTRO_DEFAULT_BIT_DEPTH); vpu_fmt = hantro_get_default_fmt(ctx, true, HANTRO_DEFAULT_BIT_DEPTH, HANTRO_AUTO_POSTPROC);
if (!vpu_fmt) if (!vpu_fmt)
return; return;
@ -393,17 +409,17 @@ hantro_reset_encoded_fmt(struct hantro_ctx *ctx)
if (ctx->is_encoder) if (ctx->is_encoder)
hantro_set_fmt_cap(ctx, &fmt); hantro_set_fmt_cap(ctx, &fmt);
else else
hantro_set_fmt_out(ctx, &fmt); hantro_set_fmt_out(ctx, &fmt, HANTRO_AUTO_POSTPROC);
} }
int int
hantro_reset_raw_fmt(struct hantro_ctx *ctx, int bit_depth) hantro_reset_raw_fmt(struct hantro_ctx *ctx, int bit_depth, bool need_postproc)
{ {
const struct hantro_fmt *raw_vpu_fmt; const struct hantro_fmt *raw_vpu_fmt;
struct v4l2_pix_format_mplane raw_fmt, *encoded_fmt; struct v4l2_pix_format_mplane raw_fmt, *encoded_fmt;
int ret; int ret;
raw_vpu_fmt = hantro_get_default_fmt(ctx, false, bit_depth); raw_vpu_fmt = hantro_get_default_fmt(ctx, false, bit_depth, need_postproc);
if (!raw_vpu_fmt) if (!raw_vpu_fmt)
return -EINVAL; return -EINVAL;
@ -418,12 +434,14 @@ hantro_reset_raw_fmt(struct hantro_ctx *ctx, int bit_depth)
raw_fmt.width = encoded_fmt->width; raw_fmt.width = encoded_fmt->width;
raw_fmt.height = encoded_fmt->height; raw_fmt.height = encoded_fmt->height;
if (ctx->is_encoder) if (ctx->is_encoder)
ret = hantro_set_fmt_out(ctx, &raw_fmt); ret = hantro_set_fmt_out(ctx, &raw_fmt, need_postproc);
else else
ret = hantro_set_fmt_cap(ctx, &raw_fmt); ret = hantro_set_fmt_cap(ctx, &raw_fmt);
if (!ret) if (!ret) {
ctx->bit_depth = bit_depth; ctx->bit_depth = bit_depth;
ctx->need_postproc = need_postproc;
}
return ret; return ret;
} }
@ -431,7 +449,7 @@ hantro_reset_raw_fmt(struct hantro_ctx *ctx, int bit_depth)
void hantro_reset_fmts(struct hantro_ctx *ctx) void hantro_reset_fmts(struct hantro_ctx *ctx)
{ {
hantro_reset_encoded_fmt(ctx); hantro_reset_encoded_fmt(ctx);
hantro_reset_raw_fmt(ctx, HANTRO_DEFAULT_BIT_DEPTH); hantro_reset_raw_fmt(ctx, HANTRO_DEFAULT_BIT_DEPTH, HANTRO_AUTO_POSTPROC);
} }
static void static void
@ -478,7 +496,8 @@ hantro_update_requires_hold_capture_buf(struct hantro_ctx *ctx, u32 fourcc)
} }
static int hantro_set_fmt_out(struct hantro_ctx *ctx, static int hantro_set_fmt_out(struct hantro_ctx *ctx,
struct v4l2_pix_format_mplane *pix_mp) struct v4l2_pix_format_mplane *pix_mp,
bool need_postproc)
{ {
struct vb2_queue *vq; struct vb2_queue *vq;
int ret; int ret;
@ -531,7 +550,9 @@ static int hantro_set_fmt_out(struct hantro_ctx *ctx,
* changes to the raw format. * changes to the raw format.
*/ */
if (!ctx->is_encoder) if (!ctx->is_encoder)
hantro_reset_raw_fmt(ctx, hantro_get_format_depth(pix_mp->pixelformat)); hantro_reset_raw_fmt(ctx,
hantro_get_format_depth(pix_mp->pixelformat),
need_postproc);
/* Colorimetry information are always propagated. */ /* Colorimetry information are always propagated. */
ctx->dst_fmt.colorspace = pix_mp->colorspace; ctx->dst_fmt.colorspace = pix_mp->colorspace;
@ -594,7 +615,7 @@ static int hantro_set_fmt_cap(struct hantro_ctx *ctx,
* changes to the raw format. * changes to the raw format.
*/ */
if (ctx->is_encoder) if (ctx->is_encoder)
hantro_reset_raw_fmt(ctx, HANTRO_DEFAULT_BIT_DEPTH); hantro_reset_raw_fmt(ctx, HANTRO_DEFAULT_BIT_DEPTH, HANTRO_AUTO_POSTPROC);
/* Colorimetry information are always propagated. */ /* Colorimetry information are always propagated. */
ctx->src_fmt.colorspace = pix_mp->colorspace; ctx->src_fmt.colorspace = pix_mp->colorspace;
@ -614,7 +635,7 @@ static int hantro_set_fmt_cap(struct hantro_ctx *ctx,
static int static int
vidioc_s_fmt_out_mplane(struct file *file, void *priv, struct v4l2_format *f) vidioc_s_fmt_out_mplane(struct file *file, void *priv, struct v4l2_format *f)
{ {
return hantro_set_fmt_out(fh_to_ctx(priv), &f->fmt.pix_mp); return hantro_set_fmt_out(fh_to_ctx(priv), &f->fmt.pix_mp, HANTRO_AUTO_POSTPROC);
} }
static int static int

8
drivers/media/platform/verisilicon/hantro_v4l2.h
View file

@ -18,13 +18,17 @@
#include "hantro.h" #include "hantro.h"
#define HANTRO_FORCE_POSTPROC true
#define HANTRO_AUTO_POSTPROC false
extern const struct v4l2_ioctl_ops hantro_ioctl_ops; extern const struct v4l2_ioctl_ops hantro_ioctl_ops;
extern const struct vb2_ops hantro_queue_ops; extern const struct vb2_ops hantro_queue_ops;
int hantro_reset_raw_fmt(struct hantro_ctx *ctx, int bit_depth); int hantro_reset_raw_fmt(struct hantro_ctx *ctx, int bit_depth, bool need_postproc);
void hantro_reset_fmts(struct hantro_ctx *ctx); void hantro_reset_fmts(struct hantro_ctx *ctx);
int hantro_get_format_depth(u32 fourcc); int hantro_get_format_depth(u32 fourcc);
const struct hantro_fmt * const struct hantro_fmt *
hantro_get_default_fmt(const struct hantro_ctx *ctx, bool bitstream, int bit_depth); hantro_get_default_fmt(const struct hantro_ctx *ctx, bool bitstream,
int bit_depth, bool need_postproc);
#endif /* HANTRO_V4L2_H_ */ #endif /* HANTRO_V4L2_H_ */