src/lib/image.cc

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