void free_EquipmentsToBeTraced(struct EquipmentsToBeTraced* equipmentsToBeTraced) {
free_object(equipmentsToBeTraced, &EQUIPMENTSTOBETRACED_TYPE);
}
static inline void free_kmem_cache_object(struct kmem_cache *cache)
{
free_object(&kmem_cache_cache, cache);
}
void kfree(void *ptr)
{
struct slab_page *slab = VIRT_TO_PAGE(ptr);
free_object(slab->cache, ptr);
}
void free_IuTransportAssociation(struct IuTransportAssociation* iuTransportAssociation) {
free_object(iuTransportAssociation, &IUTRANSPORTASSOCIATION_TYPE);
}
static void
free_pinned_object (char *obj, size_t size)
{
free_object (obj, size, TRUE);
}
void image_dct(INT32 args)
{
rgbd_group *area,*val;
struct object *o;
struct image *img;
INT32 x,y,u,v;
double xsz2,ysz2,enh,xp,yp,dx,dy;
double *costbl;
rgb_group *pix;
if (!THIS->img)
Pike_error("Called Image.Image object is not initialized\n");
#ifdef DCT_DEBUG
fprintf(stderr,"%lu bytes, %lu bytes\n",
DO_NOT_WARN((unsigned long)(sizeof(rgbd_group)*THIS->xsize*THIS->ysize)),
DO_NOT_WARN((unsigned long)(sizeof(rgb_group)*THIS->xsize*THIS->ysize+1)));
#endif
area=xalloc(sizeof(rgbd_group)*THIS->xsize*THIS->ysize+1);
if (!(costbl=malloc(sizeof(double)*THIS->xsize+1)))
{
free(area);
resource_error(NULL,0,0,"memory",0,"Out of memory.\n");
}
o=clone_object(image_program,0);
img=(struct image*)(o->storage);
*img=*THIS;
if (args>=2
&& sp[-args].type==T_INT
&& sp[1-args].type==T_INT)
{
img->xsize=MAXIMUM(1,sp[-args].u.integer);
img->ysize=MAXIMUM(1,sp[1-args].u.integer);
}
else {
free(area);
free(costbl);
free_object(o);
bad_arg_error("image->dct",sp-args,args,0,"",sp-args,
"Bad arguments to image->dct()\n");
}
if (!(img->img=(rgb_group*)malloc(sizeof(rgb_group)*
img->xsize*img->ysize+1)))
{
free(area);
free(costbl);
free_object(o);
resource_error(NULL,0,0,"memory",0,"Out of memory.\n");
}
xsz2=THIS->xsize*2.0;
ysz2=THIS->ysize*2.0;
enh=(8.0/THIS->xsize)*(8.0/THIS->ysize);
for (u=0; u<THIS->xsize; u++)
{
double d,z0;
rgbd_group sum;
for (v=0; v<THIS->ysize; v++)
{
d=(u?1:c0)*(v?1:c0)/4.0;
sum.r=sum.g=sum.b=0;
pix=THIS->img;
for (x=0; x<THIS->xsize; x++)
costbl[x]=cos( (2*x+1)*u*pi/xsz2 );
for (y=0; y<THIS->ysize; y++)
{
z0=cos( (2*y+1)*v*pi/ysz2 );
for (x=0; x<THIS->xsize; x++)
{
double z;
z = costbl[x] * z0;
sum.r += (float)(pix->r*z);
sum.g += (float)(pix->g*z);
sum.b += (float)(pix->b*z);
pix++;
}
}
sum.r *= (float)d;
sum.g *= (float)d;
sum.b *= (float)d;
area[u+v*THIS->xsize]=sum;
}
#ifdef DCT_DEBUG
fprintf(stderr,"."); fflush(stderr);
#endif
}
#ifdef DCT_DEBUG
fprintf(stderr,"\n");
#endif
dx=((double)(THIS->xsize-1))/(img->xsize);
dy=((double)(THIS->ysize-1))/(img->ysize);
pix=img->img;
for (y=0,yp=0; y<img->ysize; y++,yp+=dy)
{
double z0;
rgbd_group sum;
for (x=0,xp=0; x<img->xsize; x++,xp+=dx)
{
sum.r=sum.g=sum.b=0;
val=area;
for (u=0; u<THIS->xsize; u++)
costbl[u]=cos( (2*xp+1)*u*pi/xsz2 );
for (v=0; v<THIS->ysize; v++)
{
z0=cos( (2*yp+1)*v*pi/ysz2 )*(v?1:c0)/4.0;
for (u=0; u<THIS->xsize; u++)
{
double z;
z = (u?1:c0) * costbl[u] * z0;
sum.r += DO_NOT_WARN((float)(val->r*z));
sum.g += DO_NOT_WARN((float)(val->g*z));
sum.b += DO_NOT_WARN((float)(val->b*z));
val++;
}
}
sum.r *= (float)enh;
sum.g *= (float)enh;
sum.b *= (float)enh;
pix->r=testrange((DOUBLE_TO_INT(sum.r+0.5)));
pix->g=testrange((DOUBLE_TO_INT(sum.g+0.5)));
pix->b=testrange((DOUBLE_TO_INT(sum.b+0.5)));
pix++;
}
#ifdef DCT_DEBUG
fprintf(stderr,"."); fflush(stderr);
#endif
}
free(area);
free(costbl);
pop_n_elems(args);
push_object(o);
}
int omega_stream (struct msscene *ms, FILE *fpt, FILE *fpn, FILE *fph, FILE *fpe, FILE *fpo, char *format, double sphere_radius, double x_radius)
{
double expansion_radius, extension_radius;
char message[128];
struct surface *msphn1, *msphn2, *msphn3;
if (sphere_radius <= 0.0) {
sprintf (message, "%8.3f negative sphere radius", sphere_radius);
set_error1 (message);
return (0);
}
expansion_radius = 0.0;
extension_radius = 0.0;
if (fpt != NULL) {
/* first polyhedron */
msphn1 = read_vet (fpt);
if (error()) return (0);
fclose (fpt);
do_bounds (msphn1);
if (error()) return (0);
do_axes(msphn1);
if (error()) return (0);
}
else msphn1 = NULL;
if (fpn != NULL) {
/* second polyhedron */
msphn2 = read_vet (fpn);
if (error()) return (0);
fclose (fpn);
do_bounds (msphn2);
if (error()) return (0);
do_axes(msphn2);
if (error()) return (0);
}
else msphn2 = NULL;
if (fph != NULL) {
/* third polyhedron */
msphn3 = read_vet (fph);
if (error()) return (0);
fclose (fph);
do_bounds (msphn3);
if (error()) return (0);
do_axes(msphn3);
if (error()) return (0);
}
else msphn3 = NULL;
/* evaluation loci */
sprintf (message, "%8.3f evaluation radius", sphere_radius);
inform(message);
if (msphn1 != NULL && msphn2 == NULL && msphn3 == NULL) {
expansion_radius = x_radius;
sprintf (message, "%8.3f expansion radius", expansion_radius);
inform(message);
}
if (msphn1 != NULL && msphn2 != NULL && msphn3 == NULL) {
extension_radius = x_radius;
sprintf (message, "%8.3f extension radius", extension_radius);
inform(message);
}
set_omega_radii (msphn1, sphere_radius, expansion_radius, extension_radius);
do_evaluation (msphn1, msphn2, msphn3, (int) (extension_radius > 0.0));
if (error()) return (0);
if (msphn2 == NULL && msphn3 == NULL) {
identify (msphn1);
if (error()) return (0);
}
msphn1 -> scheme = NULL;
if (format == NULL || strlen(format) == (unsigned) 0 || strcmp(format,"vet") == 0)
write_vet (msphn1, fpo);
if (error()) return (0);
if (msphn1 != NULL) {
free_phn (msphn1);
if (error()) return(0);
free_object (SURFACE, (short *) msphn1);
if (error()) return(0);
}
if (msphn2 != NULL) {
free_phn (msphn2);
if (error()) return(0);
free_object (SURFACE, (short *) msphn2);
if (error()) return(0);
}
if (msphn3 != NULL) {
free_phn (msphn3);
if (error()) return(0);
free_object (SURFACE, (short *) msphn3);
if (error()) return(0);
}
return (1);
}
void free_QueuingAllowed(enum QueuingAllowed* queuingAllowed) {
free_object(queuingAllowed, &QUEUINGALLOWED_TYPE);
}
void free_leaf (struct leaf *lef)
{
free_object (LEAF, (short *) lef);
if (error()) return;
}
void display_object_info(ostream &out, const FrObject *obj)
{
FramepaC_bgproc() ; // handle any asynchronous operations
FramepaC_bgproc() ;
size_t objlen = FrObject_string_length(obj) ;
out << "\n\nYou entered " ;
if (objlen > 68)
out << endl ;
out << obj << endl ;
if (obj)
out << "That object is of type " << obj->objTypeName()
<< "; it takes " << objlen << " bytes to print" << endl ;
else
return ;
if (obj->framep())
{
FrList *framekit = FramepaC_to_FrameKit((FrFrame *)obj) ;
out << "As a FrameKit frame, it would be:\n" << framekit << endl ;
free_object(framekit) ;
}
else if (obj->arrayp())
{
if (obj->length() > 0)
out << "This "
<< ((obj->objType() == OT_FrSparseArray) ? "sparse " : "")
<< "array's last element is "
<< (*(FrArray*)obj)[obj->length()-1] << endl ;
}
else if (obj->queuep())
{
out << "This queue contains " << ((FrQueue*)obj)->queueLength()
<< " items" << endl ;
}
else if (obj->hashp())
{
FrList *matches = ((FrHashTable*)obj)->prefixMatches("A") ;
out << "This hash table contains " << matches->listlength()
<< " items matching the prefix 'A'" << endl ;
free_object(matches) ;
}
else if (obj->stringp())
out << "This string uses " << ((FrString*)obj)->charWidth()
<< "-byte characters." << endl ;
else if (obj->consp())
{
out << "Its length is " << obj->length() << " cons cells.\n"
<< "Its head is " << obj->car() << " and its tail is "
<< obj->cdr() << endl << endl ;
FrObject *obj_car = obj->car() ;
if (obj_car && obj_car->symbolp() &&
(obj_car == findSymbol("MAKE-FRAME") ||
obj_car == findSymbol("MAKE-FRAME-OLD")))
{
FrFrame *frame = FrameKit_to_FramepaC((FrList *)obj) ;
out << "It is a FrameKit frame; as a FramepaC frame, it would be:\n"
<< frame << endl ;
free_object(frame) ;
}
}
else if (obj->vectorp())
{
out << "This vector contains " << obj->length() << " bits, of which "
<< ((FrBitVector*)obj)->countBits() << " are set." << endl ;
}
FramepaC_bgproc() ; // handle any asynchronous operations
return ;
}
static void image_ttf_faceinstance_write(INT32 args)
{
int **sstr;
int *slen;
int i,res=0,base=0,a;
struct image_ttf_face_struct *face_s;
struct image_ttf_faceinstance_struct *face_i=THISi;
TT_CharMap charMap;
TT_Kerning kerning;
int has_kerning = 0;
char *errs=NULL;
int scalefactor=0;
int xmin=1000,xmax=-1000,pos=0,ypos;
int width,height,mod;
unsigned char* pixmap;
int maxcharwidth = 0;
if (!(face_s=(struct image_ttf_face_struct*)
get_storage(THISi->faceobj,image_ttf_face_program)))
Pike_error("Image.TTF.FaceInstance->write(): lost Face\n");
if(!TT_Get_Kerning_Directory( face_s->face, &kerning ))
{
TT_Instance_Metrics metrics;
/* fprintf(stderr, "has kerning!\n"); */
has_kerning = 1;
if(TT_Get_Instance_Metrics( face_i->instance, &metrics ))
Pike_error("Nope. No way.\n");
scalefactor = metrics.x_scale;
/* fprintf(stderr, "offset=%d\n", (int)metrics.x_scale); */
}
if (args && sp[-1].type==T_INT)
{
base=sp[-1].u.integer;
args--;
pop_stack();
}
if (!args)
{
push_empty_string();
args=1;
}
ttf_get_nice_charmap(face_s->face,&charMap,
"Image.TTF.FaceInstance->write()");
sstr=alloca(args*sizeof(int*));
slen=alloca(args*sizeof(int));
/* first pass: figure out total bounding box */
for (a=0; a<args; a++)
{
char *errs=NULL;
TT_Glyph_Metrics metrics;
if (sp[a-args].type!=T_STRING)
Pike_error("Image.TTF.FaceInstance->write(): illegal argument %d\n",a+1);
switch(sp[a-args].u.string->size_shift)
{
case 0:
ttf_translate_8bit(charMap,(unsigned char*)sp[a-args].u.string->str,
sstr+a,
DO_NOT_WARN(slen[a]=sp[a-args].u.string->len),
base);
break;
case 1:
ttf_translate_16bit(charMap,(unsigned short*)sp[a-args].u.string->str,
sstr+a,
DO_NOT_WARN(slen[a]=sp[a-args].u.string->len),
base);
break;
case 2:
Pike_error("Too wide string for truetype\n");
break;
}
pos=0;
for (i=0; i<slen[a]; i++)
{
TT_Glyph glyph;
int ind;
ind=sstr[a][i];
/* fprintf(stderr,"glyph: %d\n",ind); */
if ((res=TT_New_Glyph(face_s->face,&glyph)))
{ errs="TT_New_Glyph: "; break; }
if ((res=TT_Load_Glyph(face_i->instance, glyph, (TT_UShort)ind,
(TT_UShort)face_i->load_flags)))
{ errs="TT_Load_Glyph: "; break; }
if ((res=TT_Get_Glyph_Metrics(glyph,&metrics)))
{ errs="TT_Get_Glyph_Metrics: "; break; }
if (pos+metrics.bbox.xMin<xmin)
xmin=pos+metrics.bbox.xMin;
if (pos+metrics.bbox.xMax>xmax)
xmax=pos+metrics.bbox.xMax;
if((metrics.bbox.xMax-(metrics.bbox.xMin<0?metrics.bbox.xMin:0))
>maxcharwidth)
maxcharwidth =
(metrics.bbox.xMax-(metrics.bbox.xMin<0?metrics.bbox.xMin:0));
pos+=metrics.advance;
if(has_kerning && i<slen[a]-1)
{
int kern = find_kerning( kerning, ind, sstr[a][i+1] );
pos += DOUBLE_TO_INT(kern * (scalefactor/65535.0));
}
if ((res=TT_Done_Glyph(glyph)))
{ errs="TT_Done_Glyph: "; break; }
}
pos -= metrics.advance;
pos += metrics.bbox.xMax-metrics.bbox.xMin;
if (pos>xmax)
xmax=pos;
if (errs)
{
for (i=0; i<a; i++) free(sstr[i]);
my_tt_error("Image.TTF.FaceInstance->write()",errs,res);
}
}
pop_n_elems(args);
/* fprintf(stderr,"xmin=%f xmax=%f\n",xmin/64.0,xmax/64.0); */
xmin&=~63;
width=((xmax-xmin+63)>>6)+4;
height=face_i->height*args;
mod=(4-(maxcharwidth&3))&3;
if (width<1) width=1;
if ((pixmap=malloc((maxcharwidth+mod)*face_i->height)))
{
/* second pass: write the stuff */
TT_Raster_Map rastermap;
struct object *o;
struct image *img;
rgb_group *d;
rastermap.rows=face_i->height;
rastermap.cols=rastermap.width=maxcharwidth+mod;
rastermap.flow=TT_Flow_Down;
rastermap.bitmap=pixmap;
rastermap.size=rastermap.cols*rastermap.rows;
ypos=0;
/* fprintf(stderr,"rastermap.rows=%d cols=%d width=%d\n", */
/* rastermap.rows,rastermap.cols,rastermap.width); */
push_int(width);
push_int(height);
o=clone_object(image_program,2);
img=(struct image*)get_storage(o,image_program);
d=img->img;
for (a=0; a<args; a++)
{
pos=-xmin;
for (i=0; i<slen[a]; i++)
{
int sw, xp;
TT_Glyph glyph;
TT_Glyph_Metrics metrics;
int ind, x, y;
ind=sstr[a][i];
/* fprintf(stderr,"glyph: %d\n",ind); */
if ((res=TT_New_Glyph(face_s->face,&glyph)))
{ errs="TT_New_Glyph: "; break; }
if ((res=TT_Load_Glyph(face_i->instance, glyph, (TT_UShort)ind,
(TT_UShort)face_i->load_flags)))
{ errs="TT_Load_Glyph: "; break; }
if ((res=TT_Get_Glyph_Metrics(glyph,&metrics)))
{ errs="TT_Get_Glyph_Metrics: "; break; }
MEMSET(pixmap,0,rastermap.size);
if ((res=TT_Get_Glyph_Pixmap(glyph,
&rastermap,
-metrics.bbox.xMin
/*+pos%64*/,
face_i->height*64-
face_i->trans)))
{ errs="TT_Get_Glyph_Pixmap: "; break; }
sw = metrics.bbox.xMax-(metrics.bbox.xMin<0?metrics.bbox.xMin:0);
/* Copy source pixmap to destination image object. */
for(y=0; y<face_i->height; y++)
{
unsigned int s;
unsigned char * source = pixmap+rastermap.width*y;
rgb_group *dt=d+(ypos+y)*width+(xp=(metrics.bbox.xMin+pos)/64);
for(x=0; x<sw && xp<width; x++,xp++,source++,dt++)
if(xp<0 || !(s = *source))
continue;
else if((s=dt->r+s) < 256)
dt->r=dt->g=dt->b=s;
else
dt->r=dt->g=dt->b=255;
}
pos+=metrics.advance;
/* if(metrics.bbox.xMin < 0) */
/* pos += metrics.bbox.xMin; */
if(has_kerning && i<slen[a]-1)
{
int kern = find_kerning( kerning, sstr[a][i], sstr[a][i+1] );
pos += DOUBLE_TO_INT(kern * (scalefactor/65535.0));
/* fprintf(stderr, "Adjusted is %d\n", */
/* (int)(kern * (scalefactor/65535.0))); */
}
if ((res=TT_Done_Glyph(glyph)))
{ errs="TT_Done_Glyph: "; break; }
}
if (errs)
{
for (a=0; a<args; a++) free(sstr[a]);
free(pixmap);
free_object(o);
my_tt_error("Image.TTF.FaceInstance->write()",errs,res);
}
ypos+=face_i->height;
}
free(pixmap);
push_object(o);
}
else
{
Pike_error("Image.TTF.FaceInstance->write(): out of memory\n");
}
for (a=0; a<args; a++)
free(sstr[a]);
}
int
#ifndef __WATCOMC__
__FrCDECL
#endif
main(int argc, char **argv)
{
#ifdef __WATCOMC__
FrDestroyWindow() ; // for Watcom, run as raw console app
#endif /* __WATCOMC__ */
if (argc > 1)
cout << argv[0] << " does not require any arguments." << endl << endl ;
cout << "\tFramepaC " FramepaC_Version_string " Test Program" << endl
<< "\t==========================" << endl
<< "Use \"* ?\" to list the available commands." << endl ;
// deliberately start with a tiny symbol table, to force table expansion as
// we use the test program (in fact, the first expansion will happen during
// initialization)
#if 0
//#ifdef FrMOTIF
Widget main_window = XtVaAppInitialize( &app_context,
"Framepac Test Program",
NULL, 0,
&argc, argv,
NULL, NULL);
FrInitializeMotif("FramepaC Messages",main_window,16) ;
#else
initialize_FramepaC(16) ;
#endif /* FrMOTIF */
FramepaC_set_userinfo_dir(0) ; // set default location
FrObject *obj = 0 ;
FrSymbol *symbolEOF = FrSymbolTable::add("*EOF*") ;
do {
if (obj)
{
obj->freeObject() ; // free the object from prev pass thru the loop
obj = 0 ;
}
FramepaC_bgproc() ; // handle any asynchronous operations
cout << "\nEnter a FrObject, NIL to end: " ;
cin >> obj ;
FramepaC_bgproc() ; // handle any asynchronous operations
if (obj && obj->symbolp() && obj == FrSymbolTable::add("*"))
interpret_command(cout,cin,true) ;
else
display_object_info(cout,obj) ;
FramepaC_bgproc() ; // handle any asynchronous operations
} while (!NIL_symbol(obj) && obj != symbolEOF) ;
free_object(obj) ;
// force the inclusion of some types we don't explicitly use in the code
if (symbolEOF == 0)
{
FrInteger64 dummy_int64 ;
FrStack dummy_stack ;
FrSparseArray dummy_sparse_array ;
if ((size_t)&dummy_int64 == (size_t)&dummy_stack ||
(size_t)&dummy_stack == (size_t)&dummy_sparse_array)
FrProgError("local variables with same address!") ;
}
#if 0
//#ifdef FrMOTIF
FrShutdownMotif() ;
#else
FrShutdown() ;
#endif
return 0 ;
}
void free_MBMSCNDe_Registration(enum MBMSCNDe_Registration* mBMSCNDe_Registration) {
free_object(mBMSCNDe_Registration, &MBMSCNDE_REGISTRATION_TYPE);
}
void free_scene (struct msscene *ms) {
struct square *squares;
struct molecule *head_molecule;
struct surface *head_srf;
struct material_table *table;
struct color_ramp *head_ramp;
struct object_scheme *scheme;
struct surface *srf, *next_srf;
struct color_ramp *rmp, *next_rmp;
struct molecule *mol, *next_mol;
head_molecule = ms -> head_molecule;
head_ramp = ms -> head_ramp;
table = ms -> table;
squares = ms -> squares;
for (mol = head_molecule; mol != NULL; mol = next_mol) {
next_mol = mol -> next;
head_srf = mol -> head_surface;
for (srf = head_srf; srf != NULL; srf = next_srf) {
next_srf = srf -> next;
scheme = srf -> scheme;
if (scheme != NULL) {
if (scheme -> atom_opacities != NULL)
free_doubles (scheme -> atom_opacities, 0, ATOM_OPACITIES);
if (scheme -> atom_colors != NULL)
free_longs (scheme -> atom_colors, 0, ATOM_COLORS);
free_object (OBJECT_SCHEME, (short *) (srf -> scheme));
if (error()) return;
}
clear_pqms (srf);
if (error()) return;
free_surface (srf);
if (error()) return;
free_phn (srf);
if (error()) return;
free_object (SURFACE, (short *) srf);
if (error()) return;
}
if (mol -> atom_alphas != NULL)
free_doubles (mol -> atom_alphas, 0, ATOM_ALPHAS);
free_object (MOLECULE, (short *) mol);
if (error()) return;
}
for (srf = ms -> this_srf; srf != NULL; srf = next_srf) {
next_srf = srf -> next;
clear_pqms (srf);
if (error()) return;
free_surface (srf);
if (error()) return;
free_phn (srf);
if (error()) return;
free_object (SURFACE, (short *) srf);
if (error()) return;
}
for (rmp = head_ramp; rmp != NULL; rmp = next_rmp) {
next_rmp = rmp -> next;
free_object (COLOR_RAMP, (short *) rmp);
if (error()) return;
}
free_object (MATERIAL_TABLE, (short *) (ms -> table));
free_object (MSSCENE, (short *) ms);
}
static pyc_object *get_object(RBuffer *buffer) {
RListIter *ref_idx;
bool error = false;
pyc_object *ret = NULL;
ut8 code = get_ut8 (buffer, &error);
ut8 flag = code & FLAG_REF;
ut8 type = code & ~FLAG_REF;
if (error)
return NULL;
if (flag) {
ret = get_none_object ();
if (!ret)
return NULL;
ref_idx = r_list_append (refs, ret);
if (!ref_idx) {
free (ret);
return NULL;
}
}
switch (type) {
case TYPE_NULL:
return NULL;
case TYPE_TRUE:
return get_true_object ();
case TYPE_FALSE:
return get_false_object ();
case TYPE_NONE:
return get_none_object ();
case TYPE_REF:
return get_ref_object (buffer);
case TYPE_SMALL_TUPLE:
ret = get_small_tuple_object (buffer);
break;
case TYPE_TUPLE:
ret = get_tuple_object (buffer);
break;
case TYPE_STRING:
ret = get_string_object (buffer);
break;
case TYPE_CODE_v1:
ret = get_code_object (buffer);
break;
case TYPE_INT:
ret = get_int_object (buffer);
break;
case TYPE_ASCII_INTERNED:
ret = get_ascii_interned_object (buffer);
break;
case TYPE_SHORT_ASCII:
ret = get_short_ascii_object (buffer);
break;
case TYPE_ASCII:
ret = get_ascii_object (buffer);
break;
case TYPE_SHORT_ASCII_INTERNED:
ret = get_short_ascii_interned_object (buffer);
break;
case TYPE_BINARY_COMPLEX:
case TYPE_ELLIPSIS:
case TYPE_BINARY_FLOAT:
case TYPE_CODE_v0:
case TYPE_COMPLEX:
case TYPE_STRINGREF:
case TYPE_DICT:
case TYPE_FLOAT:
case TYPE_FROZENSET:
case TYPE_STOPITER:
case TYPE_INT64:
case TYPE_INTERNED:
case TYPE_LIST:
case TYPE_LONG:
case TYPE_SET:
case TYPE_UNICODE:
case TYPE_UNKNOWN:
eprintf ("Get not implemented for type %x\n", type);
return NULL;
default:
eprintf ("Undefined type in get_object (%x)\n", type);
return NULL;
}
if (flag) {
free_object (ref_idx->data);
ref_idx->data = copy_object (ret);
}
return ret;
}
static void
PySfDrawable_dealloc(PySfDrawable *self)
{
delete self->obj;
free_object(self);
}
static void
PySfPostFX_dealloc(PySfPostFX *self)
{
delete self->obj;
free_object(self);
}
void free_AlternativeRABConfigurationRequest(enum AlternativeRABConfigurationRequest* alternativeRABConfigurationRequest) {
free_object(alternativeRABConfigurationRequest, &ALTERNATIVERABCONFIGURATIONREQUEST_TYPE);
}
//
// function: MainWndHandler(HWND, unsigned, WORD, LONG)
//
// purpose: make initialisations (globals, Def-TTY settings)
// create Toolbox Dialog
//
// process Menu Selections
// load/save Config
// play/capture Archive
// open midi-device
// change com settings
// connect/disconnect to EEG-amp
// load/save Config
//
// scale and paint the channel-oscilloscope
//
//
//
LRESULT CALLBACK MainWndHandler(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
char sztemp[256];
switch( message )
{
case WM_CREATE:
break;
case WM_ENABLE:
if ((wParam==TRUE) && (NB_OBJ != NULL))
{
NB_OBJ->update_channelinfo();
NB_OBJ=NULL;
}
break;
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Menüauswahlen analysieren:
switch( wmId )
{
case IDM_NEWCONFIG:
stop_timer();
TTY.read_pause=1;
//BreakDownCommPort();
CAPTFILE.do_read=0;
close_captfile();
if (ghWndAnimation!=NULL) SendMessage(ghWndAnimation,WM_CLOSE,0,0);
ghWndAnimation=NULL;
close_toolbox();
write_logfile("new config: deleting all objects.");
while (GLOBAL.objects>0)
free_object(0);
deviceobject=NULL;
GLOBAL.showdesign=TRUE;
ShowWindow(ghWndDesign,TRUE);
SetWindowPos(ghWndDesign,HWND_TOP,0,0,0,0,SWP_DRAWFRAME|SWP_NOMOVE|SWP_NOSIZE);
SetDlgItemText(ghWndStatusbox,IDC_DESIGN,"Hide Design");
GLOBAL.hidestatus=FALSE;
ShowWindow(ghWndStatusbox,TRUE);
SetWindowText(ghWndMain,"BrainBay");
GLOBAL.configfile[0]=0;
init_system_time(); PACKET.readstate=0;
GLOBAL.session_length=0;
SetDlgItemText(ghWndStatusbox,IDC_STATUS,"ready.");
SetDlgItemInt(ghWndStatusbox,IDC_SAMPLINGRATE,PACKETSPERSECOND,0);
SetDlgItemText(ghWndStatusbox,IDC_STATUS,"Configuration loaded");
SetDlgItemText(ghWndStatusbox,IDC_TIME,"0.0");
SetDlgItemText(ghWndStatusbox,IDC_JUMPPOS,"0.0");
SetDlgItemText(ghWndStatusbox,IDC_SESSLEN,"0.0");
SendMessage(GetDlgItem(ghWndStatusbox,IDC_SESSIONPOS),TBM_SETPOS,TRUE,(LONG)0);
SendMessage(GetDlgItem(ghWndStatusbox,IDC_SESSIONPOS),TBM_SETSELEND,TRUE,(LONG)0);
SendMessage(GetDlgItem(ghWndStatusbox,IDC_SESSIONPOS),TBM_SETSELSTART,TRUE,(LONG)0);
InvalidateRect(ghWndDesign,NULL,TRUE);
InvalidateRect(ghWndMain,NULL,TRUE);
break;
case IDM_SAVECONFIG:
{
char configfilename[MAX_PATH];
int save_toolbox=GLOBAL.showtoolbox;
close_toolbox();
GLOBAL.showtoolbox=save_toolbox;
strcpy(configfilename,GLOBAL.resourcepath);
if (GLOBAL.configfile[0]==0)
strcat(configfilename,"CONFIGURATIONS\\*.con");
else strcpy(configfilename,GLOBAL.configfile);
if (open_file_dlg(hWnd,configfilename, FT_CONFIGURATION, OPEN_SAVE))
{
if (!save_configfile(configfilename)) report_error("Could not save Config File");
else
{
char * d_name,new_name[80];
write_logfile("configruation saved.");
d_name=configfilename;
while (strstr(d_name,"\\")) d_name=strstr(d_name,"\\")+1;
strcpy(new_name,"BrainBay - ");strcat(new_name,d_name);
SetWindowText(ghWndMain,new_name);
}
}
if (GLOBAL.showtoolbox!=-1)
{
actobject=objects[GLOBAL.showtoolbox];
actobject->make_dialog();
}
}
break;
case IDM_LOADCONFIG:
{
char configfilename[MAX_PATH];
close_toolbox();
strcpy(configfilename,GLOBAL.resourcepath);
strcat(configfilename,"CONFIGURATIONS\\*.con");
if (open_file_dlg(hWnd,configfilename, FT_CONFIGURATION, OPEN_LOAD))
{
write_logfile("load config: free existing objects.");
if (!load_configfile(configfilename)) report_error("Could not load Config File");
else sort_objects();
}
}
break;
case IDM_ABOUT:
close_toolbox();
DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)AboutDlgHandler);
break;
case IDM_HELP:
{
char tmpfile [250];
close_toolbox();
strcpy(tmpfile,GLOBAL.resourcepath);
strcat(tmpfile,"brainbay_user_manual.pdf");
ShellExecute(0, "open", tmpfile, NULL, NULL, SW_SHOWNORMAL);
}
break;
case IDM_VIEWLASTLOGFILE:
{
char tmpfile [250];
close_toolbox();
strcpy(tmpfile,GLOBAL.resourcepath);
strcat(tmpfile,"bbay.log");
ShellExecute(0, "open", tmpfile, NULL, NULL, SW_SHOWNORMAL);
}
break;
case IDM_EXIT:
DestroyWindow( hWnd );
break;
case IDM_PLAY:
SendMessage(ghWndStatusbox,WM_COMMAND, IDC_RUNSESSION,0);
break;
case IDM_STOP:
SendMessage(ghWndStatusbox,WM_COMMAND, IDC_STOPSESSION,0);
break;
case IDM_NEUROSERVER:
strcpy(sztemp,GLOBAL.resourcepath);
strcat(sztemp,"NETWORK\\nsd.exe");
ShellExecute(hWnd, "open", sztemp, NULL, NULL, SW_SHOWNORMAL);
break;
case IDM_READEDF:
{
char edffilename[MAX_PATH];
close_toolbox();
strcpy(edffilename,GLOBAL.resourcepath);
strcat(edffilename,"ARCHIVES\\*.edf");
if (open_file_dlg(hWnd,edffilename, FT_EDF, OPEN_LOAD))
{
strcpy(sztemp,GLOBAL.resourcepath);
strcat(sztemp,"NETWORK\\readedf.exe");
ShellExecute(hWnd, NULL, sztemp, edffilename, NULL, SW_SHOWNORMAL);
}
}
break;
case IDM_EDITCOLORS:
close_toolbox();
display_toolbox(CreateDialog(hInst, (LPCTSTR)IDD_EDITCOLORBOX, ghWndStatusbox, (DLGPROC)COLORDlgHandler));
break;
case IDM_EDITSCALES:
close_toolbox();
display_toolbox(CreateDialog(hInst, (LPCTSTR)IDD_EDITSCALEBOX, ghWndStatusbox, (DLGPROC)SCALEDlgHandler));
break;
case IDM_SETTINGS:
if (ghWndSettings==NULL) ghWndSettings=CreateDialog(hInst, (LPCTSTR)IDD_SETTINGSBOX, ghWndStatusbox, (DLGPROC)SETTINGSDlgHandler);
else SetForegroundWindow(ghWndSettings);
break;
case IDM_DEVICESETTINGS:
if (deviceobject)
{
close_toolbox();
actobject=deviceobject;
// GLOBAL.showtoolbox=find_object(devicebox);
actobject->make_dialog();
if (actobject->displayWnd)
SetWindowPos(actobject->displayWnd,HWND_TOP,0,0,0,0,SWP_DRAWFRAME|SWP_NOMOVE|SWP_NOSIZE);
} else report ("No Amplifier Device present in the design");
break;
case IDM_INSERTMIDI: create_object(OB_MIDI);
break;
case IDM_INSERTSPECTRUM: create_object(OB_FFT);
break;
case IDM_INSERTTHRESHOLD: create_object(OB_THRESHOLD);
break;
case IDM_INSERTFILTER: create_object(OB_FILTER);
break;
case IDM_INSERTMAGNITUDE:create_object(OB_MAGNITUDE);
break;
case IDM_INSERTPARTICLE:create_object(OB_PARTICLE);
break;
case IDM_INSERTOSCI:create_object(OB_OSCI);
break;
case IDM_INSERTTRANSLATE:create_object(OB_TRANSLATE);
break;
case IDM_INSERTSIGNAL:create_object(OB_SIGNAL);
break;
case IDM_INSERTAND:create_object(OB_AND);
break;
case IDM_INSERTOR:create_object(OB_OR);
break;
case IDM_INSERTNOT:create_object(OB_NOT);
break;
case IDM_INSERTWAV:
if (!count_objects(OB_WAV)) create_object(OB_WAV);
else report_error("Currently only one Sound player is supported.");
break;
case IDM_INSERTTCPRECEIVER:create_object(OB_TCP_RECEIVER);
break;
case IDM_INSERTDOKU:create_object(OB_DOKU);
break;
case IDM_INSERTEVAL:create_object(OB_EVAL);
break;
case IDM_INSERTAVI:create_object(OB_AVI);
break;
case IDM_INSERTAVERAGE:create_object(OB_AVERAGE);
break;
case IDM_INSERTCORR:create_object(OB_CORR);
break;
case IDM_INSERTEDFWRITER:create_object(OB_EDF_WRITER);
break;
case IDM_INSERTTCPSENDER:create_object(OB_TCP_SENDER);
break;
case IDM_INSERTEDFREADER:create_object(OB_EDF_READER);
break;
case IDM_INSERTCOMPARE:create_object(OB_COMPARE);
break;
case IDM_INSERTBALLGAME:create_object(OB_BALLGAME);
break;
case IDM_INSERTMIXER4:create_object(OB_MIXER4);
break;
case IDM_INSERTMOUSE:create_object(OB_MOUSE);
break;
case IDM_INSERTERPDETECT:create_object(OB_ERPDETECT);
break;
case IDM_INSERTCOM_WRITER:create_object(OB_COM_WRITER);
break;
case IDM_INSERTCAM:
if (!count_objects(OB_CAM)) create_object(OB_CAM);
break;
case IDM_INSERTINTEGRATE:create_object(OB_INTEGRATE);
break;
case IDM_INSERTDEBOUNCE:create_object(OB_DEBOUNCE);
break;
case IDM_INSERTSAMPLE_HOLD:create_object(OB_SAMPLE_HOLD);
break;
case IDM_INSERTCONSTANT:create_object(OB_CONSTANT);
break;
case IDM_INSERTMATLAB:create_object(OB_MATLAB);
break;
case IDM_INSERTCOUNTER:create_object(OB_COUNTER);
break;
case IDM_INSERTSKINDIALOG:
if (!count_objects(OB_SKINDIALOG)) create_object(OB_SKINDIALOG);
break;
case IDM_INSERTFILE_WRITER:create_object(OB_FILE_WRITER);
break;
case IDM_INSERTDEVIATION:create_object(OB_DEVIATION);
break;
case IDM_INSERTMCIPLAYER:create_object(OB_MCIPLAYER);
break;
case IDM_INSERTKEYSTRIKE:create_object(OB_KEYSTRIKE);
break;
case IDM_INSERTPEAKDETECT:create_object(OB_PEAKDETECT);
break;
case IDM_INSERTSPELLER:create_object(OB_SPELLER);
break;
case IDM_INSERTMARTINI:create_object(OB_MARTINI);
break;
case IDM_INSERTFILE_READER:create_object(OB_FILE_READER);
break;
case IDM_INSERTPORT_IO:create_object(OB_PORT_IO);
break;
case IDM_INSERTARRAY3600:create_object(OB_ARRAY3600);
break;
case IDM_INSERTCOMREADER:create_object(OB_COMREADER);
break;
case IDM_INSERTMIN:create_object(OB_MIN);
break;
case IDM_INSERTMAX:create_object(OB_MAX);
break;
case IDM_INSERTROUND:create_object(OB_ROUND);
break;
case IDM_INSERTDIFFERENTIATE:create_object(OB_DIFFERENTIATE);
break;
case IDM_INSERTDELAY:create_object(OB_DELAY);
break;
case IDM_INSERTLIMITER:create_object(OB_LIMITER);
break;
case IDM_INSERTFLOATVECTOR:
create_object(OB_FLOATVECTOR);
break;
case IDM_INSERTVECTORFLOAT:
create_object(OB_VECTORFLOAT);
break;
case IDM_INSERTDISPLAYVECTOR:
create_object(OB_DISPLAYVECTOR);
break;
case IDM_INSERTVECTORBUFFER:
create_object(OB_BUFFER);
break;
// here are th supported EED devices
case IDM_INSERT_EEG_GENERIC8:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_RAW8BIT; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_GENERIC16:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_RAW; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_IBVA:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_IBVA; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_NIA:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_NIA; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_P21:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_MONOLITHEEG_P21; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_OPENBCI8:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_OPENBCI8; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_P2:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_MODEEG_P2; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_P3:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_MODEEG_P3; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_PENDANT:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_PENDANT3; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_QDS:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_QDS; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_SBT4:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_SBT4; create_object(OB_EEG);}
break;
case IDM_INSERT_EEG_SBT2:
if (!count_objects(OB_EEG)) { TTY.devicetype=DEV_SBT2; create_object(OB_EEG);}
break;
// these devices need special care (seperate element)
case IDM_INSERTOPTIMA:
if ((!count_objects(OB_NEUROBIT)) && (!count_objects(OB_EEG))) create_object(OB_NEUROBIT);
break;
case IDM_INSERTEMOTIV:
if ((!count_objects(OB_EMOTIV)) && (!count_objects(OB_EEG))) create_object(OB_EMOTIV);
break;
case IDM_COPY:
if (actobject)
{
copy_object=actobject;
if ((copy_object->type!=OB_EEG)&&(copy_object->type!=OB_WAV)&&(copy_object->type!=OB_CAM)
&&(copy_object->type!=OB_SKINDIALOG)&&(copy_object->type!=OB_NEUROBIT))
{
HANDLE hFile;
char tmpfile[256];
create_object(copy_object->type);
strcpy(tmpfile,GLOBAL.resourcepath);
strcat(tmpfile,"tmp_copy.con");
hFile = CreateFile(tmpfile, GENERIC_WRITE, 0, NULL,CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(hFile != INVALID_HANDLE_VALUE)
{
copy_object->save(hFile);
save_property(hFile,"end Object",P_END,NULL);
CloseHandle(hFile);
}
hFile = CreateFile(tmpfile, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
if(hFile != INVALID_HANDLE_VALUE)
{
load_next_config_buffer(hFile);
actobject->load(hFile);
CloseHandle(hFile);
DeleteFile(tmpfile);
}
actobject->xPos+=10; actobject->yPos+=10;
}
close_toolbox();
}
break;
default:
return DefWindowProc( hWnd, message, wParam, lParam );
}
break;
case WM_ACTIVATE:
{
/* char t[50];
static int cn=0;
cn++;
sprintf(t,"%d:%d,%d",cn,HIWORD(lParam),LOWORD(lParam)); //==WA_CLICKACTIVE))
SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_ADDSTRING, 0, (LPARAM) t);
SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_SETCURSEL, SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_GETCOUNT, 0, 0)-1, 0);
UpdateWindow(ghWndStatusbox);
*/
if ((LOWORD(lParam)==WA_CLICKACTIVE) || (HIWORD(lParam)==WA_CLICKACTIVE))
SetWindowPos(ghWndMain,HWND_TOP,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
SetFocus(ghWndMain);
}
break;
case WM_ACTIVATEAPP:
{
/* char t[50];
static int cn=0;
cn++;
sprintf(t,"%d:%d,%d",cn,HIWORD(lParam),LOWORD(lParam)); //==WA_CLICKACTIVE))
SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_ADDSTRING, 0, (LPARAM) t);
SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_SETCURSEL, SendDlgItemMessage(ghWndStatusbox,IDC_LIST2, LB_GETCOUNT, 0, 0)-1, 0);
UpdateWindow(ghWndStatusbox); */
// if ((LOWORD(lParam)==1828) || (LOWORD(lParam)==964))
//SetWindowPos(ghWndMain,HWND_TOP,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
SetWindowPos(ghWndMain,0,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
// return DefWindowProc( hWnd, message, wParam, lParam );
}
break;
case WM_KEYDOWN:
if (lParam==KEY_DELETE )
SendMessage(ghWndDesign, message,wParam,lParam);
break;
case WM_SIZE:
if (wParam== SIZE_MAXIMIZED)
{
GLOBAL.main_maximized=lParam;
ShowWindow(ghWndStatusbox,TRUE);
GLOBAL.hidestatus=FALSE;
if (GLOBAL.session_length==0)
SetWindowPos(ghWndStatusbox, ghWndMain, 4, HIWORD(lParam)+15,
LOWORD(lParam)-8,HIWORD(lParam), 0);
else SetWindowPos(ghWndStatusbox, ghWndMain, 4, HIWORD(lParam)-20,
LOWORD(lParam)-8,HIWORD(lParam), 0);
}
else if (wParam== SIZE_RESTORED)
{
WINDOWPLACEMENT wndpl;
GetWindowPlacement(ghWndMain, &wndpl);
GLOBAL.top=wndpl.rcNormalPosition.top;
GLOBAL.left=wndpl.rcNormalPosition.left;
GLOBAL.right=wndpl.rcNormalPosition.right;
GLOBAL.bottom=wndpl.rcNormalPosition.bottom;
GLOBAL.main_maximized=0;
update_status_window();
}
else if (wParam== SIZE_MINIMIZED)
{
ShowWindow(ghWndStatusbox,FALSE);
GLOBAL.hidestatus=TRUE;
}
break;
case WM_MOVE:
{
WINDOWPLACEMENT wndpl;
GetWindowPlacement(ghWndMain, &wndpl);
GLOBAL.top=wndpl.rcNormalPosition.top;
GLOBAL.left=wndpl.rcNormalPosition.left;
GLOBAL.right=wndpl.rcNormalPosition.right;
GLOBAL.bottom=wndpl.rcNormalPosition.bottom;
update_status_window();
}
break;
//case WM_PAINT:
// break;
case WM_DESTROY:
actobject=0;
GlobalCleanup();
PostQuitMessage( 0 );
break;
case WM_INPUT:
if ((TTY.CONNECTED) && (!GLOBAL.loading))
ReadNIA( wParam, lParam); // NIA Daten vorhanden: auslesen
return(TRUE);
default:
return DefWindowProc( hWnd, message, wParam, lParam );
}
return 0;
}
void free_ENB_ID(struct ENB_ID* eNB_ID) {
free_object(eNB_ID, &ENB_ID_TYPE);
}
void free_ProvidedData(struct ProvidedData* providedData) {
free_object(providedData, &PROVIDEDDATA_TYPE);
}
void free_Alt_RAB_Parameter_MaxBitrateType(enum Alt_RAB_Parameter_MaxBitrateType* alt_RAB_Parameter_MaxBitrateType) {
free_object(alt_RAB_Parameter_MaxBitrateType, &ALT_RAB_PARAMETER_MAXBITRATETYPE_TYPE);
}
static void
major_free_non_pinned_object (char *obj, size_t size)
{
free_object (obj, size, FALSE);
}
bool FrTFIDF::load(const char *filename)
{
if (filename && *filename)
{
FrITextFile wt(filename) ;
if (!wt.good())
{
FrWarningVA("unable to open term weights file '%s'",filename) ;
return false ;
}
delete ht ;
ht = new FrSymHashTable ;
FrSymbol *symEOF = FrSymbolTable::add("*EOF*") ;
char *line = wt.getline() ;
bool expanded = false ;
if (line && strncmp(line,"!!! ",4) == 0)
{
char *end = 0 ;
total_docs = (size_t)strtol(line+4,&end,10) ;
if (end && end != line+4)
{
char *tmp = end ;
size_t vocab_size = (size_t)strtol(tmp,&end,10) ;
if (vocab_size > 0 && end && end != tmp)
{
ht->expand(vocab_size+100) ;
expanded = true ;
}
}
}
if (!expanded) // ensure some reasonable starting size
ht->expand(5000) ;
while ((line = wt.getline()) != 0)
{
if (FrSkipWhitespace(line) == ';' || *line == '\0')
continue ;
const char *origline = line ;
FrSymbol *term = (FrSymbol*)string_to_FrObject(line) ;
if (term == symEOF || !term || !term->symbolp())
{
FrWarning("invalid line in term-weights file") ;
free_object(term) ;
continue ;
}
char *end = 0 ;
size_t term_freq = strtol(line,&end,10) ;
if (end && end != line)
{
line = end ;
size_t doc_freq = strtol(line,&end,10) ;
if (end != line)
{
if (doc_freq > 0 && term_freq > 0)
{
FrSymHashEntry *entry = tfidfRecord(term) ;
FrTFIDFrecord *rec = new FrTFIDFrecord(term_freq,doc_freq) ;
if (entry)
{
delete (FrTFIDFrecord*)entry->getUserData() ;
entry->setUserData(rec) ;
}
else
ht->add(term,(void*)rec) ;
continue ;
}
FrWarning("invalid data in term-weights file -- both term\n"
"\tand document frequencies must be nonzero") ;
free_object(term) ;
continue ;
}
}
FrWarningVA("expected two integers following the term '%s'; line was\n"
"\t%s", term->symbolName(), origline) ;
free_object(term) ;
}
return true ;
}
return false ;
}
static void
PySfImage_dealloc(PySfImage* self)
{
delete self->obj;
free_object(self);
}
void free_Event(enum Event* event) {
free_object(event, &EVENT_TYPE);
}
void slab_free(struct kmem_cache *cache, void *object)
{
free_object(cache, object);
}
void free_object(pyc_object *object) {
if (!object)
return;
switch (object->type) {
case TYPE_SMALL_TUPLE:
case TYPE_TUPLE:
r_list_free (object->data);
break;
case TYPE_STRING:
case TYPE_TRUE:
case TYPE_FALSE:
case TYPE_INT:
case TYPE_NONE:
case TYPE_NULL:
case TYPE_ASCII_INTERNED:
case TYPE_SHORT_ASCII:
case TYPE_ASCII:
case TYPE_SHORT_ASCII_INTERNED:
free (object->data);
break;
case TYPE_CODE_v1:
{
pyc_code_object *cobj = object->data;
free_object (cobj->code);
free_object (cobj->consts);
free_object (cobj->names);
free_object (cobj->varnames);
free_object (cobj->freevars);
free_object (cobj->cellvars);
free_object (cobj->filename);
free_object (cobj->name);
free_object (cobj->lnotab);
free (object->data);
}
break;
case TYPE_REF:
free_object (object->data);
break;
case TYPE_ELLIPSIS:
case TYPE_STOPITER:
case TYPE_BINARY_COMPLEX:
case TYPE_BINARY_FLOAT:
case TYPE_CODE_v0:
case TYPE_COMPLEX:
case TYPE_STRINGREF:
case TYPE_DICT:
case TYPE_FLOAT:
case TYPE_FROZENSET:
case TYPE_INT64:
case TYPE_INTERNED:
case TYPE_LIST:
case TYPE_LONG:
case TYPE_SET:
case TYPE_UNICODE:
case TYPE_UNKNOWN:
eprintf ("Free not implemented for type %x\n", object->type);
return;
default:
eprintf ("Undefined type in free_object (%x)\n", object->type);
return;
}
free (object);
}
void image_dct(INT32 args)
{
rgbd_group *area,*val;
struct object *o;
struct image *img;
INT32 x,y,u,v;
double xsz2,ysz2,enh,xp,yp,dx,dy;
double *costbl;
rgb_group *pix;
CHECK_INIT();
get_all_args(NULL, args, "%d%d", &x, &y);
x = MAXIMUM(1, x);
y = MAXIMUM(1, y);
#ifdef DCT_DEBUG
fprintf(stderr,"%lu bytes, %lu bytes\n",
(unsigned long)(sizeof(rgbd_group)*THIS->xsize*THIS->ysize),
(unsigned long)(sizeof(rgb_group)*THIS->xsize*THIS->ysize+1));
#endif
area=xalloc(sizeof(rgbd_group)*THIS->xsize*THIS->ysize+1);
if (!(costbl=malloc(sizeof(double)*THIS->xsize+1)))
{
free(area);
out_of_memory_error(NULL, -1, 0);
}
o=clone_object(image_program,0);
img=(struct image*)(o->storage);
*img=*THIS;
img->xsize = x;
img->ysize = y;
if (!(img->img=malloc(sizeof(rgb_group)*
img->xsize*img->ysize+RGB_VEC_PAD)))
{
free(area);
free(costbl);
free_object(o);
out_of_memory_error(NULL, -1, 0);
}
xsz2=THIS->xsize*2.0;
ysz2=THIS->ysize*2.0;
enh=(8.0/THIS->xsize)*(8.0/THIS->ysize);
for (u=0; u<THIS->xsize; u++)
{
double d,z0;
rgbd_group sum;
for (v=0; v<THIS->ysize; v++)
{
d=(u?1:c0)*(v?1:c0)/4.0;
sum.r=sum.g=sum.b=0;
pix=THIS->img;
for (x=0; x<THIS->xsize; x++)
costbl[x]=cos( (2*x+1)*u*pi/xsz2 );
for (y=0; y<THIS->ysize; y++)
{
z0=cos( (2*y+1)*v*pi/ysz2 );
for (x=0; x<THIS->xsize; x++)
{
double z;
z = costbl[x] * z0;
sum.r += (float)(pix->r*z);
sum.g += (float)(pix->g*z);
sum.b += (float)(pix->b*z);
pix++;
}
}
sum.r *= (float)d;
sum.g *= (float)d;
sum.b *= (float)d;
area[u+v*THIS->xsize]=sum;
}
#ifdef DCT_DEBUG
fprintf(stderr,"."); fflush(stderr);
#endif
}
#ifdef DCT_DEBUG
fprintf(stderr,"\n");
#endif
dx=((double)(THIS->xsize-1))/(img->xsize);
dy=((double)(THIS->ysize-1))/(img->ysize);
pix=img->img;
for (y=0,yp=0; y<img->ysize; y++,yp+=dy)
{
double z0;
rgbd_group sum;
for (x=0,xp=0; x<img->xsize; x++,xp+=dx)
{
sum.r=sum.g=sum.b=0;
val=area;
for (u=0; u<THIS->xsize; u++)
costbl[u]=cos( (2*xp+1)*u*pi/xsz2 );
for (v=0; v<THIS->ysize; v++)
{
z0=cos( (2*yp+1)*v*pi/ysz2 )*(v?1:c0)/4.0;
for (u=0; u<THIS->xsize; u++)
{
double z;
z = (u?1:c0) * costbl[u] * z0;
sum.r += (float)(val->r*z);
sum.g += (float)(val->g*z);
sum.b += (float)(val->b*z);
val++;
}
}
sum.r *= (float)enh;
sum.g *= (float)enh;
sum.b *= (float)enh;
pix->r=testrange((int)(sum.r+0.5));
pix->g=testrange((int)(sum.g+0.5));
pix->b=testrange((int)(sum.b+0.5));
pix++;
}
#ifdef DCT_DEBUG
fprintf(stderr,"."); fflush(stderr);
#endif
}
free(area);
free(costbl);
pop_n_elems(args);
push_object(o);
}
void free_NonSearchingIndication(enum NonSearchingIndication* nonSearchingIndication) {
free_object(nonSearchingIndication, &NONSEARCHINGINDICATION_TYPE);
}
