/*
- Copyright (C) 2012 Carl Hetherington <cth@carlh.net>
+ Copyright (C) 2012-2014 Carl Hetherington <cth@carlh.net>
Taken from code Copyright (C) 2010-2011 Terrence Meiczinger
This program is free software; you can redistribute it and/or modify
#include <boost/asio.hpp>
#include <boost/filesystem.hpp>
#include <boost/lexical_cast.hpp>
-#include <libdcp/rec709_linearised_gamma_lut.h>
-#include <libdcp/srgb_linearised_gamma_lut.h>
-#include <libdcp/gamma_lut.h>
-#include <libdcp/xyz_frame.h>
-#include <libdcp/rgb_xyz.h>
-#include <libdcp/colour_matrix.h>
+#include <dcp/gamma_lut.h>
+#include <dcp/xyz_frame.h>
+#include <dcp/rgb_xyz.h>
+#include <dcp/colour_matrix.h>
#include <libcxml/cxml.h>
#include "film.h"
#include "dcp_video_frame.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;
+using dcp::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, ColourConversion c, 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)
, _conversion (c)
, _frames_per_second (dcp_fps)
, _j2k_bandwidth (bw)
+ , _resolution (r)
, _log (l)
{
_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.
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);
- }
+ shared_ptr<dcp::GammaLUT> in_lut;
+ in_lut = dcp::GammaLUT::cache.get (12, _conversion.input_gamma, _conversion.input_gamma_linearised);
/* XXX: libdcp should probably use boost */
}
}
- shared_ptr<libdcp::XYZFrame> xyz = libdcp::rgb_to_xyz (
+ shared_ptr<dcp::XYZFrame> xyz = dcp::rgb_to_xyz (
_image,
in_lut,
- libdcp::GammaLUT::cache.get (16, 1 / _conversion.output_gamma),
+ dcp::GammaLUT::cache.get (16, 1 / _conversion.output_gamma, false),
matrix
);
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);
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->pixel_format(), _image->components(),
- _image->lines(0), _image->lines(1), _image->lines(2),
- _image->line_size()[0], _image->line_size()[1], _image->line_size()[2]
- ));
+ _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);
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)
}
-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
+EncodedData::write_info (shared_ptr<const Film> film, int frame, Eyes eyes, dcp::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.