bool init_button(button_t *btn, widget_t *parent,
const char *caption, uint16_t points, pixel_t background, pixel_t foreground)
{
widget_init(&btn->widget, parent);
btn->widget.destroy = button_destroy;
btn->widget.reconfigure = button_reconfigure;
btn->widget.rearrange = button_rearrange;
btn->widget.repaint = button_repaint;
btn->widget.handle_keyboard_event = button_handle_keyboard_event;
btn->widget.handle_position_event = button_handle_position_event;
source_init(&btn->background);
source_set_color(&btn->background, background);
source_init(&btn->foreground);
source_set_color(&btn->foreground, foreground);
if (caption == NULL) {
btn->caption = NULL;
} else {
btn->caption = str_dup(caption);
}
font_init(&btn->font, FONT_DECODER_EMBEDDED, NULL, points);
sysarg_t cpt_width;
sysarg_t cpt_height;
font_get_box(&btn->font, btn->caption, &cpt_width, &cpt_height);
btn->widget.width_min = cpt_width + 8;
btn->widget.height_min = cpt_height + 8;
btn->widget.width_ideal = cpt_width + 28;
btn->widget.height_ideal = cpt_height + 8;
return true;
}
static int get_glyph_surface(bitmap_backend_data_t *data, glyph_id_t glyph_id,
surface_t **result)
{
if (glyph_id >= data->glyph_count)
return ENOENT;
if (data->glyph_cache[glyph_id].surface != NULL) {
*result = data->glyph_cache[glyph_id].surface;
return EOK;
}
surface_t *raw_surface;
int rc = data->decoder->load_glyph_surface(data->decoder_data, glyph_id,
&raw_surface);
if (rc != EOK)
return rc;
sysarg_t w;
sysarg_t h;
surface_get_resolution(raw_surface, &w, &h);
if (!data->scale) {
*result = raw_surface;
return EOK;
}
source_t source;
source_init(&source);
source_set_texture(&source, raw_surface, PIXELMAP_EXTEND_TRANSPARENT_BLACK);
transform_t transform;
transform_identity(&transform);
transform_translate(&transform, 0.5, 0.5);
transform_scale(&transform, data->scale_ratio, data->scale_ratio);
source_set_transform(&source, transform);
surface_coord_t scaled_width = (data->scale_ratio * ((double) w) + 0.5);
surface_coord_t scaled_height = (data->scale_ratio * ((double) h) + 0.5);
surface_t *scaled_surface = surface_create(scaled_width, scaled_height,
NULL, 0);
if (!scaled_surface) {
surface_destroy(raw_surface);
return ENOMEM;
}
drawctx_t context;
drawctx_init(&context, scaled_surface);
drawctx_set_source(&context, &source);
drawctx_transfer(&context, 0, 0, scaled_width, scaled_height);
surface_destroy(raw_surface);
data->glyph_cache[glyph_id].surface = scaled_surface;
*result = scaled_surface;
return EOK;
}
static int a2dp_source_probe(struct btd_service *service)
{
struct btd_device *dev = btd_service_get_device(service);
DBG("path %s", device_get_path(dev));
source_init(service);
return 0;
}
static void untagged_0() {
i32 local_DEBUG;
source_init();
local_DEBUG = DEBUG;
if (local_DEBUG) {
printf("Source ACTION: initialize\n");
printf("Source STATE: ReadInit\n");
printf("-------------------------\n");
}
// Update ports indexes
}
void graphics_draw_tile(const context_t* ctx, window_t* window,
uint16_t tile_id, size_t x, size_t y)
{
palette_t palette = {
{0, 1, 2, 3}
};
for (size_t tile_y = 0; tile_y < TILE_HEIGHT; tile_y++) {
source_t src;
dest_t dst;
dest_init(&dst, window->surface, x, y + tile_y, window->surface->w - x);
source_init(&src, &ctx->mem.gfx.tiles.data[tile_id], 0, tile_y);
draw_tile(&dst, &src, palette);
}
}
void sound_play(int id, float volume, float panning, float pitch) {
// Get sample data
char *buf;
int len;
if(sounds_loader_get(id, &buf, &len) != 0) {
return;
}
// Play
audio_source *src = malloc(sizeof(audio_source));
source_init(src);
raw_source_init(src, buf, len);
unsigned int sound_id = sink_play_set(audio_get_sink(), src, volume, panning, pitch);
sink_set_stream_volume(audio_get_sink(), sound_id, sound_volume);
}
int
main(int argc, const char *argv[])
{
int result = 0;
apr_pool_t *mp;
apr_status_t status;
char next_char;
Source *source = NULL;
apr_initialize();
status = apr_pool_create(&mp, NULL);
handle_and_display_error(status);
source_init(&source, mp);
status = source_set_options(source, argc, argv, mp);
handle_and_display_error(status);
status = source_open(source, mp);
handle_and_display_error(status);
while (source_shift_character(source, &next_char) == APR_SUCCESS) {
printf("%c", next_char);
}
goto cleanup;
error:
result = 1;
cleanup:
if (source) { source_cleanup(source); }
apr_pool_destroy(mp);
apr_terminate();
return result;
}
void main_open_window()
{
main_freemem_hook = freemem_alloc_hook();
char *initdir = getenv("DB101_LASTDIR");
if(initdir)
strcpy(lastdir, initdir);
variables_init();
console_init();
stacktrace_init();
source_init();
disassembler_init();
sourcelist_init();
pipe_init();
AppPort = IExec->AllocSysObjectTags(ASOT_PORT, TAG_DONE);
/* Create the window object. */
if(( MainWinObj = WindowObject,
WA_ScreenTitle, "Debug 101",
WA_Title, "Debug 101 v1.1.0 BETA - secret edition ;)",
WA_Width, 1024,
WA_Height, 768,
WA_DepthGadget, TRUE,
WA_SizeGadget, TRUE,
WA_DragBar, TRUE,
WA_CloseGadget, TRUE,
WA_Activate, TRUE,
WINDOW_NewMenu, mynewmenu,
WINDOW_MenuUserData, WGUD_IGNORE,
WINDOW_IconifyGadget, TRUE,
WINDOW_IconTitle, "Debug 101",
WINDOW_AppPort, AppPort,
WINDOW_Position, WPOS_CENTERSCREEN,
/* there is no HintInfo array set up here, instead we define the
** strings directly when each gadget is created (OM_NEW)
*/
WINDOW_GadgetHelp, TRUE,
WINDOW_ParentGroup, MainObj[GAD_TOPLAYOUT] = VLayoutObject,
LAYOUT_AddChild, HLayoutObject,
LAYOUT_AddChild, MainObj[GAD_SELECT_BUTTON] = ButtonObject,
GA_ID, GAD_SELECT_BUTTON,
GA_Text, "Select file",
GA_RelVerify, TRUE,
GA_HintInfo, "Push to select file",
ButtonEnd,
CHILD_WeightedWidth, 0,
LAYOUT_AddChild, MainObj[GAD_RELOAD_BUTTON] = ButtonObject,
GA_ID, GAD_RELOAD_BUTTON,
GA_Text, "Reload",
GA_RelVerify, TRUE,
GA_Disabled, TRUE,
GA_HintInfo, "Push to reload previously executed file",
ButtonEnd,
CHILD_WeightedWidth, 0,
LAYOUT_AddChild, MainObj[GAD_FILENAME_STRING] = StringObject,
GA_ID, GAD_FILENAME_STRING,
GA_RelVerify, TRUE,
GA_HintInfo, "Filename",
GA_Disabled, TRUE,
GA_ReadOnly, TRUE,
STRINGA_MinVisible, 10,
STRINGA_TextVal, "Select File",
StringEnd,
LAYOUT_AddChild, MainObj[GAD_ATTACH_BUTTON] = ButtonObject,
GA_ID, GAD_ATTACH_BUTTON,
GA_Text, "Attach",
GA_RelVerify, TRUE,
GA_HintInfo, "Push to attach to process",
ButtonEnd,
CHILD_WeightedWidth, 0,
LAYOUT_AddChild, SpaceObject,
SPACE_MinWidth, 24,
SpaceEnd,
LAYOUT_AddChild, MainObj[GAD_START_BUTTON] = ButtonObject,
GA_ID, GAD_START_BUTTON,
GA_RelVerify, TRUE,
GA_Text, "Continue",
GA_Disabled, TRUE,
ButtonEnd,
CHILD_WeightedHeight, 0,
LAYOUT_AddChild, MainObj[GAD_PAUSE_BUTTON] = ButtonObject,
GA_ID, GAD_PAUSE_BUTTON,
GA_RelVerify, TRUE,
GA_Text, "Pause",
GA_Disabled, TRUE,
ButtonEnd,
CHILD_WeightedHeight, 0,
LAYOUT_AddChild, MainObj[GAD_KILL_BUTTON] = ButtonObject,
GA_ID, GAD_KILL_BUTTON,
GA_RelVerify, TRUE,
GA_Text, "Kill",
GA_Disabled, TRUE,
ButtonEnd,
CHILD_WeightedHeight, 0,
#if 0
LAYOUT_AddChild, CrashButtonObj = ButtonObject,
GA_ID, GAD_CRASH_BUTTON,
GA_RelVerify, TRUE,
GA_Text, "Crash",
GA_Disabled, TRUE,
ButtonEnd,
CHILD_WeightedHeight, 0,
#endif
LAYOUT_AddChild, MainObj[GAD_STEPOVER_BUTTON] = ButtonObject,
GA_ID, GAD_STEPOVER_BUTTON,
GA_RelVerify, TRUE,
GA_Text, "Step Over",
GA_Disabled, TRUE,
ButtonEnd,
CHILD_WeightedHeight, 0,
LAYOUT_AddChild, MainObj[GAD_STEPINTO_BUTTON] = ButtonObject,
GA_ID, GAD_STEPINTO_BUTTON,
GA_RelVerify, TRUE,
GA_Text, "Step Into",
GA_Disabled, TRUE,
ButtonEnd,
CHILD_WeightedHeight, 0,
LAYOUT_AddChild, MainObj[GAD_STEPOUT_BUTTON] = ButtonObject,
GA_ID, GAD_STEPOUT_BUTTON,
GA_RelVerify, TRUE,
GA_Text, "Step Out",
GA_Disabled, TRUE,
ButtonEnd,
CHILD_WeightedHeight, 0,
LAYOUT_AddChild, SpaceObject,
SPACE_MinWidth, 24,
SpaceEnd,
LAYOUT_AddChild, MainObj[GAD_SETBREAK_BUTTON] = ButtonObject,
GA_ID, GAD_SETBREAK_BUTTON,
GA_RelVerify, TRUE,
GA_Text, "Breaks",
GA_Disabled, TRUE,
ButtonEnd,
CHILD_WeightedHeight, 0,
LAYOUT_AddChild, MainObj[GAD_HEX_BUTTON] = ButtonObject,
GA_ID, GAD_HEX_BUTTON,
GA_RelVerify, TRUE,
GA_Text, "Hex",
GA_Disabled, TRUE,
ButtonEnd,
CHILD_WeightedHeight, 0,
EndMember,
CHILD_WeightedHeight, 0,
LAYOUT_AddChild, HLayoutObject,
LAYOUT_AddChild, MainObj[GAD_STACKTRACE_LISTBROWSER] = ListBrowserObject,
GA_ID, GAD_STACKTRACE_LISTBROWSER,
GA_RelVerify, TRUE,
GA_TabCycle, TRUE,
LISTBROWSER_AutoFit, TRUE,
LISTBROWSER_Labels, &stacktrace_list,
// LISTBROWSER_ColumnInfo, columninfo,
LISTBROWSER_ColumnTitles, FALSE,
LISTBROWSER_ShowSelected, FALSE,
LISTBROWSER_Striping, LBS_ROWS,
ListBrowserEnd,
LAYOUT_AddChild, MainObj[GAD_VARIABLES_LISTBROWSER] = ListBrowserObject,
GA_ID, GAD_VARIABLES_LISTBROWSER,
GA_RelVerify, TRUE,
GA_TabCycle, TRUE,
LISTBROWSER_Hierarchical, TRUE,
//LISTBROWSER_AutoFit, TRUE,
LISTBROWSER_Labels, &variable_list,
LISTBROWSER_ColumnInfo, variablescolumninfo,
LISTBROWSER_ColumnTitles, TRUE,
//LISTBROWSER_ShowSelected, TRUE, /* not really needed yet */
LISTBROWSER_Striping, LBS_ROWS,
LISTBROWSER_SortColumn, 0,
LISTBROWSER_TitleClickable, TRUE,
ListBrowserEnd,
EndMember,
LAYOUT_AddChild, HLayoutObject,
LAYOUT_AddChild, MainObj[GAD_CLICKTAB] = ClickTabObject,
GA_Text, PageLabels_1,
CLICKTAB_Current, 0,
CLICKTAB_PageGroup, PageObject,
PAGE_Add, VLayoutObject,
//LAYOUT_SpaceOuter, TRUE,
//LAYOUT_DeferLayout, TRUE,
LAYOUT_AddChild, MainObj[GAD_SOURCE_LISTBROWSER] = ListBrowserObject,
GA_ID, GAD_SOURCE_LISTBROWSER,
GA_RelVerify, TRUE,
GA_TabCycle, TRUE,
LISTBROWSER_AutoFit, TRUE,
LISTBROWSER_Labels, &source_list,
LISTBROWSER_ColumnInfo, sourcecolumninfo,
LISTBROWSER_ColumnTitles, TRUE,
LISTBROWSER_ShowSelected, TRUE,
//LISTBROWSER_Striping, LBS_ROWS,
ListBrowserEnd,
EndMember,
PAGE_Add, VLayoutObject,
LAYOUT_AddChild, MainObj[GAD_DISASSEMBLER_LISTBROWSER] = ListBrowserObject,
GA_ID, GAD_DISASSEMBLER_LISTBROWSER,
GA_RelVerify, TRUE,
GA_TabCycle, TRUE,
//GA_TextAttr, &courier_font,
LISTBROWSER_AutoFit, TRUE,
LISTBROWSER_Labels, &disassembly_list,
LISTBROWSER_ShowSelected, TRUE,
LISTBROWSER_Striping, LBS_ROWS,
ListBrowserEnd,
LAYOUT_AddChild, HLayoutObject,
LAYOUT_AddChild, MainObj[GAD_DISASSEMBLER_STEP_BUTTON] = ButtonObject,
GA_ID, GAD_DISASSEMBLER_STEP_BUTTON,
GA_RelVerify, TRUE,
GA_Text, "Step",
ButtonEnd,
CHILD_WeightedHeight, 0,
LAYOUT_AddChild, MainObj[GAD_DISASSEMBLER_SKIP_BUTTON] = ButtonObject,
GA_ID, GAD_DISASSEMBLER_SKIP_BUTTON,
GA_RelVerify, TRUE,
GA_Text, "Skip",
ButtonEnd,
CHILD_WeightedHeight, 0,
EndMember,
CHILD_WeightedHeight, 0,
EndMember,
PageEnd,
EndMember,
LAYOUT_WeightBar, TRUE,
LAYOUT_AddChild, VLayoutObject,
LAYOUT_AddChild, MainObj[GAD_SOURCELIST_LISTBROWSER] = ListBrowserObject,
GA_ID, GAD_SOURCELIST_LISTBROWSER,
GA_RelVerify, TRUE,
GA_TabCycle, TRUE,
LISTBROWSER_AutoFit, TRUE,
LISTBROWSER_Labels, &sourcelist_list,
LISTBROWSER_ShowSelected, TRUE,
LISTBROWSER_Striping, LBS_ROWS,
ListBrowserEnd,
LAYOUT_AddChild, MainObj[GAD_IMPORT_BUTTON] = ButtonObject,
GA_ID, GAD_IMPORT_BUTTON,
GA_RelVerify, TRUE,
GA_Text, "Import externals",
ButtonEnd,
CHILD_WeightedHeight, 0,
EndMember,
CHILD_WeightedWidth, 20,
EndMember,
LAYOUT_AddChild, HLayoutObject,
LAYOUT_AddChild, MainObj[GAD_CONSOLE_LISTBROWSER] = ListBrowserObject,
GA_ID, GAD_CONSOLE_LISTBROWSER,
GA_RelVerify, TRUE,
GA_TabCycle, TRUE,
LISTBROWSER_AutoFit, TRUE,
LISTBROWSER_Labels, &console_list,
ListBrowserEnd,
EndMember,
LAYOUT_AddChild, HLayoutObject,
LAYOUT_AddChild, MainObj[GAD_AREXX_STRING] = StringObject,
GA_ID, GAD_AREXX_STRING,
GA_RelVerify, TRUE,
GA_Disabled, FALSE,
GA_ReadOnly, FALSE,
STRINGA_TextVal, "",
StringEnd,
LAYOUT_AddChild, MainObj[GAD_AREXX_BUTTON] = ButtonObject,
GA_ID, GAD_AREXX_BUTTON,
GA_RelVerify, TRUE,
GA_Text, "Send",
GA_Disabled, FALSE,
ButtonEnd,
CHILD_WeightedHeight, 0,
CHILD_WeightedWidth, 0,
LAYOUT_AddChild, MainObj[GAD_SIGNAL_BUTTON] = ButtonObject,
GA_ID, GAD_SIGNAL_BUTTON,
GA_RelVerify, TRUE,
GA_Text, "Signal",
GA_Disabled, FALSE,
ButtonEnd,
CHILD_WeightedHeight, 0,
CHILD_WeightedWidth, 0,
LAYOUT_AddChild, MainObj[GAD_X_BUTTON] = ButtonObject,
GA_ID, GAD_X_BUTTON,
GA_RelVerify, TRUE,
GA_Text, "X",
GA_Disabled, FALSE,
ButtonEnd,
CHILD_WeightedHeight, 0,
CHILD_WeightedWidth, 0,
EndMember,
CHILD_WeightedHeight, 0,
EndMember,
EndWindow))
{
/* Open the window. */
if( mainwin = (struct Window *) RA_OpenWindow(MainWinObj) )
{
main_window_is_open = TRUE;
button_set_start();
}
}
return;
}
void
draw_line(context_t *ctx) {
gfx_t* gfx = &ctx->gfx;
uint8_t screen_y = ctx->mem.io.LY;
map_t src;
dest_t dest;
palette_t palette;
if (!graphics_lock(ctx))
{
return;
}
// Background
if (lcdc_background_enabled(&ctx->mem))
{
palette = palette_decode(ctx->mem.io.BGP);
map_init(
&src, &ctx->mem,
lcdc_background_tile_map(&ctx->mem),
ctx->mem.io.SCX, screen_y + ctx->mem.io.SCY
);
dest_init(
&dest,
gfx->background,
0, screen_y, SCREEN_WIDTH
);
draw_tiles(&dest, &src, palette);
}
// Window
uint8_t window_y = ctx->mem.io.WY;
// TODO: What happens on underflow?
uint8_t window_x = ctx->mem.io.WX - 7;
if (lcdc_window_enabled(&ctx->mem) && screen_y >= window_y &&
window_x < SCREEN_WIDTH)
{
palette = palette_decode(ctx->mem.io.BGP);
map_init(
&src, &ctx->mem,
lcdc_window_tile_map(&ctx->mem),
window_x, screen_y + gfx->window_y
);
dest_init(
&dest,
gfx->background,
window_x, screen_y, SCREEN_WIDTH - window_x
);
draw_tiles(&dest, &src, palette);
gfx->window_y += 1;
}
// Sprites
if (lcdc_sprites_enabled(&ctx->mem))
{
size_t sprite_height = lcdc_sprite_height(&ctx->mem);
sprite_table_t sprites = { .length = 0 };
for (size_t i = 0; i < MAX_SPRITES; i++)
{
sprite_t sprite;
sprite_decode(&sprite, &ctx->mem.gfx.oam[i]);
if (!sprite.visible) {
continue;
}
if (screen_y >= sprite.y && screen_y < sprite.y + sprite_height)
{
graphics_sprite_table_add(&sprites, &sprite);
}
}
palette_t spp_high, spp_low;
spp_high = palette_decode(ctx->mem.io.SPP_HIGH);
spp_low = palette_decode(ctx->mem.io.SPP_LOW);
// <sprites> holds the 10 sprites with highest priority,
// sorted by ascending x coordinate. Since sprites
// with lower x coords write over tiles with higher x coords
// we draw in reverse order.
for (int i = sprites.length - 1; i >= 0; i--)
{
const sprite_t* sprite = &sprites.data[i];
source_t src;
dest_t dst;
if (sprite->x >= SCREEN_WIDTH) {
continue;
}
source_init(
&src,
&ctx->mem.gfx.tiles.data[sprite->tile_id],
sprite->tile_x, sprite->tile_y + (screen_y - sprite->y)
);
dest_init(
&dst,
sprite->in_background ? gfx->sprites_bg : gfx->sprites_fg,
sprite->x, screen_y, TILE_WIDTH
);
draw_tile(
&dst,
&src,
sprite->high_palette ? spp_high : spp_low
);
}
}
graphics_unlock(ctx);
}
int main() {
Py_Initialize(); // start Python interpreter
PyObject* sysPath = PySys_GetObject((char*)"path");
// sysPath has a borrowed reference, no need to decref it
PyObject* curDir = PyString_FromString(".");
PyList_Append(sysPath, curDir);
Py_DECREF(curDir);
FILE * fp;
time_t current_time;
char* c_time_string;
int i, j, k, cnt;
LUC_sim_pars *simp;
LUC_fields *fields;
LUC_diel_mat *diel;
LUC_abc_fields *abc_fields;
LUC_source **src;
printf("------------------------------ LUCIFER v0.3 ------------------------------\n\n");
simp = par_config("luc");//<----fix name
if(!simp){
printf(C_RED "[ERROR]" C_RES " failed to read configuration file %s\n","luc");
return 0;
}
printf(C_GREEN "[MSG]" C_RES " configuration file read successfully\n");
fields = allocate_fields(simp);
if(!fields){
printf(C_RED "[ERROR]" C_RES " failed to allocate fields (out of memory?)\n");
return 0;
}
printf(C_GREEN "[MSG]" C_RES " e.m. fields are allocated\n");
diel = allocate_diel(simp);
if(!diel){
printf(C_RED "[ERROR]" C_RES " failed to allocate materials (out of memory?)\n");
return 0;
}
printf(C_GREEN "[MSG]" C_RES " materials and geometry are allocated\n");
abc_fields = allocate_abc(simp);
if(!abc_fields){
printf(C_RED "[ERROR]" C_RES " failed to allocate abc fields (out of memory?)\n");
return 0;
}
printf(C_GREEN "[MSG]" C_RES " fields for ABC are allocated\n");
src = malloc((*simp).n_sources*sizeof(LUC_source**));
if(!src){
printf(C_RED "[ERROR]" C_RES " failed to allocate sources (out of memory?)\n");
return 0;
}
for(cnt = 0; cnt < (*simp).n_sources; cnt++)
if(!source_init((*simp).src_files[cnt], &src[cnt], simp))
printf(C_RED "[ERROR]" C_RES "source_init: failed to allocated source %d\n",cnt);
printf(C_GREEN "[MSG]" C_RES " sources are allocated\n");
printf(C_GREEN "[MSG]" C_RES " building geometry...\n");
printf(C_GREEN "[MSG]" C_RES " msgs from " C_BLUE "%s.py" C_RES " begin\n",(*simp).geom_file);
build_geometry((*simp).geom_file, simp, diel);
printf(C_GREEN "[MSG]" C_RES " msgs from " C_BLUE "%s.py" C_RES " end\n",(*simp).geom_file);
printf(C_GREEN "[MSG]" C_RES " geometry done\n\n");
printf(C_GREEN "[MSG]" C_RES " simulated domain: x = %g m; y = %g m; z = %g m;\n",(*simp).size_x*(*simp).cell_size,(*simp).size_y*(*simp).cell_size,(*simp).size_z*(*simp).cell_size);
printf(C_GREEN "[MSG]" C_RES " simulated time: %g s\n", (*simp).sim_time);
printf(C_GREEN "[MSG]" C_RES " total number of time steps: %d\n", (*simp).max_time);
//'data will be saved in: ',data_file
// ask if OK
//--------------------------------
//---------- START SIM -----------
//--------------------------------
fp = fopen ("test.dat", "w");
write_header(fp, simp);
current_time = time(NULL);
c_time_string = ctime(¤t_time);
printf(C_GREEN "[MSG]" C_RES " simulation started on: %s", c_time_string);
for ((*simp).t_step = 0; (*simp).t_step < (*simp).max_time; (*simp).t_step++) {
updateH(fields, diel, simp);
updateE(fields, diel, simp);
// add source
for(cnt = 0; cnt < (*simp).n_sources; cnt++)
add_source(src[cnt], fields, simp);
// apply abc
abc(fields, abc_fields, simp);
// apply pbc
//pbc(pbc_k,pbc_f,pbc_l,pbc_r,pbc_b,pbc_t);
write_field_views(fp, fields, simp);
printf(C_GREEN "[MSG]" C_RES " completed: %.2f%%\r", ((float)(*simp).t_step/(float)(*simp).max_time)*100);
}
current_time = time(NULL);
c_time_string = ctime(¤t_time);
printf(C_GREEN "[MSG]" C_RES " simulation finished on: %s\n", c_time_string);
printf("----------------------------------- END ----------------------------------\n");
fclose(fp);
Py_Finalize();
return 1;
}
static void *start_relay_stream (void *arg)
{
client_t *client = arg;
relay_server *relay;
source_t *src;
int failed = 1, sources;
global_lock();
sources = ++global.sources;
stats_event_args (NULL, "sources", "%d", global.sources);
global_unlock();
/* set the start time, because we want to decrease the sources on all failures */
client->connection.con_time = time (NULL);
do
{
ice_config_t *config = config_get_config();
mount_proxy *mountinfo;
relay = client->shared_data;
src = relay->source;
thread_rwlock_wlock (&src->lock);
src->flags |= SOURCE_PAUSE_LISTENERS;
if (sources > config->source_limit)
{
config_release_config();
WARN1 ("starting relayed mountpoint \"%s\" requires a higher sources limit", relay->localmount);
break;
}
config_release_config();
INFO1("Starting relayed source at mountpoint \"%s\"", relay->localmount);
if (open_relay (relay) < 0)
break;
if (connection_complete_source (src) < 0)
{
WARN1 ("Failed to complete initialisation on %s", relay->localmount);
break;
}
stats_event_inc (NULL, "source_relay_connections");
source_init (src);
config = config_get_config();
mountinfo = config_find_mount (config, src->mount);
source_update_settings (config, src, mountinfo);
INFO1 ("source %s is ready to start", src->mount);
config_release_config();
failed = 0;
} while (0);
client->ops = &relay_client_ops;
client->schedule_ms = timing_get_time();
if (failed)
{
/* failed to start any connection, better clean up and reset */
if (relay->on_demand == 0)
{
yp_remove (relay->localmount);
src->yp_public = -1;
}
relay->in_use = NULL;
INFO2 ("listener count remaining on %s is %d", src->mount, src->listeners);
src->flags &= ~(SOURCE_PAUSE_LISTENERS|SOURCE_RUNNING);
}
thread_rwlock_unlock (&src->lock);
thread_spin_lock (&relay_start_lock);
relays_connecting--;
thread_spin_unlock (&relay_start_lock);
client->flags |= CLIENT_ACTIVE;
worker_wakeup (client->worker);
return NULL;
}
void source_main (source_t *source)
{
refbuf_t *refbuf;
client_t *client;
avl_node *client_node;
source_init (source);
while (global.running == ICE_RUNNING && source->running) {
int remove_from_q;
refbuf = get_next_buffer (source);
remove_from_q = 0;
source->short_delay = 0;
if (refbuf)
{
/* append buffer to the in-flight data queue, */
if (source->stream_data == NULL)
{
source->stream_data = refbuf;
source->burst_point = refbuf;
}
if (source->stream_data_tail)
source->stream_data_tail->next = refbuf;
source->stream_data_tail = refbuf;
source->queue_size += refbuf->len;
/* new buffer is referenced for burst */
refbuf_addref (refbuf);
/* new data on queue, so check the burst point */
source->burst_offset += refbuf->len;
while (source->burst_offset > source->burst_size)
{
refbuf_t *to_release = source->burst_point;
if (to_release->next)
{
source->burst_point = to_release->next;
source->burst_offset -= to_release->len;
refbuf_release (to_release);
continue;
}
break;
}
/* save stream to file */
if (source->dumpfile && source->format->write_buf_to_file)
source->format->write_buf_to_file (source, refbuf);
}
/* lets see if we have too much data in the queue, but don't remove it until later */
if (source->queue_size > source->queue_size_limit)
remove_from_q = 1;
/* acquire write lock on pending_tree */
avl_tree_wlock(source->pending_tree);
/* acquire write lock on client_tree */
avl_tree_wlock(source->client_tree);
client_node = avl_get_first(source->client_tree);
while (client_node) {
client = (client_t *)client_node->key;
send_to_listener (source, client, remove_from_q);
if (client->con->error) {
client_node = avl_get_next(client_node);
if (client->respcode == 200)
stats_event_dec (NULL, "listeners");
avl_delete(source->client_tree, (void *)client, _free_client);
source->listeners--;
DEBUG0("Client removed");
continue;
}
client_node = avl_get_next(client_node);
}
/** add pending clients **/
client_node = avl_get_first(source->pending_tree);
while (client_node) {
if(source->max_listeners != -1 &&
source->listeners >= (unsigned long)source->max_listeners)
{
/* The common case is caught in the main connection handler,
* this deals with rarer cases (mostly concerning fallbacks)
* and doesn't give the listening client any information about
* why they were disconnected
*/
client = (client_t *)client_node->key;
client_node = avl_get_next(client_node);
avl_delete(source->pending_tree, (void *)client, _free_client);
INFO0("Client deleted, exceeding maximum listeners for this "
"mountpoint.");
continue;
}
/* Otherwise, the client is accepted, add it */
avl_insert(source->client_tree, client_node->key);
source->listeners++;
DEBUG0("Client added");
stats_event_inc(source->mount, "connections");
client_node = avl_get_next(client_node);
}
/** clear pending tree **/
while (avl_get_first(source->pending_tree)) {
avl_delete(source->pending_tree,
avl_get_first(source->pending_tree)->key,
source_remove_client);
}
/* release write lock on pending_tree */
avl_tree_unlock(source->pending_tree);
/* update the stats if need be */
if (source->listeners != source->prev_listeners)
{
source->prev_listeners = source->listeners;
INFO2("listener count on %s now %lu", source->mount, source->listeners);
if (source->listeners > source->peak_listeners)
{
source->peak_listeners = source->listeners;
stats_event_args (source->mount, "listener_peak", "%lu", source->peak_listeners);
}
stats_event_args (source->mount, "listeners", "%lu", source->listeners);
if (source->listeners == 0 && source->on_demand)
source->running = 0;
}
/* lets reduce the queue, any lagging clients should of been
* terminated by now
*/
if (source->stream_data)
{
/* normal unreferenced queue data will have a refcount 1, but
* burst queue data will be at least 2, active clients will also
* increase refcount */
while (source->stream_data->_count == 1)
{
refbuf_t *to_go = source->stream_data;
if (to_go->next == NULL || source->burst_point == to_go)
{
/* this should not happen */
ERROR0 ("queue state is unexpected");
source->running = 0;
break;
}
source->stream_data = to_go->next;
source->queue_size -= to_go->len;
to_go->next = NULL;
refbuf_release (to_go);
}
}
/* release write lock on client_tree */
avl_tree_unlock(source->client_tree);
}
source_shutdown (source);
}
int
main(int argc, char **argv, char **envp)
{
tnfctl_errcode_t err = TNFCTL_ERR_NONE;
int sys_err;
tnfctl_trace_attrs_t trace_attrs;
tnfctl_event_t event = TNFCTL_EVENT_EINTR;
pid_t prex_pid;
/* internationalization stuff */
(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST" /* Use this only if it weren't */
#endif
(void) textdomain(TEXT_DOMAIN);
g_argv = argv;
prex_pid = getpid();
#if defined(DEBUG)
fprintf(stderr, "### prex_pid = %d ###\n", prex_pid);
#endif
prex_dmodel = get_data_model(prex_pid);
#if defined(DEBUG)
fprintf(stderr, "### prex_dmodel = %d ###\n", prex_dmodel);
#endif
scanargs(argc, argv);
if (g_kernelmode) {
/* prexing the kernel */
err = tnfctl_kernel_open(&g_hndl);
if (err) {
err_fatal(gettext(
"%s: trouble attaching to the kernel: %s\n"),
argv[0], tnfctl_strerror(err));
}
} else {
/* prexing a user process */
if (g_targetpid != 0) {
/* check data model */
check_pid_model(argv, envp);
/* attach case */
err = tnfctl_pid_open(g_targetpid, &g_hndl);
if (err == TNFCTL_ERR_NOLIBTNFPROBE) {
err_fatal(gettext(
"%s: missing symbols, is "
"libtnfprobe.so loaded in target?\n"),
argv[0], tnfctl_strerror(err));
} else if (err) {
err_fatal(gettext(
"%s: trouble attaching to target "
"process: %s\n"),
argv[0], tnfctl_strerror(err));
}
} else {
/* check elf class model */
check_exec_model(argv, envp);
/* exec case */
err = tnfctl_exec_open(g_cmdname, g_cmdargs, NULL,
g_preload, NULL, &g_hndl);
if (err == TNFCTL_ERR_NONE)
err = tnfctl_trace_attrs_get(g_hndl,
&trace_attrs);
if (err) {
err_fatal(gettext(
"%s: trouble creating target process: "
"%s\n"),
argv[0], tnfctl_strerror(err));
}
g_targetpid = trace_attrs.targ_pid;
}
sys_err = set_signal();
if (sys_err)
err_fatal(gettext(
"%s: trouble setting up signal handler: %s\n"),
argv[0], strerror(err));
}
/* initialize the source stack for the parser */
source_init();
if (!g_kernelmode) {
/* set the tracefile name and size */
err = set_tracefile(g_hndl);
if (err) {
(void) fprintf(stderr, gettext(
"%s: trouble initializing tracefile: %s\n"),
argv[0], tnfctl_strerror(err));
goto Cleanup;
}
err = check_trace_error(g_hndl);
if (err) {
(void) fprintf(stderr, gettext(
"%s: cannot read tracing status : %s\n"),
argv[0], tnfctl_strerror(err));
goto Cleanup;
}
}
/* accept commands from stdin the first time through */
g_getcmds = B_TRUE;
/* set up default aliases */
set_default_cmd();
/* set up creator/destructor function to call for new probes */
err = set_probe_discovery_callback(g_hndl);
if (err) {
(void) fprintf(stderr, gettext(
"%s: error in probe discovery : %s\n"),
argv[0], tnfctl_strerror(err));
goto Cleanup;
}
if (g_kernelmode) {
prbk_warn_pfilter_empty();
}
while (err == TNFCTL_ERR_NONE) {
if (g_kernelmode || g_getcmds) {
g_getcmds = B_FALSE;
get_commands();
}
if (!g_kernelmode && (g_getcmds == B_FALSE)) {
err = tnfctl_continue(g_hndl, &event, NULL);
if (err) {
(void) fprintf(stderr, gettext(
"%s: cannot continue target : %s\n"),
argv[0], tnfctl_strerror(err));
goto Cleanup;
}
}
err = check_trace_error(g_hndl);
if (err) {
(void) fprintf(stderr, gettext(
"%s: cannot read tracing status : %s\n"),
argv[0], tnfctl_strerror(err));
goto Cleanup;
}
if (!g_kernelmode) {
if (event == TNFCTL_EVENT_EXEC) {
(void) printf(gettext(
"Target process exec'd\n"));
quit(B_FALSE, B_TRUE); /* quit resume */
} else if (event == TNFCTL_EVENT_EXIT) {
/* target exited */
(void) fprintf(stderr, gettext(
"%s: target process exited\n"),
g_argv[0]);
goto Cleanup;
} else if (event == TNFCTL_EVENT_TARGGONE) {
/* target terminated */
(void) fprintf(stderr,
gettext("%s: target process disappeared (without calling exit)\n"),
g_argv[0]);
goto Cleanup;
}
}
}
Cleanup:
err = tnfctl_close(g_hndl, TNFCTL_TARG_DEFAULT);
if (err)
(void) fprintf(stderr, gettext(
"%s: error on closing : %s\n"),
argv[0], tnfctl_strerror(err));
exit(0);
return (0);
}
static void handle_uuid(const char *uuidstr, struct audio_device *device)
{
uuid_t uuid;
uint16_t uuid16;
if (bt_string2uuid(&uuid, uuidstr) < 0) {
error("%s not detected as an UUID-128", uuidstr);
return;
}
if (!sdp_uuid128_to_uuid(&uuid) && uuid.type != SDP_UUID16) {
error("Could not convert %s to a UUID-16", uuidstr);
return;
}
uuid16 = uuid.value.uuid16;
if (!server_is_enabled(&device->src, uuid16)) {
DBG("server not enabled for %s (0x%04x)", uuidstr, uuid16);
return;
}
switch (uuid16) {
case HEADSET_SVCLASS_ID:
DBG("Found Headset record");
if (device->headset)
headset_update(device, uuid16, uuidstr);
else
device->headset = headset_init(device, uuid16,
uuidstr);
break;
case HEADSET_AGW_SVCLASS_ID:
DBG("Found Headset AG record");
break;
case HANDSFREE_SVCLASS_ID:
DBG("Found Handsfree record");
if (device->headset)
headset_update(device, uuid16, uuidstr);
else
device->headset = headset_init(device, uuid16,
uuidstr);
break;
case HANDSFREE_AGW_SVCLASS_ID:
DBG("Found Handsfree AG record");
if (enabled.gateway && (device->gateway == NULL))
device->gateway = gateway_init(device);
break;
case AUDIO_SINK_SVCLASS_ID:
DBG("Found Audio Sink");
if (device->sink == NULL)
device->sink = sink_init(device);
break;
case AUDIO_SOURCE_SVCLASS_ID:
DBG("Found Audio Source");
if (device->source == NULL)
device->source = source_init(device);
break;
case AV_REMOTE_SVCLASS_ID:
case AV_REMOTE_TARGET_SVCLASS_ID:
DBG("Found AV %s", uuid16 == AV_REMOTE_SVCLASS_ID ?
"Remote" : "Target");
if (device->control)
control_update(device, uuid16);
else
device->control = control_init(device, uuid16);
/* SS_Bluetooth(sunjo4.kim) 2012.2.16 - add for a2dp connect fail */
//if (device->sink && sink_is_active(device))
// avrcp_connect(device);
/* SS_Bluetooth(sunjo4.kim) End */
break;
default:
DBG("Unrecognized UUID: 0x%04X", uuid16);
break;
}
}
