static void imlut_new(DL_STATE *page, float *decode_array, void *decode_for_adjust, int32 ncomps, int32 bpp, Bool expanded, uint8 **lut, imlut_t **new_imlut) { Bool result = FALSE; const imlut_t blank = { 0 }; imlut_t *imlut; *new_imlut = NULL; imlut = dl_alloc(page->dlpools, sizeof(imlut_t), MM_ALLOC_CLASS_IMAGE_TABLES); if ( imlut == NULL ) return; *imlut = blank; imlut->bpp = bpp; imlut->ncomps = ncomps; imlut->decode_for_adjust = decode_for_adjust; imlut->expanded = expanded; imlut->lut = lut; #if defined( DEBUG_BUILD ) imlut->hits = 1; #endif #define return DO_NOT_return_goto_cleanup_INSTEAD! if ( decode_array ) { int32 i; imlut->decode_array = dl_alloc(page->dlpools, 2 * ncomps * sizeof(float), MM_ALLOC_CLASS_IMAGE_TABLES); if ( !imlut->decode_array ) goto cleanup; for ( i = 2 * ncomps - 1; i >= 0; --i ) { imlut->decode_array[i] = decode_array[i]; } } *new_imlut = imlut; result = TRUE; cleanup: if ( !result ) /* Failure is not an error, just tidy up */ imlut_free(page, imlut); #undef return return; }
void dl_draw_strip(dl_list_t * dl, const draw_vertex_t v[256], int n, int flags) { struct dl_draw_strip_command * c = dl_alloc(dl, sizeof(*c) - sizeof(c->v) + n * sizeof(c->v[0])); /* SDDEBUG("[%s] %d %x\n", __FUNCTION__, n, flags); */ if (c) { int i; c->n = n; c->flags = flags; for (i=0; i<n; ++i) { c->v[i] = v[i]; /* SDDEBUG("%02d %f %f %f %f\n\n", i, v[i].x, v[i].y, v[i].w, v[i].w); */ } dl_insert(dl, c, dl_draw_strip_render_opaque, dl_draw_strip_render_transparent); } }
static void dl_load_txt_build_default_data( dl_ctx_t ctx, dl_txt_read_ctx* read_state, unsigned int member_index ) { if( ctx->member_descs[member_index].default_value_offset == 0xFFFFFFFF ) return; // TODO: check that this is not outside the buffers dl_type_desc* def_type = dl_alloc_type( ctx, dl_internal_hash_string( "a_type_here" ) ); dl_member_desc* def_member = dl_alloc_member( ctx ); dl_member_desc* member = &ctx->member_descs[member_index]; uint32_t def_start = member->default_value_offset; uint32_t def_len = member->default_value_size; char def_buffer[2048]; // TODO: no hardcode =/ // TODO: check that typename do not exist in the ctx! size_t name_start = ctx->typedata_strings_size; dl_txt_read_substr temp = { "a_type_here", 11 }; def_type->name = dl_alloc_string( ctx, &temp ); def_type->size[DL_PTR_SIZE_HOST] = member->size[DL_PTR_SIZE_HOST]; def_type->alignment[DL_PTR_SIZE_HOST] = member->alignment[DL_PTR_SIZE_HOST]; def_type->member_count = 1; memcpy( def_member, member, sizeof( dl_member_desc ) ); def_member->offset[0] = 0; def_member->offset[1] = 0; dl_internal_str_format( def_buffer, sizeof(def_buffer), "{\"a_type_here\":{\"%s\":%.*s}}", dl_internal_member_name( ctx, member ), (int)def_len, read_state->start + def_start ); size_t prod_bytes; dl_error_t err; err = dl_txt_pack( ctx, def_buffer, 0x0, 0, &prod_bytes ); if( err != DL_ERROR_OK ) dl_txt_read_failed( ctx, read_state, DL_ERROR_INVALID_DEFAULT_VALUE, "failed to pack default-value for member \"%s\" with error \"%s\"", dl_internal_member_name( ctx, member ), dl_error_to_string( err ) ); uint8_t* pack_buffer = (uint8_t*)dl_alloc( &ctx->alloc, prod_bytes ); dl_txt_pack( ctx, def_buffer, pack_buffer, prod_bytes, 0x0 ); // TODO: convert packed instance to typelib endian/ptrsize here! size_t inst_size = prod_bytes - sizeof( dl_data_header ); ctx->default_data = (uint8_t*)dl_realloc( &ctx->alloc, ctx->default_data, ctx->default_data_size + inst_size, ctx->default_data_size ); memcpy( ctx->default_data + ctx->default_data_size, pack_buffer + sizeof( dl_data_header ), inst_size ); dl_free( &ctx->alloc, pack_buffer ); member->default_value_offset = (uint32_t)ctx->default_data_size; member->default_value_size = (uint32_t)inst_size; ctx->default_data_size += inst_size; --ctx->type_count; --ctx->member_count; ctx->typedata_strings_size = name_start; }
static void scrolltext(dl_list_t * dl, float x, float y, float z, float a, float r, float g, float b, const char * text, float w, float spd, int pingpong) { struct scrolltext_command * c; int len; if (!text) { return; } if (len = strlen(text), len < 1) { return; } len += sizeof(*c); if (c = dl_alloc(dl, len), c) { c->x = x; c->y = y; c->z = z; c->a = a; c->r = r; c->g = g; c->b = b; c->len = len; c->window = w > 0 ? w : 640; c->spd = (spd != 0) ? spd : 1; c->pingpong = pingpong; strcpy(c->text, text); text_size_str_prop(text, &c->w, &c->h, 0, 16, 1); if (pingpong == 2) { c->xs = 0; } else { c->xs = c->spd > 0 ? c->window : -c->w; } dl_insert(dl, c, 0, scrolltext_render_transparent); } }
/** * Create a new blist * * There are three different ways we may want to create a blist * a) block != NULL && abytes == 0 * This means create a blist and copy its characteristics from the * specified block * b) block == NULL && abytes != 0 * This means create a blist and all zero all its characteristics * except for setting abytes to the given value * c) block == NULL && abytes == 0 * This means create the blist and the block in one chunk of memory * and zero all the blist and block characteristics. * * \param[in] page DL on which the image blist is being used. * \param[in] bx Column index * \param[in] global Is it a global or local blist ? * \param[in,out] block Image block template * \param[in] abytes block size * \param[in] cost MM cost * \return The created blist, or NULL on error */ IM_BLIST *blist_create(IM_SHARED *im_shared, int32 bx, Bool global, IM_BLOCK *block, int32 abytes, mm_cost_t cost) { IM_BLIST *blist; size_t size = sizeof(IM_BLIST); HQASSERT(block == NULL || abytes == 0,"blist creation specified twice"); if ( abytes || block ) { if ( (blist = dl_alloc(im_shared->page->dlpools, size, MM_ALLOC_CLASS_IMAGE_DATA)) == NULL ) return NULL; } else { size += im_blocksizeof(); if ( (blist = im_dataalloc(im_shared, size, cost)) == NULL ) return NULL; block = (IM_BLOCK *)(blist + 1); HqMemZero(block, im_blocksizeof()); } blist->bx = bx; blist->global = (uint8)global; blist->wasGlobal = (uint8)global; blist->next = NULL; blist->prev = NULL; blist->block = block; if ( block ) im_block2blist(blist, TRUE); else { blist->wasGlobal = (uint8)(!global); /* Not sure why this is done */ blist->abytes = CAST_SIGNED_TO_INT16(abytes); blist->data = NULL; } return blist; }
static int gc_any(lua_State * L, dl_list_t * dl, dl_command_func_t render) { struct gc_com * c; if(c = dl_alloc(dl, sizeof(*c)), !c) { return DL_COMID_ERROR; } c->flags = strtoflags(lua_tostring(L, 2), GC_RESTORE_ALL); return dl_insert(dl, c, push_render, push_render); }
static void setcolor1(dl_list_t * dl, const draw_color_t * color) { struct color1_com * c; if(c = dl_alloc(dl, sizeof(*c)), !c) { return; } c->color[0] = color[0]; dl_insert(dl, c, dl_color1_render, dl_color1_render); }
static void properties(dl_list_t * dl, fontid_t fontid, const float size, const float aspect, int filter) { struct textprop_command * c; if (fontid < 0 || size <= 0) { return; } if (c = dl_alloc(dl, sizeof(*c)), c) { c->font = fontid; c->size = size; c->aspect = aspect; c->filter = filter; dl_insert(dl, c, 0, properties_render_transparent); } }
void glNewList(GLuint list, GLenum mode) { FORWARD_IF_REMOTE(glNewList); // TODO: make sure this doesn't break anything if (list == 0) { ERROR(GL_INVALID_VALUE); } if (mode != GL_COMPILE && mode != GL_COMPILE_AND_EXECUTE) { ERROR(GL_INVALID_ENUM); } if (state.block.active || state.list.active) { ERROR(GL_INVALID_OPERATION); } displaylist_t *dl = dl_alloc(); if (dl == NULL) { ERROR(GL_OUT_OF_MEMORY); } state.list.name = list; state.list.mode = mode; state.list.active = dl; }
dl_error_t dl_context_create( dl_ctx_t* dl_ctx, dl_create_params_t* create_params ) { dl_allocator alloc; dl_allocator_initialize( &alloc, create_params->alloc_func, create_params->realloc_func, create_params->free_func, create_params->alloc_ctx ); dl_context* ctx = (dl_context*)dl_alloc( &alloc, sizeof( dl_context ) ); if(ctx == 0x0) return DL_ERROR_OUT_OF_LIBRARY_MEMORY; memset(ctx, 0x0, sizeof(dl_context)); memcpy(&ctx->alloc, &alloc, sizeof( dl_allocator ) ); ctx->error_msg_func = create_params->error_msg_func; ctx->error_msg_ctx = create_params->error_msg_ctx; *dl_ctx = ctx; return DL_ERROR_OK; }
static void text(dl_list_t * dl, float x, float y, float z, float a, float r, float g, float b, const char * text) { struct text_command * c; int len; if (!text) { return; } if (len = strlen(text), len < 1) { return; } len += sizeof(*c); if (c = dl_alloc(dl, len), c) { c->x = x; c->y = y; c->z = z; c->a = a; c->r = r; c->g = g; c->b = b; strcpy(c->text, text); /* SDDEBUG("[dltext: [%s]]\n",c->text); */ dl_insert(dl, c, 0, text_render_transparent); } }
/** * Start the image blist module for this page. */ Bool im_blist_start(IM_SHARED *im_shared) { BLIST_CTX *ctx; size_t i, nthreads = NUM_THREADS(); HQASSERT(im_shared->blist_ctx == NULL, "blist_ctx already exists"); ctx = dl_alloc(im_shared->page->dlpools, sizeof(BLIST_CTX) + sizeof(blist_wide_band) * (nthreads-1), MM_ALLOC_CLASS_IMAGE); if ( ctx == NULL ) return error_handler(VMERROR); ctx->im_blistc = 0; ctx->nthreads = nthreads; for ( i = 0 ; i < nthreads ; ++i ) { ctx->wide_bands[i].width = 0; ctx->wide_bands[i].bandno = 0; } im_shared->blist_ctx = ctx; return TRUE; }