src/lib/j2k_image_proxy.cc

   1 /*
   2     Copyright (C) 2014-2015 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 #include "j2k_image_proxy.h"
  22 #include "dcpomatic_socket.h"
  23 #include "image.h"
  24 #include "dcpomatic_assert.h"
  25 #include "warnings.h"
  26 #include <dcp/raw_convert.h>
  27 #include <dcp/openjpeg_image.h>
  28 #include <dcp/mono_picture_frame.h>
  29 #include <dcp/stereo_picture_frame.h>
  30 #include <dcp/colour_conversion.h>
  31 #include <dcp/rgb_xyz.h>
  32 #include <dcp/j2k.h>
  33 #include <libcxml/cxml.h>
  34 DCPOMATIC_DISABLE_WARNINGS
  35 #include <libxml++/libxml++.h>
  36 DCPOMATIC_ENABLE_WARNINGS
  37 #include <iostream>
  38
  39 #include "i18n.h"
  40
  41 using std::string;
  42 using std::cout;
  43 using std::max;
  44 using std::pair;
  45 using std::make_pair;
  46 using boost::shared_ptr;
  47 using boost::optional;
  48 using boost::dynamic_pointer_cast;
  49 using dcp::Data;
  50 using dcp::raw_convert;
  51
  52 /** Construct a J2KImageProxy from a JPEG2000 file */
  53 J2KImageProxy::J2KImageProxy (boost::filesystem::path path, dcp::Size size, AVPixelFormat pixel_format)
  54         : _data (path)
  55         , _size (size)
  56         , _pixel_format (pixel_format)
  57         , _error (false)
  58 {
  59         /* ::image assumes 16bpp */
  60         DCPOMATIC_ASSERT (_pixel_format == AV_PIX_FMT_RGB48 || _pixel_format == AV_PIX_FMT_XYZ12LE);
  61 }
  62
  63 J2KImageProxy::J2KImageProxy (
  64         shared_ptr<const dcp::MonoPictureFrame> frame,
  65         dcp::Size size,
  66         AVPixelFormat pixel_format,
  67         optional<int> forced_reduction
  68         )
  69         : _data (frame->j2k_size ())
  70         , _size (size)
  71         , _pixel_format (pixel_format)
  72         , _forced_reduction (forced_reduction)
  73         , _error (false)
  74 {
  75         /* ::image assumes 16bpp */
  76         DCPOMATIC_ASSERT (_pixel_format == AV_PIX_FMT_RGB48 || _pixel_format == AV_PIX_FMT_XYZ12LE);
  77         memcpy (_data.data().get(), frame->j2k_data(), _data.size ());
  78 }
  79
  80 J2KImageProxy::J2KImageProxy (
  81         shared_ptr<const dcp::StereoPictureFrame> frame,
  82         dcp::Size size,
  83         dcp::Eye eye,
  84         AVPixelFormat pixel_format,
  85         optional<int> forced_reduction
  86         )
  87         : _size (size)
  88         , _eye (eye)
  89         , _pixel_format (pixel_format)
  90         , _forced_reduction (forced_reduction)
  91         , _error (false)
  92 {
  93         /* ::image assumes 16bpp */
  94         DCPOMATIC_ASSERT (_pixel_format == AV_PIX_FMT_RGB48 || _pixel_format == AV_PIX_FMT_XYZ12LE);
  95         switch (eye) {
  96         case dcp::EYE_LEFT:
  97                 _data = Data (frame->left_j2k_size ());
  98                 memcpy (_data.data().get(), frame->left_j2k_data(), _data.size ());
  99                 break;
 100         case dcp::EYE_RIGHT:
 101                 _data = Data (frame->right_j2k_size ());
 102                 memcpy (_data.data().get(), frame->right_j2k_data(), _data.size ());
 103                 break;
 104         }
 105 }
 106
 107 J2KImageProxy::J2KImageProxy (shared_ptr<cxml::Node> xml, shared_ptr<Socket> socket)
 108         : _error (false)
 109 {
 110         _size = dcp::Size (xml->number_child<int> ("Width"), xml->number_child<int> ("Height"));
 111         if (xml->optional_number_child<int> ("Eye")) {
 112                 _eye = static_cast<dcp::Eye> (xml->number_child<int> ("Eye"));
 113         }
 114         _data = Data (xml->number_child<int> ("Size"));
 115         /* This only matters when we are using J2KImageProxy for the preview, which
 116            will never use this constructor (which is only used for passing data to
 117            encode servers).  So we can put anything in here.  It's a bit of a hack.
 118         */
 119         _pixel_format = AV_PIX_FMT_XYZ12LE;
 120         socket->read (_data.data().get (), _data.size ());
 121 }
 122
 123 int
 124 J2KImageProxy::prepare (optional<dcp::Size> target_size) const
 125 {
 126         boost::mutex::scoped_lock lm (_mutex);
 127
 128         if (_image && target_size == _target_size) {
 129                 DCPOMATIC_ASSERT (_reduce);
 130                 return *_reduce;
 131         }
 132
 133         int reduce = 0;
 134
 135         if (_forced_reduction) {
 136                 reduce = *_forced_reduction;
 137         } else {
 138                 while (target_size && (_size.width / pow(2, reduce)) > target_size->width && (_size.height / pow(2, reduce)) > target_size->height) {
 139                         ++reduce;
 140                 }
 141
 142                 --reduce;
 143                 reduce = max (0, reduce);
 144         }
 145
 146         try {
 147                 shared_ptr<dcp::OpenJPEGImage> decompressed = dcp::decompress_j2k (const_cast<uint8_t*> (_data.data().get()), _data.size (), reduce);
 148                 _image.reset (new Image (_pixel_format, decompressed->size(), true));
 149
 150                 int const shift = 16 - decompressed->precision (0);
 151
 152                 /* Copy data in whatever format (sRGB or XYZ) into our Image; I'm assuming
 153                    the data is 12-bit either way.
 154                    */
 155
 156                 int const width = decompressed->size().width;
 157
 158                 int p = 0;
 159                 int* decomp_0 = decompressed->data (0);
 160                 int* decomp_1 = decompressed->data (1);
 161                 int* decomp_2 = decompressed->data (2);
 162                 for (int y = 0; y < decompressed->size().height; ++y) {
 163                         uint16_t* q = (uint16_t *) (_image->data()[0] + y * _image->stride()[0]);
 164                         for (int x = 0; x < width; ++x) {
 165                                 *q++ = decomp_0[p] << shift;
 166                                 *q++ = decomp_1[p] << shift;
 167                                 *q++ = decomp_2[p] << shift;
 168                                 ++p;
 169                         }
 170                 }
 171         } catch (dcp::J2KDecompressionError& e) {
 172                 _image.reset (new Image (_pixel_format, _size, true));
 173                 _image->make_black ();
 174                 _error = true;
 175         }
 176
 177         _target_size = target_size;
 178         _reduce = reduce;
 179
 180         return reduce;
 181 }
 182
 183
 184 ImageProxy::Result
 185 J2KImageProxy::image (optional<dcp::Size> target_size) const
 186 {
 187         int const r = prepare (target_size);
 188
 189         /* I think this is safe without a lock on mutex.  _image is guaranteed to be
 190            set up when prepare() has happened.
 191         */
 192         return Result (_image, r, _error);
 193 }
 194
 195
 196 void
 197 J2KImageProxy::add_metadata (xmlpp::Node* node) const
 198 {
 199         node->add_child("Type")->add_child_text (N_("J2K"));
 200         node->add_child("Width")->add_child_text (raw_convert<string> (_size.width));
 201         node->add_child("Height")->add_child_text (raw_convert<string> (_size.height));
 202         if (_eye) {
 203                 node->add_child("Eye")->add_child_text (raw_convert<string> (static_cast<int> (_eye.get ())));
 204         }
 205         node->add_child("Size")->add_child_text (raw_convert<string> (_data.size ()));
 206 }
 207
 208 void
 209 J2KImageProxy::write_to_socket (shared_ptr<Socket> socket) const
 210 {
 211         socket->write (_data.data().get(), _data.size());
 212 }
 213
 214 bool
 215 J2KImageProxy::same (shared_ptr<const ImageProxy> other) const
 216 {
 217         shared_ptr<const J2KImageProxy> jp = dynamic_pointer_cast<const J2KImageProxy> (other);
 218         if (!jp) {
 219                 return false;
 220         }
 221
 222         if (_data.size() != jp->_data.size()) {
 223                 return false;
 224         }
 225
 226         return memcmp (_data.data().get(), jp->_data.data().get(), _data.size()) == 0;
 227 }
 228
 229 J2KImageProxy::J2KImageProxy (Data data, dcp::Size size, AVPixelFormat pixel_format)
 230         : _data (data)
 231         , _size (size)
 232         , _pixel_format (pixel_format)
 233 {
 234         /* ::image assumes 16bpp */
 235         DCPOMATIC_ASSERT (_pixel_format == AV_PIX_FMT_RGB48 || _pixel_format == AV_PIX_FMT_XYZ12LE);
 236 }
 237
 238 size_t
 239 J2KImageProxy::memory_used () const
 240 {
 241         size_t m = _data.size();
 242         if (_image) {
 243                 /* 3 components, 16-bits per pixel */
 244                 m += 3 * 2 * _image->size().width * _image->size().height;
 245         }
 246         return m;
 247 }