src/lib/image.cc

   1 /*
   2     Copyright (C) 2012-2021 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of DCP-o-matic.
   5
   6     DCP-o-matic is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     DCP-o-matic is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with DCP-o-matic.  If not, see <http://www.gnu.org/licenses/>.
  18
  19 */
  20
  21
  22 /** @file src/image.cc
  23  *  @brief A class to describe a video image.
  24  */
  25
  26
  27 #include "compose.hpp"
  28 #include "dcpomatic_assert.h"
  29 #include "dcpomatic_socket.h"
  30 #include "exceptions.h"
  31 #include "image.h"
  32 #include "maths_util.h"
  33 #include "memory_util.h"
  34 #include "rect.h"
  35 #include "timer.h"
  36 #include <dcp/rgb_xyz.h>
  37 #include <dcp/transfer_function.h>
  38 #include <dcp/warnings.h>
  39 LIBDCP_DISABLE_WARNINGS
  40 extern "C" {
  41 #include <libavutil/frame.h>
  42 #include <libavutil/pixdesc.h>
  43 #include <libavutil/pixfmt.h>
  44 #include <libswscale/swscale.h>
  45 }
  46 LIBDCP_ENABLE_WARNINGS
  47 #if HAVE_VALGRIND_MEMCHECK_H
  48 #include <valgrind/memcheck.h>
  49 #endif
  50 #include <iostream>
  51
  52
  53 #include "i18n.h"
  54
  55
  56 using std::cerr;
  57 using std::cout;
  58 using std::list;
  59 using std::make_shared;
  60 using std::max;
  61 using std::min;
  62 using std::runtime_error;
  63 using std::shared_ptr;
  64 using std::string;
  65 using dcp::Size;
  66
  67
  68 /** The memory alignment, in bytes, used for each row of an image if Alignment::PADDED is requested */
  69 int constexpr ALIGNMENT = 64;
  70
  71 /* U/V black value for 8-bit colour */
  72 static uint8_t const eight_bit_uv =     (1 << 7) - 1;
  73 /* U/V black value for 9-bit colour */
  74 static uint16_t const nine_bit_uv =     (1 << 8) - 1;
  75 /* U/V black value for 10-bit colour */
  76 static uint16_t const ten_bit_uv =      (1 << 9) - 1;
  77 /* U/V black value for 16-bit colour */
  78 static uint16_t const sixteen_bit_uv =  (1 << 15) - 1;
  79
  80
  81 int
  82 Image::vertical_factor (int n) const
  83 {
  84         if (n == 0) {
  85                 return 1;
  86         }
  87
  88         auto d = av_pix_fmt_desc_get(_pixel_format);
  89         if (!d) {
  90                 throw PixelFormatError ("line_factor()", _pixel_format);
  91         }
  92
  93         return lrintf(powf(2.0f, d->log2_chroma_h));
  94 }
  95
  96 int
  97 Image::horizontal_factor (int n) const
  98 {
  99         if (n == 0) {
 100                 return 1;
 101         }
 102
 103         auto d = av_pix_fmt_desc_get(_pixel_format);
 104         if (!d) {
 105                 throw PixelFormatError ("sample_size()", _pixel_format);
 106         }
 107
 108         return lrintf(powf(2.0f, d->log2_chroma_w));
 109 }
 110
 111
 112 /** @param n Component index.
 113  *  @return Number of samples (i.e. pixels, unless sub-sampled) in each direction for this component.
 114  */
 115 dcp::Size
 116 Image::sample_size (int n) const
 117 {
 118         return dcp::Size (
 119                 lrint (ceil(static_cast<double>(size().width) / horizontal_factor(n))),
 120                 lrint (ceil(static_cast<double>(size().height) / vertical_factor(n)))
 121                 );
 122 }
 123
 124
 125 /** @return Number of planes */
 126 int
 127 Image::planes () const
 128 {
 129         if (_pixel_format == AV_PIX_FMT_PAL8) {
 130                 return 2;
 131         }
 132
 133         auto d = av_pix_fmt_desc_get(_pixel_format);
 134         if (!d) {
 135                 throw PixelFormatError ("planes()", _pixel_format);
 136         }
 137
 138         if ((d->flags & AV_PIX_FMT_FLAG_PLANAR) == 0) {
 139                 return 1;
 140         }
 141
 142         return d->nb_components;
 143 }
 144
 145
 146 static
 147 int
 148 round_width_for_subsampling (int p, AVPixFmtDescriptor const * desc)
 149 {
 150         return p & ~ ((1 << desc->log2_chroma_w) - 1);
 151 }
 152
 153
 154 static
 155 int
 156 round_height_for_subsampling (int p, AVPixFmtDescriptor const * desc)
 157 {
 158         return p & ~ ((1 << desc->log2_chroma_h) - 1);
 159 }
 160
 161
 162 /** Crop this image, scale it to `inter_size' and then place it in a black frame of `out_size'.
 163  *  @param crop Amount to crop by.
 164  *  @param inter_size Size to scale the cropped image to.
 165  *  @param out_size Size of output frame; if this is larger than inter_size there will be black padding.
 166  *  @param yuv_to_rgb YUV to RGB transformation to use, if required.
 167  *  @param video_range Video range of the image.
 168  *  @param out_format Output pixel format.
 169  *  @param out_aligned true to make the output image aligned.
 170  *  @param out_video_range Video range to use for the output image.
 171  *  @param fast Try to be fast at the possible expense of quality; at present this means using
 172  *  fast bilinear rather than bicubic scaling.
 173  */
 174 shared_ptr<Image>
 175 Image::crop_scale_window (
 176         Crop crop,
 177         dcp::Size inter_size,
 178         dcp::Size out_size,
 179         dcp::YUVToRGB yuv_to_rgb,
 180         VideoRange video_range,
 181         AVPixelFormat out_format,
 182         VideoRange out_video_range,
 183         Alignment out_alignment,
 184         bool fast
 185         ) const
 186 {
 187         /* Empirical testing suggests that sws_scale() will crash if
 188            the input image is not padded.
 189         */
 190         DCPOMATIC_ASSERT (alignment() == Alignment::PADDED);
 191
 192         DCPOMATIC_ASSERT (out_size.width >= inter_size.width);
 193         DCPOMATIC_ASSERT (out_size.height >= inter_size.height);
 194
 195         auto out = make_shared<Image>(out_format, out_size, out_alignment);
 196         out->make_black ();
 197
 198         auto in_desc = av_pix_fmt_desc_get (_pixel_format);
 199         if (!in_desc) {
 200                 throw PixelFormatError ("crop_scale_window()", _pixel_format);
 201         }
 202
 203         /* Round down so that we crop only the number of pixels that is straightforward
 204          * considering any subsampling.
 205          */
 206         Crop corrected_crop(
 207                 round_width_for_subsampling(crop.left, in_desc),
 208                 round_width_for_subsampling(crop.right, in_desc),
 209                 round_height_for_subsampling(crop.top, in_desc),
 210                 round_height_for_subsampling(crop.bottom, in_desc)
 211                 );
 212
 213         /* Also check that we aren't cropping more image than there actually is */
 214         if ((corrected_crop.left + corrected_crop.right) >= (size().width - 4)) {
 215                 corrected_crop.left = 0;
 216                 corrected_crop.right = size().width - 4;
 217         }
 218
 219         if ((corrected_crop.top + corrected_crop.bottom) >= (size().height - 4)) {
 220                 corrected_crop.top = 0;
 221                 corrected_crop.bottom = size().height - 4;
 222         }
 223
 224         /* Size of the image after any crop */
 225         auto const cropped_size = corrected_crop.apply (size());
 226
 227         /* Scale context for a scale from cropped_size to inter_size */
 228         auto scale_context = sws_getContext (
 229                         cropped_size.width, cropped_size.height, pixel_format(),
 230                         inter_size.width, inter_size.height, out_format,
 231                         fast ? SWS_FAST_BILINEAR : SWS_BICUBIC, 0, 0, 0
 232                 );
 233
 234         if (!scale_context) {
 235                 throw runtime_error (N_("Could not allocate SwsContext"));
 236         }
 237
 238         DCPOMATIC_ASSERT (yuv_to_rgb < dcp::YUVToRGB::COUNT);
 239         int const lut[static_cast<int>(dcp::YUVToRGB::COUNT)] = {
 240                 SWS_CS_ITU601,
 241                 SWS_CS_ITU709
 242         };
 243
 244         /* The 3rd parameter here is:
 245            0 -> source range MPEG (i.e. "video", 16-235)
 246            1 -> source range JPEG (i.e. "full", 0-255)
 247            And the 5th:
 248            0 -> destination range MPEG (i.e. "video", 16-235)
 249            1 -> destination range JPEG (i.e. "full", 0-255)
 250
 251            But remember: sws_setColorspaceDetails ignores these
 252            parameters unless the both source and destination images
 253            are isYUV or isGray.  (If either is not, it uses video range).
 254         */
 255         sws_setColorspaceDetails (
 256                 scale_context,
 257                 sws_getCoefficients (lut[static_cast<int>(yuv_to_rgb)]), video_range == VideoRange::VIDEO ? 0 : 1,
 258                 sws_getCoefficients (lut[static_cast<int>(yuv_to_rgb)]), out_video_range == VideoRange::VIDEO ? 0 : 1,
 259                 0, 1 << 16, 1 << 16
 260                 );
 261
 262         /* Prepare input data pointers with crop */
 263         uint8_t* scale_in_data[planes()];
 264         for (int c = 0; c < planes(); ++c) {
 265                 int const x = lrintf(bytes_per_pixel(c) * corrected_crop.left);
 266                 scale_in_data[c] = data()[c] + x + stride()[c] * (corrected_crop.top / vertical_factor(c));
 267         }
 268
 269         auto out_desc = av_pix_fmt_desc_get (out_format);
 270         if (!out_desc) {
 271                 throw PixelFormatError ("crop_scale_window()", out_format);
 272         }
 273
 274         /* Corner of the image within out_size */
 275         Position<int> const corner (
 276                 round_width_for_subsampling((out_size.width - inter_size.width) / 2, out_desc),
 277                 round_height_for_subsampling((out_size.height - inter_size.height) / 2, out_desc)
 278                 );
 279
 280         uint8_t* scale_out_data[out->planes()];
 281         for (int c = 0; c < out->planes(); ++c) {
 282                 int const x = lrintf(out->bytes_per_pixel(c) * corner.x);
 283                 scale_out_data[c] = out->data()[c] + x + out->stride()[c] * (corner.y / out->vertical_factor(c));
 284         }
 285
 286         sws_scale (
 287                 scale_context,
 288                 scale_in_data, stride(),
 289                 0, cropped_size.height,
 290                 scale_out_data, out->stride()
 291                 );
 292
 293         sws_freeContext (scale_context);
 294
 295         /* There are some cases where there will be unwanted image data left in the image at this point:
 296          *
 297          * 1. When we are cropping without any scaling or pixel format conversion.
 298          * 2. When we are scaling to certain sizes and placing the result into a larger
 299          *    black frame.
 300          *
 301          * Clear out the left hand side of the image to take care of that.
 302          */
 303         out->make_part_black (corner.x + inter_size.width, (out_size.width - inter_size.width) / 2);
 304
 305         if (
 306                 video_range == VideoRange::VIDEO &&
 307                 out_video_range == VideoRange::FULL &&
 308                 av_pix_fmt_desc_get(_pixel_format)->flags & AV_PIX_FMT_FLAG_RGB
 309            ) {
 310                 /* libswscale will not convert video range for RGB sources, so we have to do it ourselves */
 311                 out->video_range_to_full_range ();
 312         }
 313
 314         return out;
 315 }
 316
 317
 318 shared_ptr<Image>
 319 Image::convert_pixel_format (dcp::YUVToRGB yuv_to_rgb, AVPixelFormat out_format, Alignment out_alignment, bool fast) const
 320 {
 321         return scale(size(), yuv_to_rgb, out_format, out_alignment, fast);
 322 }
 323
 324
 325 /** @param out_size Size to scale to.
 326  *  @param yuv_to_rgb YUVToRGB transform transform to use, if required.
 327  *  @param out_format Output pixel format.
 328  *  @param out_aligment Output alignment.
 329  *  @param fast Try to be fast at the possible expense of quality; at present this means using
 330  *  fast bilinear rather than bicubic scaling.
 331  */
 332 shared_ptr<Image>
 333 Image::scale (dcp::Size out_size, dcp::YUVToRGB yuv_to_rgb, AVPixelFormat out_format, Alignment out_alignment, bool fast) const
 334 {
 335         /* Empirical testing suggests that sws_scale() will crash if
 336            the input image alignment is not PADDED.
 337         */
 338         DCPOMATIC_ASSERT (alignment() == Alignment::PADDED);
 339
 340         auto scaled = make_shared<Image>(out_format, out_size, out_alignment);
 341         auto scale_context = sws_getContext (
 342                 size().width, size().height, pixel_format(),
 343                 out_size.width, out_size.height, out_format,
 344                 (fast ? SWS_FAST_BILINEAR : SWS_BICUBIC) | SWS_ACCURATE_RND, 0, 0, 0
 345                 );
 346
 347         DCPOMATIC_ASSERT (yuv_to_rgb < dcp::YUVToRGB::COUNT);
 348         int const lut[static_cast<int>(dcp::YUVToRGB::COUNT)] = {
 349                 SWS_CS_ITU601,
 350                 SWS_CS_ITU709
 351         };
 352
 353         /* The 3rd parameter here is:
 354            0 -> source range MPEG (i.e. "video", 16-235)
 355            1 -> source range JPEG (i.e. "full", 0-255)
 356            And the 5th:
 357            0 -> destination range MPEG (i.e. "video", 16-235)
 358            1 -> destination range JPEG (i.e. "full", 0-255)
 359
 360            But remember: sws_setColorspaceDetails ignores these
 361            parameters unless the corresponding image isYUV or isGray.
 362            (If it's neither, it uses video range).
 363         */
 364         sws_setColorspaceDetails (
 365                 scale_context,
 366                 sws_getCoefficients (lut[static_cast<int>(yuv_to_rgb)]), 0,
 367                 sws_getCoefficients (lut[static_cast<int>(yuv_to_rgb)]), 0,
 368                 0, 1 << 16, 1 << 16
 369                 );
 370
 371         sws_scale (
 372                 scale_context,
 373                 data(), stride(),
 374                 0, size().height,
 375                 scaled->data(), scaled->stride()
 376                 );
 377
 378         sws_freeContext (scale_context);
 379
 380         return scaled;
 381 }
 382
 383
 384 /** Blacken a YUV image whose bits per pixel is rounded up to 16 */
 385 void
 386 Image::yuv_16_black (uint16_t v, bool alpha)
 387 {
 388         memset (data()[0], 0, sample_size(0).height * stride()[0]);
 389         for (int i = 1; i < 3; ++i) {
 390                 auto p = reinterpret_cast<int16_t*> (data()[i]);
 391                 int const lines = sample_size(i).height;
 392                 for (int y = 0; y < lines; ++y) {
 393                         /* We divide by 2 here because we are writing 2 bytes at a time */
 394                         for (int x = 0; x < line_size()[i] / 2; ++x) {
 395                                 p[x] = v;
 396                         }
 397                         p += stride()[i] / 2;
 398                 }
 399         }
 400
 401         if (alpha) {
 402                 memset (data()[3], 0, sample_size(3).height * stride()[3]);
 403         }
 404 }
 405
 406
 407 uint16_t
 408 Image::swap_16 (uint16_t v)
 409 {
 410         return ((v >> 8) & 0xff) | ((v & 0xff) << 8);
 411 }
 412
 413
 414 void
 415 Image::make_part_black (int const start, int const width)
 416 {
 417         auto y_part = [&]() {
 418                 int const bpp = bytes_per_pixel(0);
 419                 int const h = sample_size(0).height;
 420                 int const s = stride()[0];
 421                 auto p = data()[0];
 422                 for (int y = 0; y < h; ++y) {
 423                         memset (p + start * bpp, 0, width * bpp);
 424                         p += s;
 425                 }
 426         };
 427
 428         switch (_pixel_format) {
 429         case AV_PIX_FMT_RGB24:
 430         case AV_PIX_FMT_ARGB:
 431         case AV_PIX_FMT_RGBA:
 432         case AV_PIX_FMT_ABGR:
 433         case AV_PIX_FMT_BGRA:
 434         case AV_PIX_FMT_RGB555LE:
 435         case AV_PIX_FMT_RGB48LE:
 436         case AV_PIX_FMT_RGB48BE:
 437         case AV_PIX_FMT_XYZ12LE:
 438         {
 439                 int const h = sample_size(0).height;
 440                 int const bpp = bytes_per_pixel(0);
 441                 int const s = stride()[0];
 442                 uint8_t* p = data()[0];
 443                 for (int y = 0; y < h; y++) {
 444                         memset (p + start * bpp, 0, width * bpp);
 445                         p += s;
 446                 }
 447                 break;
 448         }
 449         case AV_PIX_FMT_YUV420P:
 450         {
 451                 y_part ();
 452                 for (int i = 1; i < 3; ++i) {
 453                         auto p = data()[i];
 454                         int const h = sample_size(i).height;
 455                         for (int y = 0; y < h; ++y) {
 456                                 for (int x = start / 2; x < (start + width) / 2; ++x) {
 457                                         p[x] = eight_bit_uv;
 458                                 }
 459                                 p += stride()[i];
 460                         }
 461                 }
 462                 break;
 463         }
 464         case AV_PIX_FMT_YUV422P10LE:
 465         {
 466                 y_part ();
 467                 for (int i = 1; i < 3; ++i) {
 468                         auto p = reinterpret_cast<int16_t*>(data()[i]);
 469                         int const h = sample_size(i).height;
 470                         for (int y = 0; y < h; ++y) {
 471                                 for (int x = start / 2; x < (start + width) / 2; ++x) {
 472                                         p[x] = ten_bit_uv;
 473                                 }
 474                                 p += stride()[i] / 2;
 475                         }
 476                 }
 477                 break;
 478         }
 479         default:
 480                 throw PixelFormatError ("make_part_black()", _pixel_format);
 481         }
 482 }
 483
 484
 485 void
 486 Image::make_black ()
 487 {
 488         switch (_pixel_format) {
 489         case AV_PIX_FMT_YUV420P:
 490         case AV_PIX_FMT_YUV422P:
 491         case AV_PIX_FMT_YUV444P:
 492         case AV_PIX_FMT_YUV411P:
 493                 memset (data()[0], 0, sample_size(0).height * stride()[0]);
 494                 memset (data()[1], eight_bit_uv, sample_size(1).height * stride()[1]);
 495                 memset (data()[2], eight_bit_uv, sample_size(2).height * stride()[2]);
 496                 break;
 497
 498         case AV_PIX_FMT_YUVJ420P:
 499         case AV_PIX_FMT_YUVJ422P:
 500         case AV_PIX_FMT_YUVJ444P:
 501                 memset (data()[0], 0, sample_size(0).height * stride()[0]);
 502                 memset (data()[1], eight_bit_uv + 1, sample_size(1).height * stride()[1]);
 503                 memset (data()[2], eight_bit_uv + 1, sample_size(2).height * stride()[2]);
 504                 break;
 505
 506         case AV_PIX_FMT_YUV422P9LE:
 507         case AV_PIX_FMT_YUV444P9LE:
 508                 yuv_16_black (nine_bit_uv, false);
 509                 break;
 510
 511         case AV_PIX_FMT_YUV422P9BE:
 512         case AV_PIX_FMT_YUV444P9BE:
 513                 yuv_16_black (swap_16 (nine_bit_uv), false);
 514                 break;
 515
 516         case AV_PIX_FMT_YUV422P10LE:
 517         case AV_PIX_FMT_YUV444P10LE:
 518                 yuv_16_black (ten_bit_uv, false);
 519                 break;
 520
 521         case AV_PIX_FMT_YUV422P16LE:
 522         case AV_PIX_FMT_YUV444P16LE:
 523                 yuv_16_black (sixteen_bit_uv, false);
 524                 break;
 525
 526         case AV_PIX_FMT_YUV444P10BE:
 527         case AV_PIX_FMT_YUV422P10BE:
 528                 yuv_16_black (swap_16 (ten_bit_uv), false);
 529                 break;
 530
 531         case AV_PIX_FMT_YUVA420P9BE:
 532         case AV_PIX_FMT_YUVA422P9BE:
 533         case AV_PIX_FMT_YUVA444P9BE:
 534                 yuv_16_black (swap_16 (nine_bit_uv), true);
 535                 break;
 536
 537         case AV_PIX_FMT_YUVA420P9LE:
 538         case AV_PIX_FMT_YUVA422P9LE:
 539         case AV_PIX_FMT_YUVA444P9LE:
 540                 yuv_16_black (nine_bit_uv, true);
 541                 break;
 542
 543         case AV_PIX_FMT_YUVA420P10BE:
 544         case AV_PIX_FMT_YUVA422P10BE:
 545         case AV_PIX_FMT_YUVA444P10BE:
 546                 yuv_16_black (swap_16 (ten_bit_uv), true);
 547                 break;
 548
 549         case AV_PIX_FMT_YUVA420P10LE:
 550         case AV_PIX_FMT_YUVA422P10LE:
 551         case AV_PIX_FMT_YUVA444P10LE:
 552                 yuv_16_black (ten_bit_uv, true);
 553                 break;
 554
 555         case AV_PIX_FMT_YUVA420P16BE:
 556         case AV_PIX_FMT_YUVA422P16BE:
 557         case AV_PIX_FMT_YUVA444P16BE:
 558                 yuv_16_black (swap_16 (sixteen_bit_uv), true);
 559                 break;
 560
 561         case AV_PIX_FMT_YUVA420P16LE:
 562         case AV_PIX_FMT_YUVA422P16LE:
 563         case AV_PIX_FMT_YUVA444P16LE:
 564                 yuv_16_black (sixteen_bit_uv, true);
 565                 break;
 566
 567         case AV_PIX_FMT_RGB24:
 568         case AV_PIX_FMT_ARGB:
 569         case AV_PIX_FMT_RGBA:
 570         case AV_PIX_FMT_ABGR:
 571         case AV_PIX_FMT_BGRA:
 572         case AV_PIX_FMT_RGB555LE:
 573         case AV_PIX_FMT_RGB48LE:
 574         case AV_PIX_FMT_RGB48BE:
 575         case AV_PIX_FMT_XYZ12LE:
 576                 memset (data()[0], 0, sample_size(0).height * stride()[0]);
 577                 break;
 578
 579         case AV_PIX_FMT_UYVY422:
 580         {
 581                 int const Y = sample_size(0).height;
 582                 int const X = line_size()[0];
 583                 uint8_t* p = data()[0];
 584                 for (int y = 0; y < Y; ++y) {
 585                         for (int x = 0; x < X / 4; ++x) {
 586                                 *p++ = eight_bit_uv; // Cb
 587                                 *p++ = 0;            // Y0
 588                                 *p++ = eight_bit_uv; // Cr
 589                                 *p++ = 0;            // Y1
 590                         }
 591                 }
 592                 break;
 593         }
 594
 595         default:
 596                 throw PixelFormatError ("make_black()", _pixel_format);
 597         }
 598 }
 599
 600
 601 void
 602 Image::make_transparent ()
 603 {
 604         if (_pixel_format != AV_PIX_FMT_BGRA && _pixel_format != AV_PIX_FMT_RGBA) {
 605                 throw PixelFormatError ("make_transparent()", _pixel_format);
 606         }
 607
 608         memset (data()[0], 0, sample_size(0).height * stride()[0]);
 609 }
 610
 611
 612 void
 613 Image::alpha_blend (shared_ptr<const Image> other, Position<int> position)
 614 {
 615         /* We're blending RGBA or BGRA images */
 616         DCPOMATIC_ASSERT (other->pixel_format() == AV_PIX_FMT_BGRA || other->pixel_format() == AV_PIX_FMT_RGBA);
 617         int const blue = other->pixel_format() == AV_PIX_FMT_BGRA ? 0 : 2;
 618         int const red = other->pixel_format() == AV_PIX_FMT_BGRA ? 2 : 0;
 619
 620         int const other_bpp = 4;
 621
 622         int start_tx = position.x;
 623         int start_ox = 0;
 624
 625         if (start_tx < 0) {
 626                 start_ox = -start_tx;
 627                 start_tx = 0;
 628         }
 629
 630         int start_ty = position.y;
 631         int start_oy = 0;
 632
 633         if (start_ty < 0) {
 634                 start_oy = -start_ty;
 635                 start_ty = 0;
 636         }
 637
 638         switch (_pixel_format) {
 639         case AV_PIX_FMT_RGB24:
 640         {
 641                 /* Going onto RGB24.  First byte is red, second green, third blue */
 642                 int const this_bpp = 3;
 643                 for (int ty = start_ty, oy = start_oy; ty < size().height && oy < other->size().height; ++ty, ++oy) {
 644                         uint8_t* tp = data()[0] + ty * stride()[0] + start_tx * this_bpp;
 645                         uint8_t* op = other->data()[0] + oy * other->stride()[0];
 646                         for (int tx = start_tx, ox = start_ox; tx < size().width && ox < other->size().width; ++tx, ++ox) {
 647                                 float const alpha = float (op[3]) / 255;
 648                                 tp[0] = op[red] * alpha + tp[0] * (1 - alpha);
 649                                 tp[1] = op[1] * alpha + tp[1] * (1 - alpha);
 650                                 tp[2] = op[blue] * alpha + tp[2] * (1 - alpha);
 651
 652                                 tp += this_bpp;
 653                                 op += other_bpp;
 654                         }
 655                 }
 656                 break;
 657         }
 658         case AV_PIX_FMT_BGRA:
 659         {
 660                 int const this_bpp = 4;
 661                 for (int ty = start_ty, oy = start_oy; ty < size().height && oy < other->size().height; ++ty, ++oy) {
 662                         uint8_t* tp = data()[0] + ty * stride()[0] + start_tx * this_bpp;
 663                         uint8_t* op = other->data()[0] + oy * other->stride()[0];
 664                         for (int tx = start_tx, ox = start_ox; tx < size().width && ox < other->size().width; ++tx, ++ox) {
 665                                 float const alpha = float (op[3]) / 255;
 666                                 tp[0] = op[blue] * alpha + tp[0] * (1 - alpha);
 667                                 tp[1] = op[1] * alpha + tp[1] * (1 - alpha);
 668                                 tp[2] = op[red] * alpha + tp[2] * (1 - alpha);
 669                                 tp[3] = op[3] * alpha + tp[3] * (1 - alpha);
 670
 671                                 tp += this_bpp;
 672                                 op += other_bpp;
 673                         }
 674                 }
 675                 break;
 676         }
 677         case AV_PIX_FMT_RGBA:
 678         {
 679                 int const this_bpp = 4;
 680                 for (int ty = start_ty, oy = start_oy; ty < size().height && oy < other->size().height; ++ty, ++oy) {
 681                         uint8_t* tp = data()[0] + ty * stride()[0] + start_tx * this_bpp;
 682                         uint8_t* op = other->data()[0] + oy * other->stride()[0];
 683                         for (int tx = start_tx, ox = start_ox; tx < size().width && ox < other->size().width; ++tx, ++ox) {
 684                                 float const alpha = float (op[3]) / 255;
 685                                 tp[0] = op[red] * alpha + tp[0] * (1 - alpha);
 686                                 tp[1] = op[1] * alpha + tp[1] * (1 - alpha);
 687                                 tp[2] = op[blue] * alpha + tp[2] * (1 - alpha);
 688                                 tp[3] = op[3] * alpha + tp[3] * (1 - alpha);
 689
 690                                 tp += this_bpp;
 691                                 op += other_bpp;
 692                         }
 693                 }
 694                 break;
 695         }
 696         case AV_PIX_FMT_RGB48LE:
 697         {
 698                 int const this_bpp = 6;
 699                 for (int ty = start_ty, oy = start_oy; ty < size().height && oy < other->size().height; ++ty, ++oy) {
 700                         uint8_t* tp = data()[0] + ty * stride()[0] + start_tx * this_bpp;
 701                         uint8_t* op = other->data()[0] + oy * other->stride()[0];
 702                         for (int tx = start_tx, ox = start_ox; tx < size().width && ox < other->size().width; ++tx, ++ox) {
 703                                 float const alpha = float (op[3]) / 255;
 704                                 /* Blend high bytes */
 705                                 tp[1] = op[red] * alpha + tp[1] * (1 - alpha);
 706                                 tp[3] = op[1] * alpha + tp[3] * (1 - alpha);
 707                                 tp[5] = op[blue] * alpha + tp[5] * (1 - alpha);
 708
 709                                 tp += this_bpp;
 710                                 op += other_bpp;
 711                         }
 712                 }
 713                 break;
 714         }
 715         case AV_PIX_FMT_XYZ12LE:
 716         {
 717                 auto conv = dcp::ColourConversion::srgb_to_xyz();
 718                 double fast_matrix[9];
 719                 dcp::combined_rgb_to_xyz (conv, fast_matrix);
 720                 auto lut_in = conv.in()->lut(0, 1, 8, false);
 721                 auto lut_out = conv.out()->lut(0, 1, 16, true);
 722                 int const this_bpp = 6;
 723                 for (int ty = start_ty, oy = start_oy; ty < size().height && oy < other->size().height; ++ty, ++oy) {
 724                         uint16_t* tp = reinterpret_cast<uint16_t*> (data()[0] + ty * stride()[0] + start_tx * this_bpp);
 725                         uint8_t* op = other->data()[0] + oy * other->stride()[0];
 726                         for (int tx = start_tx, ox = start_ox; tx < size().width && ox < other->size().width; ++tx, ++ox) {
 727                                 float const alpha = float (op[3]) / 255;
 728
 729                                 /* Convert sRGB to XYZ; op is BGRA.  First, input gamma LUT */
 730                                 double const r = lut_in[op[red]];
 731                                 double const g = lut_in[op[1]];
 732                                 double const b = lut_in[op[blue]];
 733
 734                                 /* RGB to XYZ, including Bradford transform and DCI companding */
 735                                 double const x = max(0.0, min(1.0, r * fast_matrix[0] + g * fast_matrix[1] + b * fast_matrix[2]));
 736                                 double const y = max(0.0, min(1.0, r * fast_matrix[3] + g * fast_matrix[4] + b * fast_matrix[5]));
 737                                 double const z = max(0.0, min(1.0, r * fast_matrix[6] + g * fast_matrix[7] + b * fast_matrix[8]));
 738
 739                                 /* Out gamma LUT and blend */
 740                                 tp[0] = lrint(lut_out[lrint(x * 65535)] * 65535) * alpha + tp[0] * (1 - alpha);
 741                                 tp[1] = lrint(lut_out[lrint(y * 65535)] * 65535) * alpha + tp[1] * (1 - alpha);
 742                                 tp[2] = lrint(lut_out[lrint(z * 65535)] * 65535) * alpha + tp[2] * (1 - alpha);
 743
 744                                 tp += this_bpp / 2;
 745                                 op += other_bpp;
 746                         }
 747                 }
 748                 break;
 749         }
 750         case AV_PIX_FMT_YUV420P:
 751         {
 752                 auto yuv = other->convert_pixel_format (dcp::YUVToRGB::REC709, _pixel_format, Alignment::COMPACT, false);
 753                 dcp::Size const ts = size();
 754                 dcp::Size const os = yuv->size();
 755                 for (int ty = start_ty, oy = start_oy; ty < ts.height && oy < os.height; ++ty, ++oy) {
 756                         int const hty = ty / 2;
 757                         int const hoy = oy / 2;
 758                         uint8_t* tY = data()[0] + (ty * stride()[0]) + start_tx;
 759                         uint8_t* tU = data()[1] + (hty * stride()[1]) + start_tx / 2;
 760                         uint8_t* tV = data()[2] + (hty * stride()[2]) + start_tx / 2;
 761                         uint8_t* oY = yuv->data()[0] + (oy * yuv->stride()[0]) + start_ox;
 762                         uint8_t* oU = yuv->data()[1] + (hoy * yuv->stride()[1]) + start_ox / 2;
 763                         uint8_t* oV = yuv->data()[2] + (hoy * yuv->stride()[2]) + start_ox / 2;
 764                         uint8_t* alpha = other->data()[0] + (oy * other->stride()[0]) + start_ox * 4;
 765                         for (int tx = start_tx, ox = start_ox; tx < ts.width && ox < os.width; ++tx, ++ox) {
 766                                 float const a = float(alpha[3]) / 255;
 767                                 *tY = *oY * a + *tY * (1 - a);
 768                                 *tU = *oU * a + *tU * (1 - a);
 769                                 *tV = *oV * a + *tV * (1 - a);
 770                                 ++tY;
 771                                 ++oY;
 772                                 if (tx % 2) {
 773                                         ++tU;
 774                                         ++tV;
 775                                 }
 776                                 if (ox % 2) {
 777                                         ++oU;
 778                                         ++oV;
 779                                 }
 780                                 alpha += 4;
 781                         }
 782                 }
 783                 break;
 784         }
 785         case AV_PIX_FMT_YUV420P10:
 786         {
 787                 auto yuv = other->convert_pixel_format (dcp::YUVToRGB::REC709, _pixel_format, Alignment::COMPACT, false);
 788                 dcp::Size const ts = size();
 789                 dcp::Size const os = yuv->size();
 790                 for (int ty = start_ty, oy = start_oy; ty < ts.height && oy < os.height; ++ty, ++oy) {
 791                         int const hty = ty / 2;
 792                         int const hoy = oy / 2;
 793                         uint16_t* tY = ((uint16_t *) (data()[0] + (ty * stride()[0]))) + start_tx;
 794                         uint16_t* tU = ((uint16_t *) (data()[1] + (hty * stride()[1]))) + start_tx / 2;
 795                         uint16_t* tV = ((uint16_t *) (data()[2] + (hty * stride()[2]))) + start_tx / 2;
 796                         uint16_t* oY = ((uint16_t *) (yuv->data()[0] + (oy * yuv->stride()[0]))) + start_ox;
 797                         uint16_t* oU = ((uint16_t *) (yuv->data()[1] + (hoy * yuv->stride()[1]))) + start_ox / 2;
 798                         uint16_t* oV = ((uint16_t *) (yuv->data()[2] + (hoy * yuv->stride()[2]))) + start_ox / 2;
 799                         uint8_t* alpha = other->data()[0] + (oy * other->stride()[0]) + start_ox * 4;
 800                         for (int tx = start_tx, ox = start_ox; tx < ts.width && ox < os.width; ++tx, ++ox) {
 801                                 float const a = float(alpha[3]) / 255;
 802                                 *tY = *oY * a + *tY * (1 - a);
 803                                 *tU = *oU * a + *tU * (1 - a);
 804                                 *tV = *oV * a + *tV * (1 - a);
 805                                 ++tY;
 806                                 ++oY;
 807                                 if (tx % 2) {
 808                                         ++tU;
 809                                         ++tV;
 810                                 }
 811                                 if (ox % 2) {
 812                                         ++oU;
 813                                         ++oV;
 814                                 }
 815                                 alpha += 4;
 816                         }
 817                 }
 818                 break;
 819         }
 820         case AV_PIX_FMT_YUV422P10LE:
 821         {
 822                 auto yuv = other->convert_pixel_format (dcp::YUVToRGB::REC709, _pixel_format, Alignment::COMPACT, false);
 823                 dcp::Size const ts = size();
 824                 dcp::Size const os = yuv->size();
 825                 for (int ty = start_ty, oy = start_oy; ty < ts.height && oy < os.height; ++ty, ++oy) {
 826                         uint16_t* tY = ((uint16_t *) (data()[0] + (ty * stride()[0]))) + start_tx;
 827                         uint16_t* tU = ((uint16_t *) (data()[1] + (ty * stride()[1]))) + start_tx / 2;
 828                         uint16_t* tV = ((uint16_t *) (data()[2] + (ty * stride()[2]))) + start_tx / 2;
 829                         uint16_t* oY = ((uint16_t *) (yuv->data()[0] + (oy * yuv->stride()[0]))) + start_ox;
 830                         uint16_t* oU = ((uint16_t *) (yuv->data()[1] + (oy * yuv->stride()[1]))) + start_ox / 2;
 831                         uint16_t* oV = ((uint16_t *) (yuv->data()[2] + (oy * yuv->stride()[2]))) + start_ox / 2;
 832                         uint8_t* alpha = other->data()[0] + (oy * other->stride()[0]) + start_ox * 4;
 833                         for (int tx = start_tx, ox = start_ox; tx < ts.width && ox < os.width; ++tx, ++ox) {
 834                                 float const a = float(alpha[3]) / 255;
 835                                 *tY = *oY * a + *tY * (1 - a);
 836                                 *tU = *oU * a + *tU * (1 - a);
 837                                 *tV = *oV * a + *tV * (1 - a);
 838                                 ++tY;
 839                                 ++oY;
 840                                 if (tx % 2) {
 841                                         ++tU;
 842                                         ++tV;
 843                                 }
 844                                 if (ox % 2) {
 845                                         ++oU;
 846                                         ++oV;
 847                                 }
 848                                 alpha += 4;
 849                         }
 850                 }
 851                 break;
 852         }
 853         default:
 854                 throw PixelFormatError ("alpha_blend()", _pixel_format);
 855         }
 856 }
 857
 858
 859 void
 860 Image::copy (shared_ptr<const Image> other, Position<int> position)
 861 {
 862         /* Only implemented for RGB24 onto RGB24 so far */
 863         DCPOMATIC_ASSERT (_pixel_format == AV_PIX_FMT_RGB24 && other->pixel_format() == AV_PIX_FMT_RGB24);
 864         DCPOMATIC_ASSERT (position.x >= 0 && position.y >= 0);
 865
 866         int const N = min (position.x + other->size().width, size().width) - position.x;
 867         for (int ty = position.y, oy = 0; ty < size().height && oy < other->size().height; ++ty, ++oy) {
 868                 uint8_t * const tp = data()[0] + ty * stride()[0] + position.x * 3;
 869                 uint8_t * const op = other->data()[0] + oy * other->stride()[0];
 870                 memcpy (tp, op, N * 3);
 871         }
 872 }
 873
 874
 875 void
 876 Image::read_from_socket (shared_ptr<Socket> socket)
 877 {
 878         for (int i = 0; i < planes(); ++i) {
 879                 uint8_t* p = data()[i];
 880                 int const lines = sample_size(i).height;
 881                 for (int y = 0; y < lines; ++y) {
 882                         socket->read (p, line_size()[i]);
 883                         p += stride()[i];
 884                 }
 885         }
 886 }
 887
 888
 889 void
 890 Image::write_to_socket (shared_ptr<Socket> socket) const
 891 {
 892         for (int i = 0; i < planes(); ++i) {
 893                 uint8_t* p = data()[i];
 894                 int const lines = sample_size(i).height;
 895                 for (int y = 0; y < lines; ++y) {
 896                         socket->write (p, line_size()[i]);
 897                         p += stride()[i];
 898                 }
 899         }
 900 }
 901
 902
 903 float
 904 Image::bytes_per_pixel (int c) const
 905 {
 906         auto d = av_pix_fmt_desc_get(_pixel_format);
 907         if (!d) {
 908                 throw PixelFormatError ("bytes_per_pixel()", _pixel_format);
 909         }
 910
 911         if (c >= planes()) {
 912                 return 0;
 913         }
 914
 915         float bpp[4] = { 0, 0, 0, 0 };
 916
 917 #ifdef DCPOMATIC_HAVE_AVCOMPONENTDESCRIPTOR_DEPTH_MINUS1
 918         bpp[0] = floor ((d->comp[0].depth_minus1 + 8) / 8);
 919         if (d->nb_components > 1) {
 920                 bpp[1] = floor ((d->comp[1].depth_minus1 + 8) / 8) / pow (2.0f, d->log2_chroma_w);
 921         }
 922         if (d->nb_components > 2) {
 923                 bpp[2] = floor ((d->comp[2].depth_minus1 + 8) / 8) / pow (2.0f, d->log2_chroma_w);
 924         }
 925         if (d->nb_components > 3) {
 926                 bpp[3] = floor ((d->comp[3].depth_minus1 + 8) / 8) / pow (2.0f, d->log2_chroma_w);
 927         }
 928 #else
 929         bpp[0] = floor ((d->comp[0].depth + 7) / 8);
 930         if (d->nb_components > 1) {
 931                 bpp[1] = floor ((d->comp[1].depth + 7) / 8) / pow (2.0f, d->log2_chroma_w);
 932         }
 933         if (d->nb_components > 2) {
 934                 bpp[2] = floor ((d->comp[2].depth + 7) / 8) / pow (2.0f, d->log2_chroma_w);
 935         }
 936         if (d->nb_components > 3) {
 937                 bpp[3] = floor ((d->comp[3].depth + 7) / 8) / pow (2.0f, d->log2_chroma_w);
 938         }
 939 #endif
 940
 941         if ((d->flags & AV_PIX_FMT_FLAG_PLANAR) == 0) {
 942                 /* Not planar; sum them up */
 943                 return bpp[0] + bpp[1] + bpp[2] + bpp[3];
 944         }
 945
 946         return bpp[c];
 947 }
 948
 949
 950 /** Construct a Image of a given size and format, allocating memory
 951  *  as required.
 952  *
 953  *  @param p Pixel format.
 954  *  @param s Size in pixels.
 955  *  @param alignment PADDED to make each row of this image aligned to a ALIGNMENT-byte boundary, otherwise COMPACT.
 956  */
 957 Image::Image (AVPixelFormat p, dcp::Size s, Alignment alignment)
 958         : _size (s)
 959         , _pixel_format (p)
 960         , _alignment (alignment)
 961 {
 962         allocate ();
 963 }
 964
 965
 966 void
 967 Image::allocate ()
 968 {
 969         _data = (uint8_t **) wrapped_av_malloc (4 * sizeof (uint8_t *));
 970         _data[0] = _data[1] = _data[2] = _data[3] = 0;
 971
 972         _line_size = (int *) wrapped_av_malloc (4 * sizeof (int));
 973         _line_size[0] = _line_size[1] = _line_size[2] = _line_size[3] = 0;
 974
 975         _stride = (int *) wrapped_av_malloc (4 * sizeof (int));
 976         _stride[0] = _stride[1] = _stride[2] = _stride[3] = 0;
 977
 978         auto stride_round_up = [](int stride, int t) {
 979                 int const a = stride + (t - 1);
 980                 return a - (a % t);
 981         };
 982
 983         for (int i = 0; i < planes(); ++i) {
 984                 _line_size[i] = ceil (_size.width * bytes_per_pixel(i));
 985                 _stride[i] = stride_round_up (_line_size[i], _alignment == Alignment::PADDED ? ALIGNMENT : 1);
 986
 987                 /* The assembler function ff_rgb24ToY_avx (in libswscale/x86/input.asm)
 988                    uses a 16-byte fetch to read three bytes (R/G/B) of image data.
 989                    Hence on the last pixel of the last line it reads over the end of
 990                    the actual data by 1 byte.  If the width of an image is a multiple
 991                    of the stride alignment there will be no padding at the end of image lines.
 992                    OS X crashes on this illegal read, though other operating systems don't
 993                    seem to mind.  The nasty + 1 in this malloc makes sure there is always a byte
 994                    for that instruction to read safely.
 995
 996                    Further to the above, valgrind is now telling me that ff_rgb24ToY_ssse3
 997                    over-reads by more then _avx.  I can't follow the code to work out how much,
 998                    so I'll just over-allocate by ALIGNMENT bytes and have done with it.  Empirical
 999                    testing suggests that it works.
1000
1001                    In addition to these concerns, we may read/write as much as a whole extra line
1002                    at the end of each plane in cases where we are messing with offsets in order to
1003                    do pad or crop.  To solve this we over-allocate by an extra _stride[i] bytes.
1004
1005                    As an example: we may write to images starting at an offset so we get some padding.
1006                    Hence we want to write in the following pattern:
1007
1008                    block start   write start                                  line end
1009                    |..(padding)..|<------line-size------------->|..(padding)..|
1010                    |..(padding)..|<------line-size------------->|..(padding)..|
1011                    |..(padding)..|<------line-size------------->|..(padding)..|
1012
1013                    where line-size is of the smaller (inter_size) image and the full padded line length is that of
1014                    out_size.  To get things to work we have to tell FFmpeg that the stride is that of out_size.
1015                    However some parts of FFmpeg (notably rgb48Toxyz12 in swscale.c) process data for the full
1016                    specified *stride*.  This does not matter until we get to the last line:
1017
1018                    block start   write start                                  line end
1019                    |..(padding)..|<------line-size------------->|XXXwrittenXXX|
1020                    |XXXwrittenXXX|<------line-size------------->|XXXwrittenXXX|
1021                    |XXXwrittenXXX|<------line-size------------->|XXXwrittenXXXXXXwrittenXXX
1022                                                                                ^^^^ out of bounds
1023                 */
1024                 _data[i] = (uint8_t *) wrapped_av_malloc (_stride[i] * (sample_size(i).height + 1) + ALIGNMENT);
1025 #if HAVE_VALGRIND_MEMCHECK_H
1026                 /* The data between the end of the line size and the stride is undefined but processed by
1027                    libswscale, causing lots of valgrind errors.  Mark it all defined to quell these errors.
1028                 */
1029                 VALGRIND_MAKE_MEM_DEFINED (_data[i], _stride[i] * (sample_size(i).height + 1) + ALIGNMENT);
1030 #endif
1031         }
1032 }
1033
1034
1035 Image::Image (Image const & other)
1036         : std::enable_shared_from_this<Image>(other)
1037         , _size (other._size)
1038         , _pixel_format (other._pixel_format)
1039         , _alignment (other._alignment)
1040 {
1041         allocate ();
1042
1043         for (int i = 0; i < planes(); ++i) {
1044                 uint8_t* p = _data[i];
1045                 uint8_t* q = other._data[i];
1046                 int const lines = sample_size(i).height;
1047                 for (int j = 0; j < lines; ++j) {
1048                         memcpy (p, q, _line_size[i]);
1049                         p += stride()[i];
1050                         q += other.stride()[i];
1051                 }
1052         }
1053 }
1054
1055
1056 Image::Image (AVFrame const * frame, Alignment alignment)
1057         : _size (frame->width, frame->height)
1058         , _pixel_format (static_cast<AVPixelFormat>(frame->format))
1059         , _alignment (alignment)
1060 {
1061         DCPOMATIC_ASSERT (_pixel_format != AV_PIX_FMT_NONE);
1062
1063         allocate ();
1064
1065         for (int i = 0; i < planes(); ++i) {
1066                 uint8_t* p = _data[i];
1067                 uint8_t* q = frame->data[i];
1068                 int const lines = sample_size(i).height;
1069                 for (int j = 0; j < lines; ++j) {
1070                         memcpy (p, q, _line_size[i]);
1071                         p += stride()[i];
1072                         /* AVFrame's linesize is what we call `stride' */
1073                         q += frame->linesize[i];
1074                 }
1075         }
1076 }
1077
1078
1079 Image::Image (shared_ptr<const Image> other, Alignment alignment)
1080         : _size (other->_size)
1081         , _pixel_format (other->_pixel_format)
1082         , _alignment (alignment)
1083 {
1084         allocate ();
1085
1086         for (int i = 0; i < planes(); ++i) {
1087                 DCPOMATIC_ASSERT (line_size()[i] == other->line_size()[i]);
1088                 uint8_t* p = _data[i];
1089                 uint8_t* q = other->data()[i];
1090                 int const lines = sample_size(i).height;
1091                 for (int j = 0; j < lines; ++j) {
1092                         memcpy (p, q, line_size()[i]);
1093                         p += stride()[i];
1094                         q += other->stride()[i];
1095                 }
1096         }
1097 }
1098
1099
1100 Image&
1101 Image::operator= (Image const & other)
1102 {
1103         if (this == &other) {
1104                 return *this;
1105         }
1106
1107         Image tmp (other);
1108         swap (tmp);
1109         return *this;
1110 }
1111
1112
1113 void
1114 Image::swap (Image & other)
1115 {
1116         std::swap (_size, other._size);
1117         std::swap (_pixel_format, other._pixel_format);
1118
1119         for (int i = 0; i < 4; ++i) {
1120                 std::swap (_data[i], other._data[i]);
1121                 std::swap (_line_size[i], other._line_size[i]);
1122                 std::swap (_stride[i], other._stride[i]);
1123         }
1124
1125         std::swap (_alignment, other._alignment);
1126 }
1127
1128
1129 Image::~Image ()
1130 {
1131         for (int i = 0; i < planes(); ++i) {
1132                 av_free (_data[i]);
1133         }
1134
1135         av_free (_data);
1136         av_free (_line_size);
1137         av_free (_stride);
1138 }
1139
1140
1141 uint8_t * const *
1142 Image::data () const
1143 {
1144         return _data;
1145 }
1146
1147
1148 int const *
1149 Image::line_size () const
1150 {
1151         return _line_size;
1152 }
1153
1154
1155 int const *
1156 Image::stride () const
1157 {
1158         return _stride;
1159 }
1160
1161
1162 dcp::Size
1163 Image::size () const
1164 {
1165         return _size;
1166 }
1167
1168
1169 Image::Alignment
1170 Image::alignment () const
1171 {
1172         return _alignment;
1173 }
1174
1175
1176 PositionImage
1177 merge (list<PositionImage> images, Image::Alignment alignment)
1178 {
1179         if (images.empty ()) {
1180                 return {};
1181         }
1182
1183         if (images.size() == 1) {
1184                 images.front().image = Image::ensure_alignment(images.front().image, alignment);
1185                 return images.front();
1186         }
1187
1188         dcpomatic::Rect<int> all (images.front().position, images.front().image->size().width, images.front().image->size().height);
1189         for (auto const& i: images) {
1190                 all.extend (dcpomatic::Rect<int>(i.position, i.image->size().width, i.image->size().height));
1191         }
1192
1193         auto merged = make_shared<Image>(images.front().image->pixel_format(), dcp::Size(all.width, all.height), alignment);
1194         merged->make_transparent ();
1195         for (auto const& i: images) {
1196                 merged->alpha_blend (i.image, i.position - all.position());
1197         }
1198
1199         return PositionImage (merged, all.position ());
1200 }
1201
1202
1203 bool
1204 operator== (Image const & a, Image const & b)
1205 {
1206         if (a.planes() != b.planes() || a.pixel_format() != b.pixel_format() || a.alignment() != b.alignment()) {
1207                 return false;
1208         }
1209
1210         for (int c = 0; c < a.planes(); ++c) {
1211                 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]) {
1212                         return false;
1213                 }
1214
1215                 uint8_t* p = a.data()[c];
1216                 uint8_t* q = b.data()[c];
1217                 int const lines = a.sample_size(c).height;
1218                 for (int y = 0; y < lines; ++y) {
1219                         if (memcmp (p, q, a.line_size()[c]) != 0) {
1220                                 return false;
1221                         }
1222
1223                         p += a.stride()[c];
1224                         q += b.stride()[c];
1225                 }
1226         }
1227
1228         return true;
1229 }
1230
1231
1232 /** Fade the image.
1233  *  @param f Amount to fade by; 0 is black, 1 is no fade.
1234  */
1235 void
1236 Image::fade (float f)
1237 {
1238         /* U/V black value for 8-bit colour */
1239         static int const eight_bit_uv =    (1 << 7) - 1;
1240         /* U/V black value for 10-bit colour */
1241         static uint16_t const ten_bit_uv = (1 << 9) - 1;
1242
1243         switch (_pixel_format) {
1244         case AV_PIX_FMT_YUV420P:
1245         {
1246                 /* Y */
1247                 uint8_t* p = data()[0];
1248                 int const lines = sample_size(0).height;
1249                 for (int y = 0; y < lines; ++y) {
1250                         uint8_t* q = p;
1251                         for (int x = 0; x < line_size()[0]; ++x) {
1252                                 *q = int(float(*q) * f);
1253                                 ++q;
1254                         }
1255                         p += stride()[0];
1256                 }
1257
1258                 /* U, V */
1259                 for (int c = 1; c < 3; ++c) {
1260                         uint8_t* p = data()[c];
1261                         int const lines = sample_size(c).height;
1262                         for (int y = 0; y < lines; ++y) {
1263                                 uint8_t* q = p;
1264                                 for (int x = 0; x < line_size()[c]; ++x) {
1265                                         *q = eight_bit_uv + int((int(*q) - eight_bit_uv) * f);
1266                                         ++q;
1267                                 }
1268                                 p += stride()[c];
1269                         }
1270                 }
1271
1272                 break;
1273         }
1274
1275         case AV_PIX_FMT_RGB24:
1276         {
1277                 /* 8-bit */
1278                 uint8_t* p = data()[0];
1279                 int const lines = sample_size(0).height;
1280                 for (int y = 0; y < lines; ++y) {
1281                         uint8_t* q = p;
1282                         for (int x = 0; x < line_size()[0]; ++x) {
1283                                 *q = int (float (*q) * f);
1284                                 ++q;
1285                         }
1286                         p += stride()[0];
1287                 }
1288                 break;
1289         }
1290
1291         case AV_PIX_FMT_XYZ12LE:
1292         case AV_PIX_FMT_RGB48LE:
1293                 /* 16-bit little-endian */
1294                 for (int c = 0; c < 3; ++c) {
1295                         int const stride_pixels = stride()[c] / 2;
1296                         int const line_size_pixels = line_size()[c] / 2;
1297                         uint16_t* p = reinterpret_cast<uint16_t*> (data()[c]);
1298                         int const lines = sample_size(c).height;
1299                         for (int y = 0; y < lines; ++y) {
1300                                 uint16_t* q = p;
1301                                 for (int x = 0; x < line_size_pixels; ++x) {
1302                                         *q = int (float (*q) * f);
1303                                         ++q;
1304                                 }
1305                                 p += stride_pixels;
1306                         }
1307                 }
1308                 break;
1309
1310         case AV_PIX_FMT_YUV422P10LE:
1311         {
1312                 /* Y */
1313                 {
1314                         int const stride_pixels = stride()[0] / 2;
1315                         int const line_size_pixels = line_size()[0] / 2;
1316                         uint16_t* p = reinterpret_cast<uint16_t*> (data()[0]);
1317                         int const lines = sample_size(0).height;
1318                         for (int y = 0; y < lines; ++y) {
1319                                 uint16_t* q = p;
1320                                 for (int x = 0; x < line_size_pixels; ++x) {
1321                                         *q = int(float(*q) * f);
1322                                         ++q;
1323                                 }
1324                                 p += stride_pixels;
1325                         }
1326                 }
1327
1328                 /* U, V */
1329                 for (int c = 1; c < 3; ++c) {
1330                         int const stride_pixels = stride()[c] / 2;
1331                         int const line_size_pixels = line_size()[c] / 2;
1332                         uint16_t* p = reinterpret_cast<uint16_t*> (data()[c]);
1333                         int const lines = sample_size(c).height;
1334                         for (int y = 0; y < lines; ++y) {
1335                                 uint16_t* q = p;
1336                                 for (int x = 0; x < line_size_pixels; ++x) {
1337                                         *q = ten_bit_uv + int((int(*q) - ten_bit_uv) * f);
1338                                         ++q;
1339                                 }
1340                                 p += stride_pixels;
1341                         }
1342                 }
1343                 break;
1344
1345         }
1346
1347         default:
1348                 throw PixelFormatError ("fade()", _pixel_format);
1349         }
1350 }
1351
1352
1353 shared_ptr<const Image>
1354 Image::ensure_alignment (shared_ptr<const Image> image, Image::Alignment alignment)
1355 {
1356         if (image->alignment() == alignment) {
1357                 return image;
1358         }
1359
1360         return make_shared<Image>(image, alignment);
1361 }
1362
1363
1364 size_t
1365 Image::memory_used () const
1366 {
1367         size_t m = 0;
1368         for (int i = 0; i < planes(); ++i) {
1369                 m += _stride[i] * sample_size(i).height;
1370         }
1371         return m;
1372 }
1373
1374
1375 void
1376 Image::video_range_to_full_range ()
1377 {
1378         switch (_pixel_format) {
1379         case AV_PIX_FMT_RGB24:
1380         {
1381                 float const factor = 256.0 / 219.0;
1382                 uint8_t* p = data()[0];
1383                 int const lines = sample_size(0).height;
1384                 for (int y = 0; y < lines; ++y) {
1385                         uint8_t* q = p;
1386                         for (int x = 0; x < line_size()[0]; ++x) {
1387                                 *q = clamp(lrintf((*q - 16) * factor), 0L, 255L);
1388                                 ++q;
1389                         }
1390                         p += stride()[0];
1391                 }
1392                 break;
1393         }
1394         case AV_PIX_FMT_RGB48LE:
1395         {
1396                 float const factor = 65536.0 / 56064.0;
1397                 uint16_t* p = reinterpret_cast<uint16_t*>(data()[0]);
1398                 int const lines = sample_size(0).height;
1399                 for (int y = 0; y < lines; ++y) {
1400                         uint16_t* q = p;
1401                         int const line_size_pixels = line_size()[0] / 2;
1402                         for (int x = 0; x < line_size_pixels; ++x) {
1403                                 *q = clamp(lrintf((*q - 4096) * factor), 0L, 65535L);
1404                                 ++q;
1405                         }
1406                         p += stride()[0] / 2;
1407                 }
1408                 break;
1409         }
1410         case AV_PIX_FMT_GBRP12LE:
1411         {
1412                 float const factor = 4096.0 / 3504.0;
1413                 for (int c = 0; c < 3; ++c) {
1414                         uint16_t* p = reinterpret_cast<uint16_t*>(data()[c]);
1415                         int const lines = sample_size(c).height;
1416                         for (int y = 0; y < lines; ++y) {
1417                                 uint16_t* q = p;
1418                                 int const line_size_pixels = line_size()[c] / 2;
1419                                 for (int x = 0; x < line_size_pixels; ++x) {
1420                                         *q = clamp(lrintf((*q - 256) * factor), 0L, 4095L);
1421                                         ++q;
1422                                 }
1423                         }
1424                 }
1425                 break;
1426         }
1427         default:
1428                 throw PixelFormatError ("video_range_to_full_range()", _pixel_format);
1429         }
1430 }
1431