jpeg.c File Reference

#include "darkplaces.h"
#include "cl_screen.h"
#include "image.h"
#include "jpeg.h"
#include "image_png.h"

Include dependency graph for jpeg.c:

Go to the source code of this file.

Data Structures
struct	CompressedImageCacheItem
struct	j_compress_ptr
struct	j_decompress_ptr
struct	jpeg_component_info
struct	jpeg_destination_mgr
struct	jpeg_error_mgr
struct	jpeg_memory_mgr
struct	jpeg_source_mgr
struct	my_destination_mgr

Macros
#define	C_MAX_BLOCKS_IN_MCU   10
#define	COMPRESSEDIMAGECACHE_SIZE   4096
#define	D_MAX_BLOCKS_IN_MCU   10
#define	DCTSIZE2   64
#define	JMSG_STR_PARM_MAX   80
#define	JPEG_EOI   0xD9
#define	JPEG_LIB_VERSION   62
#define	JPEG_OUTPUT_BUF_SIZE   4096
#define	JPOOL_IMAGE   1
#define	JPOOL_PERMANENT   0
#define	MAX_COMPS_IN_SCAN   4
#define	NUM_ARITH_TBLS   16
#define	NUM_HUFF_TBLS   4
#define	NUM_QUANT_TBLS   4
#define	qjpeg_create_compress(cinfo)
#define	qjpeg_create_decompress(cinfo)

Typedefs
typedef void *	j_common_ptr
typedef int	jboolean
typedef unsigned int	JDIMENSION
typedef my_destination_mgr *	my_dest_ptr

Enumerations
enum	J_COLOR_SPACE {   JCS_UNKNOWN , JCS_GRAYSCALE , JCS_RGB , JCS_YCbCr ,   JCS_CMYK , JCS_YCCK }
enum	J_DCT_METHOD { JPEG_DUMMY1 }
enum	J_DITHER_MODE { JPEG_DUMMY2 }

Functions
static void	CompressedImageCache_Add (const char *imagename, size_t maxsize, void *compressed, size_t compressed_size)
static CompressedImageCacheItem *	CompressedImageCache_Find (const char *imagename, size_t maxsize)
qbool	Image_Compress (const char *imagename, size_t maxsize, void **buf, size_t *size)
void	JPEG_CloseLibrary (void)
static jboolean	JPEG_EmptyOutputBuffer (j_compress_ptr cinfo)
static void	JPEG_ErrorExit (j_common_ptr cinfo)
static void	JPEG_FileDest (j_compress_ptr cinfo, qfile_t *outfile)
static jboolean	JPEG_FillInputBuffer (j_decompress_ptr cinfo)
static void	JPEG_InitDestination (j_compress_ptr cinfo)
unsigned char *	JPEG_LoadImage_BGRA (const unsigned char *f, int filesize, int *miplevel)
static jboolean	JPEG_Mem_EmptyOutputBuffer (j_compress_ptr cinfo)
static void	JPEG_Mem_InitDestination (j_compress_ptr cinfo)
static void	JPEG_Mem_TermDestination (j_compress_ptr cinfo)
static void	JPEG_MemDest (j_compress_ptr cinfo, void *buf, size_t bufsize)
static void	JPEG_MemSrc (j_decompress_ptr cinfo, const unsigned char *buffer, size_t filesize)
static void	JPEG_Noop (j_decompress_ptr cinfo)
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)
static void	JPEG_SkipInputData (j_decompress_ptr cinfo, long num_bytes)
static void	JPEG_TermDestination (j_compress_ptr cinfo)
static size_t	JPEG_try_SaveImage_to_Buffer (struct jpeg_compress_struct *cinfo, char *jpegbuf, size_t jpegsize, int quality, int width, int height, unsigned char *data)

