src/lib/image.cc

   1 /*
   2     Copyright (C) 2012-2014 Carl Hetherington <cth@carlh.net>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18 */
  19
  20 /** @file src/image.cc
  21  *  @brief A class to describe a video image.
  22  */
  23
  24 #include <iostream>
  25 extern "C" {
  26 #include <libswscale/swscale.h>
  27 #include <libavutil/pixfmt.h>
  28 #include <libavutil/pixdesc.h>
  29 }
  30 #include "image.h"
  31 #include "exceptions.h"
  32 #include "scaler.h"
  33 #include "timer.h"
  34 #include "rect.h"
  35 #include "md5_digester.h"
  36
  37 #include "i18n.h"
  38
  39 using std::string;
  40 using std::min;
  41 using std::cout;
  42 using std::cerr;
  43 using std::list;
  44 using std::stringstream;
  45 using boost::shared_ptr;
  46 using dcp::Size;
  47
  48 int
  49 Image::line_factor (int n) const
  50 {
  51         if (n == 0) {
  52                 return 1;
  53         }
  54
  55         AVPixFmtDescriptor const * d = av_pix_fmt_desc_get(_pixel_format);
  56         if (!d) {
  57                 throw PixelFormatError ("lines()", _pixel_format);
  58         }
  59
  60         return pow (2.0f, d->log2_chroma_h);
  61 }
  62
  63 /** @param n Component index.
  64  *  @return Number of lines in the image for the given component.
  65  */
  66 int
  67 Image::lines (int n) const
  68 {
  69         return rint (ceil (static_cast<double>(size().height) / line_factor (n)));
  70 }
  71
  72 /** @return Number of components */
  73 int
  74 Image::components () const
  75 {
  76         AVPixFmtDescriptor const * d = av_pix_fmt_desc_get(_pixel_format);
  77         if (!d) {
  78                 throw PixelFormatError ("components()", _pixel_format);
  79         }
  80
  81         if ((d->flags & PIX_FMT_PLANAR) == 0) {
  82                 return 1;
  83         }
  84
  85         return d->nb_components;
  86 }
  87
  88 /** Crop this image, scale it to `inter_size' and then place it in a black frame of `out_size' */
  89 shared_ptr<Image>
  90 Image::crop_scale_window (Crop crop, dcp::Size inter_size, dcp::Size out_size, Scaler const * scaler, AVPixelFormat out_format, bool out_aligned) const
  91 {
  92         assert (scaler);
  93         /* Empirical testing suggests that sws_scale() will crash if
  94            the input image is not aligned.
  95         */
  96         assert (aligned ());
  97
  98         assert (out_size.width >= inter_size.width);
  99         assert (out_size.height >= inter_size.height);
 100
 101         /* Here's an image of out_size */
 102         shared_ptr<Image> out (new Image (out_format, out_size, out_aligned));
 103         out->make_black ();
 104
 105         /* Size of the image after any crop */
 106         dcp::Size const cropped_size = crop.apply (size ());
 107
 108         /* Scale context for a scale from cropped_size to inter_size */
 109         struct SwsContext* scale_context = sws_getContext (
 110                         cropped_size.width, cropped_size.height, pixel_format(),
 111                         inter_size.width, inter_size.height, out_format,
 112                         scaler->ffmpeg_id (), 0, 0, 0
 113                 );
 114
 115         if (!scale_context) {
 116                 throw StringError (N_("Could not allocate SwsContext"));
 117         }
 118
 119         /* Prepare input data pointers with crop */
 120         uint8_t* scale_in_data[components()];
 121         for (int c = 0; c < components(); ++c) {
 122                 scale_in_data[c] = data()[c] + int (rint (bytes_per_pixel(c) * crop.left)) + stride()[c] * (crop.top / line_factor(c));
 123         }
 124
 125         /* Corner of the image within out_size */
 126         Position<int> const corner ((out_size.width - inter_size.width) / 2, (out_size.height - inter_size.height) / 2);
 127
 128         uint8_t* scale_out_data[out->components()];
 129         for (int c = 0; c < out->components(); ++c) {
 130                 scale_out_data[c] = out->data()[c] + int (rint (out->bytes_per_pixel(c) * corner.x)) + out->stride()[c] * corner.y;
 131         }
 132
 133         sws_scale (
 134                 scale_context,
 135                 scale_in_data, stride(),
 136                 0, cropped_size.height,
 137                 scale_out_data, out->stride()
 138                 );
 139
 140         sws_freeContext (scale_context);
 141
 142         return out;
 143 }
 144
 145 shared_ptr<Image>
 146 Image::scale (dcp::Size out_size, Scaler const * scaler, AVPixelFormat out_format, bool out_aligned) const
 147 {
 148         assert (scaler);
 149         /* Empirical testing suggests that sws_scale() will crash if
 150            the input image is not aligned.
 151         */
 152         assert (aligned ());
 153
 154         shared_ptr<Image> scaled (new Image (out_format, out_size, out_aligned));
 155
 156         struct SwsContext* scale_context = sws_getContext (
 157                 size().width, size().height, pixel_format(),
 158                 out_size.width, out_size.height, out_format,
 159                 scaler->ffmpeg_id (), 0, 0, 0
 160                 );
 161
 162         sws_scale (
 163                 scale_context,
 164                 data(), stride(),
 165                 0, size().height,
 166                 scaled->data(), scaled->stride()
 167                 );
 168
 169         sws_freeContext (scale_context);
 170
 171         return scaled;
 172 }
 173
 174 shared_ptr<Image>
 175 Image::crop (Crop crop, bool aligned) const
 176 {
 177         dcp::Size cropped_size = crop.apply (size ());
 178         shared_ptr<Image> out (new Image (pixel_format(), cropped_size, aligned));
 179
 180         for (int c = 0; c < components(); ++c) {
 181                 int const crop_left_in_bytes = bytes_per_pixel(c) * crop.left;
 182                 /* bytes_per_pixel() could be a fraction; in this case the stride will be rounded
 183                    up, and we need to make sure that we copy over the width (up to the stride)
 184                    rather than short of the width; hence the ceil() here.
 185                 */
 186                 int const cropped_width_in_bytes = ceil (bytes_per_pixel(c) * cropped_size.width);
 187
 188                 /* Start of the source line, cropped from the top but not the left */
 189                 uint8_t* in_p = data()[c] + (crop.top / out->line_factor(c)) * stride()[c];
 190                 uint8_t* out_p = out->data()[c];
 191
 192                 for (int y = 0; y < out->lines(c); ++y) {
 193                         memcpy (out_p, in_p + crop_left_in_bytes, cropped_width_in_bytes);
 194                         in_p += stride()[c];
 195                         out_p += out->stride()[c];
 196                 }
 197         }
 198
 199         return out;
 200 }
 201
 202 /** Blacken a YUV image whose bits per pixel is rounded up to 16 */
 203 void
 204 Image::yuv_16_black (uint16_t v, bool alpha)
 205 {
 206         memset (data()[0], 0, lines(0) * stride()[0]);
 207         for (int i = 1; i < 3; ++i) {
 208                 int16_t* p = reinterpret_cast<int16_t*> (data()[i]);
 209                 for (int y = 0; y < lines(i); ++y) {
 210                         /* We divide by 2 here because we are writing 2 bytes at a time */
 211                         for (int x = 0; x < line_size()[i] / 2; ++x) {
 212                                 p[x] = v;
 213                         }
 214                         p += stride()[i] / 2;
 215                 }
 216         }
 217
 218         if (alpha) {
 219                 memset (data()[3], 0, lines(3) * stride()[3]);
 220         }
 221 }
 222
 223 uint16_t
 224 Image::swap_16 (uint16_t v)
 225 {
 226         return ((v >> 8) & 0xff) | ((v & 0xff) << 8);
 227 }
 228
 229 void
 230 Image::make_black ()
 231 {
 232         /* U/V black value for 8-bit colour */
 233         static uint8_t const eight_bit_uv =     (1 << 7) - 1;
 234         /* U/V black value for 9-bit colour */
 235         static uint16_t const nine_bit_uv =     (1 << 8) - 1;
 236         /* U/V black value for 10-bit colour */
 237         static uint16_t const ten_bit_uv =      (1 << 9) - 1;
 238         /* U/V black value for 16-bit colour */
 239         static uint16_t const sixteen_bit_uv =  (1 << 15) - 1;
 240
 241         switch (_pixel_format) {
 242         case PIX_FMT_YUV420P:
 243         case PIX_FMT_YUV422P:
 244         case PIX_FMT_YUV444P:
 245         case PIX_FMT_YUV411P:
 246                 memset (data()[0], 0, lines(0) * stride()[0]);
 247                 memset (data()[1], eight_bit_uv, lines(1) * stride()[1]);
 248                 memset (data()[2], eight_bit_uv, lines(2) * stride()[2]);
 249                 break;
 250
 251         case PIX_FMT_YUVJ420P:
 252         case PIX_FMT_YUVJ422P:
 253         case PIX_FMT_YUVJ444P:
 254                 memset (data()[0], 0, lines(0) * stride()[0]);
 255                 memset (data()[1], eight_bit_uv + 1, lines(1) * stride()[1]);
 256                 memset (data()[2], eight_bit_uv + 1, lines(2) * stride()[2]);
 257                 break;
 258
 259         case PIX_FMT_YUV422P9LE:
 260         case PIX_FMT_YUV444P9LE:
 261                 yuv_16_black (nine_bit_uv, false);
 262                 break;
 263
 264         case PIX_FMT_YUV422P9BE:
 265         case PIX_FMT_YUV444P9BE:
 266                 yuv_16_black (swap_16 (nine_bit_uv), false);
 267                 break;
 268
 269         case PIX_FMT_YUV422P10LE:
 270         case PIX_FMT_YUV444P10LE:
 271                 yuv_16_black (ten_bit_uv, false);
 272                 break;
 273
 274         case PIX_FMT_YUV422P16LE:
 275         case PIX_FMT_YUV444P16LE:
 276                 yuv_16_black (sixteen_bit_uv, false);
 277                 break;
 278
 279         case PIX_FMT_YUV444P10BE:
 280         case PIX_FMT_YUV422P10BE:
 281                 yuv_16_black (swap_16 (ten_bit_uv), false);
 282                 break;
 283
 284         case AV_PIX_FMT_YUVA420P9BE:
 285         case AV_PIX_FMT_YUVA422P9BE:
 286         case AV_PIX_FMT_YUVA444P9BE:
 287                 yuv_16_black (swap_16 (nine_bit_uv), true);
 288                 break;
 289
 290         case AV_PIX_FMT_YUVA420P9LE:
 291         case AV_PIX_FMT_YUVA422P9LE:
 292         case AV_PIX_FMT_YUVA444P9LE:
 293                 yuv_16_black (nine_bit_uv, true);
 294                 break;
 295
 296         case AV_PIX_FMT_YUVA420P10BE:
 297         case AV_PIX_FMT_YUVA422P10BE:
 298         case AV_PIX_FMT_YUVA444P10BE:
 299                 yuv_16_black (swap_16 (ten_bit_uv), true);
 300                 break;
 301
 302         case AV_PIX_FMT_YUVA420P10LE:
 303         case AV_PIX_FMT_YUVA422P10LE:
 304         case AV_PIX_FMT_YUVA444P10LE:
 305                 yuv_16_black (ten_bit_uv, true);
 306                 break;
 307
 308         case AV_PIX_FMT_YUVA420P16BE:
 309         case AV_PIX_FMT_YUVA422P16BE:
 310         case AV_PIX_FMT_YUVA444P16BE:
 311                 yuv_16_black (swap_16 (sixteen_bit_uv), true);
 312                 break;
 313
 314         case AV_PIX_FMT_YUVA420P16LE:
 315         case AV_PIX_FMT_YUVA422P16LE:
 316         case AV_PIX_FMT_YUVA444P16LE:
 317                 yuv_16_black (sixteen_bit_uv, true);
 318                 break;
 319
 320         case PIX_FMT_RGB24:
 321         case PIX_FMT_ARGB:
 322         case PIX_FMT_RGBA:
 323         case PIX_FMT_ABGR:
 324         case PIX_FMT_BGRA:
 325         case PIX_FMT_RGB555LE:
 326                 memset (data()[0], 0, lines(0) * stride()[0]);
 327                 break;
 328
 329         case PIX_FMT_UYVY422:
 330         {
 331                 int const Y = lines(0);
 332                 int const X = line_size()[0];
 333                 uint8_t* p = data()[0];
 334                 for (int y = 0; y < Y; ++y) {
 335                         for (int x = 0; x < X / 4; ++x) {
 336                                 *p++ = eight_bit_uv; // Cb
 337                                 *p++ = 0;            // Y0
 338                                 *p++ = eight_bit_uv; // Cr
 339                                 *p++ = 0;            // Y1
 340                         }
 341                 }
 342                 break;
 343         }
 344
 345         default:
 346                 throw PixelFormatError ("make_black()", _pixel_format);
 347         }
 348 }
 349
 350 void
 351 Image::make_transparent ()
 352 {
 353         if (_pixel_format != PIX_FMT_RGBA) {
 354                 throw PixelFormatError ("make_transparent()", _pixel_format);
 355         }
 356
 357         memset (data()[0], 0, lines(0) * stride()[0]);
 358 }
 359
 360 void
 361 Image::alpha_blend (shared_ptr<const Image> other, Position<int> position)
 362 {
 363         assert (other->pixel_format() == PIX_FMT_RGBA);
 364         int const other_bpp = 4;
 365
 366         int this_bpp = 0;
 367         switch (_pixel_format) {
 368         case PIX_FMT_BGRA:
 369         case PIX_FMT_RGBA:
 370                 this_bpp = 4;
 371                 break;
 372         case PIX_FMT_RGB24:
 373                 this_bpp = 3;
 374                 break;
 375         default:
 376                 assert (false);
 377         }
 378
 379         int start_tx = position.x;
 380         int start_ox = 0;
 381
 382         if (start_tx < 0) {
 383                 start_ox = -start_tx;
 384                 start_tx = 0;
 385         }
 386
 387         int start_ty = position.y;
 388         int start_oy = 0;
 389
 390         if (start_ty < 0) {
 391                 start_oy = -start_ty;
 392                 start_ty = 0;
 393         }
 394
 395         for (int ty = start_ty, oy = start_oy; ty < size().height && oy < other->size().height; ++ty, ++oy) {
 396                 uint8_t* tp = data()[0] + ty * stride()[0] + start_tx * this_bpp;
 397                 uint8_t* op = other->data()[0] + oy * other->stride()[0];
 398                 for (int tx = start_tx, ox = start_ox; tx < size().width && ox < other->size().width; ++tx, ++ox) {
 399                         float const alpha = float (op[3]) / 255;
 400                         tp[0] = op[0] + (tp[0] * (1 - alpha));
 401                         tp[1] = op[1] + (tp[1] * (1 - alpha));
 402                         tp[2] = op[2] + (tp[2] * (1 - alpha));
 403                         tp[3] = op[3] + (tp[3] * (1 - alpha));
 404
 405                         tp += this_bpp;
 406                         op += other_bpp;
 407                 }
 408         }
 409 }
 410
 411 void
 412 Image::copy (shared_ptr<const Image> other, Position<int> position)
 413 {
 414         /* Only implemented for RGB24 onto RGB24 so far */
 415         assert (_pixel_format == PIX_FMT_RGB24 && other->pixel_format() == PIX_FMT_RGB24);
 416         assert (position.x >= 0 && position.y >= 0);
 417
 418         int const N = min (position.x + other->size().width, size().width) - position.x;
 419         for (int ty = position.y, oy = 0; ty < size().height && oy < other->size().height; ++ty, ++oy) {
 420                 uint8_t * const tp = data()[0] + ty * stride()[0] + position.x * 3;
 421                 uint8_t * const op = other->data()[0] + oy * other->stride()[0];
 422                 memcpy (tp, op, N * 3);
 423         }
 424 }
 425
 426 void
 427 Image::read_from_socket (shared_ptr<Socket> socket)
 428 {
 429         for (int i = 0; i < components(); ++i) {
 430                 uint8_t* p = data()[i];
 431                 for (int y = 0; y < lines(i); ++y) {
 432                         socket->read (p, line_size()[i]);
 433                         p += stride()[i];
 434                 }
 435         }
 436 }
 437
 438 void
 439 Image::write_to_socket (shared_ptr<Socket> socket) const
 440 {
 441         for (int i = 0; i < components(); ++i) {
 442                 uint8_t* p = data()[i];
 443                 for (int y = 0; y < lines(i); ++y) {
 444                         socket->write (p, line_size()[i]);
 445                         p += stride()[i];
 446                 }
 447         }
 448 }
 449
 450
 451 float
 452 Image::bytes_per_pixel (int c) const
 453 {
 454         AVPixFmtDescriptor const * d = av_pix_fmt_desc_get(_pixel_format);
 455         if (!d) {
 456                 throw PixelFormatError ("lines()", _pixel_format);
 457         }
 458
 459         if (c >= components()) {
 460                 return 0;
 461         }
 462
 463         float bpp[4] = { 0, 0, 0, 0 };
 464
 465         bpp[0] = floor ((d->comp[0].depth_minus1 + 1 + 7) / 8);
 466         if (d->nb_components > 1) {
 467                 bpp[1] = floor ((d->comp[1].depth_minus1 + 1 + 7) / 8) / pow (2.0f, d->log2_chroma_w);
 468         }
 469         if (d->nb_components > 2) {
 470                 bpp[2] = floor ((d->comp[2].depth_minus1 + 1 + 7) / 8) / pow (2.0f, d->log2_chroma_w);
 471         }
 472         if (d->nb_components > 3) {
 473                 bpp[3] = floor ((d->comp[3].depth_minus1 + 1 + 7) / 8) / pow (2.0f, d->log2_chroma_w);
 474         }
 475
 476         if ((d->flags & PIX_FMT_PLANAR) == 0) {
 477                 /* Not planar; sum them up */
 478                 return bpp[0] + bpp[1] + bpp[2] + bpp[3];
 479         }
 480
 481         return bpp[c];
 482 }
 483
 484 /** Construct a Image of a given size and format, allocating memory
 485  *  as required.
 486  *
 487  *  @param p Pixel format.
 488  *  @param s Size in pixels.
 489  */
 490 Image::Image (AVPixelFormat p, dcp::Size s, bool aligned)
 491         : dcp::Image (s)
 492         , _pixel_format (p)
 493         , _aligned (aligned)
 494 {
 495         allocate ();
 496 }
 497
 498 void
 499 Image::allocate ()
 500 {
 501         _data = (uint8_t **) wrapped_av_malloc (4 * sizeof (uint8_t *));
 502         _data[0] = _data[1] = _data[2] = _data[3] = 0;
 503
 504         _line_size = (int *) wrapped_av_malloc (4 * sizeof (int));
 505         _line_size[0] = _line_size[1] = _line_size[2] = _line_size[3] = 0;
 506
 507         _stride = (int *) wrapped_av_malloc (4 * sizeof (int));
 508         _stride[0] = _stride[1] = _stride[2] = _stride[3] = 0;
 509
 510         for (int i = 0; i < components(); ++i) {
 511                 _line_size[i] = ceil (_size.width * bytes_per_pixel(i));
 512                 _stride[i] = stride_round_up (i, _line_size, _aligned ? 32 : 1);
 513
 514                 /* The assembler function ff_rgb24ToY_avx (in libswscale/x86/input.asm)
 515                    uses a 16-byte fetch to read three bytes (R/G/B) of image data.
 516                    Hence on the last pixel of the last line it reads over the end of
 517                    the actual data by 1 byte.  If the width of an image is a multiple
 518                    of the stride alignment there will be no padding at the end of image lines.
 519                    OS X crashes on this illegal read, though other operating systems don't
 520                    seem to mind.  The nasty + 1 in this malloc makes sure there is always a byte
 521                    for that instruction to read safely.
 522
 523                    Further to the above, valgrind is now telling me that ff_rgb24ToY_ssse3
 524                    over-reads by more then _avx.  I can't follow the code to work out how much,
 525                    so I'll just over-allocate by 32 bytes and have done with it.  Empirical
 526                    testing suggests that it works.
 527                 */
 528                 _data[i] = (uint8_t *) wrapped_av_malloc (_stride[i] * lines (i) + 32);
 529         }
 530 }
 531
 532 Image::Image (Image const & other)
 533         : dcp::Image (other)
 534         ,  _pixel_format (other._pixel_format)
 535         , _aligned (other._aligned)
 536 {
 537         allocate ();
 538
 539         for (int i = 0; i < components(); ++i) {
 540                 uint8_t* p = _data[i];
 541                 uint8_t* q = other._data[i];
 542                 for (int j = 0; j < lines(i); ++j) {
 543                         memcpy (p, q, _line_size[i]);
 544                         p += stride()[i];
 545                         q += other.stride()[i];
 546                 }
 547         }
 548 }
 549
 550 Image::Image (AVFrame* frame)
 551         : dcp::Image (dcp::Size (frame->width, frame->height))
 552         , _pixel_format (static_cast<AVPixelFormat> (frame->format))
 553         , _aligned (true)
 554 {
 555         allocate ();
 556
 557         for (int i = 0; i < components(); ++i) {
 558                 uint8_t* p = _data[i];
 559                 uint8_t* q = frame->data[i];
 560                 for (int j = 0; j < lines(i); ++j) {
 561                         memcpy (p, q, _line_size[i]);
 562                         p += stride()[i];
 563                         /* AVFrame's linesize is what we call `stride' */
 564                         q += frame->linesize[i];
 565                 }
 566         }
 567 }
 568
 569 Image::Image (shared_ptr<const Image> other, bool aligned)
 570         : dcp::Image (other)
 571         , _pixel_format (other->_pixel_format)
 572         , _aligned (aligned)
 573 {
 574         allocate ();
 575
 576         for (int i = 0; i < components(); ++i) {
 577                 assert(line_size()[i] == other->line_size()[i]);
 578                 uint8_t* p = _data[i];
 579                 uint8_t* q = other->data()[i];
 580                 for (int j = 0; j < lines(i); ++j) {
 581                         memcpy (p, q, line_size()[i]);
 582                         p += stride()[i];
 583                         q += other->stride()[i];
 584                 }
 585         }
 586 }
 587
 588 Image&
 589 Image::operator= (Image const & other)
 590 {
 591         if (this == &other) {
 592                 return *this;
 593         }
 594
 595         Image tmp (other);
 596         swap (tmp);
 597         return *this;
 598 }
 599
 600 void
 601 Image::swap (Image & other)
 602 {
 603         dcp::Image::swap (other);
 604
 605         std::swap (_pixel_format, other._pixel_format);
 606
 607         for (int i = 0; i < 4; ++i) {
 608                 std::swap (_data[i], other._data[i]);
 609                 std::swap (_line_size[i], other._line_size[i]);
 610                 std::swap (_stride[i], other._stride[i]);
 611         }
 612
 613         std::swap (_aligned, other._aligned);
 614 }
 615
 616 /** Destroy a Image */
 617 Image::~Image ()
 618 {
 619         for (int i = 0; i < components(); ++i) {
 620                 av_free (_data[i]);
 621         }
 622
 623         av_free (_data);
 624         av_free (_line_size);
 625         av_free (_stride);
 626 }
 627
 628 uint8_t **
 629 Image::data () const
 630 {
 631         return _data;
 632 }
 633
 634 int *
 635 Image::line_size () const
 636 {
 637         return _line_size;
 638 }
 639
 640 int *
 641 Image::stride () const
 642 {
 643         return _stride;
 644 }
 645
 646 dcp::Size
 647 Image::size () const
 648 {
 649         return _size;
 650 }
 651
 652 bool
 653 Image::aligned () const
 654 {
 655         return _aligned;
 656 }
 657
 658 PositionImage
 659 merge (list<PositionImage> images)
 660 {
 661         if (images.empty ()) {
 662                 return PositionImage ();
 663         }
 664
 665         if (images.size() == 1) {
 666                 return images.front ();
 667         }
 668
 669         dcpomatic::Rect<int> all (images.front().position, images.front().image->size().width, images.front().image->size().height);
 670         for (list<PositionImage>::const_iterator i = images.begin(); i != images.end(); ++i) {
 671                 all.extend (dcpomatic::Rect<int> (i->position, i->image->size().width, i->image->size().height));
 672         }
 673
 674         shared_ptr<Image> merged (new Image (images.front().image->pixel_format (), dcp::Size (all.width, all.height), true));
 675         merged->make_transparent ();
 676         for (list<PositionImage>::const_iterator i = images.begin(); i != images.end(); ++i) {
 677                 merged->alpha_blend (i->image, i->position - all.position());
 678         }
 679
 680         return PositionImage (merged, all.position ());
 681 }
 682
 683 string
 684 Image::digest () const
 685 {
 686         MD5Digester digester;
 687
 688         for (int i = 0; i < components(); ++i) {
 689                 digester.add (data()[i], line_size()[i]);
 690         }
 691
 692         return digester.get ();
 693 }