2 Copyright (C) 2014-2015 Carl Hetherington <cth@carlh.net>
4 This file is part of DCP-o-matic.
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.
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.
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/>.
21 #include "j2k_image_proxy.h"
22 #include "dcpomatic_socket.h"
24 #include "dcpomatic_assert.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>
33 #include <libcxml/cxml.h>
34 DCPOMATIC_DISABLE_WARNINGS
35 #include <libxml++/libxml++.h>
36 DCPOMATIC_ENABLE_WARNINGS
46 using boost::shared_ptr;
47 using boost::optional;
48 using boost::dynamic_pointer_cast;
50 using dcp::raw_convert;
52 /** Construct a J2KImageProxy from a JPEG2000 file */
53 J2KImageProxy::J2KImageProxy (boost::filesystem::path path, dcp::Size size, AVPixelFormat pixel_format)
56 , _pixel_format (pixel_format)
59 /* ::image assumes 16bpp */
60 DCPOMATIC_ASSERT (_pixel_format == AV_PIX_FMT_RGB48 || _pixel_format == AV_PIX_FMT_XYZ12LE);
63 J2KImageProxy::J2KImageProxy (
64 shared_ptr<const dcp::MonoPictureFrame> frame,
66 AVPixelFormat pixel_format,
67 optional<int> forced_reduction
69 : _data (frame->j2k_size ())
71 , _pixel_format (pixel_format)
72 , _forced_reduction (forced_reduction)
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 ());
80 J2KImageProxy::J2KImageProxy (
81 shared_ptr<const dcp::StereoPictureFrame> frame,
84 AVPixelFormat pixel_format,
85 optional<int> forced_reduction
89 , _pixel_format (pixel_format)
90 , _forced_reduction (forced_reduction)
93 /* ::image assumes 16bpp */
94 DCPOMATIC_ASSERT (_pixel_format == AV_PIX_FMT_RGB48 || _pixel_format == AV_PIX_FMT_XYZ12LE);
97 _data = Data (frame->left_j2k_size ());
98 memcpy (_data.data().get(), frame->left_j2k_data(), _data.size ());
101 _data = Data (frame->right_j2k_size ());
102 memcpy (_data.data().get(), frame->right_j2k_data(), _data.size ());
107 J2KImageProxy::J2KImageProxy (shared_ptr<cxml::Node> xml, shared_ptr<Socket> socket)
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"));
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.
119 _pixel_format = AV_PIX_FMT_XYZ12LE;
120 socket->read (_data.data().get (), _data.size ());
124 J2KImageProxy::prepare (optional<dcp::Size> target_size) const
126 boost::mutex::scoped_lock lm (_mutex);
128 if (_image && target_size == _target_size) {
129 DCPOMATIC_ASSERT (_reduce);
135 if (_forced_reduction) {
136 reduce = *_forced_reduction;
138 while (target_size && (_size.width / pow(2, reduce)) > target_size->width && (_size.height / pow(2, reduce)) > target_size->height) {
143 reduce = max (0, reduce);
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));
150 int const shift = 16 - decompressed->precision (0);
152 /* Copy data in whatever format (sRGB or XYZ) into our Image; I'm assuming
153 the data is 12-bit either way.
156 int const width = decompressed->size().width;
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;
171 } catch (dcp::J2KDecompressionError& e) {
172 _image.reset (new Image (_pixel_format, _size, true));
173 _image->make_black ();
177 _target_size = target_size;
185 J2KImageProxy::image (optional<dcp::Size> target_size) const
187 int const r = prepare (target_size);
189 /* I think this is safe without a lock on mutex. _image is guaranteed to be
190 set up when prepare() has happened.
192 return Result (_image, r, _error);
197 J2KImageProxy::add_metadata (xmlpp::Node* node) const
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));
203 node->add_child("Eye")->add_child_text (raw_convert<string> (static_cast<int> (_eye.get ())));
205 node->add_child("Size")->add_child_text (raw_convert<string> (_data.size ()));
209 J2KImageProxy::write_to_socket (shared_ptr<Socket> socket) const
211 socket->write (_data.data().get(), _data.size());
215 J2KImageProxy::same (shared_ptr<const ImageProxy> other) const
217 shared_ptr<const J2KImageProxy> jp = dynamic_pointer_cast<const J2KImageProxy> (other);
222 if (_data.size() != jp->_data.size()) {
226 return memcmp (_data.data().get(), jp->_data.data().get(), _data.size()) == 0;
229 J2KImageProxy::J2KImageProxy (Data data, dcp::Size size, AVPixelFormat pixel_format)
232 , _pixel_format (pixel_format)
234 /* ::image assumes 16bpp */
235 DCPOMATIC_ASSERT (_pixel_format == AV_PIX_FMT_RGB48 || _pixel_format == AV_PIX_FMT_XYZ12LE);
239 J2KImageProxy::memory_used () const
241 size_t m = _data.size();
243 /* 3 components, 16-bits per pixel */
244 m += 3 * 2 * _image->size().width * _image->size().height;