Variables
static CompressedImageCacheItem *	CompressedImageCache [COMPRESSEDIMAGECACHE_SIZE]
static jmp_buf	error_in_jpeg
dllhandle_t	jpeg_dll = NULL
static unsigned char	jpeg_eoi_marker [2] = {0xFF, JPEG_EOI}
static qbool	jpeg_toolarge
qbool	jpeg_tried_loading = 0
static dllfunction_t	jpegfuncs []
static void(*	qjpeg_CreateCompress )(j_compress_ptr cinfo, int version, size_t structsize)
static void(*	qjpeg_CreateDecompress )(j_decompress_ptr cinfo, int version, size_t structsize)
static void(*	qjpeg_destroy_compress )(j_compress_ptr cinfo)
static void(*	qjpeg_destroy_decompress )(j_decompress_ptr cinfo)
static void(*	qjpeg_finish_compress )(j_compress_ptr cinfo)
static jboolean(*	qjpeg_finish_decompress )(j_decompress_ptr cinfo)
static int(*	qjpeg_read_header )(j_decompress_ptr cinfo, jboolean require_image)
static JDIMENSION(*	qjpeg_read_scanlines )(j_decompress_ptr cinfo, unsigned char **scanlines, JDIMENSION max_lines)
static jboolean(*	qjpeg_resync_to_restart )(j_decompress_ptr cinfo, int desired)
static void(*	qjpeg_set_defaults )(j_compress_ptr cinfo)
static void(*	qjpeg_set_quality )(j_compress_ptr cinfo, int quality, jboolean force_baseline)
static void(*	qjpeg_simple_progression )(j_compress_ptr cinfo)
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, unsigned char **scanlines, JDIMENSION num_lines)
cvar_t	r_texture_jpeg_fastpicmip = {CF_CLIENT | CF_ARCHIVE, "r_texture_jpeg_fastpicmip", "1", "perform gl_picmip during decompression for JPEG files (faster)"}
cvar_t	sv_writepicture_quality

Macro Definition Documentation

C_MAX_BLOCKS_IN_MCU

#define C_MAX_BLOCKS_IN_MCU   10

Definition at line 103 of file jpeg.c.

COMPRESSEDIMAGECACHE_SIZE

#define COMPRESSEDIMAGECACHE_SIZE   4096

Definition at line 1008 of file jpeg.c.

Referenced by CompressedImageCache_Add(), and CompressedImageCache_Find().

D_MAX_BLOCKS_IN_MCU

#define D_MAX_BLOCKS_IN_MCU   10

Definition at line 104 of file jpeg.c.

DCTSIZE2

#define DCTSIZE2   64

Definition at line 98 of file jpeg.c.

JMSG_STR_PARM_MAX

#define JMSG_STR_PARM_MAX   80

Definition at line 96 of file jpeg.c.

JPEG_EOI

#define JPEG_EOI   0xD9

Definition at line 94 of file jpeg.c.

JPEG_LIB_VERSION

#define JPEG_LIB_VERSION   62

Definition at line 76 of file jpeg.c.

JPEG_OUTPUT_BUF_SIZE

#define JPEG_OUTPUT_BUF_SIZE   4096

Definition at line 724 of file jpeg.c.

Referenced by JPEG_EmptyOutputBuffer(), JPEG_InitDestination(), and JPEG_TermDestination().

JPOOL_IMAGE

#define JPOOL_IMAGE   1

Definition at line 92 of file jpeg.c.

Referenced by JPEG_InitDestination().

JPOOL_PERMANENT

#define JPOOL_PERMANENT   0

Definition at line 91 of file jpeg.c.

Referenced by JPEG_FileDest(), JPEG_MemDest(), and JPEG_MemSrc().

MAX_COMPS_IN_SCAN

#define MAX_COMPS_IN_SCAN   4

Definition at line 102 of file jpeg.c.

NUM_ARITH_TBLS

#define NUM_ARITH_TBLS   16

Definition at line 101 of file jpeg.c.

NUM_HUFF_TBLS

#define NUM_HUFF_TBLS   4

Definition at line 100 of file jpeg.c.

NUM_QUANT_TBLS

#define NUM_QUANT_TBLS   4

Definition at line 99 of file jpeg.c.

qjpeg_create_compress

#define qjpeg_create_compress

(

cinfo

)

Value:

    qjpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, (size_t) sizeof(struct jpeg_compress_struct))

Definition at line 413 of file jpeg.c.

#define qjpeg_create_compress(cinfo) \
    qjpeg_CreateCompress((cinfo), JPEG_LIB_VERSION, (size_t) sizeof(struct jpeg_compress_struct))

Referenced by JPEG_SaveImage_preflipped(), and JPEG_SaveImage_to_Buffer().

qjpeg_create_decompress

