root/lang/c/SDL_image_save/trunk/IMGS_jpg.c @ 29324

/*
    SDL_image_save:  An example image saving library for use with SDL
    Copyright (C) 2005 cielacanth. All rights reserved.

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    cielacanth
    cielacanth@s60.xrea.com
*/

/* A simple library to save images of various formats as SDL surfaces */

#include "SDL_image_save.h"

#include <setjmp.h>
#include "libjpeg/jpeglib.h"

/* This code assumes that sizeof(JSAMPLE) is 8 bit */
#if BITS_IN_JSAMPLE != 8
#error "IMGS_jpg : this code assumes that sizeof(JSAMPLE) is 8 bit"
#endif

/* Buffering size */
#define OUTPUT_BUFFER_SIZE      4096

/* Image destination struct */
struct imgs_destination_mgr {
        struct jpeg_destination_mgr pub;

        SDL_RWops *ops;
        Uint8 buffer[OUTPUT_BUFFER_SIZE];
};

/* Initialize destination, called by jpeg_start_compress
 * before any data is actually written. 
 */
static void jpg_init_destination(j_compress_ptr cinfo)
{
        struct imgs_destination_mgr *dest = (struct imgs_destination_mgr *) cinfo->dest;
        dest->pub.next_output_byte      = dest->buffer;
        dest->pub.free_in_buffer        = OUTPUT_BUFFER_SIZE;
}

/* Write JPEG bytes to a data stream */
static boolean jpg_empty_output_buffer(j_compress_ptr cinfo)
{
        struct imgs_destination_mgr *dest = (struct imgs_destination_mgr *) cinfo->dest;
        int size;

        /* Output data to data stream */
        size = SDL_RWwrite(dest->ops, dest->buffer, 1, OUTPUT_BUFFER_SIZE);
        if (size != OUTPUT_BUFFER_SIZE) {
                /* Error has occured while writing a data */
                IMGS_SetError("IMGS_jpg.c: Error has occured while writing a data");
                return FALSE;
        }

        /* Reset buffer */
        dest->pub.next_output_byte = dest->buffer;
        dest->pub.free_in_buffer = OUTPUT_BUFFER_SIZE;
        return TRUE;
}

/* Terminate destination, called by jpeg_finish_compress
 * after all data has been written.
 */
static void jpg_term_destination(j_compress_ptr cinfo)
{
        struct imgs_destination_mgr *dest = (struct imgs_destination_mgr *) cinfo->dest;
        int size = OUTPUT_BUFFER_SIZE - dest->pub.free_in_buffer;

        /* Output data to data stream */
        SDL_RWwrite(dest->ops, dest->buffer, 1, size);
}

/* Error handler struct */
struct imgs_error_mgr {
        struct jpeg_error_mgr err;
        jmp_buf escape;
};

/* Called if error has occured */
static void jpg_error_exit(j_common_ptr cinfo)
{
        struct imgs_error_mgr *err = (struct imgs_error_mgr *)cinfo->err;
        longjmp(err->escape, 1);
}

/* Output no message */
static void jpg_output_no_message(j_common_ptr cinfo)
{
        /* do nothing */
}

/* Return the number of a true bit in a bit mask */
static int jpg_get_number_of_bits(Uint32 bit_mask)
{
        int count = 0;

        while ( bit_mask != 0 ) {
                bit_mask &= bit_mask - 1;
                ++count;
        }
        return count;
}

/* Make a colormap.
 * Colormap is a convert table of one color channel
 * from bits bpp to 8bpp.
 */
static void jpg_make_colormap(int bits, JSAMPROW colormap)
{
        int i_max = (1 << bits) - 1;
        int i;

        if ( i_max == 0 ) return;

        for ( i = 0; i <= i_max; ++i ) {
                float val = 255.0f * (float)i / i_max;

                /* Add 0.5 to round off */
                int c = (int) (val + 0.5f);
                if ( c > 255 ) c = 255;
                colormap[i] = c;
        }
}

