// test a wxFFile and wxFFileInput/OutputStreams of a known type
//
void FileKindTestCase::TestFILE(wxFFile& file, bool expected)
{
CPPUNIT_ASSERT(file.IsOpened());
CPPUNIT_ASSERT((wxGetFileKind(file.fp()) == wxFILE_KIND_DISK) == expected);
CPPUNIT_ASSERT((file.GetKind() == wxFILE_KIND_DISK) == expected);
wxFFileInputStream inStream(file);
CPPUNIT_ASSERT(inStream.IsSeekable() == expected);
wxFFileOutputStream outStream(file);
CPPUNIT_ASSERT(outStream.IsSeekable() == expected);
}
bool DbgGdb::ExecuteCmd( const wxString &cmd )
{
if( m_gdbProcess ) {
if ( m_info.enableDebugLog ) {
#if DBG_LOG
if(gfp.IsOpened()) {
gfp.Write(wxString::Format( wxT( "DEBUG>>%s\n" ), cmd.c_str() ));
gfp.Flush();
}
#else
m_observer->UpdateAddLine( wxString::Format( wxT( "DEBUG>>%s" ), cmd.c_str() ) );
#endif
}
return m_gdbProcess->Write( cmd );
}
return false;
}
bool OggImportFileHandle::Import(TrackFactory *trackFactory, Track ***outTracks,
int *outNumTracks, Tags *tags)
{
wxASSERT(mFile->IsOpened());
/* -1 is for the current logical bitstream */
vorbis_info *vi = ov_info(mVorbisFile, -1);
vorbis_comment *vc = ov_comment(mVorbisFile, -1);
WaveTrack **channels = new WaveTrack *[vi->channels];
int c;
for (c = 0; c < vi->channels; c++) {
channels[c] = trackFactory->NewWaveTrack(int16Sample, vi->rate);
if (vi->channels == 2) {
switch (c) {
case 0:
channels[c]->SetChannel(Track::LeftChannel);
channels[c]->SetLinked(true);
break;
case 1:
channels[c]->SetChannel(Track::RightChannel);
channels[c]->SetTeamed(true);
break;
}
}
else {
channels[c]->SetChannel(Track::MonoChannel);
}
}
/* The number of bytes to get from the codec in each run */
#define CODEC_TRANSFER_SIZE 4096
/* The number of samples to read between calls to the callback.
* Balance between responsiveness of the GUI and throughput of import. */
#define SAMPLES_PER_CALLBACK 100000
short *mainBuffer = new short[CODEC_TRANSFER_SIZE];
/* determine endianness (clever trick courtesy of Nicholas Devillard,
* (http://www.eso.org/~ndevilla/endian/) */
int testvar = 1, endian;
if(*(char *)&testvar)
endian = 0; // little endian
else
endian = 1; // big endian
/* number of samples currently in each channel's buffer */
bool cancelled = false;
long bytesRead = 0;
long samplesRead = 0;
int bitstream = 0;
int samplesSinceLastCallback = 0;
// You would think that the stream would already be seeked to 0, and
// indeed it is if the file is legit. But I had several ogg files on
// my hard drive that have malformed headers, and this added call
// causes them to be read correctly. Otherwise they have lots of
// zeros inserted at the beginning
ov_pcm_seek(mVorbisFile, 0);
do {
/* get data from the decoder */
bytesRead = ov_read(mVorbisFile, (char *) mainBuffer,
CODEC_TRANSFER_SIZE,
endian,
2, // word length (2 for 16 bit samples)
1, // signed
&bitstream);
if (bytesRead < 0) {
/* Malformed Ogg Vorbis file. */
/* TODO: Return some sort of meaningful error. */
break;
}
samplesRead = bytesRead / vi->channels / sizeof(short);
/* give the data to the wavetracks */
for (c = 0; c < vi->channels; c++)
channels[c]->Append((char *)(mainBuffer + c),
int16Sample,
samplesRead,
vi->channels);
samplesSinceLastCallback += samplesRead;
if (samplesSinceLastCallback > SAMPLES_PER_CALLBACK) {
if( mProgressCallback )
cancelled = mProgressCallback(mUserData,
ov_time_tell(mVorbisFile) /
ov_time_total(mVorbisFile, bitstream));
samplesSinceLastCallback -= SAMPLES_PER_CALLBACK;
}
} while (!cancelled && bytesRead != 0 && bitstream == 0);
delete[]mainBuffer;
bool res = (!cancelled && bytesRead >= 0);
if (!res) {
for(c = 0; c < vi->channels; c++) {
delete channels[c];
}
delete[] channels;
return false;
}
*outNumTracks = vi->channels;
*outTracks = new Track *[vi->channels];
for (c = 0; c < vi->channels; c++) {
channels[c]->Flush();
(*outTracks)[c] = channels[c];
}
delete[] channels;
if (vc) {
tags->Clear();
for (c = 0; c < vc->comments; c++) {
wxString comment = UTF8CTOWX(vc->user_comments[c]);
tags->SetTag(comment.BeforeFirst(wxT('=')),
comment.AfterFirst(wxT('=')));
}
}
return true;
}
int OggImportFileHandle::Import(TrackFactory *trackFactory, Track ***outTracks,
int *outNumTracks, Tags *tags)
{
wxASSERT(mFile->IsOpened());
CreateProgress();
//Number of streams used may be less than mVorbisFile->links,
//but this way bitstream matches array index.
mChannels = new WaveTrack **[mVorbisFile->links];
int i,c;
for (i = 0; i < mVorbisFile->links; i++)
{
//Stream is not used
if (mStreamUsage[i] == 0)
{
//This is just a padding to keep bitstream number and
//array indices matched.
mChannels[i] = NULL;
continue;
}
vorbis_info *vi = ov_info(mVorbisFile, i);
vorbis_comment *vc = ov_comment(mVorbisFile, i);
mChannels[i] = new WaveTrack *[vi->channels];
for (c = 0; c < vi->channels; c++) {
mChannels[i][c] = trackFactory->NewWaveTrack(int16Sample, vi->rate);
if (vi->channels == 2) {
switch (c) {
case 0:
mChannels[i][c]->SetChannel(Track::LeftChannel);
mChannels[i][c]->SetLinked(true);
break;
case 1:
mChannels[i][c]->SetChannel(Track::RightChannel);
mChannels[i][c]->SetTeamed(true);
break;
}
}
else {
mChannels[i][c]->SetChannel(Track::MonoChannel);
}
}
}
/* The number of bytes to get from the codec in each run */
#define CODEC_TRANSFER_SIZE 4096
/* The number of samples to read between calls to the callback.
* Balance between responsiveness of the GUI and throughput of import. */
#define SAMPLES_PER_CALLBACK 100000
short *mainBuffer = new short[CODEC_TRANSFER_SIZE];
/* determine endianness (clever trick courtesy of Nicholas Devillard,
* (http://www.eso.org/~ndevilla/endian/) */
int testvar = 1, endian;
if(*(char *)&testvar)
endian = 0; // little endian
else
endian = 1; // big endian
/* number of samples currently in each channel's buffer */
bool cancelled = false;
long bytesRead = 0;
long samplesRead = 0;
int bitstream = 0;
int samplesSinceLastCallback = 0;
// You would think that the stream would already be seeked to 0, and
// indeed it is if the file is legit. But I had several ogg files on
// my hard drive that have malformed headers, and this added call
// causes them to be read correctly. Otherwise they have lots of
// zeros inserted at the beginning
ov_pcm_seek(mVorbisFile, 0);
do {
/* get data from the decoder */
bytesRead = ov_read(mVorbisFile, (char *) mainBuffer,
CODEC_TRANSFER_SIZE,
endian,
2, // word length (2 for 16 bit samples)
1, // signed
&bitstream);
if (bytesRead < 0) {
/* Malformed Ogg Vorbis file. */
/* TODO: Return some sort of meaningful error. */
break;
}
samplesRead = bytesRead / mVorbisFile->vi[bitstream].channels / sizeof(short);
/* give the data to the wavetracks */
if (mStreamUsage[bitstream] != 0)
{
for (c = 0; c < mVorbisFile->vi[bitstream].channels; c++)
mChannels[bitstream][c]->Append((char *)(mainBuffer + c),
int16Sample,
samplesRead,
mVorbisFile->vi[bitstream].channels);
}
samplesSinceLastCallback += samplesRead;
if (samplesSinceLastCallback > SAMPLES_PER_CALLBACK) {
cancelled = !mProgress->Update(ov_time_tell(mVorbisFile),
ov_time_total(mVorbisFile, bitstream));
samplesSinceLastCallback -= SAMPLES_PER_CALLBACK;
}
} while (!cancelled && bytesRead != 0);
delete[]mainBuffer;
bool res = (!cancelled && bytesRead >= 0);
if (!res) {
for (i = 0; i < mVorbisFile->links; i++)
{
if (mChannels[i])
{
for(c = 0; c < mVorbisFile->vi[bitstream].channels; c++) {
if (mChannels[i][c])
delete mChannels[i][c];
}
delete[] mChannels[i];
}
}
delete[] mChannels;
return (cancelled ? eImportCancelled : eImportFailed);
}
*outNumTracks = 0;
for (int s = 0; s < mVorbisFile->links; s++)
{
if (mStreamUsage[s] != 0)
*outNumTracks += mVorbisFile->vi[s].channels;
}
*outTracks = new Track *[*outNumTracks];
int trackindex = 0;
for (i = 0; i < mVorbisFile->links; i++)
{
if (mChannels[i])
{
for (c = 0; c < mVorbisFile->vi[i].channels; c++) {
mChannels[i][c]->Flush();
(*outTracks)[trackindex++] = mChannels[i][c];
}
delete[] mChannels[i];
}
}
delete[] mChannels;
//\todo { Extract comments from each stream? }
if (mVorbisFile->vc[0].comments > 0) {
tags->Clear();
for (c = 0; c < mVorbisFile->vc[0].comments; c++) {
wxString comment = UTF8CTOWX(mVorbisFile->vc[0].user_comments[c]);
wxString name = comment.BeforeFirst(wxT('='));
wxString value = comment.AfterFirst(wxT('='));
if (name.Upper() == wxT("DATE") && !tags->HasTag(TAG_YEAR)) {
long val;
if (value.Length() == 4 && value.ToLong(&val)) {
name = TAG_YEAR;
}
}
tags->SetTag(name, value);
}
}
return eImportSuccess;
}
void DbgGdb::Poke()
{
static wxRegEx reCommand( wxT( "^([0-9]{8})" ) );
//poll the debugger output
wxString curline;
if ( !m_gdbProcess || m_gdbOutputArr.IsEmpty() ) {
return;
}
while ( DoGetNextLine( curline ) ) {
GetDebugeePID(curline);
// For string manipulations without damaging the original line read
wxString tmpline ( curline );
StripString( tmpline );
tmpline.Trim().Trim( false );
if ( m_info.enableDebugLog ) {
//Is logging enabled?
if ( curline.IsEmpty() == false && !tmpline.StartsWith( wxT( ">" ) ) ) {
wxString strdebug( wxT( "DEBUG>>" ) );
strdebug << curline;
#if DBG_LOG
if(gfp.IsOpened()) {
gfp.Write(strdebug);
gfp.Flush();
}
#else
m_observer->UpdateAddLine( strdebug );
#endif
}
}
if ( reConnectionRefused.Matches( curline ) ) {
StripString( curline );
#ifdef __WXGTK__
m_consoleFinder.FreeConsole();
#endif
m_observer->UpdateAddLine( curline );
m_observer->UpdateGotControl( DBG_EXITED_NORMALLY );
return;
}
// Check for "Operation not permitted" usually means
// that the process does not have enough permission to
// attach to the process
if( curline.Contains(wxT("Operation not permitted")) ) {
#ifdef __WXGTK__
m_consoleFinder.FreeConsole();
#endif
m_observer->UpdateAddLine( _("Failed to start debugger: permission denied") );
m_observer->UpdateGotControl( DBG_EXITED_NORMALLY );
return;
}
if( tmpline.StartsWith( wxT( ">" ) ) ) {
// Shell line, probably user command line
continue;
}
if ( curline.StartsWith( wxT( "~" ) ) || curline.StartsWith( wxT( "&" ) ) || curline.StartsWith("@") ) {
// lines starting with ~ are considered "console stream" message
// and are important to the CLI handler
bool consoleStream( false );
bool targetConsoleStream(false);
if ( curline.StartsWith( wxT( "~" ) ) ) {
consoleStream = true;
}
if ( curline.StartsWith( wxT( "@" ) ) ) {
targetConsoleStream = true;
}
// Filter out some gdb error lines...
if ( FilterMessage( curline ) ) {
continue;
}
StripString( curline );
// If we got a valid "CLI Handler" instead of writing the output to
// the output view, concatenate it into the handler buffer
if ( targetConsoleStream ) {
m_observer->UpdateAddLine( curline );
} else if ( consoleStream && GetCliHandler()) {
GetCliHandler()->Append( curline );
} else if ( consoleStream ) {
// log message
m_observer->UpdateAddLine( curline );
}
} else if ( reCommand.Matches( curline ) ) {
//not a gdb message, get the command associated with the message
wxString id = reCommand.GetMatch( curline, 1 );
if ( GetCliHandler() && GetCliHandler()->GetCommandId() == id ) {
// probably the "^done" message of the CLI command
GetCliHandler()->ProcessOutput( curline );
SetCliHandler( NULL ); // we are done processing the CLI
} else {
//strip the id from the line
curline = curline.Mid( 8 );
DoProcessAsyncCommand( curline, id );
}
} else if ( curline.StartsWith( wxT( "^done" ) ) || curline.StartsWith( wxT( "*stopped" ) ) ) {
//Unregistered command, use the default AsyncCommand handler to process the line
DbgCmdHandlerAsyncCmd cmd( m_observer, this );
cmd.ProcessOutput( curline );
} else {
//Unknow format, just log it
if( m_info.enableDebugLog && !FilterMessage( curline ) ) {
m_observer->UpdateAddLine( curline );
}
}
}
}
int OggImportFileHandle::Import(TrackFactory *trackFactory, TrackHolders &outTracks,
Tags *tags)
{
outTracks.clear();
wxASSERT(mFile->IsOpened());
CreateProgress();
//Number of streams used may be less than mVorbisFile->links,
//but this way bitstream matches array index.
mChannels.resize(mVorbisFile->links);
int i = -1;
for (auto &link: mChannels)
{
++i;
//Stream is not used
if (mStreamUsage[i] == 0)
{
//This is just a padding to keep bitstream number and
//array indices matched.
continue;
}
vorbis_info *vi = ov_info(mVorbisFile, i);
link.resize(vi->channels);
int c = - 1;
for (auto &channel : link) {
++c;
channel = trackFactory->NewWaveTrack(mFormat, vi->rate);
if (vi->channels == 2) {
switch (c) {
case 0:
channel->SetChannel(Track::LeftChannel);
channel->SetLinked(true);
break;
case 1:
channel->SetChannel(Track::RightChannel);
break;
}
}
else {
channel->SetChannel(Track::MonoChannel);
}
}
}
/* The number of bytes to get from the codec in each run */
#define CODEC_TRANSFER_SIZE 4096
/* The number of samples to read between calls to the callback.
* Balance between responsiveness of the GUI and throughput of import. */
#define SAMPLES_PER_CALLBACK 100000
short *mainBuffer = new short[CODEC_TRANSFER_SIZE];
/* determine endianness (clever trick courtesy of Nicholas Devillard,
* (http://www.eso.org/~ndevilla/endian/) */
int testvar = 1, endian;
if(*(char *)&testvar)
endian = 0; // little endian
else
endian = 1; // big endian
/* number of samples currently in each channel's buffer */
int updateResult = eProgressSuccess;
long bytesRead = 0;
long samplesRead = 0;
int bitstream = 0;
int samplesSinceLastCallback = 0;
// You would think that the stream would already be seeked to 0, and
// indeed it is if the file is legit. But I had several ogg files on
// my hard drive that have malformed headers, and this added call
// causes them to be read correctly. Otherwise they have lots of
// zeros inserted at the beginning
ov_pcm_seek(mVorbisFile, 0);
do {
/* get data from the decoder */
bytesRead = ov_read(mVorbisFile, (char *) mainBuffer,
CODEC_TRANSFER_SIZE,
endian,
2, // word length (2 for 16 bit samples)
1, // signed
&bitstream);
if (bytesRead == OV_HOLE) {
wxFileName ff(mFilename);
wxLogError(wxT("Ogg Vorbis importer: file %s is malformed, ov_read() reported a hole"),
ff.GetFullName().c_str());
/* http://lists.xiph.org/pipermail/vorbis-dev/2001-February/003223.html
* is the justification for doing this - best effort for malformed file,
* hence the message.
*/
continue;
} else if (bytesRead < 0) {
/* Malformed Ogg Vorbis file. */
/* TODO: Return some sort of meaningful error. */
wxLogError(wxT("Ogg Vorbis importer: ov_read() returned error %i"),
bytesRead);
break;
}
samplesRead = bytesRead / mVorbisFile->vi[bitstream].channels / sizeof(short);
/* give the data to the wavetracks */
auto iter = mChannels.begin();
std::advance(iter, bitstream);
if (mStreamUsage[bitstream] != 0)
{
auto iter2 = iter->begin();
for (int c = 0; c < mVorbisFile->vi[bitstream].channels; ++iter2, ++c)
iter2->get()->Append((char *)(mainBuffer + c),
int16Sample,
samplesRead,
mVorbisFile->vi[bitstream].channels);
}
samplesSinceLastCallback += samplesRead;
if (samplesSinceLastCallback > SAMPLES_PER_CALLBACK) {
updateResult = mProgress->Update(ov_time_tell(mVorbisFile),
ov_time_total(mVorbisFile, bitstream));
samplesSinceLastCallback -= SAMPLES_PER_CALLBACK;
}
} while (updateResult == eProgressSuccess && bytesRead != 0);
delete[]mainBuffer;
int res = updateResult;
if (bytesRead < 0)
res = eProgressFailed;
if (res == eProgressFailed || res == eProgressCancelled) {
return res;
}
for (auto &link : mChannels)
{
for (auto &channel : link) {
channel->Flush();
outTracks.push_back(std::move(channel));
}
}
//\todo { Extract comments from each stream? }
if (mVorbisFile->vc[0].comments > 0) {
tags->Clear();
for (int c = 0; c < mVorbisFile->vc[0].comments; c++) {
wxString comment = UTF8CTOWX(mVorbisFile->vc[0].user_comments[c]);
wxString name = comment.BeforeFirst(wxT('='));
wxString value = comment.AfterFirst(wxT('='));
if (name.Upper() == wxT("DATE") && !tags->HasTag(TAG_YEAR)) {
long val;
if (value.Length() == 4 && value.ToLong(&val)) {
name = TAG_YEAR;
}
}
tags->SetTag(name, value);
}
}
return res;
}