#define qjpeg_create_decompress

(

cinfo

)

Value:

    qjpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, (size_t) sizeof(struct jpeg_decompress_struct))

Definition at line 415 of file jpeg.c.

#define qjpeg_create_decompress(cinfo) \
    qjpeg_CreateDecompress((cinfo), JPEG_LIB_VERSION, (size_t) sizeof(struct jpeg_decompress_struct))

Referenced by JPEG_LoadImage_BGRA().

Typedef Documentation

j_common_ptr

typedef void* j_common_ptr

Definition at line 72 of file jpeg.c.

jboolean

typedef int jboolean

Definition at line 38 of file jpeg.c.

JDIMENSION

typedef unsigned int JDIMENSION

Definition at line 89 of file jpeg.c.

my_dest_ptr

typedef my_destination_mgr* my_dest_ptr

Definition at line 474 of file jpeg.c.

Enumeration Type Documentation

J_COLOR_SPACE

enum J_COLOR_SPACE

Enumerator
JCS_UNKNOWN
JCS_GRAYSCALE
JCS_RGB
JCS_YCbCr
JCS_CMYK
JCS_YCCK

Definition at line 78 of file jpeg.c.

{
    JCS_UNKNOWN,
    JCS_GRAYSCALE,
    JCS_RGB,
    JCS_YCbCr,
    JCS_CMYK,
    JCS_YCCK
} J_COLOR_SPACE;

J_DCT_METHOD

enum J_DCT_METHOD

Enumerator
JPEG_DUMMY1

Definition at line 87 of file jpeg.c.

{JPEG_DUMMY1} J_DCT_METHOD;

J_DITHER_MODE

enum J_DITHER_MODE

Enumerator
JPEG_DUMMY2

Definition at line 88 of file jpeg.c.

{JPEG_DUMMY2} J_DITHER_MODE;

Function Documentation

CompressedImageCache_Add()

static void CompressedImageCache_Add ( const char * imagename, size_t maxsize, void * compressed, size_t compressed_size )

static

Definition at line 1011 of file jpeg.c.

{
    char vabuf[1024];
    const char *hashkey = va(vabuf, sizeof(vabuf), "%s:%d", imagename, (int) maxsize);
    int hashindex = CRC_Block((unsigned char *) hashkey, strlen(hashkey)) % COMPRESSEDIMAGECACHE_SIZE;
    CompressedImageCacheItem *i;
 
    if(strlen(imagename) >= MAX_QPATH)
        return; // can't add this
 
    i = (CompressedImageCacheItem*) Z_Malloc(sizeof(CompressedImageCacheItem));
    dp_strlcpy(i->imagename, imagename, sizeof(i->imagename));
    i->maxsize = maxsize;
    i->compressed = compressed;
    i->compressed_size = compressed_size;
    i->next = CompressedImageCache[hashindex];
    CompressedImageCache[hashindex] = i;
}

References CompressedImageCacheItem::compressed, CompressedImageCacheItem::compressed_size, CompressedImageCache, COMPRESSEDIMAGECACHE_SIZE, CRC_Block(), dp_strlcpy, i, CompressedImageCacheItem::imagename, MAX_QPATH, CompressedImageCacheItem::maxsize, strlen(), va(), and Z_Malloc.

Referenced by Image_Compress().

CompressedImageCache_Find()

static CompressedImageCacheItem * CompressedImageCache_Find ( const char * imagename, size_t maxsize )

static

Definition at line 1030 of file jpeg.c.

{
    char vabuf[1024];
    const char *hashkey = va(vabuf, sizeof(vabuf), "%s:%d", imagename, (int) maxsize);
    int hashindex = CRC_Block((unsigned char *) hashkey, strlen(hashkey)) % COMPRESSEDIMAGECACHE_SIZE;
    CompressedImageCacheItem *i = CompressedImageCache[hashindex];
 
    while(i)
    {
        if(i->maxsize == maxsize)
            if(!strcmp(i->imagename, imagename))
                return i;
        i = i->next;
    }
    return NULL;
}

References CompressedImageCache, COMPRESSEDIMAGECACHE_SIZE, CRC_Block(), i, CompressedImageCacheItem::imagename, CompressedImageCacheItem::maxsize, NULL, strlen(), and va().