/* Save a SDL surface to a source data */
int IMGS_SaveJPG_RW(SDL_Surface* surface, SDL_RWops* ops)
{
        struct jpeg_compress_struct     cinfo;
        struct imgs_error_mgr           jerr;

        const SDL_PixelFormat *fmt      = surface->format;
        const Uint32 surface_pitch      = surface->pitch;
        const Uint32 width      = surface->w;
        const Uint32 height     = surface->h;
        const Uint32 Rmask      = fmt->Rmask;
        const Uint32 Gmask      = fmt->Gmask;
        const Uint32 Bmask      = fmt->Bmask;
        const Uint32 Amask      = fmt->Amask;
        const Uint32 Rshift     = fmt->Rshift;
        const Uint32 Gshift     = fmt->Gshift;
        const Uint32 Bshift     = fmt->Bshift;
        const Uint32 Ashift     = fmt->Ashift;

        JSAMPROW        row_pointer = NULL;
        Uint32          row_bytes;
        int                     error_code = 0;

        /* Check whether opt is valid or not */
        if ( ops == NULL ) {
                /* The error message has been set in SDL_RWFromFile */
                return 1;
        }

        /* Initialize error struct */
        cinfo.err = jpeg_std_error(&jerr.err);
        jerr.err.error_exit             = jpg_error_exit;
        jerr.err.output_message = jpg_output_no_message;

        /* Set error handler */
        if( setjmp(jerr.escape) != 0 ) {
                /* If we get here, libjpeg found an error */
                IMGS_SetError("IMGS_jpg.c: JPEG loading error");
                error_code = 2;
                goto done;
        }

        /* Create a JPEG struct */
        jpeg_create_compress(&cinfo);

        /* Setup image header */
        cinfo.image_width               = width;
        cinfo.image_height              = height;
        cinfo.input_components  = 3;
        cinfo.in_color_space    = JCS_RGB;

        /* Setup cinfo by default parameters */
        jpeg_set_defaults(&cinfo);

        /* Ranges of quality are 1...100,  default is 75. */
        jpeg_set_quality(&cinfo, 75, TRUE /* force base_line */);

        /* Allocate jpeg_destination_mgr in a JPEG struct */
        cinfo.dest = (struct jpeg_destination_mgr *)
                (*cinfo.mem->alloc_small) ((j_common_ptr) &cinfo, JPOOL_PERMANENT,
                                                                   sizeof(struct imgs_destination_mgr));

        if ( cinfo.dest == NULL ) {
                IMGS_SetError("IMGS_jpg.c: Out of memory");
                error_code = 5;
                goto done;
        }
        else {
                /* Initialize jpeg_destination_mgr in a JPEG struct */
                struct imgs_destination_mgr     *dest;

                dest = (struct imgs_destination_mgr *) cinfo.dest;
                dest->pub.init_destination              = jpg_init_destination;
                dest->pub.term_destination              = jpg_term_destination;
                dest->pub.empty_output_buffer   = jpg_empty_output_buffer;
                dest->ops = ops;
                dest->pub.free_in_buffer = 0; /* forces empty_output_buffer on first read */
                dest->pub.next_output_byte = NULL; /* until buffer loaded */
        }

        /* Allocate a row memory to convert data representation.
         * Libjpeg excepts RGB888 pixel format.
         */
        row_bytes       = width * 3;
        row_pointer     = (JSAMPROW)
                (*cinfo.mem->alloc_large)((j_common_ptr) &cinfo, JPOOL_PERMANENT, row_bytes);
        if ( row_pointer == NULL ) {
                IMGS_SetError("IMGS_jpg.c: Out of memory");
                error_code = 6;
                goto done;
        }

        /* Start compresion */
        jpeg_start_compress(&cinfo, TRUE);

        /* Libjpeg excepts RGB888 pixel format */
        switch ( fmt->BytesPerPixel ) {
        case 1: {
                SDL_Palette *palette = fmt->palette;
                Uint8           *pixels = (Uint8 *) surface->pixels;

                while ( cinfo.next_scanline < height ) {
                        Uint32 x;
                        for ( x = 0; x < width; ++x ) {
                                SDL_Color *col = &palette->colors[pixels[x]];
                                row_pointer[x * 3 + 0] = col->r;
                                row_pointer[x * 3 + 1] = col->g;
                                row_pointer[x * 3 + 2] = col->b;
                        }
                        pixels += surface_pitch;

                        /* Write data */
                        jpeg_write_scanlines(&cinfo, &row_pointer, 1);
                }
                }
                break;

        case 2: {
                Uint8 *pixels = (Uint8 *) surface->pixels;
                JSAMPLE colormap[3][256];       /* colormap for rgb */

                /* Setup colormap for each rgb component */
                jpg_make_colormap(jpg_get_number_of_bits(Rmask), colormap[0]);
                jpg_make_colormap(jpg_get_number_of_bits(Gmask), colormap[1]);
                jpg_make_colormap(jpg_get_number_of_bits(Bmask), colormap[2]);

                while ( cinfo.next_scanline < height ) {
                        Uint32 x;
                        for ( x = 0; x < width; ++x ) {
                                Uint16 c = *(Uint16 *) &pixels[x * 2];
                                row_pointer[x * 3 + 0] = colormap[0][(c & Rmask) >> Rshift];
                                row_pointer[x * 3 + 1] = colormap[1][(c & Gmask) >> Gshift];
                                row_pointer[x * 3 + 2] = colormap[2][(c & Bmask) >> Bshift];
                        }
                        pixels += surface_pitch;

                        /* Write data */
                        jpeg_write_scanlines(&cinfo, &row_pointer, 1);
                }
                }
                break;

        case 3: {
                Uint8 *pixels = (Uint8 *) surface->pixels;

                /* Pixel format for 24bpp is usually RRGGBB or BBGGRR. */
                if ( Rmask == 0x0000FF && Gmask == 0x00FF00 && Bmask == 0xFF0000 ) {
                        while ( cinfo.next_scanline < height ) {
                                /* Write data directly */
                                jpeg_write_scanlines(&cinfo, &pixels, 1);
                                pixels += surface_pitch;
                        }
                }
                else {
                        while ( cinfo.next_scanline < height ) {
                                Uint32 x;
                                for ( x = 0; x < row_bytes; x += 3 ) {
                                        Uint32 c = (pixels[x + 2] << 16) | (pixels[x + 1] << 8) | (pixels[x + 0] << 0);
                                        row_pointer[x + 0] = (c & Rmask) >> Rshift;
                                        row_pointer[x + 1] = (c & Gmask) >> Gshift;
                                        row_pointer[x + 2] = (c & Bmask) >> Bshift;
                                }
                                pixels += surface_pitch;

                                /* Write data */
                                jpeg_write_scanlines(&cinfo, &row_pointer, 1);
                        }
                }
                }
                break;

        case 4: {
                Uint8 *pixels = (Uint8 *) surface->pixels;

                while ( cinfo.next_scanline < height ) {
                        Uint32 x;
                        for ( x = 0; x < width; ++x ) {
                                Uint32 c = *(Uint32 *) &pixels[x * 4];
                                row_pointer[x * 3 + 0] = (c & Rmask) >> Rshift;
                                row_pointer[x * 3 + 1] = (c & Gmask) >> Gshift;
                                row_pointer[x * 3 + 2] = (c & Bmask) >> Bshift;
                        }
                        pixels += surface_pitch;

                        /* Write data */
                        jpeg_write_scanlines(&cinfo, &row_pointer, 1);
                }
                }
                break;

        default:
                IMGS_SetError("IMGS_jpg.c: Unknown pixel format");
                error_code = 8;
                goto done;
                break;
        }

        /* Finish compression */
        jpeg_finish_compress(&cinfo);

done:; /* Clean up code */

        /* This is an impotant step since it will release a good deal of memory */
        jpeg_destroy_compress(&cinfo);

        return error_code;
}