X-Git-Url: https://main.carlh.net/gitweb/?p=dcpomatic.git;a=blobdiff_plain;f=src%2Flib%2Fj2k_image_proxy.cc;h=00d3cf2ef20b4edfb473dbcaa442e73bdff9a9b5;hp=59106098a8351a1634f3e2023816856b9137a681;hb=ac34066d5e448d1984d11a180be74e31b6e13b5c;hpb=bf6eadb7b8dc4073a940cdf9327323366b9e11e2 diff --git a/src/lib/j2k_image_proxy.cc b/src/lib/j2k_image_proxy.cc index 59106098a..00d3cf2ef 100644 --- a/src/lib/j2k_image_proxy.cc +++ b/src/lib/j2k_image_proxy.cc @@ -1,131 +1,246 @@ /* - Copyright (C) 2014-2015 Carl Hetherington + Copyright (C) 2014-2021 Carl Hetherington - This program is free software; you can redistribute it and/or modify + This file is part of DCP-o-matic. + + DCP-o-matic is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - This program is distributed in the hope that it will be useful, + DCP-o-matic is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with DCP-o-matic. If not, see . */ + #include "j2k_image_proxy.h" #include "dcpomatic_socket.h" #include "image.h" -#include "encoded_data.h" -#include "raw_convert.h" +#include "dcpomatic_assert.h" +#include "warnings.h" +#include +#include #include #include #include #include +#include #include +DCPOMATIC_DISABLE_WARNINGS +#include +DCPOMATIC_ENABLE_WARNINGS +#include #include "i18n.h" + +using std::cout; +using std::dynamic_pointer_cast; +using std::make_shared; +using std::max; +using std::shared_ptr; using std::string; -using boost::shared_ptr; using boost::optional; +using dcp::ArrayData; +using dcp::raw_convert; + /** Construct a J2KImageProxy from a JPEG2000 file */ -J2KImageProxy::J2KImageProxy (boost::filesystem::path path, dcp::Size size) - : _mono (new dcp::MonoPictureFrame (path)) +J2KImageProxy::J2KImageProxy (boost::filesystem::path path, dcp::Size size, AVPixelFormat pixel_format) + : _data (new dcp::ArrayData(path)) , _size (size) + , _pixel_format (pixel_format) + , _error (false) { - + /* ::image assumes 16bpp */ + DCPOMATIC_ASSERT (_pixel_format == AV_PIX_FMT_RGB48 || _pixel_format == AV_PIX_FMT_XYZ12LE); } -J2KImageProxy::J2KImageProxy (shared_ptr frame, dcp::Size size) - : _mono (frame) + +J2KImageProxy::J2KImageProxy ( + shared_ptr frame, + dcp::Size size, + AVPixelFormat pixel_format, + optional forced_reduction + ) + : _data (frame) , _size (size) + , _pixel_format (pixel_format) + , _forced_reduction (forced_reduction) + , _error (false) { - + /* ::image assumes 16bpp */ + DCPOMATIC_ASSERT (_pixel_format == AV_PIX_FMT_RGB48 || _pixel_format == AV_PIX_FMT_XYZ12LE); } -J2KImageProxy::J2KImageProxy (shared_ptr frame, dcp::Size size, dcp::Eye eye) - : _stereo (frame) + +J2KImageProxy::J2KImageProxy ( + shared_ptr frame, + dcp::Size size, + dcp::Eye eye, + AVPixelFormat pixel_format, + optional forced_reduction + ) + : _data (eye == dcp::Eye::LEFT ? frame->left() : frame->right()) , _size (size) , _eye (eye) + , _pixel_format (pixel_format) + , _forced_reduction (forced_reduction) + , _error (false) { - + /* ::image assumes 16bpp */ + DCPOMATIC_ASSERT (_pixel_format == AV_PIX_FMT_RGB48 || _pixel_format == AV_PIX_FMT_XYZ12LE); } + J2KImageProxy::J2KImageProxy (shared_ptr xml, shared_ptr socket) + : _error (false) { - _size = dcp::Size (xml->number_child ("Width"), xml->number_child ("Height")); - if (xml->optional_number_child ("Eye")) { - _eye = static_cast (xml->number_child ("Eye")); - int const left_size = xml->number_child ("LeftSize"); - int const right_size = xml->number_child ("RightSize"); - shared_ptr f (new dcp::StereoPictureFrame ()); - socket->read (f->left_j2k_data(), left_size); - socket->read (f->right_j2k_data(), right_size); - _stereo = f; - } else { - int const size = xml->number_child ("Size"); - shared_ptr f (new dcp::MonoPictureFrame ()); - socket->read (f->j2k_data (), size); - _mono = f; + _size = dcp::Size (xml->number_child("Width"), xml->number_child("Height")); + if (xml->optional_number_child("Eye")) { + _eye = static_cast(xml->number_child("Eye")); } + auto data = make_shared(xml->number_child("Size")); + /* This only matters when we are using J2KImageProxy for the preview, which + will never use this constructor (which is only used for passing data to + encode servers). So we can put anything in here. It's a bit of a hack. + */ + _pixel_format = AV_PIX_FMT_XYZ12LE; + socket->read (data->data(), data->size()); + _data = data; } -shared_ptr -J2KImageProxy::image (optional note) const + +int +J2KImageProxy::prepare (Image::Alignment alignment, optional target_size) const { - shared_ptr image (new Image (PIX_FMT_RGB48LE, _size, true)); + boost::mutex::scoped_lock lm (_mutex); - if (_mono) { - dcp::xyz_to_rgb (_mono->xyz_image (), dcp::ColourConversion::srgb_to_xyz(), image->data()[0], image->stride()[0], note); + if (_image && target_size == _target_size) { + DCPOMATIC_ASSERT (_reduce); + return *_reduce; + } + + int reduce = 0; + + if (_forced_reduction) { + reduce = *_forced_reduction; } else { - dcp::xyz_to_rgb (_stereo->xyz_image (_eye.get ()), dcp::ColourConversion::srgb_to_xyz(), image->data()[0], image->stride()[0], note); + while (target_size && (_size.width / pow(2, reduce)) > target_size->width && (_size.height / pow(2, reduce)) > target_size->height) { + ++reduce; + } + + --reduce; + reduce = max (0, reduce); } - return image; + try { + /* XXX: should check that potentially trashing _data here doesn't matter */ + auto decompressed = dcp::decompress_j2k (const_cast(_data->data()), _data->size(), reduce); + _image = make_shared(_pixel_format, decompressed->size(), alignment); + + int const shift = 16 - decompressed->precision (0); + + /* Copy data in whatever format (sRGB or XYZ) into our Image; I'm assuming + the data is 12-bit either way. + */ + + int const width = decompressed->size().width; + + int p = 0; + int* decomp_0 = decompressed->data (0); + int* decomp_1 = decompressed->data (1); + int* decomp_2 = decompressed->data (2); + for (int y = 0; y < decompressed->size().height; ++y) { + auto q = reinterpret_cast(_image->data()[0] + y * _image->stride()[0]); + for (int x = 0; x < width; ++x) { + *q++ = decomp_0[p] << shift; + *q++ = decomp_1[p] << shift; + *q++ = decomp_2[p] << shift; + ++p; + } + } + } catch (dcp::J2KDecompressionError& e) { + _image = make_shared(_pixel_format, _size, alignment); + _image->make_black (); + _error = true; + } + + _target_size = target_size; + _reduce = reduce; + + return reduce; +} + + +ImageProxy::Result +J2KImageProxy::image (Image::Alignment alignment, optional target_size) const +{ + int const r = prepare (alignment, target_size); + + /* I think this is safe without a lock on mutex. _image is guaranteed to be + set up when prepare() has happened. + */ + return Result (_image, r, _error); } + void J2KImageProxy::add_metadata (xmlpp::Node* node) const { - node->add_child("Type")->add_child_text (N_("J2K")); - node->add_child("Width")->add_child_text (raw_convert (_size.width)); - node->add_child("Height")->add_child_text (raw_convert (_size.height)); - if (_stereo) { - node->add_child("Eye")->add_child_text (raw_convert (_eye.get ())); - node->add_child("LeftSize")->add_child_text (raw_convert (_stereo->left_j2k_size ())); - node->add_child("RightSize")->add_child_text (raw_convert (_stereo->right_j2k_size ())); - } else { - node->add_child("Size")->add_child_text (raw_convert (_mono->j2k_size ())); + node->add_child("Type")->add_child_text(N_("J2K")); + node->add_child("Width")->add_child_text(raw_convert(_size.width)); + node->add_child("Height")->add_child_text(raw_convert(_size.height)); + if (_eye) { + node->add_child("Eye")->add_child_text(raw_convert(static_cast(_eye.get()))); } + node->add_child("Size")->add_child_text(raw_convert(_data->size())); } + void -J2KImageProxy::send_binary (shared_ptr socket) const +J2KImageProxy::write_to_socket (shared_ptr socket) const { - if (_mono) { - socket->write (_mono->j2k_data(), _mono->j2k_size ()); - } else { - socket->write (_stereo->left_j2k_data(), _stereo->left_j2k_size ()); - socket->write (_stereo->right_j2k_data(), _stereo->right_j2k_size ()); + socket->write (_data->data(), _data->size()); +} + + +bool +J2KImageProxy::same (shared_ptr other) const +{ + auto jp = dynamic_pointer_cast(other); + if (!jp) { + return false; } + + return *_data == *jp->_data; } -shared_ptr -J2KImageProxy::j2k () const + +J2KImageProxy::J2KImageProxy (ArrayData data, dcp::Size size, AVPixelFormat pixel_format) + : _data (new ArrayData(data)) + , _size (size) + , _pixel_format (pixel_format) + , _error (false) { - if (_mono) { - return shared_ptr (new EncodedData (_mono->j2k_data(), _mono->j2k_size())); - } else { - if (_eye.get() == dcp::EYE_LEFT) { - return shared_ptr (new EncodedData (_stereo->left_j2k_data(), _stereo->left_j2k_size())); - } else { - return shared_ptr (new EncodedData (_stereo->right_j2k_data(), _stereo->right_j2k_size())); - } + /* ::image assumes 16bpp */ + DCPOMATIC_ASSERT (_pixel_format == AV_PIX_FMT_RGB48 || _pixel_format == AV_PIX_FMT_XYZ12LE); +} + + +size_t +J2KImageProxy::memory_used () const +{ + size_t m = _data->size(); + if (_image) { + /* 3 components, 16-bits per pixel */ + m += 3 * 2 * _image->size().width * _image->size().height; } + return m; }