[FFmpeg-devel] [PATCH] Add and use cli options for v4l2
hydra3333 at gmail.com
hydra3333 at gmail.com
Sat Mar 26 04:40:24 EET 2022
Oops, accidentally submitted with the wrong title so not in the right thread.
Is submitted with the right one now.
A re-submit of a re-base of a formerly proposed patch to align with ffmpeg github
commit 8ae15b565533944d042d3caf25f7262e002e8953
as at 2022.03.26 ACST, after ffmpeg changes overlapped the formerly proposed patch.
Add commandline options to v4l2_m2m_enc (h264_v4l2m2m only)
and use those to configure options for the h264_v4l2m2m encoder.
Uses AVOption options to filter for valid options per v4l2 spec.
For h264 it adds spec-compliant:
-profile <name> (high is max accepted by Raspberry Pi)
-level <name> (4.2 is max accepted by Raspberry Pi)
-rc <name> (Bitrate mode, VBR or CBR or CQ)
-shm <option> (Sequence Header Mode, separate_buffer or joined_1st_frame)
-rsh <boolean> (Repeat Sequence Header 0(false) 1(true))
-fsme (Frame Skip Mode for encoder, rejected by Pi OS)
-b:v <bps> (Bit per second)
-g <integer> (pseudo GOP size, not an actual one)
-iframe_period <integer> (the period between two I-frames)
-qmin <integer> (Minimum quantization parameter for h264)
-qmax <integer> (Maximum quantization parameter for h264)
Patch does not address pre-existing quirks with h264_v4l2m2m,
eg on a Raspberry Pi,
- Bitrate mode VBR, file is reported by mediainfo as CBR
- Bitrate mode CBR, encoder hangs and appears to
"lock" /dev/video11 until reboot
- CFR input yields a VFR file reported by mediainfo (and an
odd framerate) whereas an equivalent libx264 commandline
yields expected CFR; tested on a Raspberry Pi4
- Bitrate mode CBR, profile is limited to less than "high"
- Bitrate mode VBR, only target bitrate option exposed to set
- Bitrate mode CQ, is not exposed to set
Notes:
Patch arises from a desire to use ffmpeg on a Raspberry Pi (4 +).
Fixes "--profile high" not working (required an integer).
The Raspberry Pi OS does not expose a GOP size to set, so -g is
used for backward compatibility with its value overriding
the "close enough" effect of an "iframe_period" value.
Hardware like Raspberry Pi 4 rejects some spec-compliant options
beyond its capacity and/or not implemented by the Raspberry Pi OS.
The Raspberry Pi OS repository for ffmpeg appears to have Repeat
Sequence Header hard-coded as True, rather than a cli an option.
Added more return value checking, AV_LOG_WARNING and a lot
more AV_LOG_DEBUG code; one-time runtime cost of debug code
during init phase is negligible.
Intentionally left in //commented-out debug code.
A working commandline using an interlaced source:
/usr/local/bin/ffmpeg -hide_banner -nostats -v debug -i "~/Desktop/input_file_tiny.mp4" -vsync cfr -sws_flags
lanczos+accurate_rnd+full_chroma_int+full_chroma_inp -strict experimental -filter_complex "[0:v]yadif=0:0:0,format=pix_fmts=yuv420p"
-c:v h264_v4l2m2m -pix_fmt yuv420p -rc VBR -b:v 4000000 -qmin 10 -qmax 51 -profile:v high -level 4.2 -shm separate_buffer -rsh 0
-g:v 25 -movflags +faststart+write_colr -an -y "./output_file_tiny_h264_VBR_g25.mp4"
Signed-off-by: hydra3333 <hydra3333 at gmail.com <mailto:hydra3333 at gmail.com> >
---
libavcodec/v4l2_m2m.h | 12 +
libavcodec/v4l2_m2m_enc.c | 1013 ++++++++++++++++++++++++++++++++-----
2 files changed, 894 insertions(+), 131 deletions(-)
diff --git a/libavcodec/v4l2_m2m.h b/libavcodec/v4l2_m2m.h
index b67b216..c1ca837 100644
--- a/libavcodec/v4l2_m2m.h
+++ b/libavcodec/v4l2_m2m.h
@@ -76,6 +76,18 @@ typedef struct V4L2m2mPriv {
int num_output_buffers;
int num_capture_buffers;
+ /// h264 (mpeg4 part 10: AVC) add these to enable extra privately defined options (per V4L_M2M_h264_options) for h264 encoding
+ int h264_profile;
+ int h264_level;
+ int h264_video_bit_rate_mode;
+ int64_t h264_video_bit_rate;
+ int h264_qmin;
+ int h264_qmax;
+ int h264_sequence_header_mode;
+ _Bool h264_repeat_seq_header;
+ int h264_iframe_period; // overridden by h264_gop_size
+ int h264_gop_size; // if specified, overrides h264_iframe_period
+ int h264_frame_skip_mode_encoder;
} V4L2m2mPriv;
/**
diff --git a/libavcodec/v4l2_m2m_enc.c b/libavcodec/v4l2_m2m_enc.c
index 1d90de2..997c0be 100644
--- a/libavcodec/v4l2_m2m_enc.c
+++ b/libavcodec/v4l2_m2m_enc.c
@@ -1,4 +1,4 @@
-/*
+/**
* V4L2 mem2mem encoders
*
* Copyright (C) 2017 Alexis Ballier <aballier at gentoo.org <mailto:aballier at gentoo.org> >
@@ -38,37 +38,54 @@
#define MPEG_CID(x) V4L2_CID_MPEG_VIDEO_##x
#define MPEG_VIDEO(x) V4L2_MPEG_VIDEO_##x
-static inline void v4l2_set_timeperframe(V4L2m2mContext *s, unsigned int num, unsigned int den)
+static inline int v4l2_set_timeperframe(V4L2m2mContext *s, unsigned int num, unsigned int den)
{
+ /**
+ v4l2_streamparm, V4L2_TYPE_IS_MULTIPLANAR defined in linux/videodev2.h
+ */
struct v4l2_streamparm parm = { 0 };
-
+ int ret;
parm.type = V4L2_TYPE_IS_MULTIPLANAR(s->output.type) ? V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE : V4L2_BUF_TYPE_VIDEO_OUTPUT;
parm.parm.output.timeperframe.denominator = den;
parm.parm.output.timeperframe.numerator = num;
-
- if (ioctl(s->fd, VIDIOC_S_PARM, &parm) < 0)
- av_log(s->avctx, AV_LOG_WARNING, "Failed to set timeperframe");
+ av_log(s->avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m attempting to ioctl SET timeperframe; "
+ "denominator='%d' numerator='%d'\n", den, num);
+ ret = ioctl(s->fd, VIDIOC_S_PARM, &parm);
+ if (ret < 0) {
+ av_log(s->avctx, AV_LOG_ERROR,
+ "Encoder v4l2_m2m ERROR Failed to ioctl SET timeperframe; denominator='%d' numerator='%d' "
+ "ret='%d' errno='%d' error='%s'\n", den, num, ret, errno, strerror(errno));
+ return ret;
+ }
+ av_log(s->avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m ioctl SET timeperframe; "
+ "denominator='%d' numerator='%d'\n", den, num);
+ return 0;
}
-static inline void v4l2_set_ext_ctrl(V4L2m2mContext *s, unsigned int id, signed int value, const char *name, int log_warning)
+static inline int v4l2_set_ext_ctrl(V4L2m2mContext *s, unsigned int id, signed int value, const char *name, int log_warning)
{
struct v4l2_ext_controls ctrls = { { 0 } };
struct v4l2_ext_control ctrl = { 0 };
-
+ int ret;
/* set ctrls */
ctrls.ctrl_class = V4L2_CTRL_CLASS_MPEG;
ctrls.controls = &ctrl;
ctrls.count = 1;
-
/* set ctrl*/
ctrl.value = value;
ctrl.id = id;
- if (ioctl(s->fd, VIDIOC_S_EXT_CTRLS, &ctrls) < 0)
+ av_log(s->avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m attempting to ioctl SET '%s'='%d'\n", name, value);
+ ret = ioctl(s->fd, VIDIOC_S_EXT_CTRLS, &ctrls);
+ if (ret < 0) {
av_log(s->avctx, log_warning || errno != EINVAL ? AV_LOG_WARNING : AV_LOG_DEBUG,
- "Failed to set %s: %s\n", name, strerror(errno));
- else
- av_log(s->avctx, AV_LOG_DEBUG, "Encoder: %s = %d\n", name, value);
+ "Encoder v4l2_m2m WARNING Failed to ioctl SET '%s'='%d' "
+ "ret='%d' errno='%d' warning='%s'\n",
+ name, value, ret, errno, strerror(errno));
+ } else {
+ av_log(s->avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m ioctl SET '%s'='%d'\n", name, value);
+ }
+ return ret;
}
static inline int v4l2_get_ext_ctrl(V4L2m2mContext *s, unsigned int id, signed int *value, const char *name, int log_warning)
@@ -76,50 +93,129 @@ static inline int v4l2_get_ext_ctrl(V4L2m2mContext *s, unsigned int id, signed i
struct v4l2_ext_controls ctrls = { { 0 } };
struct v4l2_ext_control ctrl = { 0 };
int ret;
-
/* set ctrls */
ctrls.ctrl_class = V4L2_CTRL_CLASS_MPEG;
ctrls.controls = &ctrl;
ctrls.count = 1;
-
/* set ctrl*/
ctrl.id = id ;
-
+ av_log(s->avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m attempting to ioctl GET '%s'\n", name);
ret = ioctl(s->fd, VIDIOC_G_EXT_CTRLS, &ctrls);
if (ret < 0) {
av_log(s->avctx, log_warning || errno != EINVAL ? AV_LOG_WARNING : AV_LOG_DEBUG,
- "Failed to get %s\n", name);
+ "Encoder v4l2_m2m WARNING Failed to ioctl GET '%s' "
+ "ret='%d' errno='%d' warning='%s'\n", name, ret, errno, strerror(errno));
return ret;
}
-
*value = ctrl.value;
-
+ av_log(s->avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m ioctl GET '%s'='%d'\n", name, ctrl.value);
return 0;
}
-static inline unsigned int v4l2_h264_profile_from_ff(int p)
+static inline int ff_h264_profile_from_v4l2_h264_profile(int p)
{
static const struct h264_profile {
- unsigned int ffmpeg_val;
- unsigned int v4l2_val;
+ int v4l2_val;
+ int ffmpeg_val;
+ /**
+ NOTE: V4L2_MPEG_VIDEO_H264_ profile constants from linux/v4l2_controls.h via linux/videodev2.h
+ */
} profile[] = {
- { FF_PROFILE_H264_CONSTRAINED_BASELINE, MPEG_VIDEO(H264_PROFILE_CONSTRAINED_BASELINE) },
- { FF_PROFILE_H264_HIGH_444_PREDICTIVE, MPEG_VIDEO(H264_PROFILE_HIGH_444_PREDICTIVE) },
- { FF_PROFILE_H264_HIGH_422_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_422_INTRA) },
- { FF_PROFILE_H264_HIGH_444_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_444_INTRA) },
- { FF_PROFILE_H264_HIGH_10_INTRA, MPEG_VIDEO(H264_PROFILE_HIGH_10_INTRA) },
- { FF_PROFILE_H264_HIGH_422, MPEG_VIDEO(H264_PROFILE_HIGH_422) },
- { FF_PROFILE_H264_BASELINE, MPEG_VIDEO(H264_PROFILE_BASELINE) },
- { FF_PROFILE_H264_EXTENDED, MPEG_VIDEO(H264_PROFILE_EXTENDED) },
- { FF_PROFILE_H264_HIGH_10, MPEG_VIDEO(H264_PROFILE_HIGH_10) },
- { FF_PROFILE_H264_MAIN, MPEG_VIDEO(H264_PROFILE_MAIN) },
- { FF_PROFILE_H264_HIGH, MPEG_VIDEO(H264_PROFILE_HIGH) },
+ { V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE, FF_PROFILE_H264_BASELINE },
+ { V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE, FF_PROFILE_H264_CONSTRAINED_BASELINE },
+ { V4L2_MPEG_VIDEO_H264_PROFILE_MAIN, FF_PROFILE_H264_MAIN },
+ { V4L2_MPEG_VIDEO_H264_PROFILE_HIGH, FF_PROFILE_H264_HIGH },
+ { V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10, FF_PROFILE_H264_HIGH_10 },
+ { V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422, FF_PROFILE_H264_HIGH_422 },
+ { V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_PREDICTIVE, FF_PROFILE_H264_HIGH_444_PREDICTIVE },
+ { V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10_INTRA, FF_PROFILE_H264_HIGH_10_INTRA },
+ { V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422_INTRA, FF_PROFILE_H264_HIGH_422_INTRA },
+ { V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_INTRA, FF_PROFILE_H264_HIGH_444 }, /* ? presumed match */
+ { V4L2_MPEG_VIDEO_H264_PROFILE_CAVLC_444_INTRA, FF_PROFILE_H264_CAVLC_444 }, /* ? presumed match */
+ { V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH, FF_PROFILE_H264_MULTIVIEW_HIGH },
+ { V4L2_MPEG_VIDEO_H264_PROFILE_STEREO_HIGH, FF_PROFILE_H264_STEREO_HIGH },
+ /**
+ { V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_BASELINE, FF_PROFILE_H264_SCALABLE_BASELINE },
+ { V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_HIGH, FF_PROFILE_H264_SCALABLE_HIGH },
+ { V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_HIGH_INTRA, FF_PROFILE_H264_SCALABLE_HIGH_INTRA },
+ { V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_HIGH, FF_PROFILE_H264_CONSTRAINED_HIGH },
+ */
};
int i;
-
for (i = 0; i < FF_ARRAY_ELEMS(profile); i++) {
- if (profile[i].ffmpeg_val == p)
- return profile[i].v4l2_val;
+ if (profile[i].v4l2_val == p)
+ return profile[i].ffmpeg_val;
+ }
+ return AVERROR(ENOENT);
+}
+
+static inline int ff_h264_level_from_v4l2_h264_level(int p)
+{
+ static const struct h264_level {
+ int v4l2_val;
+ int ffmpeg_val;
+ /**
+ V4L2_MPEG_VIDEO_H264_ profile constants from linux/v4l2_controls.h via linux/videodev2.h
+ NOTE: the table from libavcodec/h264_levels.c (not .h so we cannot include anything) :-
+ H.264 table A-1.
+ static const H264LevelDescriptor h264_levels[] = {
+ Name MaxMBPS MaxBR MinCR
+ | level_idc | MaxFS | MaxCPB | MaxMvsPer2Mb
+ | | cs3f | | MaxDpbMbs | | MaxVmvR | |
+ { "1", 10, 0, 1485, 99, 396, 64, 175, 64, 2, 0 },
+ { "1b", 11, 1, 1485, 99, 396, 128, 350, 64, 2, 0 },
+ { "1b", 9, 0, 1485, 99, 396, 128, 350, 64, 2, 0 },
+ { "1.1", 11, 0, 3000, 396, 900, 192, 500, 128, 2, 0 },
+ { "1.2", 12, 0, 6000, 396, 2376, 384, 1000, 128, 2, 0 },
+ { "1.3", 13, 0, 11880, 396, 2376, 768, 2000, 128, 2, 0 },
+ { "2", 20, 0, 11880, 396, 2376, 2000, 2000, 128, 2, 0 },
+ { "2.1", 21, 0, 19800, 792, 4752, 4000, 4000, 256, 2, 0 },
+ { "2.2", 22, 0, 20250, 1620, 8100, 4000, 4000, 256, 2, 0 },
+ { "3", 30, 0, 40500, 1620, 8100, 10000, 10000, 256, 2, 32 },
+ { "3.1", 31, 0, 108000, 3600, 18000, 14000, 14000, 512, 4, 16 },
+ { "3.2", 32, 0, 216000, 5120, 20480, 20000, 20000, 512, 4, 16 },
+ { "4", 40, 0, 245760, 8192, 32768, 20000, 25000, 512, 4, 16 },
+ { "4.1", 41, 0, 245760, 8192, 32768, 50000, 62500, 512, 2, 16 },
+ { "4.2", 42, 0, 522240, 8704, 34816, 50000, 62500, 512, 2, 16 },
+ { "5", 50, 0, 589824, 22080, 110400, 135000, 135000, 512, 2, 16 },
+ { "5.1", 51, 0, 983040, 36864, 184320, 240000, 240000, 512, 2, 16 },
+ { "5.2", 52, 0, 2073600, 36864, 184320, 240000, 240000, 512, 2, 16 },
+ { "6", 60, 0, 4177920, 139264, 696320, 240000, 240000, 8192, 2, 16 },
+ { "6.1", 61, 0, 8355840, 139264, 696320, 480000, 480000, 8192, 2, 16 },
+ { "6.2", 62, 0, 16711680, 139264, 696320, 800000, 800000, 8192, 2, 16 },
+ };
+ NOTE mediainfo uses Android.Media.MediaCodecProfileLevel anmd they are different :(
+ https://developer.android.com/reference/android/media/MediaCodecInfo.CodecProfileLevel
+ */
+ } level[] = {
+ /**
+ hard-coded libx264 FF numbers since no .h currently has them
+ */
+ { V4L2_MPEG_VIDEO_H264_LEVEL_1_0, 10 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_1B, 11 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_1_1, 11 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_1_2, 12 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_1_3, 13 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_2_0, 20 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_2_1, 21 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_2_2, 22 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_3_0, 30 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_3_1, 31 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_3_2, 32 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_4_0, 40 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_4_1, 41 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_4_2, 42 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_5_0, 50 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_5_1, 51 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_5_2, 52 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_6_0, 60 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_6_1, 61 },
+ { V4L2_MPEG_VIDEO_H264_LEVEL_6_2, 62 },
+ };
+ int i;
+ for (i = 0; i < FF_ARRAY_ELEMS(level); i++) {
+ if (level[i].v4l2_val == p)
+ return level[i].ffmpeg_val;
}
return AVERROR(ENOENT);
}
@@ -147,140 +243,485 @@ static inline int v4l2_mpeg4_profile_from_ff(int p)
static int v4l2_check_b_frame_support(V4L2m2mContext *s)
{
+ av_log(s->avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m attempting v4l2_check_b_frame_support "
+ "attempting to ioctl GET number of b-frames\n");
+ /**
+ https://github.com/raspberrypi/linux/issues/4917#issuecomment-1058120137
+ B frames are not supported, and only 1 reference frame is ever used.
+ */
if (s->avctx->max_b_frames)
- av_log(s->avctx, AV_LOG_WARNING, "Encoder does not support b-frames yet\n");
-
- v4l2_set_ext_ctrl(s, MPEG_CID(B_FRAMES), 0, "number of B-frames", 0);
- v4l2_get_ext_ctrl(s, MPEG_CID(B_FRAMES), &s->avctx->max_b_frames, "number of B-frames", 0);
- if (s->avctx->max_b_frames == 0)
+ av_log(s->avctx, AV_LOG_WARNING, "Encoder v4l2_m2m WARNING does not support b-frames for V4L2 encoding\n");
+ v4l2_set_ext_ctrl(s, MPEG_CID(B_FRAMES), 0, "number of B-frames", 1);
+ v4l2_get_ext_ctrl(s, MPEG_CID(B_FRAMES), &s->avctx->max_b_frames, "number of B-frames", 1);
+ if (s->avctx->max_b_frames == 0) {
return 0;
-
- avpriv_report_missing_feature(s->avctx, "DTS/PTS calculation for V4L2 encoding");
-
+ }
+ /* ??? was: avpriv_report_missing_feature(s->avctx, "Encoder DTS/PTS calculation for V4L2 encoding"); */
+ avpriv_report_missing_feature(s->avctx, "Encoder v4l2_m2m does not support b-frames for V4L2 encoding\n");
return AVERROR_PATCHWELCOME;
}
-static inline void v4l2_subscribe_eos_event(V4L2m2mContext *s)
+static int v4l2_subscribe_eos_event(V4L2m2mContext *s)
{
struct v4l2_event_subscription sub;
-
+ int ret;
+ av_log(s->avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m v4l2_subscribe_eos_event attempting to "
+ "ioctl VIDIOC_SUBSCRIBE_EVENT\n");
memset(&sub, 0, sizeof(sub));
sub.type = V4L2_EVENT_EOS;
- if (ioctl(s->fd, VIDIOC_SUBSCRIBE_EVENT, &sub) < 0)
- av_log(s->avctx, AV_LOG_WARNING,
- "the v4l2 driver does not support end of stream VIDIOC_SUBSCRIBE_EVENT\n");
+ ret = (ioctl(s->fd, VIDIOC_SUBSCRIBE_EVENT, &sub));
+ if (ret < 0) {
+ av_log(s->avctx, AV_LOG_ERROR,
+ "Encoder v4l2_m2m the v4l2 driver does not support end of stream VIDIOC_SUBSCRIBE_EVENT\n");
+ return ret;
+ }
+ return 0;
}
static int v4l2_prepare_encoder(V4L2m2mContext *s)
{
AVCodecContext *avctx = s->avctx;
+ V4L2m2mPriv *priv = avctx->priv_data; /* for per-codec private options; eg h264_profile etc when h264 */
int qmin_cid, qmax_cid, qmin, qmax;
- int ret, val;
-
+ int ret, val, ival;
/**
* requirements
*/
- v4l2_subscribe_eos_event(s);
-
+ ret = v4l2_subscribe_eos_event(s);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR failed to v4l2_subscribe_eos_event, "
+ "return code ret=(%d) errno=(%d) error='%s'\n",
+ ret, errno, strerror(errno));
+ return AVERROR(EINVAL);
+ }
+ /**
+ https://github.com/raspberrypi/linux/issues/4917#issuecomment-1058120137
+ B frames are not supported, and only 1 reference frame is ever used.
+ */
ret = v4l2_check_b_frame_support(s);
- if (ret)
- return ret;
-
+ if (ret) {
+ av_log(avctx, AV_LOG_WARNING, "Encoder v4l2_m2m WARNING this encoder does not support b-frames") ;
+ ///return ret;
+ }
+ av_log(s->avctx, AV_LOG_WARNING, "Encoder v4l2_m2m WARNING some hardware encoders do not support "
+ "Frame Level Rate Control for V4L2 encoding; FLRC ignored.\n");
+ /*
+ ret = v4l2_set_ext_ctrl(s, MPEG_CID(FRAME_RC_ENABLE), 0,
+ "frame level rate control", 1); /// 1=enable, 0=disable; always disable(0)
+ if (ret) {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m failed to globally disable frame level rate "
+ "control is OK. ret=(%d) errno=(%d) error='%s'\n", ret, errno, strerror(errno));
+ ///return AVERROR(EINVAL);
+ }
+ */
/**
- * settingss
+ Codec-specific processing, eg h264, mpeg4, hevc(hevc), h263, vp8.
+ Code is repeated but not always identical in each block, to ensure flexibility
+ at the expense of dupication and elegance; some people don't like that.
*/
- if (avctx->framerate.num || avctx->framerate.den)
- v4l2_set_timeperframe(s, avctx->framerate.den, avctx->framerate.num);
-
- /* set ext ctrls */
- v4l2_set_ext_ctrl(s, MPEG_CID(HEADER_MODE), MPEG_VIDEO(HEADER_MODE_SEPARATE), "header mode", 0);
- v4l2_set_ext_ctrl(s, MPEG_CID(BITRATE) , avctx->bit_rate, "bit rate", 1);
- v4l2_set_ext_ctrl(s, MPEG_CID(FRAME_RC_ENABLE), 1, "frame level rate control", 0);
- v4l2_set_ext_ctrl(s, MPEG_CID(GOP_SIZE), avctx->gop_size,"gop size", 1);
-
- av_log(avctx, AV_LOG_DEBUG,
- "Encoder Context: id (%d), profile (%d), frame rate(%d/%d), number b-frames (%d), "
- "gop size (%d), bit rate (%"PRId64"), qmin (%d), qmax (%d)\n",
- avctx->codec_id, avctx->profile, avctx->framerate.num, avctx->framerate.den,
- avctx->max_b_frames, avctx->gop_size, avctx->bit_rate, avctx->qmin, avctx->qmax);
-
switch (avctx->codec_id) {
case AV_CODEC_ID_H264:
- if (avctx->profile != FF_PROFILE_UNKNOWN) {
- val = v4l2_h264_profile_from_ff(avctx->profile);
- if (val < 0)
- av_log(avctx, AV_LOG_WARNING, "h264 profile not found\n");
- else
- v4l2_set_ext_ctrl(s, MPEG_CID(H264_PROFILE), val, "h264 profile", 1);
+ /**
+ By now, the h264-specific profile and level and mode have been automatically
+ translated via Option values into h264 numeric values understood by the driver.
+ see h264-specific options
+ Back-fill some context with FFmpeg constant values,
+ to be compatible with previous version of encoder
+ */
+ val = ff_h264_profile_from_v4l2_h264_profile(priv->h264_profile);
+ if (val < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR profile not translated to FF-h264: "
+ "profile not found (%d)\n",priv->h264_profile);
+ return AVERROR(EINVAL);
+ } else {
+ avctx->profile = val;
+ }
+ val = ff_h264_level_from_v4l2_h264_level(priv->h264_level);
+ if (val < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR level not translated to H.264 table A-1: "
+ "level not found (%d)\n",priv->h264_level);
+ return AVERROR(EINVAL);
+ } else {
+ avctx->level = val;
+ }
+ if (priv->h264_video_bit_rate_mode == V4L2_MPEG_VIDEO_BITRATE_MODE_CBR &&
+ priv->h264_profile == V4L2_MPEG_VIDEO_H264_PROFILE_HIGH) {
+ av_log(avctx, AV_LOG_WARNING, "Encoder v4l2_m2m WARNING h264_video_bit_rate_mode 'CBR' "
+ "and profile 'high' may not be compatible. Try profile 'main' if it fails.\n");
+ ///return AVERROR(EINVAL);
+ }
+ if (priv->h264_qmin > priv->h264_qmax) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR (h264_only) priv->h264_qmin:(%d) "
+ "must be <= h264_qmax (%d)\n", priv->h264_qmin, priv->h264_qmax);
+ return AVERROR(EINVAL);
+ }
+ if (priv->h264_gop_size > 0) {
+ priv->h264_iframe_period = priv->h264_gop_size;
+ } else { /* fill in missing gop with h264_iframe_period which has a valid default */
+ if (priv->h264_iframe_period >=0 ) {
+ priv->h264_gop_size = priv->h264_iframe_period;
+ }
+ }
+ avctx->gop_size = priv->h264_gop_size;
+ avctx->bit_rate = priv->h264_video_bit_rate;
+ avctx->qmin = priv->h264_qmin;
+ avctx->qmax = priv->h264_qmax;
+ /* Show retrieved Option values */
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m (global) codec_id:(%d)\n", avctx->codec_id);
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m (h264_only) priv->h264_profile:(%d)\n", priv->h264_profile);
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m (h264_only) priv->h264_level:(%d)\n", priv->h264_level);
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m (global) max_b_frames:(%d)\n", avctx->max_b_frames);
+ if (avctx->framerate.num || avctx->framerate.den) {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m (global) framerate.den:(%d)\n", avctx->framerate.den);
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m (global) framerate.num:(%d)\n", avctx->framerate.num);
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m (global) framerate.num:(%d/%d)\n", avctx->framerate.num,
+ avctx->framerate.den);
+ }
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m (h264_only) priv->h264_video_bit_rate_mode:(%d) "
+ "is one of VBR(%d) CBR(%d) CQ(%d)\n",
+ priv->h264_video_bit_rate_mode,
+ V4L2_MPEG_VIDEO_BITRATE_MODE_VBR, V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, V4L2_MPEG_VIDEO_BITRATE_MODE_CQ);
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m (h264_only) priv->h264_video_bit_rate:(%"PRId64")\n",
priv->h264_video_bit_rate);
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m (h264_only) priv->h264_qmin:(%d)\n", priv->h264_qmin);
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m (h264_only) priv->h264_qmax:(%d)\n", priv->h264_qmax);
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m (h264_only) priv->h264_sequence_header_mode:(%d)\n",
priv->h264_sequence_header_mode);
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m (h264_only) priv->h264_repeat_seq_header:(%d)\n",
priv->h264_repeat_seq_header);
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m (h264_only) priv->h264_iframe_period:(%d)\n", priv->h264_iframe_period);
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m (h264_only) priv->h264_gop_size:(%d)\n", priv->h264_gop_size);
+ if (avctx->framerate.num || avctx->framerate.den) {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m attempting to set timeperframe (%d/%d)\n",
+ avctx->framerate.num, avctx->framerate.den);
+ ret = v4l2_set_timeperframe(s, avctx->framerate.den, avctx->framerate.num);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR Failed to set timeperframe (%d/%d) "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ avctx->framerate.num, avctx->framerate.den, ret, errno, strerror(errno));
+ return errno;
+ } else {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m successfully set timeperframe (%d/%d)\n",
+ avctx->framerate.num, avctx->framerate.den);
+ }
+ }
+ ret = v4l2_set_ext_ctrl(s, MPEG_CID(H264_PROFILE), priv->h264_profile, "h264 profile", 1);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR failed to set h264_profile "
+ "(%d) ret=(%d) errno=(%d) error='%s'\n'high' is possibly the max h264 profile on this hardware\n",
+ priv->h264_profile, ret, errno, strerror(errno));
+ return AVERROR(EINVAL);
+ }
+ ret = v4l2_set_ext_ctrl(s, MPEG_CID(H264_LEVEL), priv->h264_level, "h264 Level", 1);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR failed to set h264_level (%d) "
+ "ret=(%d) errno=(%d) error='%s'\n'4.2' is possibly the max h264 level on this hardware\n",
+ priv->h264_level, ret, errno, strerror(errno));
+ return AVERROR(EINVAL);
+ }
+ ret = v4l2_set_ext_ctrl(s, MPEG_CID(BITRATE_MODE), priv->h264_video_bit_rate_mode,
+ "h264 Bitrate Mode, VBR(0) or CBR(1) or CQ(2)", 1);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR failed to set h264_video_bit_rate_mode (%d); "
+ "VBR=(%d) CBR=(%d) CQ=(%d) ret=(%d) errno=(%d) error='%s'\n",
+ priv->h264_video_bit_rate_mode,
+ V4L2_MPEG_VIDEO_BITRATE_MODE_VBR, V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, V4L2_MPEG_VIDEO_BITRATE_MODE_CQ,
+ ret, errno, strerror(errno));
+ return AVERROR(EINVAL);
+ }
+ /* cast to int64_t to (int) used by v4l2_set_ext_ctrl */
+ ret = v4l2_set_ext_ctrl(s, MPEG_CID(BITRATE), (int) priv->h264_video_bit_rate, "h264 Video Bitrate", 1);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR failed to set h264_video_bit_rate (%"PRId64") "
+ "ret=(%d) errno=(%d) error='%s'\n", priv->h264_video_bit_rate, ret, errno, strerror(errno));
+ return AVERROR(EINVAL);
+ }
+ /**
+ V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE
+ Indicates in what conditions the encoder should skip frames.
+ If encoding a frame would cause the encoded stream to be larger than
+ a chosen data limit then the frame will be skipped.
+ V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_DISABLED Frame skip mode is disabled.
+ */
+ if (priv->h264_frame_skip_mode_encoder != V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_DISABLED) {
+ av_log(avctx, AV_LOG_WARNING, "Encoder v4l2_m2m WARNING "
+ "frame skip mode for encoder set to NON-disabled (%d)\n",
+ priv->h264_frame_skip_mode_encoder);
+ } else {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m "
+ "frame skip mode for encoder set to disabled (%d)\n",
+ priv->h264_frame_skip_mode_encoder);
+ }
+ ret = v4l2_set_ext_ctrl(s, MPEG_CID(FRAME_SKIP_MODE), priv->h264_frame_skip_mode_encoder,
+ "frame skip mode for encoder", 1);
+ if (ret) {
+ av_log(avctx, AV_LOG_WARNING, "Encoder v4l2_m2m WARNING failed to set "
+ "frame skip mode for encoder (%d); ret=(%d) errno=(%d) error='%s'\n",
+ priv->h264_frame_skip_mode_encoder, ret, errno, strerror(errno));
+ ///return AVERROR(EINVAL);
+ }
+ ret = v4l2_set_ext_ctrl(s, MPEG_CID(HEADER_MODE), priv->h264_sequence_header_mode,
+ "sequence header mode", 1);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR failed to set h264_sequence_header_mode (%d) "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ priv->h264_sequence_header_mode, ret, errno, strerror(errno));
+ return AVERROR(EINVAL);
+ }
+ ret = v4l2_set_ext_ctrl(s, MPEG_CID(REPEAT_SEQ_HEADER), priv->h264_repeat_seq_header,
+ "repeat sequence header", 1); /* RPi repositories build with 1(True) */
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR failed to set h264_repeat_seq_header (%d) "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ priv->h264_repeat_seq_header, ret, errno, strerror(errno));
+ return AVERROR(EINVAL);
+ }
+ /**
+ h264_iframe_period instead of gop size per
+ https://github.com/raspberrypi/linux/issues/4917#issuecomment-1057977916
+ */
+ if (priv->h264_iframe_period >=0) {
+ ret = v4l2_set_ext_ctrl(s, MPEG_CID(H264_I_PERIOD), priv->h264_iframe_period,
+ "Period between I-frames", 1);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR failed to set h264_iframe_period(/gop) (%d) "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ priv->h264_iframe_period, ret, errno, strerror(errno));
+ return AVERROR(EINVAL);
+ }
+ } else {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR h264_iframe_period(/gop) "
+ "defaulted to not set (%d)\n",
+ priv->h264_iframe_period);
+ }
+ ret = v4l2_set_ext_ctrl(s, MPEG_CID(GOP_SIZE), avctx->gop_size, "h264 gop size", 1);
+ if (ret) {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m WARNING failed to set h264_gop_size (%d) "
+ "is OK (not used by driver anyway) ret=(%d) errno=(%d) error='%s'\n",
+ priv->h264_gop_size, ret, errno, strerror(errno));
+ ///return AVERROR(EINVAL);
+ }
+ ret = v4l2_set_ext_ctrl(s, MPEG_CID(H264_MIN_QP), priv->h264_qmin, "h264 Qmin", 1);
+ if (ret) {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m ERROR failed to set h264_qmin (%d) "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ priv->h264_qmin, ret, errno, strerror(errno));
+ return AVERROR(EINVAL);
+ }
+ ret = v4l2_set_ext_ctrl(s, MPEG_CID(H264_MAX_QP), priv->h264_qmax, "h264 Qmax", 1);
+ if (ret) {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m ERROR failed to set h264_qmax (%d) "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ priv->h264_qmax, ret, errno, strerror(errno));
+ return AVERROR(EINVAL);
}
- qmin_cid = MPEG_CID(H264_MIN_QP);
- qmax_cid = MPEG_CID(H264_MAX_QP);
- qmin = 0;
- qmax = 51;
break;
case AV_CODEC_ID_MPEG4:
+ if (avctx->framerate.num || avctx->framerate.den) {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m attempting to set timeperframe (%d/%d)\n",
+ avctx->framerate.num, avctx->framerate.den);
+ ret = v4l2_set_timeperframe(s, avctx->framerate.den, avctx->framerate.num);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR Failed to set timeperframe (%d/%d) "
+ "val=(%d) errno=(%d) error='%s'\n",
+ avctx->framerate.num, avctx->framerate.den, val, errno, strerror(errno));
+ return errno;
+ } else {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m successfully set timeperframe (%d/%d)\n",
+ avctx->framerate.num, avctx->framerate.den);
+ }
+ }
if (avctx->profile != FF_PROFILE_UNKNOWN) {
- val = v4l2_mpeg4_profile_from_ff(avctx->profile);
- if (val < 0)
- av_log(avctx, AV_LOG_WARNING, "mpeg4 profile not found\n");
- else
- v4l2_set_ext_ctrl(s, MPEG_CID(MPEG4_PROFILE), val, "mpeg4 profile", 1);
+ ival = v4l2_mpeg4_profile_from_ff(avctx->profile);
+ if (ival < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR mpeg4 profile not found/translated "
+ "from FF to V42L profile; FF=(%d)\n", avctx->profile);
+ return AVERROR(EINVAL);
+ } else {
+ ret = v4l2_set_ext_ctrl(s, MPEG_CID(MPEG4_PROFILE), ival, "mpeg4 profile", 1);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR Failed to set mpeg4 V42L profile (%d) "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ ival, ret, errno, strerror(errno));
+ return errno;
+ } else {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m successfully set mpeg4 profile (%d)\n", ival);
+ }
+ }
+ }
+ if (avctx->flags & AV_CODEC_FLAG_QPEL) {
+ ret = v4l2_set_ext_ctrl(s, MPEG_CID(MPEG4_QPEL), 1, "mpeg4 qpel", 1); /* hard-code 1 as ON */
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR failed to set mpeg4_qpel to 1 "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ ret, errno, strerror(errno));
+ return AVERROR(EINVAL);
+ }
+ } else {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m mpeg4_qpel flag not specified, ignored");
}
qmin_cid = MPEG_CID(MPEG4_MIN_QP);
qmax_cid = MPEG_CID(MPEG4_MAX_QP);
- if (avctx->flags & AV_CODEC_FLAG_QPEL)
- v4l2_set_ext_ctrl(s, MPEG_CID(MPEG4_QPEL), 1, "qpel", 1);
qmin = 1;
qmax = 31;
break;
+ case AV_CODEC_ID_HEVC:
+ if (avctx->framerate.num || avctx->framerate.den) {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m attempting to set timeperframe (%d/%d)\n",
+ avctx->framerate.num, avctx->framerate.den);
+ ret = v4l2_set_timeperframe(s, avctx->framerate.den, avctx->framerate.num);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR Failed to set timeperframe (%d/%d) "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ avctx->framerate.num, avctx->framerate.den, ret, errno, strerror(errno));
+ return errno;
+ } else {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m successfully set timeperframe (%d/%d)\n",
+ avctx->framerate.num, avctx->framerate.den);
+ }
+ }
+ /* no qmin/qmax processing for HEVC */
+ break;
case AV_CODEC_ID_H263:
+ if (avctx->framerate.num || avctx->framerate.den) {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m attempting to set timeperframe (%d/%d)\n",
+ avctx->framerate.num, avctx->framerate.den);
+ ret = v4l2_set_timeperframe(s, avctx->framerate.den, avctx->framerate.num);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR Failed to set timeperframe (%d/%d) "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ avctx->framerate.num, avctx->framerate.den, ret, errno, strerror(errno));
+ return errno;
+ } else {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m successfully set timeperframe (%d/%d)\n",
+ avctx->framerate.num, avctx->framerate.den);
+ }
+ }
qmin_cid = MPEG_CID(H263_MIN_QP);
qmax_cid = MPEG_CID(H263_MAX_QP);
qmin = 1;
qmax = 31;
break;
case AV_CODEC_ID_VP8:
+ if (avctx->framerate.num || avctx->framerate.den) {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m attempting to set timeperframe (%d/%d)\n",
+ avctx->framerate.num, avctx->framerate.den);
+ ret = v4l2_set_timeperframe(s, avctx->framerate.den, avctx->framerate.num);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR Failed to set timeperframe (%d/%d) "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ avctx->framerate.num, avctx->framerate.den, ret, errno, strerror(errno));
+ return errno;
+ } else {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m successfully set timeperframe (%d/%d)\n",
+ avctx->framerate.num, avctx->framerate.den);
+ }
+ }
qmin_cid = MPEG_CID(VPX_MIN_QP);
qmax_cid = MPEG_CID(VPX_MAX_QP);
qmin = 0;
qmax = 127;
break;
case AV_CODEC_ID_VP9:
+ if (avctx->framerate.num || avctx->framerate.den) {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m attempting to set timeperframe (%d/%d)\n",
+ avctx->framerate.num, avctx->framerate.den);
+ ret = v4l2_set_timeperframe(s, avctx->framerate.den, avctx->framerate.num);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR Failed to set timeperframe (%d/%d) "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ avctx->framerate.num, avctx->framerate.den, ret, errno, strerror(errno));
+ return errno;
+ } else {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m successfully set timeperframe (%d/%d)\n",
+ avctx->framerate.num, avctx->framerate.den);
+ }
+ }
qmin_cid = MPEG_CID(VPX_MIN_QP);
qmax_cid = MPEG_CID(VPX_MAX_QP);
qmin = 0;
qmax = 255;
break;
default:
- return 0;
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR UNRECOGNISED CODEC ID (%d)\n", avctx->codec_id);
+ return AVERROR(EINVAL);
}
- if (avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) {
- av_log(avctx, AV_LOG_WARNING, "Invalid qmin:%d qmax:%d. qmin should not "
- "exceed qmax\n", avctx->qmin, avctx->qmax);
- } else {
- qmin = avctx->qmin >= 0 ? avctx->qmin : qmin;
- qmax = avctx->qmax >= 0 ? avctx->qmax : qmax;
+ if ( /* common qmin/qmax does not apply to H264 (own processing) nor HEVC (per legacy code) */
+ avctx->codec_id == AV_CODEC_ID_MPEG4 ||
+ avctx->codec_id == AV_CODEC_ID_H263 ||
+ avctx->codec_id == AV_CODEC_ID_VP8 ||
+ avctx->codec_id == AV_CODEC_ID_VP9
+ ) {
+ if (avctx->qmin >= 0 && avctx->qmax >= 0 && avctx->qmin > avctx->qmax) {
+ av_log(avctx, AV_LOG_WARNING, "Invalid qmin:%d qmax:%d. qmin should not "
+ "exceed qmax\n", avctx->qmin, avctx->qmax);
+ } else {
+ qmin = avctx->qmin >= 0 ? avctx->qmin : qmin;
+ qmax = avctx->qmax >= 0 ? avctx->qmax : qmax;
+ }
+ ret = v4l2_set_ext_ctrl(s, qmin_cid, qmin, "minimum video quantizer scale",
+ avctx->qmin >= 0);
+ if (ret) {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m ERROR failed to set qmin (%d) "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ qmin, ret, errno, strerror(errno));
+ return AVERROR(EINVAL);
+ }
+ ret = v4l2_set_ext_ctrl(s, qmax_cid, qmax, "maximum video quantizer scale",
+ avctx->qmax >= 0);
+ if (ret) {
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m ERROR failed to set qmax (%d) "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ qmax, ret, errno, strerror(errno));
+ return AVERROR(EINVAL);
+ }
}
-
- v4l2_set_ext_ctrl(s, qmin_cid, qmin, "minimum video quantizer scale",
- avctx->qmin >= 0);
- v4l2_set_ext_ctrl(s, qmax_cid, qmax, "maximum video quantizer scale",
- avctx->qmax >= 0);
-
return 0;
}
static int v4l2_send_frame(AVCodecContext *avctx, const AVFrame *frame)
{
+ int ret;
+
V4L2m2mContext *s = ((V4L2m2mPriv*)avctx->priv_data)->context;
V4L2Context *const output = &s->output;
-
+ static const int Force_a_key_frame_for_the_next_queued_buffer = 0; /* not force for the next queued buffer */
#ifdef V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME
- if (frame && frame->pict_type == AV_PICTURE_TYPE_I)
- v4l2_set_ext_ctrl(s, MPEG_CID(FORCE_KEY_FRAME), 0, "force key frame", 1);
+ /**
+ https://www.kernel.org/doc/html/latest/userspace-api/media/v4l/ext-ctrls-codec.html
+ V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME (button)
+ When 1, Force a key frame for the next queued buffer.
+ When 0, do not Force a key frame for the next queued buffer.
+ */
+ if (frame && frame->pict_type == AV_PICTURE_TYPE_I) {
+ ret = v4l2_set_ext_ctrl(s, MPEG_CID(FORCE_KEY_FRAME), Force_a_key_frame_for_the_next_queued_buffer,
+ "force key frame (0=no, 1=yes)", 1);
+ if (ret) {
+ /*
+ av_log(avctx, AV_LOG_WARNING, "Encoder v4l2_m2m V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME is defined, "
+ "am processing an IFRAME, FAILED SET force a key frame for the next queued buffer as (0=off 1=on): %d "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ Force_a_key_frame_for_the_next_queued_buffer, ret, errno, strerror(errno));
+ ///return AVERROR(EINVAL);
+ */
+ } else {
+ /*
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME is defined, "
+ "am processing an IFRAME, successful SET force a key frame for the next queued buffer as (0=off 1=on): %d\n",
+ Force_a_key_frame_for_the_next_queued_buffer);
+ */
+ }
+ } else {
+ /*
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME is defined, "
+ "am NOT processing an IFRAME, hence did not set FORCE_KEY_FRAME for the next queued buffer\n");
+ */
+ }
+#endif
+#ifndef V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME
+ /*
+ av_log(avctx, AV_LOG_DEBUG, "Encoder v4l2_m2m V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME is not defined "
+ "... so NOT forcing a key frame for the next queued buffer even if we wanted to.\n");
+ */
#endif
-
return ff_v4l2_context_enqueue_frame(output, frame);
}
@@ -291,30 +732,33 @@ static int v4l2_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
V4L2Context *const output = &s->output;
AVFrame *frame = s->frame;
int ret;
-
if (s->draining)
goto dequeue;
if (!frame->buf[0]) {
ret = ff_encode_get_frame(avctx, frame);
- if (ret < 0 && ret != AVERROR_EOF)
+ if (ret < 0 && ret != AVERROR_EOF) {
return ret;
-
- if (ret == AVERROR_EOF)
+ }
+ if (ret == AVERROR_EOF) {
frame = NULL;
+ }
}
ret = v4l2_send_frame(avctx, frame);
- if (ret != AVERROR(EAGAIN))
+ if (ret != AVERROR(EAGAIN)) {
av_frame_unref(frame);
-
- if (ret < 0 && ret != AVERROR(EAGAIN))
+ }
+ if (ret < 0 && ret != AVERROR(EAGAIN)) {
return ret;
+ }
if (!output->streamon) {
ret = ff_v4l2_context_set_status(output, VIDIOC_STREAMON);
if (ret) {
- av_log(avctx, AV_LOG_ERROR, "VIDIOC_STREAMON failed on output context\n");
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR VIDIOC_STREAMON failed on "
+ "output context ret=(%d) errno=(%d) error='%s'\n",
+ ret, errno, strerror(errno));
return ret;
}
}
@@ -322,7 +766,10 @@ static int v4l2_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
if (!capture->streamon) {
ret = ff_v4l2_context_set_status(capture, VIDIOC_STREAMON);
if (ret) {
- av_log(avctx, AV_LOG_ERROR, "VIDIOC_STREAMON failed on capture context\n");
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m v4l2_receive_packet "
+ "ERROR: VIDIOC_STREAMON failed on capture context "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ ret, errno, strerror(errno));
return ret;
}
}
@@ -339,11 +786,13 @@ static av_cold int v4l2_encode_init(AVCodecContext *avctx)
enum AVPixelFormat pix_fmt_output;
uint32_t v4l2_fmt_output;
int ret;
-
ret = ff_v4l2_m2m_create_context(priv, &s);
- if (ret < 0)
+ if (ret < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m v4l2_encode_init ERROR ff_v4l2_m2m_create_context failed "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ ret, errno, strerror(errno));
return ret;
-
+ }
capture = &s->capture;
output = &s->output;
@@ -362,7 +811,9 @@ static av_cold int v4l2_encode_init(AVCodecContext *avctx)
s->avctx = avctx;
ret = ff_v4l2_m2m_codec_init(priv);
if (ret) {
- av_log(avctx, AV_LOG_ERROR, "can't configure encoder\n");
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m v4l2_encode_init ERROR can't configure encoder "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ ret, errno, strerror(errno));
return ret;
}
@@ -374,18 +825,64 @@ static av_cold int v4l2_encode_init(AVCodecContext *avctx)
pix_fmt_output = ff_v4l2_format_v4l2_to_avfmt(v4l2_fmt_output, AV_CODEC_ID_RAWVIDEO);
if (pix_fmt_output != avctx->pix_fmt) {
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt_output);
- av_log(avctx, AV_LOG_ERROR, "Encoder requires %s pixel format.\n", desc->name);
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m ERROR requires %s pixel format. "
+ "ret=(%d) errno=(%d) error='%s'\n",
+ desc->name, ret, errno, strerror(errno));
return AVERROR(EINVAL);
}
-
return v4l2_prepare_encoder(s);
}
static av_cold int v4l2_encode_close(AVCodecContext *avctx)
{
- return ff_v4l2_m2m_codec_end(avctx->priv_data);
+ int ret;
+ ret = ff_v4l2_m2m_codec_end(avctx->priv_data);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Encoder v4l2_m2m v4l2_encode_close ERROR "
+ "ff_v4l2_m2m_codec_end failed ret=(%d) errno=(%d) error='%s'\n",
+ ret, errno, strerror(errno));
+ return ret;
+ }
+ return 0;
}
+/*
+ NOTING: /usr/include/linux/v4l2_controls.h
+ ESPECIALLY noting driver limits from: v4l2-ctl --list-ctrls-menu -d 11
+ video_bitrate_mode 0x009909ce (menu) : min=0 max=1 default=0 value=0 flags=update
+ 0: Variable Bitrate
+ 1: Constant Bitrate
+ video_bitrate 0x009909cf (int) : min=25000 max=25000000 step=25000 default=10000000 value=10000000
+ sequence_header_mode 0x009909d8 (menu) : min=0 max=1 default=1 value=1
+ 0: Separate Buffer
+ 1: Joined With 1st Frame
+ repeat_sequence_header 0x009909e2 (bool) : default=0 value=0
+ force_key_frame 0x009909e5 (button) : flags=write-only, execute-on-write
+ h264_minimum_qp_value 0x00990a61 (int) : min=0 max=51 step=1 default=20 value=20
+ h264_maximum_qp_value 0x00990a62 (int) : min=0 max=51 step=1 default=51 value=51
+ h264_i_frame_period 0x00990a66 (int) : min=0 max=2147483647 step=1 default=60 value=60
+ h264_level 0x00990a67 (menu) : min=0 max=13 default=11 value=11
+ 0: 1
+ 1: 1b
+ 2: 1.1
+ 3: 1.2
+ 4: 1.3
+ 5: 2
+ 6: 2.1
+ 7: 2.2
+ 8: 3
+ 9: 3.1
+ 10: 3.2
+ 11: 4
+ 12: 4.1
+ 13: 4.2
+ h264_profile 0x00990a6b (menu) : min=0 max=4 default=4 value=4
+ 0: Baseline
+ 1: Constrained Baseline
+ 2: Main
+ 4: High
+*/
+
#define OFFSET(x) offsetof(V4L2m2mPriv, x)
#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
@@ -394,20 +891,270 @@ static av_cold int v4l2_encode_close(AVCodecContext *avctx)
{ "num_capture_buffers", "Number of buffers in the capture context", \
OFFSET(num_capture_buffers), AV_OPT_TYPE_INT, {.i64 = 4 }, 4, INT_MAX, FLAGS }
-static const AVOption mpeg4_options[] = {
+/**
+ The following V4L_M2M_h264_options are parsed and stored in v4l2_m2m.h private typedef struct V4L2m2mPriv
+ All of the code in this encoder DEPENDS on the Options below,
+ "overriding" all "global" options having the same name.
+ i.e. the defaults and allowable values and ranges HERE take precendence.
+ Each codec has its own Options with the same names and different values.
+ */
+/**
+ h264 - h264 part 10 AVC
+ */
+static const AVOption V4L_M2M_h264_options[] = {
+ /**
+ V4L_M2M_CAPTURE_OPTS contains num_output_buffers and num_capture_buffers
+ */
+ V4L_M2M_CAPTURE_OPTS,
+ /**
+ per https://github.com/raspberrypi/linux/issues/4917#issuecomment-1057977916
+ Profile definitions from avcodec.h and v4l2-controls.h and videodev2.h
+ */
+ { "profile", "Profile restrictions, eg -profile high",
+ OFFSET(h264_profile), AV_OPT_TYPE_INT, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_HIGH},
+ V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE,
+ V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_HIGH, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "baseline", "baseline",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "c_baseline", "constrained_baseline",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "main", "main",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_MAIN},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "high", "high",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_HIGH},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "high10", "high 10",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "high422", "high 422",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "high444", "high 444 Predictive",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_PREDICTIVE},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "high10_intra", "high 10 Intra",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10_INTRA},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "high422_intra", "high 422 Intra",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422_INTRA},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "high444_intra", "high 444 Predictive Intra",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_INTRA},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "calv444_intra", "calvc 444 Intra",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_CAVLC_444_INTRA},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "scalable_baseline", "scalable baseline",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_BASELINE},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "scalable_high", "scalable high",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_HIGH},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "scalable_high_intra", "scalable high intra",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_SCALABLE_HIGH_INTRA},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "stereo_high", "stereo high",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_STEREO_HIGH},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "multiview_high", "multiview high",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ { "constrained_high", "constrained high",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_HIGH},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "profile" },
+ /**
+ Profile Level definitions from avcodec.h and v4l2-controls.h and videodev2.h
+ */
+ { "level", "Profile Level restrictions, eg 4.2",
+ OFFSET(h264_level), AV_OPT_TYPE_INT, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_4_2},
+ V4L2_MPEG_VIDEO_H264_LEVEL_1_0,
+ V4L2_MPEG_VIDEO_H264_LEVEL_6_2, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "1", "level 1",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_1_0},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "1B", "level 1B",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_1B},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "1.1", "level 1.1",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_1_1},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "1.2", "level 1.2",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_1_2},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "1.3", "level 1.3",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_1_3},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "2", "level 2",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_2_0},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "2.1", "level 2.1",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_2_1},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "2.2", "level 2.1",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_2_2},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "3", "level 3",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_3_0},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "3.1", "level 3.1",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_3_1},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "3.2", "level 3.2",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_3_2},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "4", "level 4",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_4_0},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "4.1", "level 4.1",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_4_1},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "4.2", "level 4.2",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_4_2},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "5", "level 5",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_5_0},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "5.1", "level 5.1",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_5_1},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "5.2", "level 5.2",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_5_2},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "6", "level 6",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_6_0},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "6.1", "level 6.1",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_6_1},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ { "6.2", "level 6.2",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_H264_LEVEL_6_2},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "level" },
+ /**
+ video_bitrate_mode is either CBR or VBR or CQ ... here called eg -rc CBR or -rc VBR
+ ... default to VBR, since CBR crashes with:
+ ERROR VIDIOC_STREAMON failed on output context ret=(-3) errno=(3 'No such process')
+ */
+ { "rc", "Bitrate mode VBR or CBR or CQ",
+ OFFSET(h264_video_bit_rate_mode), AV_OPT_TYPE_INT, {.i64=V4L2_MPEG_VIDEO_BITRATE_MODE_VBR},
+ V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
+ V4L2_MPEG_VIDEO_BITRATE_MODE_CQ, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "rc" },
+ { "VBR", "for variable bitrate mode",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_BITRATE_MODE_VBR},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "rc" },
+ /**
+ CBR: 1. CBR is not supported in high profile on the Raspberry Pi SoC.
+ 2. CBR causes ffmpeg encoder to hang on the Raspberry Pi.
+ */
+ { "CBR", "for constant bitrate mode",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_BITRATE_MODE_CBR},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "rc" },
+ /**
+ CQ: https://lkml.org/lkml/2020/5/22/1219
+ When V4L2_CID_MPEG_VIDEO_BITRATE_MODE value is V4L2_MPEG_VIDEO_BITRATE_MODE_CQ,
+ encoder will produce constant quality output indicated by the
+ V4L2_CID_MPEG_VIDEO_CONSTANT_QUALITY control value. Encoder will choose
+ appropriate quantization parameter and bitrate to produce requested frame quality level.
+ Valid range is 1 to 100 where 1 = lowest quality, 100 = highest quality.
+ ** V4L2_CID_MPEG_VIDEO_CONSTANT_QUALITY not dealt with here ... since
+ mode V4L2_MPEG_VIDEO_BITRATE_MODE_CQ is not allowed on a Raspberry Pi 4.
+ sequence_header_mode is peculiar ... here called -shm separate_buffer or -shm joined_1st_frame
+ */
+ { "CQ", "for constant quality mode",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_BITRATE_MODE_CQ},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "rc" },
+ { "shm", "Sequence_header_mode",
+ OFFSET(h264_sequence_header_mode), AV_OPT_TYPE_INT, {.i64=V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME},
+ V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE,
+ V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "shm" },
+ { "separate_buffer", "separate_buffer",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "shm" },
+ { "joined_1st_frame", "joined_1st_frame",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "shm" },
+ /**
+ Repeat Sequence Headers (Raspberry Pi respositories compile with this on)
+ ... here called -rsh 0 or -rsh 0
+ */
+ { "rsh", "repeat sequence header 0(false) 1(true)",
+ OFFSET(h264_repeat_seq_header), AV_OPT_TYPE_BOOL, {.i64=1},
+ 0, 1, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
+ /**
+ Frame Skip Mode here called -fsm. V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE
+ Indicates in what conditions the encoder should skip frames.
+ If encoding a frame would cause the encoded stream to be larger than
+ a chosen data limit then the frame will be skipped.
+ */
+ { "fsme", "Frame Skip Mode for encoder",
+ OFFSET(h264_frame_skip_mode_encoder), AV_OPT_TYPE_INT, {.i64=V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_DISABLED},
+ V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_DISABLED,
+ V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "fsme" },
+ { "disabled", "fsme disabled",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_DISABLED},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "fsme" },
+ { "level_limit", "fsme enabled and buffer limit is set by the chosen level",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_LEVEL_LIMIT},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "fsme" },
+ { "buffer_limit", "fsme enabled and buffer limit is set by CPB (H264) buffer size control",
+ 0, AV_OPT_TYPE_CONST, {.i64=V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT},
+ 0, 0, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM, "fsme" },
+ /**
+ Video_bitrate -b:v for both CBR and VBR
+ */
+ { "b", "-b:v video_bitrate bits per second",
+ OFFSET(h264_video_bit_rate), AV_OPT_TYPE_INT64, {.i64=10000000},
+ 25000, 25000000, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
+ { "qmin", "Minimum quantization parameter for h264",
+ OFFSET(h264_qmin), AV_OPT_TYPE_INT, {.i64=1},
+ 1, 51, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
+ { "qmax", "Maximum quantization parameter for h264",
+ OFFSET(h264_qmax), AV_OPT_TYPE_INT, {.i64=51},
+ 1, 51, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
+ /**
+ Since GOP setting is not currently used by the driver,
+ Accept it privately and if specified then allow it to over-ride iframe_period
+ */
+ { "g", "gop size, overrides iframe_period used by the driver",
+ OFFSET(h264_gop_size), AV_OPT_TYPE_INT, {.i64=-1},
+ -1, INT_MAX, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
+ /**
+ Allow iframe_period to be used directly (over-ridden by a GOP setting):
+ "For H264 there is V4L2_CID_MPEG_VIDEO_H264_I_PERIOD, which is what is implemented in the encoder"
+ per https://github.com/raspberrypi/linux/issues/4917#issuecomment-1057977916
+ */
+ { "iframe_period", "iframe_period used by the driver; overridden by -g",
+ OFFSET(h264_iframe_period), AV_OPT_TYPE_INT, {.i64=25},
+ 0, INT_MAX, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
+ { NULL },
+};
+
+/**
+ mpeg4 options
+ */
+static const AVOption V4L_M2M_mpeg4_options[] = {
V4L_M2M_CAPTURE_OPTS,
FF_MPEG4_PROFILE_OPTS
{ NULL },
};
-static const AVOption options[] = {
+/**
+ Something for num_output_buffers and num_capture_buffers
+ */
+static const AVOption V4L_M2M_options[] = {
+ /// V4L_M2M_CAPTURE_OPTS contains num_output_buffers and num_capture_buffers
V4L_M2M_CAPTURE_OPTS,
{ NULL },
};
+/**
+ info at https://stackoverflow.com/questions/12648988/converting-a-defined-constant-number-to-a-string
+ */
+#define STRINGIZE_(x) #x
+#define STRINGIZE(x) STRINGIZE_(x)
static const FFCodecDefault v4l2_m2m_defaults[] = {
- { "qmin", "-1" },
- { "qmax", "-1" },
{ NULL },
};
@@ -437,8 +1184,12 @@ static const FFCodecDefault v4l2_m2m_defaults[] = {
.p.wrapper_name = "v4l2m2m", \
}
-M2MENC(mpeg4,"MPEG4", mpeg4_options, AV_CODEC_ID_MPEG4);
-M2MENC(h263, "H.263", options, AV_CODEC_ID_H263);
-M2MENC(h264, "H.264", options, AV_CODEC_ID_H264);
-M2MENC(hevc, "HEVC", options, AV_CODEC_ID_HEVC);
-M2MENC(vp8, "VP8", options, AV_CODEC_ID_VP8);
+/**
+ also see v4l2_m2m.h typedef struct V4L2m2mPriv
+ */
+M2MENC(h264, "H.264", V4L_M2M_h264_options, AV_CODEC_ID_H264);
+M2MENC(mpeg4, "MPEG4", V4L_M2M_mpeg4_options, AV_CODEC_ID_MPEG4);
+M2MENC(hevc, "HEVC", V4L_M2M_options, AV_CODEC_ID_HEVC);
+M2MENC(vp8, "VP8", V4L_M2M_options, AV_CODEC_ID_VP8);
+M2MENC(vp9, "VP9", V4L_M2M_options, AV_CODEC_ID_VP9);
+M2MENC(h263, "H.263", V4L_M2M_options, AV_CODEC_ID_H263);
--
2.30.2
-------------- next part --------------
A non-text attachment was scrubbed...
Name: winmail.dat
Type: application/ms-tnef
Size: 27894 bytes
Desc: not available
URL: <https://ffmpeg.org/pipermail/ffmpeg-devel/attachments/20220326/5a24fb85/attachment.bin>
More information about the ffmpeg-devel
mailing list