wchar_to_utf8 (wchar_t const * s)
{
int const length = (wcslen(s) + 1) * 2;
- char* utf8 = new char[length];
- WideCharToMultiByte (CP_UTF8, 0, s, -1, utf8, length, 0, 0);
+ std::vector<char> utf8(length);
+ WideCharToMultiByte (CP_UTF8, 0, s, -1, utf8.data(), length, 0, 0);
string u (utf8);
- delete[] utf8;
return u;
}
throw CopyError (String::compose("Failed to open file %1", from.string()), 0);
}
- uint8_t* buffer = new uint8_t[block_size];
+ std::vector<uint8_t> buffer(block_size);
Digester digester;
int progress_frequency = 1;
uint64_t remaining = file_size (from);
while (remaining > 0) {
uint64_t const this_time = min(remaining, block_size);
- size_t read = fread (buffer, 1, this_time, in);
+ size_t read = fread (buffer.data(), 1, this_time, in);
if (read != this_time) {
fclose (in);
ext4_fclose (&out);
- delete[] buffer;
throw CopyError (String::compose("Short read; expected %1 but read %2", this_time, read), 0);
}
- digester.add (buffer, this_time);
+ digester.add (buffer.data(), this_time);
size_t written;
- r = ext4_fwrite (&out, buffer, this_time, &written);
+ r = ext4_fwrite (&out, buffer.data(), this_time, &written);
if (r != EOK) {
fclose (in);
ext4_fclose (&out);
- delete[] buffer;
throw CopyError ("Write failed", r);
}
if (written != this_time) {
fclose (in);
ext4_fclose (&out);
- delete[] buffer;
throw CopyError (String::compose("Short write; expected %1 but wrote %2", this_time, written), 0);
}
remaining -= this_time;
fclose (in);
ext4_fclose (&out);
- delete[] buffer;
return digester.get ();
}
}
LOG_DISK("Opened %1 for read", to.generic_string());
- uint8_t* buffer = new uint8_t[block_size];
+ std::vector<uint8_t> buffer(block_size);
Digester digester;
uint64_t remaining = file_size (from);
while (remaining > 0) {
uint64_t const this_time = min(remaining, block_size);
size_t read;
- r = ext4_fread (&in, buffer, this_time, &read);
+ r = ext4_fread (&in, buffer.data(), this_time, &read);
if (read != this_time) {
ext4_fclose (&in);
- delete[] buffer;
throw VerifyError (String::compose("Short read; expected %1 but read %2", this_time, read), 0);
}
- digester.add (buffer, this_time);
+ digester.add (buffer.data(), this_time);
remaining -= this_time;
total_remaining -= this_time;
if (nanomsg) {
}
ext4_fclose (&in);
- delete[] buffer;
return digester.get ();
}
auto const video_frame = DCPTime::from_frames (1, _film->video_frame_rate ());
int const audio_frames = video_frame.frames_round(_film->audio_frame_rate());
- float* interleaved = new float[_output_audio_channels * audio_frames];
+ std::vector<float> interleaved(_output_audio_channels * audio_frames);
auto deinterleaved = make_shared<AudioBuffers>(_output_audio_channels, audio_frames);
int const gets_per_frame = _film->three_d() ? 2 : 1;
for (DCPTime i; i < _film->length(); i += video_frame) {
waker.nudge ();
- _butler->get_audio (interleaved, audio_frames);
+ _butler->get_audio (interleaved.data(), audio_frames);
/* XXX: inefficient; butler interleaves and we deinterleave again */
- float* p = interleaved;
+ float* p = interleaved.data();
for (int j = 0; j < audio_frames; ++j) {
for (int k = 0; k < _output_audio_channels; ++k) {
deinterleaved->data(k)[j] = *p++;
}
encoder->audio (deinterleaved);
}
- delete[] interleaved;
for (auto i: file_encoders) {
i.flush ();
string out;
- auto buffer = new char[max(head_amount, tail_amount) + 1];
+ std::vector<char> buffer(max(head_amount, tail_amount) + 1);
- int N = fread (buffer, 1, head_amount, f);
+ int N = fread (buffer.data(), 1, head_amount, f);
buffer[N] = '\0';
- out += string (buffer);
+ out += string (buffer.data());
if (tail_amount > 0) {
out += "\n .\n .\n .\n";
fseek (f, - tail_amount - 1, SEEK_END);
- N = fread (buffer, 1, tail_amount, f);
+ N = fread (buffer.data(), 1, tail_amount, f);
buffer[N] = '\0';
- out += string (buffer) + "\n";
+ out += string (buffer.data()) + "\n";
}
- delete[] buffer;
fclose (f);
return out;
if (!f) {
throw FileError ("Could not open file for reading", path);
}
- auto buffer = new uint8_t[size];
- checked_fread (buffer, size, f, path);
+ std::vector<uint8_t> buffer(size);
+ checked_fread (buffer.data(), size, f, path);
fclose (f);
try {
- _video_size = dcp::decompress_j2k (buffer, size, 0)->size ();
+ _video_size = dcp::decompress_j2k(buffer.data(), size, 0)->size();
} catch (dcp::ReadError& e) {
- delete[] buffer;
throw DecodeError (String::compose (_("Could not decode JPEG2000 file %1 (%2)"), path, e.what ()));
}
- delete[] buffer;
} else {
FFmpegImageProxy proxy(content->path(0));
_video_size = proxy.image(Image::Alignment::COMPACT).image->size();
* do the work.
*/
UpdateChecker::UpdateChecker ()
- : _buffer (new char[BUFFER_SIZE])
+ : _buffer (BUFFER_SIZE)
, _state (State::NOT_RUN)
{
_curl = curl_easy_init ();
} catch (...) {}
curl_easy_cleanup (_curl);
- delete[] _buffer;
}
/* Parse the reply */
_buffer[_offset] = '\0';
- string s (_buffer);
+ string s (_buffer.data());
cxml::Document doc ("Update");
doc.read_string (s);
UpdateChecker::write_callback (void* data, size_t size, size_t nmemb)
{
size_t const t = min (size * nmemb, size_t (BUFFER_SIZE - _offset - 1));
- memcpy (_buffer + _offset, data, t);
+ memcpy (_buffer.data() + _offset, data, t);
_offset += t;
return t;
}
void set_state (State);
void thread ();
- char* _buffer;
+ std::vector<char> _buffer;
int _offset = 0;
CURL* _curl = nullptr;
#else
int accelerators = 6;
#endif
- auto accel = new wxAcceleratorEntry[accelerators];
+ std::vector<wxAcceleratorEntry> accel(accelerators);
/* [Shortcut] Ctrl+A:Add file(s) to the film */
accel[0].Set (wxACCEL_CTRL, static_cast<int>('A'), ID_add_file);
/* [Shortcut] Delete:Remove selected content from film */
Bind (wxEVT_MENU, boost::bind (&DOMFrame::timeline_pressed, this), ID_timeline);
Bind (wxEVT_MENU, boost::bind (&DOMFrame::back_frame, this), ID_back_frame);
Bind (wxEVT_MENU, boost::bind (&DOMFrame::forward_frame, this), ID_forward_frame);
- wxAcceleratorTable accel_table (accelerators, accel);
+ wxAcceleratorTable accel_table (accelerators, accel.data());
SetAcceleratorTable (accel_table);
- delete[] accel;
}
void remove_accelerators ()
_stress.setup (this, _controls);
- wxAcceleratorEntry* accel = new wxAcceleratorEntry[accelerators];
+ std::vector<wxAcceleratorEntry> accel(accelerators);
accel[0].Set(wxACCEL_NORMAL, WXK_SPACE, ID_start_stop);
accel[1].Set(wxACCEL_NORMAL, WXK_LEFT, ID_go_back_frame);
accel[2].Set(wxACCEL_NORMAL, WXK_RIGHT, ID_go_forward_frame);
#ifdef __WXOSX__
accel[11].Set(wxACCEL_CTRL, static_cast<int>('W'), ID_file_close);
#endif
- wxAcceleratorTable accel_table (accelerators, accel);
+ wxAcceleratorTable accel_table (accelerators, accel.data());
SetAcceleratorTable (accel_table);
- delete[] accel;
Bind (wxEVT_MENU, boost::bind(&DOMFrame::start_stop_pressed, this), ID_start_stop);
Bind (wxEVT_MENU, boost::bind(&DOMFrame::go_back_frame, this), ID_go_back_frame);
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_length);
string log;
if (log_length > 0) {
- char* log_char = new char[log_length];
- glGetShaderInfoLog(shader, log_length, nullptr, log_char);
- log = string(log_char);
- delete[] log_char;
+ std::vector<char> log_char(log_length);
+ glGetShaderInfoLog(shader, log_length, nullptr, log_char.data());
+ log = string(log_char.data());
}
glDeleteShader(shader);
throw GLError(String::compose("Could not compile shader (%1)", log).c_str(), -1);
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &log_length);
string log;
if (log_length > 0) {
- char* log_char = new char[log_length];
- glGetProgramInfoLog(program, log_length, nullptr, log_char);
- log = string(log_char);
- delete[] log_char;
+ std::vector<char> log_char(log_length);
+ glGetProgramInfoLog(program, log_length, nullptr, log_char.data());
+ log = string(log_char.data());
}
glDeleteProgram (program);
throw GLError(String::compose("Could not link shader (%1)", log).c_str(), -1);
boost::escaped_list_separator<char> els ("", " ", "\"\'");
boost::tokenizer<boost::escaped_list_separator<char> > tok (cmd, els);
- char** argv = new char*[256];
+ std::vector<char*> argv(256);
int argc = 0;
for (boost::tokenizer<boost::escaped_list_separator<char> >::iterator i = tok.begin(); i != tok.end(); ++i) {
argv[argc++] = strdup (i->c_str());
}
- CreateCLI cc (argc, argv);
+ CreateCLI cc (argc, argv.data());
for (int i = 0; i < argc; ++i) {
free (argv[i]);
}
- delete[] argv;
-
return cc;
}
false
);
- auto audio_buffer = new float[2000 * 6];
+ std::vector<float> audio_buffer(2000 * 6);
while (true) {
auto p = butler->get_video (true, 0);
if (!p.first) {
break;
}
/* assuming DCP is 24fps/48kHz */
- butler->get_audio (audio_buffer, 2000);
+ butler->get_audio (audio_buffer.data(), 2000);
p.first->image(bind(&PlayerVideo::force, _1, AV_PIX_FMT_RGB24), VideoRange::FULL, true);
}
- delete[] audio_buffer;
}
static SNDFILE* ref = nullptr;
-static int ref_buffer_size = 0;
-static float* ref_buffer = nullptr;
+static std::vector<float> ref_buffer;
static void
audio (std::shared_ptr<AudioBuffers> audio, int channels)
{
/* Check that we have a big enough buffer */
- BOOST_CHECK (audio->frames() * audio->channels() < ref_buffer_size);
+ BOOST_CHECK (audio->frames() * audio->channels() < static_cast<int>(ref_buffer.size()));
- int const N = sf_readf_float (ref, ref_buffer, audio->frames());
+ int const N = sf_readf_float (ref, ref_buffer.data(), audio->frames());
for (int i = 0; i < N; ++i) {
switch (channels) {
case 1:
ref = sf_open (file.string().c_str(), SFM_READ, &info);
/* We don't want to test anything that requires resampling */
BOOST_REQUIRE_EQUAL (info.samplerate, 48000);
- ref_buffer_size = info.samplerate * info.channels;
- ref_buffer = new float[ref_buffer_size];
+ ref_buffer.resize(info.samplerate * info.channels);
auto player = make_shared<Player>(film, Image::Alignment::COMPACT);
while (!player->pass ()) {}
sf_close (ref);
- delete[] ref_buffer;
return film;
}
/* We don't want to test anything that requires resampling */
BOOST_REQUIRE_EQUAL (info.samplerate, 48000);
- auto buffer = new int16_t[info.channels * 2000];
+ std::vector<int16_t> buffer(info.channels * 2000);
dcp::SoundAsset asset (dcp_file(film, "pcm"));
auto reader = asset.start_read ();
for (int i = 0; i < asset.intrinsic_duration(); ++i) {
auto frame = reader->get_frame(i);
sf_count_t this_time = min (info.frames, sf_count_t(2000));
- sf_readf_short (ref, buffer, this_time);
+ sf_readf_short (ref, buffer.data(), this_time);
for (int j = 0; j < this_time; ++j) {
BOOST_REQUIRE_EQUAL (frame->get(2, j) >> 8, buffer[j]);
}
info.frames -= this_time;
}
-
- delete[] buffer;
}
/* We don't want to test anything that requires resampling */
BOOST_REQUIRE_EQUAL (info.samplerate, 48000);
- auto buffer = new int32_t[info.channels * 2000];
+ std::vector<int32_t> buffer(info.channels * 2000);
dcp::SoundAsset asset (dcp_file(film, "pcm"));
auto reader = asset.start_read ();
for (int i = 0; i < asset.intrinsic_duration(); ++i) {
auto frame = reader->get_frame(i);
sf_count_t this_time = min (info.frames, sf_count_t(2000));
- sf_readf_int (ref, buffer, this_time);
+ sf_readf_int (ref, buffer.data(), this_time);
for (int j = 0; j < this_time; ++j) {
int32_t s = frame->get(2, j);
if (s > (1 << 23)) {
}
info.frames -= this_time;
}
-
- delete[] buffer;
}
/* We don't want to test anything that requires resampling */
BOOST_REQUIRE_EQUAL (info.samplerate, 48000);
- auto buffer = new int32_t[info.channels * 2000];
+ std::vector<int32_t> buffer(info.channels * 2000);
dcp::SoundAsset asset (dcp_file(film, "pcm"));
auto reader = asset.start_read ();
for (int i = 0; i < asset.intrinsic_duration(); ++i) {
auto frame = reader->get_frame(i);
sf_count_t this_time = min (info.frames, sf_count_t(2000));
- sf_readf_int (ref, buffer, this_time);
+ sf_readf_int (ref, buffer.data(), this_time);
for (int j = 0; j < this_time; ++j) {
int32_t s = frame->get(2, j);
if (s > (1 << 23)) {
}
info.frames -= this_time;
}
-
- delete[] buffer;
}
public:
TestServer (bool digest)
: Server (TEST_SERVER_PORT, 30)
- , _buffer (new uint8_t[TEST_SERVER_BUFFER_LENGTH])
+ , _buffer (TEST_SERVER_BUFFER_LENGTH)
, _size (0)
, _result (false)
, _digest (digest)
try {
_thread.join ();
} catch (...) {}
- delete[] _buffer;
}
void expect (int size)
}
uint8_t const * buffer() const {
- return _buffer;
+ return _buffer.data();
}
void await ()
BOOST_REQUIRE (_size);
if (_digest) {
Socket::ReadDigestScope ds (socket);
- socket->read (_buffer, _size);
+ socket->read (_buffer.data(), _size);
_size = 0;
_condition.notify_one ();
_result = ds.check();
} else {
- socket->read (_buffer, _size);
+ socket->read (_buffer.data(), _size);
_size = 0;
_condition.notify_one ();
}
boost::thread _thread;
boost::mutex _mutex;
boost::condition _condition;
- uint8_t* _buffer;
+ std::vector<uint8_t> _buffer;
int _size;
bool _result;
bool _digest;
BOOST_CHECK (check_file);
int const buffer_size = 65536;
- uint8_t* ref_buffer = new uint8_t[buffer_size];
- uint8_t* check_buffer = new uint8_t[buffer_size];
+ std::vector<uint8_t> ref_buffer(buffer_size);
+ std::vector<uint8_t> check_buffer(buffer_size);
string error = "File " + check.string() + " differs from reference " + ref.string();
while (N) {
uintmax_t this_time = min (uintmax_t (buffer_size), N);
- size_t r = fread (ref_buffer, 1, this_time, ref_file);
+ size_t r = fread (ref_buffer.data(), 1, this_time, ref_file);
BOOST_CHECK_EQUAL (r, this_time);
- r = fread (check_buffer, 1, this_time, check_file);
+ r = fread (check_buffer.data(), 1, this_time, check_file);
BOOST_CHECK_EQUAL (r, this_time);
- BOOST_CHECK_MESSAGE (memcmp (ref_buffer, check_buffer, this_time) == 0, error);
- if (memcmp (ref_buffer, check_buffer, this_time)) {
+ BOOST_CHECK_MESSAGE (memcmp(ref_buffer.data(), check_buffer.data(), this_time) == 0, error);
+ if (memcmp(ref_buffer.data(), check_buffer.data(), this_time)) {
break;
}
N -= this_time;
}
- delete[] ref_buffer;
- delete[] check_buffer;
-
fclose (ref_file);
fclose (check_file);
}
DCPOMATIC_ASSERT (buffer_size < 1024 * 1024);
- auto ref_buffer = new uint8_t[buffer_size];
- auto ref_read = fread(ref_buffer, 1, buffer_size, ref_file);
- auto check_buffer = new uint8_t[buffer_size];
- auto check_read = fread(check_buffer, 1, buffer_size, check_file);
+ std::vector<uint8_t> ref_buffer(buffer_size);
+ auto ref_read = fread(ref_buffer.data(), 1, buffer_size, ref_file);
+ std::vector<uint8_t> check_buffer(buffer_size);
+ auto check_read = fread(check_buffer.data(), 1, buffer_size, check_file);
BOOST_CHECK_EQUAL (ref_read, check_read);
string const error = "File " + check.string() + " differs from reference " + ref.string();
- BOOST_CHECK_MESSAGE(memcmp(ref_buffer, check_buffer, ref_read) == 0, error);
-
- delete[] ref_buffer;
- delete[] check_buffer;
+ BOOST_CHECK_MESSAGE(memcmp(ref_buffer.data(), check_buffer.data(), ref_read) == 0, error);
fclose (ref_file);
fclose (check_file);
projects / dcpomatic.git / commitdiff