CWE-ou-minkata/Sources/Plasma/PubUtilLib/plJPEG/plJPEG.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

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

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  plJPEG - JPEG Codec Wrapper for Plasma                                   //
//  Cyan, Inc.                                                               //
//                                                                           //
//// Version History //////////////////////////////////////////////////////////
//                                                                           //
//  2.1.2002 mcn - Created.                                                  //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include "hsTypes.h"
#include "plJPEG.h"
#include "hsStream.h"
#include "hsExceptions.h"
#include "hsUtils.h"
#include "plGImage/plMipmap.h"

#include <jpeglib.h>
#include <jerror.h>

//// Local Statics ////////////////////////////////////////////////////////////
//  Done this way so we don't have to declare them in the .h file and pull in
//  the platform-specific library

// It is not thread-safe to use a static char buffer, but it wasn't really
// thread-safe to use a static int either. The char buffer is slightly
// worse since you could get mangled strings instead of just a stale error.
static char jpegmsg[JMSG_LENGTH_MAX];

// jpeglib error handlers
static void plJPEG_error_exit( j_common_ptr cinfo )
{
    (*cinfo->err->format_message) ( cinfo, jpegmsg );
    throw ( false );
}
static void plJPEG_emit_message( j_common_ptr cinfo, int msg_level )
{
    // log NOTHING
}
static void clear_jpegmsg()
{
    // "Success" is what IJL produced for no error
    strcpy( jpegmsg, "Success" );
}


//// Instance /////////////////////////////////////////////////////////////////

plJPEG  &plJPEG::Instance( void )
{
    clear_jpegmsg();

    static plJPEG   theInstance;
    return theInstance;
}

//// GetLastError /////////////////////////////////////////////////////////////

const char  *plJPEG::GetLastError( void )
{
    return jpegmsg;
}

//// IRead ////////////////////////////////////////////////////////////////////
//  Given an open hsStream (or a filename), reads the JPEG data off of the 
//  stream and decodes it into a new plMipmap. The mipmap's buffer ends up 
//  being a packed RGBx buffer, where x is 8 bits of unused alpha (go figure 
//  that JPEG images can't store alpha, or even if they can, IJL certainly 
//  doesn't know about it).
//  Returns a pointer to the new mipmap if successful, nil otherwise.
//  Note: more or less lifted straight out of the IJL documentation, with
//  some changes to fit Plasma coding style and formats.

