Collapse all the 10-bit flags.

[nageru] / nageru / quicksync_encoder.cpp

diff --git a/nageru/quicksync_encoder.cpp b/nageru/quicksync_encoder.cpp
index 992bf8f83e037e3bf8df40b02df23ede0fbcd2a3..d0ca914e2901b031cc8f56899a4ed81eb1a78bd1 100644 (file)
--- a/nageru/quicksync_encoder.cpp
+++ b/nageru/quicksync_encoder.cpp
@@ -719,6 +719,9 @@ void QuickSyncEncoderImpl::enable_zerocopy_if_possible()
        } else if (global_flags.x264_video_to_http) {
                fprintf(stderr, "Disabling zerocopy H.264 encoding due to --http-x264-video.\n");
                use_zerocopy = false;
+       } else if (global_flags.av1_video_to_http) {
+               fprintf(stderr, "Disabling zerocopy H.264 encoding due to --http-av1-video.\n");
+               use_zerocopy = false;
        } else if (!global_flags.v4l_output_device.empty()) {
                fprintf(stderr, "Disabling zerocopy H.264 encoding due to --v4l-output.\n");
                use_zerocopy = false;
@@ -903,7 +906,7 @@ int QuickSyncEncoderImpl::setup_encode()
                        gl_surfaces[i].y_tex = resource_pool->create_2d_texture(GL_R8, 1, 1);
                        gl_surfaces[i].cbcr_tex = resource_pool->create_2d_texture(GL_RG8, 1, 1);
                } else {
-                       size_t bytes_per_pixel = (global_flags.x264_bit_depth > 8) ? 2 : 1;
+                       size_t bytes_per_pixel = (global_flags.bit_depth > 8) ? 2 : 1;
 
                        // Generate a PBO to read into. It doesn't necessarily fit 1:1 with the VA-API
                        // buffers, due to potentially differing pitch.
@@ -1342,7 +1345,8 @@ void QuickSyncEncoderImpl::save_codeddata(GLSurface *surf, storage_task task)
                        file_mux->add_packet(pkt, task.pts + global_delay(), task.dts + global_delay());
                }
                if (!global_flags.uncompressed_video_to_http &&
-                   !global_flags.x264_video_to_http) {
+                   !global_flags.x264_video_to_http &&
+                   !global_flags.av1_video_to_http) {
                        stream_mux->add_packet(pkt, task.pts + global_delay(), task.dts + global_delay());
                }
        }
@@ -1435,8 +1439,8 @@ void QuickSyncEncoderImpl::release_gl_resources()
        has_released_gl_resources = true;
 }
 
