static void *cpu_thread(void *dummyptr) {
#ifndef NDEBUG // Spamsung Galaxy Y running Gingerbread triggers this, wTf?!
ASSERT_ON_CPU_THREAD();
#endif
LOG("cpu_thread : initialized...");
struct timespec deltat = { 0 };
struct timespec disk_motor_time = { 0 };
struct timespec t0 = { 0 }; // the target timer
struct timespec ti = { 0 }; // actual before time sample
struct timespec tj = { 0 }; // actual after time sample
bool negative = false;
long drift_adj_nsecs = 0; // generic drift adjustment between target and actual
int debugging_cycles = 0;
unsigned long dbg_ticks = 0;
#if DEBUG_TIMING
int speaker_neg_feedback = 0;
int speaker_pos_feedback = 0;
unsigned long dbg_cycles_executed = 0;
#endif
audio_init();
speaker_init();
MB_Initialize();
run_args.emul_reinitialize = 1;
cpu_runloop:
do {
LOG("CPUTHREAD %lu LOCKING FOR MAYBE INITIALIZING AUDIO ...", (unsigned long)cpu_thread_id);
pthread_mutex_lock(&interface_mutex);
if (emul_reinitialize_audio) {
emul_reinitialize_audio = false;
speaker_destroy();
extern void MB_SoftDestroy(void);
MB_SoftDestroy();
audio_shutdown();
audio_init();
speaker_init();
extern void MB_SoftInitialize(void);
MB_SoftInitialize();
}
pthread_mutex_unlock(&interface_mutex);
LOG("UNLOCKING FOR MAYBE INITIALIZING AUDIO ...");
if (run_args.emul_reinitialize) {
reinitialize();
}
LOG("cpu_thread : begin main loop ...");
clock_gettime(CLOCK_MONOTONIC, &t0);
do {
////SCOPE_TRACE_CPU("CPU mainloop");
// -LOCK----------------------------------------------------------------------------------------- SAMPLE ti
if (UNLIKELY(emul_pause_audio)) {
emul_pause_audio = false;
audio_pause();
}
pthread_mutex_lock(&interface_mutex);
if (UNLIKELY(emul_resume_audio)) {
emul_resume_audio = false;
audio_resume();
}
if (UNLIKELY(emul_video_dirty)) {
emul_video_dirty = false;
video_setDirty(A2_DIRTY_FLAG);
}
clock_gettime(CLOCK_MONOTONIC, &ti);
deltat = timespec_diff(t0, ti, &negative);
if (deltat.tv_sec) {
if (!is_fullspeed) {
TIMING_LOG("NOTE : serious divergence from target time ...");
}
t0 = ti;
deltat = timespec_diff(t0, ti, &negative);
}
t0 = timespec_add(t0, EXECUTION_PERIOD_NSECS); // expected interval
drift_adj_nsecs = negative ? ~deltat.tv_nsec : deltat.tv_nsec;
// set up increment & decrement counters
run_args.cpu65_cycles_to_execute = (cycles_persec_target / 1000); // cycles_persec_target * EXECUTION_PERIOD_NSECS / NANOSECONDS_PER_SECOND
if (!is_fullspeed) {
run_args.cpu65_cycles_to_execute += cycles_speaker_feedback;
}
if (run_args.cpu65_cycles_to_execute < 0) {
run_args.cpu65_cycles_to_execute = 0;
}
MB_StartOfCpuExecute();
if (is_debugging) {
debugging_cycles = run_args.cpu65_cycles_to_execute;
}
do {
if (is_debugging) {
run_args.cpu65_cycles_to_execute = 1;
}
run_args.cpu65_cycle_count = 0;
cycles_checkpoint_count = 0;
cpu65_run(&run_args); // run emulation for cpu65_cycles_to_execute cycles ...
#if DEBUG_TIMING
dbg_cycles_executed += run_args.cpu65_cycle_count;
#endif
if (is_debugging) {
debugging_cycles -= run_args.cpu65_cycle_count;
timing_checkpointCycles();
if (c_debugger_should_break() || (debugging_cycles <= 0)) {
int err = 0;
if ((err = pthread_cond_signal(&dbg_thread_cond))) {
LOG("pthread_cond_signal : %d", err);
}
if ((err = pthread_cond_wait(&cpu_thread_cond, &interface_mutex))) {
LOG("pthread_cond_wait : %d", err);
}
if (debugging_cycles <= 0) {
break;
}
}
if (run_args.emul_reinitialize) {
pthread_mutex_unlock(&interface_mutex);
goto cpu_runloop;
}
}
} while (is_debugging);
MB_UpdateCycles();
// TODO : modularize MB and other peripheral card cycles/interrupts ...
speaker_flush(); // play audio
TRACE_CPU_BEGIN("advance scanner");
video_scannerUpdate();
TRACE_CPU_END();
clock_gettime(CLOCK_MONOTONIC, &tj);
pthread_mutex_unlock(&interface_mutex);
// -UNLOCK--------------------------------------------------------------------------------------- SAMPLE tj
if (timing_shouldAutoAdjustSpeed() && !is_fullspeed) {
disk_motor_time = timespec_diff(disk6.motor_time, tj, &negative);
if (UNLIKELY(negative)) {
LOG("WHOA... time went backwards #1! Did you just cross a timezone?");
disk_motor_time.tv_sec = 1;
}
if (!speaker_isActive() && !video_isDirty(A2_DIRTY_FLAG) && (disk6.disk[disk6.drive].file_name != NULL) &&
!disk6.motor_off && (disk_motor_time.tv_sec || disk_motor_time.tv_nsec > DISK_MOTOR_QUIET_NSECS) )
{
TIMING_LOG("auto switching to full speed");
_timing_initialize(CPU_SCALE_FASTEST);
}
}
if (!is_fullspeed) {
deltat = timespec_diff(ti, tj, &negative);
if (UNLIKELY(negative)) {
LOG("WHOA... time went backwards #2! Did you just cross a timezone?");
deltat.tv_sec = 1;
}
long sleepfor = 0;
if (LIKELY(!deltat.tv_sec))
{
sleepfor = EXECUTION_PERIOD_NSECS - drift_adj_nsecs - deltat.tv_nsec;
}
if (sleepfor <= 0)
{
// lagging ...
static time_t throttle_warning = 0;
if (t0.tv_sec - throttle_warning > 0)
{
TIMING_LOG("not sleeping to catch up ... %ld . %ld", deltat.tv_sec, deltat.tv_nsec);
throttle_warning = t0.tv_sec;
}
}
else
{
deltat.tv_sec = 0;
deltat.tv_nsec = sleepfor;
////TRACE_CPU_BEGIN("sleep");
nanosleep(&deltat, NULL);
////TRACE_CPU_END();
}
#if DEBUG_TIMING
// collect timing statistics
if (speaker_neg_feedback > cycles_speaker_feedback)
{
speaker_neg_feedback = cycles_speaker_feedback;
}
if (speaker_pos_feedback < cycles_speaker_feedback)
{
speaker_pos_feedback = cycles_speaker_feedback;
}
if ((dbg_ticks % NANOSECONDS_PER_SECOND) == 0)
{
TIMING_LOG("tick:(%ld.%ld) real:(%ld.%ld) cycles exe: %d ... speaker feedback: %d/%d", t0.tv_sec, t0.tv_nsec, ti.tv_sec, ti.tv_nsec, dbg_cycles_executed, speaker_neg_feedback, speaker_pos_feedback);
dbg_cycles_executed = 0;
speaker_neg_feedback = 0;
speaker_pos_feedback = 0;
}
#endif
if ((dbg_ticks % NANOSECONDS_PER_SECOND) == 0) {
dbg_ticks = 0;
}
}
if (timing_shouldAutoAdjustSpeed() && is_fullspeed) {
disk_motor_time = timespec_diff(disk6.motor_time, tj, &negative);
if (UNLIKELY(negative)) {
LOG("WHOA... time went backwards #3! Did you just cross a timezone?");
disk_motor_time.tv_sec = 1;
}
if (speaker_isActive() || video_isDirty(A2_DIRTY_FLAG) ||
(disk6.motor_off && (disk_motor_time.tv_sec || disk_motor_time.tv_nsec > DISK_MOTOR_QUIET_NSECS)) )
{
double speed = alt_speed_enabled ? cpu_altscale_factor : cpu_scale_factor;
if (speed <= CPU_SCALE_FASTEST_PIVOT) {
TIMING_LOG("auto switching to configured speed");
_timing_initialize(speed);
}
}
}
if (UNLIKELY(run_args.emul_reinitialize)) {
break;
}
if (UNLIKELY(emul_reinitialize_audio)) {
break;
}
if (UNLIKELY(cpu_shutting_down)) {
break;
}
} while (1);
if (UNLIKELY(cpu_shutting_down)) {
break;
}
} while (1);
speaker_destroy();
MB_Destroy();
audio_shutdown();
cpu_thread_id = 0;
cpu_pause();
disk6_eject(0);
disk6_eject(1);
return NULL;
}
/*
* Looks for the minimum between two 32-bit image pixels (a central pixel
* and its neighbors in the other image).
* The neighbor depends on the grid used (see mambaCommon.h). Neighbors are
* described using a pattern (see enum MB_Neighbors_code_t). If no neighbor
* is defined, the function will leave silently doing nothing.
*
* \param src source image in which the neighbor are taken
* \param srcdest source of the central pixel and destination image
* \param neighbors the neighbors to take into account
* \param grid the grid used (either square or hexagonal)
* \param edge the kind of edge to use (behavior for pixel near edge depends on it)
*
* \return An error code (MB_NO_ERR if successful)
*/
MB_errcode MB_InfNb32(MB_Image *src, MB_Image *srcdest, Uint32 neighbors, enum MB_grid_t grid, enum MB_edgemode_t edge)
{
Uint32 bytes_in;
MB_Image *temp;
PLINE *plines_in, *plines_inout;
MB_errcode err;
PIX32 edge_val = I32_FILL_VALUE(edge);
/* Error management */
/* Verification over image size compatibility */
if (!MB_CHECK_SIZE_2(src, srcdest)) {
return MB_ERR_BAD_SIZE;
}
/* Only greyscale images can be processed */
switch (MB_PROBE_PAIR(src, srcdest)) {
case MB_PAIR_32_32:
break;
default:
return MB_ERR_BAD_DEPTH;
}
/* If src and srcdest are the same image, we create a temporary */
/* images where we copy the pixels value */
if (src==srcdest) {
temp = MB_malloc(sizeof(MB_Image));
if (temp==NULL) {
return MB_ERR_CANT_ALLOCATE_MEMORY;
}
err = MB_Create(temp, src->width, src->height, src->depth);
if (err!=MB_NO_ERR) {
return err;
}
err = MB_Copy(src, temp);
if (err!=MB_NO_ERR) {
return err;
}
} else {
temp = src;
}
/* Setting up pointers */
plines_in = temp->plines;
plines_inout = srcdest->plines;
bytes_in = MB_LINE_COUNT(src);
/* Calling the corresponding function */
if (grid==MB_SQUARE_GRID) {
if ((neighbors&MB_NEIGHBOR_ALL_SQUARE)==0) {
/* No neighbors to take into account */
return MB_NO_ERR;
}
MB_comp_neighbors_square(plines_inout, plines_in, bytes_in, temp->height,
neighbors, edge_val);
} else {
if ((neighbors&MB_NEIGHBOR_ALL_HEXAGONAL)==0) {
/* No neighbors to take into account */
return MB_NO_ERR;
}
MB_comp_neighbors_hexagonal(plines_inout, plines_in, bytes_in, temp->height,
neighbors, edge_val);
}
/* Destroying the temporary image if one was created */
if (src==srcdest) {
MB_Destroy(temp);
}
return MB_NO_ERR;
}
static void *cpu_thread(void *dummyptr) {
assert(pthread_self() == cpu_thread_id);
LOG("cpu_thread : initialized...");
struct timespec deltat;
#if !MOBILE_DEVICE
struct timespec disk_motor_time;
#endif
struct timespec t0; // the target timer
struct timespec ti, tj; // actual time samples
bool negative = false;
long drift_adj_nsecs = 0; // generic drift adjustment between target and actual
int debugging_cycles0 = 0;
int debugging_cycles = 0;
#if DEBUG_TIMING
unsigned long dbg_ticks = 0;
int speaker_neg_feedback = 0;
int speaker_pos_feedback = 0;
unsigned int dbg_cycles_executed = 0;
#endif
do
{
#ifdef AUDIO_ENABLED
LOG("CPUTHREAD %lu LOCKING FOR MAYBE INITIALIZING AUDIO ...", cpu_thread_id);
pthread_mutex_lock(&interface_mutex);
if (emul_reinitialize_audio) {
emul_reinitialize_audio = false;
speaker_destroy();
MB_Destroy();
audio_shutdown();
audio_init();
speaker_init();
MB_Initialize();
}
pthread_mutex_unlock(&interface_mutex);
LOG("UNLOCKING FOR MAYBE INITIALIZING AUDIO ...");
#endif
if (emul_reinitialize) {
reinitialize();
}
LOG("cpu_thread : begin main loop ...");
clock_gettime(CLOCK_MONOTONIC, &t0);
do {
SCOPE_TRACE_CPU("CPU mainloop");
// -LOCK----------------------------------------------------------------------------------------- SAMPLE ti
#ifdef AUDIO_ENABLED
if (UNLIKELY(emul_pause_audio)) {
emul_pause_audio = false;
audio_pause();
}
#endif
pthread_mutex_lock(&interface_mutex);
#ifdef AUDIO_ENABLED
if (UNLIKELY(emul_resume_audio)) {
emul_resume_audio = false;
audio_resume();
}
#endif
clock_gettime(CLOCK_MONOTONIC, &ti);
deltat = timespec_diff(t0, ti, &negative);
if (deltat.tv_sec)
{
if (!is_fullspeed) {
TIMING_LOG("NOTE : serious divergence from target time ...");
}
t0 = ti;
deltat = timespec_diff(t0, ti, &negative);
}
t0 = timespec_add(t0, EXECUTION_PERIOD_NSECS); // expected interval
drift_adj_nsecs = negative ? ~deltat.tv_nsec : deltat.tv_nsec;
// set up increment & decrement counters
cpu65_cycles_to_execute = (cycles_persec_target / 1000); // cycles_persec_target * EXECUTION_PERIOD_NSECS / NANOSECONDS_PER_SECOND
if (!is_fullspeed) {
cpu65_cycles_to_execute += cycles_speaker_feedback;
}
if (cpu65_cycles_to_execute < 0)
{
cpu65_cycles_to_execute = 0;
}
#ifdef AUDIO_ENABLED
MB_StartOfCpuExecute();
#endif
if (is_debugging) {
debugging_cycles0 = cpu65_cycles_to_execute;
debugging_cycles = cpu65_cycles_to_execute;
}
do {
if (is_debugging) {
cpu65_cycles_to_execute = 1;
}
cpu65_cycle_count = 0;
cycles_checkpoint_count = 0;
cpu65_run(); // run emulation for cpu65_cycles_to_execute cycles ...
if (is_debugging) {
debugging_cycles -= cpu65_cycle_count;
if (c_debugger_should_break() || (debugging_cycles <= 0)) {
int err = 0;
if ((err = pthread_cond_signal(&dbg_thread_cond))) {
ERRLOG("pthread_cond_signal : %d", err);
}
if ((err = pthread_cond_wait(&cpu_thread_cond, &interface_mutex))) {
ERRLOG("pthread_cond_wait : %d", err);
}
if (debugging_cycles <= 0) {
cpu65_cycle_count = debugging_cycles0 - debugging_cycles/*<=0*/;
break;
}
}
}
if (emul_reinitialize) {
reinitialize();
}
} while (is_debugging);
#if DEBUG_TIMING
dbg_cycles_executed += cpu65_cycle_count;
#endif
g_dwCyclesThisFrame += cpu65_cycle_count;
#ifdef AUDIO_ENABLED
MB_UpdateCycles(); // update 6522s (NOTE: do this before updating cycles_count_total)
#endif
timing_checkpoint_cycles();
#if CPU_TRACING
cpu65_trace_checkpoint();
#endif
#ifdef AUDIO_ENABLED
speaker_flush(); // play audio
#endif
if (g_dwCyclesThisFrame >= dwClksPerFrame) {
g_dwCyclesThisFrame -= dwClksPerFrame;
#ifdef AUDIO_ENABLED
MB_EndOfVideoFrame();
#endif
}
clock_gettime(CLOCK_MONOTONIC, &tj);
pthread_mutex_unlock(&interface_mutex);
// -UNLOCK--------------------------------------------------------------------------------------- SAMPLE tj
#if !MOBILE_DEVICE
if (timing_shouldAutoAdjustSpeed()) {
disk_motor_time = timespec_diff(disk6.motor_time, tj, &negative);
assert(!negative);
if (!is_fullspeed &&
#ifdef AUDIO_ENABLED
!speaker_isActive() &&
#endif
!video_isDirty() && (!disk6.motor_off && (disk_motor_time.tv_sec || disk_motor_time.tv_nsec > DISK_MOTOR_QUIET_NSECS)) )
{
TIMING_LOG("auto switching to full speed");
_timing_initialize(CPU_SCALE_FASTEST);
}
}
#endif
if (!is_fullspeed) {
deltat = timespec_diff(ti, tj, &negative);
assert(!negative);
long sleepfor = 0;
if (!deltat.tv_sec)
{
sleepfor = EXECUTION_PERIOD_NSECS - drift_adj_nsecs - deltat.tv_nsec;
}
if (sleepfor <= 0)
{
// lagging ...
static time_t throttle_warning = 0;
if (t0.tv_sec - throttle_warning > 0)
{
TIMING_LOG("not sleeping to catch up ... %ld . %ld", deltat.tv_sec, deltat.tv_nsec);
throttle_warning = t0.tv_sec;
}
}
else
{
deltat.tv_sec = 0;
deltat.tv_nsec = sleepfor;
TRACE_CPU_BEGIN("sleep");
nanosleep(&deltat, NULL);
TRACE_CPU_END();
}
#if DEBUG_TIMING
// collect timing statistics
if (speaker_neg_feedback > cycles_speaker_feedback)
{
speaker_neg_feedback = cycles_speaker_feedback;
}
if (speaker_pos_feedback < cycles_speaker_feedback)
{
speaker_pos_feedback = cycles_speaker_feedback;
}
dbg_ticks += EXECUTION_PERIOD_NSECS;
if ((dbg_ticks % NANOSECONDS_PER_SECOND) == 0)
{
TIMING_LOG("tick:(%ld.%ld) real:(%ld.%ld) cycles exe: %d ... speaker feedback: %d/%d", t0.tv_sec, t0.tv_nsec, ti.tv_sec, ti.tv_nsec, dbg_cycles_executed, speaker_neg_feedback, speaker_pos_feedback);
dbg_cycles_executed = 0;
dbg_ticks = 0;
speaker_neg_feedback = 0;
speaker_pos_feedback = 0;
}
#endif
}
#if !MOBILE_DEVICE
if (timing_shouldAutoAdjustSpeed()) {
if (is_fullspeed && (
#ifdef AUDIO_ENABLED
speaker_isActive() ||
#endif
video_isDirty() || (disk6.motor_off && (disk_motor_time.tv_sec || disk_motor_time.tv_nsec > DISK_MOTOR_QUIET_NSECS))) )
{
double speed = alt_speed_enabled ? cpu_altscale_factor : cpu_scale_factor;
if (speed < CPU_SCALE_FASTEST) {
TIMING_LOG("auto switching to configured speed");
_timing_initialize(speed);
}
}
}
#endif
if (UNLIKELY(emul_reinitialize)) {
break;
}
#ifdef AUDIO_ENABLED
if (UNLIKELY(emul_reinitialize_audio)) {
break;
}
#endif
if (UNLIKELY(cpu_shutting_down)) {
break;
}
} while (1);
if (UNLIKELY(cpu_shutting_down)) {
break;
}
} while (1);
#ifdef AUDIO_ENABLED
speaker_destroy();
MB_Destroy();
audio_shutdown();
#endif
return NULL;
}