Instantly share code, notes, and snippets.

Embed
What would you like to do?
Crappy benchmark for stb_image, lodepng, libjpeg and libpng
// The Results: http://wp.me/pEPJ4-4S
// you can define USE_LIBPNG to decode with libpng XOR USE_LODEPNG to decode with lodepng
// XOR USE_LIBJPEG to decode with libjpeg or libjpeg-turbo XOR nothing to use stb_image.
// you'll have to provide the corresponding headers and (for libjpeg and libpng) libs to link against
// for lodepng also compile lodepng.c into the binary
// ex: gcc -O4 -DUSE_LODEPNG imgLoadBench.c lodepng.c -o imgLoadBench_lodepng_gcc_O4
// or: gcc -O0 -DUSE_LIBPNG imgLoadBench.c -o imgLoadBench_libpng_gcc_O0 -lpng
// or: gcc -O2 -DUSE_LIBJPEG imgLoadBench.c -o imgLoadBench_libjpeg_gcc_O2 -ljpeg
// or: clang -O3 imgLoadBench.c -o imgLoadBench_stb_clang_O3
/*
===========================================================================
The libpng png decoding and libjpeg jpg decoding code was adapted from RBDoom3BFG:
Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
Copyright (C) 2012-2014 Robert Beckebans
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
Doom 3 BFG Edition Source Code 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.
Doom 3 BFG Edition Source Code 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 Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
The stb_image and lodepng jpeg and png decoding code was written by myself
and is so trivial that it doesn't deserve a Copyright.
===========================================================================
*/
#include <stdio.h>
#include <limits.h> // PATH_MAX
#include <time.h>
#include <stdlib.h>
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
const char* progName = "imgLoadBench";
typedef unsigned char byte;
static void printUsage()
{
eprintf("Usage: %s <imgname> [outfilename]\n", progName);
eprintf(" e.g.: %s test.png\n", progName);
eprintf(" %s /path/to/bla.tga /other/path/to/bla.h\n", progName);
}
struct image
{
unsigned char* data;
int w;
int h;
int format; // 3: RGB, 4: RGBA
};
#ifdef USE_LIBPNG
// the libpng png loading code is stolen from rbdoom3bfg's LoadPNG()
static void freeImage(struct image* img)
{
free(img->data);
img->data = NULL;
}
#include <png.h>
static void png_Error( png_structp pngPtr, png_const_charp msg )
{
eprintf( "%s\n", msg );
exit(1);
}
static void png_Warning( png_structp pngPtr, png_const_charp msg )
{
eprintf( "%s\n", msg );
}
static void png_ReadData( png_structp pngPtr, png_bytep data, png_size_t length )
{
memcpy( data, ( byte* )pngPtr->io_ptr, length );
pngPtr->io_ptr = ( ( byte* ) pngPtr->io_ptr ) + length;
}
static struct image loadImage(const char* filename, byte* fbuffer, int len)
{
struct image ret = {0};
// create png_struct with the custom error handlers
png_structp pngPtr = png_create_read_struct( PNG_LIBPNG_VER_STRING, ( png_voidp ) NULL, png_Error, png_Warning );
if( !pngPtr )
{
eprintf( "LoadPNG( %s ): png_create_read_struct failed\n", filename );
exit(1);
}
// allocate the memory for image information
png_infop infoPtr = png_create_info_struct( pngPtr );
if( !infoPtr )
{
eprintf( "LoadPNG( %s ): png_create_info_struct failed\n", filename );
exit(1);
}
png_set_read_fn( pngPtr, fbuffer, png_ReadData );
png_set_sig_bytes( pngPtr, 0 );
png_read_info( pngPtr, infoPtr );
png_uint_32 pngWidth, pngHeight;
int bitDepth, colorType, interlaceType;
png_get_IHDR( pngPtr, infoPtr, &pngWidth, &pngHeight, &bitDepth, &colorType, &interlaceType, NULL, NULL );
// 16 bit -> 8 bit
png_set_strip_16( pngPtr );
// 1, 2, 4 bit -> 8 bit
if( bitDepth < 8 )
{
png_set_packing( pngPtr );
}
if( colorType & PNG_COLOR_MASK_PALETTE )
{
png_set_expand( pngPtr );
}
if( !( colorType & PNG_COLOR_MASK_COLOR ) )
{
png_set_gray_to_rgb( pngPtr );
}
// set paletted or RGB images with transparency to full alpha so we get RGBA
if( png_get_valid( pngPtr, infoPtr, PNG_INFO_tRNS ) )
{
png_set_tRNS_to_alpha( pngPtr );
}
// make sure every pixel has an alpha value
if( !( colorType & PNG_COLOR_MASK_ALPHA ) )
{
png_set_filler( pngPtr, 255, PNG_FILLER_AFTER );
}
png_read_update_info( pngPtr, infoPtr );
byte* out = ( byte* )malloc( pngWidth * pngHeight * 4 );
ret.data = out;
ret.w = pngWidth;
ret.h = pngHeight;
ret.format = 4;
png_uint_32 rowBytes = png_get_rowbytes( pngPtr, infoPtr );
png_bytep* rowPointers = ( png_bytep* ) malloc( sizeof( png_bytep ) * pngHeight );
for( png_uint_32 row = 0; row < pngHeight; row++ )
{
rowPointers[row] = ( png_bytep )( out + ( row * pngWidth * 4 ) );
}
png_read_image( pngPtr, rowPointers );
png_read_end( pngPtr, infoPtr );
png_destroy_read_struct( &pngPtr, &infoPtr, NULL );
free( rowPointers );
return ret;
}
#elif defined(USE_LODEPNG)
// the lodepng decoding code is written from scratch
#include "lodepng.h"
static void freeImage(struct image* img)
{
free(img->data);
img->data = NULL;
}
static struct image loadImage(const char* filename, byte* fbuffer, int len)
{
struct image ret = {0};
byte* image;
unsigned w, h;
int error = lodepng_decode32(&image, &w, &h, fbuffer, len);
if(error) {
eprintf("ERROR: Couldn't load image file %s: %s!\n", filename, lodepng_error_text(error));
exit(1);
}
ret.data = image;
ret.w = w;
ret.h = h;
ret.format = 4;
return ret;
}
#elif defined(USE_LIBJPEG)
// the libjpeg jpeg loading code is stolen from doom3's LoadJPG()
#include <jpeglib.h>
static void freeImage(struct image* img)
{
free(img->data);
img->data = NULL;
}
static struct image loadImage(const char* filename, byte* fbuffer, int len)
{
struct image ret = {0};
/* This struct contains the JPEG decompression parameters and pointers to
* working space (which is allocated as needed by the JPEG library).
*/
struct jpeg_decompress_struct cinfo;
/* We use our private extension JPEG error handler.
* Note that this struct must live as long as the main JPEG parameter
* struct, to avoid dangling-pointer problems.
*/
/* This struct represents a JPEG error handler. It is declared separately
* because applications often want to supply a specialized error handler
* (see the second half of this file for an example). But here we just
* take the easy way out and use the standard error handler, which will
* print a message on stderr and call exit() if compression fails.
* Note that this struct must live as long as the main JPEG parameter
* struct, to avoid dangling-pointer problems.
*/
struct jpeg_error_mgr jerr;
/* More stuff */
JSAMPARRAY buffer; /* Output row buffer */
int row_stride; /* physical row width in output buffer */
unsigned char* out;
byte* bbuf;
/* Step 1: allocate and initialize JPEG decompression object */
/* We have to set up the error handler first, in case the initialization
* step fails. (Unlikely, but it could happen if you are out of memory.)
* This routine fills in the contents of struct jerr, and returns jerr's
* address which we place into the link field in cinfo.
*/
cinfo.err = jpeg_std_error( &jerr );
/* Now we can initialize the JPEG decompression object. */
jpeg_create_decompress( &cinfo );
/* Step 2: specify data source (eg, a file) */
jpeg_mem_src( &cinfo, fbuffer, len ); // DG: this looks better.
/* Step 3: read file parameters with jpeg_read_header() */
jpeg_read_header( &cinfo, 1 );
/* We can ignore the return value from jpeg_read_header since
* (a) suspension is not possible with the stdio data source, and
* (b) we passed TRUE to reject a tables-only JPEG file as an error.
* See libjpeg.doc for more info.
*/
/* Step 4: set parameters for decompression */
/* In this example, we don't need to change any of the defaults set by
* jpeg_read_header(), so we do nothing here.
*/
/* Step 5: Start decompressor */
jpeg_start_decompress( &cinfo );
/* We can ignore the return value since suspension is not possible
* with the stdio data source.
*/
/* We may need to do some setup of our own at this point before reading
* the data. After jpeg_start_decompress() we have the correct scaled
* output image dimensions available, as well as the output colormap
* if we asked for color quantization.
* In this example, we need to make an output work buffer of the right size.
*/
/* JSAMPLEs per row in output buffer */
row_stride = cinfo.output_width * cinfo.output_components;
if( 0 && cinfo.output_components != 4 ) // XXX
{
eprintf( "JPG %s is unsupported color depth (%d)",
filename, cinfo.output_components );
}
out = ( byte* )malloc( cinfo.output_width * cinfo.output_height * 4 );
ret.data = out;
ret.w = cinfo.output_width;
ret.h = cinfo.output_height;
/* Step 6: while (scan lines remain to be read) */
/* jpeg_read_scanlines(...); */
/* Here we use the library's state variable cinfo.output_scanline as the
* loop counter, so that we don't have to keep track ourselves.
*/
while( cinfo.output_scanline < cinfo.output_height )
{
/* jpeg_read_scanlines expects an array of pointers to scanlines.
* Here the array is only one element long, but you could ask for
* more than one scanline at a time if that's more convenient.
*/
bbuf = ( ( out + ( row_stride * cinfo.output_scanline ) ) );
buffer = &bbuf;
jpeg_read_scanlines( &cinfo, buffer, 1 );
}
// clear all the alphas to 255
{
int i, j;
byte* buf;
buf = ret.data;
j = cinfo.output_width * cinfo.output_height * 4;
for( i = 3 ; i < j ; i += 4 )
{
buf[i] = 255;
}
}
/* Step 7: Finish decompression */
jpeg_finish_decompress( &cinfo );
/* We can ignore the return value since suspension is not possible
* with the stdio data source.
*/
/* Step 8: Release JPEG decompression object */
/* This is an important step since it will release a good deal of memory. */
jpeg_destroy_decompress( &cinfo );
return ret;
}
#else // STB
// the stb_image decoding code is written from scratch
#define STBI_NO_LINEAR // don't need HDR stuff
#define STBI_NO_HDR
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
static void freeImage(struct image* img)
{
stbi_image_free(img->data);
img->data = NULL;
}
static struct image loadImage(const char* imgFileName, byte* fbuffer, int len)
{
struct image ret = {0};
int format;
ret.data = stbi_load_from_memory(fbuffer, len, &ret.w, &ret.h, &format, 4);
if(ret.data == NULL)
{
eprintf("ERROR: Couldn't load image file %s: %s!\n", imgFileName, stbi_failure_reason());
exit(1);
}
ret.format = 4;
return ret;
}
#endif // USE_STB
int main(int argc, char** argv)
{
progName = argv[0];
if(argc < 2)
{
printUsage();
exit(1);
}
const char* filename = argv[1];
byte* fbuffer;
int len;
// the "load file into buffer code" is stolen from doom3's LoadJPG idFileSystem code (because I was lazy)
{
FILE* f = fopen(filename, "r");
if(f == NULL)
{
eprintf("ERROR: Couldn't open %s!\n", filename);
exit(1);
}
fseek(f, 0, SEEK_END);
len = ftell(f);
fseek(f, 0, SEEK_SET); // go back to start
fbuffer = ( byte* )malloc( len + 4096 );
byte* buf = fbuffer;
int remaining = len;
while(remaining)
{
int block = remaining;
int read = fread( buf, 1, block, f );
if(read < 0)
{
eprintf("WTF, error while reading file!\n");
exit(1);
}
remaining -= read;
buf += read;
}
}
// I wrote the following code myself
#define numIterations 100
struct timespec before = {0};
struct timespec after = {0};
clock_gettime(CLOCK_MONOTONIC_RAW, &before);
int i;
for(i=0; i<numIterations; ++i)
{
struct image img = loadImage(filename, fbuffer, len);
freeImage(&img);
}
clock_gettime(CLOCK_MONOTONIC_RAW, &after);
int secs = after.tv_sec - before.tv_sec;
int nsecs = after.tv_nsec - before.tv_nsec;
if(nsecs < 0)
{
--secs;
nsecs += 1000000000;
}
double ms = 1000.0*secs;
ms += nsecs * 0.000001;
printf("Decoding %s %d times took %fms => %fms avg\n", filename, numIterations, ms, ms/((float)numIterations));
return 0;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment