+PositionImage
+merge (list<PositionImage> images)
+{
+ if (images.empty ()) {
+ return PositionImage ();
+ }
+
+ if (images.size() == 1) {
+ return images.front ();
+ }
+
+ dcpomatic::Rect<int> all (images.front().position, images.front().image->size().width, images.front().image->size().height);
+ for (list<PositionImage>::const_iterator i = images.begin(); i != images.end(); ++i) {
+ all.extend (dcpomatic::Rect<int> (i->position, i->image->size().width, i->image->size().height));
+ }
+
+ shared_ptr<Image> merged (new Image (images.front().image->pixel_format (), dcp::Size (all.width, all.height), true));
+ merged->make_transparent ();
+ for (list<PositionImage>::const_iterator i = images.begin(); i != images.end(); ++i) {
+ merged->alpha_blend (i->image, i->position - all.position());
+ }
+
+ return PositionImage (merged, all.position ());
+}
+
+bool
+operator== (Image const & a, Image const & b)
+{
+ if (a.planes() != b.planes() || a.pixel_format() != b.pixel_format() || a.aligned() != b.aligned()) {
+ return false;
+ }
+
+ for (int c = 0; c < a.planes(); ++c) {
+ if (a.sample_size(c).height != b.sample_size(c).height || a.line_size()[c] != b.line_size()[c] || a.stride()[c] != b.stride()[c]) {
+ return false;
+ }
+
+ uint8_t* p = a.data()[c];
+ uint8_t* q = b.data()[c];
+ int const lines = a.sample_size(c).height;
+ for (int y = 0; y < lines; ++y) {
+ if (memcmp (p, q, a.line_size()[c]) != 0) {
+ return false;
+ }
+
+ p += a.stride()[c];
+ q += b.stride()[c];
+ }
+ }
+
+ return true;
+}
+
+/** Fade the image.
+ * @param f Amount to fade by; 0 is black, 1 is no fade.
+ */
+void
+Image::fade (float f)
+{
+ switch (_pixel_format) {
+ case AV_PIX_FMT_YUV420P:
+ case AV_PIX_FMT_YUV422P:
+ case AV_PIX_FMT_YUV444P:
+ case AV_PIX_FMT_YUV411P:
+ case AV_PIX_FMT_YUVJ420P:
+ case AV_PIX_FMT_YUVJ422P:
+ case AV_PIX_FMT_YUVJ444P:
+ case AV_PIX_FMT_RGB24:
+ case AV_PIX_FMT_ARGB:
+ case AV_PIX_FMT_RGBA:
+ case AV_PIX_FMT_ABGR:
+ case AV_PIX_FMT_BGRA:
+ case AV_PIX_FMT_RGB555LE:
+ /* 8-bit */
+ for (int c = 0; c < 3; ++c) {
+ uint8_t* p = data()[c];
+ int const lines = sample_size(c).height;
+ for (int y = 0; y < lines; ++y) {
+ uint8_t* q = p;
+ for (int x = 0; x < line_size()[c]; ++x) {
+ *q = int (float (*q) * f);
+ ++q;
+ }
+ p += stride()[c];
+ }
+ }
+ break;
+
+ case AV_PIX_FMT_YUV422P9LE:
+ case AV_PIX_FMT_YUV444P9LE:
+ case AV_PIX_FMT_YUV422P10LE:
+ case AV_PIX_FMT_YUV444P10LE:
+ case AV_PIX_FMT_YUV422P16LE:
+ case AV_PIX_FMT_YUV444P16LE:
+ case AV_PIX_FMT_YUVA420P9LE:
+ case AV_PIX_FMT_YUVA422P9LE:
+ case AV_PIX_FMT_YUVA444P9LE:
+ case AV_PIX_FMT_YUVA420P10LE:
+ case AV_PIX_FMT_YUVA422P10LE:
+ case AV_PIX_FMT_YUVA444P10LE:
+ case AV_PIX_FMT_RGB48LE:
+ case AV_PIX_FMT_XYZ12LE:
+ /* 16-bit little-endian */
+ for (int c = 0; c < 3; ++c) {
+ int const stride_pixels = stride()[c] / 2;
+ int const line_size_pixels = line_size()[c] / 2;
+ uint16_t* p = reinterpret_cast<uint16_t*> (data()[c]);
+ int const lines = sample_size(c).height;
+ for (int y = 0; y < lines; ++y) {
+ uint16_t* q = p;
+ for (int x = 0; x < line_size_pixels; ++x) {
+ *q = int (float (*q) * f);
+ ++q;
+ }
+ p += stride_pixels;
+ }
+ }
+ break;
+
+ case AV_PIX_FMT_YUV422P9BE:
+ case AV_PIX_FMT_YUV444P9BE:
+ case AV_PIX_FMT_YUV444P10BE:
+ case AV_PIX_FMT_YUV422P10BE:
+ case AV_PIX_FMT_YUVA420P9BE:
+ case AV_PIX_FMT_YUVA422P9BE:
+ case AV_PIX_FMT_YUVA444P9BE:
+ case AV_PIX_FMT_YUVA420P10BE:
+ case AV_PIX_FMT_YUVA422P10BE:
+ case AV_PIX_FMT_YUVA444P10BE:
+ case AV_PIX_FMT_YUVA420P16BE:
+ case AV_PIX_FMT_YUVA422P16BE:
+ case AV_PIX_FMT_YUVA444P16BE:
+ case AV_PIX_FMT_RGB48BE:
+ /* 16-bit big-endian */
+ for (int c = 0; c < 3; ++c) {
+ int const stride_pixels = stride()[c] / 2;
+ int const line_size_pixels = line_size()[c] / 2;
+ uint16_t* p = reinterpret_cast<uint16_t*> (data()[c]);
+ int const lines = sample_size(c).height;
+ for (int y = 0; y < lines; ++y) {
+ uint16_t* q = p;
+ for (int x = 0; x < line_size_pixels; ++x) {
+ *q = swap_16 (int (float (swap_16 (*q)) * f));
+ ++q;
+ }
+ p += stride_pixels;
+ }
+ }
+ break;
+
+ case AV_PIX_FMT_UYVY422:
+ {
+ int const Y = sample_size(0).height;
+ int const X = line_size()[0];
+ uint8_t* p = data()[0];
+ for (int y = 0; y < Y; ++y) {
+ for (int x = 0; x < X; ++x) {
+ *p = int (float (*p) * f);
+ ++p;
+ }
+ }
+ break;
+ }
+
+ default:
+ throw PixelFormatError ("fade()", _pixel_format);
+ }
+}
+
+shared_ptr<const Image>
+Image::ensure_aligned (shared_ptr<const Image> image)
+{
+ if (image->aligned()) {
+ return image;
+ }
+
+ return shared_ptr<Image> (new Image (image, true));
+}
+
+size_t
+Image::memory_used () const
+{
+ size_t m = 0;
+ for (int i = 0; i < planes(); ++i) {
+ m += _stride[i] * sample_size(i).height;
+ }
+ 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
+{
+ 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"));
+ }
+
+ 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"));
+ }
+
+ 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]);
+ }
+
+ 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);
+}