#include <libdcp/xyz_frame.h>
#include <libdcp/rgb_xyz.h>
#include <libdcp/colour_matrix.h>
+#include <libcxml/cxml.h>
#include "film.h"
#include "dcp_video_frame.h"
#include "config.h"
#include "scaler.h"
#include "image.h"
#include "log.h"
+#include "cross.h"
#include "i18n.h"
using std::string;
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)
* @param l Log to write to.
*/
DCPVideoFrame::DCPVideoFrame (
- shared_ptr<const Image> image, int f, Eyes eyes, int dcp_fps, int bw, shared_ptr<Log> l
+ shared_ptr<const Image> image, int f, Eyes eyes, ColourConversion c, int dcp_fps, int bw, Resolution r, shared_ptr<Log> l
)
: _image (image)
, _frame (f)
, _eyes (eyes)
+ , _conversion (c)
, _frames_per_second (dcp_fps)
, _j2k_bandwidth (bw)
+ , _resolution (r)
, _log (l)
{
}
+DCPVideoFrame::DCPVideoFrame (shared_ptr<const Image> image, shared_ptr<const cxml::Node> node, shared_ptr<Log> log)
+ : _image (image)
+ , _log (log)
+{
+ _frame = node->number_child<int> ("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);
+ }
+ _conversion = ColourConversion (node->node_child ("ColourConversion"));
+ _frames_per_second = node->number_child<int> ("FramesPerSecond");
+ _j2k_bandwidth = node->number_child<int> ("J2KBandwidth");
+ _resolution = Resolution (node->optional_number_child<int>("Resolution").get_value_or (RESOLUTION_2K));
+}
+
/** J2K-encode this frame on the local host.
* @return Encoded data.
*/
shared_ptr<EncodedData>
DCPVideoFrame::encode_locally ()
{
+ shared_ptr<libdcp::LUT> in_lut;
+ if (_conversion.input_gamma_linearised) {
+ in_lut = libdcp::SRGBLinearisedGammaLUT::cache.get (12, _conversion.input_gamma);
+ } else {
+ in_lut = libdcp::GammaLUT::cache.get (12, _conversion.input_gamma);
+ }
+
+ /* 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<libdcp::XYZFrame> xyz = libdcp::rgb_to_xyz (
_image,
- libdcp::SRGBLinearisedGammaLUT::cache.get (12, 2.4),
- libdcp::GammaLUT::cache.get (16, 1 / 2.6),
- libdcp::colour_matrix::srgb_to_xyz
+ in_lut,
+ libdcp::GammaLUT::cache.get (16, 1 / _conversion.output_gamma),
+ matrix
);
/* Set the max image and component sizes based on frame_rate */
parameters.tcp_rates[0] = 0;
parameters.tcp_numlayers++;
parameters.cp_disto_alloc = 1;
- parameters.cp_rsiz = CINEMA2K;
+ 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.cp_comment = strdup (N_("DCP-o-matic"));
- parameters.cp_cinema = CINEMA2K_24;
+ parameters.cp_cinema = _resolution == RESOLUTION_2K ? CINEMA2K_24 : CINEMA4K_24;
/* 3 components, so use MCT */
parameters.tcp_mct = 1;
{
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<string> (Config::instance()->server_port ()));
+ boost::asio::ip::tcp::resolver::query query (serv.host_name(), boost::lexical_cast<string> (Config::instance()->server_port_base ()));
boost::asio::ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve (query);
shared_ptr<Socket> socket (new Socket);
socket->connect (*endpoint_iterator);
- stringstream s;
- s << "encode please\n"
- << "width " << _image->size().width << "\n"
- << "height " << _image->size().height << "\n"
- << "eyes " << static_cast<int> (_eyes) << "\n"
- << "frame " << _frame << "\n"
- << "frames_per_second " << _frames_per_second << "\n"
- << "j2k_bandwidth " << _j2k_bandwidth << "\n";
+ xmlpp::Document doc;
+ xmlpp::Element* root = doc.create_root_node ("EncodingRequest");
+
+ root->add_child("Version")->add_child_text (lexical_cast<string> (SERVER_LINK_VERSION));
+ root->add_child("Width")->add_child_text (lexical_cast<string> (_image->size().width));
+ root->add_child("Height")->add_child_text (lexical_cast<string> (_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)"),
_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);
return e;
}
+void
+DCPVideoFrame::add_metadata (xmlpp::Element* el) const
+{
+ el->add_child("Frame")->add_child_text (lexical_cast<string> (_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<string> (_frames_per_second));
+ el->add_child("J2KBandwidth")->add_child_text (lexical_cast<string> (_j2k_bandwidth));
+ el->add_child("Resolution")->add_child_text (lexical_cast<string> (int (_resolution)));
+}
+
EncodedData::EncodedData (int s)
: _data (new uint8_t[s])
, _size (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_boost (file, "rb");
if (!f) {
throw FileError (_("could not open file for reading"), file);
}
void
EncodedData::write (shared_ptr<const Film> film, int frame, Eyes eyes) const
{
- string const tmp_j2c = film->j2c_path (frame, eyes, 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_boost (tmp_j2c, "wb");
if (!f) {
throw WriteFileError (tmp_j2c, errno);
fwrite (_data, 1, _size, f);
fclose (f);
- string const real_j2c = film->j2c_path (frame, eyes, 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<const Film> film, int frame, Eyes eyes, libdcp::FrameInfo fin) const
{
- string const info = film->info_path (frame, eyes);
- ofstream h (info.c_str());
+ 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.
projects / dcpomatic.git / blobdiff