-QuickSyncEncoderImpl::QuickSyncEncoderImpl(const std::string &filename, ResourcePool *resource_pool, QSurface *surface, const string &va_display, int width, int height, AVOutputFormat *oformat, X264Encoder *x264_encoder, DiskSpaceEstimator *disk_space_estimator)
-       : current_storage_frame(0), resource_pool(resource_pool), surface(surface), x264_encoder(x264_encoder), frame_width(width), frame_height(height), disk_space_estimator(disk_space_estimator)
+QuickSyncEncoderImpl::QuickSyncEncoderImpl(const std::string &filename, ResourcePool *resource_pool, QSurface *surface, const string &va_display, int width, int height, const AVOutputFormat *oformat, VideoCodecInterface *http_encoder, VideoCodecInterface *disk_encoder, DiskSpaceEstimator *disk_space_estimator)
+       : current_storage_frame(0), resource_pool(resource_pool), surface(surface), http_encoder(http_encoder), disk_encoder(disk_encoder), frame_width(width), frame_height(height), disk_space_estimator(disk_space_estimator)
 {
        file_audio_encoder.reset(new AudioEncoder(AUDIO_OUTPUT_CODEC_NAME, DEFAULT_AUDIO_OUTPUT_BIT_RATE, oformat));
        open_output_file(filename);
@@ -1448,9 +1452,13 @@ QuickSyncEncoderImpl::QuickSyncEncoderImpl(const std::string &filename, Resource
        //print_input();
 
        if (global_flags.x264_video_to_http || global_flags.x264_video_to_disk) {
-               assert(x264_encoder != nullptr);
+               assert(http_encoder != nullptr);
+               assert(disk_encoder != nullptr);
+       } else if (global_flags.av1_video_to_http) {
+               assert(http_encoder != nullptr);
        } else {
-               assert(x264_encoder == nullptr);
+               assert(http_encoder == nullptr);
+               assert(disk_encoder == nullptr);
        }
 
        enable_zerocopy_if_possible();
@@ -1625,7 +1633,7 @@ RefCountedGLsync QuickSyncEncoderImpl::end_frame()
        assert(!is_shutdown);
 
        if (!use_zerocopy) {
-               GLenum type = global_flags.x264_bit_depth > 8 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_BYTE;
+               GLenum type = global_flags.bit_depth > 8 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_BYTE;
                GLSurface *surf;
                {
                        lock_guard<mutex> lock(storage_task_queue_mutex);
@@ -1731,7 +1739,7 @@ void QuickSyncEncoderImpl::open_output_file(const std::string &filename)
 
        string video_extradata;  // FIXME: See other comment about global headers.
        if (global_flags.x264_video_to_disk) {
-               video_extradata = x264_encoder->get_global_headers();
+               video_extradata = disk_encoder->get_global_headers();
        }
 
        current_file_mux_metrics.reset();
@@ -1747,7 +1755,7 @@ void QuickSyncEncoderImpl::open_output_file(const std::string &filename)
        metric_current_file_start_time_seconds = get_timestamp_for_metrics();
 
        if (global_flags.x264_video_to_disk) {
-               x264_encoder->add_mux(file_mux.get());
+               disk_encoder->add_mux(file_mux.get());
        }
 }
 
@@ -1909,8 +1917,10 @@ void QuickSyncEncoderImpl::pass_frame(QuickSyncEncoderImpl::PendingFrame frame,
        uint8_t *data = reinterpret_cast<uint8_t *>(surf->y_ptr);
        if (global_flags.uncompressed_video_to_http) {
                add_packet_for_uncompressed_frame(pts, duration, data);
-       } else if (global_flags.x264_video_to_http || global_flags.x264_video_to_disk) {
-               x264_encoder->add_frame(pts, duration, frame.ycbcr_coefficients, data, received_ts);
+       } else if (http_encoder != nullptr) {
+               http_encoder->add_frame(pts, duration, frame.ycbcr_coefficients, data, received_ts);
+       } if (disk_encoder != nullptr && disk_encoder != http_encoder) {
+               disk_encoder->add_frame(pts, duration, frame.ycbcr_coefficients, data, received_ts);
        }
 
        if (v4l_output != nullptr) {
@@ -2012,8 +2022,8 @@ void QuickSyncEncoderImpl::encode_frame(QuickSyncEncoderImpl::PendingFrame frame
 }
 
 // Proxy object.
-QuickSyncEncoder::QuickSyncEncoder(const std::string &filename, ResourcePool *resource_pool, QSurface *surface, const string &va_display, int width, int height, AVOutputFormat *oformat, X264Encoder *x264_encoder, DiskSpaceEstimator *disk_space_estimator)
-       : impl(new QuickSyncEncoderImpl(filename, resource_pool, surface, va_display, width, height, oformat, x264_encoder, disk_space_estimator)) {}
+QuickSyncEncoder::QuickSyncEncoder(const std::string &filename, ResourcePool *resource_pool, QSurface *surface, const string &va_display, int width, int height, const AVOutputFormat *oformat, VideoCodecInterface *http_encoder, VideoCodecInterface *disk_encoder, DiskSpaceEstimator *disk_space_estimator)
+       : impl(new QuickSyncEncoderImpl(filename, resource_pool, surface, va_display, width, height, oformat, http_encoder, disk_encoder, disk_space_estimator)) {}
 
 // Must be defined here because unique_ptr<> destructor needs to know the impl.
 QuickSyncEncoder::~QuickSyncEncoder() {}