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                 memset (data()[0], 0, lines(0) * stride()[0]);
 326                 break;
 327
 328         case PIX_FMT_UYVY422:
 329         {
 330                 int const Y = lines(0);
 331                 int const X = line_size()[0];
 332                 uint8_t* p = data()[0];
 333                 for (int y = 0; y < Y; ++y) {
 334                         for (int x = 0; x < X / 4; ++x) {
 335                                 *p++ = eight_bit_uv; // Cb
 336                                 *p++ = 0;            // Y0
 337                                 *p++ = eight_bit_uv; // Cr
 338                                 *p++ = 0;            // Y1
 339                         }
 340                 }
 341                 break;
 342         }
 343
 344         default:
 345                 throw PixelFormatError ("make_black()", _pixel_format);
 346         }
 347 }
 348
 349 void
 350 Image::make_transparent ()
 351 {
 352         if (_pixel_format != PIX_FMT_RGBA) {
 353                 throw PixelFormatError ("make_transparent()", _pixel_format);
 354         }
 355
 356         memset (data()[0], 0, lines(0) * stride()[0]);
 357 }
 358
 359 void
 360 Image::alpha_blend (shared_ptr<const Image> other, Position<int> position)
 361 {
 362         int this_bpp = 0;
 363         int other_bpp = 0;
 364
 365         if (_pixel_format == PIX_FMT_BGRA && other->pixel_format() == PIX_FMT_RGBA) {
 366                 this_bpp = 4;
 367                 other_bpp = 4;
 368         } else if (_pixel_format == PIX_FMT_RGB24 && other->pixel_format() == PIX_FMT_RGBA) {
 369                 this_bpp = 3;
 370                 other_bpp = 4;
 371         } else {
 372                 assert (false);
 373         }
 374
 375         int start_tx = position.x;
 376         int start_ox = 0;
 377
 378         if (start_tx < 0) {
 379                 start_ox = -start_tx;
 380                 start_tx = 0;
 381         }
 382
 383         int start_ty = position.y;
 384         int start_oy = 0;
 385
 386         if (start_ty < 0) {
 387                 start_oy = -start_ty;
 388                 start_ty = 0;
 389         }
 390
 391         for (int ty = start_ty, oy = start_oy; ty < size().height && oy < other->size().height; ++ty, ++oy) {
 392                 uint8_t* tp = data()[0] + ty * stride()[0] + position.x * this_bpp;
 393                 uint8_t* op = other->data()[0] + oy * other->stride()[0];
 394                 for (int tx = start_tx, ox = start_ox; tx < size().width && ox < other->size().width; ++tx, ++ox) {
 395                         float const alpha = float (op[3]) / 255;
 396                         tp[0] = (tp[0] * (1 - alpha)) + op[0] * alpha;
 397                         tp[1] = (tp[1] * (1 - alpha)) + op[1] * alpha;
 398                         tp[2] = (tp[2] * (1 - alpha)) + op[2] * alpha;
 399                         tp += this_bpp;
 400                         op += other_bpp;
 401                 }
 402         }
 403 }
 404
 405 void
 406 Image::copy (shared_ptr<const Image> other, Position<int> position)
 407 {
 408         /* Only implemented for RGB24 onto RGB24 so far */
 409         assert (_pixel_format == PIX_FMT_RGB24 && other->pixel_format() == PIX_FMT_RGB24);
 410         assert (position.x >= 0 && position.y >= 0);
 411
 412         int const N = min (position.x + other->size().width, size().width) - position.x;
 413         for (int ty = position.y, oy = 0; ty < size().height && oy < other->size().height; ++ty, ++oy) {
 414                 uint8_t * const tp = data()[0] + ty * stride()[0] + position.x * 3;
 415                 uint8_t * const op = other->data()[0] + oy * other->stride()[0];
 416                 memcpy (tp, op, N * 3);
 417         }
 418 }
 419
 420 void
 421 Image::read_from_socket (shared_ptr<Socket> socket)
 422 {
 423         for (int i = 0; i < components(); ++i) {
 424                 uint8_t* p = data()[i];
 425                 for (int y = 0; y < lines(i); ++y) {
 426                         socket->read (p, line_size()[i]);
 427                         p += stride()[i];
 428                 }
 429         }
 430 }
 431
 432 void
 433 Image::write_to_socket (shared_ptr<Socket> socket) const
 434 {
 435         for (int i = 0; i < components(); ++i) {
 436                 uint8_t* p = data()[i];
 437                 for (int y = 0; y < lines(i); ++y) {
 438                         socket->write (p, line_size()[i]);
 439                         p += stride()[i];
 440                 }
 441         }
 442 }
 443
 444
 445 float
 446 Image::bytes_per_pixel (int c) const
 447 {
 448         AVPixFmtDescriptor const * d = av_pix_fmt_desc_get(_pixel_format);
 449         if (!d) {
 450                 throw PixelFormatError ("lines()", _pixel_format);
 451         }
 452
 453         if (c >= components()) {
 454                 return 0;
 455         }
 456
 457         float bpp[4] = { 0, 0, 0, 0 };
 458
 459         bpp[0] = floor ((d->comp[0].depth_minus1 + 1 + 7) / 8);
 460         if (d->nb_components > 1) {
 461                 bpp[1] = floor ((d->comp[1].depth_minus1 + 1 + 7) / 8) / pow (2.0f, d->log2_chroma_w);
 462         }
 463         if (d->nb_components > 2) {
 464                 bpp[2] = floor ((d->comp[2].depth_minus1 + 1 + 7) / 8) / pow (2.0f, d->log2_chroma_w);
 465         }
 466         if (d->nb_components > 3) {
 467                 bpp[3] = floor ((d->comp[3].depth_minus1 + 1 + 7) / 8) / pow (2.0f, d->log2_chroma_w);
 468         }
 469
 470         if ((d->flags & PIX_FMT_PLANAR) == 0) {
 471                 /* Not planar; sum them up */
 472                 return bpp[0] + bpp[1] + bpp[2] + bpp[3];
 473         }
 474
 475         return bpp[c];
 476 }
 477
 478 /** Construct a Image of a given size and format, allocating memory
 479  *  as required.
 480  *
 481  *  @param p Pixel format.
 482  *  @param s Size in pixels.
 483  */
 484 Image::Image (AVPixelFormat p, dcp::Size s, bool aligned)
 485         : dcp::Image (s)
 486         , _pixel_format (p)
 487         , _aligned (aligned)
 488 {
 489         allocate ();
 490 }
 491
 492 void
 493 Image::allocate ()
 494 {
 495         _data = (uint8_t **) wrapped_av_malloc (4 * sizeof (uint8_t *));
 496         _data[0] = _data[1] = _data[2] = _data[3] = 0;
 497
 498         _line_size = (int *) wrapped_av_malloc (4 * sizeof (int));
 499         _line_size[0] = _line_size[1] = _line_size[2] = _line_size[3] = 0;
 500
 501         _stride = (int *) wrapped_av_malloc (4 * sizeof (int));
 502         _stride[0] = _stride[1] = _stride[2] = _stride[3] = 0;
 503
 504         for (int i = 0; i < components(); ++i) {
 505                 _line_size[i] = ceil (_size.width * bytes_per_pixel(i));
 506                 _stride[i] = stride_round_up (i, _line_size, _aligned ? 32 : 1);
 507
 508                 /* The assembler function ff_rgb24ToY_avx (in libswscale/x86/input.asm)
 509                    uses a 16-byte fetch to read three bytes (R/G/B) of image data.
 510                    Hence on the last pixel of the last line it reads over the end of
 511                    the actual data by 1 byte.  If the width of an image is a multiple
 512                    of the stride alignment there will be no padding at the end of image lines.
 513                    OS X crashes on this illegal read, though other operating systems don't
 514                    seem to mind.  The nasty + 1 in this malloc makes sure there is always a byte
 515                    for that instruction to read safely.
 516
 517                    Further to the above, valgrind is now telling me that ff_rgb24ToY_ssse3
 518                    over-reads by more then _avx.  I can't follow the code to work out how much,
 519                    so I'll just over-allocate by 32 bytes and have done with it.  Empirical
 520                    testing suggests that it works.
 521                 */
 522                 _data[i] = (uint8_t *) wrapped_av_malloc (_stride[i] * lines (i) + 32);
 523         }
 524 }
 525
 526 Image::Image (Image const & other)
 527         : dcp::Image (other)
 528         ,  _pixel_format (other._pixel_format)
 529         , _aligned (other._aligned)
 530 {
 531         allocate ();
 532
 533         for (int i = 0; i < components(); ++i) {
 534                 uint8_t* p = _data[i];
 535                 uint8_t* q = other._data[i];
 536                 for (int j = 0; j < lines(i); ++j) {
 537                         memcpy (p, q, _line_size[i]);
 538                         p += stride()[i];
 539                         q += other.stride()[i];
 540                 }
 541         }
 542 }
 543
 544 Image::Image (AVFrame* frame)
 545         : dcp::Image (dcp::Size (frame->width, frame->height))
 546         , _pixel_format (static_cast<AVPixelFormat> (frame->format))
 547         , _aligned (true)
 548 {
 549         allocate ();
 550
 551         for (int i = 0; i < components(); ++i) {
 552                 uint8_t* p = _data[i];
 553                 uint8_t* q = frame->data[i];
 554                 for (int j = 0; j < lines(i); ++j) {
 555                         memcpy (p, q, _line_size[i]);
 556                         p += stride()[i];
 557                         /* AVFrame's linesize is what we call `stride' */
 558                         q += frame->linesize[i];
 559                 }
 560         }
 561 }
 562
 563 Image::Image (shared_ptr<const Image> other, bool aligned)
 564         : dcp::Image (other)
 565         , _pixel_format (other->_pixel_format)
 566         , _aligned (aligned)
 567 {
 568         allocate ();
 569
 570         for (int i = 0; i < components(); ++i) {
 571                 assert(line_size()[i] == other->line_size()[i]);
 572                 uint8_t* p = _data[i];
 573                 uint8_t* q = other->data()[i];
 574                 for (int j = 0; j < lines(i); ++j) {
 575                         memcpy (p, q, line_size()[i]);
 576                         p += stride()[i];
 577                         q += other->stride()[i];
 578                 }
 579         }
 580 }
 581
 582 Image&
 583 Image::operator= (Image const & other)
 584 {
 585         if (this == &other) {
 586                 return *this;
 587         }
 588
 589         Image tmp (other);
 590         swap (tmp);
 591         return *this;
 592 }
 593
 594 void
 595 Image::swap (Image & other)
 596 {
 597         dcp::Image::swap (other);
 598
 599         std::swap (_pixel_format, other._pixel_format);
 600
 601         for (int i = 0; i < 4; ++i) {
 602                 std::swap (_data[i], other._data[i]);
 603                 std::swap (_line_size[i], other._line_size[i]);
 604                 std::swap (_stride[i], other._stride[i]);
 605         }
 606
 607         std::swap (_aligned, other._aligned);
 608 }
 609
 610 /** Destroy a Image */
 611 Image::~Image ()
 612 {
 613         for (int i = 0; i < components(); ++i) {
 614                 av_free (_data[i]);
 615         }
 616
 617         av_free (_data);
 618         av_free (_line_size);
 619         av_free (_stride);
 620 }
 621
 622 uint8_t **
 623 Image::data () const
 624 {
 625         return _data;
 626 }
 627
 628 int *
 629 Image::line_size () const
 630 {
 631         return _line_size;
 632 }
 633
 634 int *
 635 Image::stride () const
 636 {
 637         return _stride;
 638 }
 639
 640 dcp::Size
 641 Image::size () const
 642 {
 643         return _size;
 644 }
 645
 646 bool
 647 Image::aligned () const
 648 {
 649         return _aligned;
 650 }
 651
 652 PositionImage
 653 merge (list<PositionImage> images)
 654 {
 655         if (images.empty ()) {
 656                 return PositionImage ();
 657         }
 658
 659         dcpomatic::Rect<int> all (images.front().position, images.front().image->size().width, images.front().image->size().height);
 660         for (list<PositionImage>::const_iterator i = images.begin(); i != images.end(); ++i) {
 661                 all.extend (dcpomatic::Rect<int> (i->position, i->image->size().width, i->image->size().height));
 662         }
 663
 664         shared_ptr<Image> merged (new Image (images.front().image->pixel_format (), dcp::Size (all.width, all.height), true));
 665         merged->make_transparent ();
 666         for (list<PositionImage>::const_iterator i = images.begin(); i != images.end(); ++i) {
 667                 merged->alpha_blend (i->image, i->position);
 668         }
 669
 670         return PositionImage (merged, all.position ());
 671 }
 672
 673 string
 674 Image::digest () const
 675 {
 676         MD5Digester digester;
 677
 678         for (int i = 0; i < components(); ++i) {
 679                 digester.add (data()[i], line_size()[i]);
 680         }
 681
 682         return digester.get ();
 683 }