X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=src%2Flib%2Fdcp_video_frame.cc;h=f6fb8fe2e2d7eb5d457295426fcc0c208f9e4d42;hb=854f2e5bbb7ffb9758b823af87034033033f3cb8;hp=96c40358a46176385ae67624cccd38e41c014808;hpb=4fd257106009b2db170dafddece06ee3c190fceb;p=dcpomatic.git diff --git a/src/lib/dcp_video_frame.cc b/src/lib/dcp_video_frame.cc index 96c40358a..2b7a2e18f 100644 --- a/src/lib/dcp_video_frame.cc +++ b/src/lib/dcp_video_frame.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2012 Carl Hetherington + Copyright (C) 2012-2014 Carl Hetherington Taken from code Copyright (C) 2010-2011 Terrence Meiczinger This program is free software; you can redistribute it and/or modify @@ -36,108 +36,80 @@ #include #include #include +#include #include #include #include #include #include #include +#include +#include +#include +#include +#include #include "film.h" #include "dcp_video_frame.h" -#include "lut.h" #include "config.h" -#include "film_state.h" -#include "options.h" #include "exceptions.h" #include "server.h" #include "util.h" #include "scaler.h" #include "image.h" #include "log.h" +#include "cross.h" -using namespace std; -using namespace boost; +#include "i18n.h" + +using std::string; +using std::stringstream; +using std::cout; +using boost::shared_ptr; +using boost::lexical_cast; +using dcp::Size; + +#define DCI_COEFFICENT (48.0 / 52.37) /** Construct a DCP video frame. * @param input Input image. - * @param out Required size of output, in pixels (including any padding). - * @param s Scaler to use. - * @param p Number of pixels of padding either side of the image. - * @param f Index of the frame within the Film. - * @param fps Frames per second of the Film. - * @param pp FFmpeg post-processing string to use. - * @param clut Colour look-up table to use (see Config::colour_lut_index ()) + * @param f Index of the frame within the DCP. * @param bw J2K bandwidth to use (see Config::j2k_bandwidth ()) * @param l Log to write to. */ DCPVideoFrame::DCPVideoFrame ( - shared_ptr yuv, Size out, int p, Scaler const * s, int f, float fps, string pp, int clut, int bw, Log* l) - : _input (yuv) - , _out_size (out) - , _padding (p) - , _scaler (s) + shared_ptr image, int f, Eyes eyes, ColourConversion c, int dcp_fps, int bw, Resolution r, shared_ptr l + ) + : _image (image) , _frame (f) - /* we round here; not sure if this is right */ - , _frames_per_second (rint (fps)) - , _post_process (pp) - , _colour_lut_index (clut) + , _eyes (eyes) + , _conversion (c) + , _frames_per_second (dcp_fps) , _j2k_bandwidth (bw) + , _resolution (r) , _log (l) - , _image (0) - , _parameters (0) - , _cinfo (0) - , _cio (0) { } -/** Create a libopenjpeg container suitable for our output image */ -void -DCPVideoFrame::create_openjpeg_container () -{ - for (int i = 0; i < 3; ++i) { - _cmptparm[i].dx = 1; - _cmptparm[i].dy = 1; - _cmptparm[i].w = _out_size.width; - _cmptparm[i].h = _out_size.height; - _cmptparm[i].x0 = 0; - _cmptparm[i].y0 = 0; - _cmptparm[i].prec = 12; - _cmptparm[i].bpp = 12; - _cmptparm[i].sgnd = 0; - } - - _image = opj_image_create (3, &_cmptparm[0], CLRSPC_SRGB); - if (_image == 0) { - throw EncodeError ("could not create libopenjpeg image"); - } - - _image->x0 = 0; - _image->y0 = 0; - _image->x1 = _out_size.width; - _image->y1 = _out_size.height; -} - -DCPVideoFrame::~DCPVideoFrame () +DCPVideoFrame::DCPVideoFrame (shared_ptr image, shared_ptr node, shared_ptr log) + : _image (image) + , _log (log) { - if (_image) { - opj_image_destroy (_image); - } - - if (_cio) { - opj_cio_close (_cio); - } - - if (_cinfo) { - opj_destroy_compress (_cinfo); + _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); } - - if (_parameters) { - free (_parameters->cp_comment); - free (_parameters->cp_matrice); - } - - delete _parameters; + _conversion = ColourConversion (node->node_child ("ColourConversion")); + _frames_per_second = node->number_child ("FramesPerSecond"); + _j2k_bandwidth = node->number_child ("J2KBandwidth"); + _resolution = Resolution (node->optional_number_child("Resolution").get_value_or (RESOLUTION_2K)); } /** J2K-encode this frame on the local host. @@ -146,128 +118,147 @@ DCPVideoFrame::~DCPVideoFrame () shared_ptr DCPVideoFrame::encode_locally () { - shared_ptr prepared = _input; + shared_ptr in_lut; + in_lut = dcp::GammaLUT::cache.get (12, _conversion.input_gamma, _conversion.input_gamma_linearised); + + /* XXX: libdcp should probably use boost */ - if (!_post_process.empty ()) { - prepared = prepared->post_process (_post_process); + 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); + } } - prepared = prepared->scale_and_convert_to_rgb (_out_size, _padding, _scaler); - - create_openjpeg_container (); - - int const size = _out_size.width * _out_size.height; - - struct { - double r, g, b; - } s; - - struct { - double x, y, z; - } d; - - /* Copy our RGB into the openjpeg container, converting to XYZ in the process */ - - uint8_t* p = prepared->data()[0]; - for (int i = 0; i < size; ++i) { - /* In gamma LUT (converting 8-bit input to 12-bit) */ - s.r = lut_in[_colour_lut_index][*p++ << 4]; - s.g = lut_in[_colour_lut_index][*p++ << 4]; - s.b = lut_in[_colour_lut_index][*p++ << 4]; - - /* RGB to XYZ Matrix */ - d.x = ((s.r * color_matrix[_colour_lut_index][0][0]) + (s.g * color_matrix[_colour_lut_index][0][1]) + (s.b * color_matrix[_colour_lut_index][0][2])); - d.y = ((s.r * color_matrix[_colour_lut_index][1][0]) + (s.g * color_matrix[_colour_lut_index][1][1]) + (s.b * color_matrix[_colour_lut_index][1][2])); - d.z = ((s.r * color_matrix[_colour_lut_index][2][0]) + (s.g * color_matrix[_colour_lut_index][2][1]) + (s.b * color_matrix[_colour_lut_index][2][2])); - - /* DCI companding */ - d.x = d.x * DCI_COEFFICENT * (DCI_LUT_SIZE - 1); - d.y = d.y * DCI_COEFFICENT * (DCI_LUT_SIZE - 1); - d.z = d.z * DCI_COEFFICENT * (DCI_LUT_SIZE - 1); - - /* Out gamma LUT */ - _image->comps[0].data[i] = lut_out[LO_DCI][(int) d.x]; - _image->comps[1].data[i] = lut_out[LO_DCI][(int) d.y]; - _image->comps[2].data[i] = lut_out[LO_DCI][(int) d.z]; - } - + shared_ptr xyz = dcp::rgb_to_xyz ( + _image, + in_lut, + dcp::GammaLUT::cache.get (16, 1 / _conversion.output_gamma, false), + 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 = _resolution == RESOLUTION_2K ? CINEMA2K : CINEMA4K; + if (_resolution == RESOLUTION_4K) { + parameters.numpocs = 2; + parameters.POC[0].tile = 1; + 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].compno0 = 0; + parameters.POC[1].layno1 = 1; + parameters.POC[1].resno1 = parameters.numresolution; + parameters.POC[1].compno1 = 3; + parameters.POC[1].prg1 = CPRL; + } - _parameters->tcp_rates[0] = 0; - _parameters->tcp_numlayers++; - _parameters->cp_disto_alloc = 1; - _parameters->cp_rsiz = CINEMA2K; - _parameters->cp_comment = strdup ("DVD-o-matic"); - _parameters->cp_cinema = CINEMA2K_24; + parameters.cp_comment = strdup (N_("DCP-o-matic")); + parameters.cp_cinema = _resolution == RESOLUTION_2K ? CINEMA2K_24 : CINEMA4K_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 * _image->comps[0].w * _image->comps[0].h * _image->comps[0].prec)) / (max_cs_len * 8); - - /* get a J2K compressor handle */ - _cinfo = opj_create_compress (CODEC_J2K); + 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, _image); + opj_setup_encoder (cinfo, ¶meters, xyz->opj_image ()); - _cio = opj_cio_open ((opj_common_ptr) _cinfo, 0, 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, _image, 0); + int const r = opj_encode (cinfo, cio, xyz->opj_image(), 0); if (r == 0) { - throw EncodeError ("jpeg2000 encoding failed"); + opj_cio_close (cio); + opj_destroy_compress (cinfo); + throw EncodeError (N_("JPEG2000 encoding failed")); } - { - stringstream s; - s << "Finished locally-encoded frame " << _frame; - _log->log (s.str ()); + 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; } - - return shared_ptr (new LocallyEncodedData (_cio->buffer, cio_tell (_cio))); + + 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. @@ -275,77 +266,132 @@ DCPVideoFrame::encode_locally () * @return Encoded data. */ shared_ptr -DCPVideoFrame::encode_remotely (ServerDescription const * serv) +DCPVideoFrame::encode_remotely (ServerDescription serv) { - asio::io_service io_service; - asio::ip::tcp::resolver resolver (io_service); - asio::ip::tcp::resolver::query query (serv->host_name(), boost::lexical_cast (Config::instance()->server_port ())); - asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve (query); - - Socket socket; - - socket.connect (*endpoint_iterator, 30); - - stringstream s; - s << "encode " - << _input->size().width << " " << _input->size().height << " " - << _input->pixel_format() << " " - << _out_size.width << " " << _out_size.height << " " - << _padding << " " - << _scaler->id () << " " - << _frame << " " - << _frames_per_second << " " - << (_post_process.empty() ? "none" : _post_process) << " " - << Config::instance()->colour_lut_index () << " " - << Config::instance()->j2k_bandwidth () << " "; - - for (int i = 0; i < _input->components(); ++i) { - s << _input->line_size()[i] << " "; - } + 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_base ())); + boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve (query); + + shared_ptr socket (new Socket); + + socket->connect (*endpoint_iterator); + + xmlpp::Document doc; + xmlpp::Element* root = doc.create_root_node ("EncodingRequest"); - socket.write ((uint8_t *) s.str().c_str(), s.str().length() + 1, 30); + 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); - for (int i = 0; i < _input->components(); ++i) { - socket.write (_input->data()[i], _input->line_size()[i] * _input->lines(i), 30); + stringstream xml; + doc.write_to_stream (xml, "UTF-8"); + + _log->log (String::compose (N_("Sending frame %1 to remote"), _frame)); + + socket->write (xml.str().length() + 1); + socket->write ((uint8_t *) xml.str().c_str(), xml.str().length() + 1); + + _image->write_to_socket (socket); + + shared_ptr e (new RemotelyEncodedData (socket->read_uint32 ())); + socket->read (e->data(), e->size()); + + _log->log (String::compose (N_("Finished remotely-encoded frame %1"), _frame)); + + 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)); + el->add_child("Resolution")->add_child_text (lexical_cast (int (_resolution))); +} + +EncodedData::EncodedData (int s) + : _data (new uint8_t[s]) + , _size (s) +{ - char buffer[32]; - socket.read_indefinite ((uint8_t *) buffer, sizeof (buffer), 30); - socket.consume (strlen (buffer) + 1); - shared_ptr e (new RemotelyEncodedData (atoi (buffer))); +} - /* now read the rest */ - socket.read_definite_and_consume (e->data(), e->size(), 30); +EncodedData::EncodedData (boost::filesystem::path file) +{ + _size = boost::filesystem::file_size (file); + _data = new uint8_t[_size]; - { - stringstream s; - s << "Finished remotely-encoded frame " << _frame; - _log->log (s.str ()); + FILE* f = fopen_boost (file, "rb"); + if (!f) { + throw FileError (_("could not open file for reading"), file); } - return e; + 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); +} + + +EncodedData::~EncodedData () +{ + delete[] _data; } /** Write this data to a J2K file. - * @param opt Options. - * @param frame Frame index. + * @param Film Film. + * @param frame DCP frame index. */ void -EncodedData::write (shared_ptr opt, int frame) +EncodedData::write (shared_ptr film, int frame, Eyes eyes) const { - string const tmp_j2k = opt->frame_out_path (frame, true); + boost::filesystem::path const tmp_j2c = film->j2c_path (frame, eyes, true); - FILE* f = fopen (tmp_j2k.c_str (), "wb"); + FILE* f = fopen_boost (tmp_j2c, "wb"); if (!f) { - throw WriteFileError (tmp_j2k, errno); + throw WriteFileError (tmp_j2c, errno); } fwrite (_data, 1, _size, f); fclose (f); + 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 */ - filesystem::rename (tmp_j2k, opt->frame_out_path (frame, false)); + boost::filesystem::rename (tmp_j2c, real_j2c); +} + +void +EncodedData::write_info (shared_ptr film, int frame, Eyes eyes, dcp::FrameInfo fin) const +{ + boost::filesystem::path const info = film->info_path (frame, eyes); + FILE* h = fopen_boost (info, "w"); + fin.write (h); + fclose (h); } /** Send this data to a socket. @@ -354,20 +400,19 @@ EncodedData::write (shared_ptr opt, int frame) void EncodedData::send (shared_ptr socket) { - stringstream s; - s << _size; - socket->write ((uint8_t *) s.str().c_str(), s.str().length() + 1, 30); - socket->write (_data, _size, 30); + socket->write (_size); + socket->write (_data, _size); } -/** @param s Size of data in bytes */ -RemotelyEncodedData::RemotelyEncodedData (int s) - : EncodedData (new uint8_t[s], s) +LocallyEncodedData::LocallyEncodedData (uint8_t* d, int s) + : EncodedData (s) { - + memcpy (_data, d, s); } -RemotelyEncodedData::~RemotelyEncodedData () +/** @param s Size of data in bytes */ +RemotelyEncodedData::RemotelyEncodedData (int s) + : EncodedData (s) { - delete[] _data; + }