Support AV1 streaming over HTTP, via SVT-AV1.

[nageru] / nageru / flags.cpp

diff --git a/nageru/flags.cpp b/nageru/flags.cpp
index 42fdb88b22a1b2639d8cf7c954b1284f7ec7ed8d..2bd0eeca0aa183b01f13c4ba03dfbb1ecf831d17 100644 (file)
--- a/nageru/flags.cpp
+++ b/nageru/flags.cpp
@@ -23,6 +23,7 @@ enum LongOption {
        OPTION_V4L_OUTPUT,
        OPTION_HTTP_UNCOMPRESSED_VIDEO,
        OPTION_HTTP_X264_VIDEO,
+       OPTION_HTTP_AV1_VIDEO,
        OPTION_RECORD_X264_VIDEO,
        OPTION_SEPARATE_X264_DISK_ENCODE,
        OPTION_X264_PRESET,
@@ -39,6 +40,10 @@ enum LongOption {
        OPTION_X264_SEPARATE_DISK_BITRATE,
        OPTION_X264_SEPARATE_DISK_CRF,
        OPTION_X264_SEPARATE_DISK_PARAM,
+       OPTION_AV1_PRESET,
+       OPTION_AV1_BITRATE,
+       OPTION_AV1_FPS,
+       OPTION_AV1_PARAM,
        OPTION_HTTP_MUX,
        OPTION_HTTP_COARSE_TIMEBASE,
        OPTION_HTTP_AUDIO_CODEC,
@@ -185,6 +190,16 @@ void usage(Program program)
                fprintf(stderr, "                                  incompatible with --x264-separate-disk-bitrate\n");
                fprintf(stderr, "      --x264-separate-disk-param=NAME[,VALUE] set any x264 parameter, for fine tuning\n");
        }
+#ifdef HAVE_AV1
+       fprintf(stderr, "      --http-av1-video            send AV1-compressed video to HTTP clients\n");
+       fprintf(stderr, "      --av1-preset                SVT-AV1 quality preset (default %d, from -2 to 13)\n",
+               DEFAULT_AV1_PRESET);
+       fprintf(stderr, "      --av1-bitrate               AV1 bitrate (in kilobit/sec, default %d)\n",
+               DEFAULT_AV1_OUTPUT_BIT_RATE);
+       fprintf(stderr, "      --av1-fps=NUM[/DEN]         AV1 encoded frame rate (default %d/%d)\n",
+               DEFAULT_AV1_FPS_NUM, DEFAULT_AV1_FPS_DEN);
+       fprintf(stderr, "      --av1-param=NAME[,VALUE]    set any SVT-AV1 parameter, for fine tuning\n");
+#endif
        fprintf(stderr, "      --http-mux=NAME             mux to use for HTTP streams (default " DEFAULT_STREAM_MUX_NAME ")\n");
        fprintf(stderr, "      --http-audio-codec=NAME     audio codec to use for HTTP streams\n");
        fprintf(stderr, "                                  (default is to use the same as for the recording)\n");
@@ -289,6 +304,13 @@ void parse_flags(Program program, int argc, char * const argv[])
                { "x264-separate-disk-bitrate", required_argument, 0, OPTION_X264_SEPARATE_DISK_BITRATE },
                { "x264-separate-disk-crf", required_argument, 0, OPTION_X264_SEPARATE_DISK_CRF },
                { "x264-separate-disk-param", required_argument, 0, OPTION_X264_SEPARATE_DISK_PARAM },
+#ifdef HAVE_AV1
+               { "http-av1-video", no_argument, 0, OPTION_HTTP_AV1_VIDEO },
+               { "av1-preset", required_argument, 0, OPTION_AV1_PRESET },
+               { "av1-bitrate", required_argument, 0, OPTION_AV1_BITRATE },
+               { "av1-fps", required_argument, 0, OPTION_AV1_FPS },
+               { "av1-param", required_argument, 0, OPTION_AV1_PARAM },
+#endif
                { "http-mux", required_argument, 0, OPTION_HTTP_MUX },
                { "http-audio-codec", required_argument, 0, OPTION_HTTP_AUDIO_CODEC },
                { "http-audio-bitrate", required_argument, 0, OPTION_HTTP_AUDIO_BITRATE },
@@ -445,6 +467,9 @@ void parse_flags(Program program, int argc, char * const argv[])
                        global_flags.x264_video_to_http = true;
                        global_flags.x264_separate_disk_encode = true;
                        break;
+               case OPTION_HTTP_AV1_VIDEO:
+                       global_flags.av1_video_to_http = true;
+                       break;
                case OPTION_X264_PRESET:
                        global_flags.x264_preset = optarg;
                        break;
@@ -487,6 +512,29 @@ void parse_flags(Program program, int argc, char * const argv[])
                case OPTION_X264_SEPARATE_DISK_PARAM:
                        global_flags.x264_separate_disk_extra_param.push_back(optarg);
                        break;
+               case OPTION_AV1_PRESET:
+                       global_flags.av1_preset = atoi(optarg);
+                       break;
+               case OPTION_AV1_BITRATE:
+                       global_flags.av1_bitrate = atoi(optarg);
+                       break;
+               case OPTION_AV1_FPS: {
+                       string str = optarg;
+                       const size_t pos = str.find('/');
+                       if (pos == string::npos) {
+                               global_flags.av1_fps_num = stoi(str);
+                               global_flags.av1_fps_den = 1;
+                       } else {
+                               const string num = str.substr(0, pos);
+                               const string den = str.substr(pos + 1);
+                               global_flags.av1_fps_num = stoi(num);
+                               global_flags.av1_fps_den = stoi(den);
+                       }
+                       break;
+               }
+               case OPTION_AV1_PARAM:
+                       global_flags.av1_extra_param.push_back(optarg);
+                       break;
                case OPTION_FLAT_AUDIO:
                        // If --flat-audio is given, turn off everything that messes with the sound,
                        // except the final makeup gain.
@@ -570,8 +618,6 @@ void parse_flags(Program program, int argc, char * const argv[])
                        break;
                case OPTION_10_BIT_OUTPUT:
                        global_flags.ten_bit_output = true;
-                       global_flags.x264_video_to_disk = true;
-                       global_flags.x264_video_to_http = true;
                        global_flags.x264_bit_depth = 10;
                        break;
                case OPTION_INPUT_YCBCR_INTERPRETATION: {
@@ -645,11 +691,21 @@ void parse_flags(Program program, int argc, char * const argv[])
                }
        }
 
-       if (global_flags.uncompressed_video_to_http &&
-           global_flags.x264_video_to_http) {
-               fprintf(stderr, "ERROR: --http-uncompressed-video and --http-x264-video are mutually incompatible\n");
+       if (global_flags.uncompressed_video_to_http +
+           global_flags.x264_video_to_http +
+           global_flags.av1_video_to_http > 1) {
+               fprintf(stderr, "ERROR: --http-{uncompressed,x264,av1}-video are mutually incompatible\n");
                exit(1);
        }
+       if (global_flags.ten_bit_output) {
+               global_flags.x264_video_to_disk = true;  // No 10-bit Quick Sync support.
+               if (global_flags.av1_video_to_http) {
+                       fprintf(stderr, "ERROR: 10-bit AV1 output is not supported yet\n");
+                       exit(1);
+               } else {
+                       global_flags.x264_video_to_http = true;
+               }
+       }
        if (global_flags.min_num_cards <= 0) {
                fprintf(stderr, "ERROR: --num-cards must be at least 1\n");
                exit(1);