ardour/livetrax
13
0
Fork 0
Code
40a3eab989
livetrax/libs/ardour/filesource.cc
Taybin Rutkin 8af0757b61 libardour added. 
git-svn-id: svn://localhost/trunk/ardour2@17 d708f5d6-7413-0410-9779-e7cbd77b26cf
2005-09-24 19:13:41 +00:00

1102 lines
24 KiB
C++
Raw Blame History

/*
Copyright (C) 2000 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
$Id$
*/
#include <algorithm>
/* This is is very hacky way to get pread and pwrite declarations.
First, include <features.h> so that we can avoid its #undef __USE_UNIX98.
Then define __USE_UNIX98, include <unistd.h>, and then undef it
again. If #define _XOPEN_SOURCE actually worked, I'd use that, but
despite claims in the header that it does, it doesn't.
features.h isn't available on osx and it compiles fine without it.
*/
#ifdef HAVE_FEATURES_H
#include <features.h>
#endif
#if __GNUC__ >= 3
// #define _XOPEN_SOURCE 500
#include <unistd.h>
#else
#define __USE_UNIX98
#include <unistd.h>
#undef __USE_UNIX98
#endif
#include <sys/stat.h>
#include <fcntl.h>
#include <climits>
#include <cerrno>
#include <sys/types.h>
#include <pwd.h>
#include <time.h>
#include <sys/utsname.h>
#include <vector>
#include <cstdio> /* for rename(2) */
#include <pbd/stl_delete.h>
#include <pbd/basename.h>
#include <pbd/dirname.h>
#include <pbd/lockmonitor.h>
#include <pbd/pathscanner.h>
#include <ardour/ardour.h>
#include <ardour/version.h>
#include <ardour/source.h>
#include <ardour/filesource.h>
#include <ardour/session.h>
#include <ardour/cycle_timer.h>
#include "i18n.h"
using namespace ARDOUR;
string prepare_string(string& regex);
char FileSource::bwf_country_code[3] = "us";
char FileSource::bwf_organization_code[4] = "las";
char FileSource::bwf_serial_number[13] = "000000000000";
string FileSource::search_path;
void
FileSource::set_search_path (string p)
{
search_path = p;
}
FileSource::FileSource (string pathstr, jack_nframes_t rate, bool repair_first)
{
/* constructor used when the file cannot already exist or might be damaged */
if (repair_first && repair (pathstr, rate)) {
throw failed_constructor ();
}
if (init (pathstr, false, rate)) {
throw failed_constructor ();
}
SourceCreated (this); /* EMIT SIGNAL */
}
FileSource::FileSource (const XMLNode& node, jack_nframes_t rate)
: Source (node)
{
if (set_state (node)) {
throw failed_constructor();
}
/* constructor used when the file must already exist */
if (init (_name, true, rate)) {
throw failed_constructor ();
}
SourceCreated (this); /* EMIT SIGNAL */
}
int
FileSource::init (string pathstr, bool must_exist, jack_nframes_t rate)
{
bool new_file = false;
int ret = -1;
PathScanner scanner;
/* all native files end in .wav. this lets us discard
SndFileSource paths, which have ":N" at the end to
indicate which channel to read from, as well as any
other kind of non-native file. obviously, there
are more subtle checks later on.
*/
if (pathstr.length() < 4 || pathstr.rfind (".wav") != pathstr.length() - 4) {
return ret;
}
is_bwf = false;
_length = 0;
fd = -1;
remove_at_unref = false;
next_peak_clear_should_notify = false;
if (pathstr[0] != '/') {
/* find pathstr in search path */
if (search_path.length() == 0) {
error << _("FileSource: search path not set") << endmsg;
goto out;
}
/* force exact match on the filename component by prefixing the regexp.
otherwise, "Drums-2.wav" matches "Comp_Drums-2.wav".
*/
string regexp = "^";
regexp += prepare_string(pathstr);
regexp += '$';
vector<string*>* result = scanner (search_path, regexp, false, true, -1);
if (result == 0 || result->size() == 0) {
error << compose (_("FileSource: \"%1\" not found when searching %2 using %3"),
pathstr, search_path, regexp) << endmsg;
goto out;
}
if (result->size() > 1) {
string msg = compose (_("FileSource: \"%1\" is ambigous when searching %2\n\t"), pathstr, search_path);
vector<string*>::iterator x = result->begin();
while (true) {
msg += *(*x);
++x;
if (x == result->end()) {
break;
}
msg += "\n\t";
}
error << msg << endmsg;
goto out;
}
_name = pathstr;
_path = *(result->front());
vector_delete (result);
delete result;
} else {
/* old style sessions include full paths */
_path = pathstr;
_name = pathstr.substr (pathstr.find_last_of ('/') + 1);
}
if (access (_path.c_str(), F_OK) != 0) {
if (must_exist) {
error << compose(_("Filesource: cannot find required file (%1): %2"), _path, strerror (errno)) << endmsg;
goto out;
}
if (errno == ENOENT) {
new_file = true;
} else {
error << compose(_("Filesource: cannot check for existing file (%1): %2"), _path, strerror (errno)) << endmsg;
goto out;
}
}
if ((fd = open64 (_path.c_str(), O_RDWR|O_CREAT, 0644)) < 0) {
error << compose(_("FileSource: could not open \"%1\": (%2)"), _path, strerror (errno)) << endmsg;
goto out;
}
/* if there was no timestamp available via XML,
then get it from the filesystem.
*/
if (_timestamp == 0) {
struct stat statbuf;
fstat (fd, &statbuf);
_timestamp = statbuf.st_mtime;
}
if (lseek (fd, 0, SEEK_END) == 0) {
new_file = true;
}
/* check that its a RIFF/WAVE format file */
if (new_file) {
is_bwf = Config->get_native_format_is_bwf ();
if (fill_header (rate)) {
error << compose (_("FileSource: cannot write header in %1"), _path) << endmsg;
goto out;
}
struct tm* now;
time_t xnow;
time (&xnow);
now = localtime (&xnow);
update_header (0, *now, xnow);
} else {
if (discover_chunks (must_exist)) {
error << compose (_("FileSource: cannot locate chunks in %1"), _path) << endmsg;
goto out;
}
if (read_header (must_exist)) {
error << compose (_("FileSource: cannot read header in %1"), _path) << endmsg;
goto out;
}
if (check_header (rate, must_exist)) {
error << compose (_("FileSource: cannot check header in %1"), _path) << endmsg;
goto out;
}
compute_header_size ();
}
if ((ret = initialize_peakfile (new_file, _path))) {
error << compose (_("FileSource: cannot initialize peakfile for %1"), _path) << endmsg;
}
out:
if (ret) {
if (fd >= 0) {
close (fd);
}
if (new_file) {
unlink (_path.c_str());
}
}
return ret;
}
FileSource::~FileSource ()
{
GoingAway (this); /* EMIT SIGNAL */
if (fd >= 0) {
if (remove_at_unref || is_empty (_path)) {
unlink (_path.c_str());
unlink (peakpath.c_str());
}
close (fd);
}
}
int
FileSource::discover_chunks (bool silent)
{
WAVEChunk rw;
off64_t end;
off64_t offset;
char null_terminated_id[5];
if ((end = lseek (fd, 0, SEEK_END)) < 0) {
error << _("FileSource: cannot seek to end of file") << endmsg;
return -1;
}
if (::pread64 (fd, &rw, sizeof (rw), 0) != sizeof (rw)) {
error << _("FileSource: cannot read RIFF/WAVE chunk from file") << endmsg;
return -1;
}
if (memcmp (rw.id, "RIFF", 4) || memcmp (rw.text, "WAVE", 4)) {
if (!silent) {
error << compose (_("FileSource %1: not a RIFF/WAVE file"), _path) << endmsg;
}
return -1;
}
null_terminated_id[4] = '\0';
/* OK, its a RIFF/WAVE file. Find each chunk */
memcpy (null_terminated_id, rw.id, 4);
chunk_info.push_back (ChunkInfo (null_terminated_id, rw.size, 0));
offset = sizeof (rw);
while (offset < end) {
GenericChunk this_chunk;
if (::pread64 (fd, &this_chunk, sizeof (this_chunk), offset) != sizeof (this_chunk)) {
error << _("FileSource: can't read a chunk") << endmsg;
return -1;
}
memcpy (null_terminated_id, this_chunk.id, 4);
if (end != 44)
if ((memcmp(null_terminated_id, "data", 4) == 0))
if ((this_chunk.size == 0) || (this_chunk.size > (end - offset)))
this_chunk.size = end - offset;
chunk_info.push_back (ChunkInfo (null_terminated_id, this_chunk.size, offset));
/* skip to the next chunk */
offset += sizeof(GenericChunk) + this_chunk.size;
}
return 0;
}
FileSource::ChunkInfo*
FileSource::lookup_chunk (string what)
{
for (vector<ChunkInfo>::iterator i = chunk_info.begin(); i != chunk_info.end(); ++i) {
if ((*i).name == what) {
return &*i;
}
}
return 0;
}
int
FileSource::fill_header (jack_nframes_t rate)
{
/* RIFF/WAVE */
memcpy (header.wave.id, "RIFF", 4);
header.wave.size = 0; /* file size */
memcpy (header.wave.text, "WAVE", 4);
/* BROADCAST WAVE EXTENSION */
if (is_bwf) {
/* fill the entire BWF header with nulls */
memset (&header.bext, 0, sizeof (header.bext));
memcpy (header.bext.id, "bext", 4);
snprintf (header.bext.description, sizeof (header.bext.description), "%s", "ambiguity is clearer than precision.");
struct passwd *pwinfo;
struct utsname utsinfo;
if ((pwinfo = getpwuid (getuid())) == 0) {
error << compose(_("FileSource: cannot get user information for BWF header (%1)"), strerror(errno)) << endmsg;
return -1;
}
if (uname (&utsinfo)) {
error << compose(_("FileSource: cannot get host information for BWF header (%1)"), strerror(errno)) << endmsg;
return -1;
}
snprintf (header.bext.originator, sizeof (header.bext.originator), "ardour:%s:%s:%s:%s:%s)",
pwinfo->pw_gecos,
utsinfo.nodename,
utsinfo.sysname,
utsinfo.release,
utsinfo.version);
header.bext.version = 1;
/* XXX do something about this field */
snprintf (header.bext.umid, sizeof (header.bext.umid), "%s", "fnord");
/* add some coding history */
char buf[64];
/* encode: PCM,rate,mono,24bit,ardour-version
Note that because we use JACK, there is no way to tell
what the original bit depth of the signal was.
*/
snprintf (buf, sizeof(buf), "F=%u,A=PCM,M=mono,W=24,T=ardour-%d.%d.%d",
rate,
libardour_major_version,
libardour_minor_version,
libardour_micro_version);
header.coding_history.push_back (buf);
/* initial size reflects coding history + "\r\n" */
header.bext.size = sizeof (BroadcastChunk) - sizeof (GenericChunk) + strlen (buf) + 2;
}
memcpy (header.format.id, "fmt ", 4);
header.format.size = sizeof (FMTChunk) - sizeof (GenericChunk);
header.format.formatTag = 3; /* little-endian IEEE float format */
header.format.nChannels = 1; /* mono */
header.format.nSamplesPerSec = rate;
header.format.nAvgBytesPerSec = rate * sizeof (Sample);
header.format.nBlockAlign = 4;
header.format.nBitsPerSample = 32;
/* DATA */
memcpy (header.data.id, "data", 4);
header.data.size = 0;
return 0;
}
void
FileSource::compute_header_size ()
{
off64_t end_of_file;
int32_t coding_history_size = 0;
end_of_file = lseek (fd, 0, SEEK_END);
if (is_bwf) {
/* include the coding history */
for (vector<string>::iterator i = header.coding_history.begin(); i != header.coding_history.end(); ++i) {
coding_history_size += (*i).length() + 2; // include "\r\n";
}
header.bext.size = sizeof (BroadcastChunk) - sizeof (GenericChunk) + coding_history_size;
data_offset = bwf_header_size + coding_history_size;
} else {
data_offset = wave_header_size;
}
if (end_of_file == 0) {
/* newfile condition */
if (is_bwf) {
/* include "WAVE" then all the chunk sizes (bext, fmt, data) */
header.wave.size = 4 + sizeof (BroadcastChunk) + coding_history_size + sizeof (FMTChunk) + sizeof (GenericChunk);
} else {
/* include "WAVE" then all the chunk sizes (fmt, data) */
header.wave.size = 4 + sizeof (FMTChunk) + sizeof (GenericChunk);
}
header.data.size = 0;
} else {
header.wave.size = end_of_file - 8; /* size of initial RIFF+size pseudo-chunk */
header.data.size = end_of_file - data_offset;
}
}
int
FileSource::update_header (jack_nframes_t when, struct tm& now, time_t tnow)
{
LockMonitor lm (_lock, __LINE__, __FILE__);
if (is_bwf) {
/* random code is 9 digits */
int random_code = random() % 999999999;
snprintf (header.bext.originator_reference, sizeof (header.bext.originator_reference), "%2s%3s%12s%02d%02d%02d%9d",
bwf_country_code,
bwf_organization_code,
bwf_serial_number,
now.tm_hour,
now.tm_min,
now.tm_sec,
random_code);
snprintf (header.bext.origination_date, sizeof (header.bext.origination_date), "%4d-%02d-%02d",
1900 + now.tm_year,
now.tm_mon,
now.tm_mday);
snprintf (header.bext.origination_time, sizeof (header.bext.origination_time), "%02d-%02d-%02d",
now.tm_hour,
now.tm_min,
now.tm_sec);
header.bext.time_reference_high = 0;
header.bext.time_reference_low = when;
}
compute_header_size ();
if (write_header()) {
error << compose(_("FileSource[%1]: cannot update data size: %2"), _path, strerror (errno)) << endmsg;
return -1;
}
stamp (tnow);
return 0;
}
int
FileSource::read_header (bool silent)
{
/* we already have the chunk info, so just load up whatever we have */
ChunkInfo* info;
if ((info = lookup_chunk ("RIFF")) == 0) {
error << _("FileSource: can't find RIFF chunk info") << endmsg;
return -1;
}
/* just fill this chunk/header ourselves, disk i/o is stupid */
memcpy (header.wave.id, "RIFF", 4);
header.wave.size = 0;
memcpy (header.wave.text, "WAVE", 4);
if ((info = lookup_chunk ("bext")) != 0) {
is_bwf = true;
if (::pread64 (fd, &header.bext, sizeof (header.bext), info->offset) != sizeof (header.bext)) {
error << _("FileSource: can't read RIFF chunk") << endmsg;
return -1;
}
if (read_broadcast_data (*info)) {
return -1;
}
}
if ((info = lookup_chunk ("fmt ")) == 0) {
error << _("FileSource: can't find format chunk info") << endmsg;
return -1;
}
if (::pread64 (fd, &header.format, sizeof (header.format), info->offset) != sizeof (header.format)) {
error << _("FileSource: can't read format chunk") << endmsg;
return -1;
}
if ((info = lookup_chunk ("data")) == 0) {
error << _("FileSource: can't find data chunk info") << endmsg;
return -1;
}
if (::pread (fd, &header.data, sizeof (header.data), info->offset) != sizeof (header.data)) {
error << _("FileSource: can't read data chunk") << endmsg;
return -1;
}
return 0;
}
int
FileSource::read_broadcast_data (ChunkInfo& info)
{
int32_t coding_history_size;
if (::pread (fd, (char *) &header.bext, sizeof (header.bext), info.offset + sizeof (GenericChunk)) != sizeof (header.bext)) {
error << compose(_("FileSource: cannot read Broadcast Wave data from existing audio file \"%1\" (%2)"),
_path, strerror (errno)) << endmsg;
return -1;
}
if (info.size > sizeof (header.bext)) {
coding_history_size = info.size - (sizeof (header.bext) - sizeof (GenericChunk));
char data[coding_history_size];
if (::pread (fd, data, coding_history_size, info.offset + sizeof (BroadcastChunk)) != coding_history_size) {
error << compose(_("FileSource: cannot read Broadcast Wave coding history from audio file \"%1\" (%2)"),
_path, strerror (errno)) << endmsg;
return -1;
}
/* elements of the coding history are divided by \r\n */
char *p = data;
char *end = data + coding_history_size;
string tmp;
while (p < end) {
if (*p == '\r' && (p+1) != end && *(p+1) == '\n') {
if (tmp.length()) {
header.coding_history.push_back (tmp);
tmp = "";
}
p += 2;
} else {
tmp += *p;
p++;
}
}
}
return 0;
}
int
FileSource::check_header (jack_nframes_t rate, bool silent)
{
if (header.format.formatTag != 3) { /* IEEE float */
if (!silent) {
error << compose(_("FileSource \"%1\" does not use floating point format.\n"
"This is probably a programming error."), _path) << endmsg;
}
return -1;
}
/* compute the apparent length of the data */
data_offset = 0;
for (vector<ChunkInfo>::iterator i = chunk_info.begin(); i != chunk_info.end();) {
vector<ChunkInfo>::iterator n;
n = i;
++n;
if ((*i).name == "data") {
data_offset = (*i).offset + sizeof (GenericChunk);
if (n == chunk_info.end()) {
off64_t end_of_file;
end_of_file = lseek (fd, 0, SEEK_END);
_length = end_of_file - data_offset;
} else {
_length = (*n).offset - data_offset;
}
_length /= sizeof (Sample);
break;
}
i = n;
}
if (data_offset == 0) {
error << compose(_("FileSource \"%1\" has no \"data\" chunk"), _path) << endmsg;
return -1;
}
if (_length * sizeof (Sample) != (jack_nframes_t) header.data.size) {
warning << compose(_("%1: data length in header (%2) differs from implicit size in file (%3)"),
_path, header.data.size, _length * sizeof (Sample)) << endmsg;
}
if ((jack_nframes_t) header.format.nSamplesPerSec != rate) {
warning << compose(_("\"%1\" has a sample rate of %2 instead of %3 as used by this session"),
_path, header.format.nSamplesPerSec, rate) << endmsg;
}
return 0;
}
int
FileSource::write_header()
{
off64_t pos;
/* write RIFF/WAVE boilerplate */
pos = 0;
if (::pwrite64 (fd, (char *) &header.wave, sizeof (header.wave), pos) != sizeof (header.wave)) {
error << compose(_("FileSource: cannot write WAVE chunk: %1"), strerror (errno)) << endmsg;
return -1;
}
pos += sizeof (header.wave);
if (is_bwf) {
/* write broadcast chunk data without copy history */
if (::pwrite64 (fd, (char *) &header.bext, sizeof (header.bext), pos) != sizeof (header.bext)) {
return -1;
}
pos += sizeof (header.bext);
/* write copy history */
for (vector<string>::iterator i = header.coding_history.begin(); i != header.coding_history.end(); ++i) {
string x;
x = *i;
x += "\r\n";
if (::pwrite64 (fd, x.c_str(), x.length(), pos) != (int32_t) x.length()) {
return -1;
}
pos += x.length();
}
}
/* write fmt and data chunks */
if (::pwrite64 (fd, (char *) &header.format, sizeof (header.format), pos) != sizeof (header.format)) {
error << compose(_("FileSource: cannot write format chunk: %1"), strerror (errno)) << endmsg;
return -1;
}
pos += sizeof (header.format);
if (::pwrite64 (fd, (char *) &header.data, sizeof (header.data), pos) != sizeof (header.data)) {
error << compose(_("FileSource: cannot data chunk: %1"), strerror (errno)) << endmsg;
return -1;
}
return 0;
}
void
FileSource::mark_for_remove ()
{
remove_at_unref = true;
}
jack_nframes_t
FileSource::read (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const
{
LockMonitor lm (_lock, __LINE__, __FILE__);
return read_unlocked (dst, start, cnt);
}
jack_nframes_t
FileSource::read_unlocked (Sample *dst, jack_nframes_t start, jack_nframes_t cnt) const
{
int32_t byte_cnt;
int nread;
byte_cnt = cnt * sizeof (Sample);
if ((nread = pread (fd, (char *) dst, byte_cnt, data_offset + (start * sizeof (Sample)))) != (off64_t) byte_cnt) {
cerr << "FileSource: \""
<< _path
<< "\" bad read at frame "
<< start
<< ", of "
<< cnt
<< " (bytes="
<< byte_cnt
<< ") frames [length = " << _length
<< " eor = " << start + cnt << "] ("
<< strerror (errno)
<< ") (read "
<< nread / sizeof (Sample)
<< " (bytes=" <<nread
<< ")) pos was"
<< data_offset
<< '+'
<< start << '*' << sizeof(Sample)
<< " = " << data_offset + (start * sizeof(Sample))
<< endl;
return 0;
}
_read_data_count = byte_cnt;
return cnt;
}
jack_nframes_t
FileSource::write (Sample *data, jack_nframes_t cnt)
{
{
LockMonitor lm (_lock, __LINE__, __FILE__);
int32_t byte_cnt = cnt * sizeof (Sample);
int32_t byte_pos = data_offset + (_length * sizeof (Sample));
jack_nframes_t oldlen;
if (::pwrite64 (fd, (char *) data, byte_cnt, byte_pos) != (off64_t) byte_cnt) {
error << compose(_("FileSource: \"%1\" bad write (%2)"), _path, strerror (errno)) << endmsg;
return 0;
}
oldlen = _length;
_length += cnt;
_write_data_count = byte_cnt;
if (_build_peakfiles) {
PeakBuildRecord *pbr = 0;
if (pending_peak_builds.size()) {
pbr = pending_peak_builds.back();
}
if (pbr && pbr->frame + pbr->cnt == oldlen) {
/* the last PBR extended to the start of the current write,
so just extend it again.
*/
pbr->cnt += cnt;
} else {
pending_peak_builds.push_back (new PeakBuildRecord (oldlen, cnt));
}
_peaks_built = false;
}
}
if (_build_peakfiles) {
queue_for_peaks (*this);
}
return cnt;
}
bool
FileSource::is_empty (string path)
{
struct stat statbuf;
stat (path.c_str(), &statbuf);
/* its a bit of a problem if an audio file happens
to be a regular WAVE file with just enough data
to match the size of an empty BWF. hmmm. not very
likely however - that represents a duration of
less than 1msec at typical sample rates.
*/
/* NOTE: 700 bytes is the size of a BWF header structure *plus* our minimal coding history */
return (statbuf.st_size == 0 || statbuf.st_size == wave_header_size || statbuf.st_size == 700);
}
void
FileSource::mark_streaming_write_completed ()
{
LockMonitor lm (_lock, __LINE__, __FILE__);
next_peak_clear_should_notify = true;
if (_peaks_built || pending_peak_builds.empty()) {
_peaks_built = true;
PeaksReady (); /* EMIT SIGNAL */
}
}
string
FileSource::peak_path(string audio_path)
{
return Session::peak_path_from_audio_path (audio_path);
}
string
FileSource::old_peak_path(string audio_path)
{
return Session::old_peak_path_from_audio_path (audio_path);
}
void
FileSource::mark_take (string id)
{
_take_id = id;
}
int
FileSource::move_to_trash (const string trash_dir_name)
{
string newpath;
/* don't move the file across filesystems, just
stick it in the `trash_dir_name' directory
on whichever filesystem it was already on.
*/
newpath = PBD::dirname (_path);
newpath = PBD::dirname (newpath);
newpath += '/';
newpath += trash_dir_name;
newpath += '/';
newpath += PBD::basename (_path);
if (access (newpath.c_str(), F_OK) == 0) {
/* the new path already exists, try versioning */
char buf[PATH_MAX+1];
int version = 1;
string newpath_v;
snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), version);
newpath_v = buf;
while (access (newpath_v.c_str(), F_OK) == 0 && version < 999) {
snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), ++version);
newpath_v = buf;
}
if (version == 999) {
error << compose (_("there are already 1000 files with names like %1; versioning discontinued"),
newpath)
<< endmsg;
} else {
newpath = newpath_v;
}
} else {
/* it doesn't exist, or we can't read it or something */
}
if (::rename (_path.c_str(), newpath.c_str()) != 0) {
error << compose (_("cannot rename audio file source from %1 to %2 (%3)"),
_path, newpath, strerror (errno))
<< endmsg;
return -1;
}
if (::unlink (peakpath.c_str()) != 0) {
error << compose (_("cannot remove peakfile %1 for %2 (%3)"),
peakpath, _path, strerror (errno))
<< endmsg;
/* try to back out */
rename (newpath.c_str(), _path.c_str());
return -1;
}
_path = newpath;
peakpath = "";
remove_at_unref = false;
return 0;
}
string
prepare_string(string& str)
{
string prepared;
for (uint32_t i = 0; i < str.size(); ++i){
char c = str[i];
if (isdigit(c) || isalpha(c)){
prepared += c;
} else {
prepared += '\\';
prepared += c;
}
}
return prepared;
}
int
FileSource::repair (string path, jack_nframes_t rate)
{
FILE* in;
char buf[700];
char* ptr;
struct stat statbuf;
size_t i;
int ret = -1;
if (stat (path.c_str(), &statbuf)) {
return -1;
}
if (statbuf.st_size <= (off_t) sizeof (buf)) {
/* nothing was ever written to the file, so there is nothing
really to do.
*/
return 0;
}
if ((in = fopen (path.c_str(), "r+")) == NULL) {
return -1;
}
if (fread (buf, sizeof (buf), 1, in) != 1) {
goto out;
}
if (memcmp (&buf[0], "RIFF", 4) || memcmp (&buf[8], "WAVE", 4)) {
/* no header. too dangerous to proceed */
goto out;
}
/* reset the size of the RIFF chunk header */
*((int32_t *)&buf[4]) = statbuf.st_size - 8;
/* find data chunk and reset the size */
ptr = buf;
for (i = 0; i < sizeof (buf); ) {
if (memcmp (ptr, "fmt ", 4) == 0) {
FMTChunk fmt;
memcpy (&fmt, ptr, sizeof (fmt));
fmt.nSamplesPerSec = rate;
fmt.nAvgBytesPerSec = rate * 4;
/* put it back */
memcpy (ptr, &fmt, sizeof (fmt));
ptr += sizeof (fmt);
i += sizeof (fmt);
} else if (memcmp (ptr, "data", 4) == 0) {
*((int32_t *)&ptr[4]) = statbuf.st_size - i - 8;
break;
} else {
++ptr;
++i;
}
}
/* now flush it back to disk */
rewind (in);
if (fwrite (buf, sizeof (buf), 1, in) != 1) {
goto out;
}
ret = 0;
fflush (in);
out:
fclose (in);
return ret;
}
View Git Blame Copy Permalink