jpeg.h File Reference

#include <stddef.h>
#include "qtypes.h"

Include dependency graph for jpeg.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
qbool	Image_Compress (const char *imagename, size_t maxsize, void **buf, size_t *size)
void	JPEG_CloseLibrary (void)
unsigned char *	JPEG_LoadImage_BGRA (const unsigned char *f, int filesize, int *miplevel)
qbool	JPEG_OpenLibrary (void)
qbool	JPEG_SaveImage_preflipped (const char *filename, int width, int height, unsigned char *data)
size_t	JPEG_SaveImage_to_Buffer (char *jpegbuf, size_t jpegsize, int width, int height, unsigned char *data)

Function Documentation

Image_Compress()

qbool Image_Compress	(	const char *	imagename,
		size_t	maxsize,
		void **	buf,
		size_t *	size )

Definition at line 1047 of file jpeg.c.

{
    unsigned char *imagedata, *newimagedata;
    int maxPixelCount;
    int components[3] = {2, 1, 0};
    CompressedImageCacheItem *i;
 
    JPEG_OpenLibrary (); // for now; LH had the idea of replacing this by a better format
    PNG_OpenLibrary (); // for loading
 
    // No DLL = no JPEGs
    if (!jpeg_dll)
    {
        Con_Print("You need the libjpeg library to save JPEG images\n");
        return false;
    }
 
    i = CompressedImageCache_Find(imagename, maxsize);
    if(i)
    {
        *size = i->compressed_size;
        *buf = i->compressed;
        return (*buf != NULL);
    }
 
    // load the image
    imagedata = loadimagepixelsbgra(imagename, true, false, false, NULL);
    if(!imagedata)
        return false;
 
    // find an appropriate size for somewhat okay compression
    if(maxsize <= 768)
        maxPixelCount = 32 * 32;
    else if(maxsize <= 1024)
        maxPixelCount = 64 * 64;
    else if(maxsize <= 4096)
        maxPixelCount = 128 * 128;
    else
        maxPixelCount = 256 * 256;
 
    while(image_width * image_height > maxPixelCount)
    {
        int one = 1;
        Image_MipReduce32(imagedata, imagedata, &image_width, &image_height, &one, image_width/2, image_height/2, 1);
    }
 
    newimagedata = (unsigned char *) Mem_Alloc(tempmempool, image_width * image_height * 3);
 
    // convert the image from BGRA to RGB
    Image_CopyMux(newimagedata, imagedata, image_width, image_height, false, false, false, 3, 4, components);
    Mem_Free(imagedata);
 
    // try to compress it to JPEG
    *buf = Z_Malloc(maxsize);
    *size = JPEG_SaveImage_to_Buffer((char *) *buf, maxsize, image_width, image_height, newimagedata);
    Mem_Free(newimagedata);
 
    if(!*size)
    {
        Z_Free(*buf);
        *buf = NULL;
        Con_Printf("could not compress image %s to %d bytes\n", imagename, (int)maxsize);
        // return false;
        // also cache failures!
    }
 
    // store it in the cache
    CompressedImageCache_Add(imagename, maxsize, *buf, *size);
    return (*buf != NULL);
}

References buf, CompressedImageCache_Add(), CompressedImageCache_Find(), Con_Print(), Con_Printf(), i, Image_CopyMux(), image_height, Image_MipReduce32(), image_width, CompressedImageCacheItem::imagename, jpeg_dll, JPEG_OpenLibrary(), JPEG_SaveImage_to_Buffer(), loadimagepixelsbgra(), CompressedImageCacheItem::maxsize, Mem_Alloc, Mem_Free, NULL, PNG_OpenLibrary(), size, tempmempool, Z_Free, and Z_Malloc.

Referenced by VM_SV_WritePicture().

JPEG_CloseLibrary()

void JPEG_CloseLibrary

(

void

)

Definition at line 538 of file jpeg.c.

{
#ifndef LINK_TO_LIBJPEG
    Sys_FreeLibrary (&jpeg_dll);
    jpeg_tried_loading = false; // allow retry
#endif
}

