476 lines
14 KiB
C++
476 lines
14 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "jpegloader.h"
|
|
#include "tier0/dbg.h"
|
|
#include "tier1/utlvector.h"
|
|
#include "tier0/vprof.h"
|
|
#include "jpeglib/jpeglib.h"
|
|
#include <setjmp.h>
|
|
//#include "fileio.h"
|
|
|
|
class CFileWriter
|
|
{
|
|
|
|
};
|
|
|
|
class CJpegDestMgr : public jpeg_destination_mgr
|
|
{
|
|
public:
|
|
CJpegDestMgr( CFileWriter &refOutputFileWriter )
|
|
: m_pOutputFileWriter( &refOutputFileWriter ),
|
|
m_pOutputBuffer( NULL )
|
|
{
|
|
Init();
|
|
}
|
|
|
|
CJpegDestMgr( CUtlBuffer &refOutputBuffer )
|
|
: m_pOutputFileWriter( NULL ),
|
|
m_pOutputBuffer( &refOutputBuffer )
|
|
{
|
|
Init();
|
|
}
|
|
|
|
void Init()
|
|
{
|
|
this->init_destination = &CJpegDestMgr::imp_init_dest;
|
|
this->empty_output_buffer = &CJpegDestMgr::imp_empty_output_buffer;
|
|
this->term_destination = &CJpegDestMgr::imp_term_destination;
|
|
|
|
this->next_output_byte = 0;
|
|
this->free_in_buffer = 0;
|
|
}
|
|
|
|
static void imp_init_dest( j_compress_ptr cinfo )
|
|
{
|
|
CJpegDestMgr *pInstance = (CJpegDestMgr*)cinfo->dest;
|
|
|
|
if ( pInstance->m_pOutputBuffer )
|
|
pInstance->m_pOutputBuffer->EnsureCapacity( cinfo->image_width*cinfo->image_height*3 );
|
|
|
|
const int k_cubMaxTempJpegBuffer = 1024*10;
|
|
int cubBufferSize = MIN( cinfo->image_width*cinfo->image_height*3, k_cubMaxTempJpegBuffer );
|
|
pInstance->m_Buffer.EnsureCapacity( cubBufferSize );
|
|
pInstance->free_in_buffer = pInstance->m_Buffer.Size();
|
|
pInstance->next_output_byte = (JOCTET*)pInstance->m_Buffer.Base();
|
|
}
|
|
|
|
static boolean imp_empty_output_buffer( j_compress_ptr cinfo )
|
|
{
|
|
/*
|
|
CJpegDestMgr *pInstance = (CJpegDestMgr*)cinfo->dest;
|
|
|
|
// Write the entire buffer, ignoring next_output_byte and free_in_buffer as they lie (see docs)
|
|
if ( pInstance->m_pOutputFileWriter )
|
|
pInstance->m_pOutputFileWriter->Write( pInstance->m_Buffer.Base(), pInstance->m_Buffer.Size() );
|
|
else
|
|
pInstance->m_pOutputBuffer->Put( pInstance->m_Buffer.Base(), pInstance->m_Buffer.Size() );
|
|
|
|
pInstance->free_in_buffer = pInstance->m_Buffer.Size();
|
|
pInstance->next_output_byte = (JOCTET*)pInstance->m_Buffer.Base();
|
|
*/
|
|
return true;
|
|
}
|
|
|
|
|
|
static void imp_term_destination(j_compress_ptr cinfo)
|
|
{
|
|
/*
|
|
CJpegDestMgr *pInstance = (CJpegDestMgr*)cinfo->dest;
|
|
|
|
// next_output_byte and free_in_buffer don't lie here like in empty_output_buffer
|
|
int cubToWrite = (byte*)pInstance->next_output_byte - (byte*)pInstance->m_Buffer.Base();
|
|
if ( cubToWrite > 0 )
|
|
{
|
|
if ( pInstance->m_pOutputFileWriter )
|
|
pInstance->m_pOutputFileWriter->Write( pInstance->m_Buffer.Base(), cubToWrite );
|
|
else
|
|
pInstance->m_pOutputBuffer->Put( pInstance->m_Buffer.Base(), cubToWrite );
|
|
}
|
|
|
|
if ( pInstance->m_pOutputFileWriter )
|
|
pInstance->m_pOutputFileWriter->Flush();
|
|
*/
|
|
}
|
|
|
|
static void error_exit( j_common_ptr cptr )
|
|
{
|
|
longjmp( m_JmpBuf, 1 );
|
|
}
|
|
|
|
static jmp_buf m_JmpBuf;
|
|
|
|
private:
|
|
CFileWriter *m_pOutputFileWriter;
|
|
CUtlBuffer *m_pOutputBuffer;
|
|
CUtlBuffer m_Buffer;
|
|
};
|
|
|
|
jmp_buf CJpegDestMgr::m_JmpBuf;
|
|
|
|
|
|
class CJpegSourceMgr : public jpeg_source_mgr
|
|
{
|
|
public:
|
|
CJpegSourceMgr()
|
|
{
|
|
this->init_source = &CJpegSourceMgr::imp_init_source;
|
|
this->fill_input_buffer = &CJpegSourceMgr::imp_fill_input_buffer;
|
|
this->skip_input_data = &CJpegSourceMgr::imp_skip_input_data;
|
|
this->resync_to_restart = &CJpegSourceMgr::imp_resync_to_restart;
|
|
this->term_source = &CJpegSourceMgr::imp_term_source;
|
|
|
|
this->next_input_byte = 0;
|
|
this->bytes_in_buffer = 0;
|
|
}
|
|
|
|
bool Init( const byte *pubData, int cubData )
|
|
{
|
|
m_Data.AddMultipleToTail( cubData, (char *)pubData );
|
|
bytes_in_buffer = m_Data.Count();
|
|
next_input_byte = (unsigned char*)m_Data.Base();
|
|
return true;
|
|
}
|
|
|
|
static void imp_init_source(j_decompress_ptr cinfo)
|
|
{
|
|
// We handled everything needed in our own Init() call.
|
|
}
|
|
|
|
static boolean imp_fill_input_buffer(j_decompress_ptr cinfo)
|
|
{
|
|
// If this is hit it means we are reading a corrupt file. We can't provide more data
|
|
// as we provided all of it upfront already.
|
|
return 0;
|
|
}
|
|
|
|
static void imp_skip_input_data(j_decompress_ptr cinfo, long num_bytes)
|
|
{
|
|
// The library is asking us to skip a chunk of data, usually exif header data or such. Need
|
|
// to actually do that. The library tries to be robust and skip obviously bad data on its own
|
|
// one byte at a time as well, but faster here, and safer as the library can't always do it
|
|
// correctly if we fail these calls.
|
|
CJpegSourceMgr *pInstance = (CJpegSourceMgr*)cinfo->src;
|
|
pInstance->bytes_in_buffer -= num_bytes;
|
|
pInstance->next_input_byte += num_bytes;
|
|
}
|
|
|
|
static boolean imp_resync_to_restart(j_decompress_ptr cinfo, int desired)
|
|
{
|
|
// This happens if the library fails to find a resync marker where expected, we'll then
|
|
// use it's default handler. This handler will skip ahead trying to find the next point,
|
|
// we could maybe do better going backwards as we have the full buffer, but that's lots more
|
|
// work and this will only get hit on a partially corrupt image anyway.
|
|
return jpeg_resync_to_restart( cinfo, desired );
|
|
}
|
|
|
|
static void imp_term_source(j_decompress_ptr cinfo)
|
|
{
|
|
}
|
|
|
|
static void error_exit( j_common_ptr cptr )
|
|
{
|
|
longjmp( m_JmpBuf, 1 );
|
|
}
|
|
|
|
static jmp_buf m_JmpBuf;
|
|
|
|
public:
|
|
CUtlVector<char> m_Data;
|
|
};
|
|
|
|
jmp_buf CJpegSourceMgr::m_JmpBuf;
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: returns the dimensions of a jpg file from it's contents
|
|
//-----------------------------------------------------------------------------
|
|
bool GetJpegDimensions( const byte *pubData, int cubData, uint32 &width, uint32 &height )
|
|
{
|
|
CJpegSourceMgr sourceMgr;
|
|
bool bRet = sourceMgr.Init( pubData, cubData );
|
|
if ( !bRet )
|
|
return false;
|
|
|
|
// Load the jpeg.
|
|
struct jpeg_decompress_struct jpegInfo;
|
|
struct jpeg_error_mgr jerr;
|
|
|
|
memset( &jpegInfo, 0, sizeof( jpegInfo ) );
|
|
jpegInfo.err = jpeg_std_error(&jerr);
|
|
jerr.error_exit = &CJpegSourceMgr::error_exit;
|
|
jpeg_create_decompress(&jpegInfo);
|
|
jpegInfo.src = &sourceMgr;
|
|
|
|
if ( setjmp( sourceMgr.m_JmpBuf ) == 1 )
|
|
{
|
|
jpeg_destroy_decompress(&jpegInfo);
|
|
return false;
|
|
}
|
|
|
|
if (jpeg_read_header(&jpegInfo, TRUE) != JPEG_HEADER_OK)
|
|
{
|
|
jpeg_destroy_decompress(&jpegInfo);
|
|
return false;
|
|
}
|
|
|
|
width = jpegInfo.image_width;
|
|
height = jpegInfo.image_height;
|
|
|
|
jpeg_destroy_decompress(&jpegInfo);
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: takes the contents of a .jpg file and turns it into RGB data, returning the width and height and optionally the number of bytes used
|
|
//-----------------------------------------------------------------------------
|
|
bool ConvertJpegToRGB( const byte *pubData, int cubData, CUtlVector<byte> &buf, int &width, int &height, int *pcubUsed )
|
|
{
|
|
CJpegSourceMgr sourceMgr;
|
|
bool bRet = sourceMgr.Init( pubData, cubData );
|
|
if ( !bRet )
|
|
return false;
|
|
|
|
if ( pcubUsed )
|
|
*pcubUsed = 0;
|
|
|
|
sourceMgr.bytes_in_buffer = sourceMgr.m_Data.Count();
|
|
sourceMgr.next_input_byte = (unsigned char*)sourceMgr.m_Data.Base();
|
|
|
|
// Load the jpeg.
|
|
struct jpeg_decompress_struct jpegInfo;
|
|
struct jpeg_error_mgr jerr;
|
|
|
|
memset( &jpegInfo, 0, sizeof( jpegInfo ) );
|
|
jpegInfo.err = jpeg_std_error(&jerr);
|
|
jerr.error_exit = &CJpegSourceMgr::error_exit;
|
|
jpeg_create_decompress(&jpegInfo);
|
|
jpegInfo.src = &sourceMgr;
|
|
|
|
if ( setjmp( sourceMgr.m_JmpBuf ) == 1 )
|
|
{
|
|
jpeg_destroy_decompress(&jpegInfo);
|
|
return false;
|
|
}
|
|
|
|
if (jpeg_read_header(&jpegInfo, TRUE) != JPEG_HEADER_OK)
|
|
{
|
|
jpeg_destroy_decompress(&jpegInfo);
|
|
return false;
|
|
}
|
|
|
|
// start the decompress with the jpeg engine.
|
|
if ( !jpeg_start_decompress(&jpegInfo) || jpegInfo.output_components != 3)
|
|
{
|
|
jpeg_destroy_decompress(&jpegInfo);
|
|
return false;
|
|
}
|
|
|
|
// now that we've started the decompress with the jpeg lib, we have the attributes of the
|
|
// cdnfile ready to be read out of the decompress struct.
|
|
int row_stride = jpegInfo.output_width * jpegInfo.output_components;
|
|
int mem_required = jpegInfo.image_height * jpegInfo.image_width * jpegInfo.output_components;
|
|
JSAMPROW row_pointer[1];
|
|
int cur_row = 0;
|
|
|
|
width = jpegInfo.output_width;
|
|
height = jpegInfo.output_height;
|
|
|
|
// allocate the memory to read the cdnfile data into.
|
|
buf.SetSize( mem_required );
|
|
|
|
// read in all the scan lines of the cdnfile into our cdnfile data buffer.
|
|
bool working = true;
|
|
while (working && (jpegInfo.output_scanline < jpegInfo.output_height))
|
|
{
|
|
row_pointer[0] = &(buf[cur_row * row_stride]);
|
|
if ( !jpeg_read_scanlines(&jpegInfo, row_pointer, 1) )
|
|
{
|
|
working = false;
|
|
}
|
|
++cur_row;
|
|
}
|
|
|
|
if (!working)
|
|
{
|
|
jpeg_destroy_decompress(&jpegInfo);
|
|
return false;
|
|
}
|
|
|
|
if ( pcubUsed )
|
|
*pcubUsed = (int)((byte*)sourceMgr.next_input_byte - (byte*)sourceMgr.m_Data.Base());
|
|
jpeg_finish_decompress(&jpegInfo);
|
|
jpeg_destroy_decompress(&jpegInfo);
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Converts an RGB image to RGBA opacity will be 100%
|
|
//-----------------------------------------------------------------------------
|
|
void ConvertRGBToRGBAImage( CUtlVector<unsigned char> &srcData,
|
|
int srcWidth,
|
|
int srcHeight,
|
|
byte *destData,
|
|
int destWidth,
|
|
int destHeight )
|
|
{
|
|
int destPixelSize = 4;
|
|
int cub = destWidth * destHeight * destPixelSize;
|
|
byte *pSrc = srcData.Base();
|
|
for ( int i = 0; i < cub; i += 4 )
|
|
{
|
|
destData[i] = *pSrc++;
|
|
destData[i+1] = *pSrc++;
|
|
destData[i+2] = *pSrc++;
|
|
destData[i+3] = 255;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Converts raw Jpeg file data and converts to RGBA image buffer
|
|
//-----------------------------------------------------------------------------
|
|
bool ConvertJpegToRawInternal( const byte *pubJpegData, int cubJpegData, CUtlBuffer &bufOutput, int &width, int &height, int *pcubUsed, bool bMakeRGBA )
|
|
{
|
|
// Temporary buffer to decompress Jpeg into as RGB, since libjpeg doesn't do RGBA
|
|
CUtlVector<byte> vecRGB;
|
|
|
|
bool bConverted = false;
|
|
{
|
|
VPROF_BUDGET( "ConvertJpegToRGB", VPROF_BUDGETGROUP_OTHER_VGUI );
|
|
bConverted = ConvertJpegToRGB( pubJpegData, cubJpegData, vecRGB, width, height, pcubUsed );
|
|
}
|
|
|
|
if ( bConverted )
|
|
{
|
|
bufOutput.Clear();
|
|
|
|
int bytesPerPixel = 3;
|
|
if ( bMakeRGBA )
|
|
bytesPerPixel = 4;
|
|
|
|
// make sure the buffer is big enough to hold the cdnfile data
|
|
bufOutput.EnsureCapacity( width * height * bytesPerPixel );
|
|
|
|
// If the buffer was externally allocated the EnsureCapacity can fail
|
|
if ( bufOutput.Size() < width * height * bytesPerPixel )
|
|
return false;
|
|
|
|
bufOutput.SeekPut( CUtlBuffer::SEEK_HEAD, width*height*bytesPerPixel );
|
|
|
|
// convert RGB->RGBA, into the final buffer
|
|
if ( bMakeRGBA )
|
|
{
|
|
VPROF_BUDGET( "ConvertRGBToRGBAImage", VPROF_BUDGETGROUP_OTHER_VGUI );
|
|
ConvertRGBToRGBAImage( vecRGB, width, height, (byte *)bufOutput.Base(), width, height );
|
|
}
|
|
else
|
|
{
|
|
Q_memcpy( bufOutput.Base(), vecRGB.Base(), width*height*bytesPerPixel );
|
|
}
|
|
|
|
// done
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Converts raw Jpeg file data and converts to RGBA image buffer
|
|
//-----------------------------------------------------------------------------
|
|
bool ConvertJpegToRGBA( const byte *pubJpegData, int cubJpegData, CUtlBuffer &bufOutput, int &width, int &height, int *pcubUsed )
|
|
{
|
|
return ConvertJpegToRawInternal( pubJpegData, cubJpegData, bufOutput, width, height, pcubUsed, true );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Converts raw Jpeg file data and converts to RGB image buffer
|
|
//-----------------------------------------------------------------------------
|
|
bool ConvertJpegToRGB( const byte *pubJpegData, int cubJpegData, CUtlBuffer &bufOutput, int &width, int &height, int *pcubUsed )
|
|
{
|
|
return ConvertJpegToRawInternal( pubJpegData, cubJpegData, bufOutput, width, height, pcubUsed, false );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Internal method for converting RGB to Jpeg and writing either
|
|
// to disk or to an output buffer
|
|
//-----------------------------------------------------------------------------
|
|
bool ConvertRGBToJpegInternal( CJpegDestMgr &destMgr, int quality, int width, int height, CUtlBuffer &bufRGB )
|
|
{
|
|
struct jpeg_compress_struct cinfo = {0};
|
|
JSAMPROW row_ptr[1];
|
|
struct jpeg_error_mgr jerr;
|
|
|
|
cinfo.err = jpeg_std_error(&jerr);
|
|
jerr.error_exit = &CJpegDestMgr::error_exit;
|
|
jpeg_create_compress(&cinfo);
|
|
cinfo.dest = &destMgr;
|
|
|
|
if ( setjmp( destMgr.m_JmpBuf ) == 1 )
|
|
{
|
|
jpeg_destroy_compress(&cinfo);
|
|
return false;
|
|
}
|
|
|
|
cinfo.image_width = width;
|
|
cinfo.image_height = height;
|
|
cinfo.input_components = 3;
|
|
cinfo.in_color_space = JCS_RGB;
|
|
|
|
jpeg_set_defaults( &cinfo );
|
|
cinfo.dct_method = JDCT_FLOAT;
|
|
jpeg_set_quality(&cinfo, quality, TRUE);
|
|
|
|
jpeg_start_compress( &cinfo, TRUE );
|
|
|
|
byte *rawBytes = (byte*)bufRGB.Base();
|
|
while( cinfo.next_scanline < cinfo.image_height )
|
|
{
|
|
row_ptr[0] = (unsigned char *)rawBytes+(width*3*cinfo.next_scanline);
|
|
jpeg_write_scanlines( &cinfo, row_ptr, 1 );
|
|
}
|
|
|
|
jpeg_finish_compress( &cinfo );
|
|
jpeg_destroy_compress( &cinfo );
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Takes a RGB buffer and writes it to disk as a Jpeg
|
|
// Params: qualtity should be 0-100, where 100 is best quality. 80 is generally
|
|
// a good value.
|
|
//-----------------------------------------------------------------------------
|
|
bool ConvertRGBToJpeg( const char *pchFileOut, int quality, int width, int height, CUtlBuffer &bufRGB )
|
|
{
|
|
/*
|
|
CFileWriter fileWriter;
|
|
if ( !fileWriter.BSetFile( pchFileOut ) )
|
|
return false;
|
|
|
|
CJpegDestMgr destMgr( fileWriter );
|
|
return ConvertRGBToJpegInternal( destMgr, quality, width, height, bufRGB );
|
|
*/
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Takes a RGB buffer and writes it to a buffer as a jpeg
|
|
// Params: qualtity should be 0-100, where 100 is best quality. 80 is generally
|
|
// a good value.
|
|
//-----------------------------------------------------------------------------
|
|
bool ConvertRGBToJpeg( CUtlBuffer &bufOutput, int quality, int width, int height, CUtlBuffer &bufRGB )
|
|
{
|
|
CJpegDestMgr destMgr( bufOutput );
|
|
return ConvertRGBToJpegInternal( destMgr, quality, width, height, bufRGB );
|
|
} |