Referenced by Image_Compress().

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_EmptyOutputBuffer()

static jboolean JPEG_EmptyOutputBuffer ( j_compress_ptr cinfo )

static

Definition at line 733 of file jpeg.c.

{
    my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
 
    if (FS_Write (dest->outfile, dest->buffer, JPEG_OUTPUT_BUF_SIZE) != (size_t) JPEG_OUTPUT_BUF_SIZE)
        longjmp(error_in_jpeg, 1);
 
    dest->pub.next_output_byte = dest->buffer;
    dest->pub.free_in_buffer = JPEG_OUTPUT_BUF_SIZE;
    return true;
}

References my_destination_mgr::buffer, error_in_jpeg, jpeg_destination_mgr::free_in_buffer, FS_Write(), JPEG_OUTPUT_BUF_SIZE, jpeg_destination_mgr::next_output_byte, my_destination_mgr::outfile, and my_destination_mgr::pub.

Referenced by JPEG_FileDest().

JPEG_ErrorExit()

static void JPEG_ErrorExit ( j_common_ptr cinfo )

static

Definition at line 592 of file jpeg.c.

{
    ((struct jpeg_decompress_struct*)cinfo)->err->output_message (cinfo);
    longjmp(error_in_jpeg, 1);
}

References j_decompress_ptr::err, error_in_jpeg, and jpeg_error_mgr::output_message.

Referenced by JPEG_LoadImage_BGRA(), JPEG_SaveImage_preflipped(), and JPEG_SaveImage_to_Buffer().

JPEG_FileDest()

static void JPEG_FileDest ( j_compress_ptr cinfo, qfile_t * outfile )

static

Definition at line 756 of file jpeg.c.

{
    my_dest_ptr dest;
 
    // First time for this JPEG object?
    if (cinfo->dest == NULL)
        cinfo->dest = (struct jpeg_destination_mgr *)(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(my_destination_mgr));
 
    dest = (my_dest_ptr)cinfo->dest;
    dest->pub.init_destination = JPEG_InitDestination;
    dest->pub.empty_output_buffer = JPEG_EmptyOutputBuffer;
    dest->pub.term_destination = JPEG_TermDestination;
    dest->outfile = outfile;
}

References jpeg_destination_mgr::empty_output_buffer, jpeg_destination_mgr::init_destination, JPEG_EmptyOutputBuffer(), JPEG_InitDestination(), JPEG_TermDestination(), JPOOL_PERMANENT, NULL, my_destination_mgr::outfile, outfile, my_destination_mgr::pub, and jpeg_destination_mgr::term_destination.

Referenced by JPEG_SaveImage_preflipped().

JPEG_FillInputBuffer()

static jboolean JPEG_FillInputBuffer ( j_decompress_ptr cinfo )

static

Definition at line 557 of file jpeg.c.

{
    // Insert a fake EOI marker
    cinfo->src->next_input_byte = jpeg_eoi_marker;
    cinfo->src->bytes_in_buffer = 2;
 
    return true;
}

References jpeg_eoi_marker.

Referenced by JPEG_MemSrc().

JPEG_InitDestination()

static void JPEG_InitDestination ( j_compress_ptr cinfo )

static

Definition at line 725 of file jpeg.c.

{
    my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
    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;
}

References my_destination_mgr::buffer, jpeg_destination_mgr::free_in_buffer, JPEG_OUTPUT_BUF_SIZE, JPOOL_IMAGE, jpeg_destination_mgr::next_output_byte, and my_destination_mgr::pub.

Referenced by JPEG_FileDest().

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_Mem_EmptyOutputBuffer()

static jboolean JPEG_Mem_EmptyOutputBuffer ( j_compress_ptr cinfo )

static

Definition at line 778 of file jpeg.c.

{
    my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
    jpeg_toolarge = true;
    dest->pub.next_output_byte = dest->buffer;
    dest->pub.free_in_buffer = dest->bufsize;
    return true;
}

References my_destination_mgr::buffer, my_destination_mgr::bufsize, jpeg_destination_mgr::free_in_buffer, jpeg_toolarge, jpeg_destination_mgr::next_output_byte, and my_destination_mgr::pub.

Referenced by JPEG_MemDest().

JPEG_Mem_InitDestination()

