diff --git a/libvisual/CMakeLists.txt b/libvisual/CMakeLists.txt
index 4409400c..c1706c96 100644
--- a/libvisual/CMakeLists.txt
+++ b/libvisual/CMakeLists.txt
@@ -82,8 +82,11 @@ IF(NOT HAVE_STDC_MATH)
   MESSAGE(FATAL_ERROR "Libvisual requires libm to build")
 ENDIF()
 
+# Check for Zlib
+FIND_PACKAGE(ZLIB 1.2 REQUIRED)
+
 # Check for libpng
-FIND_PACKAGE(PNG REQUIRED)
+FIND_PACKAGE(PNG 1.4 REQUIRED)
 
 # Internationalization
 SET(GETTEXT_PACKAGE "libvisual-${LV_VERSION_SUFFIX}")
diff --git a/libvisual/libvisual/CMakeLists.txt b/libvisual/libvisual/CMakeLists.txt
index c784cf71..cf089d28 100644
--- a/libvisual/libvisual/CMakeLists.txt
+++ b/libvisual/libvisual/CMakeLists.txt
@@ -176,6 +176,7 @@ TARGET_LINK_LIBRARIES(libvisual
   PkgConfig::ORC
   PNG::PNG
   Threads::Threads
+  ZLIB::ZLIB
 )
 
 IF(WIN32)
diff --git a/libvisual/libvisual/lv_video.cpp b/libvisual/libvisual/lv_video.cpp
index 9bb5f1b1..b97af6a7 100644
--- a/libvisual/libvisual/lv_video.cpp
+++ b/libvisual/libvisual/lv_video.cpp
@@ -29,6 +29,7 @@
 #include "lv_color.h"
 #include "lv_common.h"
 #include "lv_cpu.h"
+#include "private/lv_string_hash.hpp"
 #include "private/lv_video_private.hpp"
 #include "private/lv_video_blit.hpp"
 #include "private/lv_video_convert.hpp"
@@ -36,19 +37,79 @@
 #include "private/lv_video_transform.hpp"
 #include "private/lv_video_bmp.hpp"
 #include "private/lv_video_png.hpp"
+#include <algorithm>
+#include <cctype>
 #include <cstring>
+#include <filesystem>
 #include <fstream>
