X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fj2k_image_proxy.cc;h=d4c7a8716d7a6dae7876d3b07030b0a0f8a79fde;hb=5ffa0a4eab3bf13d52476b7549546c9028b11f88;hp=f7e6dd5f4dd52f25ffc444f79de58e71376e4457;hpb=b395478cbb0706de2b6afa9a34fb33e49c61ee67;p=dcpomatic.git diff --git a/src/lib/j2k_image_proxy.cc b/src/lib/j2k_image_proxy.cc index f7e6dd5f4..d4c7a8716 100644 --- a/src/lib/j2k_image_proxy.cc +++ b/src/lib/j2k_image_proxy.cc @@ -21,6 +21,7 @@ #include "j2k_image_proxy.h" #include "dcpomatic_socket.h" #include "image.h" +#include "dcpomatic_assert.h" #include #include #include @@ -30,7 +31,6 @@ #include #include #include -#include #include #include "i18n.h" @@ -38,6 +38,8 @@ using std::string; using std::cout; using std::max; +using std::pair; +using std::make_pair; using boost::shared_ptr; using boost::optional; using boost::dynamic_pointer_cast; @@ -50,22 +52,40 @@ J2KImageProxy::J2KImageProxy (boost::filesystem::path path, dcp::Size size, AVPi , _size (size) , _pixel_format (pixel_format) { - + /* ::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, AVPixelFormat pixel_format) +J2KImageProxy::J2KImageProxy ( + shared_ptr frame, + dcp::Size size, + AVPixelFormat pixel_format, + optional forced_reduction + ) : _data (frame->j2k_size ()) , _size (size) , _pixel_format (pixel_format) + , _forced_reduction (forced_reduction) { + /* ::image assumes 16bpp */ + DCPOMATIC_ASSERT (_pixel_format == AV_PIX_FMT_RGB48 || _pixel_format == AV_PIX_FMT_XYZ12LE); memcpy (_data.data().get(), frame->j2k_data(), _data.size ()); } -J2KImageProxy::J2KImageProxy (shared_ptr frame, dcp::Size size, dcp::Eye eye, AVPixelFormat pixel_format) +J2KImageProxy::J2KImageProxy ( + shared_ptr frame, + dcp::Size size, + dcp::Eye eye, + AVPixelFormat pixel_format, + optional forced_reduction + ) : _size (size) , _eye (eye) , _pixel_format (pixel_format) + , _forced_reduction (forced_reduction) { + /* ::image assumes 16bpp */ + DCPOMATIC_ASSERT (_pixel_format == AV_PIX_FMT_RGB48 || _pixel_format == AV_PIX_FMT_XYZ12LE); switch (eye) { case dcp::EYE_LEFT: _data = Data (frame->left_j2k_size ()); @@ -93,55 +113,75 @@ J2KImageProxy::J2KImageProxy (shared_ptr xml, shared_ptr soc socket->read (_data.data().get (), _data.size ()); } -shared_ptr -J2KImageProxy::image (optional, optional target_size) const +int +J2KImageProxy::prepare (optional target_size) const { - if (!_decompressed || target_size != _target_size) { - int reduce = 0; + boost::mutex::scoped_lock lm (_mutex); + + if (_image && target_size == _target_size) { + DCPOMATIC_ASSERT (_reduce); + return *_reduce; + } + int reduce = 0; + + if (_forced_reduction) { + reduce = *_forced_reduction; + } else { 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); - _decompressed = dcp::decompress_j2k (const_cast (_data.data().get()), _data.size (), reduce); - - if (_decompressed->precision(0) < 12) { - int const shift = 12 - _decompressed->precision (0); - for (int c = 0; c < 3; ++c) { - int* p = _decompressed->data (c); - for (int y = 0; y < _decompressed->size().height; ++y) { - for (int x = 0; x < _decompressed->size().width; ++x) { - *p++ <<= shift; - } - } - } - } - - _target_size = target_size; } - shared_ptr image (new Image (_pixel_format, _decompressed->size(), true)); + shared_ptr decompressed = dcp::decompress_j2k (const_cast (_data.data().get()), _data.size (), reduce); + + /* When scaling JPEG2000 images (using AV_PIX_FMT_XYZ12LE) ffmpeg will call xyz12ToRgb48 which reads data + from the whole of the image stride. If we are cropping, Image::crop_scale_window munges the + start addresses of each image row (to do the crop) but keeps the stride the same. This means + that under crop we will read over the end of the image by the amount of the crop. To allow this + to happen without invalid memory access we need to overallocate by one whole stride's worth of pixels. + */ + _image.reset (new Image (_pixel_format, decompressed->size(), true, decompressed->size().width)); + + 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 const width = decompressed->size().width; int p = 0; - for (int y = 0; y < _decompressed->size().height; ++y) { - uint16_t* q = (uint16_t *) (image->data()[0] + y * image->stride()[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) { + uint16_t* q = (uint16_t *) (_image->data()[0] + y * _image->stride()[0]); for (int x = 0; x < width; ++x) { - for (int c = 0; c < 3; ++c) { - *q++ = _decompressed->data(c)[p] << 4; - } + *q++ = decomp_0[p] << shift; + *q++ = decomp_1[p] << shift; + *q++ = decomp_2[p] << shift; ++p; } } - return image; + _target_size = target_size; + _reduce = reduce; + + return reduce; +} + +pair, int> +J2KImageProxy::image (optional target_size) const +{ + int const r = prepare (target_size); + /* I think this is safe without a lock on mutex. _image is guaranteed to be + set up when prepare() has happened. + */ + return make_pair (_image, r); } void @@ -182,5 +222,17 @@ J2KImageProxy::J2KImageProxy (Data data, dcp::Size size, AVPixelFormat pixel_for , _size (size) , _pixel_format (pixel_format) { + /* ::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; }