From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <ffmpeg-devel-bounces@ffmpeg.org>
Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org [79.124.17.100])
	by master.gitmailbox.com (Postfix) with ESMTP id 850DE40F17
	for <ffmpegdev@gitmailbox.com>; Sun, 13 Mar 2022 15:34:24 +0000 (UTC)
Received: from [127.0.1.1] (localhost [127.0.0.1])
	by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 106E768B10B;
	Sun, 13 Mar 2022 17:34:22 +0200 (EET)
Received: from mail-pl1-f174.google.com (mail-pl1-f174.google.com
 [209.85.214.174])
 by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 05216689B39
 for <ffmpeg-devel@ffmpeg.org>; Sun, 13 Mar 2022 17:34:15 +0200 (EET)
Received: by mail-pl1-f174.google.com with SMTP id r12so11592051pla.1
 for <ffmpeg-devel@ffmpeg.org>; Sun, 13 Mar 2022 08:34:14 -0700 (PDT)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112;
 h=from:to:references:in-reply-to:subject:date:message-id:mime-version
 :content-transfer-encoding:thread-index:content-language
 :disposition-notification-to;
 bh=glwmYeJ6amLlga4pEEQWDMSjFR/6wmnviApRd4Hy6Vo=;
 b=BMtpwLKWzScLRCjSGFqESadL4+TRej+/zokp2cQpBlXD8bnjfg174zhCQXgaKEhQvx
 ctsKrg2F0Y/r+lQftnxZbCrt3azWCnk745c93ShtikOv69EmS6Y67r1zDY6N8vsVXFcO
 7KVpXgrE1aDRAwQYZ1EUpmavDlXQ5jYK4yc7HhR38Efax+GmCHBQIuWfMh+w2H/Nd8Yt
 djPq8dG9BlDm8LcKulAI2hBYvBx8MTx48wLq1SK/dX3PeX6hM5ebfSFVx5QYm5CD/yj3
 wfrHL1R0I6VvtCyzBIKlqqM08tKkqmHUk582GciIy/eueT77Dup0FJLlpcjubxFhP+2t
 Xjlw==
X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
 d=1e100.net; s=20210112;
 h=x-gm-message-state:from:to:references:in-reply-to:subject:date
 :message-id:mime-version:content-transfer-encoding:thread-index
 :content-language:disposition-notification-to;
 bh=glwmYeJ6amLlga4pEEQWDMSjFR/6wmnviApRd4Hy6Vo=;
 b=humd4X/7SgHS2UE3DhCKJCJp+LS69HZy9Qc9izsq7jfgLZpV4gRBJmQbtlZsXpAsB9
 hvYw6fs2FeYHlX+lGEJSRsxlClizoaCbZl2+dPY3Vj2WPrrNtRQwHecC6M3OFzOxCL1a
 LHtZlSskghCWr8U3d2CSHi9iHiY5qdgMWdp8I8rmGTKSjh7dT+gIJTQg8/ZOb3Z5/J/C
 rCZXmHlMIDYsbkxaWZrdP47PrEexH/wFOPxMl7tX7pVDE/wWLHln1hPWtz6F3tl4Up9G
 Eqox8nGqjRHS1aD5LvlgKR4sFVtQU2OmDm9ccQrigLweR4pY8IXW2kDhS3DHfY0JwlG5
 KFtQ==
X-Gm-Message-State: AOAM533Sr6tid6XDpTUUue5A5lqweGzD59zYWQagYxOAkrU6PX85Tkf+
 uP/Kovk4rBQ1dlQWZjWTO4vAsp8sTrM=
X-Google-Smtp-Source: ABdhPJzTdPE7QUjjTtzs7xE3yU3m5MltdCx+eImYqNQl1KPllGOeIAydS5DdofXft6VozjCLc2h80Q==
X-Received: by 2002:a17:90b:4a8d:b0:1bf:a1ab:7ffc with SMTP id
 lp13-20020a17090b4a8d00b001bfa1ab7ffcmr20680535pjb.75.1647185651168; 
 Sun, 13 Mar 2022 08:34:11 -0700 (PDT)
