void MHmgphy::SolveSystem( vector<double> &X, int nTr )
{
fflush( stdout );
clock_t t0 = StartTiming();
#if 0
HmgphyFromHmgphy( X, nTr );
#else
vector<double> Xin;
AFromTbl( Xin, nTr );
clock_t t2 = StartTiming();
OnePassTH( _OnePass_HFromA, X, Xin, nTr*8, 16, 0.9 );
printf( "Just HfromA\n" );
PrintMagnitude( X );
fflush( stdout );
for( gpass = 0; gpass < 2000; ++gpass ) { // 1000 - 2000 good
Xin = X;
OnePassTH( _OnePass_HFromH, X, Xin, nTr*8, 16, 0.9 );
printf( "Done pass %d\n", gpass + 1 ); fflush( stdout );
}
PrintMagnitude( X );
StopTiming( stdout, "Iters", t2 );
fflush( stdout );
myc.clear();
#endif
StopTiming( stdout, "SolveH", t0 );
}
// _______________________________________________________________________________________
//
void CAAudioFile::WritePacketsFromCallback(
AudioConverterComplexInputDataProc inInputDataProc,
void * inInputDataProcUserData)
{
while (true) {
// keep writing until we exhaust the input (temporary stop), or produce no output (EOF)
UInt32 numEncodedPackets = mIOBufferSizePackets;
mIOBufferList.mBuffers[0].mDataByteSize = mIOBufferSizeBytes;
#if CAAUDIOFILE_PROFILE
mInConverter = true;
#endif
StartTiming(this, fill);
OSStatus err = AudioConverterFillComplexBuffer(mConverter, inInputDataProc, inInputDataProcUserData,
&numEncodedPackets, &mIOBufferList, mPacketDescs);
ElapsedTime(this, fill, mTicksInConverter);
#if CAAUDIOFILE_PROFILE
mInConverter = false;
#endif
XThrowIf(err != 0 && err != kNoMoreInputRightNow, err, "convert audio packets (write)");
if (numEncodedPackets == 0)
break;
Byte *buf = (Byte *)mIOBufferList.mBuffers[0].mData;
#if VERBOSE_IO
printf("CAAudioFile::WritePacketsFromCallback: wrote %ld packets, %ld bytes\n", numEncodedPackets, mIOBufferList.mBuffers[0].mDataByteSize);
if (mPacketDescs) {
for (UInt32 i = 0; i < numEncodedPackets; ++i) {
printf(" write packet %qd : offset %qd, length %ld\n", mPacketMark + i, mPacketDescs[i].mStartOffset, mPacketDescs[i].mDataByteSize);
#if VERBOSE_IO >= 2
hexdump(buf + mPacketDescs[i].mStartOffset, mPacketDescs[i].mDataByteSize);
#endif
}
}
#endif
StartTiming(this, write);
XThrowIfError(AudioFileWritePackets(mAudioFile, mUseCache, mIOBufferList.mBuffers[0].mDataByteSize, mPacketDescs, mPacketMark, &numEncodedPackets, buf), "write audio file");
ElapsedTime(this, write, mTicksInIO);
mPacketMark += numEncodedPackets;
//mNumberPackets += numEncodedPackets;
if (mFileDataFormat.mFramesPerPacket > 0)
mFrameMark += numEncodedPackets * mFileDataFormat.mFramesPerPacket;
else {
for (UInt32 i = 0; i < numEncodedPackets; ++i)
mFrameMark += mPacketDescs[i].mVariableFramesInPacket;
}
if (err == kNoMoreInputRightNow)
break;
}
}
// _______________________________________________________________________________________
//
void CAAudioFile::Write(UInt32 numPackets, const AudioBufferList *data)
{
if (mIOBufferList.mBuffers[0].mData == NULL) {
#if DEBUG
printf("warning: CAAudioFile::AllocateBuffers called from WritePackets\n");
#endif
AllocateBuffers();
}
if (mMode == kPreparingToWrite)
mMode = kWriting;
else
XThrowIf(mMode != kWriting, kExtAudioFileError_InvalidOperationOrder, "can't write to this file");
if (mConverter != NULL) {
mWritePackets = numPackets;
mWriteBufferList->SetFrom(data);
WritePacketsFromCallback(WriteInputProc, this);
} else {
StartTiming(this, write);
XThrowIfError(AudioFileWritePackets(mAudioFile, mUseCache, data->mBuffers[0].mDataByteSize,
NULL, mPacketMark, &numPackets, data->mBuffers[0].mData),
"write audio file");
ElapsedTime(this, write, mTicksInIO);
#if VERBOSE_IO
printf("CAAudioFile::WritePackets: wrote %ld packets at %qd, %ld bytes\n", numPackets, mPacketMark, data->mBuffers[0].mDataByteSize);
#endif
//mNumberPackets =
mPacketMark += numPackets;
if (mFileDataFormat.mFramesPerPacket > 0)
mFrameMark += numPackets * mFileDataFormat.mFramesPerPacket;
// else: shouldn't happen since we're only called when there's no converter
}
}
inline
double RunTestImpl ( const char* title, void (*pfn)(), char* histogramFileName = no_histogram ) {
double time = 0, variation = 0, deviation = 0;
size_t nrep = 1;
while (true) {
CalibrateTiming(NRUNS, 1, nrep);
StartTiming(NRUNS, 1, nrep);
pfn();
StopTiming(time, variation, deviation);
time -= util::base;
if ( time > 1e-6 )
break;
nrep *= 2;
}
nrep *= (size_t)ceil(ONE_TEST_DURATION/time);
CalibrateTiming(NRUNS, 1, nrep); // sets util::base
util::durations_t t;
StartTimingEx(t, NRUNS, 1, nrep);
pfn();
StopTiming(time, variation, deviation);
if ( histogramFileName != (char*)-1 )
util::trace_histogram(t, histogramFileName);
double clean_time = time - util::base;
if ( title ) {
// Deviation (in percent) is calulated for the Gross time
printf ("\n%-34s %.2e %5.1f ", title, clean_time, deviation);
if ( util::sequential_time != 0 )
//printf ("% .2e ", clean_time - util::sequential_time);
printf ("% 10.1f ", 100*(clean_time - util::sequential_time)/util::sequential_time);
else
printf ("%*s ", util::rate_field_len, "");
printf ("%-9u %1.6f |", (unsigned)nrep, time * nrep);
}
return clean_time;
}
static void *GenericThread(void *a) {
RunArgs * args = reinterpret_cast< RunArgs * > (a);
unsigned int threadOps = GetOperationCountPerThread();
_startBarrier->Join();
if (args->id == 0) {
StartTiming();
}
_runBarrier->Join();
if (threadOps == 0) {
while (!isDone()) {
args->op_routine(args->id, args->arg, args->randSeed);
threadOps++;
}
} else {
for (unsigned int j = 0; j < threadOps; j++) {
args->op_routine(args->id, args->arg, args->randSeed);
}
}
CompletedOperations(threadOps);
_runBarrier->Join();
return NULL;
}
double MIDASTimer::Start() {
double current = GetTime();
base_time = 0.0;
StartTiming();
running = true;
return current;
}
int main( int argc, char* argv[] )
{
clock_t t0 = StartTiming();
/* ------------------ */
/* Parse command line */
/* ------------------ */
gArgs.SetCmdLine( argc, argv );
TS.SetLogFile( flog );
if( !ReadScriptParams( scr, gArgs.script, flog ) )
goto exit;
inv_scl = 1.0 / scr.crossscale;
/* ---------------- */
/* Read source data */
/* ---------------- */
if( gArgs.zb >= 0 && gArgs.za < 0 )
gArgs.za = gArgs.zb;
TS.FillFromRgns( gArgs.srcmons, gArgs.idb, gArgs.zb, gArgs.za );
fprintf( flog, "Got %d images.\n", (int)TS.vtil.size() );
if( !TS.vtil.size() )
goto exit;
TS.SetTileDimsFromImageFile();
TS.GetTileDims( gW, gH );
t0 = StopTiming( flog, "ReadFile", t0 );
/* ------------- */
/* Sort by layer */
/* ------------- */
TS.SortAll_z();
/* ----- */
/* Stuff */
/* ----- */
ScapeStuff();
/* ---- */
/* Done */
/* ---- */
exit:
fprintf( flog, "\n" );
VMStats( flog );
fclose( flog );
return 0;
}
double MIDASTimer::Resume() {
if (running) return GetTime();
else {
running = true;
StartTiming();
return base_time;
}
}
void BossTimeOut::Fallingstone()
{
FallingStone* stone = FallingStone::create();
stone->setTag(20150924);
stone->setPosition(randPos());
UIController::getInstance()->getPhysicsLayer()->addChild(stone);
StartTiming();
}
void BossTimeOut::Fallingstone()
{
//³å´Ì²»µôÂä
bool isSpeedUp = GameData::getInstance()->getisSpeedUp();
if (isSpeedUp)
{
unschedule(schedule_selector(BossTimeOut::speedUp));
return;
}
FallingStone* stone = FallingStone::create();
stone->setPosition(randPos());
UIController::getInstance()->getPhysicsLayer()->addChild(stone);
StartTiming();
}
double GetSeconds()
{
if ( RecipCyclesPerSecond < 0.0f ) { StartTiming(); }
#ifndef ANDROID
LARGE_INTEGER T1;
#else
int64_t T1;
#endif
QueryPerformanceCounter( &T1 );
#ifndef ANDROID
return RecipCyclesPerSecond * ( double )( T1.QuadPart );
#else
return RecipCyclesPerSecond * ( double )( T1 );
#endif
}
/**
* The run method is used internally to actually run the commands.
* @return whether or not the command should stay within the {@link Scheduler}.
*/
bool Command::Run()
{
if (!m_runWhenDisabled && m_parent == NULL && DriverStation::GetInstance()->IsDisabled())
Cancel();
if (IsCanceled())
return false;
if (!m_initialized)
{
m_initialized = true;
StartTiming();
_Initialize();
Initialize();
}
_Execute();
Execute();
return !IsFinished();
}
// _______________________________________________________________________________________
//
void CAAudioFile::Read(UInt32 &ioNumPackets, AudioBufferList *ioData)
// May read fewer packets than requested if:
// buffer is not big enough
// file does not contain that many more packets
// Note that eofErr is not fatal, just results in 0 packets returned
// ioData's buffer sizes may be shortened
{
XThrowIf(mClientMaxPacketSize == 0, kExtAudioFileError_MaxPacketSizeUnknown, "client maximum packet size is 0");
if (mIOBufferList.mBuffers[0].mData == NULL) {
#if DEBUG
printf("warning: CAAudioFile::AllocateBuffers called from ReadPackets\n");
#endif
AllocateBuffers();
}
UInt32 bufferSizeBytes = ioData->mBuffers[0].mDataByteSize;
UInt32 maxNumPackets = bufferSizeBytes / mClientMaxPacketSize;
// older versions of AudioConverterFillComplexBuffer don't do this, so do our own sanity check
UInt32 nPackets = std::min(ioNumPackets, maxNumPackets);
mMaxPacketsToRead = ~0UL;
if (mClientDataFormat.mFramesPerPacket == 1) { // PCM or equivalent
while (mFramesToSkipFollowingSeek > 0) {
UInt32 skipFrames = std::min(mFramesToSkipFollowingSeek, maxNumPackets);
UInt32 framesPerPacket;
if ((framesPerPacket=mFileDataFormat.mFramesPerPacket) > 0)
mMaxPacketsToRead = (skipFrames + framesPerPacket - 1) / framesPerPacket;
if (mConverter == NULL) {
XThrowIfError(ReadInputProc(NULL, &skipFrames, ioData, NULL, this), "read audio file");
} else {
#if CAAUDIOFILE_PROFILE
mInConverter = true;
#endif
StartTiming(this, fill);
XThrowIfError(AudioConverterFillComplexBuffer(mConverter, ReadInputProc, this, &skipFrames, ioData, NULL), "convert audio packets (pcm read)");
ElapsedTime(this, fill, mTicksInConverter);
#if CAAUDIOFILE_PROFILE
mInConverter = false;
#endif
}
if (skipFrames == 0) { // hit EOF
ioNumPackets = 0;
return;
}
mFrameMark += skipFrames;
#if VERBOSE_IO
printf("CAAudioFile::ReadPackets: skipped %ld frames\n", skipFrames);
#endif
mFramesToSkipFollowingSeek -= skipFrames;
// restore mDataByteSize
for (int i = ioData->mNumberBuffers; --i >= 0 ; )
ioData->mBuffers[i].mDataByteSize = bufferSizeBytes;
}
}
if (mFileDataFormat.mFramesPerPacket > 0)
// don't read more packets than we are being asked to produce
mMaxPacketsToRead = nPackets / mFileDataFormat.mFramesPerPacket + 1;
if (mConverter == NULL) {
XThrowIfError(ReadInputProc(NULL, &nPackets, ioData, NULL, this), "read audio file");
} else {
#if CAAUDIOFILE_PROFILE
mInConverter = true;
#endif
StartTiming(this, fill);
XThrowIfError(AudioConverterFillComplexBuffer(mConverter, ReadInputProc, this, &nPackets, ioData, NULL), "convert audio packets (read)");
ElapsedTime(this, fill, mTicksInConverter);
#if CAAUDIOFILE_PROFILE
mInConverter = false;
#endif
}
if (mClientDataFormat.mFramesPerPacket == 1)
mFrameMark += nPackets;
ioNumPackets = nPackets;
}
void BossTimeOut::TimeOut()
{
schedule(schedule_selector(BossTimeOut::speedUp),0.25f);
StartTiming();
}
void CDecPerformanceForm::OnStartClick()
{
StartTiming();
}
static void Init(const std::string & system, int & argc, char ** &argv)
// Call this first thing in your program. It will parse the standard
// commandline options and remove them from the argv.
{
assert(argc >= 1);
std::vector<char*> leftOvers;
leftOvers.push_back(argv[0]);
if (argc < 2) {
std::cerr << "Standard harness options : " << argv[0] << " " << _usage << "\n";
exit(1);
}
_name = argv[1];
_system = system;
bool durationSet = false;
int i=2;
while(i < argc) {
if (!strcmp(argv[i], "-tc"))
_threadCount = atoi(argv[++i]);
else if (!strcmp(argv[i], "-foot"))
_footPrintB = atoll(argv[++i])*1024*1024;
else if (!strcmp(argv[i], "-footMB"))
_footPrintB = atoll(argv[++i])*1024*1024;
else if (!strcmp(argv[i], "-footKB"))
_footPrintB = atoll(argv[++i])*1024;
else if (!strcmp(argv[i], "-footB"))
_footPrintB = atoll(argv[++i]);
else if (!strcmp(argv[i], "-rt")) {
durationSet = true;
_runTimeSeconds = atoi(argv[++i]);
} else if (!strcmp(argv[i], "-max")) {
durationSet = true;
_opCountSet = true;
_operationCount = atoi(argv[++i]);
} else if (!strcmp(argv[i], "-file"))
_file = argv[++i];
else if (!strcmp(argv[i], "-reload"))
_reload = true;
else if (!strcmp(argv[i], "-create"))
_create = true;
else if (!strcmp(argv[i], "-hang"))
_hang = true;
else if (!strcmp(argv[i], "-nondet"))
srand(time(NULL));
else {
leftOvers.push_back(argv[i]);
}
i++;
}
if (_footPrintB == 0) {
std::cerr << "Footprint must be specified\n";
std::cerr << argv[0] << _usage << "\n";
exit(-1);
}
if (!durationSet) {
std::cerr << "-rt or -max must be specified\n";
std::cerr << argv[0] << _usage << "\n";
exit(-1);
}
if (_runTimeSeconds > 0 && _operationCount > 0) {
std::cerr << "only one of -rt or -max\n";
std::cerr << argv[0] << _usage << "\n";
exit(-1);
}
if (_create && _reload) {
std::cerr << "Either -create or -reload may be specified, but not both\n";
std::cerr << argv[0] << _usage << "\n";
exit(-1);
}
_operationsPerThread = _operationCount/_threadCount;
_startTime = GetNow();
argc = leftOvers.size();
for(unsigned int i = 0; i< leftOvers.size(); i++) {
argv[i] = leftOvers[i];
}
argv[leftOvers.size()] = NULL;
struct sigaction act;
bzero(&act, sizeof(act));
act.sa_handler = GracefulExit;
sigaction(SIGINT, &act, NULL);
StartTiming();
}
int main( int argc, char **argv )
{
clock_t t0 = StartTiming();
/* ---------- */
/* Parameters */
/* ---------- */
MPIInit( argc, argv );
if( !gArgs.SetCmdLine( argc, argv ) ||
!gArgs.GetRanges() ) {
MPIExit();
exit( 42 );
}
/* ------------ */
/* Initial data */
/* ------------ */
if( !LayerCat( vL, gArgs.tempdir, gArgs.cachedir,
gArgs.zolo, gArgs.zohi, false ) ) {
MPIExit();
exit( 42 );
}
InitTables( gArgs.zilo, gArgs.zihi );
{
CLoadPoints *LP = new CLoadPoints;
LP->Load( gArgs.tempdir, gArgs.cachedir );
delete LP;
}
/* ----- */
/* Solve */
/* ----- */
printf( "\n---- Solve ----\n" );
SetSolveParams( gArgs.regtype, gArgs.Wr, gArgs.Etol );
XArray Xevn, Xodd;
if( !strcmp( gArgs.mode, "A2A" ) ) {
Xevn.Load( gArgs.prior );
if( gArgs.untwist )
UntwistAffines( Xevn );
Xodd.Resize( 6 );
Solve( Xevn, Xodd, gArgs.iters );
}
else if( !strcmp( gArgs.mode, "A2H" ) ) {
Xevn.Resize( 8 );
{ // limit A lifetime
XArray *A = new XArray;
A->Load( gArgs.prior );
if( gArgs.untwist )
UntwistAffines( *A );
Solve( *A, Xevn, 1 );
delete A;
}
Xodd.Resize( 8 );
Solve( Xevn, Xodd, gArgs.iters );
}
else if( !strcmp( gArgs.mode, "H2H" ) ) {
Xevn.Load( gArgs.prior );
Xodd.Resize( 8 );
Solve( Xevn, Xodd, gArgs.iters );
}
else if( !strcmp( gArgs.mode, "eval" ) ) {
Xevn.Load( gArgs.prior );
if( gArgs.untwist )
UntwistAffines( Xevn );
gArgs.iters = 0;
}
else { // split
Xevn.Load( gArgs.prior );
gArgs.iters = 0;
}
const XArray& Xfinal = ((gArgs.iters & 1) ? Xodd : Xevn);
/* ----------- */
/* Postprocess */
/* ----------- */
if( gArgs.mode[0] == 's' ) {
Split S( Xfinal, gArgs.splitmin );
S.Run();
}
else {
Evaluate( Xfinal );
if( gArgs.mode[0] != 'e' )
Xfinal.Save();
}
/* ------- */
/* Cleanup */
/* ------- */
if( !wkid ) {
printf( "\n" );
StopTiming( stdout, "Lsq", t0 );
}
MPIExit();
VMStats( stdout );
return 0;
}
// The strip alignment from S.DenovoBestAngle (followed by SetXY)
// produces a transform A->B = best.T for the scaled down scapes.
// Here's how to convert that to a transform between the original
// montages:
//
// Recapitulate total process...
// TAffine Rbi, Ra, t;
//
// Scale back up
// best.T.MulXY( scr.crossscale );
// A.x0 *= scr.crossscale;
// A.y0 *= scr.crossscale;
// B.x0 *= scr.crossscale;
// B.y0 *= scr.crossscale;
//
// A-montage -> A-oriented
// Ra.NUSetRot( A.deg*PI/180 );
//
// A-oriented -> A-scape
// Ra.AddXY( -A.x0, -A.y0 );
//
// A-scape -> B-scape
// t = best.T * Ra;
//
// B-scape -> B-oriented
// t.AddXY( B.x0, B.y0 );
//
// B-oriented -> B-montage
// Rbi.NUSetRot( -B.deg*PI/180 );
// best.T = Rbi * t;
//
static void ScapeStuff()
{
clock_t t0 = StartTiming();
CSuperscape A, B;
ThmRec thm;
CThmScan S;
CorRec best;
B.FindLayerIndices( gArgs.zb );
B.OrientLayer();
if( gArgs.ismb ) {
char buf[256];
B.MakeWholeRaster();
sprintf( buf, "montages/M_%d_0.png", gArgs.zb );
B.DrawRas( buf );
B.KillRas();
B.WriteMeta( 'M', gArgs.zb );
t0 = StopTiming( flog, "MakeMontage", t0 );
}
if( !gArgs.isab )
return;
A.FindLayerIndices( gArgs.za );
A.OrientLayer();
MakeStripRasters( A, B );
t0 = StopTiming( flog, "MakeStrips", t0 );
A.MakePoints( thm.av, thm.ap );
A.WriteMeta( 'A', gArgs.za );
B.MakePoints( thm.bv, thm.bp );
B.WriteMeta( 'B', gArgs.zb );
thm.ftc.clear();
thm.reqArea = int(gW * gH * inv_scl * inv_scl);
thm.olap1D = int(gW * inv_scl * 0.5);
thm.scl = 1;
S.Initialize( flog, best );
S.SetRThresh( scr.stripmincorr );
S.SetNbMaxHt( 0.99 );
S.SetSweepConstXY( false );
S.SetSweepPretweak( true );
S.SetSweepNThreads( scr.stripslots );
S.SetUseCorrR( true );
S.SetNewAngProc( NewAngProc );
gA = &A;
gB = &B;
gS = &S;
if( gArgs.abdbg ) {
//S.RFromAngle( best, gArgs.abctr, thm );
//S.Pretweaks( best.R, gArgs.abctr, thm );
dbgCor = true;
S.RFromAngle( best, gArgs.abctr, thm );
}
else {
if( scr.stripsweepspan && scr.stripsweepstep ) {
S.DenovoBestAngle( best,
0, scr.stripsweepspan / 2, scr.stripsweepstep,
thm, true );
}
else {
best.A = 0;
S.PeakHunt( best, 0, thm );
}
best.T.Apply_R_Part( A.Opts );
best.X += B.Opts.x - A.Opts.x;
best.Y += B.Opts.y - A.Opts.y;
best.T.SetXY( best.X, best.Y );
fprintf( flog, "*T: [0,1,2,3,4,5] (strip-strip)\n" );
fprintf( flog, "[%f,%f,%f,%f,%f,%f]\n",
best.T.t[0], best.T.t[1], best.T.t[2],
best.T.t[3], best.T.t[4], best.T.t[5] );
}
t0 = StopTiming( flog, "Corr", t0 );
}
// _______________________________________________________________________________________
//
OSStatus CAAudioFile::ReadInputProc( AudioConverterRef inAudioConverter,
UInt32* ioNumberDataPackets,
AudioBufferList* ioData,
AudioStreamPacketDescription** outDataPacketDescription,
void* inUserData)
{
CAAudioFile *This = static_cast<CAAudioFile *>(inUserData);
#if 0
SInt64 remainingPacketsInFile = This->mNumberPackets - This->mPacketMark;
if (remainingPacketsInFile <= 0) {
*ioNumberDataPackets = 0;
ioData->mBuffers[0].mDataByteSize = 0;
if (outDataPacketDescription)
*outDataPacketDescription = This->mPacketDescs;
#if VERBOSE_IO
printf("CAAudioFile::ReadInputProc: EOF\n");
#endif
return noErr; // not eofErr; EOF is signified by 0 packets/0 bytes
}
#endif
// determine how much to read
AudioBufferList *readBuffer;
UInt32 readPackets;
if (inAudioConverter != NULL) {
// getting called from converter, need to use our I/O buffer
readBuffer = &This->mIOBufferList;
readPackets = This->mIOBufferSizePackets;
} else {
// getting called directly from ReadPackets, use supplied buffer
if (This->mFileMaxPacketSize == 0)
return kExtAudioFileError_MaxPacketSizeUnknown;
readBuffer = ioData;
readPackets = std::min(*ioNumberDataPackets, readBuffer->mBuffers[0].mDataByteSize / This->mFileMaxPacketSize);
// don't attempt to read more packets than will fit in the buffer
}
// don't try to read past EOF
// if (readPackets > remainingPacketsInFile)
// readPackets = remainingPacketsInFile;
// don't read more packets than necessary to produce the requested amount of converted data
if (readPackets > This->mMaxPacketsToRead) {
#if VERBOSE_IO
printf("CAAudioFile::ReadInputProc: limiting read to %ld packets (from %ld)\n", This->mMaxPacketsToRead, readPackets);
#endif
readPackets = This->mMaxPacketsToRead;
}
// read
UInt32 bytesRead;
OSStatus err;
StartTiming(This, read);
StartTiming(This, readinconv);
err = AudioFileReadPackets(This->mAudioFile, This->mUseCache, &bytesRead, This->mPacketDescs, This->mPacketMark, &readPackets, readBuffer->mBuffers[0].mData);
#if CAAUDIOFILE_PROFILE
if (This->mInConverter) ElapsedTime(This, readinconv, This->mTicksInReadInConverter);
#endif
ElapsedTime(This, read, This->mTicksInIO);
if (err) {
DebugMessageN1("Error %ld from AudioFileReadPackets!!!\n", err);
return err;
}
#if VERBOSE_IO
printf("CAAudioFile::ReadInputProc: read %ld packets (%qd-%qd), %ld bytes, err %ld\n", readPackets, This->mPacketMark, This->mPacketMark + readPackets, bytesRead, err);
#if VERBOSE_IO >= 2
if (This->mPacketDescs) {
for (UInt32 i = 0; i < readPackets; ++i) {
printf(" read packet %qd : offset %qd, length %ld\n", This->mPacketMark + i, This->mPacketDescs[i].mStartOffset, This->mPacketDescs[i].mDataByteSize);
}
}
printf(" read buffer:"); CAShowAudioBufferList(readBuffer, 0, 4);
#endif
#endif
if (readPackets == 0) {
*ioNumberDataPackets = 0;
ioData->mBuffers[0].mDataByteSize = 0;
return noErr;
}
if (outDataPacketDescription)
*outDataPacketDescription = This->mPacketDescs;
ioData->mBuffers[0].mDataByteSize = bytesRead;
ioData->mBuffers[0].mData = readBuffer->mBuffers[0].mData;
This->mPacketMark += readPackets;
if (This->mClientDataFormat.mFramesPerPacket != 1) { // for PCM client formats we update in Read
// but for non-PCM client format (weird case) we must update here/now
if (This->mFileDataFormat.mFramesPerPacket > 0)
This->mFrameMark += readPackets * This->mFileDataFormat.mFramesPerPacket;
else {
for (UInt32 i = 0; i < readPackets; ++i)
This->mFrameMark += This->mPacketDescs[i].mVariableFramesInPacket;
}
}
*ioNumberDataPackets = readPackets;
return noErr;
}
bool PixPair::Load(
const char *apath,
const char *bpath,
int order,
int bDoG,
int r1,
int r2,
FILE* flog )
{
printf( "\n---- Image loading ----\n" );
clock_t t0 = StartTiming();
/* ----------------------------- */
/* Load and sanity check rasters */
/* ----------------------------- */
uint8 *aras, *bras;
uint32 wa, ha, wb, hb;
int ok = false;
aras = Raster8FromAny( apath, wa, ha, flog );
bras = Raster8FromAny( bpath, wb, hb, flog );
if( !aras || !bras ) {
fprintf( flog,
"PixPair: Picture load failure.\n" );
goto exit;
}
if( wa != wb || ha != hb ) {
fprintf( flog,
"PixPair: Nonmatching picture dimensions.\n" );
goto exit;
}
ok = true;
wf = wa;
hf = ha;
ws = wa;
hs = ha;
scl = 1;
/* -------------- */
/* Resin removal? */
/* -------------- */
//if( dbgCor ) {
// ZeroResin( "bloba.tif", aras );
// ZeroResin( "blobb.tif", bras );
//}
//else {
// ZeroResin( NULL, aras );
// ZeroResin( NULL, bras );
//}
//StopTiming( flog, "Resin removal", t0 );
/* ------- */
/* Flatten */
/* ------- */
LegPolyFlatten( _avf, aras, wf, hf, order );
RasterFree( aras );
LegPolyFlatten( _bvf, bras, wf, hf, order );
RasterFree( bras );
avs_vfy = avs_aln = avf_vfy = avf_aln = &_avf;
bvs_vfy = bvs_aln = bvf_vfy = bvf_aln = &_bvf;
/* ------------- */
/* Apply filters */
/* ------------- */
//{
// vector<CD> kfft;
// double K[] = {
// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
// 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
// Convolve( _avf, _avf, wf, hf, K, 11, 11, true, true, kfft );
// Normalize( _avf );
// Convolve( _bvf, _bvf, wf, hf, K, 11, 11, true, true, kfft );
// Normalize( _bvf );
//}
#if 0
{
vector<CD> kfft;
double K[] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
Convolve( _avfflt, _avf, wf, hf, K, 11, 11, true, true, kfft );
Normalize( _avfflt );
Convolve( _bvfflt, _bvf, wf, hf, K, 11, 11, true, true, kfft );
Normalize( _bvfflt );
avs_aln = avf_aln = &_avfflt;
bvs_aln = bvf_aln = &_bvfflt;
bDoG = true;
}
#endif
if( bDoG ) {
vector<double> DoG;
vector<CD> kfft;
int dim = MakeDoGKernel( DoG, r1, r2, flog );
Convolve( _avfflt, _avf, wf, hf,
&DoG[0], dim, dim, true, true, kfft );
Normalize( _avfflt );
Convolve( _bvfflt, _bvf, wf, hf,
&DoG[0], dim, dim, true, true, kfft );
Normalize( _bvfflt );
avs_aln = avf_aln = &_avfflt;
bvs_aln = bvf_aln = &_bvfflt;
}
/* --------------------- */
/* Downsample all images */
/* --------------------- */
if( ws > 2048 || hs >= 2048 ) {
do {
ws /= 2;
hs /= 2;
scl *= 2;
} while( ws > 2048 || hs > 2048 );
fprintf( flog, "PixPair: Scaling by %d\n", scl );
if( ws * scl != wf || hs * scl != hf ) {
fprintf( flog,
"PixPair: Dimensions not multiple of scale!\n" );
goto exit;
}
Downsample( _avs, _avf );
Downsample( _bvs, _bvf );
avs_vfy = avs_aln = &_avs;
bvs_vfy = bvs_aln = &_bvs;
if( bDoG ) {
if( _avfflt.size() ) {
Downsample( _avsflt, _avfflt );
avs_aln = &_avsflt;
}
if( _bvfflt.size() ) {
Downsample( _bvsflt, _bvfflt );
bvs_aln = &_bvsflt;
}
}
}
else
fprintf( flog, "PixPair: Using image scale=1.\n" );
/* ------------------------------ */
/* Write DoG images for debugging */
/* ------------------------------ */
#if 0
if( bDoG ) {
VectorDblToTif8( "DoGa.tif", avs_aln, ws, hs );
VectorDblToTif8( "DoGb.tif", bvs_aln, ws, hs );
}
#endif
/* -------- */
/* Clean up */
/* -------- */
exit:
if( aras )
RasterFree( aras );
if( bras )
RasterFree( bras );
StopTiming( flog, "Image conditioning", t0 );
return ok;
}
