X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fdcp_video_frame.cc;h=25abd6f0df57ee7f9f0304e9713b919052639c00;hb=f660fe3f1be97f373318806a77b3ce3fcd53cb73;hp=39334d3c72fab4711a1d1bcfb05af7c3e95c58e8;hpb=07ba15f367b36d17ec60edf77aa57fd20ee76740;p=dcpomatic.git diff --git a/src/lib/dcp_video_frame.cc b/src/lib/dcp_video_frame.cc index 39334d3c7..25abd6f0d 100644 --- a/src/lib/dcp_video_frame.cc +++ b/src/lib/dcp_video_frame.cc @@ -49,6 +49,7 @@ #include #include #include +#include #include "film.h" #include "dcp_video_frame.h" #include "config.h" @@ -66,6 +67,7 @@ using std::stringstream; using std::ofstream; using std::cout; using boost::shared_ptr; +using boost::lexical_cast; using libdcp::Size; #define DCI_COEFFICENT (48.0 / 52.37) @@ -73,41 +75,41 @@ using libdcp::Size; /** Construct a DCP video frame. * @param input Input image. * @param f Index of the frame within the DCP. - * @param clut Colour look-up table to use (see Config::colour_lut_index ()) * @param bw J2K bandwidth to use (see Config::j2k_bandwidth ()) * @param l Log to write to. */ DCPVideoFrame::DCPVideoFrame ( - shared_ptr image, int f, int dcp_fps, int clut, int bw, shared_ptr l + shared_ptr image, int f, Eyes eyes, ColourConversion c, int dcp_fps, int bw, shared_ptr l ) : _image (image) , _frame (f) + , _eyes (eyes) + , _conversion (c) , _frames_per_second (dcp_fps) - , _colour_lut (clut) , _j2k_bandwidth (bw) , _log (l) - , _parameters (0) - , _cinfo (0) - , _cio (0) { } -DCPVideoFrame::~DCPVideoFrame () +DCPVideoFrame::DCPVideoFrame (shared_ptr image, shared_ptr node, shared_ptr log) + : _image (image) + , _log (log) { - if (_cio) { - opj_cio_close (_cio); - } - - if (_cinfo) { - opj_destroy_compress (_cinfo); - } - - if (_parameters) { - free (_parameters->cp_comment); + _frame = node->number_child ("Frame"); + string const eyes = node->string_child ("Eyes"); + if (eyes == "Both") { + _eyes = EYES_BOTH; + } else if (eyes == "Left") { + _eyes = EYES_LEFT; + } else if (eyes == "Right") { + _eyes = EYES_RIGHT; + } else { + assert (false); } - - delete _parameters; + _conversion = ColourConversion (node->node_child ("ColourConversion")); + _frames_per_second = node->number_child ("FramesPerSecond"); + _j2k_bandwidth = node->number_child ("J2KBandwidth"); } /** J2K-encode this frame on the local host. @@ -116,100 +118,133 @@ DCPVideoFrame::~DCPVideoFrame () shared_ptr DCPVideoFrame::encode_locally () { - /* In sRGB / Rec709 gamma LUT */ - shared_ptr lut_in; - if (_colour_lut == 0) { - lut_in = libdcp::SRGBLinearisedGammaLUT::cache.get (12, 2.4); + shared_ptr in_lut; + if (_conversion.input_gamma_linearised) { + in_lut = libdcp::SRGBLinearisedGammaLUT::cache.get (12, _conversion.input_gamma); } else { - lut_in = libdcp::Rec709LinearisedGammaLUT::cache.get (12, 1 / 0.45); + in_lut = libdcp::GammaLUT::cache.get (12, _conversion.input_gamma); } - /* Out DCI gamma LUT */ - shared_ptr lut_out = libdcp::GammaLUT::cache.get (16, 1 / 2.6); - + /* XXX: libdcp should probably use boost */ + + double matrix[3][3]; + for (int i = 0; i < 3; ++i) { + for (int j = 0; j < 3; ++j) { + matrix[i][j] = _conversion.matrix (i, j); + } + } + shared_ptr xyz = libdcp::rgb_to_xyz ( - _image, lut_in, lut_out, _colour_lut == 0 ? libdcp::colour_matrix::srgb_to_xyz : libdcp::colour_matrix::rec709_to_xyz + _image, + in_lut, + libdcp::GammaLUT::cache.get (16, 1 / _conversion.output_gamma), + matrix ); /* Set the max image and component sizes based on frame_rate */ - int const max_cs_len = ((float) _j2k_bandwidth) / 8 / _frames_per_second; + int max_cs_len = ((float) _j2k_bandwidth) / 8 / _frames_per_second; + if (_eyes == EYES_LEFT || _eyes == EYES_RIGHT) { + /* In 3D we have only half the normal bandwidth per eye */ + max_cs_len /= 2; + } int const max_comp_size = max_cs_len / 1.25; + /* get a J2K compressor handle */ + opj_cinfo_t* cinfo = opj_create_compress (CODEC_J2K); + if (cinfo == 0) { + throw EncodeError (N_("could not create JPEG2000 encoder")); + } + /* Set encoding parameters to default values */ - _parameters = new opj_cparameters_t; - opj_set_default_encoder_parameters (_parameters); + opj_cparameters_t parameters; + opj_set_default_encoder_parameters (¶meters); /* Set default cinema parameters */ - _parameters->tile_size_on = false; - _parameters->cp_tdx = 1; - _parameters->cp_tdy = 1; + parameters.tile_size_on = false; + parameters.cp_tdx = 1; + parameters.cp_tdy = 1; /* Tile part */ - _parameters->tp_flag = 'C'; - _parameters->tp_on = 1; + 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->image_offset_x0 = 0; - _parameters->image_offset_y0 = 0; + parameters.cp_tx0 = 0; + parameters.cp_ty0 = 0; + parameters.image_offset_x0 = 0; + parameters.image_offset_y0 = 0; /* Codeblock size = 32x32 */ - _parameters->cblockw_init = 32; - _parameters->cblockh_init = 32; - _parameters->csty |= 0x01; + parameters.cblockw_init = 32; + parameters.cblockh_init = 32; + parameters.csty |= 0x01; /* The progression order shall be CPRL */ - _parameters->prog_order = CPRL; + parameters.prog_order = CPRL; /* No ROI */ - _parameters->roi_compno = -1; + parameters.roi_compno = -1; - _parameters->subsampling_dx = 1; - _parameters->subsampling_dy = 1; + parameters.subsampling_dx = 1; + parameters.subsampling_dy = 1; /* 9-7 transform */ - _parameters->irreversible = 1; + parameters.irreversible = 1; - _parameters->tcp_rates[0] = 0; - _parameters->tcp_numlayers++; - _parameters->cp_disto_alloc = 1; - _parameters->cp_rsiz = CINEMA2K; - _parameters->cp_comment = strdup (N_("DCP-o-matic")); - _parameters->cp_cinema = CINEMA2K_24; + parameters.tcp_rates[0] = 0; + parameters.tcp_numlayers++; + parameters.cp_disto_alloc = 1; + parameters.cp_rsiz = CINEMA2K; + parameters.cp_comment = strdup (N_("DCP-o-matic")); + parameters.cp_cinema = CINEMA2K_24; /* 3 components, so use MCT */ - _parameters->tcp_mct = 1; + parameters.tcp_mct = 1; /* set max image */ - _parameters->max_comp_size = max_comp_size; - _parameters->tcp_rates[0] = ((float) (3 * xyz->size().width * xyz->size().height * 12)) / (max_cs_len * 8); - - /* get a J2K compressor handle */ - _cinfo = opj_create_compress (CODEC_J2K); - if (_cinfo == 0) { - throw EncodeError (N_("could not create JPEG2000 encoder")); - } + parameters.max_comp_size = max_comp_size; + parameters.tcp_rates[0] = ((float) (3 * xyz->size().width * xyz->size().height * 12)) / (max_cs_len * 8); /* Set event manager to null (openjpeg 1.3 bug) */ - _cinfo->event_mgr = 0; + cinfo->event_mgr = 0; /* Setup the encoder parameters using the current image and user parameters */ - opj_setup_encoder (_cinfo, _parameters, xyz->opj_image ()); + opj_setup_encoder (cinfo, ¶meters, xyz->opj_image ()); - _cio = opj_cio_open ((opj_common_ptr) _cinfo, 0, 0); - if (_cio == 0) { + opj_cio_t* cio = opj_cio_open ((opj_common_ptr) cinfo, 0, 0); + if (cio == 0) { + opj_destroy_compress (cinfo); throw EncodeError (N_("could not open JPEG2000 stream")); } - int const r = opj_encode (_cinfo, _cio, xyz->opj_image(), 0); + int const r = opj_encode (cinfo, cio, xyz->opj_image(), 0); if (r == 0) { + opj_cio_close (cio); + opj_destroy_compress (cinfo); throw EncodeError (N_("JPEG2000 encoding failed")); } - _log->log (String::compose (N_("Finished locally-encoded frame %1"), _frame)); - - return shared_ptr (new LocallyEncodedData (_cio->buffer, cio_tell (_cio))); + switch (_eyes) { + case EYES_BOTH: + _log->log (String::compose (N_("Finished locally-encoded frame %1 for mono"), _frame)); + break; + case EYES_LEFT: + _log->log (String::compose (N_("Finished locally-encoded frame %1 for L"), _frame)); + break; + case EYES_RIGHT: + _log->log (String::compose (N_("Finished locally-encoded frame %1 for R"), _frame)); + break; + default: + break; + } + + shared_ptr enc (new LocallyEncodedData (cio->buffer, cio_tell (cio))); + + opj_cio_close (cio); + free (parameters.cp_comment); + opj_destroy_compress (cinfo); + + return enc; } /** Send this frame to a remote server for J2K encoding, then read the result. @@ -217,25 +252,27 @@ DCPVideoFrame::encode_locally () * @return Encoded data. */ shared_ptr -DCPVideoFrame::encode_remotely (ServerDescription const * serv) +DCPVideoFrame::encode_remotely (ServerDescription serv) { boost::asio::io_service io_service; boost::asio::ip::tcp::resolver resolver (io_service); - boost::asio::ip::tcp::resolver::query query (serv->host_name(), boost::lexical_cast (Config::instance()->server_port ())); + boost::asio::ip::tcp::resolver::query query (serv.host_name(), boost::lexical_cast (Config::instance()->server_port_base ())); boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve (query); shared_ptr socket (new Socket); socket->connect (*endpoint_iterator); - stringstream s; - s << N_("encode please\n") - << N_("width ") << _image->size().width << N_("\n") - << N_("height ") << _image->size().height << N_("\n") - << N_("frame ") << _frame << N_("\n") - << N_("frames_per_second ") << _frames_per_second << N_("\n") - << N_("colour_lut ") << _colour_lut << N_("\n") - << N_("j2k_bandwidth ") << _j2k_bandwidth << N_("\n"); + xmlpp::Document doc; + xmlpp::Element* root = doc.create_root_node ("EncodingRequest"); + + root->add_child("Version")->add_child_text (lexical_cast (SERVER_LINK_VERSION)); + root->add_child("Width")->add_child_text (lexical_cast (_image->size().width)); + root->add_child("Height")->add_child_text (lexical_cast (_image->size().height)); + add_metadata (root); + + stringstream xml; + doc.write_to_stream (xml, "UTF-8"); _log->log (String::compose ( N_("Sending to remote; pixel format %1, components %2, lines (%3,%4,%5), line sizes (%6,%7,%8)"), @@ -244,8 +281,8 @@ DCPVideoFrame::encode_remotely (ServerDescription const * serv) _image->line_size()[0], _image->line_size()[1], _image->line_size()[2] )); - socket->write (s.str().length() + 1); - socket->write ((uint8_t *) s.str().c_str(), s.str().length() + 1); + socket->write (xml.str().length() + 1); + socket->write ((uint8_t *) xml.str().c_str(), xml.str().length() + 1); _image->write_to_socket (socket); @@ -257,6 +294,31 @@ DCPVideoFrame::encode_remotely (ServerDescription const * serv) return e; } +void +DCPVideoFrame::add_metadata (xmlpp::Element* el) const +{ + el->add_child("Frame")->add_child_text (lexical_cast (_frame)); + + switch (_eyes) { + case EYES_BOTH: + el->add_child("Eyes")->add_child_text ("Both"); + break; + case EYES_LEFT: + el->add_child("Eyes")->add_child_text ("Left"); + break; + case EYES_RIGHT: + el->add_child("Eyes")->add_child_text ("Right"); + break; + default: + assert (false); + } + + _conversion.as_xml (el->add_child("ColourConversion")); + + el->add_child("FramesPerSecond")->add_child_text (lexical_cast (_frames_per_second)); + el->add_child("J2KBandwidth")->add_child_text (lexical_cast (_j2k_bandwidth)); +} + EncodedData::EncodedData (int s) : _data (new uint8_t[s]) , _size (s) @@ -264,17 +326,22 @@ EncodedData::EncodedData (int s) } -EncodedData::EncodedData (string file) +EncodedData::EncodedData (boost::filesystem::path file) { _size = boost::filesystem::file_size (file); _data = new uint8_t[_size]; - FILE* f = fopen (file.c_str(), N_("rb")); + FILE* f = fopen (file.string().c_str(), N_("rb")); if (!f) { throw FileError (_("could not open file for reading"), file); } - fread (_data, 1, _size, f); + size_t const r = fread (_data, 1, _size, f); + if (r != size_t (_size)) { + fclose (f); + throw FileError (_("could not read encoded data"), file); + } + fclose (f); } @@ -289,11 +356,11 @@ EncodedData::~EncodedData () * @param frame DCP frame index. */ void -EncodedData::write (shared_ptr film, int frame) const +EncodedData::write (shared_ptr film, int frame, Eyes eyes) const { - string const tmp_j2c = film->j2c_path (frame, true); + boost::filesystem::path const tmp_j2c = film->j2c_path (frame, eyes, true); - FILE* f = fopen (tmp_j2c.c_str (), N_("wb")); + FILE* f = fopen (tmp_j2c.string().c_str (), N_("wb")); if (!f) { throw WriteFileError (tmp_j2c, errno); @@ -302,17 +369,17 @@ EncodedData::write (shared_ptr film, int frame) const fwrite (_data, 1, _size, f); fclose (f); - string const real_j2c = film->j2c_path (frame, false); + boost::filesystem::path const real_j2c = film->j2c_path (frame, eyes, false); /* Rename the file from foo.j2c.tmp to foo.j2c now that it is complete */ boost::filesystem::rename (tmp_j2c, real_j2c); } void -EncodedData::write_info (shared_ptr film, int frame, libdcp::FrameInfo fin) const +EncodedData::write_info (shared_ptr film, int frame, Eyes eyes, libdcp::FrameInfo fin) const { - string const info = film->info_path (frame); - ofstream h (info.c_str()); + boost::filesystem::path const info = film->info_path (frame, eyes); + ofstream h (info.string().c_str()); fin.write (h); }