/** \brief Constructor.
*
* @param fd File handle to adapt.
* @param skip How many bytes of file have already been read
*/
PngWriter(FILE *fd) :
m_fd(fd),
m_png(NULL),
m_info(NULL)
{
m_png = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if(!m_png)
{
std::stringstream sstr;
sstr << "could not create a PNG read struct";
BOOST_THROW_EXCEPTION(std::runtime_error(sstr.str()));
}
m_info = png_create_info_struct(m_png);
if(!m_info)
{
std::stringstream sstr;
sstr << "could not create a PNG info struct";
BOOST_THROW_EXCEPTION(std::runtime_error(sstr.str()));
}
png_init_io(m_png, m_fd); // read header
png_set_compression_buffer_size(m_png, 8192);
png_set_compression_level(m_png, Z_BEST_COMPRESSION);
png_set_compression_mem_level(m_png, Z_BEST_COMPRESSION);
png_set_compression_window_bits(m_png, 15);
}
errort WritePNG( FILE * fp , unsigned char * data, unsigned int sizeX, unsigned int sizeY, int img_depth, int img_alpha)
{
png_structp png_ptr = png_create_write_struct
(PNG_LIBPNG_VER_STRING, (png_voidp)NULL,NULL,NULL);
if (!png_ptr)
return BadFormat;
png_infop info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return BadFormat;
}
if (setjmp(png_ptr->jmpbuf)) {
png_destroy_write_struct(&png_ptr, &info_ptr);
return BadFormat;
}
png_init_io(png_ptr, fp);
png_set_filter(png_ptr, 0, PNG_FILTER_NONE);
png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
/* set other zlib parameters */
png_set_compression_mem_level(png_ptr, 8);
png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);
png_set_compression_window_bits(png_ptr, 15);
png_set_compression_method(png_ptr, 8);
png_set_IHDR(png_ptr,
info_ptr,
sizeX,
sizeY,
img_depth,
img_alpha?PNG_COLOR_TYPE_RGB_ALPHA:PNG_COLOR_TYPE_RGB,
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_DEFAULT);
png_write_info(png_ptr, info_ptr);
# if __BYTE_ORDER != __BIG_ENDIAN
if (img_depth==16) {
png_set_swap(png_ptr);
}
#endif
int stride = (img_depth/8)*(img_alpha?4:3);
png_byte **row_pointers = new png_byte*[sizeY];
for (unsigned int i=0;i<sizeY;i++) {
row_pointers[i]= (png_byte *)&data[stride*i*sizeX];
}
png_write_image (png_ptr,row_pointers);
png_write_end(png_ptr, info_ptr);
png_write_flush(png_ptr);
png_destroy_write_struct(&png_ptr, &info_ptr);
//free (data);
delete [] row_pointers;
return Ok;
}
void png_write( const char *myfile, unsigned char *data, unsigned int width, unsigned int height, bool alpha, char bpp )
{
FILE *fp = VSFileSystem::vs_open( myfile, "wb" );
png_structp png_ptr = png_create_write_struct
( PNG_LIBPNG_VER_STRING, (png_voidp) NULL, NULL, NULL );
if (!png_ptr)
return;
png_infop info_ptr = png_create_info_struct( png_ptr );
if (!info_ptr) {
png_destroy_write_struct( &png_ptr, (png_infopp) NULL );
return;
}
if ( setjmp( png_ptr->jmpbuf ) ) {
png_destroy_write_struct( &png_ptr, &info_ptr );
VSFileSystem::vs_close( fp );
return;
}
png_init_io( png_ptr, fp );
png_set_filter( png_ptr, 0, PNG_FILTER_NONE );
png_set_compression_level( png_ptr, Z_BEST_COMPRESSION );
/* set other zlib parameters */
png_set_compression_mem_level( png_ptr, 8 );
png_set_compression_strategy( png_ptr, Z_DEFAULT_STRATEGY );
png_set_compression_window_bits( png_ptr, 15 );
png_set_compression_method( png_ptr, 8 );
png_set_IHDR( png_ptr,
info_ptr,
width,
height,
bpp,
alpha ? PNG_COLOR_TYPE_RGB_ALPHA : PNG_COLOR_TYPE_RGB,
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_DEFAULT );
png_write_info( png_ptr, info_ptr );
# if __BYTE_ORDER != __BIG_ENDIAN
if (bpp == 16)
png_set_swap( png_ptr );
#endif
int stride = (bpp/8)*(alpha ? 4 : 3);
png_byte **row_pointers = new png_byte*[height];
for (unsigned int i = 0; i < height; i++)
row_pointers[i] = (png_byte*) &data[stride*i*width];
png_write_image( png_ptr, row_pointers );
png_write_end( png_ptr, info_ptr );
png_write_flush( png_ptr );
png_destroy_write_struct( &png_ptr, &info_ptr );
VSFileSystem::vs_close( fp );
free( data );
delete[] row_pointers;
}
bool CPNGFile::Save(const char *szFilename)
{
// regular file saving - first, there has to be a buffer
if (!pImageData) return false;
// open the file
fp = fopen(szFilename, "wb"); if (!fp) return false;
// clear any previously initialized png-structs (e.g. by reading)
ClearPngStructs();
// reinit them for writing
fWriteMode=true;
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) { Clear(); return false; }
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) { Clear(); return false; }
// error handling
if (setjmp(png_jmpbuf(png_ptr))) { Clear(); return false; }
// io initialization
png_init_io(png_ptr, fp);
// compression stuff
png_set_filter(png_ptr, 0, PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_PAETH);
png_set_compression_level(png_ptr, Z_BEST_COMPRESSION);
png_set_compression_mem_level(png_ptr, 8);
png_set_compression_strategy(png_ptr, Z_DEFAULT_STRATEGY);
png_set_compression_window_bits(png_ptr, 15);
png_set_compression_method(png_ptr, 8);
// set header
png_set_IHDR(png_ptr, info_ptr, iWdt, iHgt, iBPC, iClrType, iIntrlcType, iCmprType, iFltrType);
// double-check our calculated row size
int iRealRowSize=png_get_rowbytes(png_ptr, info_ptr);
if (iRealRowSize != iRowSize)
{
// this won't go well, so better abort
Clear(); return false;
}
// write png header
png_write_info(png_ptr, info_ptr);
// image data is given as bgr...
png_set_bgr(png_ptr);
// create row array
unsigned char **ppRowBuf = new unsigned char *[iHgt];
unsigned char **ppRows=ppRowBuf; unsigned char *pRow=pImageData;
for (unsigned int i=0; i<iHgt; ++i,pRow+=iRowSize) *ppRows++=pRow;
// write image
png_write_image(png_ptr, ppRowBuf);
// free row buffer
delete [] ppRowBuf;
// write end struct
png_write_end(png_ptr, info_ptr);
// finally, close the file
fclose(fp); fp = NULL;
// clear png structs
ClearPngStructs();
// success!
return true;
}
/*
* Encodes an image to a PNG file stream.
*/
int opng_encode_image(struct opng_codec_context *context, int filtered, FILE *stream, const char *fname, int level)
{
const char * volatile err_msg; /* volatile is required by cexcept */
context->libpng_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, 0, opng_write_error, opng_write_warning);
context->info_ptr = png_create_info_struct(context->libpng_ptr);
if (!context->libpng_ptr || !context->info_ptr)
{
opng_error(0, "Out of memory");
png_destroy_write_struct(&context->libpng_ptr, &context->info_ptr);
exit(1);
}
struct opng_encoding_stats * stats = context->stats;
opng_init_stats(stats);
context->stream = stream;
context->fname = fname;
Try
{
png_set_filter(context->libpng_ptr, PNG_FILTER_TYPE_BASE, filtered ? PNG_ALL_FILTERS : PNG_FILTER_NONE);
if (level != 6) {
png_set_compression_level(context->libpng_ptr, level);
}
png_set_compression_mem_level(context->libpng_ptr, 8);
png_set_compression_window_bits(context->libpng_ptr, 15);
png_set_compression_strategy(context->libpng_ptr, 0);
png_set_keep_unknown_chunks(context->libpng_ptr, PNG_HANDLE_CHUNK_ALWAYS, 0, 0);
opng_store_image(context->image, context->libpng_ptr, context->info_ptr);
/* Write the PNG stream. */
png_set_write_fn(context->libpng_ptr, context, opng_write_data, 0);
png_write_png(context->libpng_ptr, context->info_ptr, 0, 0);
}
Catch (err_msg)
{
stats->idat_size = OPTK_INT64_MAX;
opng_error(fname, err_msg);
return -1;
}
png_data_freer(context->libpng_ptr, context->info_ptr, PNG_USER_WILL_FREE_DATA, PNG_FREE_ALL);
png_destroy_write_struct(&context->libpng_ptr, &context->info_ptr);
return 0;
}
void write_header( const View& view )
{
using png_rw_info_t = detail::png_write_support
<
typename channel_type<typename get_pixel_type<View>::type>::type,
typename color_space_type<View>::type
>;
// Set the image information here. Width and height are up to 2^31,
// bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
// the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
// PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
// or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or
// PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
// currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
png_set_IHDR( get_struct()
, get_info()
, static_cast< png_image_width::type >( view.width() )
, static_cast< png_image_height::type >( view.height() )
, static_cast< png_bitdepth::type >( png_rw_info_t::_bit_depth )
, static_cast< png_color_type::type >( png_rw_info_t::_color_type )
, _info._interlace_method
, _info._compression_type
, _info._filter_method
);
#ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
if( _info._valid_cie_colors )
{
png_set_cHRM( get_struct()
, get_info()
, _info._white_x
, _info._white_y
, _info._red_x
, _info._red_y
, _info._green_x
, _info._green_y
, _info._blue_x
, _info._blue_y
);
}
if( _info._valid_file_gamma )
{
png_set_gAMA( get_struct()
, get_info()
, _info._file_gamma
);
}
#else
if( _info._valid_cie_colors )
{
png_set_cHRM_fixed( get_struct()
, get_info()
, _info._white_x
, _info._white_y
, _info._red_x
, _info._red_y
, _info._green_x
, _info._green_y
, _info._blue_x
, _info._blue_y
);
}
if( _info._valid_file_gamma )
{
png_set_gAMA_fixed( get_struct()
, get_info()
, _info._file_gamma
);
}
#endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
if( _info._valid_icc_profile )
{
#if PNG_LIBPNG_VER_MINOR >= 5
png_set_iCCP( get_struct()
, get_info()
, const_cast< png_charp >( _info._icc_name.c_str() )
, _info._iccp_compression_type
, reinterpret_cast< png_const_bytep >( & (_info._profile.front ()) )
, _info._profile_length
);
#else
png_set_iCCP( get_struct()
, get_info()
, const_cast< png_charp >( _info._icc_name.c_str() )
, _info._iccp_compression_type
, const_cast< png_charp >( & (_info._profile.front()) )
, _info._profile_length
);
#endif
}
if( _info._valid_intent )
{
png_set_sRGB( get_struct()
, get_info()
, _info._intent
);
}
if( _info._valid_palette )
{
png_set_PLTE( get_struct()
, get_info()
, const_cast< png_colorp >( &_info._palette.front() )
, _info._num_palette
);
}
if( _info._valid_background )
{
png_set_bKGD( get_struct()
, get_info()
, const_cast< png_color_16p >( &_info._background )
);
}
if( _info._valid_histogram )
{
png_set_hIST( get_struct()
, get_info()
, const_cast< png_uint_16p >( &_info._histogram.front() )
);
}
if( _info._valid_offset )
{
png_set_oFFs( get_struct()
, get_info()
, _info._offset_x
, _info._offset_y
, _info._off_unit_type
);
}
if( _info._valid_pixel_calibration )
{
std::vector< const char* > params( _info._num_params );
for( std::size_t i = 0; i < params.size(); ++i )
{
params[i] = _info._params[ i ].c_str();
}
png_set_pCAL( get_struct()
, get_info()
, const_cast< png_charp >( _info._purpose.c_str() )
, _info._X0
, _info._X1
, _info._cal_type
, _info._num_params
, const_cast< png_charp >( _info._units.c_str() )
, const_cast< png_charpp >( ¶ms.front() )
);
}
if( _info._valid_resolution )
{
png_set_pHYs( get_struct()
, get_info()
, _info._res_x
, _info._res_y
, _info._phy_unit_type
);
}
if( _info._valid_significant_bits )
{
png_set_sBIT( get_struct()
, get_info()
, const_cast< png_color_8p >( &_info._sig_bits )
);
}
#ifndef BOOST_GIL_IO_PNG_1_4_OR_LOWER
#ifdef BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
if( _info._valid_scale_factors )
{
png_set_sCAL( get_struct()
, get_info()
, this->_info._scale_unit
, this->_info._scale_width
, this->_info._scale_height
);
}
#else
#ifdef BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED
if( _info._valid_scale_factors )
{
png_set_sCAL_fixed( get_struct()
, get_info()
, this->_info._scale_unit
, this->_info._scale_width
, this->_info._scale_height
);
}
#else
if( _info._valid_scale_factors )
{
png_set_sCAL_s( get_struct()
, get_info()
, this->_info._scale_unit
, const_cast< png_charp >( this->_info._scale_width.c_str() )
, const_cast< png_charp >( this->_info._scale_height.c_str() )
);
}
#endif // BOOST_GIL_IO_PNG_FIXED_POINT_SUPPORTED
#endif // BOOST_GIL_IO_PNG_FLOATING_POINT_SUPPORTED
#endif // BOOST_GIL_IO_PNG_1_4_OR_LOWER
if( _info._valid_text )
{
std::vector< png_text > texts( _info._num_text );
for( std::size_t i = 0; i < texts.size(); ++i )
{
png_text pt;
pt.compression = _info._text[i]._compression;
pt.key = const_cast< png_charp >( this->_info._text[i]._key.c_str() );
pt.text = const_cast< png_charp >( this->_info._text[i]._text.c_str() );
pt.text_length = _info._text[i]._text.length();
texts[i] = pt;
}
png_set_text( get_struct()
, get_info()
, &texts.front()
, _info._num_text
);
}
if( _info._valid_modification_time )
{
png_set_tIME( get_struct()
, get_info()
, const_cast< png_timep >( &_info._mod_time )
);
}
if( _info._valid_transparency_factors )
{
int sample_max = ( 1u << _info._bit_depth );
/* libpng doesn't reject a tRNS chunk with out-of-range samples */
if( !( ( _info._color_type == PNG_COLOR_TYPE_GRAY
&& (int) _info._trans_values[0].gray > sample_max
)
|| ( _info._color_type == PNG_COLOR_TYPE_RGB
&&( (int) _info._trans_values[0].red > sample_max
|| (int) _info._trans_values[0].green > sample_max
|| (int) _info._trans_values[0].blue > sample_max
)
)
)
)
{
//@todo Fix that once reading transparency values works
/*
png_set_tRNS( get_struct()
, get_info()
, trans
, num_trans
, trans_values
);
*/
}
}
// Compression Levels - valid values are [0,9]
png_set_compression_level( get_struct()
, _info._compression_level
);
png_set_compression_mem_level( get_struct()
, _info._compression_mem_level
);
png_set_compression_strategy( get_struct()
, _info._compression_strategy
);
png_set_compression_window_bits( get_struct()
, _info._compression_window_bits
);
png_set_compression_method( get_struct()
, _info._compression_method
);
png_set_compression_buffer_size( get_struct()
, _info._compression_buffer_size
);
#ifdef BOOST_GIL_IO_PNG_DITHERING_SUPPORTED
// Dithering
if( _info._set_dithering )
{
png_set_dither( get_struct()
, &_info._dithering_palette.front()
, _info._dithering_num_palette
, _info._dithering_maximum_colors
, &_info._dithering_histogram.front()
, _info._full_dither
);
}
#endif // BOOST_GIL_IO_PNG_DITHERING_SUPPORTED
// Filter
if( _info._set_filter )
{
png_set_filter( get_struct()
, 0
, _info._filter
);
}
// Invert Mono
if( _info._invert_mono )
{
png_set_invert_mono( get_struct() );
}
// True Bits
if( _info._set_true_bits )
{
png_set_sBIT( get_struct()
, get_info()
, &_info._true_bits.front()
);
}
// sRGB Intent
if( _info._set_srgb_intent )
{
png_set_sRGB( get_struct()
, get_info()
, _info._srgb_intent
);
}
// Strip Alpha
if( _info._strip_alpha )
{
png_set_strip_alpha( get_struct() );
}
// Swap Alpha
if( _info._swap_alpha )
{
png_set_swap_alpha( get_struct() );
}
png_write_info( get_struct()
, get_info()
);
}
BOOL CScreenCapture::PngInit(int nWidth, int nHeight, BOOL bGrayscale, CString sFileName)
{
m_fp = NULL;
m_png_ptr = NULL;
m_info_ptr = NULL;
#if _MSC_VER>=1400
_tfopen_s(&m_fp, sFileName.GetBuffer(0), _T("wb"));
#else
m_fp = _tfopen(sFileName.GetBuffer(0), _T("wb"));
#endif
if (!m_fp)
{
return FALSE;
}
m_png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
(png_voidp)NULL, NULL, NULL);
if (!m_png_ptr)
return FALSE;
m_info_ptr = png_create_info_struct(m_png_ptr);
if (!m_info_ptr)
{
png_destroy_write_struct(&m_png_ptr, (png_infopp)NULL);
return FALSE;
}
/* Error handler*/
if (setjmp(png_jmpbuf(m_png_ptr)))
{
png_destroy_write_struct(&m_png_ptr, &m_info_ptr);
fclose(m_fp);
return FALSE;
}
png_init_io(m_png_ptr, m_fp);
/* set the zlib compression level */
png_set_compression_level(m_png_ptr, Z_BEST_COMPRESSION);
/* set other zlib parameters */
png_set_compression_mem_level(m_png_ptr, 8);
png_set_compression_strategy(m_png_ptr, Z_DEFAULT_STRATEGY);
png_set_compression_window_bits(m_png_ptr, 15);
png_set_compression_method(m_png_ptr, 8);
png_set_compression_buffer_size(m_png_ptr, 8192);
png_set_IHDR(
m_png_ptr,
m_info_ptr,
nWidth, //width,
nHeight, //height,
8, // bit_depth
bGrayscale?PNG_COLOR_TYPE_GRAY:PNG_COLOR_TYPE_RGB, // color_type
PNG_INTERLACE_NONE, // interlace_type
PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_DEFAULT);
png_set_bgr(m_png_ptr);
/* write the file information */
png_write_info(m_png_ptr, m_info_ptr);
return TRUE;
}
LOGICAL PngImageFile ( Image pImage, uint8_t ** buf, int *size)
{
png_structp png_ptr;
png_infop info_ptr;
//png_infop end_info;
ImagePngRawData raw;
if( !pImage->width || !pImage->height )
return FALSE;
png_ptr = png_create_write_struct( PNG_LIBPNG_VER_STRING, NULL,
NULL, NULL);
if (!png_ptr)
return NULL;
png_set_error_fn( png_ptr, NotSoFatalError //png_get_error_ptr( png_ptr )
, NotSoFatalError2, NotSoFatalError2 );
//png_ptr->error_fn = NotSoFatalError;
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr)
{
no_mem2:
png_destroy_write_struct(&png_ptr,
(png_infopp)NULL);
return NULL;
}
//end_info = png_create_info_struct(png_ptr);
//if (!end_info)
//{
// png_destroy_write_struct(&png_ptr, &info_ptr,
// (png_infopp)NULL);
// return NULL;
//}
{
raw.r_data = buf;
raw.r_size = size;
raw.alloced = 0;
png_set_write_fn( png_ptr, &raw, ImagePngWrite, ImagePngFlush );
}
// Set the compression level, image filters, and compression strategy...
//png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;
//png_ptr->zlib_strategy = Z_DEFAULT_STRATEGY;
png_set_compression_window_bits(png_ptr, 15);
png_set_compression_level(png_ptr, /*0-9*/ 3 );
// gzip level?
png_set_filter(png_ptr, 0, PNG_FILTER_NONE);
png_set_bgr( png_ptr );
//png_set_swap_alpha( png_ptr );
png_set_IHDR(png_ptr, info_ptr,
pImage->width, pImage->height, // the width & height
8, PNG_COLOR_TYPE_RGB_ALPHA, // bit_depth, color_type,
PNG_INTERLACE_NONE, // no interlace
PNG_COMPRESSION_TYPE_BASE, // compression type
PNG_FILTER_TYPE_BASE); // filter type
png_write_info(png_ptr, info_ptr);
{
int row;
png_bytep * const row_pointers = (png_bytep*const)Allocate( sizeof( png_bytep ) * pImage->height );
for (row=0; row< pImage->height; row++)
{
#ifdef _INVERT_IMAGE
row_pointers[row] = (png_bytep)(pImage->image + (pImage->height-row-1) * pImage->pwidth);
#else
row_pointers[row] = (png_bytep)(pImage->image + row * pImage->pwidth);
#endif
}
png_write_image(png_ptr, row_pointers);
Release( row_pointers );
}
png_write_end(png_ptr, info_ptr);
png_destroy_write_struct( &png_ptr, &info_ptr
);
return TRUE;
void CAPTURE_AddImage(Bitu width, Bitu height, Bitu bpp, Bitu pitch, Bitu flags, float fps, Bit8u * data, Bit8u * pal) {
#if (C_SSHOT)
Bitu i;
Bit8u doubleRow[SCALER_MAXWIDTH*4];
Bitu countWidth = width;
if (flags & CAPTURE_FLAG_DBLH)
height *= 2;
if (flags & CAPTURE_FLAG_DBLW)
width *= 2;
if (height > SCALER_MAXHEIGHT)
return;
if (width > SCALER_MAXWIDTH)
return;
if (CaptureState & CAPTURE_IMAGE) {
png_structp png_ptr;
png_infop info_ptr;
png_color palette[256];
CaptureState &= ~CAPTURE_IMAGE;
/* Open the actual file */
FILE * fp=OpenCaptureFile("Screenshot",".png");
if (!fp) goto skip_shot;
/* First try to allocate the png structures */
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL,NULL, NULL);
if (!png_ptr) goto skip_shot;
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_write_struct(&png_ptr,(png_infopp)NULL);
goto skip_shot;
}
/* Finalize the initing of png library */
png_init_io(png_ptr, fp);
png_set_compression_level(png_ptr,Z_BEST_COMPRESSION);
/* set other zlib parameters */
png_set_compression_mem_level(png_ptr, 8);
png_set_compression_strategy(png_ptr,Z_DEFAULT_STRATEGY);
png_set_compression_window_bits(png_ptr, 15);
png_set_compression_method(png_ptr, 8);
png_set_compression_buffer_size(png_ptr, 8192);
if (bpp==8) {
png_set_IHDR(png_ptr, info_ptr, width, height,
8, PNG_COLOR_TYPE_PALETTE, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
for (i=0;i<256;i++) {
palette[i].red=pal[i*4+0];
palette[i].green=pal[i*4+1];
palette[i].blue=pal[i*4+2];
}
png_set_PLTE(png_ptr, info_ptr, palette,256);
} else {
png_set_bgr( png_ptr );
png_set_IHDR(png_ptr, info_ptr, width, height,
8, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
}
#ifdef PNG_TEXT_SUPPORTED
int fields = 1;
png_text text[1];
const char* text_s = "DOSBox " VERSION;
size_t strl = strlen(text_s);
char* ptext_s = new char[strl + 1];
strcpy(ptext_s, text_s);
char software[9] = { 'S','o','f','t','w','a','r','e',0};
text[0].compression = PNG_TEXT_COMPRESSION_NONE;
text[0].key = software;
text[0].text = ptext_s;
png_set_text(png_ptr, info_ptr, text, fields);
#endif
png_write_info(png_ptr, info_ptr);
#ifdef PNG_TEXT_SUPPORTED
delete [] ptext_s;
#endif
for (i=0;i<height;i++) {
void *rowPointer;
void *srcLine;
if (flags & CAPTURE_FLAG_DBLH)
srcLine=(data+(i >> 1)*pitch);
else
srcLine=(data+(i >> 0)*pitch);
rowPointer=srcLine;
switch (bpp) {
case 8:
if (flags & CAPTURE_FLAG_DBLW) {
for (Bitu x=0;x<countWidth;x++)
doubleRow[x*2+0] =
doubleRow[x*2+1] = ((Bit8u *)srcLine)[x];
rowPointer = doubleRow;
}
break;
case 15:
if (flags & CAPTURE_FLAG_DBLW) {
for (Bitu x=0;x<countWidth;x++) {
Bitu pixel = ((Bit16u *)srcLine)[x];
doubleRow[x*6+0] = doubleRow[x*6+3] = ((pixel& 0x001f) * 0x21) >> 2;
doubleRow[x*6+1] = doubleRow[x*6+4] = ((pixel& 0x03e0) * 0x21) >> 7;
doubleRow[x*6+2] = doubleRow[x*6+5] = ((pixel& 0x7c00) * 0x21) >> 12;
}
} else {
for (Bitu x=0;x<countWidth;x++) {
Bitu pixel = ((Bit16u *)srcLine)[x];
doubleRow[x*3+0] = ((pixel& 0x001f) * 0x21) >> 2;
doubleRow[x*3+1] = ((pixel& 0x03e0) * 0x21) >> 7;
doubleRow[x*3+2] = ((pixel& 0x7c00) * 0x21) >> 12;
}
}
rowPointer = doubleRow;
break;
case 16:
if (flags & CAPTURE_FLAG_DBLW) {
for (Bitu x=0;x<countWidth;x++) {
Bitu pixel = ((Bit16u *)srcLine)[x];
doubleRow[x*6+0] = doubleRow[x*6+3] = ((pixel& 0x001f) * 0x21) >> 2;
doubleRow[x*6+1] = doubleRow[x*6+4] = ((pixel& 0x07e0) * 0x41) >> 9;
doubleRow[x*6+2] = doubleRow[x*6+5] = ((pixel& 0xf800) * 0x21) >> 13;
}
} else {
for (Bitu x=0;x<countWidth;x++) {
bool DeferredPNGWriter::begin( GFXFormat format, S32 width, S32 height, Stream &stream, U32 compressionLevel )
{
// ONLY RGB bitmap writing supported at this time!
AssertFatal( format == GFXFormatR8G8B8 ||
format == GFXFormatR8G8B8A8 ||
format == GFXFormatR8G8B8X8 ||
format == GFXFormatA8 ||
format == GFXFormatR5G6B5, "_writePNG: ONLY RGB bitmap writing supported at this time.");
if ( format != GFXFormatR8G8B8 &&
format != GFXFormatR8G8B8A8 &&
format != GFXFormatR8G8B8X8 &&
format != GFXFormatA8 &&
format != GFXFormatR5G6B5 )
return false;
mData->png_ptr = png_create_write_struct_2(PNG_LIBPNG_VER_STRING,
NULL,
pngFatalErrorFn,
pngWarningFn,
NULL,
pngRealMallocFn,
pngRealFreeFn);
if (mData->png_ptr == NULL)
return (false);
mData->info_ptr = png_create_info_struct(mData->png_ptr);
if (mData->info_ptr == NULL)
{
png_destroy_write_struct(&mData->png_ptr, (png_infopp)NULL);
return false;
}
png_set_write_fn(mData->png_ptr, &stream, pngWriteDataFn, pngFlushDataFn);
// Set the compression level and image filters
png_set_compression_window_bits(mData->png_ptr, 15);
png_set_compression_level(mData->png_ptr, compressionLevel);
png_set_filter(mData->png_ptr, 0, PNG_ALL_FILTERS);
// Set the image information here. Width and height are up to 2^31,
// bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
// the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
// PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
// or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or
// PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
// currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
if (format == GFXFormatR8G8B8)
{
png_set_IHDR(mData->png_ptr, mData->info_ptr,
width, height, // the width & height
8, PNG_COLOR_TYPE_RGB, // bit_depth, color_type,
NULL, // no interlace
NULL, // compression type
NULL); // filter type
}
else if (format == GFXFormatR8G8B8A8 || format == GFXFormatR8G8B8X8)
{
png_set_IHDR(mData->png_ptr, mData->info_ptr,
width, height, // the width & height
8, PNG_COLOR_TYPE_RGB_ALPHA, // bit_depth, color_type,
NULL, // no interlace
NULL, // compression type
NULL); // filter type
}
else if (format == GFXFormatA8)
{
png_set_IHDR(mData->png_ptr, mData->info_ptr,
width, height, // the width & height
8, PNG_COLOR_TYPE_GRAY, // bit_depth, color_type,
NULL, // no interlace
NULL, // compression type
NULL); // filter type
}
else if (format == GFXFormatR5G6B5)
{
png_set_IHDR(mData->png_ptr, mData->info_ptr,
width, height, // the width & height
16, PNG_COLOR_TYPE_GRAY, // bit_depth, color_type,
PNG_INTERLACE_NONE, // no interlace
PNG_COMPRESSION_TYPE_DEFAULT, // compression type
PNG_FILTER_TYPE_DEFAULT); // filter type
png_color_8_struct sigBit = { 0 };
sigBit.gray = 16;
png_set_sBIT(mData->png_ptr, mData->info_ptr, &sigBit );
png_set_swap( mData->png_ptr );
}
png_write_info(mData->png_ptr, mData->info_ptr);
mActive = true;
return true;
}
//--------------------------------------------------------------------------
static bool _writePNG(GBitmap *bitmap, Stream &stream, U32 compressionLevel, U32 strategy, U32 filter)
{
GFXFormat format = bitmap->getFormat();
// ONLY RGB bitmap writing supported at this time!
AssertFatal( format == GFXFormatR8G8B8 ||
format == GFXFormatR8G8B8A8 ||
format == GFXFormatR8G8B8X8 ||
format == GFXFormatA8 ||
format == GFXFormatR5G6B5, "_writePNG: ONLY RGB bitmap writing supported at this time.");
if ( format != GFXFormatR8G8B8 &&
format != GFXFormatR8G8B8A8 &&
format != GFXFormatR8G8B8X8 &&
format != GFXFormatA8 &&
format != GFXFormatR5G6B5 )
return false;
png_structp png_ptr = png_create_write_struct_2(PNG_LIBPNG_VER_STRING,
NULL,
pngFatalErrorFn,
pngWarningFn,
NULL,
pngMallocFn,
pngFreeFn);
if (png_ptr == NULL)
return (false);
png_infop info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == NULL)
{
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return false;
}
png_set_write_fn(png_ptr, &stream, pngWriteDataFn, pngFlushDataFn);
// Set the compression level and image filters
png_set_compression_window_bits(png_ptr, 15);
png_set_compression_level(png_ptr, compressionLevel);
png_set_filter(png_ptr, 0, filter);
// Set the image information here. Width and height are up to 2^31,
// bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
// the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
// PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
// or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or
// PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
// currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
U32 width = bitmap->getWidth();
U32 height = bitmap->getHeight();
if (format == GFXFormatR8G8B8)
{
png_set_IHDR(png_ptr, info_ptr,
width, height, // the width & height
8, PNG_COLOR_TYPE_RGB, // bit_depth, color_type,
NULL, // no interlace
NULL, // compression type
NULL); // filter type
}
else if (format == GFXFormatR8G8B8A8 || format == GFXFormatR8G8B8X8)
{
png_set_IHDR(png_ptr, info_ptr,
width, height, // the width & height
8, PNG_COLOR_TYPE_RGB_ALPHA, // bit_depth, color_type,
NULL, // no interlace
NULL, // compression type
NULL); // filter type
}
else if (format == GFXFormatA8)
{
png_set_IHDR(png_ptr, info_ptr,
width, height, // the width & height
8, PNG_COLOR_TYPE_GRAY, // bit_depth, color_type,
NULL, // no interlace
NULL, // compression type
NULL); // filter type
}
else if (format == GFXFormatR5G6B5)
{
png_set_IHDR(png_ptr, info_ptr,
width, height, // the width & height
16, PNG_COLOR_TYPE_GRAY, // bit_depth, color_type,
PNG_INTERLACE_NONE, // no interlace
PNG_COMPRESSION_TYPE_DEFAULT, // compression type
PNG_FILTER_TYPE_DEFAULT); // filter type
png_color_8_struct sigBit = { 0 };
sigBit.gray = 16;
png_set_sBIT(png_ptr, info_ptr, &sigBit );
png_set_swap( png_ptr );
}
png_write_info(png_ptr, info_ptr);
FrameAllocatorMarker marker;
png_bytep* row_pointers = (png_bytep*)marker.alloc( height * sizeof( png_bytep ) );
for (U32 i=0; i<height; i++)
row_pointers[i] = const_cast<png_bytep>(bitmap->getAddress(0, i));
png_write_image(png_ptr, row_pointers);
// Write S3TC data if present...
// Write FXT1 data if present...
png_write_end(png_ptr, info_ptr);
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return true;
}
bool R9_ImgWritePNG( F9FILE file, r9Img* img )
{
const int32 compressionlevel = 6;
const int32 strategy = 0;
const int32 filter = PNG_ALL_FILTERS;
if(img->m_pf!=R9_PF_RGB && img->m_pf!=R9_PF_ARGB && img->m_pf!=R9_PF_BGR && img->m_pf!=R9_PF_ABGR )
{
elog::rnd() << "png format not supported" << std::endl; return false;
}
png_structp png_ptr = png_create_write_struct_2( PNG_LIBPNG_VER_STRING,
NULL,
R9_ImgPNG_FatalError,
R9_ImgPNG_Warning,
NULL,
R9_ImgPNG_Malloc,
R9_ImgPNG_Free );
if(png_ptr==NULL) return false;
png_infop info_ptr = png_create_info_struct(png_ptr);
if(info_ptr==NULL)
{
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return false;
}
r9_imgpng_file = file;
png_set_write_fn(png_ptr, NULL, R9_ImgPNG_WriteData, NULL); // last one was imgpng_flush (fflush) that did nothing
// set the compression level, image filters, and compression strategy...
png_ptr->flags |= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;
png_ptr->zlib_strategy = strategy;
png_set_compression_window_bits(png_ptr, 15);
png_set_compression_level(png_ptr, compressionlevel);
png_set_filter(png_ptr, 0, filter);
// flip rgb temporary, if necessarily - png likes BGR!
if(img->m_pf==R9_PF_ARGB || img->m_pf==R9_PF_RGB) R9_ImgFlipRGB(img);
// Set the image information here. Width and height are up to 2^31,
// bit_depth is one of 1, 2, 4, 8, or 16, but valid values also depend on
// the color_type selected. color_type is one of PNG_COLOR_TYPE_GRAY,
// PNG_COLOR_TYPE_GRAY_ALPHA, PNG_COLOR_TYPE_PALETTE, PNG_COLOR_TYPE_RGB,
// or PNG_COLOR_TYPE_RGB_ALPHA. interlace is either PNG_INTERLACE_NONE or
// PNG_INTERLACE_ADAM7, and the compression_type and filter_type MUST
// currently be PNG_COMPRESSION_TYPE_BASE and PNG_FILTER_TYPE_BASE. REQUIRED
if(img->m_pf==R9_PF_RGB || img->m_pf==R9_PF_BGR)
{
png_set_IHDR(png_ptr, info_ptr,
img->m_width, img->m_height, // the width & height
8, PNG_COLOR_TYPE_RGB, // bit_depth, color_type,
NULL, // no interlace
NULL, // compression type
NULL); // filter type
}
else
if(img->m_pf==R9_PF_ARGB || img->m_pf==R9_PF_ABGR)
{
png_set_IHDR(png_ptr, info_ptr,
img->m_width, img->m_height, // the width & height
8, PNG_COLOR_TYPE_RGB_ALPHA, // bit_depth, color_type,
NULL, // no interlace
NULL, // compression type
NULL); // filter type
}
png_write_info(png_ptr, info_ptr);
png_bytep* rowpointers = new png_bytep[img->m_height];
for(int i=0; i<img->m_height; i++)
rowpointers[i] = (png_bytep)(img->m_data+(i*img->lineSize()));
png_write_image(png_ptr, rowpointers);
// release
png_write_end(png_ptr, info_ptr);
png_destroy_write_struct(&png_ptr, &info_ptr);
delete [] rowpointers;
r9_imgpng_file = NULL;
// flip rgb back, if necessarily
if(img->m_pf==R9_PF_ARGB || img->m_pf==R9_PF_RGB) R9_ImgFlipRGB(img);
return true;
}
static uint8_t png_write( png_structp writePtr, png_image * image, uint32_t flags )
{
const uint32_t h = image->height;
const uint32_t w = image->width;
const uint8_t * p = image->data;
const uint32_t bitDepth = 8;
const uint32_t channels = 4;
png_infop infoPtr = png_create_info_struct( writePtr );
if (!infoPtr)
{
pngio_error( "Couldn't initialize PNG info struct" );
png_destroy_write_struct( & writePtr, NULL );
return 0;
}
if (setjmp( png_jmpbuf( writePtr ) ))
{
png_destroy_write_struct( & writePtr, & infoPtr );
pngio_error( "An error occured while writing the PNG file." );
return 0;
}
png_set_filter( writePtr, 0, PNG_FILTER_NONE );
#ifdef PNG_APPLE_MODE_SUPPORTED
if (png_get_apple_mode())
{
png_write_sig( writePtr );
png_set_sig_bytes( writePtr, 8 );
png_set_compression_window_bits( writePtr, -15 );
png_set_write_user_transform_fn( writePtr, png_write_swap_and_premultiply_transform );
png_set_user_transform_info( writePtr, NULL, bitDepth, channels );
}
#endif
png_set_IHDR( writePtr, infoPtr, w, h, bitDepth, PNG_COLOR_TYPE_RGBA, PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT );
png_set_gAMA( writePtr, infoPtr, 0.45455 );
png_set_cHRM( writePtr, infoPtr, 0.312700, 0.329, 0.64, 0.33, 0.3, 0.6, 0.15, 0.06 );
png_set_sRGB( writePtr, infoPtr, 0);
#ifdef PNG_APPLE_MODE_SUPPORTED
if (png_get_apple_mode())
{
png_byte cname[] = { 'C', 'g', 'B', 'I', '\0' };
png_byte cdata[] = { 0x50, 0x00, 0x20, 0x02 };
png_write_chunk( writePtr, cname, cdata, 4 );
}
#endif
png_write_info( writePtr, infoPtr );
const size_t bytesPerRow = w * 4;
if (flags & PNG_IMAGE_FLIP_VERTICAL)
{
for (size_t i = 0; i < h; i++)
{
png_write_row( writePtr, p + (bytesPerRow * (h - i - 1)) );
}
}
else
{
for (size_t i = 0; i < h; i++)
{
png_write_row( writePtr, p + (bytesPerRow * i) );
}
}
png_write_end( writePtr, infoPtr );
png_destroy_write_struct( & writePtr, & infoPtr );
return 1;
}