static void JPEG_Mem_InitDestination ( j_compress_ptr cinfo )

static

Definition at line 771 of file jpeg.c.

{
    my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
    dest->pub.next_output_byte = dest->buffer;
    dest->pub.free_in_buffer = dest->bufsize;
}

References my_destination_mgr::buffer, my_destination_mgr::bufsize, jpeg_destination_mgr::free_in_buffer, jpeg_destination_mgr::next_output_byte, and my_destination_mgr::pub.

Referenced by JPEG_MemDest().

JPEG_Mem_TermDestination()

static void JPEG_Mem_TermDestination ( j_compress_ptr cinfo )

static

Definition at line 787 of file jpeg.c.

{
    my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
    dest->bufsize = dest->pub.next_output_byte - dest->buffer;
}

References my_destination_mgr::buffer, my_destination_mgr::bufsize, jpeg_destination_mgr::next_output_byte, and my_destination_mgr::pub.

Referenced by JPEG_MemDest().

JPEG_MemDest()

static void JPEG_MemDest ( j_compress_ptr cinfo, void * buf, size_t bufsize )

static

Definition at line 792 of file jpeg.c.

{
    my_dest_ptr dest;
 
    // First time for this JPEG object?
    if (cinfo->dest == NULL)
        cinfo->dest = (struct jpeg_destination_mgr *)(*cinfo->mem->alloc_small) ((j_common_ptr) cinfo, JPOOL_PERMANENT, sizeof(my_destination_mgr));
 
    dest = (my_dest_ptr)cinfo->dest;
    dest->pub.init_destination = JPEG_Mem_InitDestination;
    dest->pub.empty_output_buffer = JPEG_Mem_EmptyOutputBuffer;
    dest->pub.term_destination = JPEG_Mem_TermDestination;
    dest->outfile = NULL;
 
    dest->buffer = (unsigned char *) buf;
    dest->bufsize = bufsize;
}

References buf, my_destination_mgr::buffer, my_destination_mgr::bufsize, jpeg_destination_mgr::empty_output_buffer, jpeg_destination_mgr::init_destination, JPEG_Mem_EmptyOutputBuffer(), JPEG_Mem_InitDestination(), JPEG_Mem_TermDestination(), JPOOL_PERMANENT, NULL, my_destination_mgr::outfile, my_destination_mgr::pub, and jpeg_destination_mgr::term_destination.

Referenced by JPEG_try_SaveImage_to_Buffer().

JPEG_MemSrc()

static void JPEG_MemSrc ( j_decompress_ptr cinfo, const unsigned char * buffer, size_t filesize )

static

Definition at line 578 of file jpeg.c.

{
    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 = filesize;
 
    cinfo->src->init_source = JPEG_Noop;
    cinfo->src->fill_input_buffer = JPEG_FillInputBuffer;
    cinfo->src->skip_input_data = JPEG_SkipInputData;
    cinfo->src->resync_to_restart = qjpeg_resync_to_restart; // use the default method
    cinfo->src->term_source = JPEG_Noop;
}

References buffer, JPEG_FillInputBuffer(), JPEG_Noop(), JPEG_SkipInputData(), JPOOL_PERMANENT, and qjpeg_resync_to_restart.

Referenced by JPEG_LoadImage_BGRA().

JPEG_Noop()

static void JPEG_Noop ( j_decompress_ptr cinfo )

static

Definition at line 555 of file jpeg.c.

{}

Referenced by JPEG_MemSrc().

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().

JPEG_SkipInputData()

static void JPEG_SkipInputData ( j_decompress_ptr cinfo, long num_bytes )

static

Definition at line 566 of file jpeg.c.

{
    if (cinfo->src->bytes_in_buffer <= (unsigned long)num_bytes)
    {
        cinfo->src->bytes_in_buffer = 0;
        return;
    }
 
    cinfo->src->next_input_byte += num_bytes;
    cinfo->src->bytes_in_buffer -= num_bytes;
}

Referenced by JPEG_MemSrc().

JPEG_TermDestination()

static void JPEG_TermDestination ( j_compress_ptr cinfo )

static

Definition at line 745 of file jpeg.c.