plMipmap    *plJPEG::IRead( hsStream *inStream )
{
    MemPushDisableTracking();

    plMipmap    *newMipmap = nil;
    UInt8       *jpegSourceBuffer = nil;
    UInt32      jpegSourceSize;
    
    struct jpeg_decompress_struct   cinfo;
    struct jpeg_error_mgr       jerr;


    clear_jpegmsg();
    cinfo.err = jpeg_std_error( &jerr );
    jerr.error_exit = plJPEG_error_exit;
    jerr.emit_message = plJPEG_emit_message;

    try
    {
        jpeg_create_decompress( &cinfo );

        /// Read in the JPEG header
        if ( inStream->GetEOF() == 0 )
            throw( false );

        /// Wonderful limitation of mixing our streams with IJL--it wants either a filename
        /// or a memory buffer. Since we can't give it the former, we have to read the entire
        /// JPEG stream into a separate buffer before we can decode it. Which means we ALSO
        /// have to write/read a length of said buffer. Such is life, I guess...
        jpegSourceSize = inStream->ReadSwap32();
        jpegSourceBuffer = TRACKED_NEW UInt8[ jpegSourceSize ];
        if( jpegSourceBuffer == nil )
        {
            // waah.
            ERREXIT1( &cinfo, JERR_OUT_OF_MEMORY, 0 );
        }

        inStream->Read( jpegSourceSize, jpegSourceBuffer );
        jpeg_mem_src( &cinfo, jpegSourceBuffer, jpegSourceSize );
        (void) jpeg_read_header( &cinfo, TRUE );

        /// So we got lots of data to play with now. First, set the JPEG color
        /// space to read in from/as...
        /// From the IJL code:
        // "Set the JPG color space ... this will always be
        // somewhat of an educated guess at best because JPEG
        // is "color blind" (i.e., nothing in the bit stream
        // tells you what color space the data was encoded from).
        // However, in this example we assume that we are
        // reading JFIF files which means that 3 channel images
        // are in the YCbCr color space and 1 channel images are
        // in the Y color space."

        switch( cinfo.jpeg_color_space )
        {
            case JCS_GRAYSCALE:
            case JCS_YCbCr:
                cinfo.out_color_space = JCS_RGB;
                break;

            default:
                // We should probably assert here, since we're pretty sure we WON'T get ARGB. <sigh>
                hsAssert( false, "Unknown JPEG stream format in ReadFromStream()" );
                cinfo.out_color_space = JCS_UNKNOWN;
                break;
        }

        (void) jpeg_start_decompress( &cinfo );

        /// Construct a new mipmap to hold everything
        newMipmap = TRACKED_NEW plMipmap( cinfo.output_width, cinfo.output_height, plMipmap::kRGB32Config, 1, plMipmap::kJPEGCompression );

        if( newMipmap == nil || newMipmap->GetImage() == nil )
        {
            ERREXIT1( &cinfo, JERR_OUT_OF_MEMORY, 0 );
        }

        /// Set up to read in to that buffer we now have
        JSAMPROW jbuffer;
        int row_stride = cinfo.output_width * cinfo.output_components;
        int out_stride = cinfo.output_width * 4;  // Decompress to RGBA
        jbuffer = TRACKED_NEW JSAMPLE[row_stride];

        UInt8 *destp = (UInt8 *)newMipmap->GetImage();
        while( cinfo.output_scanline < cinfo.output_height )
        {
            (void) jpeg_read_scanlines( &cinfo, &jbuffer, 1 );
            (void) memset( destp, 0xFF, out_stride );
            
            for( size_t pixel = 0; pixel < cinfo.output_width; ++pixel )
            {
                (void) memcpy( destp + (pixel * 4),
                               jbuffer + (pixel * cinfo.output_components),
                               cinfo.out_color_components );
            }

            destp += out_stride;
        }

        (void) jpeg_finish_decompress(&cinfo);
        delete [] jbuffer;

        // Sometimes life just sucks
        ISwapRGBAComponents( (UInt32 *)newMipmap->GetImage(), newMipmap->GetWidth() * newMipmap->GetHeight() );
    }
    catch( ... )
    {
        delete newMipmap;
        newMipmap = nil;
    }

    // Cleanup
    delete [] jpegSourceBuffer;

    // Clean up the JPEG Library
    jpeg_destroy_decompress( &cinfo );
    MemPopDisableTracking();

    // All done!
    return newMipmap;
}

plMipmap*   plJPEG::ReadFromFile( const char *fileName )
{
    wchar* wFilename = hsStringToWString(fileName);
    plMipmap* retVal = ReadFromFile(wFilename);
    delete [] wFilename;
    return retVal;
}

plMipmap*   plJPEG::ReadFromFile( const wchar *fileName )
{
    // we use a stream because the IJL can't handle unicode
    hsRAMStream tempstream;
    hsUNIXStream in;
    if (!in.Open(fileName, L"rb"))
        return false;

    // The stream reader for JPEGs expects a 32-bit size at the start,
    // so insert that into the stream before passing it on
    in.FastFwd();
    UInt32 fsize = in.GetPosition();
    UInt8 *tempbuffer = TRACKED_NEW UInt8[fsize];
    in.Rewind();
    in.Read(fsize, tempbuffer);
    tempstream.WriteSwap32(fsize);
    tempstream.Write(fsize, tempbuffer);
    delete [] tempbuffer;
    tempstream.Rewind();

    plMipmap* ret = IRead(&tempstream);
    in.Close();
    return ret;
}

//// IWrite ///////////////////////////////////////////////////////////////////
//  Oh, figure it out yourself. :P