References jpeg_dll, jpeg_tried_loading, and Sys_FreeLibrary().

Referenced by r_textures_shutdown().

JPEG_LoadImage_BGRA()

unsigned char * JPEG_LoadImage_BGRA	(	const unsigned char *	f,
		int	filesize,
		int *	miplevel )

Definition at line 606 of file jpeg.c.

{
    struct jpeg_decompress_struct cinfo;
    struct jpeg_error_mgr jerr;
    unsigned char *image_buffer = NULL, *scanline = NULL;
    unsigned int line;
    int submip = 0;
 
    // No DLL = no JPEGs
    if (!jpeg_dll)
        return NULL;
 
    if(miplevel && r_texture_jpeg_fastpicmip.integer)
        submip = bound(0, *miplevel, 3);
 
    cinfo.err = qjpeg_std_error (&jerr);
    qjpeg_create_decompress (&cinfo);
    if(setjmp(error_in_jpeg))
        goto error_caught;
    cinfo.err = qjpeg_std_error (&jerr);
    cinfo.err->error_exit = JPEG_ErrorExit;
    JPEG_MemSrc (&cinfo, f, filesize);
    qjpeg_read_header (&cinfo, true);
    cinfo.scale_num = 1;
    cinfo.scale_denom = (1 << submip);
    qjpeg_start_decompress (&cinfo);
 
    image_width = cinfo.output_width;
    image_height = cinfo.output_height;
 
    if (image_width > 32768 || image_height > 32768 || image_width <= 0 || image_height <= 0)
    {
        Con_Printf("JPEG_LoadImage: invalid image size %ix%i\n", image_width, image_height);
        return NULL;
    }
 
    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_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);
        qjpeg_destroy_decompress (&cinfo);
        return NULL;
    }
 
    // Decompress the image, line by line
    line = 0;
    while (cinfo.output_scanline < cinfo.output_height)
    {
        unsigned char *buffer_ptr;
        int ind;
 
        qjpeg_read_scanlines (&cinfo, &scanline, 1);
 
        // Convert the image to BGRA
        switch (cinfo.output_components)
        {
            // RGB images
            case 3:
                buffer_ptr = &image_buffer[image_width * line * 4];
                for (ind = 0; ind < image_width * 3; ind += 3, buffer_ptr += 4)
                {
                    buffer_ptr[2] = scanline[ind];
                    buffer_ptr[1] = scanline[ind + 1];
                    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_buffer[image_width * line * 4];
                for (ind = 0; ind < image_width; ind++, buffer_ptr += 4)
                {
                    buffer_ptr[0] = scanline[ind];
                    buffer_ptr[1] = scanline[ind];
                    buffer_ptr[2] = scanline[ind];
                    buffer_ptr[3] = 255;
                }
        }
 
        line++;
    }
    Mem_Free (scanline); scanline = NULL;
 
    qjpeg_finish_decompress (&cinfo);
    qjpeg_destroy_decompress (&cinfo);
 
    if(miplevel)
        *miplevel -= submip;
 
    return image_buffer;
 
error_caught:
    if(scanline)
        Mem_Free (scanline);
    if(image_buffer)
        Mem_Free (image_buffer);
    qjpeg_destroy_decompress (&cinfo);
    return NULL;
}

References bound, Con_Printf(), j_decompress_ptr::err, jpeg_error_mgr::error_exit, error_in_jpeg, f, image_height, image_width, cvar_t::integer, jpeg_dll, JPEG_ErrorExit(), JPEG_MemSrc(), Mem_Alloc, Mem_Free, NULL, j_decompress_ptr::output_components, j_decompress_ptr::output_height, j_decompress_ptr::output_scanline, j_decompress_ptr::output_width, qjpeg_create_decompress, qjpeg_destroy_decompress, qjpeg_finish_decompress, qjpeg_read_header, qjpeg_read_scanlines, qjpeg_start_decompress, qjpeg_std_error, r_texture_jpeg_fastpicmip, j_decompress_ptr::scale_denom, j_decompress_ptr::scale_num, and tempmempool.

