src/lib/image.cc

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