119 lines
3.5 KiB
C
119 lines
3.5 KiB
C
#include <stdlib.h>
|
|
#include <inttypes.h>
|
|
#include <string.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <cairo.h>
|
|
#include <jpeglib.h>
|
|
|
|
#include "jpg.h"
|
|
|
|
/*
|
|
* Checks if the file is a JPEG by looking for a valid JPEG header.
|
|
*/
|
|
bool file_is_jpg(char* file_path) {
|
|
if (!file_path) return false;
|
|
FILE* image_file;
|
|
uint16_t file_header;
|
|
size_t read_count;
|
|
// TODO: Consider endianess on non-x86 platforms
|
|
uint16_t jpg_magick = 0xd8ff;
|
|
|
|
image_file = fopen(file_path, "rb");
|
|
if (image_file == NULL) {
|
|
int img_err = errno;
|
|
fprintf(stderr, "Could not open image file %s: %s\n",
|
|
file_path, strerror(img_err));
|
|
return false;
|
|
}
|
|
|
|
read_count = fread(&file_header, sizeof(file_header), 1, image_file);
|
|
fclose(image_file);
|
|
|
|
if (read_count < 1) {
|
|
fprintf(stderr, "Error searching for JPEG header in %s\n", file_path);
|
|
return false;
|
|
}
|
|
|
|
return file_header == jpg_magick;
|
|
}
|
|
|
|
/*
|
|
* Reads a JPEG from a file into memory, in a format that Cairo can create a
|
|
* surface from.
|
|
*/
|
|
void* read_JPEG_file(char *file_path, JPEG_INFO *jpg_info) {
|
|
int img_err;
|
|
struct jpeg_decompress_struct cinfo;
|
|
struct jpeg_error_mgr jerr;
|
|
FILE *infile; /* source file */
|
|
void *img; /* decompressed image data pointer */
|
|
|
|
if ((infile = fopen(file_path, "rb")) == NULL) {
|
|
img_err = errno;
|
|
fprintf(stderr, "Could not open image file %s: %s\n",
|
|
file_path, strerror(img_err));
|
|
return NULL;
|
|
}
|
|
|
|
cinfo.err = jpeg_std_error(&jerr);
|
|
jpeg_create_decompress(&cinfo);
|
|
|
|
jpeg_stdio_src(&cinfo, infile);
|
|
|
|
(void) jpeg_read_header(&cinfo, TRUE);
|
|
|
|
// BGRA + endianness change = RGBA?
|
|
// TODO: Test this code on non-x86_64 platforms
|
|
cinfo.out_color_space = JCS_EXT_BGRA;
|
|
|
|
(void) jpeg_start_decompress(&cinfo);
|
|
|
|
jpg_info->height = cinfo.output_height;
|
|
jpg_info->width = cinfo.output_width;
|
|
|
|
/* Get the *cairo* stride rather than the stride from the image. This is
|
|
* the space needed in memory for each row for optimized Cairo rendering. */
|
|
int cairo_stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32,
|
|
cinfo.output_width);
|
|
jpg_info->stride = cairo_stride;
|
|
if (cairo_stride < jpg_info->width) {
|
|
/* This should never happen, but if it does then the following code
|
|
* will potentially write into unallocated memory */
|
|
fprintf(
|
|
stderr,
|
|
"WARNING: Cairo stride shorter than JPEG width. Aborting JPEG read."
|
|
);
|
|
return NULL;
|
|
}
|
|
|
|
// Allocate storage for the final, decompressed image.
|
|
img = calloc(cairo_stride, cinfo.output_height);
|
|
if (img == NULL) {
|
|
fprintf(stderr, "Could not allocate memory for JPEG decode\n");
|
|
|
|
(void) jpeg_finish_decompress(&cinfo);
|
|
jpeg_destroy_decompress(&cinfo);
|
|
fclose(infile);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
while (cinfo.output_scanline < cinfo.output_height) {
|
|
/* Normally, you would allocate a buffer using libJPEG's memory
|
|
* management and write into it, but since we're reading one row at a
|
|
* time, we just write it directly into the image memory space */
|
|
unsigned char* pos = img + (cairo_stride * (cinfo.output_scanline));
|
|
(void) jpeg_read_scanlines(&cinfo, &pos, 1);
|
|
}
|
|
|
|
(void) jpeg_finish_decompress(&cinfo);
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
|
fclose(infile);
|
|
|
|
return img;
|
|
}
|