Referenced by decode_image(), loadimagepixelsbgra(), and VM_CL_ReadPicture().

JPEG_OpenLibrary()

qbool JPEG_OpenLibrary

(

void

)

Definition at line 492 of file jpeg.c.

{
#ifdef LINK_TO_LIBJPEG
    return true;
#else
    const char* dllnames [] =
    {
#if defined(WIN32)
        "libjpeg.dll",
#elif defined(MACOSX)
        "libjpeg.62.dylib",
#else
        "libjpeg.so.62",
        "libjpeg.so",
#endif
        NULL
    };
 
    // Already loaded?
    if (jpeg_dll)
        return true;
 
    if (jpeg_tried_loading) // only try once
        return false;
 
    jpeg_tried_loading = true;
 
#ifdef __ANDROID__
    // loading the native Android libjpeg.so causes crashes
    Con_Printf("Not opening libjpeg.so dynamically on Android - use LINK_TO_LIBJPEG instead if it is needed.\n");
    return false;
#endif
 
    // Load the DLL
    return Sys_LoadDependency (dllnames, &jpeg_dll, jpegfuncs);
#endif
}

References Con_Printf(), jpeg_dll, jpeg_tried_loading, jpegfuncs, NULL, and Sys_LoadDependency().

Referenced by Image_Compress(), and r_textures_start().

JPEG_SaveImage_preflipped()

qbool JPEG_SaveImage_preflipped	(	const char *	filename,
		int	width,
		int	height,
		unsigned char *	data )

Definition at line 818 of file jpeg.c.

{
    struct jpeg_compress_struct cinfo;
    struct jpeg_error_mgr jerr;
    unsigned char *scanline;
    unsigned int offset, linesize;
    qfile_t* file;
 
    // No DLL = no JPEGs
    if (!jpeg_dll)
    {
        Con_Print("You need the libjpeg library to save JPEG images\n");
        return false;
    }
 
    // Open the file
    file = FS_OpenRealFile(filename, "wb", true);
    if (!file)
        return false;
 
    if(setjmp(error_in_jpeg))
        goto error_caught;
    cinfo.err = qjpeg_std_error (&jerr);
    cinfo.err->error_exit = JPEG_ErrorExit;
 
    qjpeg_create_compress (&cinfo);
    JPEG_FileDest (&cinfo, file);
 
    // Set the parameters for compression
    cinfo.image_width = width;
    cinfo.image_height = height;
    cinfo.in_color_space = JCS_RGB;
    cinfo.input_components = 3;
    qjpeg_set_defaults (&cinfo);
    qjpeg_set_quality (&cinfo, (int)(scr_screenshot_jpeg_quality.value * 100), true);
    qjpeg_simple_progression (&cinfo);
 
    // turn off subsampling (to make text look better)
    cinfo.optimize_coding = 1;
    cinfo.comp_info[0].h_samp_factor = 1;
    cinfo.comp_info[0].v_samp_factor = 1;
    cinfo.comp_info[1].h_samp_factor = 1;
    cinfo.comp_info[1].v_samp_factor = 1;
    cinfo.comp_info[2].h_samp_factor = 1;
    cinfo.comp_info[2].v_samp_factor = 1;
 
    qjpeg_start_compress (&cinfo, true);
 
    // Compress each scanline
    linesize = cinfo.image_width * 3;
    offset = linesize * (cinfo.image_height - 1);
    while (cinfo.next_scanline < cinfo.image_height)
    {
        scanline = &data[offset - cinfo.next_scanline * linesize];
 
        qjpeg_write_scanlines (&cinfo, &scanline, 1);
    }
 
    qjpeg_finish_compress (&cinfo);
    qjpeg_destroy_compress (&cinfo);
 
    FS_Close (file);
    return true;
 
error_caught:
    qjpeg_destroy_compress (&cinfo);
    FS_Close (file);
    return false;
}

