Core (LV::Video): Implement saving to PNG files.

Author: kaixiong

libvisual/libvisual/lv_video.cpp

@@ -37,10 +37,14 @@
 #include "private/lv_video_bmp.hpp"
 #include "private/lv_video_png.hpp"
 #include <cstring>
+#include <iostream>
 #include <fstream>
+#include <filesystem>
 
 namespace LV {
 
+  namespace fs = std::filesystem;
+
   namespace {
 
     bool is_valid_scale_method (VisVideoScaleMethod scale_method)
@@ -260,6 +264,21 @@ namespace LV {
       return m_impl->buffer->is_allocated ();
   }
 
+  bool Video::save_to_file (std::string const& path) const
+  {
+      auto extension = fs::path {path}.extension ();
+
+      std::ofstream file {path};
+
+      if (extension == ".png") {
+          return bitmap_save_png (*this, file);
+      }
+
+      visual_log (VISUAL_LOG_ERROR, "Unsupported format with extension '%s'.", extension.c_str ());
+
+      return false;
+  }
+
   void Video::copy_attrs (VideoConstPtr const& src)
   {
       set_depth (src->m_impl->depth);

libvisual/libvisual/lv_video.h

@@ -259,6 +259,15 @@ namespace LV {
        */
       BufferPtr get_buffer () const;
 
+      /**
+       * Saves contents to a file.
+       *
+       * @param path Path name of file to save to. Specify the file format by using the appropriate extension.
+       *
+       * @return true if file was successfully saved, false otherwise.
+       */
+      bool save_to_file (std::string const& path) const;
+
       /**
        * Sets all attributes.
        *
@@ -513,6 +522,8 @@ LV_NODISCARD LV_API VisVideo *visual_video_new_with_buffer (int width, int heigh
 LV_NODISCARD LV_API VisVideo *visual_video_new_wrap_buffer (void *buffer, int owner, int width, int height, VisVideoDepth depth, int pitch);
 LV_NODISCARD LV_API VisVideo *visual_video_load_from_file  (const char *path);
 
+LV_API int visual_video_save_to_file (VisVideo *video);
+
 LV_API void visual_video_ref   (VisVideo *video);
 LV_API void visual_video_unref (VisVideo *video);
 

libvisual/libvisual/lv_video_c.cpp

@@ -68,6 +68,13 @@ VisVideo *visual_video_load_from_file (const char *path)
     return self.get ();
 }
 
+int visual_video_save_to_file (VisVideo *self, const char *path)
+{
+    visual_return_val_if_fail (self != nullptr, FALSE);
+
+    return self->save_to_file (path);
+}
+
 int visual_video_has_allocated_buffer (VisVideo *self)
 {
     visual_return_val_if_fail (self != nullptr, FALSE);

libvisual/libvisual/private/lv_video_png.cpp

@@ -22,9 +22,11 @@
 #include "config.h"
 #include "lv_video_png.hpp"
 #include "lv_common.h"
-#include <png.h>
-#include <istream>
+#include <iostream>
+#include <vector>
 #include <csetjmp>
+#include <png.h>
+#include <zlib.h>
 
 namespace LV {
 
@@ -40,20 +42,52 @@ namespace LV {
         }
     }
 
-    void handle_png_warning (png_structp png_ptr, char const* message)
+    void handle_png_write (png_structp png_ptr, png_bytep data, png_size_t length)
+    {
+        auto  io_ptr = png_get_io_ptr (png_ptr);
+        auto& output = *static_cast<std::ostream*> (io_ptr);
+
+        if (!output.write(reinterpret_cast<char*>(data), length)) {
+            std::longjmp (png_jmpbuf (png_ptr), -1);
+        }
+    }
+
+    void handle_png_flush (png_structp png_ptr)
+    {
+        auto  io_ptr = png_get_io_ptr (png_ptr);
+        auto& output = *static_cast<std::ostream*> (io_ptr);
+
+        output.flush ();
+    }
+
+    void handle_png_load_warning (png_structp png_ptr, char const* message)
     {
         (void)png_ptr;
 
         visual_log (VISUAL_LOG_WARNING, "PNG load error: %s", message);
     }
 
-    void handle_png_error (png_structp png_ptr, char const* message)
+    void handle_png_load_error (png_structp png_ptr, char const* message)
     {
         (void)png_ptr;
 
         visual_log (VISUAL_LOG_ERROR, "PNG load error: %s", message);
     }
 
+    void handle_png_save_warning (png_structp png_ptr, char const* message)
+    {
+        (void)png_ptr;
+
+        visual_log (VISUAL_LOG_WARNING, "PNG save error: %s", message);
+    }
+
+    void handle_png_save_error (png_structp png_ptr, char const* message)
+    {
+        (void)png_ptr;
+
+        visual_log (VISUAL_LOG_ERROR, "PNG save error: %s", message);
+    }
+
   } // anonymous
 
   VideoPtr bitmap_load_png (std::istream& input)
@@ -69,7 +103,10 @@ namespace LV {
           return nullptr;
       }
 
-      auto png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, nullptr, handle_png_error, handle_png_warning);
+      auto png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING,
+                                             nullptr,
+                                             handle_png_load_error,
+                                             handle_png_load_warning);
       if (!png_ptr) {
           return nullptr;
       }
@@ -176,4 +213,103 @@ namespace LV {
       return Video::wrap (pixels, true, width, height, depth);
   }
 
+  bool bitmap_save_png(Video const& bitmap, std::ostream &output)
+  {
+      auto saved_stream_pos = output.tellp ();
+
+      auto png_ptr = png_create_write_struct (PNG_LIBPNG_VER_STRING,
+                                              nullptr,
+                                              handle_png_save_error,
+                                              handle_png_save_warning);
+      if (!png_ptr) {
+          visual_log (VISUAL_LOG_ERROR, "Failed to create PNG write struct.");
+          return false;
+      }
+
+      auto info_ptr = png_create_info_struct (png_ptr);
+      if (!info_ptr) {
+          visual_log (VISUAL_LOG_ERROR, "Failed to create PNG info struct.");
+          png_destroy_write_struct (&png_ptr, nullptr);
+          return false;
+      }
+
+      auto bitmap_width = bitmap.get_width ();
+      auto bitmap_height = bitmap.get_height ();
+
+      std::vector<png_byte*> pixel_row_ptrs;
+      pixel_row_ptrs.reserve (bitmap_height);
+
+      for (auto y = 0; y < bitmap_height; y++) {
+          pixel_row_ptrs.push_back (static_cast<png_byte *> (bitmap.get_pixel_ptr (0, y)));
+      }
+
+      if (setjmp (png_jmpbuf (png_ptr))) {
+          visual_log (VISUAL_LOG_ERROR, "Some error occurred.");
+          output.seekp (saved_stream_pos);
+          png_destroy_write_struct (&png_ptr, &info_ptr);
+      }
+
+      int bit_depth = 0;
+      int color_type = 0;
+
+      switch (bitmap.get_depth ()) {
+          case VISUAL_VIDEO_DEPTH_8BIT: {
+              bit_depth = 8;
+              color_type = PNG_COLOR_TYPE_PALETTE;
+              break;
+          }
+          case VISUAL_VIDEO_DEPTH_24BIT: {
+              bit_depth = 8;
+              color_type = PNG_COLOR_TYPE_RGB;
+              break;
+          }
+          case VISUAL_VIDEO_DEPTH_32BIT: {
+              bit_depth = 8;
+              color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+              break;
+          }
+          default: {
+              visual_log (VISUAL_LOG_ERROR, "Invalid depth or depth not supported.");
+              return false;
+          }
+      }
+
+#if VISUAL_LITTLE_ENDIAN
+      png_set_bgr (png_ptr);
+#endif
+
+      png_set_filter (png_ptr, 0, PNG_FILTER_NONE);
+
+      png_set_compression_level (png_ptr, Z_BEST_COMPRESSION);
+
+      png_set_IHDR (png_ptr, info_ptr, bitmap_width, bitmap_height,
+                    bit_depth, color_type, PNG_INTERLACE_NONE,
+                    PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+
+      if (color_type == PNG_COLOR_TYPE_PALETTE) {
+          auto const& colors = bitmap.get_palette ().colors;
+
+          std::vector<png_color> out_palette;
+          out_palette.reserve (colors.size ());
+
+          for (auto const& color : colors) {
+              out_palette.push_back ({color.r, color.g, color.b});
+          }
+
+          png_set_PLTE (png_ptr, info_ptr, out_palette.data (), out_palette.size ());
+      }
+
+      png_set_sRGB (png_ptr, info_ptr, PNG_sRGB_INTENT_PERCEPTUAL);
+
+      png_set_write_fn (png_ptr, &output, handle_png_write, handle_png_flush);
+
+      png_write_info (png_ptr, info_ptr);
+      png_write_rows (png_ptr, pixel_row_ptrs.data (), bitmap_height);
+      png_write_end (png_ptr, info_ptr);
+
+      png_destroy_write_struct (&png_ptr, &info_ptr);
+
+      return true;
+  }
+
 } // LV namespace

libvisual/libvisual/private/lv_video_png.hpp

@@ -26,7 +26,11 @@
 #include <iosfwd>
 
 namespace LV {
+
   VideoPtr bitmap_load_png (std::istream& input);
-}
+
+  bool bitmap_save_png (Video const& bitmap, std::ostream& output);
+
+} // LV namespace
 
 #endif // _LV_VIDEO_BMP_HPP