-\r
- \r
-#include "radiant_jpeglib.h"\r
-#include "jerror.h"\r
-#include <memory.h>\r
-\r
-GLOBAL int LoadJPGBuff(unsigned char *fbuffer, int bufsize, unsigned char **pic, int *width, int *height ) \r
-{\r
-\r
- /* This struct contains the JPEG decompression parameters and pointers to\r
- * working space (which is allocated as needed by the JPEG library).\r
- */\r
- struct jpeg_decompress_struct cinfo;\r
- /* We use our private extension JPEG error handler.\r
- * Note that this struct must live as long as the main JPEG parameter\r
- * struct, to avoid dangling-pointer problems.\r
- */\r
- /* This struct represents a JPEG error handler. It is declared separately\r
- * because applications often want to supply a specialized error handler\r
- * (see the second half of this file for an example). But here we just\r
- * take the easy way out and use the standard error handler, which will\r
- * print a message on stderr and call exit() if compression fails.\r
- * Note that this struct must live as long as the main JPEG parameter\r
- * struct, to avoid dangling-pointer problems.\r
- */\r
-\r
- struct jpeg_error_mgr jerr;\r
- /* More stuff */\r
- JSAMPARRAY buffer; /* Output row buffer */\r
- int row_stride; /* physical row width in output buffer */\r
- unsigned char *out, *bbuf;\r
- int nSize;\r
- int jmpret;\r
-\r
- // Rad additions: initialize the longjmp buffer\r
- jmpret = setjmp( rad_loadfailed );\r
- if (jmpret != 0)\r
- {\r
- *pic = (unsigned char *)rad_errormsg;\r
- return -1;\r
- }\r
-\r
- /* Step 1: allocate and initialize JPEG decompression object */\r
-\r
- /* We have to set up the error handler first, in case the initialization\r
- * step fails. (Unlikely, but it could happen if you are out of memory.)\r
- * This routine fills in the contents of struct jerr, and returns jerr's\r
- * address which we place into the link field in cinfo.\r
- */\r
- cinfo.err = jpeg_std_error(&jerr);\r
-\r
- /* Now we can initialize the JPEG decompression object. */\r
- jpeg_create_decompress(&cinfo);\r
-\r
- /* Step 2: specify data source (eg, a file) */\r
-\r
- jpeg_stdio_src(&cinfo, fbuffer, bufsize);\r
-\r
- /* Step 3: read file parameters with jpeg_read_header() */\r
-\r
- (void) jpeg_read_header(&cinfo, TRUE);\r
- /* We can ignore the return value from jpeg_read_header since\r
- * (a) suspension is not possible with the stdio data source, and\r
- * (b) we passed TRUE to reject a tables-only JPEG file as an error.\r
- * See libjpeg.doc for more info.\r
- */\r
-\r
- /* Step 4: set parameters for decompression */\r
-\r
- /* In this example, we don't need to change any of the defaults set by\r
- * jpeg_read_header(), so we do nothing here.\r
- */\r
-\r
- /* Step 5: Start decompressor */\r
-\r
- (void) jpeg_start_decompress(&cinfo);\r
- /* We can ignore the return value since suspension is not possible\r
- * with the stdio data source.\r
- */\r
- \r
- /* ydnar: radiant only handles RGB, non-progressive format jpegs */\r
- if( cinfo.output_components != 4 )\r
- {\r
- *pic = (unsigned char*) "Non-RGB JPEG encountered (unsupported)";\r
- return -1;\r
- }\r
- if( cinfo.progressive_mode )\r
- {\r
- *pic = (unsigned char*) "Progressive JPEG encountered (unsupported)";\r
- return -1;\r
- }\r
- \r
- /* We may need to do some setup of our own at this point before reading\r
- * the data. After jpeg_start_decompress() we have the correct scaled\r
- * output image dimensions available, as well as the output colormap\r
- * if we asked for color quantization.\r
- * In this example, we need to make an output work buffer of the right size.\r
- */ \r
- \r
- /* JSAMPLEs per row in output buffer */\r
- row_stride = cinfo.output_width * cinfo.output_components;\r
- nSize = cinfo.output_width*cinfo.output_height*cinfo.output_components;\r
- \r
- out = reinterpret_cast<unsigned char*>( malloc( nSize+ 1 ) );\r
- memset( out, 255, nSize + 1 );\r
- \r
- *pic = out;\r
- *width = cinfo.output_width;\r
- *height = cinfo.output_height;\r
-\r
- /* Step 6: while (scan lines remain to be read) */\r
- /* jpeg_read_scanlines(...); */\r
-\r
- /* Here we use the library's state variable cinfo.output_scanline as the\r
- * loop counter, so that we don't have to keep track ourselves.\r
- */\r
- while (cinfo.output_scanline < cinfo.output_height)\r
- {\r
- /* jpeg_read_scanlines expects an array of pointers to scanlines.\r
- * Here the array is only one element long, but you could ask for\r
- * more than one scanline at a time if that's more convenient.\r
- */\r
- bbuf = out + row_stride * cinfo.output_scanline;\r
- buffer = &bbuf;\r
- (void) jpeg_read_scanlines( &cinfo, buffer, 1 );\r
- }\r
-\r
- // clear all the alphas to 255\r
- {\r
- int i, j;\r
- unsigned char *buf;\r
-\r
- buf = *pic;\r
-\r
- j = cinfo.output_width * cinfo.output_height * 4;\r
- for ( i = 3 ; i < j ; i+=4 ) {\r
- buf[i] = 255;\r
- }\r
- }\r
-\r
- /* Step 7: Finish decompression */\r
-\r
- (void) jpeg_finish_decompress(&cinfo);\r
- /* We can ignore the return value since suspension is not possible\r
- * with the stdio data source.\r
- */\r
-\r
- /* Step 8: Release JPEG decompression object */\r
-\r
- /* This is an important step since it will release a good deal of memory. */\r
- jpeg_destroy_decompress(&cinfo);\r
-\r
- /* After finish_decompress, we can close the input file.\r
- * Here we postpone it until after no more JPEG errors are possible,\r
- * so as to simplify the setjmp error logic above. (Actually, I don't\r
- * think that jpeg_destroy can do an error exit, but why assume anything...)\r
- */\r
- //free (fbuffer);\r
-\r
- /* At this point you may want to check to see whether any corrupt-data\r
- * warnings occurred (test whether jerr.pub.num_warnings is nonzero).\r
- */\r
-\r
- /* And we're done! */\r
- return 0;\r
-}\r
-\r
+
+
+#include "radiant_jpeglib.h"
+#include "jerror.h"
+#include <memory.h>
+
+GLOBAL int LoadJPGBuff(unsigned char *fbuffer, int bufsize, unsigned char **pic, int *width, int *height )
+{
+
+ /* 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, *bbuf;
+ int nSize;
+ int jmpret;
+
+ // Rad additions: initialize the longjmp buffer
+ jmpret = setjmp( rad_loadfailed );
+ if (jmpret != 0)
+ {
+ *pic = (unsigned char *)rad_errormsg;
+ return -1;
+ }
+
+ /* 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_stdio_src(&cinfo, fbuffer, bufsize);
+
+ /* Step 3: read file parameters with jpeg_read_header() */
+
+ (void) jpeg_read_header(&cinfo, TRUE);
+ /* 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 */
+
+ (void) jpeg_start_decompress(&cinfo);
+ /* We can ignore the return value since suspension is not possible
+ * with the stdio data source.
+ */
+
+ /* ydnar: radiant only handles RGB, non-progressive format jpegs */
+ if( cinfo.output_components != 4 )
+ {
+ *pic = (unsigned char*) "Non-RGB JPEG encountered (unsupported)";
+ return -1;
+ }
+ if( cinfo.progressive_mode )
+ {
+ *pic = (unsigned char*) "Progressive JPEG encountered (unsupported)";
+ return -1;
+ }
+
+ /* 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;
+ nSize = cinfo.output_width*cinfo.output_height*cinfo.output_components;
+
+ out = reinterpret_cast<unsigned char*>( malloc( nSize+ 1 ) );
+ memset( out, 255, nSize + 1 );
+
+ *pic = out;
+ *width = cinfo.output_width;
+ *height = 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;
+ (void) jpeg_read_scanlines( &cinfo, buffer, 1 );
+ }
+
+ // clear all the alphas to 255
+ {
+ int i, j;
+ unsigned char *buf;
+
+ buf = *pic;
+
+ j = cinfo.output_width * cinfo.output_height * 4;
+ for ( i = 3 ; i < j ; i+=4 ) {
+ buf[i] = 255;
+ }
+ }
+
+ /* Step 7: Finish decompression */
+
+ (void) 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);
+
+ /* After finish_decompress, we can close the input file.
+ * Here we postpone it until after no more JPEG errors are possible,
+ * so as to simplify the setjmp error logic above. (Actually, I don't
+ * think that jpeg_destroy can do an error exit, but why assume anything...)
+ */
+ //free (fbuffer);
+
+ /* At this point you may want to check to see whether any corrupt-data
+ * warnings occurred (test whether jerr.pub.num_warnings is nonzero).
+ */
+
+ /* And we're done! */
+ return 0;
+}
+
projects / xonotic / netradiant.git / blobdiff