/*
* Thread trampoline function.
*/
static void thread_run(thread_func_t *start_func, ulong_t arg)
{
int_enable(); /* make sure interrupts are enabled */
start_func(arg);
thread_exit(0);
KASSERT(false); /* not reached */
}
static DWORD WINAPI
inner_start_thread (LPVOID arg)
{
ThreadStartInfo *start_info = arg;
void *t_arg = start_info->arg;
int post_result;
LPTHREAD_START_ROUTINE start_func = start_info->start_routine;
DWORD result;
gboolean suspend = start_info->suspend;
HANDLE suspend_event = start_info->suspend_event;
MonoThreadInfo *info;
info = mono_thread_info_attach (&result);
info->runtime_thread = TRUE;
info->create_suspended = suspend;
post_result = MONO_SEM_POST (&(start_info->registered));
g_assert (!post_result);
if (suspend) {
WaitForSingleObject (suspend_event, INFINITE); /* caller will suspend the thread before setting the event. */
CloseHandle (suspend_event);
}
result = start_func (t_arg);
mono_thread_info_detach ();
return result;
}
void thread_pool_add_job(thread_pool_type * pool , start_func_ftype * start_func , void * func_arg ) {
if (pool->max_running == 0) /* Blocking non-threaded mode: */
start_func( func_arg );
else {
if (pool->accepting_jobs) {
if (pool->queue_size == pool->queue_alloc_size)
thread_pool_resize_queue( pool , pool->queue_alloc_size * 2);
/*
The new job is added to the queue - the main thread is watching
the queue and will pick up the new job.
*/
{
int queue_index = pool->queue_size;
pool->queue[ queue_index ].pool = pool;
pool->queue[ queue_index ].func_arg = func_arg;
pool->queue[ queue_index ].func = start_func;
pool->queue[ queue_index ].return_value = NULL;
pool->queue[ queue_index ].queue_index = queue_index;
}
pool->queue_size++; /* <- This is shared between this thread and the dispatch thread */
} else
util_abort("%s: thread_pool is not running - restart with thread_pool_restart()?? \n",__func__);
}
}
static void*
inner_start_thread (void *arg)
{
StartInfo *start_info = (StartInfo *) arg;
void *t_arg = start_info->arg;
int res;
void *(*start_func)(void*) = start_info->start_routine;
guint32 flags = start_info->flags;
void *result;
HANDLE handle;
MonoThreadInfo *info;
/* Register the thread with the io-layer */
handle = wapi_create_thread_handle ();
if (!handle) {
res = MONO_SEM_POST (&(start_info->registered));
g_assert (!res);
return NULL;
}
start_info->handle = handle;
info = mono_thread_info_attach (&result);
MONO_PREPARE_BLOCKING
info->runtime_thread = TRUE;
info->handle = handle;
if (flags & CREATE_SUSPENDED) {
info->create_suspended = TRUE;
MONO_SEM_INIT (&info->create_suspended_sem, 0);
}
/* start_info is not valid after this */
res = MONO_SEM_POST (&(start_info->registered));
g_assert (!res);
start_info = NULL;
if (flags & CREATE_SUSPENDED) {
while (MONO_SEM_WAIT (&info->create_suspended_sem) != 0 &&
errno == EINTR);
MONO_SEM_DESTROY (&info->create_suspended_sem);
}
MONO_FINISH_BLOCKING
/* Run the actual main function of the thread */
result = start_func (t_arg);
mono_threads_core_exit (GPOINTER_TO_UINT (result));
g_assert_not_reached ();
}
Plugin *
PluginManager::load(std::string const & path)
{
if (!initialized)
{
std::cerr << "PluginManager: Manager not initialized" << std::endl;
return NULL;
}
if (dynlibs.find(path) != dynlibs.end()) return NULL;
DynLib * dynlib = DynLibManager::load(path);
dynlibs[path] = dynlib;
SNL_DLL_START_PLUGIN start_func = (SNL_DLL_START_PLUGIN)dynlib->getSymbol("dllStartPlugin");
return start_func(); // this must call install(), which adds the plugin to the installed list
}
static void*
inner_start_thread (void *arg)
{
ThreadStartInfo *start_info = arg;
void *t_arg = start_info->arg;
int post_result;
void *(*start_func)(void*) = start_info->start_routine;
void *result;
mono_thread_info_attach (&result);
post_result = MONO_SEM_POST (&(start_info->registered));
g_assert (!post_result);
result = start_func (t_arg);
g_assert (!mono_domain_get ());
return result;
}
static TInt silc_thread_start(TAny *context)
{
#ifdef SILC_THREADS
SilcSymbianThread *tc = (SilcSymbianThread *)context;
SilcThreadStart start_func = tc->start_func;
void *user_context = tc->context;
SilcBool waitable = tc->waitable;
SilcTls tls, other = tc->tls;
void *ret = NULL;
silc_free(tc);
tls = silc_thread_tls_init_shared(other);
CTrapCleanup *cs = CTrapCleanup::New();
if (cs) {
CActiveScheduler *s = new CActiveScheduler;
if(s) {
CActiveScheduler::Install(s);
/* Call the thread function */
TRAPD(ret_val, ret = start_func(user_context));
delete s;
}
delete cs;
}
if (tls->tls_variables)
silc_hash_table_free(tls->tls_variables);
silc_free(tls);
silc_thread_exit(ret);
#endif
return KErrNone;
}
static void*
inner_start_thread (void *arg)
{
StartInfo *start_info = arg;
void *t_arg = start_info->arg;
int res;
void *(*start_func)(void*) = start_info->start_routine;
guint32 flags = start_info->flags;
void *result;
HANDLE handle;
MonoThreadInfo *info;
/* Register the thread with the io-layer */
handle = wapi_create_thread_handle ();
if (!handle) {
res = MONO_SEM_POST (&(start_info->registered));
g_assert (!res);
return NULL;
}
start_info->handle = handle;
info = mono_thread_info_attach (&result);
info->runtime_thread = TRUE;
info->handle = handle;
if (flags & CREATE_SUSPENDED) {
info->create_suspended = TRUE;
MONO_SEM_INIT (&info->create_suspended_sem, 0);
}
/* start_info is not valid after this */
res = MONO_SEM_POST (&(start_info->registered));
g_assert (!res);
start_info = NULL;
if (flags & CREATE_SUSPENDED) {
while (MONO_SEM_WAIT (&info->create_suspended_sem) != 0 &&
errno == EINTR);
MONO_SEM_DESTROY (&info->create_suspended_sem);
}
/* Run the actual main function of the thread */
result = start_func (t_arg);
/*
mono_thread_info_detach ();
*/
#if defined(__native_client__)
nacl_shutdown_gc_thread();
#endif
wapi_thread_handle_set_exited (handle, GPOINTER_TO_UINT (result));
/* This is needed by mono_threads_core_unregister () which is called later */
info->handle = NULL;
g_assert (mono_threads_get_callbacks ()->thread_exit);
mono_threads_get_callbacks ()->thread_exit (NULL);
g_assert_not_reached ();
return result;
}
struct thread *backend_thread_create_varstack(bomp_thread_func_t start_func,
void *arg, size_t stacksize)
{
start_func(arg);
return NULL;
}
static void
_eventd_protocol_evp_parse_line(EventdProtocol *self, const gchar *line, GError **error)
{
#ifdef EVENTD_DEBUG
g_debug("[%s] Parse line: %.255s%s", _eventd_protocol_evp_states[self->state], line, ( strlen(line) > 255 ) ? " […]" : "");
#endif /* EVENTD_DEBUG */
const EventdProtocolTokens *message;
/*
* Handle the end of a dot message
*/
if ( g_strcmp0(line, ".") == 0 )
{
for ( message = _eventd_protocol_evp_dot_messages ; message->message != NULL ; ++message )
{
if ( self->state == message->continue_state )
return message->stop_func(self, error);
}
return g_set_error(error, EVENTD_PROTOCOL_PARSE_ERROR, EVENTD_PROTOCOL_PARSE_ERROR_UNEXPECTED_TOKEN, "Got '.' in an invalid state '%s'", _eventd_protocol_evp_states[self->state]);
}
/*
* Handle dot message line
*/
for ( message = _eventd_protocol_evp_dot_messages ; message->message != NULL ; ++message )
{
if ( self->state == message->continue_state )
{
if ( message->continue_func(self, line, error) )
return;
}
}
/*
* Either we got a brand new message
* or the dot message did not eat the line
*/
const EventdProtocolState *state;
if ( g_str_has_prefix(line, ".") )
{
message = _eventd_protocol_evp_dot_messages;
++line;
}
else
message = _eventd_protocol_evp_messages;
for ( ; message->message != NULL ; ++message )
{
if ( ! g_str_has_prefix(line, message->message) )
continue;
const gchar *args = line + strlen(message->message);
gchar **argv = NULL;
if ( g_str_has_prefix(args, " ") )
{
++args;
if ( message->max_args < 1 )
return g_set_error(error, EVENTD_PROTOCOL_PARSE_ERROR, EVENTD_PROTOCOL_PARSE_ERROR_MALFORMED, "Message '%s' does not take arguments, but got '%s'", message->message, args);
gsize argc;
argv = g_strsplit(args, " ", message->max_args);
argc = g_strv_length(argv);
if ( argc < message->min_args )
{
g_strfreev(argv);
return g_set_error(error, EVENTD_PROTOCOL_PARSE_ERROR, EVENTD_PROTOCOL_PARSE_ERROR_MALFORMED, "Message '%s' does take at least %" G_GSIZE_FORMAT " arguments, but got %" G_GSIZE_FORMAT, message->message, message->min_args, argc);
}
}
else if ( message->min_args > 0 )
return g_set_error(error, EVENTD_PROTOCOL_PARSE_ERROR, EVENTD_PROTOCOL_PARSE_ERROR_MALFORMED, "Message '%s' does take at least %" G_GSIZE_FORMAT " arguments, but got none", message->message, message->min_args);
gboolean valid = FALSE;
for ( state = message->start_states ; *state != _EVENTD_PROTOCOL_EVP_STATE_SIZE ; ++state )
{
if ( self->state == *state )
valid = TRUE;
}
if ( valid )
message->start_func(self, (const gchar * const *) argv, error);
else
g_set_error(error, EVENTD_PROTOCOL_PARSE_ERROR, EVENTD_PROTOCOL_PARSE_ERROR_UNEXPECTED_TOKEN, "Message '%s' in an invalid state '%s'", message->message, _eventd_protocol_evp_states[self->state]);
return;
}
}
static int encode_ogg (cdrom_drive *drive, rip_opts_s *rip_opts,
text_tag_s *text_tag, int track,
int tracktot, char *filename, char **filenames)
{
ogg_stream_state os;
ogg_page og;
ogg_packet op;
vorbis_dsp_state vd;
vorbis_block vb;
vorbis_info vi;
long samplesdone = 0;
int sector = 0, last_sector = 0;
long bytes_written = 0, packetsdone = 0;
double time_elapsed = 0.0;
int ret = 0;
time_t *timer;
double time;
int serialno = rand ();
vorbis_comment vc;
long total_samples_per_channel = 0;
int channels = 2;
int eos = 0;
long rate = 44100;
FILE *out = fopen (filename, "w+");
timer = timer_start ();
if (!rip_opts->managed && (rip_opts->min_bitrate > 0 || rip_opts->max_bitrate > 0)) {
log_msg ("Min or max bitrate requires managed", FL, FN, LN);
return -1;
}
if (rip_opts->bitrate < 0 && rip_opts->min_bitrate < 0 && rip_opts->max_bitrate < 0) {
rip_opts->quality_set = 1;
}
start_func (filename, rip_opts->bitrate, rip_opts->quality, rip_opts->quality_set,
rip_opts->managed, rip_opts->min_bitrate, rip_opts->max_bitrate);
vorbis_info_init (&vi);
if (rip_opts->quality_set > 0) {
if (vorbis_encode_setup_vbr (&vi, channels, rate, rip_opts->quality)) {
log_msg ("Couldn't initialize vorbis_info", FL, FN, LN);
vorbis_info_clear (&vi);
return -1;
}
/* two options here, max or min bitrate */
if (rip_opts->max_bitrate > 0 || rip_opts->min_bitrate > 0) {
struct ovectl_ratemanage_arg ai;
vorbis_encode_ctl (&vi, OV_ECTL_RATEMANAGE_GET, &ai);
ai.bitrate_hard_min = rip_opts->min_bitrate;
ai.bitrate_hard_max = rip_opts->max_bitrate;
ai.management_active = 1;
vorbis_encode_ctl (&vi, OV_ECTL_RATEMANAGE_SET, &ai);
}
} else {
if (vorbis_encode_setup_managed (&vi, channels, rate,
rip_opts->max_bitrate > 0 ? rip_opts->max_bitrate * 1000 : -1,
rip_opts->bitrate * 1000,
rip_opts->min_bitrate > 0 ? rip_opts->min_bitrate * 1000 : -1)) {
log_msg ("Mode init failed, encode setup managed", FL, FN, LN);
vorbis_info_clear (&vi);
return -1;
}
}
if (rip_opts->managed && rip_opts->bitrate < 0) {
vorbis_encode_ctl (&vi, OV_ECTL_RATEMANAGE_AVG, NULL);
} else if (!rip_opts->managed) {
vorbis_encode_ctl (&vi, OV_ECTL_RATEMANAGE_SET, NULL);
}
/* set advanced encoder options */
vorbis_encode_setup_init (&vi);
vorbis_analysis_init (&vd, &vi);
vorbis_block_init (&vd, &vb);
ogg_stream_init (&os, serialno);
{
ogg_packet header_main;
ogg_packet header_comments;
ogg_packet header_codebooks;
int result;
char buf[32];
vorbis_comment_init (&vc);
vorbis_comment_add_tag (&vc, "title", text_tag->songname);
vorbis_comment_add_tag (&vc, "artist", text_tag->artistname);
vorbis_comment_add_tag (&vc, "album", text_tag->albumname);
vorbis_comment_add_tag (&vc, "genre", text_tag->genre);
snprintf (buf, 32, "%d", text_tag->year);
vorbis_comment_add_tag (&vc, "date", buf);
snprintf (buf, 32, "%02d", text_tag->track);
vorbis_comment_add_tag (&vc, "tracknumber", buf);
vorbis_analysis_headerout (&vd, &vc, &header_main, &header_comments, &header_codebooks);
ogg_stream_packetin (&os, &header_main);
ogg_stream_packetin (&os, &header_comments);
ogg_stream_packetin (&os, &header_codebooks);
while ((result = ogg_stream_flush (&os, &og))) {
if (result == 0)
break;
ret = write_page (&og, out);
if (ret != og.header_len + og.body_len) {
log_msg ("Failed writing data to output stream", FL, FN, LN);
ret = -1;
}
}
sector = cdda_track_firstsector (drive, track);
last_sector = cdda_track_lastsector (drive, track);
total_samples_per_channel = (last_sector - sector) * (CD_FRAMESAMPLES / 2);
int eos = 0;
while (!eos) {
signed char *buffer = (signed char *)malloc (CD_FRAMESIZE_RAW * READ_SECTORS);
//use this variable as a s**t
long sectors_read = last_sector - sector;
if (sectors_read > READ_SECTORS)
sectors_read = READ_SECTORS;
sectors_read = cdda_read (drive, (signed char *)buffer, sector, sectors_read);
int i;
if (sectors_read == 0) {
vorbis_analysis_wrote (&vd, 0);
} else {
float **vorbbuf = vorbis_analysis_buffer (&vd, CD_FRAMESIZE_RAW * sectors_read);
for (i = 0; i < (CD_FRAMESIZE_RAW * sectors_read) / 4; i++) {
vorbbuf[0][i] = ((buffer[i * 4 + 1] << 8) | (0x00ff&(int)buffer[i * 4])) / 32768.f;
vorbbuf[1][i] = ((buffer[i * 4 + 3] << 8) | (0x00ff&(int)buffer[i * 4 + 2])) / 32768.f;
}
int samples_read = sectors_read * (CD_FRAMESAMPLES / 2);
samplesdone += samples_read;
// progress every 60 pages
if (packetsdone >= 60) {
packetsdone = 0;
time = timer_time (timer);
update_statistics (total_samples_per_channel, samplesdone, time, track,
tracktot, 0, filenames);
}
vorbis_analysis_wrote (&vd, i);
}
free (buffer);
sector += sectors_read;
while (vorbis_analysis_blockout (&vd, &vb) == 1) {
vorbis_analysis (&vb, &op);
vorbis_bitrate_addblock (&vb);
while (vorbis_bitrate_flushpacket (&vd, &op)) {
ogg_stream_packetin (&os, &op);
packetsdone++;
while (!eos) {
int result = ogg_stream_pageout (&os, &og);
if (result == 0) {
break;
}
ret = write_page (&og, out);
if (ret != og.header_len + og.body_len) {
log_msg ("Failed writing data to output stream", FL, FN, LN);
ret = -1;
} else
bytes_written += ret;
if (ogg_page_eos (&og)) {
eos = 1;
}
}
}
}
}
}
ret = 0;
update_statistics (total_samples_per_channel, samplesdone, time, track,
tracktot, 0, filenames);
ogg_stream_clear (&os);
vorbis_block_clear (&vb);
vorbis_dsp_clear (&vd);
vorbis_comment_clear (&vc);
vorbis_info_clear (&vi);
vorbis_comment_clear (&vc);
time_elapsed = timer_time (timer);
end_func (time_elapsed, rate, samplesdone, bytes_written);
timer_clear (timer);
fclose (out);
return ret;
}
//
// no point in reinventing the wheel; start_event and start_update both
// need to be handled exactly the same, so here's a function to do just that
PyObject *PyEvent_start(PyObject *self, PyObject *args, void *func) {
void (* start_func)(void *, int, void *, void *, void *, const char *) = func;
PyObject *PyOwner = NULL; // the python representation of our owner
PyObject *efunc = NULL; // the event function
PyObject *edata = Py_None; // the event data
char *arg = NULL; // the arg we will be supplying to the function
double delay = 0; // how long the event delay is (in seconds)
void *owner = NULL; // actual owner supplied to the event handler
char otype[20]; // is the owner a char, room, obj, or None?
// try to parse all of our values
if(!PyArg_ParseTuple(args, "OdO|Os", &PyOwner, &delay, &efunc, &edata, &arg)){
//PyErr_Format(PyExc_TypeError,
//"Invalid arguments provided to event handler");
return NULL;
}
// make sure our event is a function
if(!PyFunction_Check(efunc)) {
PyErr_Format(PyExc_TypeError,
"The event handler supplied must be a python function");
return NULL;
}
// figure out what type of data our owner is
if(PyOwner == Py_None) {
owner = NULL;
sprintf(otype, "none");
}
else if(PyChar_Check(PyOwner)) {
owner = PyChar_AsChar(PyOwner);
sprintf(otype, "char");
}
else if(PyRoom_Check(PyOwner)) {
owner = PyRoom_AsRoom(PyOwner);
sprintf(otype, "room");
}
else if(PyObj_Check(PyOwner)) {
owner = PyObj_AsObj(PyOwner);
sprintf(otype, "obj");
}
// invalid type
else {
PyErr_Format(PyExc_TypeError,
"An event owner must be a room, char, obj, or none");
return NULL;
}
// make sure the owner exists
if(PyOwner != Py_None && owner == NULL) {
PyErr_Format(PyExc_StandardError, "Owner supplied does not exist in game");
return NULL;
}
// now, queue up the action
start_func(owner, (int)(delay SECONDS), PyEvent_on_complete, NULL,
Py_BuildValue("sOO", otype, efunc, edata), arg);
// everything seems ok. exit normally
return Py_BuildValue("i", 1);
}
