open source

Conch/source/common/imageLib/JCJpegImg.cpp

@@ -0,0 +1,425 @@
+/**
+@file			JCJpegImg.cpp
+@brief			
+@author			hugao
+@version		1.0
+@date			2016_5_11
+*/
+
+#include <stdio.h>
+#include <memory.h>
+#include <stdlib.h>
+#include "JCImageRW.h"
+#include "../util/JCCommonMethod.h"
+#pragma warning (disable: 4996)
+//------------------------------------------------------------------------------
+
+/*
+ * Include file for users of JPEG library.
+ * You will need to have included system headers that define at least
+ * the typedefs FILE and size_t before you can include jpeglib.h.
+ * (stdio.h is sufficient on ANSI-conforming systems.)
+ * You may also wish to include "jerror.h".
+ */
+#include "jpeglib.h"
+/*
+ * <setjmp.h> is used for the optional error recovery mechanism shown in
+ * the second part of the example.
+ */
+#include <setjmp.h>
+namespace laya
+{
+	/******************** JPEG COMPRESSION SAMPLE INTERFACE *******************/
+
+	/* This half of the example shows how to feed data into the JPEG compressor.
+	 * We present a minimal version that does not worry about refinements such
+	 * as error recovery (the JPEG code will just exit() if it gets an error).
+	 */
+	/*
+	 * ERROR HANDLING:
+	 *
+	 * The JPEG library's standard error handler (jerror.c) is divided into
+	 * several "methods" which you can override individually.  This lets you
+	 * adjust the behavior without duplicating a lot of code, which you might
+	 * have to update with each future release.
+	 *
+	 * Our example here shows how to override the "error_exit" method so that
+	 * control is returned to the library's caller when a fatal error occurs,
+	 * rather than calling exit() as the standard error_exit method does.
+	 *
+	 * We use C's setjmp/longjmp facility to return control.  This means that the
+	 * routine which calls the JPEG library must first execute a setjmp() call to
+	 * establish the return point.  We want the replacement error_exit to do a
+	 * longjmp().  But we need to make the setjmp buffer accessible to the
+	 * error_exit routine.  To do this, we make a private extension of the
+	 * standard JPEG error handler object.  (If we were using C++, we'd say we
+	 * were making a subclass of the regular error handler.)
+	 *
+	 * Here's the extended error handler struct:
+	 */
+
+	struct my_error_mgr {
+	  struct jpeg_error_mgr pub;	/* "public" fields */
+
+	  jmp_buf setjmp_buffer;	/* for return to caller */
+	};
+
+	typedef struct my_error_mgr * my_error_ptr;
+
+	/*
+	 * Here's the routine that will replace the standard error_exit method:
+	 */
+
+	METHODDEF(void)
+	my_error_exit (j_common_ptr cinfo)
+	{
+	  /* cinfo->err really points to a my_error_mgr struct, so coerce pointer */
+	  my_error_ptr myerr = (my_error_ptr) cinfo->err;
+
+	  /* Always display the message. */
+	  /* We could postpone this until after returning, if we chose. */
+	  (*cinfo->err->output_message) (cinfo);
+
+	  /* Return control to the setjmp point */
+	  longjmp(myerr->setjmp_buffer, 1);
+	}
+
+
+	/*
+	 * Sample routine for JPEG decompression.  We assume that the source file name
+	 * is passed in.  We want to return 1 on success, 0 on error.
+	 */
+	unsigned char* readFile(const char* filename,int &size)
+	{
+	  unsigned char *infile;
+	  FILE* fInput;
+	  if ((fInput = fopen(filename, "rb")) == NULL)
+	  {
+		  fprintf(stderr, "can't open %s\n", filename);
+		  return 0;
+	  }
+	  fseek(fInput,0L,SEEK_END);
+	  size=ftell(fInput);
+	  fseek(fInput,0L,SEEK_SET);
+	  infile = (unsigned char*)malloc(size);
+	  if (!infile) {
+		  throw - 3;
+	  }
+	  else {
+		  size = fread(infile, 1, size, fInput);
+	  }
+	  fclose(fInput);
+	  return infile;
+	}
+
+	GLOBAL(int) LoadJpegFromMem (BitmapData * texture,unsigned  char * infile,int size )
+	{
+	  /* 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.
+	   */
+	  struct my_error_mgr jerr;
+	  /* More stuff */
+	  JSAMPARRAY buffer;		/* Output row buffer */
+	  int row_stride;		/* physical row width in output buffer */
+
+	  /* In this example we want to open the input file before doing anything else,
+	   * so that the setjmp() error recovery below can assume the file is open.
+	   * VERY IMPORTANT: use "b" option to fopen() if you are on a machine that
+	   * requires it in order to read binary files.
+	   */
+	  /* Step 1: allocate and initialize JPEG decompression object */
+
+	  /* We set up the normal JPEG error routines, then override error_exit. */
+	  cinfo.err = jpeg_std_error(&jerr.pub);
+	  jerr.pub.error_exit = my_error_exit;
+	  /* Establish the setjmp return context for my_error_exit to use. */
+	  if (setjmp(jerr.setjmp_buffer)) {
+		/* If we get here, the JPEG code has signaled an error.
+		 * We need to clean up the JPEG object, close the input file, and return.
+		 */
+		jpeg_destroy_decompress(&cinfo);
+		//fclose(infile);
+		return 0;
+	  }
+	  /* Now we can initialize the JPEG decompression object. */
+	  jpeg_create_decompress(&cinfo);
+
+	  /* Step 2: specify data source (eg, a file) */
+
+	  //jpeg_stdio_src(&cinfo, infile);
+	  jpeg_mem_src(&cinfo, infile,size);
+
+	  /* 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.txt 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.
+	   */
+
+      if (cinfo.jpeg_color_space == JCS_GRAYSCALE)
+      {
+      }
+      else
+      {
+          cinfo.out_color_space = JCS_RGB;
+      }
+
+	  /* 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.
+	   */
+
+	  texture->m_nWidth  = cinfo.image_width;
+	  texture->m_nHeight = cinfo.output_height;
+	  texture->m_nBpp = 32;//cinfo.output_components * 8;
+	  /*if(cinfo.output_components!=3)
+	  {
+          (void)jpeg_finish_decompress(&cinfo);
+          jpeg_destroy_decompress(&cinfo);
+		  return false;
+	  }*/
+	#if 0
+	  if(cinfo.output_components == 3)
+	  {
+		texture->type	= GL_RGB;
+	  }
+	  else  // Else if its 32 BPP
+	  {
+		texture->type	= GL_RGBA;
+	  }
+		texture->imageData = std::shared_ptr<GLubyte> (new GLubyte[texture->width*texture->height*cinfo.output_components], std::default_delete<char[]>());
+	#endif
+        
+	  //texture->type	= GL_RGBA;
+	  texture->m_pImageData = /*std::shared_array<char> */(new char[texture->m_nWidth*texture->m_nHeight*texture->m_nBpp / 8]);
+	  if(texture->m_pImageData == NULL)											// If no space was allocated
+	  {
+		  //fclose(infile);														// Close the file
+          (void)jpeg_finish_decompress(&cinfo);
+          jpeg_destroy_decompress(&cinfo);
+		  return false;														// Return failed
+	  }
+
+	  /* 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;
+	  /* Make a one-row-high sample array that will go away when done with image */
+	  buffer = (*cinfo.mem->alloc_sarray)
+			((j_common_ptr) &cinfo, JPOOL_IMAGE, row_stride, 1);
+
+	  /* 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.
+	   */
+	 #if 0
+	  int bufOffset = 0;
+	  int line =1;
+	  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.
+		 */
+		(void) jpeg_read_scanlines(&cinfo, buffer, 1);
+		/* Assume put_scanline_someplace wants a pointer and sample count. */
+		bufOffset = (cinfo.output_height-line)*row_stride;
+		memcpy(texture->imageData+bufOffset,buffer[0],row_stride);   //kuo
+		line++;
+	  }
+	#else
+		int line =0;
+        int pixels = 0;
+        if (cinfo.jpeg_color_space == JCS_GRAYSCALE)
+        {
+            pixels = row_stride;
+        }
+        else
+        {
+            pixels = row_stride / 3;
+        }
+		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.
+			*/
+			(void) jpeg_read_scanlines(&cinfo, buffer, 1);
+			unsigned char* startBuffer = (unsigned char*)texture->m_pImageData+line*pixels*4;
+            if (cinfo.jpeg_color_space == JCS_GRAYSCALE)
+            {
+                for (int i = 0; i < pixels; ++i)
+                {
+                    startBuffer[i * 4 + 0] = buffer[0][i];
+                    startBuffer[i * 4 + 1] = buffer[0][i];
+                    startBuffer[i * 4 + 2] = buffer[0][i];
+                    startBuffer[i * 4 + 3] = 255;
+                }
+            }
+            else
+            {
+                for (int i = 0; i < pixels; ++i)
+                {
+                    startBuffer[i * 4 + 0] = buffer[0][i * 3 + 0];
+                    startBuffer[i * 4 + 1] = buffer[0][i * 3 + 1];
+                    startBuffer[i * 4 + 2] = buffer[0][i * 3 + 2];
+                    startBuffer[i * 4 + 3] = 255;
+                }
+            }
+			/* Assume put_scanline_someplace wants a pointer and sample count. */
+			//memcpy(texture->imageData+line*row_stride,buffer[0],row_stride);   //kuo
+			line++;
+		}
+
+	#endif
+	  /* 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...)
+	   */
+	  //fclose(infile);
+
+
+	  /* 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 1;
+	}
+
+	//------------------------------------------------------------------------------
+	bool LoadJpegWH( const char* p_sFileName,int& p_nWidth,int& p_nHeight )
+    {
+		return true;
+	}
+	//保存jpeg图片，要求格式必须为rgb的
+	bool saveJpeg(int width ,int height,int bpp, char *buffer, int quality, const char*filename){
+		int components = bpp/8;
+		if( components!=1 && components!=3 )
+			return false;
+		jpeg_compress_struct jcs;
+		jpeg_error_mgr jem;
+		FILE *fp;
+		JSAMPROW row_pointer[1];//?一行位图?
+		int row_stride; //?每一行的字节数
+		jcs.err = jpeg_std_error(&jem);
+		jpeg_create_compress(&jcs);
+		fp = fopen(filename,"wb");
+		if(fp==NULL)
+			return false;
+		jpeg_stdio_dest(&jcs,fp);
+		jcs.image_width = width; //位图的宽和高，单位为像素
+		jcs.image_height = height;
+		jcs.input_components =components; //?在此为1,表示灰度图，?如果是彩色位图，则为3?
+		jcs.in_color_space = components==3?JCS_RGB:JCS_GRAYSCALE;//JCS_GRAYSCALE表示灰度图，JCS_RGB表示彩色图像??
+		jpeg_set_defaults(&jcs);
+		jpeg_set_quality(&jcs, quality, (boolean)true);
+		jpeg_start_compress(&jcs,(boolean)true);
+		row_stride = jcs.input_components*width;	/* JSAMPLEs per row in image_buffer */
+		while(jcs.next_scanline < jcs.image_height){
+			row_pointer[0] = (JSAMPROW)&buffer[jcs.next_scanline * row_stride ];
+			jpeg_write_scanlines(&jcs, row_pointer, 1);
+		}
+		jpeg_finish_compress(&jcs);
+		jpeg_destroy_compress(&jcs);
+		fclose(fp);
+		return true;
+	}
+    std::pair<unsigned char*, unsigned long> convertBitmapToJpeg(int uWidth, int uHeight, int bpp, unsigned char* pImg, int iQuality)
+    {
+        std::pair<unsigned char*, unsigned long> mRes = std::make_pair((unsigned char*)NULL, 0);
+        int components = bpp / 8;
+        if (components != 1 && components != 3)
+            return mRes;
+        jpeg_compress_struct  jcInfo;
+        jpeg_error_mgr      jErr;
+        jcInfo.err = jpeg_std_error(&jErr);
+
+        jpeg_create_compress(&jcInfo);
+
+        jpeg_mem_dest(&jcInfo, &mRes.first, &mRes.second);
+
+        jcInfo.image_width = uWidth;
+        jcInfo.image_height = uHeight;
+        jcInfo.input_components = 3;
+        jcInfo.in_color_space = JCS_RGB;
+
+
+        jpeg_set_defaults(&jcInfo);
+
+        jpeg_set_quality(&jcInfo, iQuality, TRUE);
+
+        jpeg_start_compress(&jcInfo, TRUE);
+        int  iRowStride = jcInfo.image_width * jcInfo.input_components;
+        while (jcInfo.next_scanline < jcInfo.image_height) {
+            JSAMPROW pData = &(pImg[jcInfo.next_scanline * iRowStride]);
+            jpeg_write_scanlines(&jcInfo, &pData, 1);
+        }
+
+        jpeg_finish_compress(&jcInfo);
+
+        jpeg_destroy_compress(&jcInfo);
+
+        return mRes;
+    }
+    std::pair<unsigned char*, unsigned long> convertBitmapToJpeg(const char* p_pData, int nWidth, int nHeight, int nBpp)
+    {
+        char* pData = (char*)p_pData;
+
+        //32转24
+        if (nBpp == 32) {
+            pData = new char[nWidth*nHeight * 3];
+            char* pSrc = (char*)p_pData;
+            char* pDst = pData;
+            for (int y = 0; y < nHeight; y++) {
+                for (int x = 0; x < nWidth; x++) {
+                    pDst[0] = pSrc[0]; pDst[1] = pSrc[1]; pDst[2] = pSrc[2];
+                    pSrc += 4;
+                    pDst += 3;
+                }
+            }
+        }
+        std::pair<unsigned char*, unsigned long> ret = convertBitmapToJpeg(nWidth, nHeight, 24, (unsigned char*)pData, 80);
+        if (nBpp == 32)
+            delete[] pData;
+
+        return ret;
+    }
+}
+//------------------------------------------------------------------------------
+
+
+//-----------------------------END FILE--------------------------------