//------------------------------------------------------------------------------
int main()
{
char answer[100];
printf("This program will generate the energy maps. It may take some time...\n");
printf("Do you want to continue (yes/no)? ");
if(scanf("%s", answer) != EOF && strcmp(answer, "yes") == 0)
{
char file[200];
pp_init();
for(int configE = 1; configE <= 9; configE++)
for(int configI = 1; configI <= 4; configI++)
{
pp_clear_maps();
printf("Generating configuration (%d/9,%d/4)...\n", configE, configI);
pp_draw_config(configE, configI);
pp_compute_distance_transform();
sprintf(file,"config%d.dat",configE*10+configI);
pp_save_to_file(file);
sprintf(file,"config%d.bmp",configE*10+configI);
pp_save_to_bmp(file);
}
printf("Les fichiers configxx.dat générés dans le répertoire courant doivent être placés dans le répertoire 'data' à la racine du client pc.\n");
}
return 0;
}
bool pass_parse(sourcefile_t *src)
{
const lineelement_t *lelem;
segment_reset();
allBytesResolved = true;
allTermsFinal = true;
dumpPass = false;
/* Set Pet/Screen Mode to the default */
reset_TextMode();
src_reset(src);
if( !pp_init(src) ) {
return false;
}
resetResolveCounter();
while( (lelem=pp_peek())!=NULL && lelem->typ!=LE_EOF )
{
if( !pass_eparse() ) {
pp_skipGarbage();
}
/* Change SegElem if PC was redefined in this line */
segment_processChange();
/* if the number of errors reached the maximum value, stop parsing now */
if( errorcnt>=cfg_maxerrors ) {
printf("maximum number of errors reached. aborting!\n");
break;
}
};
if( errorcnt==0 )
{
if( segment_getPhaseIdx()!=0 ) {
error(EM_PseudoPCStillOpenAtEnd);
return false;
}
if( getLocalBlock()!=0 ) {
error(EM_LocalBlockStillOpenAtEnd);
return false;
}
}
return true;
}
//----------------------------------------------------------
void init(void)
{
DDRB = BV(PB0);
DDRD = BV(PD1) | BV(PD3) | BV(PD4);
uart0_init(); // PC
uart1_init(); // internal
uart2_init(); // external (via extBus)
adc_init();
timer_init();
TB_Callback_setBaud = uart1_set_baud;
TB_Init((void*) 0x10); // addr in eeprom with settings
pp_init();
sei();
}
/*!
* V4L2 interface - open function
*
* @param inode structure inode *
*
* @param file structure file *
*
* @return status 0 success, ENODEV invalid device instance,
* ENODEV timeout, ERESTARTSYS interrupted by user
*/
static int mxc_v4l2out_open(struct inode *inode, struct file *file)
{
struct video_device *dev = video_devdata(file);
vout_data *vout = video_get_drvdata(dev);
int err;
dq_intr_cnt = 0;
if (!vout) {
pr_info("Internal error, vout_data not found!\n");
return -ENODEV;
}
down(&vout->busy_lock);
err = -EINTR;
if (signal_pending(current))
goto oops;
if (vout->open_count++ == 0) {
pp_init(vout);
init_waitqueue_head(&vout->v4l_bufq);
init_timer(&vout->output_timer);
vout->output_timer.function = mxc_v4l2out_timer_handler;
vout->output_timer.data = (unsigned long)vout;
vout->state = STATE_STREAM_OFF;
g_irq_cnt = g_buf_output_cnt = g_buf_q_cnt = g_buf_dq_cnt = 0;
}
#ifdef CONFIG_VIDEO_MXC_OUTPUT_FBSYNC
vout->tear_protection = TEARING_PROTECTION_ACTIVE;
#else
vout->tear_protection = TEARING_PROTECTION_UNSUPPORTED;
#endif
file->private_data = dev;
up(&vout->busy_lock);
return 0;
oops:
up(&vout->busy_lock);
return err;
}
int run_processes_parallel(int n,
get_next_task_fn get_next_task,
start_failure_fn start_failure,
task_finished_fn task_finished,
void *pp_cb)
{
int i, code;
int output_timeout = 100;
int spawn_cap = 4;
struct parallel_processes pp;
pp_init(&pp, n, get_next_task, start_failure, task_finished, pp_cb);
while (1) {
for (i = 0;
i < spawn_cap && !pp.shutdown &&
pp.nr_processes < pp.max_processes;
i++) {
code = pp_start_one(&pp);
if (!code)
continue;
if (code < 0) {
pp.shutdown = 1;
kill_children(&pp, -code);
}
break;
}
if (!pp.nr_processes)
break;
pp_buffer_stderr(&pp, output_timeout);
pp_output(&pp);
code = pp_collect_finished(&pp);
if (code) {
pp.shutdown = 1;
if (code < 0)
kill_children(&pp, -code);
}
}
pp_cleanup(&pp);
return 0;
}
// Render the given term into the output stream.
void
print(std::ostream& os, Tree* t) {
if (not t) {
os << "<null>";
return;
}
switch (t->kind) {
case id_tree: return pp_terminal(os, as<Id_tree>(t));
case lit_tree: return pp_terminal(os, as<Lit_tree>(t));
case var_tree: return pp_var(os, as<Var_tree>(t));
case init_tree: return pp_init(os, as<Init_tree>(t));
case abs_tree: return pp_abs(os, as<Abs_tree>(t));
case fn_tree: return pp_fn(os, as<Fn_tree>(t));
case app_tree: return pp_app(os, as<App_tree>(t));
case if_tree: return pp_if(os, as<If_tree>(t));
case succ_tree: return pp_succ(os, as<Succ_tree>(t));
case pred_tree: return pp_pred(os, as<Pred_tree>(t));
case ls_tree: return pp_ls(os, as<Ls_tree>(t));//Rishi
case mkdir_tree: return pp_mkdir(os, as<Mkdir_tree>(t));//Rishi
case rmdir_tree: return pp_rmdir(os, as<Rmdir_tree>(t));//Rishi
case cd_tree: return pp_cd(os, as<Cd_tree>(t));//Rishi
case mv_tree: return pp_mv(os, as<Mv_tree>(t));//Rishi
case iszero_tree: return pp_iszero(os, as<Iszero_tree>(t));
case arrow_tree: return pp_arrow(os, as<Arrow_tree>(t));
case def_tree: return pp_def(os, as<Def_tree>(t));
case print_tree: return pp_print(os, as<Print_tree>(t));
case typeof_tree: return pp_typeof(os, as<Typeof_tree>(t));
case tuple_tree: return pp_tuple(os, as<Tuple_tree>(t));
case list_tree: return pp_list(os, as<List_tree>(t));
case variant_tree: return pp_variant(os, as<Variant_tree>(t));
case comma_tree: return pp_comma(os, as<Comma_tree>(t));
case dot_tree: return pp_dot(os, as<Dot_tree>(t));
case prog_tree: return pp_prog(os, as<Prog_tree>(t));
}
lang_unreachable(format("print unknown node '{}'", node_name(t)));
}
int main(int argc, char *argv[]) {
bool chook = false;
int client = false;
int dinx;
int disable;
int ferr;
int inx;
char lname[10];
bool mq = false;
int oid;
void *res;
bool rnd = false;
int sleept;
int snid;
int spid;
int status;
TAD zargs[] = {
{ "-chook", TA_Bool, TA_NOMAX, &chook },
{ "-client", TA_Bool, TA_NOMAX, &client },
{ "-dloop", TA_Int, MAX_OUT, &gdloop },
{ "-dsize", TA_Int, TA_NOMAX, &gdsize },
{ "-ksleep", TA_Int, TA_NOMAX, &gksleep },
{ "-loop", TA_Int, TA_NOMAX, &gloop },
{ "-maxc", TA_Int, MAX_THR, &gmaxc },
{ "-maxs", TA_Int, MAX_THR, &gmaxs },
{ "-mq", TA_Bool, TA_NOMAX, &mq },
{ "-nodecycle", TA_Bool, TA_NOMAX, &gnodecycle },
{ "-rnd", TA_Bool, TA_NOMAX, &rnd },
{ "-server", TA_Ign, TA_NOMAX, NULL },
{ "-v", TA_Bool, TA_NOMAX, &gverbose },
{ "-vpp", TA_Bool, TA_NOMAX, &gverbosepp },
{ "", TA_End, TA_NOMAX, NULL }
};
arg_proc_args(zargs, false, argc, argv);
if (client && chook)
test_debug_hook("c", "c");
msfs_util_init(&argc, &argv, msg_debug_hook);
util_test_start(client);
if (!client)
setup_sig();
ferr = msg_mon_process_startup(true); // system messages
TEST_CHK_FEOK(ferr);
gargc = argc; // after msg_init - it removes args
gargp = argv;
sprintf(gprog, "%s/%s", getenv("PWD"), argv[0]);
gvirtual = (getenv("SQ_VIRTUAL_NODES") != NULL);
ferr = msg_mon_get_my_process_name(gname, sizeof(gname));
assert(ferr == XZFIL_ERR_OK);
if (client) {
msg_mon_enable_mon_messages(true); // get mon messages
ferr = msg_mon_get_process_info(NULL, &gcnid, NULL);
assert(ferr == XZFIL_ERR_OK);
ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETSENDLIMIT,
(short) (gmaxc * gdloop));
assert(ferr == XZFIL_ERR_OK);
srand(1);
sleept = 1000;
start_server(argc, argv);
sleep(1);
ferr = msg_mon_open_process((char *) "$srv", // name
TPT_REF(gphandle),
&oid);
TEST_CHK_FEOK(ferr);
ferr = XPROCESSHANDLE_DECOMPOSE_(TPT_REF(gphandle), &snid, &spid);
TEST_CHK_FEOK(ferr);
for (inx = 0; inx < gloop; inx++) {
if (mq)
printf("client: inx=%d\n", inx);
for (dinx = 0; dinx < gmaxc; dinx++) {
sprintf(lname, "c%d", dinx);
gthrc[dinx] = new MyThread(client_thr, lname, dinx);
}
disable = msg_test_assert_disable();
for (dinx = 0; dinx < gmaxc; dinx++)
gthrc[dinx]->start();
if (rnd)
sleept = (int) ((float) gksleep * (rand_r(&gseed) / (RAND_MAX + 1.0)));
usleep(sleept);
for (dinx = 0; dinx < gmaxc; dinx++) {
status = gthrc[dinx]->join(&res);
TEST_CHK_STATUSOK(status);
if (gverbose)
printf("joined with client %d\n", dinx);
}
for (dinx = 0; dinx < gmaxc; dinx++)
delete gthrc[dinx];
msg_test_assert_enable(disable);
}
} else {
msg_mon_enable_mon_messages(true); // get mon messages
ferr = XCONTROLMESSAGESYSTEM(XCTLMSGSYS_SETRECVLIMIT,
XMAX_SETTABLE_RECVLIMIT);
assert(ferr == XZFIL_ERR_OK);
pp_init();
if (!gshutdown) {
for (dinx = 0; dinx < gmaxs; dinx++) {
char lname[10];
sprintf(lname, "s%d", dinx);
gthrs[dinx] = new SB_Thread::Thread(server_thr, lname);
}
for (dinx = 0; dinx < gmaxs; dinx++)
gthrs[dinx]->start();
for (dinx = 0; dinx < gmaxs; dinx++) {
status = gthrs[dinx]->join(&res);
TEST_CHK_STATUSOK(status);
if (gverbose)
printf("joined with server %d\n", dinx);
}
}
if (gverbosepp)
pp_printf("exit pid=%d\n", getpid());
}
if (client) {
sleep(1);
ferr = msg_mon_close_process(TPT_REF(gphandle));
TEST_CHK_FEOK(ferr);
}
ferr = msg_mon_process_shutdown();
TEST_CHK_FEOK(ferr);
util_test_finish(client);
return 0;
}
GLboolean
dri_create_context(gl_api api, const struct gl_config * visual,
__DRIcontext * cPriv,
unsigned major_version,
unsigned minor_version,
uint32_t flags,
unsigned *error,
void *sharedContextPrivate)
{
__DRIscreen *sPriv = cPriv->driScreenPriv;
struct dri_screen *screen = dri_screen(sPriv);
struct st_api *stapi = screen->st_api;
struct dri_context *ctx = NULL;
struct st_context_iface *st_share = NULL;
struct st_context_attribs attribs;
enum st_context_error ctx_err = 0;
memset(&attribs, 0, sizeof(attribs));
switch (api) {
case API_OPENGLES:
attribs.profile = ST_PROFILE_OPENGL_ES1;
break;
case API_OPENGLES2:
attribs.profile = ST_PROFILE_OPENGL_ES2;
break;
case API_OPENGL:
attribs.profile = ST_PROFILE_DEFAULT;
attribs.major = major_version;
attribs.minor = minor_version;
if ((flags & __DRI_CTX_FLAG_DEBUG) != 0)
attribs.flags |= ST_CONTEXT_FLAG_DEBUG;
if ((flags & __DRI_CTX_FLAG_FORWARD_COMPATIBLE) != 0)
attribs.flags |= ST_CONTEXT_FLAG_FORWARD_COMPATIBLE;
break;
default:
*error = __DRI_CTX_ERROR_BAD_API;
goto fail;
}
if (sharedContextPrivate) {
st_share = ((struct dri_context *)sharedContextPrivate)->st;
}
ctx = CALLOC_STRUCT(dri_context);
if (ctx == NULL) {
*error = __DRI_CTX_ERROR_NO_MEMORY;
goto fail;
}
cPriv->driverPrivate = ctx;
ctx->cPriv = cPriv;
ctx->sPriv = sPriv;
driParseConfigFiles(&ctx->optionCache,
&screen->optionCache, sPriv->myNum, driver_descriptor.name);
dri_fill_st_options(&attribs.options, &ctx->optionCache);
dri_fill_st_visual(&attribs.visual, screen, visual);
ctx->st = stapi->create_context(stapi, &screen->base, &attribs, &ctx_err,
st_share);
if (ctx->st == NULL) {
switch (ctx_err) {
case ST_CONTEXT_SUCCESS:
*error = __DRI_CTX_ERROR_SUCCESS;
break;
case ST_CONTEXT_ERROR_NO_MEMORY:
*error = __DRI_CTX_ERROR_NO_MEMORY;
break;
case ST_CONTEXT_ERROR_BAD_API:
*error = __DRI_CTX_ERROR_BAD_API;
break;
case ST_CONTEXT_ERROR_BAD_VERSION:
*error = __DRI_CTX_ERROR_BAD_VERSION;
break;
case ST_CONTEXT_ERROR_BAD_FLAG:
*error = __DRI_CTX_ERROR_BAD_FLAG;
break;
case ST_CONTEXT_ERROR_UNKNOWN_ATTRIBUTE:
*error = __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE;
break;
case ST_CONTEXT_ERROR_UNKNOWN_FLAG:
*error = __DRI_CTX_ERROR_UNKNOWN_FLAG;
break;
}
goto fail;
}
ctx->st->st_manager_private = (void *) ctx;
ctx->stapi = stapi;
// Context successfully created. See if post-processing is requested.
dri_pp_query(ctx);
ctx->pp = pp_init(screen->base.screen, ctx->pp_enabled);
*error = __DRI_CTX_ERROR_SUCCESS;
return GL_TRUE;
fail:
if (ctx && ctx->st)
ctx->st->destroy(ctx->st);
FREE(ctx);
return GL_FALSE;
}
context_id
GalliumContext::CreateContext(Bitmap *bitmap)
{
CALLED();
struct hgl_context* context = CALLOC_STRUCT(hgl_context);
if (!context) {
ERROR("%s: Couldn't create pipe context!\n", __FUNCTION__);
return 0;
}
// Set up the initial things our context needs
context->bitmap = bitmap;
context->colorSpace = get_bitmap_color_space(bitmap);
context->screen = fScreen;
context->draw = NULL;
context->read = NULL;
context->st = NULL;
context->api = st_gl_api_create();
if (!context->api) {
ERROR("%s: Couldn't obtain Mesa state tracker API!\n", __func__);
return -1;
}
// Create state_tracker manager
context->manager = hgl_create_st_manager(context);
// Create state tracker visual
context->stVisual = hgl_create_st_visual(fOptions);
// Create state tracker framebuffers
context->draw = hgl_create_st_framebuffer(context);
context->read = hgl_create_st_framebuffer(context);
if (!context->draw || !context->read) {
ERROR("%s: Problem allocating framebuffer!\n", __func__);
FREE(context->stVisual);
return -1;
}
// Build state tracker attributes
struct st_context_attribs attribs;
memset(&attribs, 0, sizeof(attribs));
attribs.options.force_glsl_extensions_warn = false;
attribs.profile = ST_PROFILE_DEFAULT;
attribs.visual = *context->stVisual;
attribs.major = 1;
attribs.minor = 0;
//attribs.flags |= ST_CONTEXT_FLAG_DEBUG;
struct st_api* api = context->api;
// Create context using state tracker api call
enum st_context_error result;
context->st = api->create_context(api, context->manager, &attribs,
&result, context->st);
if (!context->st) {
ERROR("%s: Couldn't create mesa state tracker context!\n",
__func__);
switch (result) {
case ST_CONTEXT_SUCCESS:
ERROR("%s: State tracker error: SUCCESS?\n", __func__);
break;
case ST_CONTEXT_ERROR_NO_MEMORY:
ERROR("%s: State tracker error: NO_MEMORY\n", __func__);
break;
case ST_CONTEXT_ERROR_BAD_API:
ERROR("%s: State tracker error: BAD_API\n", __func__);
break;
case ST_CONTEXT_ERROR_BAD_VERSION:
ERROR("%s: State tracker error: BAD_VERSION\n", __func__);
break;
case ST_CONTEXT_ERROR_BAD_FLAG:
ERROR("%s: State tracker error: BAD_FLAG\n", __func__);
break;
case ST_CONTEXT_ERROR_UNKNOWN_ATTRIBUTE:
ERROR("%s: State tracker error: BAD_ATTRIBUTE\n", __func__);
break;
case ST_CONTEXT_ERROR_UNKNOWN_FLAG:
ERROR("%s: State tracker error: UNKNOWN_FLAG\n", __func__);
break;
}
hgl_destroy_st_visual(context->stVisual);
FREE(context);
return -1;
}
assert(!context->st->st_manager_private);
context->st->st_manager_private = (void*)context;
struct st_context *stContext = (struct st_context*)context->st;
// Init Gallium3D Post Processing
// TODO: no pp filters are enabled yet through postProcessEnable
context->postProcess = pp_init(stContext->pipe, context->postProcessEnable,
stContext->cso_context);
context_id contextNext = -1;
Lock();
for (context_id i = 0; i < CONTEXT_MAX; i++) {
if (fContext[i] == NULL) {
fContext[i] = context;
contextNext = i;
break;
}
}
Unlock();
if (contextNext < 0) {
ERROR("%s: The next context is invalid... something went wrong!\n",
__func__);
//st_destroy_context(context->st);
FREE(context->stVisual);
FREE(context);
return -1;
}
TRACE("%s: context #%" B_PRIu64 " is the next available context\n",
__func__, contextNext);
return contextNext;
}
/**
* Bind an OSMesaContext to an image buffer. The image buffer is just a
* block of memory which the client provides. Its size must be at least
* as large as width*height*pixelSize. Its address should be a multiple
* of 4 if using RGBA mode.
*
* By default, image data is stored in the order of glDrawPixels: row-major
* order with the lower-left image pixel stored in the first array position
* (ie. bottom-to-top).
*
* If the context's viewport hasn't been initialized yet, it will now be
* initialized to (0,0,width,height).
*
* Input: osmesa - the rendering context
* buffer - the image buffer memory
* type - data type for pixel components
* GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT
* or GL_FLOAT.
* width, height - size of image buffer in pixels, at least 1
* Return: GL_TRUE if success, GL_FALSE if error because of invalid osmesa,
* invalid type, invalid size, etc.
*/
GLAPI GLboolean GLAPIENTRY
OSMesaMakeCurrent(OSMesaContext osmesa, void *buffer, GLenum type,
GLsizei width, GLsizei height)
{
struct st_api *stapi = get_st_api();
struct osmesa_buffer *osbuffer;
enum pipe_format color_format;
if (!osmesa || !buffer || width < 1 || height < 1) {
return GL_FALSE;
}
if (osmesa->format == OSMESA_RGB_565 && type != GL_UNSIGNED_SHORT_5_6_5) {
return GL_FALSE;
}
color_format = osmesa_choose_format(osmesa->format, type);
if (color_format == PIPE_FORMAT_NONE) {
fprintf(stderr, "OSMesaMakeCurrent(unsupported format/type)\n");
return GL_FALSE;
}
/* See if we already have a buffer that uses these pixel formats */
osbuffer = osmesa_find_buffer(color_format,
osmesa->depth_stencil_format,
osmesa->accum_format, width, height);
if (!osbuffer) {
/* Existing buffer found, create new buffer */
osbuffer = osmesa_create_buffer(color_format,
osmesa->depth_stencil_format,
osmesa->accum_format);
}
osbuffer->width = width;
osbuffer->height = height;
osbuffer->map = buffer;
/* XXX unused for now */
(void) osmesa_destroy_buffer;
osmesa->current_buffer = osbuffer;
osmesa->type = type;
stapi->make_current(stapi, osmesa->stctx, osbuffer->stfb, osbuffer->stfb);
if (!osmesa->ever_used) {
/* one-time init, just postprocessing for now */
boolean any_pp_enabled = FALSE;
unsigned i;
for (i = 0; i < ARRAY_SIZE(osmesa->pp_enabled); i++) {
if (osmesa->pp_enabled[i]) {
any_pp_enabled = TRUE;
break;
}
}
if (any_pp_enabled) {
osmesa->pp = pp_init(osmesa->stctx->pipe,
osmesa->pp_enabled,
osmesa->stctx->cso_context);
pp_init_fbos(osmesa->pp, width, height);
}
osmesa->ever_used = TRUE;
}
return GL_TRUE;
}
context_id
GalliumContext::CreateContext(Bitmap *bitmap)
{
CALLED();
struct hgl_context* context = CALLOC_STRUCT(hgl_context);
if (!context) {
ERROR("%s: Couldn't create pipe context!\n", __FUNCTION__);
return 0;
}
// Set up the initial things our context needs
context->bitmap = bitmap;
context->colorSpace = get_bitmap_color_space(bitmap);
context->draw = NULL;
context->read = NULL;
context->st = NULL;
context->api = st_gl_api_create();
if (!context->api) {
ERROR("%s: Couldn't obtain Mesa state tracker API!\n", __func__);
return -1;
}
context->manager = CALLOC_STRUCT(st_manager);
if (!context->manager) {
ERROR("%s: Couldn't allocate Mesa state tracker manager!\n", __func__);
return -1;
}
context->manager->get_param = hook_stm_get_param;
// Calculate visual configuration
const GLboolean rgbFlag = ((fOptions & BGL_INDEX) == 0);
const GLboolean alphaFlag = ((fOptions & BGL_ALPHA) == BGL_ALPHA);
const GLboolean dblFlag = ((fOptions & BGL_DOUBLE) == BGL_DOUBLE);
const GLboolean stereoFlag = false;
const GLint depth = (fOptions & BGL_DEPTH) ? 24 : 0;
const GLint stencil = (fOptions & BGL_STENCIL) ? 8 : 0;
const GLint accum = (fOptions & BGL_ACCUM) ? 16 : 0;
const GLint red = rgbFlag ? 8 : 5;
const GLint green = rgbFlag ? 8 : 5;
const GLint blue = rgbFlag ? 8 : 5;
const GLint alpha = alphaFlag ? 8 : 0;
TRACE("rgb :\t%d\n", (bool)rgbFlag);
TRACE("alpha :\t%d\n", (bool)alphaFlag);
TRACE("dbl :\t%d\n", (bool)dblFlag);
TRACE("stereo :\t%d\n", (bool)stereoFlag);
TRACE("depth :\t%d\n", depth);
TRACE("stencil :\t%d\n", stencil);
TRACE("accum :\t%d\n", accum);
TRACE("red :\t%d\n", red);
TRACE("green :\t%d\n", green);
TRACE("blue :\t%d\n", blue);
TRACE("alpha :\t%d\n", alpha);
gl_config* glVisual = _mesa_create_visual(dblFlag, stereoFlag, red, green,
blue, alpha, depth, stencil, accum, accum, accum, alpha ? accum : 0, 1);
if (!glVisual) {
ERROR("%s: Couldn't create Mesa visual!\n", __func__);
return -1;
}
TRACE("depthBits :\t%d\n", glVisual->depthBits);
TRACE("stencilBits :\t%d\n", glVisual->stencilBits);
// Convert Mesa calculated visual into state tracker visual
context->stVisual = hgl_fill_st_visual(glVisual);
context->draw = new GalliumFramebuffer(context->stVisual, (void*)this);
context->read = new GalliumFramebuffer(context->stVisual, (void*)this);
if (!context->draw || !context->read) {
ERROR("%s: Problem allocating framebuffer!\n", __func__);
_mesa_destroy_visual(glVisual);
return -1;
}
// We need to assign the screen *before* calling st_api create_context
context->manager->screen = fScreen;
// Build state tracker attributes
struct st_context_attribs attribs;
memset(&attribs, 0, sizeof(attribs));
attribs.options.force_glsl_extensions_warn = false;
attribs.profile = ST_PROFILE_DEFAULT;
attribs.visual = *context->stVisual;
attribs.major = 1;
attribs.minor = 0;
//attribs.flags |= ST_CONTEXT_FLAG_DEBUG;
struct st_api* api = context->api;
// Create context using state tracker api call
enum st_context_error result;
context->st = api->create_context(api, context->manager, &attribs,
&result, context->st);
if (!context->st) {
ERROR("%s: Couldn't create mesa state tracker context!\n",
__func__);
switch (result) {
case ST_CONTEXT_SUCCESS:
ERROR("%s: State tracker error: SUCCESS?\n", __func__);
break;
case ST_CONTEXT_ERROR_NO_MEMORY:
ERROR("%s: State tracker error: NO_MEMORY\n", __func__);
break;
case ST_CONTEXT_ERROR_BAD_API:
ERROR("%s: State tracker error: BAD_API\n", __func__);
break;
case ST_CONTEXT_ERROR_BAD_VERSION:
ERROR("%s: State tracker error: BAD_VERSION\n", __func__);
break;
case ST_CONTEXT_ERROR_BAD_FLAG:
ERROR("%s: State tracker error: BAD_FLAG\n", __func__);
break;
case ST_CONTEXT_ERROR_UNKNOWN_ATTRIBUTE:
ERROR("%s: State tracker error: BAD_ATTRIBUTE\n", __func__);
break;
case ST_CONTEXT_ERROR_UNKNOWN_FLAG:
ERROR("%s: State tracker error: UNKNOWN_FLAG\n", __func__);
break;
}
FREE(context);
return -1;
}
assert(!context->st->st_manager_private);
context->st->st_manager_private = (void*)context;
struct st_context *stContext = (struct st_context*)context->st;
stContext->ctx->Driver.Viewport = hgl_viewport;
// Init Gallium3D Post Processing
// TODO: no pp filters are enabled yet through postProcessEnable
context->postProcess = pp_init(stContext->pipe, context->postProcessEnable,
stContext->cso_context);
context_id contextNext = -1;
Lock();
for (context_id i = 0; i < CONTEXT_MAX; i++) {
if (fContext[i] == NULL) {
fContext[i] = context;
contextNext = i;
break;
}
}
Unlock();
if (contextNext < 0) {
ERROR("%s: The next context is invalid... something went wrong!\n",
__func__);
//st_destroy_context(context->st);
FREE(context);
_mesa_destroy_visual(glVisual);
return -1;
}
TRACE("%s: context #%" B_PRIu64 " is the next available context\n",
__func__, contextNext);
return contextNext;
}
int main(int argc,char *argv[])
{
int er=1,i;
signed char *s=NULL;
char *tmpp;
int mifiles = 5;
int nifiles = 0;
int verbose = 0;
int oldfile = 0;
int no_link = 0;
char **ifiles;
char *ofile;
char *efile;
char *lfile;
char *ifile;
char old_e[MAXLINE];
char old_l[MAXLINE];
char old_o[MAXLINE];
tim1=time(NULL);
ncmos=0;
n65816=0;
cmosfl=1;
w65816=0; /* default: 6502 only */
altppchar = '#' ; /* i.e., NO alternate char */
if((tmpp = strrchr(argv[0],'/'))) {
tmpp++;
} else {
tmpp = argv[0];
}
if( (!strcmp(tmpp,"xa65816"))
|| (!strcmp(tmpp,"XA65816"))
|| (!strcmp(tmpp,"xa816"))
|| (!strcmp(tmpp,"XA816"))
) {
w65816 = 1; /* allow 65816 per default */
}
/* default output charset for strings in quotes */
set_charset("ASCII");
ifiles = malloc(mifiles*sizeof(char*));
afile = alloc_file();
if (argc <= 1) {
usage(w65816, stderr);
exit(1);
}
if (strstr(argv[1], "--help")) {
usage(w65816, stdout);
exit(0);
}
if (strstr(argv[1], "--version")) {
version(programname, progversion, authors, copyright);
exit(0);
}
ofile="a.o65";
efile=NULL;
lfile=NULL;
if(pp_init()) {
logout("fatal: pp: no memory!");
return 1;
}
if(b_init()) {
logout("fatal: b: no memory!");
return 1;
}
if(l_init()) {
logout("fatal: l: no memory!");
return 1;
}
i=1;
while(i<argc) {
if(argv[i][0]=='-') {
switch(argv[i][1]) {
case 'p':
/* intentionally not allowing an argument to follow with a
space to avoid - being seen as the alternate
preprocessor char! */
if (argv[i][2] == '\0') {
fprintf(stderr, "-p requires a character argument\n");
exit(1);
}
if (argv[i][2] == '#')
fprintf(stderr,
"using -p# is evidence of stupidity\n");
altppchar = argv[i][2];
if (argv[i][3] != '\0')
fprintf(stderr,
"warning: extra characters to -p ignored\n");
break;
case 'M':
masm = 1; /* MASM compatibility mode */
break;
case 'O': /* output charset */
{
char *name = NULL;
if (argv[i][2] == 0) {
name = argv[++i];
} else {
name = argv[i]+2;
}
if (set_charset(name) < 0) {
fprintf(stderr, "Output charset name '%s' unknown - ignoring! (check case?)\n", name);
}
}
break;
case 'A': /* make text segment start so that text relocation
is not necessary when _file_ starts at adr */
romable = 2;
if(argv[i][2]==0) romaddr = atoi(argv[++i]);
else romaddr = atoi(argv[i]+2);
break;
case 'G':
noglob = 1;
break;
case 'L': /* define global label */
if(argv[i][2]) lg_set(argv[i]+2);
break;
case 'r':
crossref = 1;
break;
case 'R':
relmode = 1;
break;
case 'D':
s = (signed char*)strstr(argv[i]+2,"=");
if(s) *s = ' ';
pp_define(argv[i]+2);
break;
case 'c':
no_link = 1;
fmode |= FM_OBJ;
break;
case 'v':
verbose = 1;
break;
case 'C':
cmosfl = 0;
break;
case 'W':
w65816 = 0;
break;
case 'w':
w65816 = 1;
break;
case 'B':
showblk = 1;
break;
case 'x': /* old filename behaviour */
oldfile = 1;
fprintf(stderr, "Warning: -x is now deprecated and may disappear in future versions!\n");
break;
case 'I':
if(argv[i][2]==0) {
reg_include(argv[++i]);
} else {
reg_include(argv[i]+2);
}
break;
case 'o':
if(argv[i][2]==0) {
ofile=argv[++i];
} else {
ofile=argv[i]+2;
}
break;
case 'l':
if(argv[i][2]==0) {
lfile=argv[++i];
} else {
lfile=argv[i]+2;
}
break;
case 'e':
if(argv[i][2]==0) {
efile=argv[++i];
} else {
efile=argv[i]+2;
}
break;
case 'b': /* set segment base addresses */
switch(argv[i][2]) {
case 't':
if(argv[i][3]==0) tbase = atoi(argv[++i]);
else tbase = atoi(argv[i]+3);
break;
case 'd':
if(argv[i][3]==0) dbase = atoi(argv[++i]);
else dbase = atoi(argv[i]+3);
break;
case 'b':
if(argv[i][3]==0) bbase = atoi(argv[++i]);
else bbase = atoi(argv[i]+3);
break;
case 'z':
if(argv[i][3]==0) zbase = atoi(argv[++i]);
else zbase = atoi(argv[i]+3);
break;
default:
fprintf(stderr,"unknown segment type '%c' - ignoring!\n",
argv[i][2]);
break;
}
break;
case 0:
fprintf(stderr, "Single dash '-' on command line - ignoring!\n");
break;
default:
fprintf(stderr, "Unknown option '%c' - ignoring!\n",argv[i][1]);
break;
}
} else { /* no option -> filename */
ifiles[nifiles++] = argv[i];
if(nifiles>=mifiles) {
mifiles += 5;
ifiles=realloc(ifiles, mifiles*sizeof(char*));
if(!ifiles) {
fprintf(stderr, "Oops: couldn't alloc enough mem for filelist table..!\n");
exit(1);
}
}
}
i++;
}
if(!nifiles) {
fprintf(stderr, "No input files given!\n");
exit(0);
}
if(oldfile) {
strcpy(old_e, ifiles[0]);
strcpy(old_o, ifiles[0]);
strcpy(old_l, ifiles[0]);
if(setfext(old_e,".err")==0) efile = old_e;
if(setfext(old_o,".obj")==0) ofile = old_o;
if(setfext(old_l,".lab")==0) lfile = old_l;
}
fplab= lfile ? xfopen(lfile,"w") : NULL;
fperr= efile ? xfopen(efile,"w") : NULL;
if(!strcmp(ofile,"-")) {
ofile=NULL;
fpout = stdout;
} else {
fpout= xfopen(ofile,"wb");
}
if(!fpout) {
fprintf(stderr, "Couldn't open output file!\n");
exit(1);
}
if(verbose) fprintf(stderr, "%s\n",copyright);
if(1 /*!m_init()*/)
{
if(1 /*!b_init()*/)
{
if(1 /*!l_init()*/)
{
/*if(!pp_init())*/
{
if(!x_init())
{
if(fperr) fprintf(fperr,"%s\n",copyright);
if(verbose) logout(ctime(&tim1));
/* Pass 1 */
pc[SEG_ABS]= 0; /* abs addressing */
seg_start(fmode, tbase, dbase, bbase, zbase, 0, relmode);
if(relmode) {
r_mode(RMODE_RELOC);
segment = SEG_TEXT;
} else {
r_mode(RMODE_ABS);
}
nolink = no_link;
for (i=0; i<nifiles; i++)
{
ifile = ifiles[i];
sprintf(out,"xAss65: Pass 1: %s\n",ifile);
if(verbose) logout(out);
er=pp_open(ifile);
puttmp(0);
puttmp(T_FILE);
puttmp(0);
puttmp(0);
puttmps((signed char*)&ifile, sizeof(filep->fname));
if(!er) {
er=pass1();
pp_close();
} else {
sprintf(out, "Couldn't open source file '%s'!\n", ifile);
logout(out);
}
}
if((er=b_depth())) {
sprintf(out,"Still %d blocks open at end of file!\n",er);
logout(out);
}
if(tbase & (align-1)) {
sprintf(out,"Warning: text segment ($%04x) start address doesn't align to %d!\n", tbase, align);
logout(out);
}
if(dbase & (align-1)) {
sprintf(out,"Warning: data segment ($%04x) start address doesn't align to %d!\n", dbase, align);
logout(out);
}
if(bbase & (align-1)) {
sprintf(out,"Warning: bss segment ($%04x) start address doesn't align to %d!\n", bbase, align);
logout(out);
}
if(zbase & (align-1)) {
sprintf(out,"Warning: zero segment ($%04x) start address doesn't align to %d!\n", zbase, align);
logout(out);
}
if (n65816>0)
fmode |= 0x8000;
switch(align) {
case 1: break;
case 2: fmode |= 1; break;
case 4: fmode |= 2; break;
case 256: fmode |=3; break;
}
if((!er) && relmode)
h_write(fpout, fmode, tlen, dlen, blen, zlen, 0);
if(!er)
{
if(verbose) logout("xAss65: Pass 2:\n");
seg_pass2();
if(!relmode) {
r_mode(RMODE_ABS);
} else {
r_mode(RMODE_RELOC);
segment = SEG_TEXT;
}
er=pass2();
}
if(fplab) printllist(fplab);
tim2=time(NULL);
if(verbose) printstat();
if((!er) && relmode) seg_end(fpout); /* write reloc/label info */
if(fperr) fclose(fperr);
if(fplab) fclose(fplab);
if(fpout) fclose(fpout);
} else {
logout("fatal: x: no memory!\n");
}
pp_end();
/* } else {
logout("fatal: pp: no memory!");*/
}
} else {
logout("fatal: l: no memory!\n");
}
} else {
logout("fatal: b: no memory!\n");
}
/*m_exit();*/
} else {
logout("Not enough memory available!\n");
}
if(ner || er)
{
fprintf(stderr, "Break after %d error%c\n",ner,ner?'s':0);
/*unlink();*/
if(ofile) {
unlink(ofile);
}
}
free(ifiles);
return( (er || ner) ? 1 : 0 );
}
GLboolean
dri_create_context(gl_api api, const struct gl_config * visual,
__DRIcontext * cPriv,
unsigned major_version,
unsigned minor_version,
uint32_t flags,
bool notify_reset,
unsigned *error,
void *sharedContextPrivate)
{
__DRIscreen *sPriv = cPriv->driScreenPriv;
struct dri_screen *screen = dri_screen(sPriv);
struct st_api *stapi = screen->st_api;
struct dri_context *ctx = NULL;
struct st_context_iface *st_share = NULL;
struct st_context_attribs attribs;
enum st_context_error ctx_err = 0;
memset(&attribs, 0, sizeof(attribs));
switch (api) {
case API_OPENGLES:
attribs.profile = ST_PROFILE_OPENGL_ES1;
break;
case API_OPENGLES2:
attribs.profile = ST_PROFILE_OPENGL_ES2;
break;
case API_OPENGL_COMPAT:
case API_OPENGL_CORE:
attribs.profile = api == API_OPENGL_COMPAT ? ST_PROFILE_DEFAULT
: ST_PROFILE_OPENGL_CORE;
attribs.major = major_version;
attribs.minor = minor_version;
if ((flags & __DRI_CTX_FLAG_DEBUG) != 0)
attribs.flags |= ST_CONTEXT_FLAG_DEBUG;
if ((flags & __DRI_CTX_FLAG_FORWARD_COMPATIBLE) != 0)
attribs.flags |= ST_CONTEXT_FLAG_FORWARD_COMPATIBLE;
break;
default:
*error = __DRI_CTX_ERROR_BAD_API;
goto fail;
}
if (flags & ~(__DRI_CTX_FLAG_DEBUG | __DRI_CTX_FLAG_FORWARD_COMPATIBLE)) {
*error = __DRI_CTX_ERROR_UNKNOWN_FLAG;
goto fail;
}
if (notify_reset) {
*error = __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE;
goto fail;
}
if (sharedContextPrivate) {
st_share = ((struct dri_context *)sharedContextPrivate)->st;
}
ctx = CALLOC_STRUCT(dri_context);
if (ctx == NULL) {
*error = __DRI_CTX_ERROR_NO_MEMORY;
goto fail;
}
cPriv->driverPrivate = ctx;
ctx->cPriv = cPriv;
ctx->sPriv = sPriv;
dri_fill_st_options(&attribs.options, &screen->optionCache);
dri_fill_st_visual(&attribs.visual, screen, visual);
ctx->st = stapi->create_context(stapi, &screen->base, &attribs, &ctx_err,
st_share);
if (ctx->st == NULL) {
switch (ctx_err) {
case ST_CONTEXT_SUCCESS:
*error = __DRI_CTX_ERROR_SUCCESS;
break;
case ST_CONTEXT_ERROR_NO_MEMORY:
*error = __DRI_CTX_ERROR_NO_MEMORY;
break;
case ST_CONTEXT_ERROR_BAD_API:
*error = __DRI_CTX_ERROR_BAD_API;
break;
case ST_CONTEXT_ERROR_BAD_VERSION:
*error = __DRI_CTX_ERROR_BAD_VERSION;
break;
case ST_CONTEXT_ERROR_BAD_FLAG:
*error = __DRI_CTX_ERROR_BAD_FLAG;
break;
case ST_CONTEXT_ERROR_UNKNOWN_ATTRIBUTE:
*error = __DRI_CTX_ERROR_UNKNOWN_ATTRIBUTE;
break;
case ST_CONTEXT_ERROR_UNKNOWN_FLAG:
*error = __DRI_CTX_ERROR_UNKNOWN_FLAG;
break;
}
goto fail;
}
ctx->st->st_manager_private = (void *) ctx;
ctx->stapi = stapi;
if (ctx->st->cso_context) {
ctx->pp = pp_init(ctx->st->pipe, screen->pp_enabled, ctx->st->cso_context);
ctx->hud = hud_create(ctx->st->pipe, ctx->st->cso_context);
}
*error = __DRI_CTX_ERROR_SUCCESS;
return GL_TRUE;
fail:
if (ctx && ctx->st)
ctx->st->destroy(ctx->st);
free(ctx);
return GL_FALSE;
}
EXPORT void FrontInitStandardIO(
int argc,
char **argv,
F_BASIC_DATA *f_basic)
{
char *in_name = f_basic->in_name;
char *out_name = f_basic->out_name;
char *restart_name = f_basic->restart_name;
int *subdomains = f_basic->subdomains;
f_basic->ReadFromInput = NO;
f_basic->RestartRun = NO;
#if defined(__MPI__)
pp_init(&argc,&argv);
#endif /* defined(__MPI__) */
argc--;
argv++;
strcpy(out_name,"intfc");
while (argc >= 1)
{
if (argv[0][0] != '-')
{
printf("Usage: example -o output\n");
exit(1);
}
switch(argv[0][1]) {
case 'i':
case 'I':
f_basic->ReadFromInput = YES;
zero_scalar(in_name,200);
strcpy(in_name,argv[1]);
argc -= 2;
argv += 2;
break;
case 'r':
case 'R':
f_basic->RestartRun = YES;
zero_scalar(restart_name,200);
strcpy(restart_name,argv[1]);
argc -= 2;
argv += 2;
break;
case 't':
case 'T':
f_basic->RestartStep = atoi(argv[1]);
argc -= 2;
argv += 2;
break;
case 'd':
case 'D':
f_basic->dim = atoi(argv[1]);
argc -= 2;
argv += 2;
break;
case 'o':
case 'O':
zero_scalar(out_name,200);
strcpy(out_name,argv[1]);
#if defined(__MPI__)
sprintf(out_name,"%s.%d",out_name,pp_mynode());
#endif /* defined(__MPI__) */
freopen(out_name,"w",stdout);
zero_scalar(out_name,200);
strcpy(out_name,argv[1]);
argc -= 2;
argv += 2;
break;
#if defined(__MPI__)
case 'p':
case 'P':
{
int i,total_num_proc = 1;
for (i = 0; i < MAXD; ++i)
{
if (argc < 2 || argv[1][0] == '-') break;
argc -= 1;
argv += 1;
subdomains[i] = atoi(argv[0]);
total_num_proc *= subdomains[i];
}
argc -= 1;
argv += 1;
if (total_num_proc != pp_numnodes())
{
printf("total number of processors for the partition %d "
"does not equal to requested np %d\n",
total_num_proc,pp_numnodes());
clean_up(ERROR);
}
}
#endif /* defined(__MPI__) */
}
}
} /* end FrontInitStatndardIO */
int main(int argc, char *argv[])
{
// Catch signals
signal(SIGINT, uquad_sig_handler);
signal(SIGQUIT, uquad_sig_handler);
int
i,
retval;
FILE *file;
uquad_mat_t *x, *w;
uquad_bool_t ctrl_outdated = false;
double w_hover;
if(argc < 2)
{
err_log_str("Invalid arguments!",USAGE)
quit();
}
else
{
file = fopen(argv[1],"r");
if(file == NULL)
{
err_log_stderr("Failed to open log!");
quit();
}
}
x = uquad_mat_alloc(STATE_COUNT,1);
w = uquad_mat_alloc(LENGTH_INPUT,1);
if(x == NULL || w == NULL)
{
quit_log_if(ERROR_MALLOC,"Failed to allocate tmp mem!");
}
/**
* The following should be done by calling mot_update_w_hover(), this
* is just a test program.
*/
retval = uquad_solve_pol2(&w_hover, NULL, F_B1, F_B2, -GRAVITY*MASA_DEFAULT/4.0);
quit_log_if(retval, "Failed to get w_hover!");
for(i=0; i<LENGTH_INPUT; ++i)
w->m_full[i] = w_hover;
retval = uquad_mat_zeros(x);
quit_if(retval);
ctrl = control_init();
if(ctrl == NULL)
{
quit_if(ERROR_FAIL);
}
pp = pp_init();
if(pp == NULL)
{
quit_if(ERROR_FAIL);
}
retval = pp_new_setpoint(pp, x, w);
quit_if(retval);
retval = control_update_K(ctrl, pp, MASA_DEFAULT);
quit_log_if(retval, "Failed to update control matrix! Aborting...");
for(;;)
{
retval = uquad_mat_load(x,file);
if(retval != ERROR_OK)
{
quit_log_if(retval, "End of log?");
}
#warning "w_hover should use mot_control.h!!"
retval = pp_update_setpoint(pp, x, w_hover, &ctrl_outdated);
quit_if(retval);
if(ctrl_outdated)
{
retval = control_update_K(ctrl, pp, MASA_DEFAULT);
quit_log_if(retval, "Failed to update control matrix! Aborting...");
retval = control_dump(ctrl, NULL);
quit_log_if(retval, "Failed to dump new control matrix! Aborting...");
}
retval = control(ctrl, w, x, pp->sp, TS_DEFAULT_US);
quit_if(retval);
ctrl_outdated = false;
}
// Never gets here
quit();
}