+#include <functional>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <vector>
 
 namespace LV {
 
+  namespace fs = std::filesystem;
+
   namespace {
 
+    using BitmapReader = std::function<VideoPtr (std::istream&)>;
+    using BitmapWriter = std::function<bool (Video const&, std::ostream&)>;
+
+    struct ImageFormatInfo
+    {
+        std::string              name;
+        BitmapReader             reader;
+        BitmapWriter             writer;
+        std::vector<std::string> extensions;
+    };
+
+    using ImageFormatExtensionLookup = std::unordered_map<
+        std::string, ImageFormat, StringHash, std::equal_to<>>;
+
+    std::unordered_map<ImageFormat, ImageFormatInfo> const supported_image_formats
+    {
+        {ImageFormat::BMP, {"BMP", bitmap_load_bmp, nullptr, {".bmp"}}},
+        {ImageFormat::PNG, {"PNG", bitmap_load_png, bitmap_save_png, {".png"}}}
+    };
+
+    ImageFormatExtensionLookup build_image_format_extension_lookup ()
+    {
+        ImageFormatExtensionLookup map;
+
+        for (auto const& entry : supported_image_formats)
+            for (auto const& extension : entry.second.extensions)
+                map.emplace (extension, entry.first);
+
+        return map;
+    }
+
+    std::optional<ImageFormat> find_image_format_by_extension (std::string_view extension)
+    {
+        static auto const lookup {build_image_format_extension_lookup ()};
+
+        auto match {lookup.find (extension)};
+        if (match == lookup.end ())
+            return std::nullopt;
+        return match->second;
+    }
+
     bool is_valid_scale_method (VisVideoScaleMethod scale_method)
     {
         return scale_method == VISUAL_VIDEO_SCALE_NEAREST
             || scale_method == VISUAL_VIDEO_SCALE_BILINEAR;
     }
 
+    // TODO: Factor this out into a string utility library
+    std::string to_lower_ascii (std::string const& s)
+    {
+        auto result {s};
+        for (auto& c : result)
+            c = std::tolower (c);
+        return result;
+    }
+
   } // anonymous namespace
 
 
@@ -191,17 +252,16 @@ namespace LV {
 
   VideoPtr Video::create_from_stream (std::istream& input)
   {
-      auto image = bitmap_load_bmp (input);
-      if (image) {
-          return image;
-      }
-
-      image = bitmap_load_png (input);
-      if (image) {
-          return image;
+      for (auto entry : supported_image_formats) {
+          if (entry.second.reader) {
+              auto image {entry.second.reader (input)};
+              if (image) {
+                  return image;
+              }
+          }
       }
 
-      return {};
+      return nullptr;
   }
 
   VideoPtr Video::create_scale_depth (VideoConstPtr const& src,
@@ -260,6 +320,43 @@ namespace LV {
       return m_impl->buffer->is_allocated ();
   }
 
+  bool Video::save_to_file (std::string const& path) const
+  {
+      auto extension {fs::path {path}.extension ()};
+      auto extension_lower (to_lower_ascii (extension.string ()));
+
+      auto format {find_image_format_by_extension (extension_lower)};
+      if (!format.has_value ()) {
+          visual_log (VISUAL_LOG_ERROR, "Could not deduce format from filename (%s)", path.c_str ());
+          return false;
+      }
+
+      std::ofstream output {path};
+      if (!output) {
+          visual_log (VISUAL_LOG_ERROR, "Could not create file '%s'", path.c_str ());
+          return false;
+      }
+
+      return save_to_stream (output, format.value ());
+  }
+
+  bool Video::save_to_stream (std::ostream& output, ImageFormat format) const
+  {
+      auto entry {supported_image_formats.find (format)};
+
+      if (entry == supported_image_formats.end ()) {
+          visual_log (VISUAL_LOG_ERROR, "Saving to unknown format (%d).", static_cast<int> (format));
+          return false;
+      }
+
+      if (!entry->second.writer) {
+          visual_log (VISUAL_LOG_ERROR, "Saving to %s is unsupported.", entry->second.name.c_str ());
+          return false;
+      }
+
+      return entry->second.writer (*this, output);
+  }
+
   void Video::copy_attrs (VideoConstPtr const& src)
   {
       set_depth (src->m_impl->depth);
diff --git a/libvisual/libvisual/lv_video.h b/libvisual/libvisual/lv_video.h
index 793375d0..3c1f3fec 100644
--- a/libvisual/libvisual/lv_video.h
+++ b/libvisual/libvisual/lv_video.h
@@ -96,6 +96,14 @@ typedef enum {
     VISUAL_VIDEO_COMPOSE_TYPE_CUSTOM      /**< Custom compose function (looks up on the source VisVideo. */
 } VisVideoComposeType;
 
+/**
+ * The set of known and supported image formats.
+ */
+typedef enum {
+    VISUAL_IMAGE_FORMAT_BMP = 0,
+    VISUAL_IMAGE_FORMAT_PNG
+} VisImageFormat;
+
 typedef struct _VisVideoAttrOptions VisVideoAttrOptions;
 
 #ifdef __cplusplus
@@ -125,6 +133,15 @@ struct _VisVideoAttrOptions {
 
 namespace LV {
 
+  /**
+   * The set of known and supported image formats.
+   */
+  enum class ImageFormat
+  {
+      BMP = VISUAL_IMAGE_FORMAT_BMP,
+      PNG = VISUAL_IMAGE_FORMAT_PNG
+  };
+
   class Video;
 
   typedef IntrusivePtr<Video> VideoPtr;
@@ -259,6 +276,25 @@ 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;
+
+      /**
+       * Saves contents to a stream.
+       *
+       * @param output stream to write contents to.
+       * @param format image file format to encode contents in.
+       *
+       * @return true if file was successfully saved, false otherwise.
+       */
+      bool save_to_stream (std::ostream& output, ImageFormat format) const;
+
       /**
        * Sets all attributes.
        *
@@ -513,6 +549,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);
 
diff --git a/libvisual/libvisual/lv_video_c.cpp b/libvisual/libvisual/lv_video_c.cpp
index 3c423695..66619301 100644
--- a/libvisual/libvisual/lv_video_c.cpp
+++ b/libvisual/libvisual/lv_video_c.cpp
@@ -68,6 +68,14 @@ 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);
+    visual_return_val_if_fail (path != nullptr, FALSE);
+
+    return self->save_to_file (path);
+}
+
 int visual_video_has_allocated_buffer (VisVideo *self)
 {
     visual_return_val_if_fail (self != nullptr, FALSE);
diff --git a/libvisual/libvisual/private/lv_video_png.cpp b/libvisual/libvisual/private/lv_video_png.cpp
index 1bea1107..5bbb887b 100644
--- a/libvisual/libvisual/private/lv_video_png.cpp
+++ b/libvisual/libvisual/private/lv_video_png.cpp
@@ -22,9 +22,12 @@
 #include "config.h"
 #include "lv_video_png.hpp"
 #include "lv_common.h"
-#include <png.h>
-#include <istream>
+#include <iostream>
+#include <bit>
+#include <vector>
 #include <csetjmp>
+#include <png.h>
+#include <zlib.h>
 
 namespace LV {
 
@@ -32,28 +35,60 @@ namespace LV {
 
     void handle_png_read (png_structp png_ptr, png_bytep data, png_size_t length)
     {
-        auto  io_ptr = png_get_io_ptr (png_ptr);
-        auto& input  = *static_cast<std::istream*> (io_ptr);
+        auto  io_ptr {png_get_io_ptr (png_ptr)};
+        auto& input  {*static_cast<std::istream*> (io_ptr)};
 
         if (!input.read (reinterpret_cast<char*> (data), length)) {
             std::longjmp (png_jmpbuf (png_ptr), -1);
         }
     }
 
-    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 +104,7 @@ namespace LV {
           return nullptr;
       }
 
-      bool is_png = !png_sig_cmp (signature, 0, sizeof (signature));
+      auto is_png {!png_sig_cmp (signature, 0, sizeof (signature))};
 
       // Clean up test by rewinding to the beginning, like we have read nothing.
       if (!input.seekg (start_stream_pos)) {
@@ -80,18 +115,21 @@ 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;
       }
 
-      auto info_ptr = png_create_info_struct (png_ptr);
+      auto info_ptr {png_create_info_struct (png_ptr)};
       if (!info_ptr) {
           png_destroy_read_struct (&png_ptr, nullptr, nullptr);
           return nullptr;
       }
 
-      auto end_info = png_create_info_struct (png_ptr);
+      auto end_info {png_create_info_struct (png_ptr)};
       if (!end_info) {
           png_destroy_read_struct (&png_ptr, &info_ptr, nullptr);
           return nullptr;
@@ -124,8 +162,8 @@ namespace LV {
 
       png_read_info (png_ptr, info_ptr);
 
-      auto color_type = png_get_color_type (png_ptr, info_ptr);
-      auto bit_depth  = png_get_bit_depth (png_ptr, info_ptr);
+      auto color_type {png_get_color_type (png_ptr, info_ptr)};
+      auto bit_depth  {png_get_bit_depth (png_ptr, info_ptr)};
 
       if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8) {
           png_set_expand_gray_1_2_4_to_8 (png_ptr);
@@ -148,13 +186,13 @@ namespace LV {
           png_set_gray_to_rgb (png_ptr);
       }
 
-#if VISUAL_LITTLE_ENDIAN
-      png_set_bgr (png_ptr);
-#endif
+      if constexpr (std::endian::native == std::endian::little) {
+          png_set_bgr (png_ptr);
+      }
 
       png_read_update_info (png_ptr, info_ptr);
 
-      VisVideoDepth depth = VISUAL_VIDEO_DEPTH_NONE;
+      auto depth {VISUAL_VIDEO_DEPTH_NONE};
 
       switch (png_get_color_type (png_ptr, info_ptr)) {
           case PNG_COLOR_TYPE_PALETTE:
@@ -170,9 +208,9 @@ namespace LV {
               std::longjmp (png_jmpbuf (png_ptr), -1);
       }
 
-      auto width      = png_get_image_width (png_ptr, info_ptr);
-      auto height     = png_get_image_height (png_ptr, info_ptr);
-      auto row_stride = png_get_rowbytes (png_ptr, info_ptr);
+      auto width      {png_get_image_width (png_ptr, info_ptr)};
+      auto height     {png_get_image_height (png_ptr, info_ptr)};
+      auto row_stride {png_get_rowbytes (png_ptr, info_ptr)};
 
       // NOTE: We have to use visual_mem_malloc() here as LV::Video
       // will free the buffer with visual_mem_free()
@@ -180,7 +218,7 @@ namespace LV {
 
       pixel_row_ptrs = new uint8_t*[height];
 
-      for (unsigned int y = 0; y < height; y++) {
+      for (unsigned int y {0}; y < height; y++) {
           pixel_row_ptrs[y] = pixels + y * row_stride;
       }
 
@@ -212,4 +250,103 @@ namespace LV {
       return video;
   }
 
+  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);
+      }
+
+      auto bits_per_channel {0};
+      auto color_type {0};
+
+      switch (bitmap.get_depth ()) {
+          case VISUAL_VIDEO_DEPTH_8BIT: {
+              bits_per_channel = 8;
+              color_type = PNG_COLOR_TYPE_PALETTE;
+              break;
+          }
+          case VISUAL_VIDEO_DEPTH_24BIT: {
+              bits_per_channel = 8;
+              color_type = PNG_COLOR_TYPE_RGB;
+              break;
+          }
+          case VISUAL_VIDEO_DEPTH_32BIT: {
+              bits_per_channel = 8;
+              color_type = PNG_COLOR_TYPE_RGB_ALPHA;
+              break;
+          }
+          default: {
+              visual_log (VISUAL_LOG_ERROR, "Invalid depth or depth not supported.");
+              return false;
+          }
+      }
+
+      if constexpr (std::endian::native == std::endian::little) {
+          png_set_bgr (png_ptr);
+      }
+
+      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,
+                    bits_per_channel, 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.emplace_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
diff --git a/libvisual/libvisual/private/lv_video_png.hpp b/libvisual/libvisual/private/lv_video_png.hpp
index 9019fd9c..247dc797 100644
--- a/libvisual/libvisual/private/lv_video_png.hpp
+++ b/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
diff --git a/libvisual/tests/video_test/CMakeLists.txt b/libvisual/tests/video_test/CMakeLists.txt
index 4a8bad4c..beef643a 100644
--- a/libvisual/tests/video_test/CMakeLists.txt
+++ b/libvisual/tests/video_test/CMakeLists.txt
@@ -1,15 +1,26 @@
 LV_BUILD_TEST(video_check_test
   SOURCES video_check_test.cpp
+  LINK_LIBS video_test_common
 )
 
 LV_BUILD_TEST(video_blit_test
   SOURCES video_blit_test.cpp
+  LINK_LIBS video_test_common
 )
 
 LV_BUILD_TEST(video_load_test
   SOURCES video_load_test.cpp
+  LINK_LIBS video_test_common
 )
 
+LV_BUILD_TEST(video_save_test
+  SOURCES video_save_test.cpp
+  LINK_LIBS video_test_common
+)
+
+ADD_LIBRARY(video_test_common STATIC common.cpp)
+TARGET_LINK_LIBRARIES(video_test_common PUBLIC libvisual)
+
 IF(HAVE_SDL)
   LV_BUILD_TEST(video_scale_test
     SOURCES   video_scale_test.cpp
diff --git a/libvisual/tests/video_test/common.cpp b/libvisual/tests/video_test/common.cpp
new file mode 100644
index 00000000..39ce8fc4
--- /dev/null
+++ b/libvisual/tests/video_test/common.cpp
@@ -0,0 +1,87 @@
+#include "common.hpp"
+#include <libvisual/libvisual.h>
+#include <filesystem>
+#include <fstream>
+#include <optional>
+
+namespace fs = std::filesystem;
+
+LV::VideoPtr load_raw_image (fs::path const& path, int width, int height, VisVideoDepth depth)
+{
+    auto image {LV::Video::create (width, height, depth)};
+
+    std::size_t const content_bytes_per_row = image->get_width () * image->get_bpp ();
+
+    {
+        std::ifstream input {path, std::ios::binary};
+        if (!input) {
+            return nullptr;
+        }
+
+        for (int y = 0; y < image->get_height (); y++) {
+            auto pixel_row_ptr = static_cast<char*> (image->get_pixel_ptr (0, y));
+            if (!input.read (pixel_row_ptr, content_bytes_per_row)) {
+                return nullptr;
+            }
+        }
+    }
+
+    if constexpr (std::endian::native == std::endian::little) {
+        auto byteswapped_image {LV::Video::create (width, height, depth)};
+        byteswapped_image->flip_pixel_bytes (image);
+        return byteswapped_image;
+    } else {
+        return image;
+    }
+}
+
+std::optional<LV::Palette> load_raw_palette (fs::path const& path)
+{
+    std::vector<std::uint8_t> palette_buffer (256 * 3);
+    {
+        std::ifstream input {path, std::ios::binary};
+        if (!input.read (reinterpret_cast<char*> (palette_buffer.data ()), palette_buffer.size ())) {
+            return std::nullopt;
+        }
+    }
+
+    LV::Palette palette;
+    palette.colors.reserve (256);
+    for (unsigned int i = 0; i < 256; i++) {
+        palette.colors.emplace_back (palette_buffer[i*3], palette_buffer[i*3+1], palette_buffer[i*3+2]);
+    }
+
+    return palette;
+}
+
+LV::VideoPtr load_raw_indexed_image (fs::path const& image_path,
+                                     fs::path const& palette_path,
+                                     int width,
+                                     int height)
+{
+    auto image {LV::Video::create (width, height, VISUAL_VIDEO_DEPTH_8BIT)};
+
+    std::size_t const content_bytes_per_row = image->get_width () * image->get_bpp ();
+
+    {
+        std::ifstream input {image_path, std::ios::binary};
+        if (!input) {
+            return nullptr;
+        }
+
+        for (int y = 0; y < image->get_height (); y++) {
+            auto pixel_row_ptr = static_cast<char*> (image->get_pixel_ptr (0, y));
+            if (!input.read (pixel_row_ptr, content_bytes_per_row)) {
+                return nullptr;
+            }
+        }
+    }
+
+    auto palette {load_raw_palette (palette_path)};
+    if (!palette.has_value ()) {
+        return nullptr;
+    }
+    image->set_palette (palette.value ());
+
+    return image;
+}
diff --git a/libvisual/tests/video_test/common.hpp b/libvisual/tests/video_test/common.hpp
new file mode 100644
index 00000000..1488730b
--- /dev/null
+++ b/libvisual/tests/video_test/common.hpp
@@ -0,0 +1,17 @@
+#ifndef LV_VIDEO_TEST_COMMON_HPP
+#define LV_VIDEO_TEST_COMMON_HPP
+
+#include <libvisual/libvisual.h>
+#include <filesystem>
+#include <optional>
+
+LV::VideoPtr load_raw_image (std::filesystem::path const& path, int width, int height, VisVideoDepth depth);
+
+std::optional<LV::Palette> load_raw_palette (std::filesystem::path const& path);
+
+LV::VideoPtr load_raw_indexed_image (std::filesystem::path const& image_path,
+                                     std::filesystem::path const& palette_path,
+                                     int width,
+                                     int height);
+
+#endif // LV_VIDEO_TEST_COMMON_HPP
diff --git a/libvisual/tests/video_test/video_load_test.cpp b/libvisual/tests/video_test/video_load_test.cpp
index 720d2d50..4e18112d 100644
--- a/libvisual/tests/video_test/video_load_test.cpp
+++ b/libvisual/tests/video_test/video_load_test.cpp
@@ -1,93 +1,9 @@
 #include "test.h"
+#include "video_test/common.hpp"
 #include <libvisual/libvisual.h>
-#include <bit>
-#include <filesystem>
-#include <fstream>
-#include <optional>
 
 namespace
 {
-  namespace fs = std::filesystem;
-
-  LV::VideoPtr load_raw_image (fs::path const& path, int width, int height, VisVideoDepth depth)
-  {
-      auto image {LV::Video::create (width, height, depth)};
-
-      std::size_t const content_bytes_per_row = image->get_width () * image->get_bpp ();
-
-      {
-          std::ifstream input {path, std::ios::binary};
-          if (!input) {
-              return nullptr;
-          }
-
-          for (int y = 0; y < image->get_height (); y++) {
-              auto pixel_row_ptr = static_cast<char*> (image->get_pixel_ptr (0, y));
-              if (!input.read (pixel_row_ptr, content_bytes_per_row)) {
-                  return nullptr;
-              }
-          }
-      }
-
-      if constexpr (std::endian::native == std::endian::little) {
-          auto byteswapped_image {LV::Video::create (width, height, depth)};
-          byteswapped_image->flip_pixel_bytes (image);
-          return byteswapped_image;
-      } else {
-          return image;
-      }
-  }
-
-  std::optional<LV::Palette> load_raw_palette (fs::path const& path)
-  {
-      std::vector<std::uint8_t> palette_buffer (256 * 3);
-      {
-          std::ifstream input {path, std::ios::binary};
-          if (!input.read (reinterpret_cast<char*> (palette_buffer.data ()), palette_buffer.size ())) {
-              return std::nullopt;
-          }
-      }
-
-      LV::Palette palette;
-      palette.colors.reserve (256);
-      for (unsigned int i = 0; i < 256; i++) {
-          palette.colors.emplace_back (palette_buffer[i*3], palette_buffer[i*3+1], palette_buffer[i*3+2]);
-      }
-
-      return palette;
-  }
-
-  LV::VideoPtr load_raw_indexed_image (fs::path const& image_path,
-                                       fs::path const& palette_path,
-                                       int width,
-                                       int height)
-  {
-      auto image {LV::Video::create (width, height, VISUAL_VIDEO_DEPTH_8BIT)};
-
-      std::size_t const content_bytes_per_row = image->get_width () * image->get_bpp ();
-
-      {
-          std::ifstream input {image_path, std::ios::binary};
-          if (!input) {
-              return nullptr;
-          }
-
-          for (int y = 0; y < image->get_height (); y++) {
-              auto pixel_row_ptr = static_cast<char*> (image->get_pixel_ptr (0, y));
-              if (!input.read (pixel_row_ptr, content_bytes_per_row)) {
-                  return nullptr;
-              }
-          }
-      }
-
-      auto palette {load_raw_palette (palette_path)};
-      if (!palette.has_value ()) {
-          return nullptr;
-      }
-      image->set_palette (palette.value ());
-
-      return image;
-  }
 
   void test_load_indexed8 ()
   {
diff --git a/libvisual/tests/video_test/video_save_test.cpp b/libvisual/tests/video_test/video_save_test.cpp
new file mode 100644
index 00000000..1f23c6c0
--- /dev/null
+++ b/libvisual/tests/video_test/video_save_test.cpp
@@ -0,0 +1,53 @@
+#include "test.h"
+#include <libvisual/libvisual.h>
+#include <sstream>
+
+void test_save_indexed8 ()
+{
+      auto png_image {LV::Video::create_from_file ("../images/additive-colors-indexed8.png")};
+      LV_TEST_ASSERT (png_image);
+
+      std::stringstream buffer;
+      LV_TEST_ASSERT (png_image->save_to_stream (buffer, LV::ImageFormat::PNG));
+
+      auto png_saved_image {LV::Video::create_from_stream (buffer)};
+      LV_TEST_ASSERT (png_saved_image);
+      LV_TEST_ASSERT (png_saved_image->has_same_content (png_image));
+}
+
+void test_save_rgb24 ()
+{
+      auto png_image {LV::Video::create_from_file ("../images/additive-colors-rgb24.png")};
+      LV_TEST_ASSERT (png_image);
+
+      std::stringstream buffer;
+      LV_TEST_ASSERT (png_image->save_to_stream (buffer, LV::ImageFormat::PNG));
+
+      auto png_saved_image {LV::Video::create_from_stream (buffer)};
+      LV_TEST_ASSERT (png_saved_image);
+      LV_TEST_ASSERT (png_saved_image->has_same_content (png_image));
+}
+
+void test_save_argb32 ()
+{
+      auto png_image {LV::Video::create_from_file ("../images/additive-colors-argb32.png")};
+      LV_TEST_ASSERT (png_image);
+
+      std::stringstream buffer;
+      LV_TEST_ASSERT (png_image->save_to_stream (buffer, LV::ImageFormat::PNG));
+
+      auto png_saved_image {LV::Video::create_from_stream (buffer)};
+      LV_TEST_ASSERT (png_saved_image);
+      LV_TEST_ASSERT (png_saved_image->has_same_content (png_image));
+}
+
+int main (int argc, char* argv[])
+{
+    LV::System::init (argc, argv);
+
+    test_save_indexed8 ();
+    test_save_rgb24 ();
+    test_save_argb32 ();
+
+    LV::System::destroy ();
+}