void SendFeedbackDialog::
replyFinished(QNetworkReply* reply)
{
QString s = reply->readAll();
TaskInfo ti("SendFeedback reply");
TaskInfo("%s", s.replace("\\r\\n","\n").replace("\r","").toStdString().c_str());
if (QNetworkReply::NoError != reply->error())
{
TaskInfo("SendFeedback error=%s (code %d)",
QNetworkReply::NoError == reply->error()?"no error":reply->errorString().toStdString().c_str(),
(int)reply->error());
}
if (QNetworkReply::NoError != reply->error())
QMessageBox::warning(dynamic_cast<QWidget*>(parent()), "Could not send feedback", reply->errorString() + "\n" + s);
else if (s.contains("sorry", Qt::CaseInsensitive) ||
s.contains("error", Qt::CaseInsensitive) ||
s.contains("fatal", Qt::CaseInsensitive) ||
s.contains("fail", Qt::CaseInsensitive) ||
s.contains("html", Qt::CaseInsensitive) ||
!s.contains("sendfeedback finished", Qt::CaseInsensitive))
{
QMessageBox::warning(dynamic_cast<QWidget*>(parent()), "Could not send feedback", s);
}
else
{
QDialog::accept();
QMessageBox::information(dynamic_cast<QWidget*>(parent()), "Feedback", "Your input has been sent. Thank you!");
ui->textEditMessage->setText ("");
ui->lineEditAttachFile->setText ("");
}
setEnabled( true );
}
void TooltipView::
draw()
{
if (!model_->comment)
return;
if (!initialized)
initialize();
//if (visible)
{
drawMarkers();
if (model_->automarking == TooltipModel::AutoMarkerWorking)
{
TaskInfo ti("TooltipView doesn't have all data yet");
std::string prev_html = model_->comment->html();
model_->showToolTip( model_->pos() );
std::string html = model_->comment->html();
if (model_->automarking != TooltipModel::AutoMarkerWorking)
TaskInfo("TooltipView just finished\n%s", html.c_str());
else if(html != prev_html)
TaskInfo("Changed tooltip\n%s", html.c_str());
render_view_->redraw();
emit tooltipChanged();
}
}
}
void printSignalInfo(int sig, bool noaction)
{
// Lots of memory allocations here. Not neat, but more helpful.
if (enable_signal_print)
TaskInfo("Got %s(%d) '%s'\n%s",
SignalName::name (sig), sig, SignalName::desc (sig),
Backtrace::make_string ().c_str());
fflush(stdout);
switch(sig)
{
#ifndef _MSC_VER
case SIGCHLD:
return;
case SIGWINCH:
TaskInfo("Got SIGWINCH");
fflush(stdout);
return;
#endif
case SIGABRT:
TaskInfo("Got SIGABRT");
fflush(stdout);
if (!noaction)
exit(1);
return;
case SIGILL:
case SIGSEGV:
if (enable_signal_print)
TaskInfo("Throwing segfault_sigill_exception");
fflush(stdout);
if (!noaction)
BOOST_THROW_EXCEPTION(segfault_sigill_exception()
<< signal_exception::signal(sig)
<< signal_exception::signalname(SignalName::name (sig))
<< signal_exception::signaldesc(SignalName::desc (sig))
<< Backtrace::make (2));
return;
default:
if (enable_signal_print)
TaskInfo("Throwing signal_exception");
fflush(stdout);
if (!noaction)
BOOST_THROW_EXCEPTION(signal_exception()
<< signal_exception::signal(sig)
<< signal_exception::signalname(SignalName::name (sig))
<< signal_exception::signaldesc(SignalName::desc (sig))
<< Backtrace::make (2));
return;
}
}
void ReadMatlabSettings::
checkIfReady()
{
bool finished = function_->hasProcessCrashed() || function_->hasProcessEnded();
string file = function_->isReady();
if (file.empty() && !finished)
{
QTimer::singleShot(100, this, SLOT(checkIfReady()));
return;
}
QByteArray ba;
if (function_->getProcess())
ba = function_->getProcess()->readAllStandardOutput();
QString s( ba );
s = s.trimmed();
if (s.isEmpty())
TaskInfo("ReadMatlabSettings %s: no output", function_->matlabFunction().c_str());
else
TaskInfo("ReadMatlabSettings %s: output: %s", function_->matlabFunction().c_str(), s.toLatin1().data());
bool success = false;
if (!file.empty()) try
{
switch (type_)
{
case MetaData_Settings:
readSettings(file);
break;
case MetaData_Source:
readSource(file);
break;
default:
EXCEPTION_ASSERT( false );
break;
}
success = true;
}
catch (const runtime_error& x)
{
TaskInfo("ReadMatlabSettings::%s %s", vartype(x).c_str(), x.what());
s += "\n";
s += vartype(x).c_str();
s += ": ";
s += x.what();
}
if (!success)
emit failed( settings.scriptname().c_str(), s );
if (deletethis_)
delete this;
}
void MappedVboVoid::
unmap(DataStorageVoid* datap)
{
if (_is_mapped)
{
TIME_MAPPEDVBOVOID TaskInfo("Unmapping vbo %u of size %s", (unsigned)*_vbo, DataStorageVoid::getMemorySizeText(datap->numberOfBytes()).c_str());
#ifdef USE_CUDA
// make sure data is located in cuda
datap->AccessStorage<CudaGlobalStorage>( true, false );
#ifdef CUDA_MEMCHECK_TEST
// copy data back over the mapped memory
*mapped_gl_mem = *datap;
#endif
// sync from cuda to vbo
cudaGLUnmapBufferObject(*_vbo);
// release resources
mapped_gl_mem.reset();
datap->DiscardAllData();
_is_mapped = false;
// The memory bound with Cuda-OpenGL-interop can be relied on. So
// call cudaGetLastError to clear the cuda error state just in case.
// (I'm not sure why but it might be related to cuda out-of-memory
// errors elsewhere)
cudaGetLastError();
#else
// make sure data is located in cpu
datap->AccessStorage<CpuMemoryStorage>( true, false );
// sync from mem to vbo
glBindBuffer(_vbo->vbo_type(), *_vbo);
glUnmapBuffer(_vbo->vbo_type());
glBindBuffer(_vbo->vbo_type(), 0);
// release resources
mapped_gl_mem.reset();
datap->DiscardAllData();
_is_mapped = false;
#endif
TIME_MAPPEDVBOVOID ComputationSynchronize();
if (_tt)
{
TaskInfo("Unmapped vbo %u of size %s", (unsigned)*_vbo, DataStorageVoid::getMemorySizeText(datap->numberOfBytes()).c_str());
delete _tt;
_tt = 0;
}
}
}
void WorkerCrashLogger::
log(const boost::exception& x)
{
// Fetch various info from the exception to make a prettier log
std::string crashed_engine_typename = "<no info>";
std::string operation_desc_text;
if( std::string const * mi = boost::get_error_info<Workers::crashed_engine_typename>(x) )
{
crashed_engine_typename = *mi;
}
if( Step::ptr const * mi = boost::get_error_info<Step::crashed_step>(x) )
{
Signal::OperationDesc::ptr od;
{
auto s = mi->write ();
s->mark_as_crashed_and_get_invalidator ();
od = Step::get_crashed (*mi);
}
if (od)
{
auto o = od.read ();
o->getInvalidator()->deprecateCache (Signal::Intervals::Intervals_ALL);
operation_desc_text = " in " + o->toString().toStdString();
}
}
if( Signal::Interval const * mi = boost::get_error_info<Task::crashed_expected_output>(x) )
{
operation_desc_text += " " + mi->toString ();
}
// Ignore logging in UnitTest
if (dynamic_cast<const DummyException*>(&x))
{
// Execute to_string for all tagged info (i.e force the slow backtrace beautifier if it's included)
boost::diagnostic_information(x);
return;
}
TaskInfo(boost::format("1 of %d workers crashed: '%s'%s")
% workers_.read ()->n_workers()
% crashed_engine_typename
% operation_desc_text);
bool send_feedback = true;
if (send_feedback)
ApplicationErrorLogController::registerException (boost::current_exception ());
else
TaskInfo(boost::format("%s") % boost::diagnostic_information(x));
}
Intervals Step::
deprecateCache(Intervals deprecated)
{
// Could remove all allocated cache memory here if the entire interval is deprecated.
// But it is highly likely that it will be required again very soon, so don't bother.
if (operation_desc_ && deprecated) {
auto o = operation_desc_.read ();
Intervals A;
for (const Interval& i : deprecated) {
A |= o->affectedInterval(i);
}
deprecated = A;
}
DEBUGINFO TaskInfo(format("Step::deprecateCache %2% | %3% on %1%")
% operation_name()
% deprecated
% not_started_);
not_started_ |= deprecated;
return deprecated;
}
pBlock GarbageCollector::
runOnce(unsigned frame_counter)
{
size_t free_memory = availableMemoryForSingleAllocation();
BlockCache::cache_t cacheCopy = cache_->clone();
size_t allocatedMemory = BlockCacheInfo::cacheByteSize (cacheCopy);
if (allocatedMemory < free_memory*MAX_FRACTION_FOR_CACHES)
return pBlock(); // No need to release memory
pBlock releasedBlock = getOldestBlock(frame_counter, cacheCopy, 2);
if (!releasedBlock)
return pBlock(); // Nothing to release
Heightmap::Block::pGlBlock glblock = releasedBlock->glblock;
size_t blockMemory = glblock
? glblock->allocated_bytes_per_element() * releasedBlock->block_layout().texels_per_block ()
: 0;
if (true)
TaskInfo(format("Removing block %s last used %u frames ago. Freeing %s, total free %s, cache %s, %u blocks")
% releasedBlock->getRegion ()
% (frame_counter - releasedBlock->frame_number_last_used)
% DataStorageVoid::getMemorySizeText( blockMemory )
% DataStorageVoid::getMemorySizeText( free_memory )
% DataStorageVoid::getMemorySizeText( allocatedMemory )
% cacheCopy.size()
);
return releasedBlock;
}
void Vbo::
init(size_t size, unsigned vbo_type, unsigned access_pattern, void* data)
{
TIME_VBO TaskTimer tt("Vbo::init(%s, %u, %u, %p)",
DataStorageVoid::getMemorySizeText(_sz).c_str(), vbo_type, access_pattern, data);
GlException_CHECK_ERROR();
clear();
GlException_CHECK_ERROR();
// create buffer object
glGenBuffers(1, &_vbo);
glBindBuffer(vbo_type, _vbo);
glBufferData(vbo_type, size, data, access_pattern);
glBindBuffer(vbo_type, 0);
TIME_VBO TaskInfo("Got vbo %u", _vbo) ;
GlException_CHECK_ERROR();
_sz = size;
_vbo_type = vbo_type;
}
void Worker::
loop_while_tasks()
{
while (!QThread::currentThread ()->isInterruptionRequested ())
{
Task task;
{
DEBUGINFO TaskTimer tt(boost::format("worker: get task %s %s") % vartype(*schedule_.get ()) % (computing_engine_?vartype(*computing_engine_):"(null)") );
task = schedule_->getTask(computing_engine_);
}
if (task)
{
DEBUGINFO TaskTimer tt(boost::format("worker: running task %s") % task.expected_output());
task.run();
emit oneTaskDone();
}
else
{
DEBUGINFO TaskInfo("worker: back to sleep");
// Wait for a new wakeup call
break;
}
}
}
void Worker::
finished()
{
DEBUGINFO TaskInfo("worker: finished");
moveToThread (0); // important. otherwise 'thread_' will try to delete 'this', but 'this' owns 'thread_' -> crash.
emit finished(*exception_.read (), computing_engine_);
}
void Worker::
wakeup()
{
if (QThread::currentThread () != this->thread ())
{
// Dispatch
QMetaObject::invokeMethod (this, "wakeup");
return;
}
DEBUGINFO TaskInfo("worker: wakeup");
try
{
// Let exception_ mark unexpected termination.
*exception_.write () = terminated_exception_;
loop_while_tasks();
// Finished normal execution without any exception.
*exception_.write () = std::exception_ptr();
}
catch (...)
{
*exception_.write () = std::current_exception ();
QThread::currentThread ()->requestInterruption ();
}
if (QThread::currentThread ()->isInterruptionRequested ())
{
QThread::currentThread ()->quit ();
}
}
void QtEventWorkerFactory::
test()
{
std::string name = "QtEventWorkers";
int argc = 1;
char * argv = &name[0];
QApplication a(argc,&argv); // takes 0.4 s if this is the first instantiation of QApplication
Workers::test ([](ISchedule::ptr schedule){
Bedroom::ptr bedroom(new Bedroom);
return IWorkerFactory::ptr(new QtEventWorkerFactory(schedule, bedroom));
});
{
UNITTEST_STEPS TaskInfo("It should terminate all threads when it's closed");
ISchedule::ptr schedule[] = {
ISchedule::ptr(new SleepScheduleMock),
ISchedule::ptr(new LockScheduleMock),
ISchedule::ptr(new BusyScheduleMock)
};
for (unsigned i=0; i<sizeof(schedule)/sizeof(schedule[0]); i++) {
Timer t;
{
ISchedule::ptr s = schedule[i];
//TaskInfo ti(boost::format("%s") % vartype(*s));
Bedroom::ptr bedroom(new Bedroom);
Processing::Workers workers(IWorkerFactory::ptr(new QtEventWorkerFactory(s, bedroom)));
Bedroom::Bed bed = dynamic_cast<BlockScheduleMock*>(s.get ())->bedroom.getBed();
workers.addComputingEngine(Signal::ComputingEngine::ptr());
// Wait until the schedule has been called (Bedroom supports
// that the wakeup in schedule is called even before this sleep call
// as long as 'bed' is allocated before the wakeup call)
bed.sleep ();
EXCEPTION_ASSERT_EQUALS(false, workers.remove_all_engines (10));
EXCEPTION_ASSERT_EQUALS(true, QtEventWorkerFactory::terminate_workers (workers, 0));
EXCEPTION_ASSERT_EQUALS(workers.n_workers(), 0u);
EXPECT_EXCEPTION(QtEventWorker::TerminatedException, workers.rethrow_any_worker_exception ());
workers.clean_dead_workers ();
}
float elapsed = t.elapsed ();
float n = (i+1)*0.00001;
EXCEPTION_ASSERT_LESS(0.01+n, elapsed);
EXCEPTION_ASSERT_LESS(elapsed, 0.04+n); // +n makes it possible to see in the test log which iteration that failed
}
}
// It should wake up sleeping workers when any work is done to see if they can
// help out on what's left.
{
}
}
void BedroomSignalAdapter::
run ()
{
Bedroom::Bed bed = bedroom_->getBed();
while (!stop_flag_) {
DEBUGINFO TaskInfo("BedroomSignalAdapter wakeup");
emit wakeup();
try {
bed.sleep ();
} catch (const BedroomClosed&) {
stop_flag_ = true;
}
}
DEBUGINFO TaskInfo("BedroomSignalAdapter finished");
}
WriteWav::
WriteWav( std::string filename )
: _filename(filename),
_normalize(false)
{
TaskInfo("WriteWav %s", _filename.c_str());
reset();
}
RenderBlock::Renderer::~Renderer()
{
try {
RenderBlock::endVboRendering();
} catch (...) {
TaskInfo(boost::format("!!! ~RenderBlock::Renderer: endVboRendering failed\n%s") % boost::current_exception_diagnostic_information());
}
}
Worker::
~Worker ()
{
abort ();
wait (1); // To quit the thread normally if idle (returns within 1 ms if it is ready to quit)
terminate ();
if (!wait (100))
TaskInfo("Worker didn't respond to quitting");
}
void IMasterTask::NotifyResult(TaskCompletion result)
{
if (config.pCallback)
{
config.pCallback->OnComplete(result);
}
pApplication->OnTaskComplete(TaskInfo(this->GetTaskType(), result, config.taskId));
}
void ExportAudioDialog::
exportSelection()
{
if (0 == project->tools().selection_model.current_selection().get())
{
TaskInfo("ExportAudio::exportSelection without selection");
}
Signal::pOperation selection = project->tools().selection_model.current_selection_copy( SelectionModel::SaveInside_TRUE );
start(selection);
}
virtual Task getTask(Signal::ComputingEngine::ptr) const override {
if (DetectGdb::was_started_through_gdb ())
BOOST_THROW_EXCEPTION(segfault_sigill_exception());
// Causing deliberate segfault to test that the worker handles it correctly
// The test verifies that it works to instantiate a TaskInfo works
TaskInfo("testing instantiated TaskInfo");
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wnull-dereference"
*(int*)0 = 0; // cause segfault
#pragma clang diagnostic pop
// unreachable code
return Task();
}
bool QtEventWorkerFactory::
terminate_workers(Processing::Workers& workers, int timeout)
{
TIME_TERMINATE TaskTimer ti("terminate_workers");
workers.remove_all_engines(timeout);
TIME_TERMINATE TaskInfo("terminate");
for (auto& i: workers.workers_map()) {
WorkerWrapper* w = dynamic_cast<WorkerWrapper*>(i.second.get());
if (w)
w->terminate ();
}
return workers.wait(1000);
}
void PrettifySegfault::
test()
{
// Skip test if running through gdb
if (DetectGdb::is_running_through_gdb() || DetectGdb::was_started_through_gdb ()) {
TaskInfo("Running through debugger, skipping PrettifySegfault test");
return;
}
// It should attempt to capture any null-pointer exception (SIGSEGV and
// SIGILL) in the program, log a backtrace, and then throw a regular C++
// exception from the location causing the signal.
{
enable_signal_print = false;
// In order for the EXPECT_EXCEPTION macro to catch the exception the call
// must not be inlined as the function causing the signal will first return and
// then throw the exception.
#ifdef _DEBUG
EXPECT_EXCEPTION(segfault_sigill_exception, throw_catchable_segfault_exception());
EXPECT_EXCEPTION(segfault_sigill_exception, throw_catchable_segfault_exception2());
EXPECT_EXCEPTION(segfault_sigill_exception, throw_catchable_segfault_exception3());
EXPECT_EXCEPTION(segfault_sigill_exception, throw_catchable_segfault_exception4());
EXPECT_EXCEPTION(segfault_sigill_exception, throw_catchable_segfault_exception5());
#else
EXPECT_EXCEPTION(segfault_sigill_exception, throw_catchable_segfault_exception_noinline());
EXPECT_EXCEPTION(segfault_sigill_exception, throw_catchable_segfault_exception2_noinline());
EXPECT_EXCEPTION(segfault_sigill_exception, throw_catchable_segfault_exception3_noinline());
EXPECT_EXCEPTION(segfault_sigill_exception, throw_catchable_segfault_exception4_noinline());
EXPECT_EXCEPTION(segfault_sigill_exception, throw_catchable_segfault_exception5_noinline());
#endif
enable_signal_print = true;
}
// It returns immediately from the signalling function without unwinding
// that scope and thus break the RAII assumption that a destructor will
// always be called (does not apply in windows)
{
EXCEPTION_ASSERT(breaks_RAII_assumptions::constructor_was_called);
#ifndef _MSC_VER
EXCEPTION_ASSERT(!breaks_RAII_assumptions::destructor_was_called);
breaks_RAII_assumptions(); // This calls the destructor
#endif
EXCEPTION_ASSERT(breaks_RAII_assumptions::destructor_was_called);
}
}
void WriteWav::
put( Signal::pBuffer buffer )
{
TIME_WRITEWAV TaskTimer tt("WriteWav::put %s", buffer->getInterval().toString().c_str());
// Make sure that all of buffer is expected
if (buffer->getInterval() - _invalid_samples)
{
Signal::Interval expected = (buffer->getInterval() & _invalid_samples).spannedInterval();
EXCEPTION_ASSERT( expected );
buffer = Signal::BufferSource(buffer).readFixedLength( expected );
}
if (!_sndfile)
{
const int format=SF_FORMAT_WAV | SF_FORMAT_PCM_16;
_sndfile.reset(new SndfileHandle(_filename, SFM_WRITE, format, buffer->number_of_channels (), buffer->sample_rate()));
if (!*_sndfile)
{
TaskInfo("ERROR: WriteWav(%s) libsndfile couldn't create a file for %u channels and sample rate %f",
_filename.c_str(), buffer->number_of_channels (), buffer->sample_rate());
return;
}
}
_invalid_samples -= buffer->getInterval();
buffer->sample_offset();
appendBuffer(buffer);
if (!_invalid_samples)
{
_sndfile.reset();
if (_normalize)
rewriteNormalized();
}
}
VOID
ti(
IN HANDLE CurrentProcess,
IN HANDLE CurrentThread,
IN DWORD CurrentPc,
IN PWINDBG_EXTENSION_APIS ExtensionApis,
IN LPSTR ArgumentString
)
/*++
Routine Description:
Arguments:
CurrentProcess -- Supplies a handle to the current process
CurrentThread -- Supplies a handle to the current thread
CurrentPc -- Supplies the current program counter. (may be meaningless)
ExtensionApis -- Supplies pointers to ntsd support routines
ArgumentString -- Supplies the arguments passed to the command
Return Value:
None.
--*/
{
UNREFERENCED_PARAMETER(CurrentPc);
hCurrentProcess = CurrentProcess;
hCurrentThread = CurrentThread;
lpArgumentString = ArgumentString;
SETUP_WINDBG_POINTERS(ExtensionApis);
TaskInfo();
}
void GraphicsScene::
drawBackground(QPainter *painter, const QRectF & rectf)
{
if (!painter->device())
return;
double T = last_frame_.elapsedAndRestart();
TIME_PAINTGL TaskTimer tt("GraphicsScene: Draw, last frame %.0f ms / %.0f fps", T*1e3, 1/T);
if (update_timer_->isActive ())
TaskInfo("GraphicsScene: Forced redraw");
painter->beginNativePainting();
try { {
GlException_CHECK_ERROR();
renderview_->initializeGL();
float dpr = painter->device ()->devicePixelRatio();
renderview_->model->render_settings.dpifactor = dpr;
unsigned w = painter->device()->width();
unsigned h = painter->device()->height();
w *= dpr;
h *= dpr;
renderview_->setStates();
{
TIME_PAINTGL_DETAILS TaskTimer tt("glClear");
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
QRect rect = QRectF(rectf.topLeft(), QSizeF(rectf.width ()-1, rectf.height ()-1)).toRect ();
// QRect rect = tool_selector->parentTool()->geometry();
rect.setWidth (rect.width ()*dpr);
rect.setHeight (rect.height ()*dpr);
rect.setLeft (rect.left ()*dpr);
rect.setTop (rect.top ()*dpr);
renderview_->resizeGL( rect, QSize(w,h) );
// This changes state. Shouldn't be a part of rendering.
renderview_->model->recompute_extent ();
renderview_->paintGL();
renderview_->defaultStates();
glFlush();
}
GlException_CHECK_ERROR();
} catch (const std::exception& x) {
TaskInfo("");
TaskInfo(boost::format("std::exception\n%s") % boost::diagnostic_information(x));
TaskInfo("");
} catch (...) {
TaskInfo(boost::format("Not an std::exception\n%s") % boost::current_exception_diagnostic_information ());
}
painter->endNativePainting();
if (0 < draw_more_)
draw_more_--;
if (0 < draw_more_)
update_timer_->start(5);
}
void ChainInfo::
test()
{
std::string name = "ChainInfo";
int argc = 1;
char * argv = &name[0];
QApplication a(argc,&argv);
// It should provide info about the running state of a signal processing chain
{
Chain::ptr cp = Chain::createDefaultChain ();
ChainInfo c(cp);
EXCEPTION_ASSERT( !c.hasWork () );
EXCEPTION_ASSERT_EQUALS( QThread::idealThreadCount () + 1, c.n_workers () );
EXCEPTION_ASSERT_EQUALS( 0, c.dead_workers () );
}
Signal::OperationDesc::ptr transparent(new Test::TransparentOperationDesc);
Signal::OperationDesc::ptr buffersource(new Signal::BufferSource(Test::RandomBuffer::smallBuffer ()));
// It should say that there is no work if a step has crashed (no crash).
{
UNITTEST_STEPS TaskInfo("It should say that there is no work if a step has crashed (no crash)");
Chain::ptr cp = Chain::createDefaultChain ();
ChainInfo c(cp);
TargetMarker::ptr at = cp.write ()->addTarget(transparent);
TargetNeeds::ptr n = at->target_needs();
cp.write ()->addOperationAt(buffersource,at);
EXCEPTION_ASSERT( !c.hasWork () );
n->updateNeeds(Signal::Interval(0,10));
EXCEPTION_ASSERT( c.hasWork () );
QThread::msleep (10);
EXCEPTION_ASSERT( !c.hasWork () );
EXCEPTION_ASSERT_EQUALS( 0, c.dead_workers () );
}
// It should say that there is no work if a step has crashed (requiredIntervalCrash).
{
UNITTEST_STEPS TaskInfo("It should say that there is no work if a step has crashed (requiredIntervalCrash)");
Chain::ptr cp = Chain::createDefaultChain ();
ChainInfo c(cp);
TargetMarker::ptr at = cp.write ()->addTarget(Signal::OperationDesc::ptr(new RequiredIntervalCrash));
TargetNeeds::ptr n = at->target_needs();
cp.write ()->addOperationAt(buffersource,at);
EXCEPTION_ASSERT( !c.hasWork () );
EXCEPTION_ASSERT_EQUALS( 0, c.dead_workers () );
n->updateNeeds(Signal::Interval(0,10));
EXCEPTION_ASSERT( n->sleep (12) );
EXCEPTION_ASSERT( !c.hasWork () );
QThread::msleep (1);
EXCEPTION_ASSERT_EQUALS( 1, c.dead_workers () );
}
// It should say that there is no work if a step has crashed (process).
{
UNITTEST_STEPS TaskInfo("It should say that there is no work if a step has crashed (process)");
Chain::ptr cp = Chain::createDefaultChain ();
ChainInfo c(cp);
TargetMarker::ptr at = cp.write ()->addTarget(Signal::OperationDesc::ptr(new ProcessCrashOperationDesc));
TargetNeeds::ptr n = at->target_needs();
cp.write ()->addOperationAt(buffersource,at);
EXCEPTION_ASSERT( !c.hasWork () );
n->updateNeeds(Signal::Interval(0,10));
EXCEPTION_ASSERT( c.hasWork () );
QThread::msleep (10);
a.processEvents (); // a crashed worker announces 'wakeup' to the others through the application eventloop
EXCEPTION_ASSERT( n->sleep (10) );
EXCEPTION_ASSERT( !c.hasWork () );
EXCEPTION_ASSERT_EQUALS( 1, c.dead_workers () );
}
}
LONG WINAPI MyUnhandledExceptionFilter(
_In_ struct _EXCEPTION_POINTERS *ExceptionInfo
)
{
DWORD code = ExceptionInfo->ExceptionRecord->ExceptionCode;
if (enable_signal_print)
TaskInfo("Caught UnhandledException %s(0x%x) %s", ExceptionCodeName(code), code, ExceptionCodeDescription(code));
// Translate from Windows Structured Exception to C signal.
//C signals known in Windows:
// http://msdn.microsoft.com/en-us/library/xdkz3x12(v=vs.110).aspx
//#define SIGINT 2 /* interrupt */
//#define SIGILL 4 /* illegal instruction - invalid function image */
//#define SIGFPE 8 /* floating point exception */
//#define SIGSEGV 11 /* segment violation */
//#define SIGTERM 15 /* Software termination signal from kill */
//#define SIGBREAK 21 /* Ctrl-Break sequence */
//#define SIGABRT 22 /* abnormal termination triggered by abort call */
//#define SIGABRT_COMPAT 6 /* SIGABRT compatible with other platforms, same as SIGABRT */
// http://msdn.microsoft.com/en-us/library/windows/desktop/aa363082(v=vs.85).aspx
int sig=0;
switch (ExceptionInfo->ExceptionRecord->ExceptionCode)
{
case EXCEPTION_ACCESS_VIOLATION:
case EXCEPTION_DATATYPE_MISALIGNMENT:
case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
case EXCEPTION_PRIV_INSTRUCTION:
case EXCEPTION_IN_PAGE_ERROR:
case EXCEPTION_NONCONTINUABLE_EXCEPTION:
case EXCEPTION_STACK_OVERFLOW:
case EXCEPTION_INVALID_DISPOSITION:
case EXCEPTION_GUARD_PAGE:
case EXCEPTION_INVALID_HANDLE:
#ifdef STATUS_POSSIBLE_DEADLOCK
case EXCEPTION_POSSIBLE_DEADLOCK:
#endif
case CONTROL_C_EXIT:
sig = SIGSEGV;
break;
case EXCEPTION_ILLEGAL_INSTRUCTION:
sig = SIGILL;
break;
case EXCEPTION_FLT_DENORMAL_OPERAND:
case EXCEPTION_FLT_DIVIDE_BY_ZERO:
case EXCEPTION_FLT_INEXACT_RESULT:
case EXCEPTION_FLT_INVALID_OPERATION:
case EXCEPTION_FLT_OVERFLOW:
case EXCEPTION_FLT_STACK_CHECK:
case EXCEPTION_FLT_UNDERFLOW:
case EXCEPTION_INT_DIVIDE_BY_ZERO:
case EXCEPTION_INT_OVERFLOW:
sig = SIGFPE;
break;
case EXCEPTION_BREAKPOINT:
case EXCEPTION_SINGLE_STEP:
default:
break;
}
if (sig) {
fflush(stdout);
fflush(stderr);
if (enable_signal_print)
Backtrace::malloc_free_log ();
printSignalInfo(sig, false);
// unreachable, printSignalInfo throws a C++ exception for SIGFPE, SIGSEGV and SIGILL
}
// carry on with default exception handling
return EXCEPTION_CONTINUE_SEARCH;
}
void Application::
execute_command_line_options()
{
string message = Sawe::Configuration::parseCommandLineMessage();
if (!message.empty())
{
cerr << message << endl // Want output in logfile
<< Sawe::Configuration::commandLineUsageString();
this->rs.reset();
cerr << message << endl // Want output in console window, if any
<< Sawe::Configuration::commandLineUsageString();
QErrorMessage::qtHandler()->showMessage( QString::fromStdString( message ) );
::exit(1);
//mb.setWindowModality( Qt::ApplicationModal );
//mb.show();
return;
}
Sawe::pProject p; // p will be owned by Application and released before a.exec()
if (!Sawe::Configuration::input_file().empty())
p = Sawe::Application::slotOpen_file( Sawe::Configuration::input_file() );
if (!p)
p = Sawe::Application::slotNew_recording( );
if (!p)
::exit(3);
Tools::RenderModel& render_model = p->tools().render_model;
auto td = render_model.transform_descs ().write ();
Tfr::Cwt& cwt = td->getParam<Tfr::Cwt>();
//Signal::pOperation source = render_model.renderSignalTarget->post_sink()->source();
Signal::OperationDesc::Extent extent = p->processing_chain()->extent(p->default_target ());
Signal::IntervalType number_of_samples = extent.interval.get_value_or (Signal::Interval());
float sample_rate = extent.sample_rate.get_value_or (1);
unsigned samples_per_chunk_hint = Sawe::Configuration::samples_per_chunk_hint();
unsigned total_samples_per_chunk = cwt.prev_good_size( 1<<samples_per_chunk_hint, sample_rate );
bool sawe_exit = false;
unsigned get_csv = Sawe::Configuration::get_csv();
if (get_csv != (unsigned)-1) {
if (0==number_of_samples) {
Sawe::Application::display_fatal_exception(std::invalid_argument("Can't extract CSV without input file."));
::exit(4);
}
Tfr::ChunkFilterDesc::ptr cfd(new Adapters::CsvDesc(QString("sonicawe-%1.csv").arg(get_csv).toStdString()));
Signal::OperationDesc::ptr o(new Tfr::TransformOperationDesc(cfd));
Signal::Processing::TargetMarker::ptr t = p->processing_chain ()->addTargetBefore(o, p->default_target ());
Signal::Processing::TargetNeeds::ptr needs = t->target_needs ();
Signal::Interval I( get_csv*total_samples_per_chunk, (get_csv+1)*total_samples_per_chunk );
needs->updateNeeds (I);
needs->sleep(-1);
TaskInfo("Samples per chunk = %u", total_samples_per_chunk);
sawe_exit = true;
}
unsigned get_hdf = Sawe::Configuration::get_hdf();
if (get_hdf != (unsigned)-1) {
if (0==number_of_samples) {
Sawe::Application::display_fatal_exception(std::invalid_argument("Can't extract HDF without input file."));
::exit(5);
}
Tfr::ChunkFilterDesc::ptr cfd(new Adapters::Hdf5ChunkDesc(QString("sonicawe-%1.h5").arg(get_hdf).toStdString()));
Signal::OperationDesc::ptr o(new Tfr::TransformOperationDesc(cfd));
Signal::Processing::TargetMarker::ptr t = p->processing_chain ()->addTargetBefore(o, p->default_target ());
Signal::Processing::TargetNeeds::ptr needs = t->target_needs ();
Signal::Interval I( get_hdf*total_samples_per_chunk, (get_hdf+1)*total_samples_per_chunk );
needs->updateNeeds (I);
needs->sleep(-1);
TaskInfo("Samples per chunk = %u", total_samples_per_chunk);
sawe_exit = true;
}
if (Sawe::Configuration::get_chunk_count()) {
TaskInfo("number of samples = %u", number_of_samples);
TaskInfo("samples per chunk = %u", total_samples_per_chunk);
TaskInfo("chunk count = %u", (number_of_samples + total_samples_per_chunk-1) / total_samples_per_chunk);
this->rs.reset();
cout << "number_of_samples = " << number_of_samples << endl
<< "samples_per_chunk = " << total_samples_per_chunk << endl
<< "chunk_count = " << (number_of_samples + total_samples_per_chunk-1) / total_samples_per_chunk << endl;
sawe_exit = true;
}
if (sawe_exit)
{
::exit(0);
}
else
{
// Ensures that an OpenGL context is created
if( !QGLContext::currentContext() )
QMessageBox::information(0,"Sonic AWE", "Sonic AWE couldn't start");
}
}
ExportAudioDialog::~ExportAudioDialog()
{
TaskInfo("~ExportAudioDialog");
delete ui;
}
void WriteWav::
rewriteNormalized()
{
_sndfile.reset();
std::string tempfilename;
{
QTemporaryFile tempname("XXXXXX.wav");
tempname.open();
tempfilename = tempname.fileName().toStdString();
}
bool renamestatus = QFile::rename( _filename.c_str(), tempfilename.c_str() );
TaskInfo ti("renaming '%s' to '%s': %s",
_filename.c_str(), tempfilename.c_str(),
renamestatus?"success":"failed");
if (!renamestatus)
return;
try
{
SndfileHandle inputfile(tempfilename);
if (!inputfile || 0 == inputfile.frames())
{
TaskInfo("ERROR: Couldn't read from %s", tempfilename.c_str());
return;
}
SndfileHandle outputfile(_filename, SFM_WRITE, inputfile.format(), inputfile.channels(), inputfile.samplerate());
if (!outputfile)
{
TaskInfo("ERROR: Couldn't write to %s", _filename.c_str());
return;
}
long double mean = _sum/_sumsamples;
// -1 + 2*(v - low)/(high-low);
// -1 + (v - low)/std::max(_high-mean, mean-_low)
long double k = std::max(_high-mean, mean-_low);
float affine_s = 1/k;
float affine_d = -1 - _low/k;
if (!_normalize)
{
affine_d = mean;
affine_s = k;
}
// when sndfile converts float to 16-bit integers it doesn't bother with rounding to nearest. Adding an offset in advance accomodates for that.
affine_d += 1.f/(1<<16);
sf_count_t frames = inputfile.frames();
TaskInfo ti2("rewriting %u frames", (unsigned)frames);
int num_channels = inputfile.channels();
size_t frames_per_buffer = (4 << 20)/sizeof(float)/num_channels; // 4 MB buffer
std::vector<float> buffer(num_channels * frames_per_buffer);
float* p = &buffer[0];
while (true)
{
sf_count_t items_read = inputfile.read(p, buffer.size());
if (0 == items_read)
break;
for (int x=0; x<items_read; ++x)
p[x] = affine_d + affine_s*p[x];
outputfile.write(p, items_read );
}
} catch (...) {
QFile::remove(tempfilename.c_str());
throw;
}
QFile::remove(tempfilename.c_str());
}
