From c00aa7dc0196ea48641c550157ea027b88d4327f Mon Sep 17 00:00:00 2001 From: Glenn Maynard Date: Tue, 23 Mar 2004 22:50:09 +0000 Subject: [PATCH] mostly whitespace changes --- stepmania/src/SDL_SaveJPEG.cpp | 179 +++++++++++++-------------------- 1 file changed, 69 insertions(+), 110 deletions(-) diff --git a/stepmania/src/SDL_SaveJPEG.cpp b/stepmania/src/SDL_SaveJPEG.cpp index 7645b52231..3e5c857790 100644 --- a/stepmania/src/SDL_SaveJPEG.cpp +++ b/stepmania/src/SDL_SaveJPEG.cpp @@ -24,7 +24,8 @@ namespace jpeg #define OUTPUT_BUFFER_SIZE 4096 -typedef struct { +typedef struct +{ struct jpeg::jpeg_destination_mgr pub; SDL_RWops *ctx; @@ -36,21 +37,19 @@ typedef struct { * Initialize source --- called by jpeg_read_header * before any data is actually read. */ -static void init_destination (jpeg::j_compress_ptr cinfo) +static void init_destination( jpeg::j_compress_ptr cinfo ) { - /* We don't actually need to do anything */ + /* nop */ return; } -/* - * Empty the output buffer --- called whenever buffer is full. - */ -static jpeg::boolean empty_output_buffer (jpeg::j_compress_ptr cinfo) +/* Empty the output buffer; called whenever buffer is full. */ +static jpeg::boolean empty_output_buffer( jpeg::j_compress_ptr cinfo ) { my_destination_mgr * dest = (my_destination_mgr *) cinfo->dest; int nbytes; - nbytes = SDL_RWwrite(dest->ctx, dest->buffer, 1, OUTPUT_BUFFER_SIZE); + nbytes = SDL_RWwrite( dest->ctx, dest->buffer, 1, OUTPUT_BUFFER_SIZE ); dest->pub.next_output_byte = dest->buffer; dest->pub.free_in_buffer = OUTPUT_BUFFER_SIZE; @@ -65,14 +64,10 @@ static jpeg::boolean empty_output_buffer (jpeg::j_compress_ptr cinfo) static void term_destination (jpeg::j_compress_ptr cinfo) { /* Write data remaining in the buffer */ - my_destination_mgr * dest = (my_destination_mgr *) cinfo->dest; - int nbytes; - - nbytes = SDL_RWwrite(dest->ctx, dest->buffer, 1, OUTPUT_BUFFER_SIZE - dest->pub.free_in_buffer); + my_destination_mgr *dest = (my_destination_mgr *) cinfo->dest; + SDL_RWwrite(dest->ctx, dest->buffer, 1, OUTPUT_BUFFER_SIZE - dest->pub.free_in_buffer); dest->pub.next_output_byte = dest->buffer; dest->pub.free_in_buffer = OUTPUT_BUFFER_SIZE; - - return; } /* @@ -80,33 +75,32 @@ static void term_destination (jpeg::j_compress_ptr cinfo) * The caller must have already opened the stream, and is responsible * for closing it after finishing decompression. */ -static void jpeg_SDL_RW_dest(jpeg::j_compress_ptr cinfo, SDL_RWops *ctx) +static void jpeg_SDL_RW_dest( jpeg::j_compress_ptr cinfo, SDL_RWops *ctx ) { - my_destination_mgr *dest; + my_destination_mgr *dest; - /* The source object and input buffer are made permanent so that a series - * of JPEG images can be read from the same file by calling jpeg_stdio_src - * only before the first one. (If we discarded the buffer at the end of - * one image, we'd likely lose the start of the next one.) - * This makes it unsafe to use this manager and a different source - * manager serially with the same JPEG object. Caveat programmer. - */ - if( cinfo->dest == NULL ) - { - /* first time for this JPEG object? */ - cinfo->dest = (struct jpeg::jpeg_destination_mgr *) - (*cinfo->mem->alloc_small) ((jpeg::j_common_ptr) cinfo, JPOOL_PERMANENT, - sizeof(my_destination_mgr)); - dest = (my_destination_mgr *) cinfo->dest; - } + /* The source object and input buffer are made permanent so that a series + * of JPEG images can be read from the same file by calling jpeg_stdio_src + * only before the first one. (If we discarded the buffer at the end of + * one image, we'd likely lose the start of the next one.) + * This makes it unsafe to use this manager and a different source + * manager serially with the same JPEG object. Caveat programmer. */ + if( cinfo->dest == NULL ) + { + /* first time for this JPEG object? */ + cinfo->dest = (struct jpeg::jpeg_destination_mgr *) + (*cinfo->mem->alloc_small) ( (jpeg::j_common_ptr) cinfo, JPOOL_PERMANENT, + sizeof(my_destination_mgr) ); + dest = (my_destination_mgr *) cinfo->dest; + } - dest = (my_destination_mgr *) cinfo->dest; - dest->pub.init_destination = init_destination; - dest->pub.empty_output_buffer = empty_output_buffer; - dest->pub.term_destination = term_destination; - dest->ctx = ctx; - dest->pub.free_in_buffer = OUTPUT_BUFFER_SIZE; /* forces fill_input_buffer on first read */ - dest->pub.next_output_byte = dest->buffer; /* until buffer loaded */ + dest = (my_destination_mgr *) cinfo->dest; + dest->pub.init_destination = init_destination; + dest->pub.empty_output_buffer = empty_output_buffer; + dest->pub.term_destination = term_destination; + dest->ctx = ctx; + dest->pub.free_in_buffer = OUTPUT_BUFFER_SIZE; /* forces fill_input_buffer on first read */ + dest->pub.next_output_byte = dest->buffer; /* until buffer loaded */ } /* Save a JPEG to a file. cjpeg.c and example.c from jpeglib were helpful in writing this. */ @@ -117,89 +111,54 @@ void IMG_SaveJPG_RW( SDL_Surface *surface, SDL_RWops *dest, bool bHighQual ) surface->w, surface->h, 24, mySDL_SwapBE24(0xFF0000), mySDL_SwapBE24(0x00FF00), mySDL_SwapBE24(0x0000FF), 0 ) ) surface = dst_surface; - struct jpeg::jpeg_compress_struct cinfo; + struct jpeg::jpeg_compress_struct cinfo; - /* Step 1: allocate and initialize JPEG compression object */ + /* Set up the error handler. */ + struct jpeg::jpeg_error_mgr jerr; + cinfo.err = jpeg::jpeg_std_error( &jerr ); - /* 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. - */ - struct jpeg::jpeg_error_mgr jerr; - cinfo.err = jpeg::jpeg_std_error(&jerr); + /* Now we can initialize the JPEG compression object. */ + jpeg::jpeg_CreateCompress(&cinfo, JPEG_LIB_VERSION, \ + (size_t) sizeof(struct jpeg::jpeg_compress_struct)); - /* Now we can initialize the JPEG compression object. */ - jpeg::jpeg_CreateCompress(&cinfo, JPEG_LIB_VERSION, \ - (size_t) sizeof(struct jpeg::jpeg_compress_struct)); + cinfo.image_width = surface->w; /* image width and height, in pixels */ + cinfo.image_height = surface->h; + cinfo.input_components = 3; /* # of color components per pixel */ + cinfo.in_color_space = jpeg::JCS_RGB; /* colorspace of input image */ - /* Step 2: specify data destination (eg, a file) */ - /* Note: steps 2 and 3 can be done in either order. */ + /* Set compression parameters. You must set at least cinfo.in_color_space before + * calling this.*/ + jpeg::jpeg_set_defaults(&cinfo); - /* Here we use the library-supplied code to send compressed data to a - * stdio stream. You can also write your own code to do something else. - * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that - * requires it in order to write binary files. - */ - jpeg_SDL_RW_dest(&cinfo, dest); + if( bHighQual ) + jpeg::jpeg_set_quality( &cinfo, 150, TRUE ); + else + jpeg::jpeg_set_quality( &cinfo, 40, TRUE ); - /* Step 3: set parameters for compression */ + jpeg_SDL_RW_dest( &cinfo, dest ); - /* First we supply a description of the input image. - * Four fields of the cinfo struct must be filled in: - */ - cinfo.image_width = surface->w; /* image width and height, in pixels */ - cinfo.image_height = surface->h; - cinfo.input_components = 3; /* # of color components per pixel */ - cinfo.in_color_space = jpeg::JCS_RGB; /* colorspace of input image */ - /* Now use the library's routine to set default compression parameters. - * (You must set at least cinfo.in_color_space before calling this, - * since the defaults depend on the source color space.) - */ - jpeg::jpeg_set_defaults(&cinfo); - if( bHighQual ) - jpeg::jpeg_set_quality( &cinfo, 150, TRUE ); - else - jpeg::jpeg_set_quality( &cinfo, 40, TRUE ); + /* Start the compressor. */ + jpeg::jpeg_start_compress( &cinfo, TRUE ); - /* Step 4: Start compressor */ + /* Here we use the library's state variable cinfo.next_scanline as the + * loop counter, so that we don't have to keep track ourselves. + * To keep things simple, we pass one scanline per call; you can pass + * more if you wish, though. */ + const int row_stride = surface->pitch; /* JSAMPLEs per row in image_buffer */ - /* TRUE ensures that we will write a complete interchange-JPEG file. - * Pass TRUE unless you are very sure of what you're doing. - */ - jpeg::jpeg_start_compress(&cinfo, TRUE); + while( cinfo.next_scanline < cinfo.image_height ) + { + /* jpeg_write_scanlines expects an array of pointers to scanlines. + * Here the array is only one element long, but you could pass + * more than one scanline at a time if that's more convenient. */ + jpeg::JSAMPROW row_pointer = & ((jpeg::JSAMPLE*)surface->pixels)[cinfo.next_scanline * row_stride]; + jpeg::jpeg_write_scanlines( &cinfo, &row_pointer, 1 ); + } - /* Step 5: while (scan lines remain to be written) */ - /* jpeg_write_scanlines(...); */ + /* Finish compression. */ + jpeg::jpeg_finish_compress( &cinfo ); + jpeg::jpeg_destroy_compress( &cinfo ); - /* Here we use the library's state variable cinfo.next_scanline as the - * loop counter, so that we don't have to keep track ourselves. - * To keep things simple, we pass one scanline per call; you can pass - * more if you wish, though. - */ - const int row_stride = surface->pitch; /* JSAMPLEs per row in image_buffer */ - - while( cinfo.next_scanline < cinfo.image_height ) - { - /* jpeg_write_scanlines expects an array of pointers to scanlines. - * Here the array is only one element long, but you could pass - * more than one scanline at a time if that's more convenient. - */ - jpeg::JSAMPROW row_pointer = & ((jpeg::JSAMPLE*)surface->pixels)[cinfo.next_scanline * row_stride]; - jpeg::jpeg_write_scanlines(&cinfo, &row_pointer, 1); - } - - /* Step 6: Finish compression */ - - jpeg::jpeg_finish_compress(&cinfo); - /* After finish_compress, we can close the output file. */ - - /* Step 7: release JPEG compression object */ - - /* This is an important step since it will release a good deal of memory. */ - jpeg::jpeg_destroy_compress(&cinfo); - - /* And we're done! */ if( dst_surface ) SDL_FreeSurface( dst_surface ); }