{
    my_dest_ptr dest = (my_dest_ptr)cinfo->dest;
    size_t datacount = JPEG_OUTPUT_BUF_SIZE - dest->pub.free_in_buffer;
 
    // Write any data remaining in the buffer
    if (datacount > 0)
        if (FS_Write (dest->outfile, dest->buffer, datacount) != (fs_offset_t)datacount)
            longjmp(error_in_jpeg, 1);
}

References my_destination_mgr::buffer, error_in_jpeg, jpeg_destination_mgr::free_in_buffer, FS_Write(), JPEG_OUTPUT_BUF_SIZE, my_destination_mgr::outfile, and my_destination_mgr::pub.

Referenced by JPEG_FileDest().

JPEG_try_SaveImage_to_Buffer()

static size_t JPEG_try_SaveImage_to_Buffer ( struct jpeg_compress_struct * cinfo, char * jpegbuf, size_t jpegsize, int quality, int width, int height, unsigned char * data )

static

Definition at line 888 of file jpeg.c.

{
    unsigned char *scanline;
    unsigned int linesize;
 
    jpeg_toolarge = false;
    JPEG_MemDest (cinfo, jpegbuf, jpegsize);
 
    // 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, quality, false);
 
    cinfo->comp_info[0].h_samp_factor = 2;
    cinfo->comp_info[0].v_samp_factor = 2;
    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;
    cinfo->optimize_coding = 1;
 
    qjpeg_start_compress (cinfo, true);
 
    // Compress each scanline
    linesize = width * 3;
    while (cinfo->next_scanline < cinfo->image_height)
    {
        scanline = &data[cinfo->next_scanline * linesize];
 
        qjpeg_write_scanlines (cinfo, &scanline, 1);
    }
 
    qjpeg_finish_compress (cinfo);
 
    if(jpeg_toolarge)
        return 0;
 
    return ((my_dest_ptr) cinfo->dest)->bufsize;
}

References j_compress_ptr::comp_info, data, j_compress_ptr::dest, 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_MemDest(), jpeg_toolarge, j_compress_ptr::next_scanline, j_compress_ptr::optimize_coding, qjpeg_finish_compress, qjpeg_set_defaults, qjpeg_set_quality, qjpeg_start_compress, qjpeg_write_scanlines, jpeg_component_info::v_samp_factor, and width.

Referenced by JPEG_SaveImage_to_Buffer().

Variable Documentation

CompressedImageCache

CompressedImageCacheItem* CompressedImageCache[COMPRESSEDIMAGECACHE_SIZE]

static

Definition at line 1009 of file jpeg.c.

Referenced by CompressedImageCache_Add(), and CompressedImageCache_Find().

error_in_jpeg

jmp_buf error_in_jpeg

static

Definition at line 462 of file jpeg.c.

Referenced by JPEG_EmptyOutputBuffer(), JPEG_ErrorExit(), JPEG_LoadImage_BGRA(), JPEG_SaveImage_preflipped(), JPEG_SaveImage_to_Buffer(), and JPEG_TermDestination().

jpeg_dll

dllhandle_t jpeg_dll = NULL

Definition at line 457 of file jpeg.c.

Referenced by Image_Compress(), JPEG_CloseLibrary(), JPEG_LoadImage_BGRA(), JPEG_OpenLibrary(), JPEG_SaveImage_preflipped(), and JPEG_SaveImage_to_Buffer().

jpeg_eoi_marker

unsigned char jpeg_eoi_marker[2] = {0xFF, JPEG_EOI}

static

Definition at line 461 of file jpeg.c.

{0xFF, JPEG_EOI};

Referenced by JPEG_FillInputBuffer().

jpeg_toolarge

qbool jpeg_toolarge

static

Definition at line 463 of file jpeg.c.

Referenced by JPEG_Mem_EmptyOutputBuffer(), and JPEG_try_SaveImage_to_Buffer().

jpeg_tried_loading

qbool jpeg_tried_loading = 0

Definition at line 458 of file jpeg.c.

Referenced by JPEG_CloseLibrary(), and JPEG_OpenLibrary().

jpegfuncs

dllfunction_t jpegfuncs[]

static

Initial value:

=
{
    {"jpeg_CreateCompress",     (void **) &qjpeg_CreateCompress},
    {"jpeg_CreateDecompress",   (void **) &qjpeg_CreateDecompress},
    {"jpeg_destroy_compress",   (void **) &qjpeg_destroy_compress},
    {"jpeg_destroy_decompress", (void **) &qjpeg_destroy_decompress},
    {"jpeg_finish_compress",    (void **) &qjpeg_finish_compress},
    {"jpeg_finish_decompress",  (void **) &qjpeg_finish_decompress},
    {"jpeg_resync_to_restart",  (void **) &qjpeg_resync_to_restart},
    {"jpeg_read_header",        (void **) &qjpeg_read_header},
    {"jpeg_read_scanlines",     (void **) &qjpeg_read_scanlines},
    {"jpeg_set_defaults",       (void **) &qjpeg_set_defaults},
    {"jpeg_set_quality",        (void **) &qjpeg_set_quality},
    {"jpeg_start_compress",     (void **) &qjpeg_start_compress},
    {"jpeg_start_decompress",   (void **) &qjpeg_start_decompress},
    {"jpeg_std_error",          (void **) &qjpeg_std_error},
    {"jpeg_write_scanlines",    (void **) &qjpeg_write_scanlines},
    {"jpeg_simple_progression", (void **) &qjpeg_simple_progression},
    {NULL, NULL}
}

Definition at line 435 of file jpeg.c.

{
    {"jpeg_CreateCompress",     (void **) &qjpeg_CreateCompress},
    {"jpeg_CreateDecompress",   (void **) &qjpeg_CreateDecompress},
    {"jpeg_destroy_compress",   (void **) &qjpeg_destroy_compress},
    {"jpeg_destroy_decompress", (void **) &qjpeg_destroy_decompress},
    {"jpeg_finish_compress",    (void **) &qjpeg_finish_compress},
    {"jpeg_finish_decompress",  (void **) &qjpeg_finish_decompress},
    {"jpeg_resync_to_restart",  (void **) &qjpeg_resync_to_restart},
    {"jpeg_read_header",        (void **) &qjpeg_read_header},
    {"jpeg_read_scanlines",     (void **) &qjpeg_read_scanlines},
    {"jpeg_set_defaults",       (void **) &qjpeg_set_defaults},
    {"jpeg_set_quality",        (void **) &qjpeg_set_quality},
    {"jpeg_start_compress",     (void **) &qjpeg_start_compress},
    {"jpeg_start_decompress",   (void **) &qjpeg_start_decompress},
    {"jpeg_std_error",          (void **) &qjpeg_std_error},
    {"jpeg_write_scanlines",    (void **) &qjpeg_write_scanlines},
    {"jpeg_simple_progression", (void **) &qjpeg_simple_progression},
    {NULL, NULL}
};

Referenced by JPEG_OpenLibrary().

qjpeg_CreateCompress

void(* qjpeg_CreateCompress) (j_compress_ptr cinfo, int version, size_t structsize) ( j_compress_ptr cinfo, int version, size_t structsize )

static

Definition at line 418 of file jpeg.c.

qjpeg_CreateDecompress

void(* qjpeg_CreateDecompress) (j_decompress_ptr cinfo, int version, size_t structsize) ( j_decompress_ptr cinfo, int version, size_t structsize )

static

Definition at line 419 of file jpeg.c.

qjpeg_destroy_compress

void(* qjpeg_destroy_compress) (j_compress_ptr cinfo) ( j_compress_ptr cinfo )

static

Definition at line 420 of file jpeg.c.

Referenced by JPEG_SaveImage_preflipped(), and JPEG_SaveImage_to_Buffer().

qjpeg_destroy_decompress

void(* qjpeg_destroy_decompress) (j_decompress_ptr cinfo) ( j_decompress_ptr cinfo )

static

Definition at line 421 of file jpeg.c.

Referenced by JPEG_LoadImage_BGRA().

qjpeg_finish_compress

void(* qjpeg_finish_compress) (j_compress_ptr cinfo) ( j_compress_ptr cinfo )

static

Definition at line 422 of file jpeg.c.

Referenced by JPEG_SaveImage_preflipped(), and JPEG_try_SaveImage_to_Buffer().

qjpeg_finish_decompress

jboolean(* qjpeg_finish_decompress) (j_decompress_ptr cinfo) ( j_decompress_ptr cinfo )

static

Definition at line 423 of file jpeg.c.

Referenced by JPEG_LoadImage_BGRA().

