Merge branch 'master' of ssh://git.carlh.net/home/carl/git/dcpomatic

[dcpomatic.git] / src / lib / image.cc

diff --git a/src/lib/image.cc b/src/lib/image.cc
index bdd4f61d8d7abd33470654f36604f3c7dfbf730b..41582f307b30b23bce02603aad7c9f74bae1f6f0 100644 (file)
--- a/src/lib/image.cc
+++ b/src/lib/image.cc
@@ -27,16 +27,20 @@
 #include "timer.h"
 #include "rect.h"
 #include "util.h"
+#include "compose.hpp"
 #include "dcpomatic_socket.h"
 #include <dcp/rgb_xyz.h>
 #include <dcp/transfer_function.h>
-#include <Magick++.h>
 extern "C" {
 #include <libswscale/swscale.h>
 #include <libavutil/pixfmt.h>
 #include <libavutil/pixdesc.h>
 #include <libavutil/frame.h>
 }
+#include <png.h>
+#if HAVE_VALGRIND_MEMCHECK_H
+#include <valgrind/memcheck.h>
+#endif
 #include <iostream>
 
 #include "i18n.h"
@@ -102,6 +106,10 @@ Image::planes () const
                throw PixelFormatError ("planes()", _pixel_format);
        }
 
+       if (_pixel_format == AV_PIX_FMT_PAL8) {
+               return 2;
+       }
+
        if ((d->flags & AV_PIX_FMT_FLAG_PLANAR) == 0) {
                return 1;
        }
@@ -822,11 +830,17 @@ Image::allocate ()
                   testing suggests that it works.
                */
                _data[i] = (uint8_t *) wrapped_av_malloc (_stride[i] * sample_size(i).height + _extra_pixels * bytes_per_pixel(i) + 32);
+#if HAVE_VALGRIND_MEMCHECK_H
+               /* The data between the end of the line size and the stride is undefined but processed by
+                  libswscale, causing lots of valgrind errors.  Mark it all defined to quell these errors.
+               */
+               VALGRIND_MAKE_MEM_DEFINED (_data[i], _stride[i] * sample_size(i).height + _extra_pixels * bytes_per_pixel(i) + 32);
+#endif
        }
 }
 
 Image::Image (Image const & other)
-       : enable_shared_from_this<Image>(other)
+       : boost::enable_shared_from_this<Image>(other)
        , _size (other._size)
        , _pixel_format (other._pixel_format)
        , _aligned (other._aligned)
@@ -1147,37 +1161,97 @@ Image::memory_used () const
        return m;
 }
 
+class Memory
+{
+public:
+       Memory ()
+               : data(0)
+               , size(0)
+       {}
+
+       ~Memory ()
+       {
+               free (data);
+       }
+
+       uint8_t* data;
+       size_t size;
+};
+
+static void
+png_write_data (png_structp png_ptr, png_bytep data, png_size_t length)
+{
+       Memory* mem = reinterpret_cast<Memory*>(png_get_io_ptr(png_ptr));
+       size_t size = mem->size + length;
+
+       if (mem->data) {
+               mem->data = reinterpret_cast<uint8_t*>(realloc(mem->data, size));
+       } else {
+               mem->data = reinterpret_cast<uint8_t*>(malloc(size));
+       }
+
+       if (!mem->data) {
+               throw EncodeError (N_("could not allocate memory for PNG"));
+       }
+
+       memcpy (mem->data + mem->size, data, length);
+       mem->size += length;
+}
+
+static void
+png_flush (png_structp)
+{
+
+}
+
+static void
+png_error_fn (png_structp png_ptr, char const * message)
+{
+       reinterpret_cast<Image*>(png_get_error_ptr(png_ptr))->png_error (message);
+}
+
+void
+Image::png_error (char const * message)
+{
+       throw EncodeError (String::compose ("Error during PNG write: %1", message));
+}
+
 dcp::Data
 Image::as_png () const
 {
-#ifdef DCPOMATIC_IMAGE_MAGICK
-               using namespace MagickCore;
-#else
-               using namespace MagickLib;
-#endif
+       DCPOMATIC_ASSERT (bytes_per_pixel(0) == 4);
+       DCPOMATIC_ASSERT (planes() == 1);
+       DCPOMATIC_ASSERT (pixel_format() == AV_PIX_FMT_BGRA);
+
+       /* error handling? */
+       png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, reinterpret_cast<void*>(const_cast<Image*>(this)), png_error_fn, 0);
+       if (!png_ptr) {
+               throw EncodeError (N_("could not create PNG write struct"));
+       }
 
-       string format;
-       switch (_pixel_format) {
-       case AV_PIX_FMT_RGB24:
-               format = "RGB";
-               break;
-       case AV_PIX_FMT_BGRA:
-               format = "BGRA";
-               break;
-       default:
-               DCPOMATIC_ASSERT (false);
-               break;
+       Memory state;
+
+       png_set_write_fn (png_ptr, &state, png_write_data, png_flush);
+
+       png_infop info_ptr = png_create_info_struct(png_ptr);
+       if (!info_ptr) {
+               png_destroy_write_struct (&png_ptr, &info_ptr);
+               throw EncodeError (N_("could not create PNG info struct"));
        }
 
-       shared_ptr<const Image> use;
-       if (aligned()) {
-               use.reset (new Image(shared_from_this(), false));
+       png_set_IHDR (png_ptr, info_ptr, size().width, size().height, 8, PNG_COLOR_TYPE_RGBA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
+
+       png_byte ** row_pointers = reinterpret_cast<png_byte **>(png_malloc(png_ptr, size().height * sizeof(png_byte *)));
+       for (int i = 0; i < size().height; ++i) {
+               row_pointers[i] = (png_byte *) (data()[0] + i * stride()[0]);
        }
 
-       Magick::Image m (size().width, size().height, format, CharPixel, (void *) use->data()[0]);
-       m.magick ("PNG");
-       Magick::Blob blob;
-       m.write (&blob);
-       /* XXX: could use a subclass of Data here (storing its data in a Blob) */
-       return dcp::Data (static_cast<const uint8_t*>(blob.data()), blob.length());
+       png_write_info (png_ptr, info_ptr);
+       png_write_image (png_ptr, row_pointers);
+       png_write_end (png_ptr, info_ptr);
+
+       png_destroy_write_struct (&png_ptr, &info_ptr);
+       png_free (png_ptr, row_pointers);
+
+       return dcp::Data (state.data, state.size);
 }