=================================================================
*/
-// jboolean is qbyte instead of int on Win32
+// jboolean is unsigned char instead of int on Win32
#ifdef WIN32
-typedef qbyte jboolean;
+typedef unsigned char jboolean;
#else
typedef int jboolean;
#endif
struct jpeg_source_mgr
{
- const qbyte *next_input_byte;
+ const unsigned char *next_input_byte;
size_t bytes_in_buffer;
void (*init_source) (j_decompress_ptr cinfo);
void *comp_info;
jboolean progressive_mode;
jboolean arith_code;
- qbyte arith_dc_L[NUM_ARITH_TBLS];
- qbyte arith_dc_U[NUM_ARITH_TBLS];
- qbyte arith_ac_K[NUM_ARITH_TBLS];
+ unsigned char arith_dc_L[NUM_ARITH_TBLS];
+ unsigned char arith_dc_U[NUM_ARITH_TBLS];
+ unsigned char arith_ac_K[NUM_ARITH_TBLS];
unsigned int restart_interval;
jboolean saw_JFIF_marker;
- qbyte JFIF_major_version;
- qbyte JFIF_minor_version;
- qbyte density_unit;
+ unsigned char JFIF_major_version;
+ unsigned char JFIF_minor_version;
+ unsigned char density_unit;
unsigned short X_density;
unsigned short Y_density;
jboolean saw_Adobe_marker;
- qbyte Adobe_transform;
+ unsigned char Adobe_transform;
jboolean CCIR601_sampling;
void *marker_list;
int max_h_samp_factor;
void *quant_tbl_ptrs[NUM_QUANT_TBLS];
void *dc_huff_tbl_ptrs[NUM_HUFF_TBLS];
void *ac_huff_tbl_ptrs[NUM_HUFF_TBLS];
- qbyte arith_dc_L[NUM_ARITH_TBLS];
- qbyte arith_dc_U[NUM_ARITH_TBLS];
- qbyte arith_ac_K[NUM_ARITH_TBLS];
+ unsigned char arith_dc_L[NUM_ARITH_TBLS];
+ unsigned char arith_dc_U[NUM_ARITH_TBLS];
+ unsigned char arith_ac_K[NUM_ARITH_TBLS];
int num_scans;
const void *scan_info;
int restart_in_rows;
jboolean write_JFIF_header;
- qbyte JFIF_major_version;
- qbyte JFIF_minor_version;
- qbyte density_unit;
+ unsigned char JFIF_major_version;
+ unsigned char JFIF_minor_version;
+ unsigned char density_unit;
unsigned short X_density;
unsigned short Y_density;
jboolean write_Adobe_marker;
struct jpeg_destination_mgr
{
- qbyte* next_output_byte;
+ unsigned char* next_output_byte;
size_t free_in_buffer;
void (*init_destination) (j_compress_ptr cinfo);
static jboolean (*qjpeg_finish_decompress) (j_decompress_ptr cinfo);
static jboolean (*qjpeg_resync_to_restart) (j_decompress_ptr cinfo, int desired);
static int (*qjpeg_read_header) (j_decompress_ptr cinfo, jboolean require_image);
-static JDIMENSION (*qjpeg_read_scanlines) (j_decompress_ptr cinfo, qbyte** scanlines, JDIMENSION max_lines);
+static JDIMENSION (*qjpeg_read_scanlines) (j_decompress_ptr cinfo, unsigned char** scanlines, JDIMENSION max_lines);
static void (*qjpeg_set_defaults) (j_compress_ptr cinfo);
static void (*qjpeg_set_quality) (j_compress_ptr cinfo, int quality, jboolean force_baseline);
static jboolean (*qjpeg_start_compress) (j_compress_ptr cinfo, jboolean write_all_tables);
static jboolean (*qjpeg_start_decompress) (j_decompress_ptr cinfo);
static struct jpeg_error_mgr* (*qjpeg_std_error) (struct jpeg_error_mgr *err);
-static JDIMENSION (*qjpeg_write_scanlines) (j_compress_ptr cinfo, qbyte** scanlines, JDIMENSION num_lines);
+static JDIMENSION (*qjpeg_write_scanlines) (j_compress_ptr cinfo, unsigned char** scanlines, JDIMENSION num_lines);
static dllfunction_t jpegfuncs[] =
{
// Handle for JPEG DLL
dllhandle_t jpeg_dll = NULL;
-static qbyte jpeg_eoi_marker [2] = {0xFF, JPEG_EOI};
+static unsigned char jpeg_eoi_marker [2] = {0xFF, JPEG_EOI};
static qboolean error_in_jpeg;
// Our own output manager for JPEG compression
struct jpeg_destination_mgr pub;
qfile_t* outfile;
- qbyte* buffer;
+ unsigned char* buffer;
} my_destination_mgr;
typedef my_destination_mgr* my_dest_ptr;
cinfo->src->bytes_in_buffer -= num_bytes;
}
-static void JPEG_MemSrc (j_decompress_ptr cinfo, const qbyte *buffer)
+static void JPEG_MemSrc (j_decompress_ptr cinfo, const unsigned char *buffer, size_t filesize)
{
- cinfo->src = cinfo->mem->alloc_small ((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof (struct jpeg_source_mgr));
+ cinfo->src = (struct jpeg_source_mgr *)cinfo->mem->alloc_small ((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof (struct jpeg_source_mgr));
cinfo->src->next_input_byte = buffer;
- cinfo->src->bytes_in_buffer = fs_filesize;
+ cinfo->src->bytes_in_buffer = filesize;
cinfo->src->init_source = JPEG_Noop;
cinfo->src->fill_input_buffer = JPEG_FillInputBuffer;
====================
JPEG_LoadImage
-Load a JPEG image into a RGBA buffer
+Load a JPEG image into a BGRA buffer
====================
*/
-qbyte* JPEG_LoadImage (const qbyte *f, int matchwidth, int matchheight)
+unsigned char* JPEG_LoadImage_BGRA (const unsigned char *f, int filesize)
{
struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr;
- qbyte *image_rgba, *scanline;
+ unsigned char *image_buffer, *scanline;
unsigned int line;
// No DLL = no JPEGs
cinfo.err = qjpeg_std_error (&jerr);
qjpeg_create_decompress (&cinfo);
- JPEG_MemSrc (&cinfo, f);
+ JPEG_MemSrc (&cinfo, f, filesize);
qjpeg_read_header (&cinfo, TRUE);
qjpeg_start_decompress (&cinfo);
image_width = cinfo.image_width;
image_height = cinfo.image_height;
- if ((matchwidth && image_width != matchwidth) || (matchheight && image_height != matchheight))
- {
- qjpeg_finish_decompress (&cinfo);
- qjpeg_destroy_decompress (&cinfo);
- return NULL;
- }
if (image_width > 4096 || image_height > 4096 || image_width <= 0 || image_height <= 0)
{
Con_Printf("JPEG_LoadImage: invalid image size %ix%i\n", image_width, image_height);
return NULL;
}
- image_rgba = Mem_Alloc(tempmempool, image_width * image_height * 4);
- scanline = Mem_Alloc(tempmempool, image_width * cinfo.output_components);
- if (!image_rgba || !scanline)
+ image_buffer = (unsigned char *)Mem_Alloc(tempmempool, image_width * image_height * 4);
+ scanline = (unsigned char *)Mem_Alloc(tempmempool, image_width * cinfo.output_components);
+ if (!image_buffer || !scanline)
{
- if (!image_rgba)
- Mem_Free (image_rgba);
+ if (image_buffer)
+ Mem_Free (image_buffer);
+ if (scanline)
+ Mem_Free (scanline);
Con_Printf("JPEG_LoadImage: not enough memory for %i by %i image\n", image_width, image_height);
qjpeg_finish_decompress (&cinfo);
line = 0;
while (cinfo.output_scanline < cinfo.output_height)
{
- qbyte *buffer_ptr;
+ unsigned char *buffer_ptr;
int ind;
qjpeg_read_scanlines (&cinfo, &scanline, 1);
- // Convert the image to RGBA
+ // Convert the image to BGRA
switch (cinfo.output_components)
{
// RGB images
case 3:
- buffer_ptr = &image_rgba[image_width * line * 4];
+ buffer_ptr = &image_buffer[image_width * line * 4];
for (ind = 0; ind < image_width * 3; ind += 3, buffer_ptr += 4)
{
- buffer_ptr[0] = scanline[ind];
+ buffer_ptr[2] = scanline[ind];
buffer_ptr[1] = scanline[ind + 1];
- buffer_ptr[2] = scanline[ind + 2];
+ buffer_ptr[0] = scanline[ind + 2];
buffer_ptr[3] = 255;
}
break;
// Greyscale images (default to it, just in case)
case 1:
default:
- buffer_ptr = &image_rgba[image_width * line * 4];
+ buffer_ptr = &image_buffer[image_width * line * 4];
for (ind = 0; ind < image_width; ind++, buffer_ptr += 4)
{
buffer_ptr[0] = scanline[ind];
qjpeg_finish_decompress (&cinfo);
qjpeg_destroy_decompress (&cinfo);
- return image_rgba;
+ return image_buffer;
}
static void JPEG_InitDestination (j_compress_ptr cinfo)
{
my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
- dest->buffer = (qbyte*)cinfo->mem->alloc_small ((j_common_ptr) cinfo, JPOOL_IMAGE, JPEG_OUTPUT_BUF_SIZE * sizeof(qbyte));
+ dest->buffer = (unsigned char*)cinfo->mem->alloc_small ((j_common_ptr) cinfo, JPOOL_IMAGE, JPEG_OUTPUT_BUF_SIZE * sizeof(unsigned char));
dest->pub.next_output_byte = dest->buffer;
dest->pub.free_in_buffer = JPEG_OUTPUT_BUF_SIZE;
}
Save a preflipped JPEG image to a file
====================
*/
-qboolean JPEG_SaveImage_preflipped (const char *filename, int width, int height, qbyte *data)
+qboolean JPEG_SaveImage_preflipped (const char *filename, int width, int height, unsigned char *data)
{
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
- qbyte *scanline;
+ unsigned char *scanline;
unsigned int offset, linesize;
qfile_t* file;
cinfo.in_color_space = JCS_RGB;
cinfo.input_components = 3;
qjpeg_set_defaults (&cinfo);
- qjpeg_set_quality (&cinfo, scr_screenshot_jpeg_quality.value * 100, TRUE);
+ qjpeg_set_quality (&cinfo, (int)(scr_screenshot_jpeg_quality.value * 100), TRUE);
qjpeg_start_compress (&cinfo, true);
// Compress each scanline