src/j2k.cc

   1 /*
   2     Copyright (C) 2012-2015 Carl Hetherington <cth@carlh.net>
   3
   4     This file is part of libdcp.
   5
   6     libdcp 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     libdcp 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 libdcp.  If not, see <http://www.gnu.org/licenses/>.
  18
  19     In addition, as a special exception, the copyright holders give
  20     permission to link the code of portions of this program with the
  21     OpenSSL library under certain conditions as described in each
  22     individual source file, and distribute linked combinations
  23     including the two.
  24
  25     You must obey the GNU General Public License in all respects
  26     for all of the code used other than OpenSSL.  If you modify
  27     file(s) with this exception, you may extend this exception to your
  28     version of the file(s), but you are not obligated to do so.  If you
  29     do not wish to do so, delete this exception statement from your
  30     version.  If you delete this exception statement from all source
  31     files in the program, then also delete it here.
  32 */
  33
  34
  35 #include "array_data.h"
  36 #include "j2k.h"
  37 #include "exceptions.h"
  38 #include "openjpeg_image.h"
  39 #include "dcp_assert.h"
  40 #include "compose.hpp"
  41 #include <openjpeg.h>
  42 #include <cmath>
  43 #include <iostream>
  44
  45 using std::min;
  46 using std::pow;
  47 using std::string;
  48 using std::shared_ptr;
  49 using boost::shared_array;
  50 using namespace dcp;
  51
  52 shared_ptr<dcp::OpenJPEGImage>
  53 dcp::decompress_j2k (ArrayData data, int reduce)
  54 {
  55         return dcp::decompress_j2k (data.data(), data.size(), reduce);
  56 }
  57
  58 #ifdef LIBDCP_OPENJPEG2
  59
  60 class ReadBuffer
  61 {
  62 public:
  63         ReadBuffer (uint8_t* data, int64_t size)
  64                 : _data (data)
  65                 , _size (size)
  66                 , _offset (0)
  67         {}
  68
  69         OPJ_SIZE_T read (void* buffer, OPJ_SIZE_T nb_bytes)
  70         {
  71                 int64_t N = min (nb_bytes, _size - _offset);
  72                 memcpy (buffer, _data + _offset, N);
  73                 _offset += N;
  74                 return N;
  75         }
  76
  77 private:
  78         uint8_t* _data;
  79         OPJ_SIZE_T _size;
  80         OPJ_SIZE_T _offset;
  81 };
  82
  83 static OPJ_SIZE_T
  84 read_function (void* buffer, OPJ_SIZE_T nb_bytes, void* data)
  85 {
  86         return reinterpret_cast<ReadBuffer*>(data)->read (buffer, nb_bytes);
  87 }
  88
  89 static void
  90 read_free_function (void* data)
  91 {
  92         delete reinterpret_cast<ReadBuffer*>(data);
  93 }
  94
  95
  96 static void
  97 decompress_error_callback (char const * msg, void *)
  98 {
  99         throw J2KDecompressionError (msg);
 100 }
 101
 102
 103 static void
 104 compress_error_callback (char const * msg, void *)
 105 {
 106         throw MiscError (msg);
 107 }
 108
 109 /** Decompress a JPEG2000 image to a bitmap.
 110  *  @param data JPEG2000 data.
 111  *  @param size Size of data in bytes.
 112  *  @param reduce A power of 2 by which to reduce the size of the decoded image;
 113  *  e.g. 0 reduces by (2^0 == 1), ie keeping the same size.
 114  *       1 reduces by (2^1 == 2), ie halving the size of the image.
 115  *  This is useful for scaling 4K DCP images down to 2K.
 116  *  @return OpenJPEGImage.
 117  */
 118 shared_ptr<dcp::OpenJPEGImage>
 119 dcp::decompress_j2k (uint8_t* data, int64_t size, int reduce)
 120 {
 121         DCP_ASSERT (reduce >= 0);
 122
 123         uint8_t const jp2_magic[] = {
 124                 0x00,
 125                 0x00,
 126                 0x00,
 127                 0x0c,
 128                 'j',
 129                 'P',
 130                 0x20,
 131                 0x20
 132         };
 133
 134         OPJ_CODEC_FORMAT format = OPJ_CODEC_J2K;
 135         if (size >= int (sizeof (jp2_magic)) && memcmp (data, jp2_magic, sizeof (jp2_magic)) == 0) {
 136                 format = OPJ_CODEC_JP2;
 137         }
 138
 139         opj_codec_t* decoder = opj_create_decompress (format);
 140         if (!decoder) {
 141                 boost::throw_exception (ReadError ("could not create JPEG2000 decompresser"));
 142         }
 143         opj_dparameters_t parameters;
 144         opj_set_default_decoder_parameters (&parameters);
 145         parameters.cp_reduce = reduce;
 146         opj_setup_decoder (decoder, &parameters);
 147
 148         opj_stream_t* stream = opj_stream_default_create (OPJ_TRUE);
 149         if (!stream) {
 150                 throw MiscError ("could not create JPEG2000 stream");
 151         }
 152
 153         opj_set_error_handler(decoder, decompress_error_callback, 00);
 154
 155         opj_stream_set_read_function (stream, read_function);
 156         ReadBuffer* buffer = new ReadBuffer (data, size);
 157         opj_stream_set_user_data (stream, buffer, read_free_function);
 158         opj_stream_set_user_data_length (stream, size);
 159
 160         opj_image_t* image = 0;
 161         opj_read_header (stream, decoder, &image);
 162         if (opj_decode (decoder, stream, image) == OPJ_FALSE) {
 163                 opj_destroy_codec (decoder);
 164                 opj_stream_destroy (stream);
 165                 if (format == OPJ_CODEC_J2K) {
 166                         boost::throw_exception (ReadError (String::compose ("could not decode JPEG2000 codestream of %1 bytes.", size)));
 167                 } else {
 168                         boost::throw_exception (ReadError (String::compose ("could not decode JP2 file of %1 bytes.", size)));
 169                 }
 170         }
 171
 172         opj_destroy_codec (decoder);
 173         opj_stream_destroy (stream);
 174
 175         image->x1 = rint (float(image->x1) / pow (2.0f, reduce));
 176         image->y1 = rint (float(image->y1) / pow (2.0f, reduce));
 177         return shared_ptr<OpenJPEGImage> (new OpenJPEGImage (image));
 178 }
 179 #endif
 180
 181 #ifdef LIBDCP_OPENJPEG1
 182 /** Decompress a JPEG2000 image to a bitmap.
 183  *  @param data JPEG2000 data.
 184  *  @param size Size of data in bytes.
 185  *  @param reduce A power of 2 by which to reduce the size of the decoded image;
 186  *  e.g. 0 reduces by (2^0 == 1), ie keeping the same size.
 187  *       1 reduces by (2^1 == 2), ie halving the size of the image.
 188  *  This is useful for scaling 4K DCP images down to 2K.
 189  *  @return XYZ image.
 190  */
 191 shared_ptr<dcp::OpenJPEGImage>
 192 dcp::decompress_j2k (uint8_t* data, int64_t size, int reduce)
 193 {
 194         opj_dinfo_t* decoder = opj_create_decompress (CODEC_J2K);
 195         opj_dparameters_t parameters;
 196         opj_set_default_decoder_parameters (&parameters);
 197         parameters.cp_reduce = reduce;
 198         opj_setup_decoder (decoder, &parameters);
 199         opj_cio_t* cio = opj_cio_open ((opj_common_ptr) decoder, data, size);
 200         opj_image_t* image = opj_decode (decoder, cio);
 201         if (!image) {
 202                 opj_destroy_decompress (decoder);
 203                 opj_cio_close (cio);
 204                 boost::throw_exception (ReadError (String::compose ("could not decode JPEG2000 codestream of %1 bytes.", size)));
 205         }
 206
 207         opj_destroy_decompress (decoder);
 208         opj_cio_close (cio);
 209
 210         image->x1 = rint (float(image->x1) / pow (2, reduce));
 211         image->y1 = rint (float(image->y1) / pow (2, reduce));
 212         return shared_ptr<OpenJPEGImage> (new OpenJPEGImage (image));
 213 }
 214 #endif
 215
 216 #ifdef LIBDCP_OPENJPEG2
 217 class WriteBuffer
 218 {
 219 public:
 220 /* XXX: is there a better strategy for this? */
 221 #define MAX_J2K_SIZE (1024 * 1024 * 2)
 222         WriteBuffer ()
 223                 : _data (shared_array<uint8_t> (new uint8_t[MAX_J2K_SIZE]), MAX_J2K_SIZE)
 224                 , _offset (0)
 225         {
 226                 _data.set_size (0);
 227         }
 228
 229         OPJ_SIZE_T write (void* buffer, OPJ_SIZE_T nb_bytes)
 230         {
 231                 DCP_ASSERT ((_offset + nb_bytes) < MAX_J2K_SIZE);
 232                 memcpy (_data.data() + _offset, buffer, nb_bytes);
 233                 _offset += nb_bytes;
 234                 if (_offset > OPJ_SIZE_T (_data.size())) {
 235                         _data.set_size (_offset);
 236                 }
 237                 return nb_bytes;
 238         }
 239
 240         OPJ_BOOL seek (OPJ_SIZE_T nb_bytes)
 241         {
 242                 _offset = nb_bytes;
 243                 return OPJ_TRUE;
 244         }
 245
 246         ArrayData data () const
 247         {
 248                 return _data;
 249         }
 250
 251 private:
 252         ArrayData _data;
 253         OPJ_SIZE_T _offset;
 254 };
 255
 256 static OPJ_SIZE_T
 257 write_function (void* buffer, OPJ_SIZE_T nb_bytes, void* data)
 258 {
 259         return reinterpret_cast<WriteBuffer*>(data)->write (buffer, nb_bytes);
 260 }
 261
 262 static void
 263 write_free_function (void* data)
 264 {
 265         delete reinterpret_cast<WriteBuffer*>(data);
 266 }
 267
 268 static OPJ_BOOL
 269 seek_function (OPJ_OFF_T nb_bytes, void* data)
 270 {
 271         return reinterpret_cast<WriteBuffer*>(data)->seek (nb_bytes);
 272 }
 273
 274 /** @xyz Picture to compress.  Parts of xyz's data WILL BE OVERWRITTEN by libopenjpeg so xyz cannot be re-used
 275  *  after this call; see opj_j2k_encode where if l_reuse_data is false it will set l_tilec->data = l_img_comp->data.
 276  */
 277 ArrayData
 278 dcp::compress_j2k (shared_ptr<const OpenJPEGImage> xyz, int bandwidth, int frames_per_second, bool threed, bool fourk, string comment)
 279 {
 280         /* get a J2K compressor handle */
 281         opj_codec_t* encoder = opj_create_compress (OPJ_CODEC_J2K);
 282         if (encoder == 0) {
 283                 throw MiscError ("could not create JPEG2000 encoder");
 284         }
 285
 286         if (comment.empty()) {
 287                 /* asdcplib complains with "Illegal data size" when reading frames encoded with an empty comment */
 288                 throw MiscError("compress_j2k comment can not be an empty string");
 289         }
 290
 291         opj_set_error_handler (encoder, compress_error_callback, 0);
 292
 293         /* Set encoding parameters to default values */
 294         opj_cparameters_t parameters;
 295         opj_set_default_encoder_parameters (&parameters);
 296         if (fourk) {
 297                 parameters.numresolution = 7;
 298         }
 299         parameters.rsiz = fourk ? OPJ_PROFILE_CINEMA_4K : OPJ_PROFILE_CINEMA_2K;
 300         parameters.cp_comment = strdup (comment.c_str());
 301
 302         /* set max image */
 303         parameters.max_cs_size = (bandwidth / 8) / frames_per_second;
 304         if (threed) {
 305                 /* In 3D we have only half the normal bandwidth per eye */
 306                 parameters.max_cs_size /= 2;
 307         }
 308         parameters.max_comp_size = parameters.max_cs_size / 1.25;
 309         parameters.tcp_numlayers = 1;
 310         parameters.tcp_mct = 1;
 311
 312         /* Setup the encoder parameters using the current image and user parameters */
 313         opj_setup_encoder (encoder, &parameters, xyz->opj_image());
 314
 315         opj_stream_t* stream = opj_stream_default_create (OPJ_FALSE);
 316         if (!stream) {
 317                 opj_destroy_codec (encoder);
 318                 free (parameters.cp_comment);
 319                 throw MiscError ("could not create JPEG2000 stream");
 320         }
 321
 322         opj_stream_set_write_function (stream, write_function);
 323         opj_stream_set_seek_function (stream, seek_function);
 324         WriteBuffer* buffer = new WriteBuffer ();
 325         opj_stream_set_user_data (stream, buffer, write_free_function);
 326
 327         if (!opj_start_compress (encoder, xyz->opj_image(), stream)) {
 328                 opj_stream_destroy (stream);
 329                 opj_destroy_codec (encoder);
 330                 free (parameters.cp_comment);
 331                 if ((errno & 0x61500) == 0x61500) {
 332                         /* We've had one of the magic error codes from our patched openjpeg */
 333                         boost::throw_exception (StartCompressionError (errno & 0xff));
 334                 } else {
 335                         boost::throw_exception (StartCompressionError ());
 336                 }
 337         }
 338
 339         if (!opj_encode (encoder, stream)) {
 340                 opj_stream_destroy (stream);
 341                 opj_destroy_codec (encoder);
 342                 free (parameters.cp_comment);
 343                 throw MiscError ("JPEG2000 encoding failed");
 344         }
 345
 346         if (!opj_end_compress (encoder, stream)) {
 347                 opj_stream_destroy (stream);
 348                 opj_destroy_codec (encoder);
 349                 free (parameters.cp_comment);
 350                 throw MiscError ("could not end JPEG2000 encoding");
 351         }
 352
 353         ArrayData enc (buffer->data ());
 354
 355         opj_stream_destroy (stream);
 356         opj_destroy_codec (encoder);
 357         free (parameters.cp_comment);
 358
 359         return enc;
 360 }
 361 #endif
 362
 363 #ifdef LIBDCP_OPENJPEG1
 364 ArrayData
 365 dcp::compress_j2k (shared_ptr<const OpenJPEGImage> xyz, int bandwidth, int frames_per_second, bool threed, bool fourk)
 366 {
 367         /* Set the max image and component sizes based on frame_rate */
 368         int max_cs_len = ((float) bandwidth) / 8 / frames_per_second;
 369         if (threed) {
 370                 /* In 3D we have only half the normal bandwidth per eye */
 371                 max_cs_len /= 2;
 372         }
 373         int const max_comp_size = max_cs_len / 1.25;
 374
 375         /* get a J2K compressor handle */
 376         opj_cinfo_t* cinfo = opj_create_compress (CODEC_J2K);
 377         if (cinfo == 0) {
 378                 throw MiscError ("could not create JPEG2000 encoder");
 379         }
 380
 381         /* Set encoding parameters to default values */
 382         opj_cparameters_t parameters;
 383         opj_set_default_encoder_parameters (&parameters);
 384         if (fourk) {
 385                 parameters.numresolution = 7;
 386         }
 387
 388         /* Set default cinema parameters */
 389         parameters.tile_size_on = false;
 390         parameters.cp_tdx = 1;
 391         parameters.cp_tdy = 1;
 392
 393         /* Tile part */
 394         parameters.tp_flag = 'C';
 395         parameters.tp_on = 1;
 396
 397         /* Tile and Image shall be at (0,0) */
 398         parameters.cp_tx0 = 0;
 399         parameters.cp_ty0 = 0;
 400         parameters.image_offset_x0 = 0;
 401         parameters.image_offset_y0 = 0;
 402
 403         /* Codeblock size = 32x32 */
 404         parameters.cblockw_init = 32;
 405         parameters.cblockh_init = 32;
 406         parameters.csty |= 0x01;
 407
 408         /* The progression order shall be CPRL */
 409         parameters.prog_order = CPRL;
 410
 411         /* No ROI */
 412         parameters.roi_compno = -1;
 413
 414         parameters.subsampling_dx = 1;
 415         parameters.subsampling_dy = 1;
 416
 417         /* 9-7 transform */
 418         parameters.irreversible = 1;
 419
 420         parameters.tcp_rates[0] = 0;
 421         parameters.tcp_numlayers++;
 422         parameters.cp_disto_alloc = 1;
 423         parameters.cp_rsiz = fourk ? CINEMA4K : CINEMA2K;
 424         if (fourk) {
 425                 parameters.numpocs = 2;
 426                 parameters.POC[0].tile = 1;
 427                 parameters.POC[0].resno0 = 0;
 428                 parameters.POC[0].compno0 = 0;
 429                 parameters.POC[0].layno1 = 1;
 430                 parameters.POC[0].resno1 = parameters.numresolution - 1;
 431                 parameters.POC[0].compno1 = 3;
 432                 parameters.POC[0].prg1 = CPRL;
 433                 parameters.POC[1].tile = 1;
 434                 parameters.POC[1].resno0 = parameters.numresolution - 1;
 435                 parameters.POC[1].compno0 = 0;
 436                 parameters.POC[1].layno1 = 1;
 437                 parameters.POC[1].resno1 = parameters.numresolution;
 438                 parameters.POC[1].compno1 = 3;
 439                 parameters.POC[1].prg1 = CPRL;
 440         }
 441
 442         parameters.cp_comment = strdup ("libdcp");
 443         parameters.cp_cinema = fourk ? CINEMA4K_24 : CINEMA2K_24;
 444
 445         /* 3 components, so use MCT */
 446         parameters.tcp_mct = 1;
 447
 448         /* set max image */
 449         parameters.max_comp_size = max_comp_size;
 450         parameters.tcp_rates[0] = ((float) (3 * xyz->size().width * xyz->size().height * 12)) / (max_cs_len * 8);
 451
 452         /* Set event manager to null (openjpeg 1.3 bug) */
 453         cinfo->event_mgr = 0;
 454
 455         /* Setup the encoder parameters using the current image and user parameters */
 456         opj_setup_encoder (cinfo, &parameters, xyz->opj_image ());
 457
 458         opj_cio_t* cio = opj_cio_open ((opj_common_ptr) cinfo, 0, 0);
 459         if (cio == 0) {
 460                 opj_destroy_compress (cinfo);
 461                 throw MiscError ("could not open JPEG2000 stream");
 462         }
 463
 464         int const r = opj_encode (cinfo, cio, xyz->opj_image(), 0);
 465         if (r == 0) {
 466                 opj_cio_close (cio);
 467                 opj_destroy_compress (cinfo);
 468                 throw MiscError ("JPEG2000 encoding failed");
 469         }
 470
 471         ArrayData enc (cio->buffer, cio_tell (cio));
 472
 473         opj_cio_close (cio);
 474         free (parameters.cp_comment);
 475         opj_destroy_compress (cinfo);
 476
 477         return enc;
 478 }
 479
 480 #endif