static void report_pcm_state(struct audio *audio, const char *prefix)
{
char buf[32];
snd_pcm_state_t state;
#define HANDLE_CASE(_c) case _c: strncpy(buf, #_c, sizeof(buf)); break
switch (state = snd_pcm_state(audio->pcm)) {
HANDLE_CASE(SND_PCM_STATE_OPEN);
HANDLE_CASE(SND_PCM_STATE_SETUP);
HANDLE_CASE(SND_PCM_STATE_PREPARED);
HANDLE_CASE(SND_PCM_STATE_RUNNING);
HANDLE_CASE(SND_PCM_STATE_XRUN);
HANDLE_CASE(SND_PCM_STATE_DRAINING);
HANDLE_CASE(SND_PCM_STATE_PAUSED);
HANDLE_CASE(SND_PCM_STATE_SUSPENDED);
HANDLE_CASE(SND_PCM_STATE_DISCONNECTED);
default:
snprintf(buf, sizeof(buf), "UNKNOWN<%d>", state);
break;
}
#undef HANDLE_CASE
fprintf(stderr, "%s: %s(): %s\n", prefix, __func__, buf);
}
int audio_getid(const char *name)
{
for (int i = 0; i < _sounds_count; ++i) {
if (strcmp(name, _sounds_desc[i].name) == 0)
return i;
}
HANDLE_CASE(false);
return 0;
}
void audio_play(int id)
{
assert(id < _sounds_count);
// Find a free stream
int free_stream;
for (free_stream = 0; free_stream < _STREAM_COUNT; ++free_stream) {
if (_VOLATILE(_streams[free_stream].begin) == -1)
break;
}
HANDLE_CASE(free_stream == _STREAM_COUNT);
// Play on the free stream
_VOLATILE(_streams[free_stream].end) = _sounds_desc[id].end;
_VOLATILE(_streams[free_stream].begin) = _sounds_desc[id].begin;
}
void CreateExceptionInfoString(int32 Signal, struct __siginfo* Info)
{
FString ErrorString = TEXT("Unhandled Exception: ");
#define HANDLE_CASE(a,b) case a: ErrorString += TEXT(#a #b); break;
switch (Signal)
{
case SIGSEGV:
ErrorString += TEXT("SIGSEGV segmentation violation at address ");
ErrorString += FString::Printf(TEXT("0x%08x"), (uint32*)Info->si_addr);
break;
case SIGBUS:
ErrorString += TEXT("SIGBUS bus error at address ");
ErrorString += FString::Printf(TEXT("0x%08x"), (uint32*)Info->si_addr);
break;
HANDLE_CASE(SIGINT, "interrupt program")
HANDLE_CASE(SIGQUIT, "quit program")
HANDLE_CASE(SIGILL, "illegal instruction")
HANDLE_CASE(SIGTRAP, "trace trap")
HANDLE_CASE(SIGABRT, "abort() call")
HANDLE_CASE(SIGFPE, "floating-point exception")
HANDLE_CASE(SIGKILL, "kill program")
HANDLE_CASE(SIGSYS, "non-existent system call invoked")
HANDLE_CASE(SIGPIPE, "write on a pipe with no reader")
HANDLE_CASE(SIGTERM, "software termination signal")
HANDLE_CASE(SIGSTOP, "stop")
default:
ErrorString += FString::Printf(TEXT("0x%08x"), (uint32)Signal);
}
#if WITH_EDITORONLY_DATA
FCString::Strncpy(GErrorExceptionDescription, *ErrorString, FMath::Min(ErrorString.Len() + 1, (int32)ARRAY_COUNT(GErrorExceptionDescription)));
#endif
#undef HANDLE_CASE
}
FString DescribeSignal(int32 Signal, siginfo_t* Info)
{
FString ErrorString;
#define HANDLE_CASE(a,b) case a: ErrorString += TEXT(#a ": " b); break;
switch (Signal)
{
case 0:
// No signal - used for initialization stacktrace on non-fatal errors (ex: ensure)
break;
case SIGSEGV:
ErrorString += TEXT("SIGSEGV: invalid attempt to access memory at address ");
ErrorString += FString::Printf(TEXT("0x%08x"), (uint32*)Info->si_addr);
break;
case SIGBUS:
ErrorString += TEXT("SIGBUS: invalid attempt to access memory at address ");
ErrorString += FString::Printf(TEXT("0x%08x"), (uint32*)Info->si_addr);
break;
HANDLE_CASE(SIGINT, "program interrupted")
HANDLE_CASE(SIGQUIT, "user-requested crash")
HANDLE_CASE(SIGILL, "illegal instruction")
HANDLE_CASE(SIGTRAP, "trace trap")
HANDLE_CASE(SIGABRT, "abort() called")
HANDLE_CASE(SIGFPE, "floating-point exception")
HANDLE_CASE(SIGKILL, "program killed")
HANDLE_CASE(SIGSYS, "non-existent system call invoked")
HANDLE_CASE(SIGPIPE, "write on a pipe with no reader")
HANDLE_CASE(SIGTERM, "software termination signal")
HANDLE_CASE(SIGSTOP, "stop")
default:
ErrorString += FString::Printf(TEXT("Signal %d (unknown)"), Signal);
}
return ErrorString;
#undef HANDLE_CASE
}
// [[register]]
SEXP transpose_list(SEXP x_) {
SEXP x;
bool do_coerce = false;
int n = length(x_);
int N = length(VECTOR_ELT(x_, 0));
char type = max_type1(x_);
for (int i=0; i < n; ++i) {
if (length(VECTOR_ELT(x_, i)) != N) {
Rf_error("Each element in the list must be of the same length");
}
}
for (int i=0; i < n; ++i) {
if (TYPEOF( VECTOR_ELT(x_, i) ) != type) {
Rf_warning("Coercing vectors in the list to type '%s'", type2char(type));
do_coerce = true;
break;
}
}
if (do_coerce) {
x = PROTECT( duplicate(x_) );
for (int i=0; i < n; ++i) {
if (TYPEOF(VECTOR_ELT(x, i)) != type) {
SET_VECTOR_ELT(x, i, coerceVector(VECTOR_ELT(x, i), type));
}
}
} else {
x = x_;
}
SEXP output = PROTECT( allocVector(VECSXP, N) );
#define HANDLE_CASE(RTYPE, CTYPE, ACCESSOR) { \
for (int j=0; j < N; ++j) { \
SET_VECTOR_ELT(output, j, allocVector(RTYPE, n)); \
CTYPE* ptr = ACCESSOR( VECTOR_ELT(output, j) ); \
for (int i=0; i < n; ++i) { \
ptr[i] = ACCESSOR( VECTOR_ELT(x, i) )[j]; \
} \
} \
break; \
} \
switch (type) {
case LGLSXP: HANDLE_CASE(LGLSXP, int, LOGICAL);
case INTSXP: HANDLE_CASE(INTSXP, int, INTEGER);
case REALSXP: HANDLE_CASE(REALSXP, double, REAL);
case STRSXP: HANDLE_CASE(STRSXP, SEXP, STRING_PTR);
}
#undef HANDLE_CASE
UNPROTECT(1);
if (do_coerce) UNPROTECT(1);
return output;
}
void FApplePlatformCrashContext::CreateExceptionInfoString(int32 Signal, siginfo_t* Info)
{
#define HANDLE_CASE(a,b) case a: FCString::Strncpy(GErrorExceptionDescription, TEXT(#a ": " b), ARRAY_COUNT( SignalDescription ) - 1); break;
switch (Signal)
{
case SIGSEGV:
FCString::Strncpy(GErrorExceptionDescription, TEXT("SIGSEGV: invalid attempt to access memory at address 0x"), ARRAY_COUNT( SignalDescription ) - 1);
FCString::Strcat(GErrorExceptionDescription, ItoTCHAR((uintptr_t)Info->si_addr, 16));
break;
case SIGBUS:
FCString::Strncpy(GErrorExceptionDescription, TEXT("SIGBUS: invalid attempt to access memory at address 0x"), ARRAY_COUNT( SignalDescription ) - 1);
FCString::Strcat(GErrorExceptionDescription, ItoTCHAR((uintptr_t)Info->si_addr, 16));
break;
HANDLE_CASE(SIGINT, "program interrupted")
HANDLE_CASE(SIGQUIT, "user-requested crash")
HANDLE_CASE(SIGILL, "illegal instruction")
HANDLE_CASE(SIGTRAP, "trace trap")
HANDLE_CASE(SIGABRT, "abort() called")
HANDLE_CASE(SIGFPE, "floating-point exception")
HANDLE_CASE(SIGKILL, "program killed")
HANDLE_CASE(SIGSYS, "non-existent system call invoked")
HANDLE_CASE(SIGPIPE, "write on a pipe with no reader")
HANDLE_CASE(SIGTERM, "software termination signal")
HANDLE_CASE(SIGSTOP, "stop")
default:
FCString::Strncpy(GErrorExceptionDescription, TEXT("Signal "), ARRAY_COUNT( SignalDescription ) - 1);
FCString::Strcat(GErrorExceptionDescription, ItoTCHAR(Signal, 10));
FCString::Strcat(GErrorExceptionDescription, TEXT(" (unknown)"));
break;
}
#undef HANDLE_CASE
}
void FApplePlatformCrashContext::InitFromSignal(int32 InSignal, siginfo_t* InInfo, void* InContext)
{
Signal = InSignal;
Info = InInfo;
Context = reinterpret_cast< ucontext_t* >( InContext );
#define HANDLE_CASE(a,b) case a: FCStringAnsi::Strncpy(SignalDescription, #a ": " b, ARRAY_COUNT( SignalDescription ) - 1); break;
switch (Signal)
{
case SIGSEGV:
FCStringAnsi::Strncpy(SignalDescription, "SIGSEGV: invalid attempt to access memory at address 0x", ARRAY_COUNT( SignalDescription ) - 1);
FCStringAnsi::Strcat(SignalDescription, ItoANSI((uintptr_t)Info->si_addr, 16));
break;
case SIGBUS:
FCStringAnsi::Strncpy(SignalDescription, "SIGBUS: invalid attempt to access memory at address 0x", ARRAY_COUNT( SignalDescription ) - 1);
FCStringAnsi::Strcat(SignalDescription, ItoANSI((uintptr_t)Info->si_addr, 16));
break;
HANDLE_CASE(SIGINT, "program interrupted")
HANDLE_CASE(SIGQUIT, "user-requested crash")
HANDLE_CASE(SIGILL, "illegal instruction")
HANDLE_CASE(SIGTRAP, "trace trap")
HANDLE_CASE(SIGABRT, "abort() called")
HANDLE_CASE(SIGFPE, "floating-point exception")
HANDLE_CASE(SIGKILL, "program killed")
HANDLE_CASE(SIGSYS, "non-existent system call invoked")
HANDLE_CASE(SIGPIPE, "write on a pipe with no reader")
HANDLE_CASE(SIGTERM, "software termination signal")
HANDLE_CASE(SIGSTOP, "stop")
default:
FCStringAnsi::Strncpy(SignalDescription, "Signal ", ARRAY_COUNT( SignalDescription ) - 1);
FCStringAnsi::Strcat(SignalDescription, ItoANSI(Signal, 10));
FCStringAnsi::Strcat(SignalDescription, " (unknown)");
break;
}
#undef HANDLE_CASE
}
void audio_init(void)
{
FILE *f;
puts("Initializing the audio subsystem");
memset(_streams, -1, sizeof _streams);
puts("\tInitializing SDL audio");
HANDLE_CASE(SDL_Init(SDL_INIT_AUDIO) == -1);
SDL_AudioSpec fmt;
fmt.freq = 22050;
fmt.format = AUDIO_S16;
fmt.channels = 1;
fmt.samples = 512;
fmt.callback = _mixaudio;
fmt.userdata = NULL;
HANDLE_CASE(SDL_OpenAudio(&fmt, NULL) == -1);
SDL_PauseAudio(0);
puts("\tLoading sounds.raw");
f = fopen("sounds.raw", "r");
HANDLE_CASE(f == NULL);
HANDLE_CASE(fseek(f, 0, SEEK_END) != 0);
int filesize = ftell(f);
HANDLE_CASE(filesize <= 0);
HANDLE_CASE(fseek(f, 0, SEEK_SET) != 0);
_all_sounds = malloc(filesize);
HANDLE_CASE(fread(_all_sounds, filesize, 1, f) != 1);
HANDLE_CASE(fclose(f) != 0);
_all_sounds_length = filesize / 2;
puts("\tLoading sounds.desc");
// sounds.desc consists of two entries per line:
// <name of the sound> <the number of samples it has>
f = fopen("sounds.desc", "r");
HANDLE_CASE(f == NULL);
char name[MAXSTR];
int begin = 0, length;
while (fscanf(f, "%60s %d", name, &length) == 2) {
HANDLE_CASE(_sounds_count >= _MAX_SOUNDS);
int idx = _sounds_count++;
_sounds_desc[idx].begin = begin;
begin += length;
_sounds_desc[idx].end = begin;
strcpy(_sounds_desc[idx].name, name);
HANDLE_CASE(begin > _all_sounds_length);
}
HANDLE_CASE(fclose(f) != 0);
}
// [[register]]
SEXP unmelt(SEXP data, SEXP uniq_id, SEXP other_ind_, SEXP id_ind_, SEXP value_ind_) {
// int id_ind = asInteger(id_ind_);
int value_ind = asInteger(value_ind_);
int* other_ind = INTEGER(other_ind_);
int nRow = (int)(length(VECTOR_ELT(data, 0)) / length(uniq_id));
int numprotect = 0;
if (TYPEOF(uniq_id) != STRSXP) {
GUARD(uniq_id = coerceVector(uniq_id, STRSXP));
}
int n_uniq = length(uniq_id);
SEXP output;
GUARD(output = allocVector(VECSXP, length(other_ind_) + length(uniq_id)));
int n_other = length(other_ind_);
// ensure that the unmelting process will go smoothly
#define HANDLE_CASE(RTYPE, CTYPE, ACCESSOR) \
case RTYPE: { \
CTYPE* tmp = ACCESSOR( VECTOR_ELT(data, other_ind[i]) ); \
for (int j=0; j < nRow; ++j) { \
for (int k=1; k < n_uniq; ++k) { \
if (tmp[j] != tmp[j + nRow*k]) { \
Rf_error("Mismatch in elements at indices %i and %i in vector %s", j+1, j + nRow*k+1, CHAR(STRING_ELT(getAttrib(data, R_NamesSymbol), other_ind[i]))); \
} \
} \
} \
break; \
} \
if (n_uniq > 1) {
for (int i=0; i < n_other; ++i) {
switch (TYPEOF(VECTOR_ELT(data, other_ind[i]))) {
HANDLE_CASE(LGLSXP, int, LOGICAL);
HANDLE_CASE(INTSXP, int, INTEGER);
HANDLE_CASE(REALSXP, double, REAL);
HANDLE_CASE(STRSXP, SEXP, STRING_PTR);
default: Rf_error("Unhandled type %s", type2char(TYPEOF(VECTOR_ELT(data, other_ind[i]))));
}
}
}
#undef HANDLE_CASE
// copy in the 'other' variables first
#define COPY(RTYPE, CTYPE, ACCESSOR) { \
PROTECT(tmp = allocVector(RTYPE, nRow)); \
CTYPE* tmp_ptr = ACCESSOR(tmp); \
CTYPE* data_ptr = ACCESSOR(VECTOR_ELT(data, other_ind[i])); \
for (int i=0; i < nRow; ++i) { \
tmp_ptr[i] = data_ptr[i]; \
} \
SET_VECTOR_ELT(output, i, tmp); \
UNPROTECT(1); \
break; \
} \
SEXP tmp;
for (int i=0; i < n_other; ++i) {
switch (TYPEOF(VECTOR_ELT(data, other_ind[i]))) {
case LGLSXP: COPY(LGLSXP, int, LOGICAL);
case INTSXP: COPY(INTSXP, int, INTEGER);
case REALSXP: COPY(REALSXP, double, REAL);
case STRSXP: COPY(STRSXP, SEXP, STRING_PTR);
default: Rf_error("Unhandled SEXP type");
}
}
#undef COPY
#define COPY(RTYPE, CTYPE, ACCESSOR) { \
PROTECT(tmp = allocVector(RTYPE, nRow)); \
CTYPE* tmp_ptr = ACCESSOR(tmp); \
CTYPE* data_ptr = ACCESSOR(VECTOR_ELT(data, value_ind)); \
for (int j=0; j < nRow; ++j) { \
tmp_ptr[j] = data_ptr[j + (i*nRow)]; \
} \
SET_VECTOR_ELT(output, i + n_other, tmp); \
UNPROTECT(1); \
break; \
} \
// copy the value
int valuetype = TYPEOF(VECTOR_ELT(data, value_ind));
for (int i=0; i < n_uniq; ++i) {
switch (valuetype) {
case LGLSXP: COPY(LGLSXP, int, LOGICAL);
case INTSXP: COPY(INTSXP, int, INTEGER);
case REALSXP: COPY(REALSXP, double, REAL);
case STRSXP: COPY(STRSXP, SEXP, STRING_PTR);
}
}
// set the names
SEXP datanames = getAttrib(data, R_NamesSymbol);
SEXP names;
GUARD(names = allocVector(STRSXP, n_other + n_uniq));
for (int i=0; i < n_other; ++i) {
SET_STRING_ELT(names, i, STRING_ELT(datanames, i));
}
for (int i=0; i < n_uniq; ++i) {
SET_STRING_ELT(names, n_other+i, STRING_ELT(uniq_id, i));
}
setAttrib(output, R_NamesSymbol, names);
// set the class
setAttrib(output, R_ClassSymbol, mkString("data.frame"));
// set the rows
SEXP rownames;
GUARD( rownames=allocVector(INTSXP, nRow) );
int* rownames_ptr = INTEGER(rownames);
for (int i=0; i < nRow; ++i) {
rownames_ptr[i] = i+1;
}
setAttrib(output, R_RowNamesSymbol, rownames);
UNGUARD;
return output;
}
