/* * WiVRn VR streaming * Copyright (C) 2022 Guillaume Meunier * Copyright (C) 2022 Patrick Nicolas * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #pragma once #include "driver/clock_offset.h" #include "idr_handler.h" #include "wivrn_packets.h" #include #include #include #include #include #include #include #include #include namespace wivrn { struct encoder_settings; struct vk_bundle; class wivrn_session; inline const char * encoder_nvenc = "nvenc"; inline const char * encoder_vaapi = "vaapi"; inline const char * encoder_x264 = "x264"; inline const char * encoder_vulkan = "vulkan"; inline const char * encoder_raw = "raw"; class video_encoder { protected: struct data { video_encoder * encoder; std::span span; std::shared_ptr mem; // true if data should be sent over reliable (TCP) socket bool prefer_control = false; }; private: class sender { std::mutex mutex; std::condition_variable cv; std::deque pending; std::jthread thread; void run(); sender(); public: void push(data &&); static std::shared_ptr get(); void wait_idle(video_encoder *); }; public: const uint8_t stream_idx; const uint32_t target_queue; const bool need_transfer; // Layout the encoder needs y_cbcr to arrive in. Set during construction // or init() and read by the compositor on every layer_commit — must not // change after the first frame. vk::ImageLayout target_layout = vk::ImageLayout::eGeneral; static const uint8_t num_slots = 2; const double bitrate_multiplier; private: using state_t = std::atomic_unsigned_lock_free::value_type; static const state_t idle = 0; static const state_t busy = 1; static const state_t skip = 2; std::array state = {idle, idle}; uint8_t present_slot = 0; uint8_t encode_slot = 0; std::mutex mutex; // temporary data wivrn_session * cnx; // shard to send to_headset::video_stream_data_shard shard; to_headset::video_stream_data_shard::timing_info_t timing_info; clock_offset clock; std::ofstream video_dump; std::shared_ptr shared_sender; protected: std::atomic_uint32_t pending_bitrate; std::atomic pending_framerate; std::unique_ptr idr; const vk::Extent2D extent; public: static std::unique_ptr create( wivrn::vk_bundle &, const encoder_settings & settings, uint8_t stream_idx); video_encoder(vk_bundle &, uint8_t stream_idx, uint32_t target_queue, const encoder_settings & settings, std::unique_ptr, bool async_send); virtual ~video_encoder(); void present_image(vk::Image y_cbcr, vk::SemaphoreSubmitInfo sem_info, uint64_t frame_index); void on_feedback(const from_headset::feedback &); void reset(); // bitrate_bps is the bitrate for the whole stream // the encoder bitrate will be scaled accordingly void set_bitrate(uint32_t bitrate_bps); void set_framerate(float framerate); void encode(wivrn_session & cnx, const to_headset::video_stream_data_shard::view_info_t & view_info, uint64_t frame_index); protected: // called on present to submit command buffers for the image. virtual void present_image(vk::Image y_cbcr, vk::SemaphoreSubmitInfo sem_info, uint8_t slot, uint64_t frame_index) = 0; // called when command buffer finished executing virtual std::optional encode(uint8_t slot, uint64_t frame_index) = 0; void SendData(std::span data, bool end_of_frame, bool control = false); }; } // namespace wivrn