qjpeg_read_header

int(* qjpeg_read_header) (j_decompress_ptr cinfo, jboolean require_image) ( j_decompress_ptr cinfo, jboolean require_image )

static

Definition at line 425 of file jpeg.c.

Referenced by JPEG_LoadImage_BGRA().

qjpeg_read_scanlines

JDIMENSION(* qjpeg_read_scanlines) (j_decompress_ptr cinfo, unsigned char **scanlines, JDIMENSION max_lines) ( j_decompress_ptr cinfo, unsigned char ** scanlines, JDIMENSION max_lines )

static

Definition at line 426 of file jpeg.c.

Referenced by JPEG_LoadImage_BGRA().

qjpeg_resync_to_restart

jboolean(* qjpeg_resync_to_restart) (j_decompress_ptr cinfo, int desired) ( j_decompress_ptr cinfo, int desired )

static

Definition at line 424 of file jpeg.c.

Referenced by JPEG_MemSrc().

qjpeg_set_defaults

void(* qjpeg_set_defaults) (j_compress_ptr cinfo) ( j_compress_ptr cinfo )

static

Definition at line 427 of file jpeg.c.

Referenced by JPEG_SaveImage_preflipped(), and JPEG_try_SaveImage_to_Buffer().

qjpeg_set_quality

void(* qjpeg_set_quality) (j_compress_ptr cinfo, int quality, jboolean force_baseline) ( j_compress_ptr cinfo, int quality, jboolean force_baseline )

static

Definition at line 428 of file jpeg.c.

Referenced by JPEG_SaveImage_preflipped(), and JPEG_try_SaveImage_to_Buffer().

qjpeg_simple_progression

void(* qjpeg_simple_progression) (j_compress_ptr cinfo) ( j_compress_ptr cinfo )

static

Definition at line 433 of file jpeg.c.

Referenced by JPEG_SaveImage_preflipped().

qjpeg_start_compress

jboolean(* qjpeg_start_compress) (j_compress_ptr cinfo, jboolean write_all_tables) ( j_compress_ptr cinfo, jboolean write_all_tables )

static

Definition at line 429 of file jpeg.c.

Referenced by JPEG_SaveImage_preflipped(), and JPEG_try_SaveImage_to_Buffer().

qjpeg_start_decompress

jboolean(* qjpeg_start_decompress) (j_decompress_ptr cinfo) ( j_decompress_ptr cinfo )

static

Definition at line 430 of file jpeg.c.

Referenced by JPEG_LoadImage_BGRA().

qjpeg_std_error

struct jpeg_error_mgr *(* qjpeg_std_error) (struct jpeg_error_mgr *err) ( struct jpeg_error_mgr * err )

static

Definition at line 430 of file jpeg.c.

Referenced by JPEG_LoadImage_BGRA(), JPEG_SaveImage_preflipped(), and JPEG_SaveImage_to_Buffer().

qjpeg_write_scanlines

JDIMENSION(* qjpeg_write_scanlines) (j_compress_ptr cinfo, unsigned char **scanlines, JDIMENSION num_lines) ( j_compress_ptr cinfo, unsigned char ** scanlines, JDIMENSION num_lines )

static

Definition at line 432 of file jpeg.c.

Referenced by JPEG_SaveImage_preflipped(), and JPEG_try_SaveImage_to_Buffer().

r_texture_jpeg_fastpicmip

cvar_t r_texture_jpeg_fastpicmip = {CF_CLIENT | CF_ARCHIVE, "r_texture_jpeg_fastpicmip", "1", "perform gl_picmip during decompression for JPEG files (faster)"}

Definition at line 32 of file jpeg.c.

{CF_CLIENT | CF_ARCHIVE, "r_texture_jpeg_fastpicmip", "1", "perform gl_picmip during decompression for JPEG files (faster)"};

Referenced by Host_InitLocal(), and JPEG_LoadImage_BGRA().

sv_writepicture_quality

cvar_t sv_writepicture_quality

extern

Definition at line 219 of file sv_main.c.

{CF_SERVER | CF_ARCHIVE, "sv_writepicture_quality", "10", "WritePicture quality offset (higher means better quality, but slower)"};

Referenced by JPEG_SaveImage_to_Buffer(), and SV_Init().