static int
initialize (struct filter *f, struct initdata *i)
{
struct subdata *s = (struct subdata *) f->data;
int x;
int val = 0;
pixel_t **lines1, **lines2 = NULL;
double size;
int width, height;
int threed = 0;
struct filter *f1 = f;
inhermisc (f, i);
if (datalost (f, i))
s->recal = 1;
while (f1)
{
if (f1->action == &threed_filter)
threed = 1;
f1 = f1->next;
}
f->imageversion = i->image->version;
if (f->childimage != NULL)
destroy_image (f->childimage);
s->image = f->image = i->image;
s->image->flags |= PROTECTBUFFERS;
s->currlines = f->image->currlines;
s->forpversion = f->image->palette->version;
s->forversion = f->fractalc->version;
if (f->image->width * f->image->pixelwidth <
f->image->height * f->image->pixelheight)
size = f->image->width * f->image->pixelwidth / 2;
else
size = f->image->height * f->image->pixelheight / 2;
width = (int) (size / f->image->pixelwidth);
height = (int) (size / f->image->pixelheight);
/*fractalc_resize_to(f->fractalc,size,size); */
lines1 = (pixel_t **) malloc (sizeof (*lines1) * height);
if (f->image->nimages == 2)
lines2 = (pixel_t **) malloc (sizeof (*lines2) * height);
if (lines1 == NULL)
return 0;
if (f->image->nimages == 2 && lines2 == NULL)
{
free (lines1);
return 0;
}
for (x = 0; x < height; x++)
{
lines1[x] =
i->image->currlines[x + (threed ? f->image->height / 3 : 0)];
if (f->image->nimages == 2)
lines2[x] =
i->image->oldlines[x + (threed ? f->image->height / 3 : 0)];
}
if (f->image->nimages == 2)
for (x = 0; x < f->image->height; x++)
{
memcpy (f->image->oldlines[x], f->image->currlines[x],
f->image->width * f->image->bytesperpixel);
}
f->childimage = i->image =
create_image_lines (width, height, f->image->nimages, lines1, lines2,
i->image->palette, myflip, FREELINES,
f->image->pixelwidth, f->image->pixelheight);
if (i->image == NULL)
{
free (lines1);
free (lines2);
return 0;
}
f->childimage->data = s;
x = f->previous->action->initialize (f->previous, i);
if (!x)
return 0;
if (s->second != NULL)
{
i->image = f->image;
val = s->second->action->initialize (s->second, i);
if (!val)
return 0;
}
return (x | val);
}
/* An function helping to filter create new image.
* It should be called by filter in inicialization. Filter passes
* width,height,pixelwidth, pixelheight
* and palette he wants to pass to his child and flags defining how it works
* with image(IMAGEDATA if it requires data from previous frames (like blur
* filter, TOUCHIMAGE if it changes data in image(like blur or stereogram
* filter but unlike interlace and NEWIMAGE if it strictly requires to create
* new image)
* As palette he should pass NULL to keep parents palette. Same as
* (pixel)width/height should be passed 0;
*
* Function then aplies some heruistic in order to minimize memory
* requirements. So it should share image, create image that shares image data
* or create new image)
*
* fills f->image, f->childimage and returns 1 if sucess and 0 if fail(usually
* out of memory or it is unable to fit child's requirements)
* and prepares data for child call.
*/
int
inherimage(struct filter *f, struct initdata *data, int flags, int width,
int height, struct palette *palette, float pixelwidth,
float pixelheight)
{
int newimage = 0;
int subimage = 1;
int sharedimage = 1;
struct image *i;
int ddatalost = 0;
if (width == 0)
width = data->image->width;
if (height == 0)
height = data->image->height;
#ifdef DEBUG
printf("Inherimage:%s %i %i imagedata:%i %i\n", f->name, width, height,
flags & IMAGEDATA, flags & PROTECTBUFFERS);
#endif
if (pixelwidth == 0)
pixelwidth = data->image->pixelwidth;
if (pixelheight == 0)
pixelheight = data->image->pixelheight;
if (palette == NULL)
palette = data->image->palette;
if (!(palette->type & f->req.supportedmask)) {
#ifdef DEBUG
printf
("Initalization of filter %s failed due to unsupported type by child %s-%i,%i\n",
f->name, f->previous->name, f->req.supportedmask,
palette->type);
#endif
f->image = data->image;
return 0;
}
if (flags & NEWIMAGE)
newimage = 1, sharedimage = 0, subimage = 0;
if ((flags & IMAGEDATA) /*|| (data->image->flags & PROTECTBUFFERS) */ )
subimage = 0, sharedimage = 0, newimage = 1;
/*if filter touches data but child requires them, create separated image */
if ((flags & TOUCHIMAGE)
&& ((f->req.flags & IMAGEDATA)
|| (data->image->flags & PROTECTBUFFERS)))
subimage = 0, newimage = 1, sharedimage = 0;
/*if required image differs in size or so */
if (width != data->image->width || height != data->image->height ||
palette != data->image->palette)
newimage = 1, sharedimage = 0;
if (f->childimage != NULL && (f->flags & ALLOCEDIMAGE)) {
/*is an old child image still useable for us purposes? if not burn it it! */
/*We should share image? Why alloc new?? */
if (!newimage && (f->flags & ALLOCEDIMAGE))
destroyinheredimage(f), ddatalost = 1;
/*We should share data? but child image dont do that! */
if (subimage && !(f->flags & SHAREDDATA))
destroyinheredimage(f), ddatalost = 1;
/*We can't share data but child image does that? */
if (!subimage && (f->flags & SHAREDDATA))
destroyinheredimage(f), ddatalost = 1;
/*When image changed, child image must be recreated too */
if (f->flags & SHAREDDATA && ((data->flags & DATALOST)
|| f->imageversion !=
data->image->version))
destroyinheredimage(f), ddatalost = 1;
/*We should share image with filter? Why keep created new one? */
if (sharedimage)
destroyinheredimage(f), ddatalost = 1;
/*When child image don't fit out needs */
if (f->childimage != NULL
&& (f->childimage->width != width
|| f->childimage->height != height
|| f->childimage->palette != palette
|| f->childimage->bytesperpixel !=
bytesperpixel(palette->type)
|| f->childimage->nimages < f->req.nimages))
destroyinheredimage(f), ddatalost = 1;
/*Well now child image seems to be heavily probed */
}
i = f->childimage;
if (newimage) { /*Create new image when required */
if (!(f->flags & ALLOCEDIMAGE)) {
if (subimage) {
i = create_subimage(data->image, width, height,
f->req.nimages, palette, pixelwidth,
pixelheight);
f->flags |= ALLOCEDIMAGE | SHAREDDATA;
ddatalost = 1;
} else {
i = create_image_mem(width, height, f->req.nimages,
palette, pixelwidth, pixelheight);
f->flags |= ALLOCEDIMAGE;
ddatalost = 1;
}
}
}
#ifdef DEBUG
printf("Filter:%s newimage:%i subimage:%i sharedimage:%i\n", f->name,
newimage, subimage, sharedimage);
#endif
if (i == NULL) {
f->image = data->image;
return 0;
}
if (sharedimage)
i = data->image, ddatalost = (data->flags & DATALOST)
|| (f->childimage != data->image);
if (sharedimage && datalost(f, data))
ddatalost = 1;
else if ((f->flags | SHAREDDATA) && datalost(f, data)
&& !(i->flags & FREEDATA))
ddatalost = 1;
if (ddatalost)
data->flags |= DATALOST;
else
data->flags &= ~DATALOST;
f->image = data->image;
f->childimage = i;
f->imageversion = data->image->version;
data->image = i;
#ifdef DEBUG
printf("OK %i datalost:%i\n", f->flags, ddatalost);
#endif
#ifdef DEBUG
printf("Inherimage2:%s %i %i\n", f->name, width, height);
#endif
return 1;
}
