encoder = JPEG2000Encoder::all().front ();
}
- shared_ptr<EncodedData> enc = encoder->encode (
+ Data enc = encoder->encode (
xyz, _j2k_bandwidth, _frames_per_second, _resolution, _frame->eyes() == EYES_LEFT || _frame->eyes() == EYES_RIGHT
);
try {
_encoders.push_back (shared_ptr<JPEG2000Encoder> (new OpenJPEGEncoder ()));
} catch (JPEG2000EncoderUnavailableException &) {
-
+
}
}
return shared_ptr<JPEG2000Encoder> ();
}
-shared_ptr<EncodedData>
-JPEG2000Encoder::encode (shared_ptr<const dcp::XYZImage> input, int bandwidth, int frame_rate, Resolution resolution, bool threed)
+Data
+JPEG2000Encoder::encode (shared_ptr<const dcp::OpenJPEGImage> input, int bandwidth, int frame_rate, Resolution resolution, bool threed)
{
std::cout << "Encoding with " << name() << "\n";
-
+
if (!_bandwidth || _bandwidth.get() != bandwidth ||
!_frame_rate || _frame_rate.get() != frame_rate ||
!_resolution || _resolution.get() != resolution ||
_frame_rate = frame_rate;
_resolution = resolution;
_threed = threed;
-
+
parameters_changed ();
}
#define DCPOMATIC_JPEG2000_ENCODER_H
#include "types.h"
+#include "data.h"
#include <dcp/types.h>
#include <boost/shared_ptr.hpp>
#include <boost/optional.hpp>
#include <list>
namespace dcp {
- class XYZImage;
+ class OpenJPEGImage;
}
-class EncodedData;
-
class JPEG2000Encoder
{
public:
virtual ~JPEG2000Encoder () {}
-
+
/** @return Internationalised descriptive name for this encoder */
virtual std::string name () const = 0;
/** @return Non-internationalised ID for this encoder */
/** @param input XYZ input frame.
* @param note_handler Handler for notes about the encode.
-
+
* @return Encoded JPEG2000 data.
*/
- boost::shared_ptr<EncodedData> encode (
- boost::shared_ptr<const dcp::XYZImage> input,
+ Data encode (
+ boost::shared_ptr<const dcp::OpenJPEGImage> input,
int bandwidth,
int frame_rate,
Resolution resolution,
protected:
- virtual boost::shared_ptr<EncodedData> do_encode (
- boost::shared_ptr<const dcp::XYZImage> input
+ virtual Data do_encode (
+ boost::shared_ptr<const dcp::OpenJPEGImage> input
) = 0;
virtual void parameters_changed () {}
*/
#include "openjpeg_encoder.h"
-#include "encoded_data.h"
+#include "data.h"
#include "exceptions.h"
-#include <dcp/xyz_image.h>
+#include <dcp/openjpeg_image.h>
#include "i18n.h"
return _("OpenJPEG library");
}
-shared_ptr<EncodedData>
-OpenJPEGEncoder::do_encode (shared_ptr<const dcp::XYZImage> input)
+Data
+OpenJPEGEncoder::do_encode (shared_ptr<const dcp::OpenJPEGImage> input)
{
/* Set the max image and component sizes based on frame_rate */
int max_cs_len = ((float) _bandwidth.get()) / 8 / _frame_rate.get();
parameters.tile_size_on = false;
parameters.cp_tdx = 1;
parameters.cp_tdy = 1;
-
+
/* Tile part */
parameters.tp_flag = 'C';
parameters.tp_on = 1;
-
+
/* Tile and Image shall be at (0,0) */
parameters.cp_tx0 = 0;
parameters.cp_ty0 = 0;
parameters.cblockw_init = 32;
parameters.cblockh_init = 32;
parameters.csty |= 0x01;
-
+
/* The progression order shall be CPRL */
parameters.prog_order = CPRL;
-
+
/* No ROI */
parameters.roi_compno = -1;
-
+
parameters.subsampling_dx = 1;
parameters.subsampling_dy = 1;
-
+
/* 9-7 transform */
parameters.irreversible = 1;
-
+
parameters.tcp_rates[0] = 0;
parameters.tcp_numlayers++;
parameters.cp_disto_alloc = 1;
if (_resolution.get() == RESOLUTION_4K) {
parameters.numpocs = 2;
parameters.POC[0].tile = 1;
- parameters.POC[0].resno0 = 0;
+ parameters.POC[0].resno0 = 0;
parameters.POC[0].compno0 = 0;
parameters.POC[0].layno1 = 1;
parameters.POC[0].resno1 = parameters.numresolution - 1;
parameters.POC[0].compno1 = 3;
parameters.POC[0].prg1 = CPRL;
parameters.POC[1].tile = 1;
- parameters.POC[1].resno0 = parameters.numresolution - 1;
+ parameters.POC[1].resno0 = parameters.numresolution - 1;
parameters.POC[1].compno0 = 0;
parameters.POC[1].layno1 = 1;
parameters.POC[1].resno1 = parameters.numresolution;
parameters.POC[1].compno1 = 3;
parameters.POC[1].prg1 = CPRL;
}
-
+
parameters.cp_comment = strdup (N_("DCP-o-matic"));
parameters.cp_cinema = _resolution.get() == RESOLUTION_2K ? CINEMA2K_24 : CINEMA4K_24;
/* 3 components, so use MCT */
parameters.tcp_mct = 1;
-
+
/* set max image */
parameters.max_comp_size = max_comp_size;
parameters.tcp_rates[0] = ((float) (3 * input->size().width * input->size().height * 12)) / (max_cs_len * 8);
throw EncodeError (N_("JPEG2000 encoding failed"));
}
- shared_ptr<EncodedData> enc (new LocallyEncodedData (cio->buffer, cio_tell (cio)));
+ Data enc (cio->buffer, cio_tell (cio));
opj_cio_close (cio);
free (parameters.cp_comment);
}
protected:
- boost::shared_ptr<EncodedData> do_encode (boost::shared_ptr<const dcp::XYZImage> input);
+ Data do_encode (boost::shared_ptr<const dcp::OpenJPEGImage> input);
};
#include "poznan_encoder.h"
#include "exceptions.h"
-#include "encoded_data.h"
+#include "data.h"
#include "raw_convert.h"
#include <poznan/tier2/markers.h>
-#include <dcp/xyz_image.h>
+#include <dcp/openjpeg_image.h>
#include <dlfcn.h>
#include "i18n.h"
void* tier2 = open_library ("tier2");
void* types = open_library ("types");
void* misc = open_library ("misc");
-
+
_init_device = (void (*)(type_parameters *)) dlsym (config, "init_device");
_color_coder_lossy = (void (*)(type_image *)) dlsym (preprocessing, "color_coder_lossy");
_fwt = (void (*)(type_tile *)) dlsym (dwt, "fwt");
_cuda_h_allocate_mem = (void (*)(void **, uint64_t)) dlsym (misc, "cuda_h_allocate_mem");
_cuda_memcpy_htd = (void (*)(void *, void *, uint64_t)) dlsym (misc, "cuda_memcpy_htd");
_cuda_h_free = (void (*)(void *)) dlsym (misc, "cuda_h_free");
-
+
if (
!_init_device || !_color_coder_lossy || !_fwt || !_quantize_tile ||
!_encode_tile || !_set_coding_parameters || !_init_tiles ||
_param.param_mct_klt_iterations = 10000;
_param.param_mct_klt_border_eigenvalue = 0.000001;
_param.param_mct_klt_err = 1.0e-7;
-
+
_init_device (&_param);
}
return _("CUDA (GPU) encoder (Poznan Supercomputing and Networking Center)");
}
-shared_ptr<EncodedData>
-PoznanEncoder::do_encode (shared_ptr<const dcp::XYZImage> input)
+Data
+PoznanEncoder::do_encode (shared_ptr<const dcp::OpenJPEGImage> input)
{
type_image* img = new type_image;
_cuda_memcpy_htd (c->img_data, c->img_data_d, pixels * sizeof (type_data));
_cuda_h_free (c->img_data);
}
-
+
std::cout << "Tile " << tile->width << "x" << tile->height << "\n";
_fwt (tile);
_quantize_tile (tile);
std::cout << img->num_tiles << " tiles.\n";
std::cout << "got " << buffer.bytes_count << " bytes.\n";
- shared_ptr<EncodedData> encoded (new EncodedData (buffer.data, buffer.bytes_count));
+ Data encoded (buffer.data, buffer.bytes_count);
/* XXX! */
static int shit = 0;
{
public:
PoznanEncoder ();
-
+
std::string name () const;
std::string id () const {
protected:
- boost::shared_ptr<EncodedData> do_encode (
- boost::shared_ptr<const dcp::XYZImage> input
+ Data do_encode (
+ boost::shared_ptr<const dcp::OpenJPEGImage> input
);
void parameters_changed ();
-
+
private:
void* open_library (std::string name);
-
+
type_parameters _param;
void (*_init_device) (type_parameters *);
void (*_color_coder_lossy) (type_image *);
- void (*_fwt) (type_tile *);
- void (*_quantize_tile) (type_tile *);
- void (*_encode_tile) (type_tile *);
+ void (*_fwt) (type_tile *);
+ void (*_quantize_tile) (type_tile *);
+ void (*_encode_tile) (type_tile *);
void (*_set_coding_parameters) (type_image *, type_parameters *);
void (*_init_tiles) (type_image **, type_parameters *);
void (*_init_buffer) (type_buffer *);
int main ()
{
JPEG2000Encoder::setup_encoders ();
-
+
shared_ptr<JPEG2000Encoder> encoder = JPEG2000Encoder::from_id ("poznan");
shared_ptr<Image> rgb (new Image (PIX_FMT_RGB24, dcp::Size (1998, 1080), false));
}
}
- vector<PresetColourConversion> presets = Config::instance()->colour_conversions ();
- shared_ptr<const dcp::XYZImage> xyz = dcp::rgb_to_xyz (rgb->data()[0], rgb->size(), rgb->stride()[0], presets.front().conversion);
-
- shared_ptr<EncodedData> j2k = encoder->encode (xyz, 100000000, 24, RESOLUTION_2K, false);
+ shared_ptr<const dcp::OpenJPEGImage> xyz = dcp::rgb_to_xyz (rgb->data()[0], rgb->size(), rgb->stride()[0], ColourConversion::rec709_to_xyz ());
+ Data j2k = encoder->encode (xyz, 100000000, 24, RESOLUTION_2K, false);
}