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