Worked on the encoder.

liblava/frame/renderer.cpp

@@ -134,9 +134,11 @@ namespace lava {
         std::array<VkSemaphore, 1> const wait_semaphores = { image_acquired_semaphores[current_sync] };
         std::array<VkSemaphore, 1> const sync_present_semaphores = { render_complete_semaphores[current_sync] };
 
-        std::vector<VkSemaphore> complete_semaphores = frame_semaphores;
-        complete_semaphores.push_back(render_complete_semaphores[current_sync]);
-        frame_semaphores.clear();
+        std::vector<VkSemaphore> complete_semaphores = { render_complete_semaphores[current_sync] };
+        
+        for (frame_attachment& attachment : attachments) {
+            complete_semaphores.push_back(attachment.semaphore);
+        }
 
         VkPipelineStageFlags const wait_stage = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
 
@@ -157,6 +159,12 @@ namespace lava {
         if (!device->vkQueueSubmit(graphics_queue.vk_queue, to_ui32(submit_infos.size()), submit_infos.data(), current_fence))
             return false;
 
+        for (frame_attachment& attachment : attachments) {
+            attachment.callback();
+        }
+
+        attachments.clear();
+
         std::array<VkSwapchainKHR, 1> const swapchains = { target->get() };
         std::array<ui32, 1> const indices = { current_frame };
 

liblava/frame/renderer.hpp

@@ -11,6 +11,14 @@ namespace lava {
 
     using optional_index = std::optional<index>;
 
+    struct frame_attachment
+    {
+        VkSemaphore semaphore;
+        std::function<void(void)> callback;
+    };
+
+    using frame_attachments = std::vector<frame_attachment>;
+
     struct renderer : id_obj {
         bool create(swapchain* target);
         void destroy();
@@ -37,8 +45,8 @@ namespace lava {
             return graphics_queue;
         }
 
-        void add_semaphore(VkSemaphore semaphore){
-            frame_semaphores.push_back(semaphore);
+        void add_attachment(frame_attachment attachment) {
+            attachments.push_back(attachment);
         }
 
         using destroy_func = std::function<void()>;
@@ -60,7 +68,8 @@ namespace lava {
         VkFences fences_in_use = {};
         VkSemaphores image_acquired_semaphores = {};
         VkSemaphores render_complete_semaphores = {};
-        VkSemaphores frame_semaphores = {};
+
+        frame_attachments attachments = {};
     };
 
 } // namespace lava

src/encoder.hpp

@@ -26,9 +26,16 @@ public:
 
     VkImageView input_view_luma = nullptr;
     VkImageView input_view_chroma = nullptr;
+    VkImageView input_view_combined = nullptr;
+
+    VmaAllocation slot_memory_luma;
+    VmaAllocation slot_memory_chroma;
+
+    VkImage slot_image = nullptr;
+    VkImageView slot_view = nullptr;
 
     uint32_t output_query_index = 0;
-	lava::buffer::ptr output_buffer; //TODO: create the output buffer
+    lava::buffer::ptr output_buffer;
 
     VkDescriptorSet convert_descriptor = nullptr;
     lava::graphics_pipeline::ptr convert_pipeline;
@@ -84,6 +91,7 @@ private:
     bool aquire_frame(encoder_frame::ptr& frame);
     bool submit_frame(lava::device_ptr device, encoder_frame::ptr frame, lava::renderer& renderer);
     void write_image(lava::device_ptr device, encoder_frame::ptr frame, lava::image::ptr image);
+    bool record_encoding(lava::device_ptr device, encoder_frame::ptr frame);
 
     bool create_profiles(lava::device_ptr device);
     bool create_session(lava::device_ptr device, const glm::uvec2& size);
@@ -97,21 +105,25 @@ private:
     bool create_input_images(lava::device_ptr device, encoder_frame::ptr frame, const glm::uvec2& size);
     bool create_image_memory(lava::device_ptr device, VkImage image, VkImageAspectFlagBits image_plane, VmaAllocation& memory);
     bool create_image_view(lava::device_ptr device, VkImage image, VkFormat image_format, VkImageView& image_view);
+    bool create_slot_image(lava::device_ptr device, encoder_frame::ptr frame, const glm::uvec2& size);
     bool create_output_buffer(lava::device_ptr device, encoder_frame::ptr frame);
 
     bool create_convert_pass(lava::device_ptr device, encoder_frame::ptr frame, const glm::uvec2& size);
     bool create_convert_pipeline(lava::device_ptr device, encoder_frame::ptr frame);
-	bool create_encode_resources(lava::device_ptr device, encoder_frame::ptr frame);
+    bool create_encode_resources(lava::device_ptr device, encoder_frame::ptr frame, const glm::uvec2& size);
 
     bool check_encode_support(lava::device_ptr device, const lava::queue& queue) const;
     bool check_format_support(lava::device_ptr device, VkImageUsageFlags usage, VkFormat format) const;
 
     void convert_pass(VkCommandBuffer command_buffer);
-	void encode_pass(VkCommandBuffer command_buffer, encoder_frame::ptr frame);
+    void encode_pass_setup(VkCommandBuffer command_buffer, encoder_frame::ptr frame);
+    void encode_pass_command(VkCommandBuffer command_buffer, encoder_frame::ptr frame);
+    void encode_pass_contol(VkCommandBuffer command_buffer, encoder_frame::ptr frame);
 
 private:
     glm::uvec2 size;
     uint32_t frame_count = 0;
+    uint32_t frame_index = 0;
     
     encoder_callback callback;
     encoder_thread::ptr thread;

src/naive_stereo.cpp

@@ -30,13 +30,6 @@ bool naive_stereo::create() {
 }
 
 void naive_stereo::render(VkCommandBuffer command_buffer, lava::index frame) {
-    for (auto& eye_pass : render_passes_) {
-        eye_pass.render_pass->process(command_buffer, 0);
-    }
-
-    frame_capture().capture_image(command_buffer, app()->left_eye_framebuffer()->color_image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, "left_eye");
-    frame_capture().capture_image(command_buffer, app()->right_eye_framebuffer()->color_image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, "right_eye");
-
     pass_timer().begin_pass(command_buffer, "left_eye");
     render_passes_[0].render_pass->process(command_buffer, 0);
     pass_timer().end_pass(command_buffer);
@@ -44,6 +37,11 @@ void naive_stereo::render(VkCommandBuffer command_buffer, lava::index frame) {
     pass_timer().begin_pass(command_buffer, "right_eye");
     render_passes_[1].render_pass->process(command_buffer, 0);
     pass_timer().end_pass(command_buffer);
+
+    frame_capture().capture_image(command_buffer, app()->left_eye_framebuffer()->color_image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, "left_eye");
+    frame_capture().capture_image(command_buffer, app()->right_eye_framebuffer()->color_image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, "right_eye");
+
+    encoder().encode(command_buffer, renderer(), app()->left_eye_framebuffer()->color_image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
 }
 
 naive_stereo::eye_render_pass naive_stereo::create_render_pass(const stereo_framebuffer::ptr& framebuffer) {

src/stereo_strategy.cpp

@@ -12,3 +12,13 @@ pass_timer& stereo_strategy::pass_timer() const
 {
 	return app_->pass_timer();
 }
+
+lava::renderer& stereo_strategy::renderer() const
+{
+    return app_->renderer();
+}
+
+encoder& stereo_strategy::encoder() const
+{
+    return app_->encoder();
+}
\ No newline at end of file

src/stereo_strategy.hpp

@@ -6,6 +6,7 @@
 class vr_app;
 class frame_capture;
 class pass_timer;
+class encoder;
 
 class stereo_strategy {
 public:
@@ -19,6 +20,8 @@ public:
     inline vr_app* app() const { return app_; }
     frame_capture& frame_capture() const;
     pass_timer& pass_timer() const;
+    lava::renderer& renderer() const;
+    encoder& encoder() const;
 
 private:
     vr_app* app_;

src/vr_app.cpp

@@ -182,6 +182,11 @@ bool vr_app::setup() {
         return false;
     }
     
+    if(std::filesystem::exists("video.h264"))
+    {
+        std::filesystem::remove("video.h264");
+    }
+
     encoder_callback callback = [](const uint8_t* data, uint32_t size)
     {
         std::fstream file;

src/vr_app.hpp

@@ -23,6 +23,8 @@ public:
     auto scene() { return scene_; }
     auto& frame_capture() { return frame_capture_; }
     auto& pass_timer() { return pass_timer_; }
+    auto& renderer() { return app_->renderer; }
+    auto& encoder() { return encoder_; }
 
     auto per_frame_descriptor() const { return per_frame_descriptor_; }