X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=nageru%2Fmjpeg_encoder.h;h=6ba7f0381bad3a1f3f1ec879e07cf44dcaf7260b;hb=bcd177e1daf5a63d7bf877bc5d30d8803dfd472c;hp=f3c9d9946aec6b8e301f80b0583b072deffc459d;hpb=271ddbb0c7e84560e73e89b1a125576477f95380;p=nageru diff --git a/nageru/mjpeg_encoder.h b/nageru/mjpeg_encoder.h index f3c9d99..6ba7f03 100644 --- a/nageru/mjpeg_encoder.h +++ b/nageru/mjpeg_encoder.h @@ -1,7 +1,9 @@ #ifndef _MJPEG_ENCODER_H #define _MJPEG_ENCODER_H 1 +#include "defs.h" #include "shared/ffmpeg_raii.h" +#include "shared/httpd.h" #include "ref_counted_frame.h" extern "C" { @@ -20,53 +22,132 @@ extern "C" { #include #include +#include #include -class HTTPD; struct jpeg_compress_struct; struct VADisplayWithCleanup; struct VectorDestinationManager; +#define CHECK_VASTATUS(va_status, func) \ + if (va_status != VA_STATUS_SUCCESS) { \ + fprintf(stderr, "%s:%d (%s) failed with %d\n", __func__, __LINE__, func, va_status); \ + exit(1); \ + } + class MJPEGEncoder { public: MJPEGEncoder(HTTPD *httpd, const std::string &va_display); ~MJPEGEncoder(); void stop(); - void upload_frame(int64_t pts, unsigned card_index, RefCountedFrame frame, const bmusb::VideoFormat &video_format, size_t y_offset, size_t cbcr_offset); + void upload_frame(int64_t pts, unsigned card_index, RefCountedFrame frame, const bmusb::VideoFormat &video_format, size_t y_offset, size_t cbcr_offset, std::vector audio, const movit::RGBTriplet &white_balance); + bool using_vaapi() const { return va_dpy != nullptr; } + + bool should_encode_mjpeg_for_card(unsigned card_index); private: static constexpr int quality = 90; + struct VAResources { + unsigned width, height; + VASurfaceID surface; + VAContextID context; + VABufferID data_buffer; + VAImage image; + }; + + // RAII wrapper to release VAResources on return (even on error). + class ReleaseVAResources { + public: + ReleaseVAResources() : committed(true) {} + + ReleaseVAResources(MJPEGEncoder *mjpeg, const VAResources &resources) + : mjpeg(mjpeg), resources(resources) {} + + ReleaseVAResources(ReleaseVAResources &) = delete; + + ReleaseVAResources(ReleaseVAResources &&other) + : mjpeg(other.mjpeg), resources(other.resources), committed(other.committed) { + other.commit(); + } + + ReleaseVAResources &operator= (ReleaseVAResources &) = delete; + + ReleaseVAResources &operator= (ReleaseVAResources &&other) { + if (!committed) { + mjpeg->release_va_resources(resources); + } + mjpeg = other.mjpeg; + resources = std::move(other.resources); + committed = other.committed; + other.commit(); + return *this; + } + + ~ReleaseVAResources() + { + if (!committed) { + mjpeg->release_va_resources(resources); + } + } + + void commit() { committed = true; } + + private: + MJPEGEncoder *mjpeg = nullptr; + VAResources resources; + bool committed = false; + }; + struct QueuedFrame { int64_t pts; unsigned card_index; RefCountedFrame frame; bmusb::VideoFormat video_format; size_t y_offset, cbcr_offset; + std::vector audio; + movit::RGBTriplet white_balance; + + // Only for frames in the process of being encoded by VA-API. + VAResources resources; + ReleaseVAResources resource_releaser; }; void encoder_thread_func(); - std::vector encode_jpeg(const QueuedFrame &qf); - std::vector encode_jpeg_va(const QueuedFrame &qf); + void va_receiver_thread_func(); + void encode_jpeg_va(QueuedFrame &&qf); std::vector encode_jpeg_libjpeg(const QueuedFrame &qf); - void init_jpeg_422(unsigned width, unsigned height, VectorDestinationManager *dest, jpeg_compress_struct *cinfo); - std::vector get_jpeg_header(unsigned width, unsigned height, jpeg_compress_struct *cinfo); - + void write_mjpeg_packet(AVFormatContext *avctx, int64_t pts, unsigned stream_index, const uint8_t *jpeg, size_t jpeg_size); + void write_audio_packet(AVFormatContext *avctx, int64_t pts, unsigned stream_index, const std::vector &audio); + void init_jpeg_422(unsigned width, unsigned height, const movit::RGBTriplet &white_balance, VectorDestinationManager *dest, jpeg_compress_struct *cinfo); + std::vector get_jpeg_header(unsigned width, unsigned height, const movit::RGBTriplet &white_balance, jpeg_compress_struct *cinfo); + void add_stream(HTTPD::StreamID stream_id); // Can only be called from the constructor, or the thread owning . + void update_siphon_streams(); // Same. + void create_ffmpeg_context(HTTPD::StreamID stream_id); + + struct WritePacket2Context { + MJPEGEncoder *mjpeg_encoder; + HTTPD::StreamID stream_id; + }; + std::map ffmpeg_contexts; // Statically set up, so we never need to worry about dangling pointers. static int write_packet2_thunk(void *opaque, uint8_t *buf, int buf_size, AVIODataMarkerType type, int64_t time); - int write_packet2(uint8_t *buf, int buf_size, AVIODataMarkerType type, int64_t time); + int write_packet2(HTTPD::StreamID stream_id, uint8_t *buf, int buf_size, AVIODataMarkerType type, int64_t time); - std::thread encoder_thread; + std::thread encoder_thread, va_receiver_thread; std::mutex mu; std::queue frames_to_be_encoded; // Under mu. - std::condition_variable any_frames_to_be_encoded; + std::condition_variable any_frames_to_be_encoded; // Governs changes in both frames_to_be_encoded and frames_under_encoding - std::queue frames_encoding; // Under mu. + std::queue frames_encoding; // Under mu. Used for VA-API only. std::condition_variable any_frames_encoding; - AVFormatContextWithCloser avctx; + struct Stream { + AVFormatContextWithCloser avctx; + std::string mux_header; + }; + std::map streams; // Owned by the VA-API receiver thread if VA-API is active, or the encoder thread if not. HTTPD *httpd; - std::string mux_header; std::atomic should_quit{false}; bool running = false; @@ -81,42 +162,25 @@ private: VAEncSliceParameterBufferJPEG parms; }; std::map, VAData> va_data_for_resolution; - VAData get_va_data_for_resolution(unsigned width, unsigned height); + VAData get_va_data_for_resolution(unsigned width, unsigned height, const movit::RGBTriplet &white_balance); - struct VAResources { - unsigned width, height; - VASurfaceID surface; - VAContextID context; - VABufferID data_buffer; - }; std::list va_resources_freelist; std::mutex va_resources_mutex; VAResources get_va_resources(unsigned width, unsigned height); void release_va_resources(VAResources resources); - // RAII wrapper to release VAResources on return (even on error). - class ReleaseVAResources { - public: - ReleaseVAResources(MJPEGEncoder *mjpeg, const VAResources &resources) - : mjpeg(mjpeg), resources(resources) {} - ~ReleaseVAResources() - { - if (!committed) { - mjpeg->release_va_resources(resources); - } - } - - void commit() { committed = true; } + static std::unique_ptr try_open_va(const std::string &va_display, std::string *error, VAConfigID *config_id); - private: - MJPEGEncoder * const mjpeg; - const VAResources &resources; - bool committed = false; - }; + uint8_t *tmp_y, *tmp_cbcr, *tmp_cb, *tmp_cr; // Private to the encoder thread. Used by the libjpeg backend only. - static std::unique_ptr try_open_va(const std::string &va_display, std::string *error, VAConfigID *config_id); + std::atomic metric_mjpeg_frames_zero_size_dropped{0}; + std::atomic metric_mjpeg_frames_interlaced_dropped{0}; + std::atomic metric_mjpeg_frames_unsupported_pixel_format_dropped{0}; + std::atomic metric_mjpeg_frames_oversized_dropped{0}; + std::atomic metric_mjpeg_overrun_dropped{0}; + std::atomic metric_mjpeg_overrun_submitted{0}; - uint8_t *tmp_y, *tmp_cbcr, *tmp_cb, *tmp_cr; // Private to the encoder thread. + friend class PBOFrameAllocator; // FIXME }; #endif // !defined(_MJPEG_ENCODER_H)