/*
* Triggers logging functions to be tested, which are
* given due to logf.h and macro.h
*/
int
main(int argc, char **argv)
{
/*
logf_register(&logf_file_write, stdout);
logf_register(&logf_file_write, stderr);
logf_register(&logf_file_write, fopen("log.cmld", "a"));
logf_register(&logf_file_write, logf_file_new("log.cmld"));
logf_register(&logf_syslog_write, logf_syslog_new("trustme-cmld"));
logf_register(&logf_android_write, logf_android_new("trustme-cmld"));
logf_register(&logf_klog_write, logf_klog_new("trustme-cmld"));
logf_debug("debug test");
logf_info("info test");
logf_warn("warn test");
logf_error("error test");
logf_debug_errno("debug errno test");
errno = 1;
logf_info_errno("info errno test");
errno = 2;
logf_warn_errno("warn errno test");
errno = 3;
logf_error_errno("error errno test");
return 0;
*/
logf_register(&logf_test_write, stdout);
DEBUG("Unit Test: logf.test.c");
DEBUG("Test logf_register and logD");
logf_register(&logf_test_write, stderr);
DEBUG("Test logf_debug");
logf_debug("debug test");
DEBUG("Test logf_info");
logf_info("info test");
DEBUG("Test logf_warn");
logf_warn("warn test");
DEBUG("Test logf_error");
logf_error("error test");
DEBUG("Test logf_debug_errno");
logf_debug_errno("debug errno test");
errno = 1;
DEBUG("Test logf_info_errno");
logf_info_errno("info errno test");
errno = 2;
DEBUG("Test logf_warn_errno");
logf_warn_errno("warn errno test");
errno = 3;
DEBUG("Test logf_error_errno");
logf_error_errno("error errno test");
return 0;
}
result_t motionmaskplayer_load(motionmaskplayer_t *player,
const char *filename)
{
result_t err;
FILE *f = NULL;
stream_t *s = NULL;
uint32_t signature;
frame_t *frames = NULL;
int start;
int i;
int totalheights;
mmoffset_t *offsets = NULL;
mmdata_t *data = NULL;
int dataused;
int dataallocated;
if (player->flags & player_FLAGS_LOADED)
{
free(player->frames);
free(player->offsets);
free(player->data);
player->flags &= ~player_FLAGS_LOADED;
}
f = fopen(filename, "rb");
if (f == NULL)
{
err = result_FILE_NOT_FOUND;
goto failure;
}
err = stream_stdio_create(f, 1024, &s);
if (err)
goto failure;
f = NULL; /* 'f' is now owned by the stream code */
/* read file header */
err = unpackfromstream(s,
format_HEADER_SIZE,
"<i2hii",
&signature,
&player->width,
&player->height,
&player->nframes);
if (err)
goto failure;
if (signature != format_ID)
{
logf_fatal("header has bad signature");
err = result_MMPLAYER_BAD_SIGNATURE;
goto failure;
}
logf_info("header: width x height = %d x %d, nframes = %d",
player->width,
player->height,
player->nframes);
if (player->width <= 0 || player->height <= 0 || player->nframes <= 0)
{
logf_fatal("header has invalid dimensions");
err = result_MMPLAYER_INVALID_DIMENSIONS;
goto failure;
}
/* read frames */
frames = malloc(player->nframes * sizeof(*frames));
if (frames == NULL)
goto oom;
start = 0;
for (i = 0; i < player->nframes; i++)
{
frame_t *frame = &frames[i];
err = unpackfromstream(s,
format_FRAME_SIZE,
"<4hiC",
&frame->width,
&frame->height,
&frame->x,
&frame->y,
&frame->source);
if (err)
goto failure;
logf_info("frame %d: width x height = %d x %d, x,y = %d,%d, source = %x",
i,
frame->width,
frame->height,
frame->x,
frame->y,
frame->source);
if (frame->width <= 0 || frame->height <= 0)
{
err = result_MMPLAYER_INVALID_FRAME_DIMENSIONS;
goto failure;
}
// FIXME: Expand checks for x,y and source fields.
frame->start = start;
start += player->height;
}
totalheights = start;
/* unpack offsets. we'll need to work over them again later. */
offsets = malloc(totalheights * sizeof(*offsets));
if (offsets == NULL)
goto oom;
{
int consumedoffsets;
for (i = 0; i < totalheights; i += consumedoffsets)
{
stream_size_t availablebytes;
stream_size_t availableoffsets;
int32_t maxavailableoffsets;
availablebytes = stream_remaining_need_and_fill(s, 2);
if (availablebytes == stream_EOF || availablebytes < 2)
{
err = result_MMPLAYER_TRUNCATED_INPUT;
goto failure;
}
availableoffsets = availablebytes / 2;
/* read up to the limit of the size of data we're anticipating */
maxavailableoffsets = availableoffsets > INT32_MAX ?
INT32_MAX : (int32_t) availableoffsets;
consumedoffsets = MIN(totalheights - i, maxavailableoffsets);
if (consumedoffsets < 1)
{
err = result_MMPLAYER_TRUNCATED_INPUT;
goto failure;
}
s->buf += unpack(s->buf, "<*hP", consumedoffsets, offsets + i);
}
}
/* read data chunk */
data = NULL;
dataused = 0;
dataallocated = 0;
for (;;)
{
stream_size_t remaining; // stream returns a ptrdiff_t actually
remaining = stream_remaining_and_fill(s);
if (remaining == stream_EOF)
break; /* EOF (we assume) */
if (array_grow((void **) &data,
sizeof(*data),
dataused,
&dataallocated,
(int) remaining,
1))
goto oom;
memcpy(data + dataused, s->buf, remaining);
dataused += remaining;
s->buf += remaining;
}
if (data == NULL)
{
err = result_MMPLAYER_TRUNCATED_INPUT;
goto failure;
}
if (array_shrink((void **) &data,
sizeof(*data),
dataused,
&dataallocated))
goto oom;
/* fix up offsets table now we know where 'data' lives */
for (i = 0; i < totalheights; i++)
{
mmoffset_t o;
o = offsets[i];
/* verify the offsets (since a truncated data chunk cannot be detected
* earlier on) */
if ((intptr_t) o >= dataused)
{
logf_fatal("offset %d out of range\n", i);
err = result_MMPLAYER_BAD_OFFSET;
goto failure;
}
offsets[i] = data + (ptrdiff_t) o;
}
stream_destroy(s);
player->frames = frames;
player->offsets = offsets;
player->data = data;
player->ndata = dataused;
player->flags |= player_FLAGS_LOADED;
return result_OK;
oom:
err = result_OOM;
failure:
if (f)
fclose(f);
stream_destroy(s);
free(frames);
free(offsets);
free(data);
return err;
}
result_t read_png_file(pngloader_t *png,
const char *file_name,
int verbosity)
{
result_t err = result_OK;
FILE *fp;
png_byte header[8]; /* 8 is the maximum size that can be checked */
int y;
/* open file and test for it being a png */
fp = fopen(file_name, "rb");
if (!fp)
haltf("[read_png_file] File %s could not be opened for reading",
file_name);
fread(header, 1, 8, fp);
if (png_sig_cmp(header, 0, 8))
haltf("[read_png_file] File %s is not recognized as a PNG file",
file_name);
/* initialize stuff */
png->png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING,
NULL, NULL, NULL);
if (!png->png_ptr)
haltf("[read_png_file] png_create_read_struct failed");
png->info_ptr = png_create_info_struct(png->png_ptr);
if (!png->info_ptr)
haltf("[read_png_file] png_create_info_struct failed");
if (setjmp(png_jmpbuf(png->png_ptr)))
haltf("[read_png_file] Error during init_io");
png_init_io(png->png_ptr, fp);
png_set_sig_bytes(png->png_ptr, 8);
png_read_info(png->png_ptr, png->info_ptr);
/* not using png_get_IHDR due to type differences */
png->width = png_get_image_width(png->png_ptr, png->info_ptr);
png->height = png_get_image_height(png->png_ptr,png->info_ptr);
png->color_type = png_get_color_type(png->png_ptr, png->info_ptr);
png->bit_depth = png_get_bit_depth(png->png_ptr, png->info_ptr);
if (verbosity > 0)
logf_info("%d x %d, depth %d, color_type %d",
png->width,
png->height,
png->bit_depth,
png->color_type);
png->number_of_passes = png_set_interlace_handling(png->png_ptr);
png_read_update_info(png->png_ptr, png->info_ptr);
/* read file */
if (setjmp(png_jmpbuf(png->png_ptr)))
haltf("[read_png_file] Error during read_image");
png->rowbytes = png_get_rowbytes(png->png_ptr, png->info_ptr);
if (verbosity > 0)
logf_info("rowbytes=%zu", png->rowbytes);
png->row_pointers = malloc(sizeof(png_bytep) * png->height);
png->bitmap = malloc(png->rowbytes * png->height);
if (png->row_pointers == NULL || png->bitmap == NULL)
{
free(png->row_pointers);
free(png->bitmap);
err = result_OOM;
goto exit;
}
for (y = 0; y < png->height; y++)
png->row_pointers[y] = png->bitmap + y * png->rowbytes;
png_read_image(png->png_ptr, png->row_pointers);
fclose(fp);
exit:
return err;
}
result_t MMMaker_make(const char **sourceMaskDirs,
int nSourceMaskDirs,
const char *filename)
{
#define MAX_FILENAMES 500
result_t err;
char **sourceMaskFilenames;
int nSourceMaskFilenames = 0;
char *sourceMaskFilenamesBuffer = NULL;
motionmaskmaker_t *maker = NULL;
int i;
CGImageRef makerSource[MAX_FILENAMES];
CGBitmapInfo bitmapInfo;
pixelfmt_t pixelfmt;
bitmap_set_t makerBitmaps;
CFDataRef pixels[MAX_FILENAMES];
void *makerBitmapBases[MAX_FILENAMES];
err = findfilesbyregexp(sourceMaskDirs,
nSourceMaskDirs,
".*\\.png",
&sourceMaskFilenames,
&nSourceMaskFilenames,
&sourceMaskFilenamesBuffer);
if (err)
goto failure;
if (nSourceMaskFilenames <= 0 || nSourceMaskFilenames > MAX_FILENAMES)
{
err = result_TOO_BIG;
goto failure;
}
for (i = 0; i < nSourceMaskFilenames; i++)
pixels[i] = NULL;
err = motionmaskmaker_create(&maker);
if (err)
goto failure;
for (i = 0; i < nSourceMaskFilenames; i++)
{
logf_info("sourcing mask %d from %s", i, sourceMaskFilenames[i]);
makerSource[i] = createCGImageFromPNGFile(sourceMaskFilenames[i]);
bitmapInfo = CGImageGetBitmapInfo(makerSource[i]);
pixelfmt = bitmapInfoToPixelfmt(bitmapInfo);
if (pixelfmt == pixelfmt_unknown)
{
logf_error("MMMaker_make: Unknown pixelfmt.");
return result_BAD_ARG;
}
// bodge pixelfmt to be something we can currently cope with
if (pixelfmt == pixelfmt_rgba8888)
pixelfmt = pixelfmt_rgbx8888;
if (pixelfmt == pixelfmt_abgr8888)
pixelfmt = pixelfmt_xbgr8888;
// turn the image into greyscale if it's anything else
if (pixelfmt != pixelfmt_y8)
{
CGImageRef greyCopy;
greyCopy = BitmapTransform_createGreyscaleCopy(makerSource[i]);
CGImageRelease(makerSource[i]);
makerSource[i] = greyCopy;
bitmapInfo = CGImageGetBitmapInfo(makerSource[i]);
pixelfmt = bitmapInfoToPixelfmt(bitmapInfo);
if (pixelfmt == pixelfmt_unknown)
return result_BAD_ARG;
}
pixels[i] = copyImagePixels(makerSource[i]);
if (pixels[i] == NULL)
goto failure;
makerBitmapBases[i] = (void *) CFDataGetBytePtr(pixels[i]);
}
makerBitmaps.width = (int) CGImageGetWidth(makerSource[0]);
makerBitmaps.height = (int) CGImageGetHeight(makerSource[0]);
makerBitmaps.format = pixelfmt;
makerBitmaps.rowbytes = (int) CGImageGetBytesPerRow(makerSource[0]);
makerBitmaps.nbases = nSourceMaskFilenames;
makerBitmaps.bases = makerBitmapBases;
err = motionmaskmaker_pack(maker, &makerBitmaps);
if (err)
goto failure;
err = motionmaskmaker_save(maker, filename);
if (err)
goto failure;
/* cleanup */
failure:
for (i = 0; i < nSourceMaskFilenames; i++)
if (pixels[i])
CFRelease(pixels[i]);
motionmaskmaker_destroy(maker);
maker = NULL;
free(sourceMaskFilenamesBuffer);
free(sourceMaskFilenames);
return err;
}
