/* * 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; }