Received: from 3900X ([58.174.84.57]) by smtp.gmail.com with ESMTPSA id
 s1-20020a056a00178100b004f731a1a952sm18002996pfg.168.2022.03.13.08.34.08
 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128);
 Sun, 13 Mar 2022 08:34:10 -0700 (PDT)
From: <hydra3333@gmail.com>
To: <ffmpeg-devel@ffmpeg.org>
References: <20220313153133.47041-1-hydra3333@gmail.com>
In-Reply-To: <20220313153133.47041-1-hydra3333@gmail.com>
Date: Mon, 14 Mar 2022 02:04:06 +1030
Message-ID: <!&!AAAAAAAAAAAYAAAAAAAAAPVpP4J8X/dMswzQa6NNRVPCgAAAEAAAAGjq5t3mT9BFlRBSENs1HQ4BAAAAAA==@gmail.com>
MIME-Version: 1.0
X-Mailer: Microsoft Outlook 16.0
Thread-Index: AQE1yqREGZvZ127uJpYLUWWzdAozQq4CSe3g
Content-Language: en-au
Subject: [FFmpeg-devel] [PATCH] Add and use cli options for v4l2
 encoder=h264_v4l2m2m
X-BeenThere: ffmpeg-devel@ffmpeg.org
X-Mailman-Version: 2.1.29
Precedence: list
List-Id: FFmpeg development discussions and patches <ffmpeg-devel.ffmpeg.org>
List-Unsubscribe: <https://ffmpeg.org/mailman/options/ffmpeg-devel>,
 <mailto:ffmpeg-devel-request@ffmpeg.org?subject=unsubscribe>
List-Archive: <https://ffmpeg.org/pipermail/ffmpeg-devel>
List-Post: <mailto:ffmpeg-devel@ffmpeg.org>
List-Help: <mailto:ffmpeg-devel-request@ffmpeg.org?subject=help>
List-Subscribe: <https://ffmpeg.org/mailman/listinfo/ffmpeg-devel>,
 <mailto:ffmpeg-devel-request@ffmpeg.org?subject=subscribe>
Reply-To: FFmpeg development discussions and patches <ffmpeg-devel@ffmpeg.org>
Content-Type: text/plain; charset="us-ascii"
Content-Transfer-Encoding: 7bit
Errors-To: ffmpeg-devel-bounces@ffmpeg.org
Sender: "ffmpeg-devel" <ffmpeg-devel-bounces@ffmpeg.org>
Archived-At: <https://master.gitmailbox.com/ffmpegdev/!&!AAAAAAAAAAAYAAAAAAAAAPVpP4J8X%2FdMswzQa6NNRVPCgAAAEAAAAGjq5t3mT9BFlRBSENs1HQ4BAAAAAA==@gmail.com/>
List-Archive: <https://master.gitmailbox.com/ffmpegdev/>
List-Post: <mailto:ffmpegdev@gitmailbox.com>

Well, let's try to submit a patch and see how it fares.


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@gmail.com>
---
 libavcodec/v4l2_m2m.h     |   13 +-
 libavcodec/v4l2_m2m_enc.c | 1013 ++++++++++++++++++++++++++++++++-----
 2 files changed, 894 insertions(+), 132 deletions(-)

diff --git a/libavcodec/v4l2_m2m.h b/libavcodec/v4l2_m2m.h
index b67b216..f3955b5 100644
--- a/libavcodec/v4l2_m2m.h
+++ b/libavcodec/v4l2_m2m.h
@@ -73,9 +73,20 @@ typedef struct V4L2m2mPriv {
 
     V4L2m2mContext *context;
     AVBufferRef    *context_ref;
-
     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 043fe80..9ac7514 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@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 AVCodecDefault v4l2_m2m_defaults[] = {
-    { "qmin", "-1" },
-    { "qmax", "-1" },
     { NULL },
 };
 
@@ -437,8 +1184,12 @@ static const AVCodecDefault v4l2_m2m_defaults[] = {
         .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

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".