1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in 12 * the documentation and/or other materials provided with the 13 * distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 /* this small program is used to measure the performance of libjpeg decompression 29 * algorithm... 30 */ 31 32 #include <time.h> 33 #include <stdio.h> 34 #include <stdlib.h> 35 #include <string.h> 36 #include <errno.h> 37 #include <unistd.h> 38 #include <sys/time.h> 39 #include "jpeglib.h" 40 #include <setjmp.h> 41 #ifdef HAVE_ANDROID_OS 42 #include <hardware_legacy/qemu_tracing.h> 43 #endif 44 45 #define USE_STDIO 46 47 #define CHUNK 32768 48 49 typedef struct { 50 struct jpeg_source_mgr jpeg_mgr; 51 char* base; 52 char* cursor; 53 char* end; 54 } SourceMgrRec, *SourceMgr; 55 56 static void 57 _source_init_source(j_decompress_ptr cinfo) 58 { 59 SourceMgr src = (SourceMgr) cinfo->src; 60 61 src->jpeg_mgr.next_input_byte = (unsigned char*)src->base, 62 src->jpeg_mgr.bytes_in_buffer = src->end - src->base; 63 } 64 65 static int 66 _source_fill_input_buffer(j_decompress_ptr cinfo) 67 { 68 SourceMgr src = (SourceMgr) cinfo->src; 69 70 cinfo->err->error_exit((j_common_ptr)cinfo); 71 return FALSE; 72 } 73 74 static void 75 _source_skip_input_data(j_decompress_ptr cinfo, long num_bytes) 76 { 77 SourceMgr src = (SourceMgr) cinfo->src; 78 79 if (src->jpeg_mgr.next_input_byte + num_bytes > (unsigned char*)src->end ) { 80 cinfo->err->error_exit((j_common_ptr)cinfo); 81 } 82 83 src->jpeg_mgr.next_input_byte += num_bytes; 84 src->jpeg_mgr.bytes_in_buffer -= num_bytes; 85 } 86 87 static int 88 _source_resync_to_restart( j_decompress_ptr cinfo, int desired) 89 { 90 SourceMgr src = (SourceMgr) cinfo->src; 91 92 src->jpeg_mgr.next_input_byte = (unsigned char*)src->base; 93 src->jpeg_mgr.bytes_in_buffer = src->end - src->base; 94 return TRUE; 95 } 96 97 static void 98 _source_term_source(j_decompress_ptr cinfo) 99 { 100 // nothing to do 101 } 102 103 static void 104 _source_init( SourceMgr src, char* base, long size ) 105 { 106 src->base = base; 107 src->cursor = base; 108 src->end = base + size; 109 110 src->jpeg_mgr.init_source = _source_init_source; 111 src->jpeg_mgr.fill_input_buffer = _source_fill_input_buffer; 112 src->jpeg_mgr.skip_input_data = _source_skip_input_data; 113 src->jpeg_mgr.resync_to_restart = _source_resync_to_restart; 114 src->jpeg_mgr.term_source = _source_term_source; 115 } 116 117 118 typedef struct { 119 struct jpeg_error_mgr jpeg_mgr; 120 jmp_buf jumper; 121 int volatile error; 122 123 } ErrorMgrRec, *ErrorMgr; 124 125 static void _error_exit(j_common_ptr cinfo) 126 { 127 ErrorMgr error = (ErrorMgr) cinfo->err; 128 129 (*error->jpeg_mgr.output_message) (cinfo); 130 131 /* Let the memory manager delete any temp files before we die */ 132 longjmp(error->jumper, -1); 133 } 134 135 #ifdef USE_STDIO 136 int decompress(FILE* input_file, int dct_method, int disable_rgb) 137 #else 138 int decompress(char* data, long fsize) 139 #endif 140 { 141 ErrorMgrRec errmgr; 142 SourceMgrRec sourcemgr; 143 struct jpeg_decompress_struct cinfo; 144 int volatile error = 0; 145 jmp_buf jumper; 146 int isRGB; 147 char* pixels; 148 JSAMPLE* temprow; 149 150 memset( &cinfo, 0, sizeof(cinfo) ); 151 memset( &errmgr, 0, sizeof(errmgr) ); 152 jpeg_create_decompress(&cinfo); 153 cinfo.err = jpeg_std_error(&errmgr.jpeg_mgr); 154 #if 0 155 errmgr.jpeg_mgr.error_exit = _error_exit; 156 errmgr.error = 0; 157 #endif 158 159 if (setjmp(errmgr.jumper) != 0) { 160 fprintf(stderr, "returning error from jpeglib ---\n" ); 161 goto Exit; 162 } 163 164 #ifdef USE_STDIO 165 /* Specify data source for decompression */ 166 jpeg_stdio_src(&cinfo, input_file); 167 #else 168 _source_init( &sourcemgr, data, fsize ); 169 cinfo.src = &sourcemgr.jpeg_mgr; 170 #endif 171 172 jpeg_read_header(&cinfo, 1); 173 174 if (3 == cinfo.num_components && JCS_RGB == cinfo.out_color_space) 175 isRGB = 1; 176 else if (1 == cinfo.num_components && JCS_GRAYSCALE == cinfo.out_color_space) 177 isRGB = 0; // could use Index8 config if we want... 178 else { 179 fprintf( stderr, "unsupported jpeg colorspace %d with %d components\n", 180 cinfo.jpeg_color_space, cinfo.num_components ); 181 goto Exit; 182 } 183 184 cinfo.dct_method = dct_method; 185 if (disable_rgb) 186 cinfo.out_color_space = JCS_YCbCr; 187 188 jpeg_start_decompress(&cinfo); 189 190 temprow = calloc( cinfo.num_components * cinfo.output_width, sizeof(JSAMPLE) ); 191 192 { 193 unsigned y; 194 for (y = 0; y < cinfo.output_height; y++) { 195 JSAMPLE* rowptr = temprow; 196 (void)jpeg_read_scanlines(&cinfo, &rowptr, 1); 197 } 198 } 199 jpeg_finish_decompress(&cinfo); 200 201 free( temprow ); 202 Exit: 203 jpeg_destroy_decompress(&cinfo); 204 return error; 205 } 206 207 208 #define DEFAULT_REPEAT 10 209 210 static void usage(void) 211 { 212 fprintf(stderr, "usage: test_jpeg [options] filename.jpg [filename2.jpg ...]\n" ); 213 fprintf(stderr, "options: -r NN repeat count (default %d)\n", DEFAULT_REPEAT ); 214 fprintf(stderr, " -d N idct method (0=default, 1=fastest, 2=slow, 3=float)\n" ); 215 fprintf(stderr, " -C no RGB color conversion (YCbCr instead)\n" ); 216 exit(1); 217 } 218 219 static double 220 get_time_usec( void ) 221 { 222 #ifdef HAVE_ANDROID_OS 223 struct timespec ts; 224 225 if ( clock_gettime( CLOCK_MONOTONIC, &ts ) < 0 ) 226 fprintf(stderr, "clock_gettime: %s\n", strerror(errno) ); 227 228 return ts.tv_sec*1e6 + ts.tv_nsec*1e-3; 229 #else 230 struct timeval tv; 231 if (gettimeofday( &tv, NULL ) < 0) 232 fprintf(stderr, "gettimeofday: %s\n", strerror(errno) ); 233 234 return tv.tv_sec*1000000. + tv.tv_usec*1.0; 235 #endif 236 } 237 238 239 int main( int argc, char** argv ) 240 { 241 FILE* f; 242 int repeat_count = DEFAULT_REPEAT; 243 int dct_method = JDCT_DEFAULT; 244 int disable_rgb = 0; 245 double usec0, usec1; 246 247 if (argc < 2) 248 usage(); 249 250 for ( ; argc > 1 && argv[1][0] == '-'; argc--, argv++) { 251 const char* arg = &argv[1][1]; 252 switch (arg[0]) { 253 case 'r': 254 if (arg[1] == 0) { 255 if (argc < 3) 256 usage(); 257 arg = argv[2]; 258 argc--; 259 argv++; 260 } else 261 arg += 1; 262 263 repeat_count = strtol(arg, NULL, 10); 264 265 if (repeat_count <= 0) 266 repeat_count = 1; 267 break; 268 269 case 'C': 270 disable_rgb = 1; 271 break; 272 273 case 'd': 274 if (arg[1] == 0) { 275 if (argc < 3) 276 usage(); 277 arg = argv[2]; 278 argc--; 279 argv++; 280 } else 281 arg += 1; 282 283 dct_method = strtol(arg, NULL, 10); 284 switch (dct_method) { 285 case 0: 286 dct_method = JDCT_DEFAULT; 287 break; 288 case 1: 289 dct_method = JDCT_IFAST; 290 break; 291 case 2: 292 dct_method = JDCT_ISLOW; 293 break; 294 case 3: 295 dct_method = JDCT_FLOAT; 296 break; 297 default: 298 usage(); 299 } 300 break; 301 302 default: 303 usage(); 304 } 305 } 306 307 for ( ; argc > 1; argc--, argv++ ) 308 { 309 long fsize; 310 char* data; 311 FILE* f = fopen( argv[1], "rb" ); 312 int rr; 313 314 if (f == NULL) { 315 fprintf(stderr, "could not open '%s': %s\n", argv[1], strerror(errno) ); 316 continue; 317 } 318 319 fseek( f, 0, SEEK_END ); 320 fsize = ftell(f); 321 fseek( f, 0, SEEK_SET ); 322 323 usec0 = get_time_usec(); 324 #ifdef HAVE_ANDROID_OS 325 qemu_start_tracing(); 326 #endif 327 #ifdef USE_STDIO 328 for ( rr = repeat_count; rr > 0; rr-- ) { 329 fseek( f, 0, SEEK_SET ); 330 decompress(f, dct_method, disable_rgb); 331 } 332 fclose( f ); 333 #else 334 335 data = malloc( fsize ); 336 if (data == NULL) { 337 if (fsize > 0) 338 fprintf(stderr, "could not allocate %ld bytes to load '%s'\n", fsize, argv[1] ); 339 fclose(f); 340 continue; 341 } 342 fread( data, 1, fsize, f ); 343 fclose(f); 344 345 usec1 = get_time_usec() - usec0; 346 printf( "compressed load: %10.2f ms (%ld bytes)\n", usec1*1e-3, fsize ); 347 348 usec0 = get_time_usec(); 349 for ( rr = repeat_count; rr > 0; rr -- ) 350 { 351 decompress( data, fsize ); 352 } 353 free( data ); 354 #endif 355 #ifdef HAVE_ANDROID_OS 356 qemu_stop_tracing(); 357 #endif 358 usec1 = get_time_usec() - usec0; 359 printf( "decompression took: %10.3f ms (%.2f KB/s, %d passes)\n", usec1/1e3, fsize*(1e6/1024)*repeat_count/usec1, repeat_count ); 360 } 361 return 0; 362 } 363