References j_compress_ptr::comp_info, Con_Print(), data, j_compress_ptr::err, jpeg_error_mgr::error_exit, error_in_jpeg, FS_Close(), FS_OpenRealFile(), jpeg_component_info::h_samp_factor, height, j_compress_ptr::image_height, j_compress_ptr::image_width, j_compress_ptr::in_color_space, j_compress_ptr::input_components, JCS_RGB, jpeg_dll, JPEG_ErrorExit(), JPEG_FileDest(), j_compress_ptr::next_scanline, offset, j_compress_ptr::optimize_coding, qjpeg_create_compress, qjpeg_destroy_compress, qjpeg_finish_compress, qjpeg_set_defaults, qjpeg_set_quality, qjpeg_simple_progression, qjpeg_start_compress, qjpeg_std_error, qjpeg_write_scanlines, scr_screenshot_jpeg_quality, jpeg_component_info::v_samp_factor, cvar_t::value, and width.

Referenced by SCR_ScreenShot().

JPEG_SaveImage_to_Buffer()

size_t JPEG_SaveImage_to_Buffer	(	char *	jpegbuf,
		size_t	jpegsize,
		int	width,
		int	height,
		unsigned char *	data )

Returns

0 if failed, or the size actually used.

Definition at line 931 of file jpeg.c.

{
    struct jpeg_compress_struct cinfo;
    struct jpeg_error_mgr jerr;
 
    int quality;
    int quality_guess;
    size_t result;
 
    // No DLL = no JPEGs
    if (!jpeg_dll)
    {
        Con_Print("You need the libjpeg library to save JPEG images\n");
        return false;
    }
 
    if(setjmp(error_in_jpeg))
        goto error_caught;
    cinfo.err = qjpeg_std_error (&jerr);
    cinfo.err->error_exit = JPEG_ErrorExit;
 
    qjpeg_create_compress (&cinfo);
 
#if 0
    // used to get the formula below
    {
        char buf[1048576];
        unsigned char *img;
        int i;
 
        img = Mem_Alloc(tempmempool, width * height * 3);
        for(i = 0; i < width * height * 3; ++i)
            img[i] = rand() & 0xFF;
 
        for(i = 0; i <= 100; ++i)
        {
            Con_Printf("! %d %d %d %d\n", width, height, i, (int) JPEG_try_SaveImage_to_Buffer(&cinfo, buf, sizeof(buf), i, width, height, img));
        }
 
        Mem_Free(img);
    }
#endif
 
    //quality_guess = (int)((100 * jpegsize - 41000) / (width*height) + 2); // fits random data
    quality_guess   = (int)((256 * jpegsize - 81920) / (width*height) - 8); // fits Nexuiz's/Xonotic's map pictures
 
    quality_guess = bound(0, quality_guess, 100);
    quality = bound(0, quality_guess + sv_writepicture_quality.integer, 100); // assume it can do 10 failed attempts
 
    while(!(result = JPEG_try_SaveImage_to_Buffer(&cinfo, jpegbuf, jpegsize, quality, width, height, data)))
    {
        --quality;
        if(quality < 0)
        {
            Con_Printf("couldn't write image at all, probably too big\n");
            return 0;
        }
    }
    qjpeg_destroy_compress (&cinfo);
    Con_DPrintf("JPEG_SaveImage_to_Buffer: guessed quality/size %d/%d, actually got %d/%d\n", quality_guess, (int)jpegsize, quality, (int)result);
 
    return result;
 
error_caught:
    qjpeg_destroy_compress (&cinfo);
    return 0;
}

References bound, buf, Con_DPrintf(), Con_Print(), Con_Printf(), data, j_compress_ptr::err, jpeg_error_mgr::error_exit, error_in_jpeg, height, i, img, int(), cvar_t::integer, jpeg_dll, JPEG_ErrorExit(), JPEG_try_SaveImage_to_Buffer(), Mem_Alloc, Mem_Free, qjpeg_create_compress, qjpeg_destroy_compress, qjpeg_std_error, sv_writepicture_quality, tempmempool, and width.

Referenced by Image_Compress().