void MeshBufferReader::setMeshPyramid()
{
TICK("setupMeshBufferRendering");
visibilityMaskPyramid.resize(m_nNumMeshLevels);
outputInfoPyramid.resize(m_nNumMeshLevels);
outputPropPyramid.resize(m_nNumMeshLevels);
for(int i = 0; i < m_nNumMeshLevels; ++i)
{
int numVertices = currentMeshPyramid.levels[i].numVertices;
visibilityMaskPyramid[i].resize(numVertices,true);
vector<CoordinateType> proj2D;
proj2D.resize(2); proj2D[0] = 0; proj2D[1] = 0;
outputInfoPyramid[i].meshData = std::move(currentMeshPyramid.levels[i]);
// outputInfoPyramid[i].meshDataGT = currentMeshPyramid.levels[i];
// outputInfoPyramid[i].meshDataColorDiff = currentMeshPyramid.levels[i];
outputInfoPyramid[i].nRenderLevel = i;
outputInfoPyramid[i].meshProj.resize(numVertices, proj2D);
// outputInfoPyramid[i].meshProjGT = outputInfoPyramid[i].meshProj;
outputInfoPyramid[i].visibilityMask.resize(numVertices, true);
memset(outputInfoPyramid[i].camPose, 0, 6*sizeof(double));
UpdateRenderingData(outputInfoPyramid[i], KK, camPose, outputInfoPyramid[i].meshData);
//////////////////////////// outputPropPyramid
if(meshLoadingSettings.loadProp)
{
outputPropPyramid[i].meshData = std::move(propMeshPyramid.levels[i]);
// outputPropPyramid[i].meshDataGT = propMeshPyramid.levels[i];
// outputPropPyramid[i].meshDataColorDiff = propMeshPyramid.levels[i];
outputPropPyramid[i].nRenderLevel = i;
outputPropPyramid[i].meshProj.resize(numVertices, proj2D);
// outputPropPyramid[i].meshProjGT = outputPropPyramid[i].meshProj;
outputPropPyramid[i].visibilityMask.resize(numVertices, true);
memset(outputPropPyramid[i].camPose, 0, 6*sizeof(double));
UpdateRenderingData(outputPropPyramid[i], KK, camPose, outputPropPyramid[i].meshData);
}
// update the visibility of each vertex
if(useVisibilityMask)
{
TICK( "visibilityMask" + std::to_string(i) );
UpdateVisibilityMaskGL(outputInfoPyramid[i], visibilityMaskPyramid[i], KK, camPose, m_nWidth, m_nHeight);
if(meshLoadingSettings.loadProp)
UpdateVisibilityMaskGL(outputPropPyramid[i], visibilityMaskPyramid[i], KK, camPose, m_nWidth, m_nHeight);
TOCK( "visibilityMask" + std::to_string(i) );
}
}
TOCK("setupMeshBufferRendering");
}
bool MainEngine::ProcessOneFrame(int nFrame)
{
// read input
// if(!GetInput(nFrame))
// return false;
// if(inputThreadGroup.size() > 0){
// inputThreadGroup.join_all();
// memcpy(m_pColorImageRGB, m_pColorImageRGBBuffer, m_nWidth * m_nHeight * 3);
// inputThreadGroup.remove_thread(pInputThread);
// pInputThread = inputThreadGroup.create_thread( boost::bind(&MainEngine::GetInput, this, nFrame) );
// }
// // for the first frame, we have to wait
// else{
// pInputThread = inputThreadGroup.create_thread( boost::bind(&MainEngine::GetInput, this, nFrame) );
// inputThreadGroup.join_all();
// memcpy(m_pColorImageRGB, m_pColorImageRGBBuffer, m_nWidth * m_nHeight * 3);
// }
TICK("timePerFrame");
TICK("getInput");
if(pInputThread == NULL)
{
pInputThread = new boost::thread(boost::bind(&MainEngine::GetInput, this, nFrame));
pInputThread->join();
memcpy(m_pColorImageRGB, m_pColorImageRGBBuffer, m_nWidth * m_nHeight * 3);
}
else
{
pInputThread->join();
memcpy(m_pColorImageRGB, m_pColorImageRGBBuffer, m_nWidth * m_nHeight * 3);
delete pInputThread;
pInputThread = new boost::thread(boost::bind(&MainEngine::GetInput, this, nFrame));
}
TOCK("getInput");
if(!inputFlag)
{
cout << "getting input failure" << endl;
return false;
}
// do tracking
TICK("tracking");
if(!m_pTrackingEngine->trackFrame(nFrame, m_pColorImageRGB, &pOutputInfo))
{
cout << "tracking failed: " << endl;
return false;
}
TOCK("tracking");
TOCK("timePerFrame");
return true;
}
inline static int pfile_write_unlocked(int fd, lsn_t off, const byte *dat,
lsn_t len) {
int error = 0;
ssize_t bytes_written = 0;
TICK(write_hist);
while (bytes_written < len) {
ssize_t count = pwrite(fd,
dat + bytes_written,
len - bytes_written,
off + bytes_written);
if (count == -1) {
if (errno == EAGAIN || errno == EINTR) {
// @see file.c for an explanation; basically; we ignore these,
// and try again.
count = 0;
} else {
if (errno == EBADF) {
error = EBADF;
} else {
error = errno;
}
break;
}
}
bytes_written += count;
if (bytes_written != len) {
DEBUG("pwrite spinning\n");
}
}
TOCK(write_hist);
return error;
}
MeshPyramidReader::MeshPyramidReader(MeshLoadingSettings& settings, int width,
int height, double K[3][3], int startFrame, int numTrackingFrames): trackerInitialized(false)
{
m_nWidth = width;
m_nHeight = height;
startFrameNo = startFrame;
currentFrameNo = startFrame;
pCurrentColorImageRGB = new unsigned char[3*width*height];
// in this case camPose will always be zero
for(int i = 0; i < 6; ++i)
camPose[i] = 0;
useVisibilityMask = settings.visibilityMask;
setIntrinsicMatrix(K);
TICK("loadingMesh");
currentMeshPyramid = std::move(PangaeaMeshPyramid(settings.meshPath,
settings.meshLevelFormat, currentFrameNo, settings.meshLevelList));
if(settings.loadProp)
{
propMeshPyramid = std::move(PangaeaMeshPyramid(settings.meshPath,
settings.propLevelFormat, currentFrameNo, settings.meshLevelList));
}
TOCK("loadingMesh");
m_nNumMeshLevels = settings.meshLevelList.size();
}
static long unimplementedos(long d0)
{
long retval;
switch(d0)
{
case 0x77: /* CountADBs */
case 0x78: /* GetIndADB */
case 0x79: /* GetADBInfo */
case 0x7A: /* SetADBInfo */
case 0x7B: /* ADBReInit */
case 0x7C: /* ADBOp */
case 0x3D: /* DrvrInstall */
case 0x3E: /* DrvrRemove */
case 0x4F: /* RDrvrInstall */
retval = 1;
break;
case 0x8B: /* Communications Toolbox */
retval = ROMlib_creator == TICK("KR09"); /* kermit */
break;
default:
retval = 0;
break;
}
return retval;
}
static void
wheel_handler (game_time t, void *client_data)
{
int wheel_crash;
wheel_crash = (wheel_x<car_x && wheel_y==LINES-5 && ground2[wheel_x]==' ');
if (wheel_x < car_x) mvwaddch (moon, wheel_y, wheel_x, ' ');
wheel_x -= 1;
switch (car_x - wheel_x) {
case 1:
case 5:
case 7:
case 8:
case 9:
wheel_y = LINES - 6;
break;
case 2:
case 3:
case 4:
wheel_y = LINES - 7;
break;
default:
wheel_y = LINES - 5;
break;
}
if (wheel_x >= 0 && ! wheel_crash) {
mvwaddch (moon, wheel_y, wheel_x, 'o');
add_event (t+TICK(2.3), wheel_handler, NULL);
} else {
crash_detected = 1000;
}
wnoutrefresh (moon);
}
void run_benchmarks(void) {
int asizes[] = {2, 5, 10, 30, 500};
int i, j;
yatrie_t trie = (yatrie_t)NULL;
int set_time = 0; int get_time = 0;
BENCHMARK_INIT();
for (i = 0; i < 5; i++) {
int array_size = asizes[i];
/* Contiguous keys */
TICK();
for (j = 0; j < array_size; j++)
trie = yatrie_insert(trie, j, j);
TOCK();
set_time += benchmark_total_time * 500 / array_size;
TICK();
for (j = 0; j < array_size; j++)
yatrie_get(trie, j);
TOCK();
get_time += benchmark_total_time * 500 / array_size;
yatrie_free(trie); trie = (yatrie_t)NULL;
/* Uniform keys */
srand(1234567);
TICK();
for (j = 0; j < array_size; j++)
trie = yatrie_insert(trie, rand(), j);
TOCK();
set_time += benchmark_total_time * 500 / array_size;
TICK();
for (j = 0; j < array_size; j++)
yatrie_get(trie, rand());
TOCK();
get_time += benchmark_total_time * 500 / array_size;
yatrie_free(trie); trie = (yatrie_t)NULL;
}
printf("%i %i\n", get_time, set_time);
}
PUBLIC void
PutScrapX (LONGINT type, LONGINT length, char *p, int scrap_count)
{
static int old_count = -1;
if (OpenClipboard (cygwin_sdlwindow ()) &&
(scrap_count == old_count || EmptyClipboard ()))
{
UINT format;
int new_length;
HANDLE data;
new_length = calc_length_and_format (&format, type, length, p);
data = GlobalAlloc (GMEM_MOVEABLE|GMEM_DDESHARE, new_length);
if (type == TICK ("PICT"))
{
if (clip_data)
LocalFree (clip_data);
clip_data = LocalAlloc (LMEM_FIXED, new_length);
}
if (data)
{
char *destp;
destp = GlobalLock (data);
fill_in_data (destp, type, length, p);
GlobalUnlock (data);
SetClipboardData (format, data);
if (type == TICK ("PICT"))
{
fill_in_data ((char *) clip_data, type, length, p);
SetClipboardData (CF_DIB, NULL); /* we can create a DIB if
asked to do so */
}
CloseClipboard ();
old_count = scrap_count;
}
}
}
static int pfile_read(stasis_handle_t *h, lsn_t off, byte *buf, lsn_t len) {
pfile_impl *impl = (pfile_impl*)(h->impl);
int error = 0;
if (off < 0) {
error = EDOM;
} else {
ssize_t bytes_read = 0;
TICK(read_hist);
while (bytes_read < len) {
ssize_t count = pread(impl->fd,
buf + bytes_read,
len - bytes_read,
off + bytes_read);
if (count == -1) {
if (errno == EAGAIN || errno == EINTR) {
count = 0;
} else {
if (errno == EBADF) {
h->error = EBADF;
} else {
int err = errno;
// The other errors either involve memory bugs (EFAULT), logic bugs
// (EISDIR, EFIFO, EOVERFLOW), or bad hardware (EIO), so print
// something to console, and uncleanly crash.
perror("pfile_read encountered an unknown error code.");
fprintf(stderr, "pread() returned -1; errno is %d\n",err);
abort();
}
error = errno;
break;
}
} else if(count == 0) {
// EOF
if(bytes_read != 0) {
fprintf(stderr, "short read at end of storefile. Assuming that this is due to strange recovery scenario, and continuing.\n");
}
error = EDOM;
break;
} else {
bytes_read += count;
if (bytes_read != len) {
DEBUG("pread spinning\n");
}
}
}
TOCK(read_hist);
assert(error || bytes_read == len);
}
return error;
}
void MeshSequenceReader::trackerUpdate(TrackerOutputInfo& outputInfo)
{
TICK("visualRenderingUpdate");
UpdateRenderingData(outputInfo, KK, camPose, currentMesh);
UpdateRenderingDataFast(outputInfo, KK, currentMesh);
if(useVisibilityMask)
{
UpdateVisibilityMaskGL(outputInfo, visibilityMask, KK, camPose, m_nWidth, m_nHeight);
//UpdateVisibilityMask(outputInfo, visibilityMask, m_nWidth, m_nHeight);
UpdateColorDiff(outputInfo, visibilityMask, colorImageSplit);
}
TOCK("visualRenderingUpdate");
}
void
fire_laser (double t)
{
struct beam *b;
if (! beam_table.data) DA_INIT (beam_table, struct beam *);
b = xmalloc (sizeof (struct beam));
b->state = bs_START;
b->count = 40;
b->left = car_x-8;
b->right = car_x;
b->y = car_y;
DA_ADD (beam_table, struct beam *, b);
add_event (t+TICK(0.25), beam_handler, b);
adjust_score (-1);
}
void ExtendedTrack::fill(Dict *d) const{
Track::fill(d);
d->SetValueAndShowSection("NOTES", notes, "HAS_NOTES");
d->SetValueAndShowSection("LICENSE", license, "HAS_LICENSE");
d->ShowSection(airable ? "IS_AIRABLE" : "NOT_AIRABLE");
// Tags
if(!tags.empty()){
d->ShowSection("HAS_TAGS");
for(std::vector<std::string>::const_iterator i=tags.begin(); i!=tags.end(); i++)
d->SetValueAndShowSection("TAG", *i, "TAG");
}
// License
d->SetValue("LICENSE", license);
d->ShowSection(license == "Copyright" ? "COPYRIGHT" : "OTHER_LICENSE");
TICK("CC BY", "CC_BY");
else TICK("CC BY-NC", "CC_BY_NC");
PUBLIC Ptr
ROMlib_kchr_ptr (void)
{
if (!kchr_ptr)
{
ZONE_SAVE_EXCURSION
(SysZone,
{
Handle kchr_hand;
kchr_hand = GetResource (TICK ("KCHR"), kchr_id);
gui_assert (kchr_hand);
LoadResource (kchr_hand);
HLock (kchr_hand);
kchr_ptr = STARH (kchr_hand);
});
bool MeshSequenceReader::setCurrentFrame(int curFrame)
{
if(currentFrameNo != curFrame)
{
currentFrameNo = curFrame;
// changing new frame time
TICK("setCurrentFrame");
if(!loadMesh(meshLoadingSettings.meshPath,
meshLoadingSettings.meshFormat,currentFrameNo))
return false;
TOCK("setCurrentFrame");
}
return true;
}
int main(int argc, char *argv[])
{
float *u = new float[N];
float *v = new float[N];
float alpha = 2.3;
double time4=0;
initializeVectors(u,v);
TICK();
axpyGPU(u,v,alpha,N);
TOCK(time4);
outputStats(time4);
delete [] u;
delete [] v;
}
bool MeshPyramidReader::setCurrentFrame(int curFrame)
{
if(currentFrameNo != curFrame)
{
currentFrameNo = curFrame;
TICK("setCurrentFrame");
if(!loadMeshPyramid(meshLoadingSettings.meshPath,
meshLoadingSettings.meshLevelFormat, currentFrameNo,
meshLoadingSettings.meshLevelList))
return false;
TOCK("setCurrentFrame");
}
return true;
}
static int pfile_force_range(stasis_handle_t *h, lsn_t start, lsn_t stop) {
TICK(force_range_hist);
pfile_impl * impl = h->impl;
#ifdef HAVE_SYNC_FILE_RANGE
// stop of zero syncs to eof.
DEBUG("pfile_force_range calling sync_file_range %lld %lld\n",
start, stop-start); fflush(stdout);
int ret = sync_file_range(impl->fd, start, stop-start,
SYNC_FILE_RANGE_WAIT_BEFORE |
SYNC_FILE_RANGE_WRITE |
SYNC_FILE_RANGE_WAIT_AFTER);
if(ret) {
int error = errno;
assert(ret == -1);
// With the possible exceptions of ENOMEM and ENOSPACE, all of the sync
// errors are unrecoverable.
h->error = EBADF;
ret = error;
}
#else
#ifdef HAVE_FDATASYNC
DEBUG("pfile_force_range() is calling fdatasync()\n");
fdatasync(impl->fd);
#else
DEBUG("pfile_force_range() is calling fsync()\n");
fsync(impl->fd);
#endif
int ret = 0;
#endif
#ifdef HAVE_POSIX_FADVISE
if(impl->sequential) {
int err = posix_fadvise(impl->fd, start, stop-start, POSIX_FADV_DONTNEED);
if(err) perror("Attempt to pass POSIX_FADV_SEQUENTIAL (for a range of a file) to kernel failed");
}
#endif
TOCK(force_range_hist);
return ret;
}
static int pfile_force(stasis_handle_t *h) {
TICK(force_hist);
pfile_impl *impl = h->impl;
if(!(impl->file_flags & O_SYNC)) {
#ifdef HAVE_FDATASYNC
DEBUG("pfile_force() is calling fdatasync()\n");
fdatasync(impl->fd);
#else
DEBUG("pfile_force() is calling fsync()\n");
fsync(impl->fd);
#endif
} else {
DEBUG("File was opened with O_SYNC. pfile_force() is a no-op\n");
}
if(impl->sequential) {
#ifdef HAVE_POSIX_FADVISE
int err = posix_fadvise(impl->fd, 0, 0, POSIX_FADV_DONTNEED);
if(err) perror("Attempt to pass POSIX_FADV_SEQUENTIAL to kernel failed");
#endif
}
TOCK(force_hist);
return 0;
}
bool MainFrame::ProcessOneFrame(int nFrame)
{
// if(trackingType != DEFORMNRSFM && m_pControlPanel->m_nCurrentFrame == nFrame && m_nCurrentFrame == nFrame)
// return true;
isTrackingFinished = false;
cout << "processing frame: " << nFrame << endl;
// // read input
// TICK("getInput");
// if(!GetInput(nFrame))
// return false;
// TOCK("getInput");
// // do tracking
// TICK("tracking");
// if(!m_pTrackingEngine->trackFrame(nFrame, m_pColorImageRGB, &pOutputInfo))
// {
// cout << "tracking failed: " << endl;
// return false;
// }
// TOCK("tracking");
if(!MainEngine::ProcessOneFrame(nFrame))
return false;
// update imagePanel
TICK("update2DRendering");
m_pOverlayPane->updateImage(m_pColorImageRGB, m_nWidth, m_nHeight);
m_pImagePane->updateImage(m_pColorImageRGB, m_nWidth, m_nHeight);
TOCK("update2DRendering");
isTrackingFinished = true;
Stopwatch::getInstance().printAll();
return true;
}
/**
* Main game loop.
*/
static void loop(void)
{
extern nyancat_t nc;
gametime_t time;
int key_ready = 0, ch;
/* switch to intro mode */
gamemode_enter(mode_intro);
gamemode_draw();
while (gamemode_valid()) {
/* look for the first to run event */
time = queue_get_first_time();
if (time) {
/* wait for time to run the first event form queue or the first
* keypress, wichever comes first. */
key_ready = io_wait_for_key(time);
} else {
/* no event queue item found */
io_wait_for_key(0);
key_ready = 1;
}
if (key_ready > 0) {
ch = getch();
/* no redraw call explicite because this should be done bey the
* key handlers called functions */
gamemode_key(ch);
} else {
/* TODO find a better way for prevening hight cpu usage here. But
* for now insert a sleep for the minimum ticks used in game */
usleep(SECOND * TICK(0.1));
queue_run_until(time);
}
doupdate();
}
}
bool inline TrackerInterface::process()
{
if(firstRun)
{
cudaSafeCall(cudaSetDevice(ConfigArgs::get().gpu));
firstRun = false;
}
if(!threadPack.pauseCapture.getValue())
{
TICK(threadIdentifier);
uint64_t start = Stopwatch::getCurrentSystemTime();
bool returnVal = true;
bool shouldEnd = endRequested.getValue();
if(!logRead->grabNext(returnVal, currentFrame) || shouldEnd)
{
threadPack.pauseCapture.assignValue(true);
threadPack.finalised.assignValue(true);
finalise();
while(!threadPack.cloudSliceProcessorFinished.getValueWait())
{
frontend->cloudSignal.notify_all();
}
return shouldEnd ? false : returnVal;
}
depth.data = (unsigned short *)logRead->decompressedDepth;
rgb24.data = (PixelRGB *)logRead->decompressedImage;
currentFrame++;
depth.step = Resolution::get().width() * 2;
depth.rows = Resolution::get().rows();
depth.cols = Resolution::get().cols();
rgb24.step = Resolution::get().width() * 3;
rgb24.rows = Resolution::get().rows();
rgb24.cols = Resolution::get().cols();
depth_device.upload(depth.data, depth.step, depth.rows, depth.cols);
colors_device.upload(rgb24.data, rgb24.step, rgb24.rows, rgb24.cols);
TICK("processFrame");
frontend->processFrame(depth_device,
colors_device,
logRead->decompressedImage,
logRead->decompressedDepth,
logRead->timestamp,
logRead->isCompressed,
logRead->compressedDepth,
logRead->compressedDepthSize,
logRead->compressedImage,
logRead->compressedImageSize);
TOCK("processFrame");
uint64_t duration = Stopwatch::getCurrentSystemTime() - start;
if(threadPack.limit.getValue() && duration < 33333)
{
int sleepTime = std::max(int(33333 - duration), 0);
usleep(sleepTime);
}
TOCK(threadIdentifier);
}
return true;
}
void MeshSequenceReader::trackerInitSetup(TrackerOutputInfo& outputInfo)
{
TICK("visualRenderingInit");
outputInfo.meshData = currentMesh;
outputInfo.meshDataGT = outputInfo.meshData;
// get 2d projections
double X,Y,Z;
double u,v,w;
vector<CoordinateType> proj2D, proj2DGT;
proj2D.resize(2); proj2DGT.resize(2);
for(int vertex = 0; vertex < currentMesh.numVertices; ++vertex)
{
X = currentMesh.vertices[vertex][0];
Y = currentMesh.vertices[vertex][1];
Z = currentMesh.vertices[vertex][2];
if(KK[0][2] == 0) // this is orthographic camera
{
proj2D[0] = X; proj2D[1] = Y;
proj2DGT[0] = X; proj2DGT[1] = Y;
}
else
{
u = KK[0][0] * X + KK[0][1] * Y + KK[0][2] * Z;
v = KK[1][0] * X + KK[1][1] * Y + KK[1][2] * Z;
w = KK[2][0] * X + KK[2][1] * Y + KK[2][2] * Z;
if(w != 0)
{
u = u/w;
v = v/w;
}
proj2D[0] = u; proj2D[1] = v;
proj2DGT[0] = u; proj2DGT[1] = v;
}
outputInfo.meshProj.push_back(proj2D);
outputInfo.meshProjGT.push_back(proj2DGT);
}
outputInfo.visibilityMask.resize(outputInfo.meshData.numVertices,true);
// update the visiblity mask
if(useVisibilityMask)
{
UpdateVisibilityMaskGL(outputInfo, visibilityMask, KK, camPose, m_nWidth, m_nHeight);
//UpdateVisibilityMask(outputInfo, visibilityMask, m_nWidth, m_nHeight);
outputInfo.meshDataColorDiff = outputInfo.meshData;
UpdateColorDiff(outputInfo, visibilityMask, colorImageSplit);
}
// camera pose is always 0 in this case
for(int i = 0; i < 6; ++i)
outputInfo.camPose[i] = 0;
trackerInitialized = true;
TOCK("visualRenderingInit");
}
* the queue was free'd by gamemode switching. */
typedef struct {
gametime_t time;
eventhandler_fn callback;
} event_backup;
static event_backup eventbackup_specialmode;
static event_backup eventbackup_gem;
static event_backup eventbackup_milk;
extern coordinate_t screen;
static cat_t cat;
static movement_t move_fall[] = {
{TICK(3.5), 1, CatStateGlideDown, &move_fall[1]},
{TICK(2.5), 1, CatStateGlideDown, &move_fall[2]},
{TICK(2.5), 1, CatStateFall, &move_fall[3]},
{TICK(2.5), 1, CatStateFall, &move_fall[4]},
{TICK(2.5), 1, CatStateFall, &move_fall[5]},
{TICK(2.1), 1, CatStateFall, &move_fall[6]},
{TICK(2.1), 1, CatStateFall, &move_fall[7]},
{TICK(2.1), 1, CatStateFall, &move_fall[8]},
{TICK(1), 1, CatStateFallFast, &move_fall[8]}
};
static movement_t move_walk[] = {
{TICK(1), 0, CatStateWalk, &move_walk[1]},
{TICK(1), 0, CatStateGlide, move_fall}
};
static movement_t move_jump[] = {
{TICK(2.5), -1, CatStateJumpUp, &move_jump[1]},
/*!
Routine to compute an approximate solution to Ax = b
@param[in] geom The description of the problem's geometry.
@param[inout] A The known system matrix
@param[inout] data The data structure with all necessary CG vectors preallocated
@param[in] b The known right hand side vector
@param[inout] x On entry: the initial guess; on exit: the new approximate solution
@param[in] max_iter The maximum number of iterations to perform, even if tolerance is not met.
@param[in] tolerance The stopping criterion to assert convergence: if norm of residual is <= to tolerance.
@param[out] niters The number of iterations actually performed.
@param[out] normr The 2-norm of the residual vector after the last iteration.
@param[out] normr0 The 2-norm of the residual vector before the first iteration.
@param[out] times The 7-element vector of the timing information accumulated during all of the iterations.
@param[in] doPreconditioning The flag to indicate whether the preconditioner should be invoked at each iteration.
@return Returns zero on success and a non-zero value otherwise.
@see CG_ref()
*/
int CG(const SparseMatrix & A, CGData & data, const Vector & b, Vector & x,
const int max_iter, const double tolerance, int & niters, double & normr, double & normr0,
double * times, bool doPreconditioning) {
double t_begin = mytimer(); // Start timing right away
normr = 0.0;
double rtz = 0.0, oldrtz = 0.0, alpha = 0.0, beta = 0.0, pAp = 0.0;
double t0 = 0.0, t1 = 0.0, t2 = 0.0, t3 = 0.0, t4 = 0.0, t5 = 0.0;
//#ifndef HPCG_NOMPI
// double t6 = 0.0;
//#endif
local_int_t nrow = A.localNumberOfRows;
Vector & r = data.r; // Residual vector
Vector & z = data.z; // Preconditioned residual vector
Vector & p = data.p; // Direction vector (in MPI mode ncol>=nrow)
Vector & Ap = data.Ap;
if (!doPreconditioning && A.geom->rank==0) HPCG_fout << "WARNING: PERFORMING UNPRECONDITIONED ITERATIONS" << std::endl;
#ifdef HPCG_DEBUG
int print_freq = 1;
if (print_freq>50) print_freq=50;
if (print_freq<1) print_freq=1;
#endif
// p is of length ncols, copy x to p for sparse MV operation
CopyVector(x, p); //TODO paralel
TICK(); ComputeSPMV(A, p, Ap); TOCK(t3); // Ap = A*p
TICK(); ComputeWAXPBY(nrow, 1.0, b, -1.0, Ap, r, A.isWaxpbyOptimized); TOCK(t2); // r = b - Ax (x stored in p)
TICK(); ComputeDotProduct(nrow, r, r, normr, t4, A.isDotProductOptimized); TOCK(t1);
normr = sqrt(normr);
#ifdef HPCG_DEBUG
if (A.geom->rank==0) HPCG_fout << "Initial Residual = "<< normr << std::endl;
#endif
// Record initial residual for convergence testing
normr0 = normr;
// Start iterations
for (int k=1; k<=max_iter && normr/normr0 > tolerance; k++ ) {
TICK();
if (doPreconditioning)
ComputeMG(A, r, z); // Apply preconditioner
else
CopyVector (r, z); // copy r to z (no preconditioning)
TOCK(t5); // Preconditioner apply time
if (k == 1) {
TICK(); ComputeWAXPBY(nrow, 1.0, z, 0.0, z, p, A.isWaxpbyOptimized); TOCK(t2); // Copy Mr to p
TICK(); ComputeDotProduct (nrow, r, z, rtz, t4, A.isDotProductOptimized); TOCK(t1); // rtz = r'*z
} else {
oldrtz = rtz;
TICK(); ComputeDotProduct (nrow, r, z, rtz, t4, A.isDotProductOptimized); TOCK(t1); // rtz = r'*z
beta = rtz/oldrtz;
TICK(); ComputeWAXPBY (nrow, 1.0, z, beta, p, p, A.isWaxpbyOptimized); TOCK(t2); // p = beta*p + z
}
TICK(); ComputeSPMV(A, p, Ap); TOCK(t3); // Ap = A*p
TICK(); ComputeDotProduct(nrow, p, Ap, pAp, t4, A.isDotProductOptimized); TOCK(t1); // alpha = p'*Ap
alpha = rtz/pAp;
TICK(); ComputeWAXPBY(nrow, 1.0, x, alpha, p, x, A.isWaxpbyOptimized);// x = x + alpha*p
ComputeWAXPBY(nrow, 1.0, r, -alpha, Ap, r, A.isWaxpbyOptimized); TOCK(t2);// r = r - alpha*Ap
TICK(); ComputeDotProduct(nrow, r, r, normr, t4, A.isDotProductOptimized); TOCK(t1);
normr = sqrt(normr);
#ifdef HPCG_DEBUG
if (A.geom->rank==0 && (k%print_freq == 0 || k == max_iter))
HPCG_fout << "Iteration = "<< k << " Scaled Residual = "<< normr/normr0 << std::endl;
#endif
niters = k;
}
// Store times
times[1] += t1; // dot-product time
times[2] += t2; // WAXPBY time
times[3] += t3; // SPMV time
times[4] += t4; // AllReduce time
times[5] += t5; // preconditioner apply time
//#ifndef HPCG_NOMPI
// times[6] += t6; // exchange halo time
//#endif
times[0] += mytimer() - t_begin; // Total time. All done...
return(0);
}
static MRESULT APIENTRY Button1Up ( HWND Window, MESG, MPARAM1 mp1, MPARAM2 ) {
/***************************************************************************
* Find the instance data. *
***************************************************************************/
PDATA Data = PDATA ( Sys_GetWindowData ( Window ) ) ;
/***************************************************************************
* If the mouse wasn't captured, return. *
***************************************************************************/
if ( NOT Data->Capture )
return ( MRFROMSHORT ( FALSE ) ) ;
/***************************************************************************
* Get the presentation space. *
***************************************************************************/
WorkSpace PS ( "HRuler::Button1Up", 0, Window, Data->pDevice, int(Data->Metric) ) ;
PS.SetTransform ( Data->fxZoom, int(Data->TopLeft), 0 ) ;
/***************************************************************************
* Find out where the mouse touched. *
***************************************************************************/
RECTL Rectangle ;
WinQueryWindowRect ( Window, &Rectangle ) ;
POINTL Mouse = { SHORT1FROMMP(mp1), SHORT2FROMMP(mp1) } ;
PS.Transform ( CVTC_DEVICE, CVTC_DEFAULTPAGE, 1, &Mouse ) ;
PS.Transform ( CVTC_DEVICE, CVTC_DEFAULTPAGE, Rectangle ) ;
POINTL ButtonSize = { 8, 8 } ;
PS.Transform ( CVTC_DEVICE, CVTC_PAGE, 1, &ButtonSize ) ;
#ifdef DEBUG
Log ( "HRuler::Button1Up: Mouse at %i,%i (%i,%i). Rectangle %i,%i-%i,%i. ButtonSize %i.%i (8x8).",
Mouse.x, Mouse.y, SHORT1FROMMP(mp1), SHORT2FROMMP(mp1),
Rectangle.xLeft, Rectangle.yBottom, Rectangle.xRight, Rectangle.yTop,
ButtonSize.x, ButtonSize.y ) ;
#endif
/***************************************************************************
* Erase the previous hairline. *
***************************************************************************/
PS.SetMix ( FM_INVERT ) ;
PS.SetLineType ( LINETYPE_ALTERNATE ) ;
POINTL Point = { Data->Tick, Rectangle.yBottom } ;
PS.Move ( Point ) ;
Point.y = Rectangle.yTop ;
PS.DrawLine ( Point ) ;
/***************************************************************************
* Release the mouse. *
***************************************************************************/
Data->Capture = FALSE ;
Sys_ReleaseCapture ( ) ;
/***************************************************************************
* Restore the normal mouse pointer. *
***************************************************************************/
HPOINTER Ptr = WinQuerySysPointer ( HWND_DESKTOP, SPTR_ARROW, FALSE ) ;
WinSetPointer ( HWND_DESKTOP, Ptr ) ;
/***************************************************************************
* Restore the keyboard focus. *
***************************************************************************/
Sys_SetFocus ( Data->HadFocus ) ;
/***************************************************************************
* Process final location of mouse. *
***************************************************************************/
switch ( Data->Mode ) {
case MOVELEFT:
{
Data->Tick = TICK(Mouse.x) ;
if ( ( Data->Tick < 0 ) OR ( Data->Tick >= Data->RightMargin ) )
{
Sys_BeepError ( ) ;
break ;
}
Sys_SendMessage ( OWNER(Window), WM_SET_LEFTMARGIN, MPFROMLONG(Data->Tick), 0 ) ;
break ;
}
case MOVERIGHT:
{
Data->Tick = TICK(Mouse.x) ;
if ( ( Data->Tick <= Data->LeftMargin ) OR ( Data->Tick > Data->PageWidth ) )
{
Sys_BeepError ( ) ;
break ;
}
Sys_SendMessage ( OWNER(Window), WM_SET_RIGHTMARGIN, MPFROMLONG(Data->Tick), 0 ) ;
break ;
}
case MOVETAB:
{
Data->Tick = TICK(Mouse.x) ;
if ( ( Mouse.y > Rectangle.yTop )
OR ( Mouse.y < Rectangle.yBottom )
OR ( Data->Tick <= Data->LeftMargin )
OR ( Data->Tick >= Data->RightMargin ) )
{
Sys_SendMessage ( OWNER(Window), WM_CLEAR_TAB, MPFROMLONG(Data->Tabs[Data->TabIndex]), 0 ) ;
break ;
}
Sys_SendMessage ( OWNER(Window), WM_MOVE_TAB, MPFROMLONG(Data->Tabs[Data->TabIndex]), MPFROMLONG(Data->Tick) ) ;
break ;
}
case SETTAB:
{
Data->Tick = TICK(Mouse.x) ;
if ( ( Mouse.y > Rectangle.yTop )
OR ( Mouse.y < Rectangle.yBottom )
OR ( Data->Tick <= Data->LeftMargin )
OR ( Data->Tick >= Data->RightMargin ) )
{
Sys_BeepError ( ) ;
break ;
}
Sys_SendMessage ( OWNER(Window), WM_SET_TAB, MPFROMLONG(Data->Tick), 0 ) ;
break ;
}
}
/***************************************************************************
* Reset mode. *
***************************************************************************/
Data->Mode = NOTMOVING ;
/***************************************************************************
* We're done. *
***************************************************************************/
return ( MRFROMSHORT ( TRUE ) ) ;
}
MeshBufferReader::MeshBufferReader(MeshLoadingSettings& settings, int width,
int height, double K[3][3], int startFrame, int numTrackingFrames): trackerInitialized(false)
{
m_nWidth = width;
m_nHeight = height;
startFrameNo = startFrame;
currentFrameNo = startFrame;
pCurrentColorImageRGB = new unsigned char[3*width*height];
// in this case camPose will always be zero
for(int i = 0; i < 6; ++i)
camPose[i] = 0;
useVisibilityMask = settings.visibilityMask;
setIntrinsicMatrix(K);
nRenderingLevel = 0;
m_nNumMeshLevels = settings.meshLevelList.size();
// a bit ugly
nFrameStep = imageSourceSettings.frameStep;
// loading meshes into buffer
// outputInfoPyramidBuffer.resize(numTrackingFrames);
// outputPropPyramidBuffer.resize(numTrackingFrames);
int bufferSize = (numTrackingFrames - startFrameNo)/nFrameStep + 1;
outputInfoPyramidBuffer.resize(bufferSize);
outputPropPyramidBuffer.resize(bufferSize);
m_nGoodFrames = 0;
TICK("loadingMeshBuffer");
for(int i = startFrameNo; i <= numTrackingFrames; i = i + nFrameStep)
{
// TICK("loadingOneFrame");
if(!existenceTest(settings.meshPath, settings.meshLevelFormat,
i, settings.meshLevelList))
break;
++m_nGoodFrames;
currentMeshPyramid = std::move(PangaeaMeshPyramid(settings.meshPath,
settings.meshLevelFormat, i, settings.meshLevelList));
// TOCK("loadingOneFrame");
if(settings.loadProp)
{
propMeshPyramid = std::move(PangaeaMeshPyramid(settings.meshPath,
settings.propLevelFormat, i, settings.meshLevelList));
}
if(!settings.fastLoading)
propMeshPyramid = currentMeshPyramid;
// TICK("setOneFrame");
setMeshPyramid();
int bufferPos = (i-startFrameNo)/nFrameStep;
outputInfoPyramidBuffer[ bufferPos ] = std::move(outputInfoPyramid);
outputPropPyramidBuffer[ bufferPos ] = std::move(outputPropPyramid);
// TOCK("setOneFrame");
cout << "loading frame " << i << endl;
}
TOCK("loadingMeshBuffer");
}
int
test_decode(void *code, int k, int index[], int sz, char *s)
{
int errors;
int reconstruct = 0 ;
int item, i ;
static int prev_k = 0, prev_sz = 0;
static u_char **d_original = NULL, **d_src = NULL ;
if (sz < 1 || sz > 8192) {
fprintf(stderr, "test_decode: size %d invalid, must be 1..8K\n",
sz);
return 1 ;
}
if (k < 1 || k > GF_SIZE + 1) {
fprintf(stderr, "test_decode: k %d invalid, must be 1..%d\n",
k, GF_SIZE + 1 );
return 2 ;
}
if (prev_k != k || prev_sz != sz) {
if (d_original != NULL) {
for (i = 0 ; i < prev_k ; i++ ) {
free(d_original[i]);
free(d_src[i]);
}
free(d_original);
free(d_src);
d_original = NULL ;
d_src = NULL ;
}
}
prev_k = k ;
prev_sz = sz ;
if (d_original == NULL) {
d_original = my_malloc(k * sizeof(void *), "d_original ptr");
d_src = my_malloc(k * sizeof(void *), "d_src ptr");
for (i = 0 ; i < k ; i++ ) {
d_original[i] = my_malloc(sz, "d_original data");
d_src[i] = my_malloc(sz, "d_src data");
}
/*
* build sample data
*/
for (i = 0 ; i < k ; i++ ) {
for (item=0; item < sz; item++)
d_original[i][item] = ((item ^ i) + 3) & GF_SIZE;
}
}
errors = 0 ;
for( i = 0 ; i < k ; i++ )
if (index[i] >= k ) reconstruct ++ ;
TICK(ticks[2]);
for( i = 0 ; i < k ; i++ )
fec_encode(code, d_original, d_src[i], index[i], sz );
TOCK(ticks[2]);
TICK(ticks[1]);
if (fec_decode(code, d_src, index, sz)) {
fprintf(stderr, "detected singular matrix for %s \n", s);
return 1 ;
}
TOCK(ticks[1]);
for (i=0; i<k; i++)
if (bcmp(d_original[i], d_src[i], sz )) {
errors++;
fprintf(stderr, "error reconstructing block %d\n", i);
}
if (errors)
fprintf(stderr, "Errors reconstructing %d blocks out of %d\n",
errors, k);
fprintf(stderr,
" k %3d, l %3d c_enc %10.6f MB/s c_dec %10.6f MB/s \r",
k, reconstruct,
(double)(k * sz * reconstruct)/(double)ticks[2],
(double)(k * sz * reconstruct)/(double)ticks[1]);
return errors ;
}
int main ( int argc, char *argv[] )
{
TIMINGS_START ();
cmd_set_arguments ( argc, argv );
// Version
if ( find_arg ( "-v" ) >= 0 || find_arg ( "-version" ) >= 0 ) {
#ifdef GIT_VERSION
fprintf ( stdout, "Version: "GIT_VERSION "\n" );
#else
fprintf ( stdout, "Version: "VERSION "\n" );
#endif
exit ( EXIT_SUCCESS );
}
// Detect if we are in dmenu mode.
// This has two possible causes.
// 1 the user specifies it on the command-line.
if ( find_arg ( "-dmenu" ) >= 0 ) {
dmenu_mode = TRUE;
}
// 2 the binary that executed is called dmenu (e.g. symlink to rofi)
else{
// Get the base name of the executable called.
char *base_name = g_path_get_basename ( argv[0] );
const char * const dmenu_str = "dmenu";
dmenu_mode = ( strcmp ( base_name, dmenu_str ) == 0 );
// Free the basename for dmenu detection.
g_free ( base_name );
}
TICK ();
// Get the path to the cache dir.
cache_dir = g_get_user_cache_dir ();
// Create pid file path.
const char *path = g_get_user_runtime_dir ();
if ( path ) {
pidfile = g_build_filename ( path, "rofi.pid", NULL );
}
config_parser_add_option ( xrm_String, "pid", (void * *) &pidfile, "Pidfile location" );
if ( find_arg ( "-config" ) < 0 ) {
const char *cpath = g_get_user_config_dir ();
if ( cpath ) {
config_path = g_build_filename ( cpath, "rofi", "config", NULL );
}
}
else {
char *c = NULL;
find_arg_str ( "-config", &c );
config_path = rofi_expand_path ( c );
}
TICK ();
// Register cleanup function.
atexit ( cleanup );
TICK ();
// Get DISPLAY, first env, then argument.
char *display_str = getenv ( "DISPLAY" );
find_arg_str ( "-display", &display_str );
if ( setlocale ( LC_ALL, "" ) == NULL ) {
fprintf ( stderr, "Failed to set locale.\n" );
return EXIT_FAILURE;
}
xcb->connection = xcb_connect ( display_str, &xcb->screen_nbr );
if ( xcb_connection_has_error ( xcb->connection ) ) {
fprintf ( stderr, "Failed to open display: %s", display_str );
return EXIT_FAILURE;
}
TICK_N ( "Open Display" );
xcb->screen = xcb_aux_get_screen ( xcb->connection, xcb->screen_nbr );
xcb_intern_atom_cookie_t *ac = xcb_ewmh_init_atoms ( xcb->connection, &xcb->ewmh );
xcb_generic_error_t *errors = NULL;
xcb_ewmh_init_atoms_replies ( &xcb->ewmh, ac, &errors );
if ( errors ) {
fprintf ( stderr, "Failed to create EWMH atoms\n" );
free ( errors );
}
if ( xkb_x11_setup_xkb_extension ( xcb->connection, XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION,
XKB_X11_SETUP_XKB_EXTENSION_NO_FLAGS, NULL, NULL, &xkb.first_event, NULL ) < 0 ) {
fprintf ( stderr, "cannot setup XKB extension!\n" );
return EXIT_FAILURE;
}
xkb.context = xkb_context_new ( XKB_CONTEXT_NO_FLAGS );
if ( xkb.context == NULL ) {
fprintf ( stderr, "cannot create XKB context!\n" );
return EXIT_FAILURE;
}
xkb.xcb_connection = xcb->connection;
xkb.device_id = xkb_x11_get_core_keyboard_device_id ( xcb->connection );
enum
{
required_events =
( XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY |
XCB_XKB_EVENT_TYPE_MAP_NOTIFY |
XCB_XKB_EVENT_TYPE_STATE_NOTIFY ),
required_nkn_details =
( XCB_XKB_NKN_DETAIL_KEYCODES ),
required_map_parts =
( XCB_XKB_MAP_PART_KEY_TYPES |
XCB_XKB_MAP_PART_KEY_SYMS |
XCB_XKB_MAP_PART_MODIFIER_MAP |
XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS |
XCB_XKB_MAP_PART_KEY_ACTIONS |
XCB_XKB_MAP_PART_VIRTUAL_MODS |
XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP ),
required_state_details =
( XCB_XKB_STATE_PART_MODIFIER_BASE |
XCB_XKB_STATE_PART_MODIFIER_LATCH |
XCB_XKB_STATE_PART_MODIFIER_LOCK |
XCB_XKB_STATE_PART_GROUP_BASE |
XCB_XKB_STATE_PART_GROUP_LATCH |
XCB_XKB_STATE_PART_GROUP_LOCK ),
};
static const xcb_xkb_select_events_details_t details = {
.affectNewKeyboard = required_nkn_details,
.newKeyboardDetails = required_nkn_details,
.affectState = required_state_details,
.stateDetails = required_state_details,
};
xcb_xkb_select_events ( xcb->connection, xkb.device_id, required_events, /* affectWhich */
0, /* clear */
required_events, /* selectAll */
required_map_parts, /* affectMap */
required_map_parts, /* map */
&details );
xkb.keymap = xkb_x11_keymap_new_from_device ( xkb.context, xcb->connection, xkb.device_id, XKB_KEYMAP_COMPILE_NO_FLAGS );
if ( xkb.keymap == NULL ) {
fprintf ( stderr, "Failed to get Keymap for current keyboard device.\n" );
return EXIT_FAILURE;
}
xkb.state = xkb_x11_state_new_from_device ( xkb.keymap, xcb->connection, xkb.device_id );
if ( xkb.state == NULL ) {
fprintf ( stderr, "Failed to get state object for current keyboard device.\n" );
return EXIT_FAILURE;
}
xkb.compose.table = xkb_compose_table_new_from_locale ( xkb.context, setlocale ( LC_CTYPE, NULL ), 0 );
if ( xkb.compose.table != NULL ) {
xkb.compose.state = xkb_compose_state_new ( xkb.compose.table, 0 );
}
else {
fprintf ( stderr, "Failed to get keyboard compose table. Trying to limp on.\n" );
}
if ( xcb_connection_has_error ( xcb->connection ) ) {
fprintf ( stderr, "Connection has error\n" );
exit ( EXIT_FAILURE );
}
x11_setup ( &xkb );
if ( xcb_connection_has_error ( xcb->connection ) ) {
fprintf ( stderr, "Connection has error\n" );
exit ( EXIT_FAILURE );
}
const xcb_query_extension_reply_t *er = xcb_get_extension_data ( xcb->connection, &xcb_xinerama_id );
if ( er ) {
if ( er->present ) {
xcb_xinerama_is_active_cookie_t is_active_req = xcb_xinerama_is_active ( xcb->connection );
xcb_xinerama_is_active_reply_t *is_active = xcb_xinerama_is_active_reply ( xcb->connection, is_active_req, NULL );
xcb->has_xinerama = is_active->state;
free ( is_active );
}
}
main_loop = g_main_loop_new ( NULL, FALSE );
TICK_N ( "Setup mainloop" );
// startup not.
xcb->sndisplay = sn_xcb_display_new ( xcb->connection, error_trap_push, error_trap_pop );
if ( xcb_connection_has_error ( xcb->connection ) ) {
fprintf ( stderr, "Connection has error\n" );
exit ( EXIT_FAILURE );
}
if ( xcb->sndisplay != NULL ) {
xcb->sncontext = sn_launchee_context_new_from_environment ( xcb->sndisplay, xcb->screen_nbr );
}
if ( xcb_connection_has_error ( xcb->connection ) ) {
fprintf ( stderr, "Connection has error\n" );
exit ( EXIT_FAILURE );
}
TICK_N ( "Startup Notification" );
// Initialize Xresources subsystem.
config_parse_xresource_init ();
TICK_N ( "Initialize Xresources system" );
// Setup keybinding
setup_abe ();
TICK_N ( "Setup abe" );
if ( find_arg ( "-no-config" ) < 0 ) {
load_configuration ( );
}
if ( !dmenu_mode ) {
// setup_modi
setup_modi ();
}
if ( find_arg ( "-no-config" ) < 0 ) {
// Reload for dynamic part.
load_configuration_dynamic ( );
}
// Dump.
// catch help request
if ( find_arg ( "-h" ) >= 0 || find_arg ( "-help" ) >= 0 || find_arg ( "--help" ) >= 0 ) {
help ( argc, argv );
exit ( EXIT_SUCCESS );
}
if ( find_arg ( "-dump-xresources" ) >= 0 ) {
config_parse_xresource_dump ();
exit ( EXIT_SUCCESS );
}
if ( find_arg ( "-dump-xresources-theme" ) >= 0 ) {
config_parse_xresources_theme_dump ();
exit ( EXIT_SUCCESS );
}
main_loop_source = g_water_xcb_source_new_for_connection ( NULL, xcb->connection, main_loop_x11_event_handler, NULL, NULL );
TICK_N ( "X11 Setup " );
rofi_view_workers_initialize ();
// Setup signal handling sources.
// SIGINT
g_unix_signal_add ( SIGINT, main_loop_signal_handler_int, NULL );
g_idle_add ( startup, NULL );
// Start mainloop.
g_main_loop_run ( main_loop );
return return_code;
}
P2 (PUBLIC pascal trap, OSErr, FSpExchangeFiles,
FSSpecPtr, src, FSSpecPtr, dst)
{
#if 0
save_fcb_info_t *src_fcb_info, *dst_fcb_info;
OSErr retval;
src_fcb_info = get_fcb_info (src);
dst_fcb_info = get_fcb_info (dst);
retval = exchange_forks (src, dst, datafork);
if (retval == noErr)
{
retval = exchange_forks (src, dst, resourcefork);
if (retval != noErr)
exchange_forks (src, dst, datafork); /* try to put things back
together */
}
if (retval == noErr)
exchange_fcbs (src, src_fcb_info, dst, dst_fcb_info);
else
{
restore_fcb (src_fcb_info);
restore_fcb (dst_fcb_info);
}
release_fcb_info (src_fcb_info);
release_fcb_info (dst_fcb_info);
return retval;
#else
OSErr retval;
warning_unimplemented ("poorly implemented");
if (src->vRefNum != dst->vRefNum)
retval = diffVolErr;
else if (ROMlib_creator != TICK("PAUP") || src->parID != dst->parID)
retval = wrgVolTypeErr;
else
{
/* Evil hack to get PAUP to work -- doesn't bother adjusting FCBs */
FSSpec tmp_spec;
int i;
i = 0;
tmp_spec = *dst;
do
{
create_temp_name (tmp_spec.name, i++);
retval = FSpRename (dst, tmp_spec.name);
}
while (retval == dupFNErr);
if (retval == noErr)
{
retval = FSpRename (src, dst->name);
if (retval != noErr)
FSpRename (&tmp_spec, dst->name);
else
{
retval = FSpRename (&tmp_spec, src->name);
if (retval != noErr)
{
FSpRename (dst, src->name);
FSpRename (&tmp_spec, dst->name);
}
}
}
}
return retval;
#endif
}
A1(PRIVATE, OSErr, cropen, INTEGER *, fp)
{
OSErr retval;
retval = FSOpen(MR(ScrapName), CW (BootDrive), fp);
if (retval == fnfErr) {
retval = Create(MR(ScrapName), CW (BootDrive), TICK("MACS"), TICK("CLIP"));
if (retval != noErr)
return(retval);
return(FSOpen(MR(ScrapName), CW (BootDrive), fp));
}
return(retval);
}
