src/lib/image.cc

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