hsBool  plJPEG::IWrite( plMipmap *source, hsStream *outStream )
{
    hsBool  result = true, swapped = false;
    UInt8   *jpgBuffer = nil;
    UInt32  jpgBufferSize = 0;

    struct jpeg_compress_struct cinfo;
    struct jpeg_error_mgr       jerr;


    clear_jpegmsg();
    cinfo.err = jpeg_std_error( &jerr );
    jerr.error_exit = plJPEG_error_exit;
    jerr.emit_message = plJPEG_emit_message;

    try
    {
        jpeg_create_compress( &cinfo );

        // Create a buffer to hold the data
        jpgBufferSize = source->GetWidth() * source->GetHeight() * 3;
        jpgBuffer = TRACKED_NEW UInt8[ jpgBufferSize ];
        if( jpgBuffer == nil )
        {
            ERREXIT1( &cinfo, JERR_OUT_OF_MEMORY, 0 );
        }

        UInt8 *bufferAddr = jpgBuffer;
        UInt32 bufferSize = jpgBufferSize;
        jpeg_mem_dest( &cinfo, &bufferAddr, &bufferSize );

        cinfo.image_width = source->GetWidth();
        cinfo.image_height = source->GetHeight();
        cinfo.input_components = 3;
        cinfo.in_color_space = JCS_RGB;

        jpeg_set_defaults( &cinfo );

        cinfo.jpeg_width = source->GetWidth(); // default
        cinfo.jpeg_height = source->GetHeight(); // default
        cinfo.jpeg_color_space = JCS_YCbCr; // default
        // not sure how to set 4:1:1 but supposedly it's the default
        jpeg_set_quality( &cinfo, fWriteQuality, TRUE );

        jpeg_start_compress( &cinfo, TRUE );

        // Sometimes life just sucks
        ISwapRGBAComponents( (UInt32 *)source->GetImage(), source->GetWidth() * source->GetHeight() );
        swapped = true;

        // Write it!
        JSAMPROW jbuffer;
        int in_stride = cinfo.image_width * 4;  // Input is always RGBA
        int row_stride = cinfo.image_width * cinfo.input_components;
        jbuffer = TRACKED_NEW JSAMPLE[row_stride];

        UInt8 *srcp = (UInt8 *)source->GetImage();
        while( cinfo.next_scanline < cinfo.image_height )
        {
            for( size_t pixel = 0; pixel < cinfo.image_width; ++pixel )
            {
                (void) memcpy( jbuffer + (pixel * cinfo.input_components),
                               srcp + (pixel * 4), cinfo.input_components );
            }

            (void) jpeg_write_scanlines( &cinfo, &jbuffer, 1 );
            srcp += in_stride;
        }

        jpeg_finish_compress( &cinfo );
        delete [] jbuffer;

        // jpeglib changes bufferSize and bufferAddr
        outStream->WriteSwap32( bufferSize );
        outStream->Write( bufferSize, bufferAddr );
    }
    catch( ... )
    {
        result = false;
    }

    // Cleanup
    if ( jpgBuffer )
        delete [] jpgBuffer;
    jpeg_destroy_compress( &cinfo );

    if( swapped )
        ISwapRGBAComponents( (UInt32 *)source->GetImage(), source->GetWidth() * source->GetHeight() );

    return result;
}

hsBool  plJPEG::WriteToFile( const char *fileName, plMipmap *sourceData )
{
    wchar* wFilename = hsStringToWString(fileName);
    hsBool retVal = WriteToFile(wFilename, sourceData);
    delete [] wFilename;
    return retVal;
}

hsBool  plJPEG::WriteToFile( const wchar *fileName, plMipmap *sourceData )
{
    // we use a stream because the IJL can't handle unicode
    hsRAMStream tempstream;
    hsUNIXStream out;
    if (!out.Open(fileName, L"wb"))
        return false;
    hsBool ret = IWrite(sourceData, &tempstream);
    if (ret)
    {
        // The stream writer for JPEGs prepends a 32-bit size,
        // so remove that from the stream before saving to a file
        tempstream.Rewind();
        UInt32 fsize = tempstream.ReadSwap32();
        UInt8 *tempbuffer = TRACKED_NEW UInt8[fsize];
        tempstream.Read(fsize, tempbuffer);
        out.Write(fsize, tempbuffer);

        delete [] tempbuffer;
    }
    out.Close();
    return ret;
}

//// ISwapRGBAComponents //////////////////////////////////////////////////////

void    plJPEG::ISwapRGBAComponents( UInt32 *data, UInt32 count )
{
    while( count-- )
    {
        *data = ( ( ( *data ) & 0xff00ff00 )       ) |
                ( ( ( *data ) & 0x00ff0000 ) >> 16 ) |
//              ( ( ( *data ) & 0x0000ff00 ) << 8 ) |
                ( ( ( *data ) & 0x000000ff ) << 16 );
        data++;
    }
}