/** The cipher that this code uses */
#define CIPHER EVP_aes_256_cbc()
-dcp::Data
+dcp::ArrayData
dcpomatic::random_iv ()
{
EVP_CIPHER const * cipher = CIPHER;
- dcp::Data iv (EVP_CIPHER_iv_length(cipher));
- RAND_bytes (iv.data().get(), iv.size());
+ dcp::ArrayData iv (EVP_CIPHER_iv_length(cipher));
+ RAND_bytes (iv.data(), iv.size());
return iv;
}
-dcp::Data
-dcpomatic::encrypt (string plaintext, dcp::Data key, dcp::Data iv)
+dcp::ArrayData
+dcpomatic::encrypt (string plaintext, dcp::ArrayData key, dcp::ArrayData iv)
{
EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new ();
if (!ctx) {
throw CryptoError ("could not create cipher context");
}
- int r = EVP_EncryptInit_ex (ctx, CIPHER, 0, key.data().get(), iv.data().get());
+ int r = EVP_EncryptInit_ex (ctx, CIPHER, 0, key.data(), iv.data());
if (r != 1) {
throw CryptoError ("could not initialise cipher context for encryption");
}
- dcp::Data ciphertext (plaintext.size() * 2);
+ dcp::ArrayData ciphertext (plaintext.size() * 2);
int len;
- r = EVP_EncryptUpdate (ctx, ciphertext.data().get(), &len, (uint8_t const *) plaintext.c_str(), plaintext.size());
+ r = EVP_EncryptUpdate (ctx, ciphertext.data(), &len, (uint8_t const *) plaintext.c_str(), plaintext.size());
if (r != 1) {
throw CryptoError ("could not encrypt data");
}
int ciphertext_len = len;
- r = EVP_EncryptFinal_ex (ctx, ciphertext.data().get() + len, &len);
+ r = EVP_EncryptFinal_ex (ctx, ciphertext.data() + len, &len);
if (r != 1) {
throw CryptoError ("could not finish encryption");
}
}
string
-dcpomatic::decrypt (dcp::Data ciphertext, dcp::Data key, dcp::Data iv)
+dcpomatic::decrypt (dcp::ArrayData ciphertext, dcp::ArrayData key, dcp::ArrayData iv)
{
EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new ();
if (!ctx) {
throw CryptoError ("could not create cipher context");
}
- int r = EVP_DecryptInit_ex (ctx, CIPHER, 0, key.data().get(), iv.data().get());
+ int r = EVP_DecryptInit_ex (ctx, CIPHER, 0, key.data(), iv.data());
if (r != 1) {
throw CryptoError ("could not initialise cipher context for decryption");
}
- dcp::Data plaintext (ciphertext.size() * 2);
+ dcp::ArrayData plaintext (ciphertext.size() * 2);
int len;
- r = EVP_DecryptUpdate (ctx, plaintext.data().get(), &len, ciphertext.data().get(), ciphertext.size());
+ r = EVP_DecryptUpdate (ctx, plaintext.data(), &len, ciphertext.data(), ciphertext.size());
if (r != 1) {
throw CryptoError ("could not decrypt data");
}
int plaintext_len = len;
- r = EVP_DecryptFinal_ex (ctx, plaintext.data().get() + len, &len);
+ r = EVP_DecryptFinal_ex (ctx, plaintext.data() + len, &len);
if (r != 1) {
throw CryptoError ("could not finish decryption");
}
plaintext_len += len;
plaintext.set_size (plaintext_len + 1);
- plaintext.data().get()[plaintext_len] = '\0';
+ plaintext.data()[plaintext_len] = '\0';
EVP_CIPHER_CTX_free (ctx);
- return string ((char *) plaintext.data().get());
+ return string ((char *) plaintext.data());
}
int
*/
-#include <dcp/data.h>
+#include <dcp/array_data.h>
namespace dcpomatic {
-
-dcp::Data random_iv ();
-dcp::Data encrypt (std::string plaintext, dcp::Data key, dcp::Data iv);
-std::string decrypt (dcp::Data ciphertext, dcp::Data key, dcp::Data iv);
-int crypto_key_length ();
+
+dcp::ArrayData random_iv ();
+dcp::ArrayData encrypt (std::string plaintext, dcp::ArrayData key, dcp::ArrayData iv);
+std::string decrypt (dcp::ArrayData ciphertext, dcp::ArrayData key, dcp::ArrayData iv);
+int crypto_key_length ();
}
using std::cout;
using boost::shared_ptr;
using dcp::Size;
-using dcp::Data;
+using dcp::ArrayData;
using dcp::raw_convert;
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
/** J2K-encode this frame on the local host.
* @return Encoded data.
*/
-Data
+ArrayData
DCPVideo::encode_locally ()
{
string const comment = Config::instance()->dcp_j2k_comment();
- Data enc = dcp::compress_j2k (
+ ArrayData enc = dcp::compress_j2k (
convert_to_xyz (_frame, boost::bind(&Log::dcp_log, dcpomatic_log.get(), _1, _2)),
_j2k_bandwidth,
_frames_per_second,
* @param timeout timeout in seconds.
* @return Encoded data.
*/
-Data
+ArrayData
DCPVideo::encode_remotely (EncodeServerDescription serv, int timeout)
{
boost::asio::io_service io_service;
*/
Socket::ReadDigestScope ds (socket);
LOG_TIMING("start-remote-encode thread=%1", thread_id ());
- Data e (socket->read_uint32 ());
+ ArrayData e (socket->read_uint32 ());
LOG_TIMING("start-remote-receive thread=%1", thread_id ());
- socket->read (e.data().get(), e.size());
+ socket->read (e.data(), e.size());
LOG_TIMING("finish-remote-receive thread=%1", thread_id ());
if (!ds.check()) {
throw NetworkError ("Checksums do not match");
#include "types.h"
#include "encode_server_description.h"
#include <libcxml/cxml.h>
-#include <dcp/data.h>
+#include <dcp/array_data.h>
/** @file src/dcp_video_frame.h
* @brief A single frame of video destined for a DCP.
DCPVideo (boost::shared_ptr<const PlayerVideo>, int, int, int, Resolution);
DCPVideo (boost::shared_ptr<const PlayerVideo>, cxml::ConstNodePtr);
- dcp::Data encode_locally ();
- dcp::Data encode_remotely (EncodeServerDescription, int timeout = 30);
+ dcp::ArrayData encode_locally ();
+ dcp::ArrayData encode_remotely (EncodeServerDescription, int timeout = 30);
int index () const {
return _index;
using std::cout;
using std::pair;
using boost::shared_ptr;
-using dcp::Data;
+using dcp::ArrayData;
Emailer::Emailer (string from, list<string> to, string subject, string body)
: _from (from)
BIO* bio = BIO_new (BIO_s_mem());
bio = BIO_push (b64, bio);
- Data data (i.file);
- BIO_write (bio, data.data().get(), data.size());
+ ArrayData data (i.file);
+ BIO_write (bio, data.data(), data.size());
(void) BIO_flush (bio);
char* out;
using boost::bind;
using boost::scoped_array;
using boost::optional;
+using dcp::ArrayData;
using dcp::Size;
-using dcp::Data;
using dcp::raw_convert;
EncodeServer::EncodeServer (bool verbose, int num_threads)
gettimeofday (&after_read, 0);
- Data encoded = dcp_video_frame.encode_locally ();
+ ArrayData encoded = dcp_video_frame.encode_locally ();
gettimeofday (&after_encode, 0);
try {
Socket::WriteDigestScope ds (socket);
socket->write (encoded.size());
- socket->write (encoded.data().get(), encoded.size());
+ socket->write (encoded.data(), encoded.size());
} catch (std::exception& e) {
cerr << "Send failed; frame " << dcp_video_frame.index() << "\n";
LOG_ERROR ("Send failed; frame %1", dcp_video_frame.index());
}
-FFmpegImageProxy::FFmpegImageProxy (dcp::Data data)
+FFmpegImageProxy::FFmpegImageProxy (dcp::ArrayData data)
: _data (data)
, _pos (0)
{
: _pos (0)
{
uint32_t const size = socket->read_uint32 ();
- _data = dcp::Data (size);
- socket->read (_data.data().get(), size);
+ _data = dcp::ArrayData (size);
+ socket->read (_data.data(), size);
}
static int
if (to_do == 0) {
return AVERROR_EOF;
}
- memcpy (buffer, _data.data().get() + _pos, to_do);
+ memcpy (buffer, _data.data() + _pos, to_do);
_pos += to_do;
return to_do;
}
FFmpegImageProxy::write_to_socket (shared_ptr<Socket> socket) const
{
socket->write (_data.size());
- socket->write (_data.data().get(), _data.size());
+ socket->write (_data.data(), _data.size());
}
bool
return false;
}
- if (_data.size() != mp->_data.size()) {
- return false;
- }
-
- return memcmp (_data.data().get(), mp->_data.data().get(), _data.size()) == 0;
+ return _data == mp->_data;
}
size_t
*/
#include "image_proxy.h"
-#include <dcp/data.h>
+#include <dcp/array_data.h>
#include <boost/thread/mutex.hpp>
#include <boost/filesystem.hpp>
{
public:
explicit FFmpegImageProxy (boost::filesystem::path);
- explicit FFmpegImageProxy (dcp::Data);
+ explicit FFmpegImageProxy (dcp::ArrayData);
FFmpegImageProxy (boost::shared_ptr<cxml::Node> xml, boost::shared_ptr<Socket> socket);
Result image (
int64_t avio_seek (int64_t const pos, int whence);
private:
- dcp::Data _data;
+ dcp::ArrayData _data;
mutable int64_t _pos;
/** Path of a file that this image came from, if applicable; stored so that
failed-decode errors can give more detail.
throw EncodeError (String::compose ("Error during PNG write: %1", message));
}
-dcp::Data
+dcp::ArrayData
Image::as_png () const
{
DCPOMATIC_ASSERT (bytes_per_pixel(0) == 4);
png_destroy_write_struct (&png_ptr, &info_ptr);
png_free (png_ptr, row_pointers);
- return dcp::Data (state.data, state.size);
+ return dcp::ArrayData (state.data, state.size);
}
extern "C" {
#include <libavutil/pixfmt.h>
}
+#include <dcp/array_data.h>
#include <dcp/colour_conversion.h>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
size_t memory_used () const;
- dcp::Data as_png () const;
+ dcp::ArrayData as_png () const;
void png_error (char const * message);
/* Read the data from the asset and hash it */
dcpomatic_fseek (asset_file, info.offset, SEEK_SET);
- Data data (info.size);
- size_t const read = fread (data.data().get(), 1, data.size(), asset_file);
+ ArrayData data (info.size);
+ size_t const read = fread (data.data(), 1, data.size(), asset_file);
LOG_GENERAL ("Read %1 bytes of asset data; wanted %2", read, info.size);
if (read != static_cast<size_t> (data.size ())) {
LOG_GENERAL ("Existing frame %1 is incomplete", frame);
ok = false;
} else {
Digester digester;
- digester.add (data.data().get(), data.size());
+ digester.add (data.data(), data.size());
LOG_GENERAL ("Hash %1 vs %2", digester.get(), info.hash);
if (digester.get() != info.hash) {
LOG_GENERAL ("Existing frame %1 failed hash check", frame);
using boost::shared_ptr;
using boost::scoped_array;
using boost::optional;
-using dcp::Data;
+using dcp::ArrayData;
using namespace dcpomatic;
StringTextFile::StringTextFile (shared_ptr<const StringTextFileContent> content)
} else {
/* Text-based file; sort out its character encoding before we try to parse it */
- Data in (content->path (0));
+ ArrayData in (content->path (0));
UErrorCode status = U_ZERO_ERROR;
UCharsetDetector* detector = ucsdet_open (&status);
- ucsdet_setText (detector, reinterpret_cast<const char *> (in.data().get()), in.size(), &status);
+ ucsdet_setText (detector, reinterpret_cast<const char *>(in.data()), in.size(), &status);
UCharsetMatch const * match = ucsdet_detect (detector, &status);
char const * in_charset = ucsdet_getName (match, &status);
scoped_array<uint16_t> utf16 (new uint16_t[in.size() * 2]);
int const utf16_len = ucnv_toUChars (
to_utf16, reinterpret_cast<UChar*>(utf16.get()), in.size() * 2,
- reinterpret_cast<const char *> (in.data().get()), in.size(),
+ reinterpret_cast<const char *>(in.data()), in.size(),
&status
);
#if BOOST_VERSION >= 106100
using namespace boost::placeholders;
#endif
-using dcp::Data;
+using dcp::ArrayData;
static shared_ptr<Film> film;
static EncodeServerDescription* server;
++frame_count;
- Data local_encoded = local->encode_locally ();
- Data remote_encoded;
+ ArrayData local_encoded = local->encode_locally ();
+ ArrayData remote_encoded;
string remote_error;
try {
return;
}
- uint8_t* p = local_encoded.data().get ();
- uint8_t* q = remote_encoded.data().get ();
+ uint8_t* p = local_encoded.data();
+ uint8_t* q = remote_encoded.data();
for (int i = 0; i < local_encoded.size(); ++i) {
if (*p++ != *q++) {
cout << "\033[0;31mdata differ\033[0m at byte " << i << "\n";
using boost::thread;
using boost::optional;
using boost::weak_ptr;
-using dcp::Data;
+using dcp::ArrayData;
void
-do_remote_encode (shared_ptr<DCPVideo> frame, EncodeServerDescription description, Data locally_encoded)
+do_remote_encode (shared_ptr<DCPVideo> frame, EncodeServerDescription description, ArrayData locally_encoded)
{
- Data remotely_encoded;
+ ArrayData remotely_encoded;
BOOST_REQUIRE_NO_THROW (remotely_encoded = frame->encode_remotely (description, 1200));
BOOST_REQUIRE_EQUAL (locally_encoded.size(), remotely_encoded.size());
- BOOST_CHECK_EQUAL (memcmp (locally_encoded.data().get(), remotely_encoded.data().get(), locally_encoded.size()), 0);
+ BOOST_CHECK_EQUAL (memcmp (locally_encoded.data(), remotely_encoded.data(), locally_encoded.size()), 0);
}
BOOST_AUTO_TEST_CASE (client_server_test_rgb)
)
);
- Data locally_encoded = frame->encode_locally ();
+ ArrayData locally_encoded = frame->encode_locally ();
EncodeServer* server = new EncodeServer (true, 2);
)
);
- Data locally_encoded = frame->encode_locally ();
+ ArrayData locally_encoded = frame->encode_locally ();
EncodeServer* server = new EncodeServer (true, 2);
)
);
- Data raw_locally_encoded = raw_frame->encode_locally ();
+ ArrayData raw_locally_encoded = raw_frame->encode_locally ();
shared_ptr<PlayerVideo> j2k_pvf (
new PlayerVideo (
)
);
- Data j2k_locally_encoded = j2k_frame->encode_locally ();
+ ArrayData j2k_locally_encoded = j2k_frame->encode_locally ();
EncodeServer* server = new EncodeServer (true, 2);
BOOST_AUTO_TEST_CASE (crypto_test)
{
- dcp::Data key (dcpomatic::crypto_key_length());
- dcp::Data iv = dcpomatic::random_iv ();
+ dcp::ArrayData key (dcpomatic::crypto_key_length());
+ dcp::ArrayData iv = dcpomatic::random_iv ();
- RAND_bytes (key.data().get(), dcpomatic::crypto_key_length());
+ RAND_bytes (key.data(), dcpomatic::crypto_key_length());
- dcp::Data ciphertext = dcpomatic::encrypt ("Can you see any fish?", key, iv);
+ dcp::ArrayData ciphertext = dcpomatic::encrypt ("Can you see any fish?", key, iv);
BOOST_REQUIRE_EQUAL (dcpomatic::decrypt (ciphertext, key, iv), "Can you see any fish?");
key.data()[5]++;
png_destroy_write_struct (&png_ptr, &info_ptr);
png_free (png_ptr, row_pointers);
- dcp::Data(state.data, state.size).write(file);
+ dcp::ArrayData(state.data, state.size).write(file);
}