src/lib/image.cc

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