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