allow setting software H264 profile and level (bluenviron/mediamtx#3965) (#57)

Author: aler9

encoder_hard_h264.c

@@ -114,15 +114,27 @@ bool encoder_hard_h264_create(const parameters_t *params, int stride, int colors
 
     struct v4l2_control ctrl = {0};
     ctrl.id = V4L2_CID_MPEG_VIDEO_H264_PROFILE;
-    ctrl.value = params->profile;
+    if (strcmp(params->hardware_h264_profile, "baseline") == 0) {
+        ctrl.value = V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE;
+    } else if (strcmp(params->hardware_h264_profile, "main") == 0) {
+        ctrl.value = V4L2_MPEG_VIDEO_H264_PROFILE_MAIN;
+    } else {
+        ctrl.value = V4L2_MPEG_VIDEO_H264_PROFILE_HIGH;
+    }
     int res = ioctl(encp->fd, VIDIOC_S_CTRL, &ctrl);
     if (res != 0) {
         set_error("unable to set profile");
         goto failed;
     }
 
     ctrl.id = V4L2_CID_MPEG_VIDEO_H264_LEVEL;
-    ctrl.value = params->level;
+    if (strcmp(params->hardware_h264_level, "4.0") == 0) {
+        ctrl.value = V4L2_MPEG_VIDEO_H264_LEVEL_4_0;
+    } else if (strcmp(params->hardware_h264_level, "4.1") == 0) {
+        ctrl.value = V4L2_MPEG_VIDEO_H264_LEVEL_4_1;
+    } else {
+        ctrl.value = V4L2_MPEG_VIDEO_H264_LEVEL_4_2;
+    }
     res = ioctl(encp->fd, VIDIOC_S_CTRL, &ctrl);
     if (res != 0) {
         set_error("unable to set level");

encoder_soft_h264.c

@@ -9,10 +9,6 @@
 
 #include "encoder_soft_h264.h"
 
-#define PRESET      "ultrafast"
-#define TUNE        "zerolatency"
-#define PROFILE     "baseline"
-
 static char errbuf[256];
 
 static void set_error(const char *format, ...) {
@@ -32,7 +28,6 @@ typedef struct {
     x264_t *x_handler;
     x264_picture_t x_pic_in;
     x264_picture_t x_pic_out;
-    uint64_t next_pts;
     pthread_mutex_t mutex;
 } encoder_soft_h264_priv_t;
 
@@ -41,10 +36,18 @@ bool encoder_soft_h264_create(const parameters_t *params, int stride, int colors
     encoder_soft_h264_priv_t *encp = (encoder_soft_h264_priv_t *)(*enc);
     memset(encp, 0, sizeof(encoder_soft_h264_priv_t));
 
-    int res = x264_param_default_preset(&encp->x_params, PRESET, TUNE);
-    if (res < 0) {
-        set_error("x264_param_default_preset() failed");
-        goto failed;
+    if (strcmp(params->software_h264_profile, "baseline") == 0) {
+        int res = x264_param_default_preset(&encp->x_params, "ultrafast", "zerolatency");
+        if (res < 0) {
+            set_error("x264_param_default_preset() failed");
+            goto failed;
+        }
+    } else {
+        int res = x264_param_default_preset(&encp->x_params, "superfast", NULL);
+        if (res < 0) {
+            set_error("x264_param_default_preset() failed");
+            goto failed;
+        }
     }
 
     encp->x_params.i_width  = params->width;
@@ -68,8 +71,9 @@ bool encoder_soft_h264_create(const parameters_t *params, int stride, int colors
     encp->x_params.rc.i_vbv_max_bitrate = params->bitrate / 1000;
     encp->x_params.rc.i_rc_method = X264_RC_ABR;
     encp->x_params.i_bframe = 0;
+    encp->x_params.i_level_idc = (int)(atof(params->software_h264_level) * 10.0f);
 
-    res = x264_param_apply_profile(&encp->x_params, PROFILE);
+    int res = x264_param_apply_profile(&encp->x_params, params->software_h264_profile);
     if (res < 0) {
         set_error("x264_param_apply_profile() failed");
         goto failed;
@@ -103,7 +107,7 @@ void encoder_soft_h264_encode(encoder_soft_h264_t *enc, uint8_t *buffer_mapped,
     encp->x_pic_in.img.plane[0] = buffer_mapped; // Y
     encp->x_pic_in.img.plane[1] = encp->x_pic_in.img.plane[0] + encp->x_pic_in.img.i_stride[0] * encp->params->height; // U
     encp->x_pic_in.img.plane[2] = encp->x_pic_in.img.plane[1] + (encp->x_pic_in.img.i_stride[0] / 2) * (encp->params->height / 2); // V
-    encp->x_pic_in.i_pts = encp->next_pts++;
+    encp->x_pic_in.i_pts = (int64_t)timestamp;
 
     pthread_mutex_lock(&encp->mutex);
 
@@ -113,7 +117,9 @@ void encoder_soft_h264_encode(encoder_soft_h264_t *enc, uint8_t *buffer_mapped,
 
     pthread_mutex_unlock(&encp->mutex);
 
-    encp->output_cb(nal->p_payload, frame_size, timestamp);
+    if (nal != NULL) {
+        encp->output_cb(nal->p_payload, frame_size, (uint64_t)encp->x_pic_out.i_pts);
+    }
 }
 
 void encoder_soft_h264_reload_params(encoder_soft_h264_t *enc, const parameters_t *params) {

main.c

@@ -145,7 +145,7 @@ int main() {
         ok = encoder_jpeg_create(
             params.secondary_width,
             params.secondary_height,
-            params.secondary_quality,
+            params.secondary_mjpeg_quality,
             camera_get_secondary_stride(cam),
             on_jpeg_output,
             &enc_jpeg);

parameters.c

@@ -4,8 +4,6 @@
 #include <stdarg.h>
 #include <stdio.h>
 
-#include <linux/videodev2.h>
-
 #include "base64.h"
 #include "parameters.h"
 
@@ -134,34 +132,22 @@ bool parameters_unserialize(parameters_t *params, const uint8_t *buf, size_t buf
             params->idr_period = atoi(val);
         } else if (strcmp(key, "Bitrate") == 0) {
             params->bitrate = atoi(val);
-        } else if (strcmp(key, "Profile") == 0) {
-            char *decoded_val = base64_decode(val);
-            if (strcmp(decoded_val, "baseline") == 0) {
-                params->profile = V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE;
-            } else if (strcmp(decoded_val, "main") == 0) {
-                params->profile = V4L2_MPEG_VIDEO_H264_PROFILE_MAIN;
-            } else {
-                params->profile = V4L2_MPEG_VIDEO_H264_PROFILE_HIGH;
-            }
-            free(decoded_val);
-        } else if (strcmp(key, "Level") == 0) {
-            char *decoded_val = base64_decode(val);
-            if (strcmp(decoded_val, "4.0") == 0) {
-                params->level = V4L2_MPEG_VIDEO_H264_LEVEL_4_0;
-            } else if (strcmp(decoded_val, "4.1") == 0) {
-                params->level = V4L2_MPEG_VIDEO_H264_LEVEL_4_1;
-            } else {
-                params->level = V4L2_MPEG_VIDEO_H264_LEVEL_4_2;
-            }
-            free(decoded_val);
+        } else if (strcmp(key, "HardwareH264Profile") == 0) {
+            params->hardware_h264_profile = base64_decode(val);
+        } else if (strcmp(key, "HardwareH264Level") == 0) {
+            params->hardware_h264_level = base64_decode(val);
+        } else if (strcmp(key, "SoftwareH264Profile") == 0) {
+            params->software_h264_profile = base64_decode(val);
+        } else if (strcmp(key, "SoftwareH264Level") == 0) {
+            params->software_h264_level = base64_decode(val);
         } else if (strcmp(key, "SecondaryWidth") == 0) {
             params->secondary_width = atoi(val);
         } else if (strcmp(key, "SecondaryHeight") == 0) {
             params->secondary_height = atoi(val);
         } else if (strcmp(key, "SecondaryFPS") == 0) {
             params->secondary_fps = atof(val);
-        } else if (strcmp(key, "SecondaryQuality") == 0) {
-            params->secondary_quality = atoi(val);
+        } else if (strcmp(key, "SecondaryMJPEGQuality") == 0) {
+            params->secondary_mjpeg_quality = atoi(val);
         }
     }
 

parameters.h

@@ -43,12 +43,14 @@ typedef struct {
     char *codec;
     unsigned int idr_period;
     unsigned int bitrate;
-    unsigned int profile;
-    unsigned int level;
+    char *hardware_h264_profile;
+    char *hardware_h264_level;
+    char *software_h264_profile;
+    char *software_h264_level;
     unsigned int secondary_width;
     unsigned int secondary_height;
     float secondary_fps;
-    unsigned int secondary_quality;
+    unsigned int secondary_mjpeg_quality;
 
     // private
     unsigned int buffer_count;