jpegfile.cpp

超声影像工作站系统可与各种型号的B超、彩超连接

   */

  jpeg_set_defaults(&cinfo);
  /* Now you can set any non-default parameters you wish to.
   * Here we just illustrate the use of quality (quantization table) scaling:
   */
  jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);

  /* Step 4: Start compressor */

  /* TRUE ensures that we will write a complete interchange-JPEG file.
   * Pass TRUE unless you are very sure of what you're doing.
   */
  jpeg_start_compress(&cinfo, TRUE);

  /* Step 5: while (scan lines remain to be written) */
  /*           jpeg_write_scanlines(...); */

  /* 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.
   */
  row_stride = widthPix * 3;	/* 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.
     */
	LPBYTE outRow;
	if (color) {
		outRow = dataBuf + (cinfo.next_scanline * widthPix * 3);
	} else {
		outRow = tmp + (cinfo.next_scanline * widthPix);
	}

    (void) jpeg_write_scanlines(&cinfo, &outRow, 1);
  }

  /* Step 6: Finish compression */

  jpeg_finish_compress(&cinfo);

  /* After finish_compress, we can close the output file. */
  fclose(outfile);

  /* Step 7: release JPEG compression object */

  /* This is an important step since it will release a good deal of memory. */
  jpeg_destroy_compress(&cinfo);

  if (!color)
	  delete [] tmp;
  /* And we're done! */

  return TRUE;
}

//
//	stash a scanline
//

void j_putRGBScanline(BYTE *jpegline, 
					 int widthPix,
					 BYTE *outBuf,
					 int row)
{
	int offset = row * widthPix * 3;
	int count;
	for (count=0;count<widthPix;count++) {
		BYTE iRed, iBlu, iGrn;
		LPBYTE oRed, oBlu, oGrn;

		iRed = *(jpegline + count * 3 + 0);
		iGrn = *(jpegline + count * 3 + 1);
		iBlu = *(jpegline + count * 3 + 2);

		oRed = outBuf + offset + count * 3 + 0;
		oGrn = outBuf + offset + count * 3 + 1;
		oBlu = outBuf + offset + count * 3 + 2;

		*oRed = iRed;
		*oGrn = iGrn;
		*oBlu = iBlu;
	}
}

//
//	stash a gray scanline
//

void j_putGrayScanlineToRGB(BYTE *jpegline, 
							 int widthPix,
							 BYTE *outBuf,
							 int row)
{
	int offset = row * widthPix * 3;
	int count;
	for (count=0;count<widthPix;count++) {

		BYTE iGray;
		LPBYTE oRed, oBlu, oGrn;

		// get our grayscale value
		iGray = *(jpegline + count);

		oRed = outBuf + offset + count * 3;
		oGrn = outBuf + offset + count * 3 + 1;
		oBlu = outBuf + offset + count * 3 + 2;

		*oRed = iGray;
		*oGrn = iGray;
		*oBlu = iGray;
	}
}

//
// copies BYTE buffer into DWORD-aligned BYTE buffer
// return addr of new buffer
//

BYTE * JpegFile::MakeDwordAlignedBuf(BYTE *dataBuf,
									 UINT widthPix,				// pixels!!
									 UINT height,
									 UINT *uiOutWidthBytes,int flag)		// bytes!!!
{
	////////////////////////////////////////////////////////////
	// what's going on here? this certainly means trouble 
	if	(NULL == dataBuf)	return NULL;

	////////////////////////////////////////////////////////////
	// how big is the smallest DWORD-aligned buffer that we can use?
	UINT	uiWidthBytes;
	if(flag==1)
		uiWidthBytes = WIDTHBYTES(widthPix * 24);
	else
		uiWidthBytes = WIDTHBYTES(widthPix * 8);

	DWORD dwNewsize=(DWORD)((DWORD)uiWidthBytes * 
							(DWORD)height);
	BYTE *pNew;

	////////////////////////////////////////////////////////////
	// alloc and open our new buffer
	pNew=(BYTE *)new BYTE[dwNewsize];
	if (pNew==NULL) {
		return NULL;
	}
	
	////////////////////////////////////////////////////////////
	// copy row-by-row
	UINT uiInWidthBytes ;
	uiInWidthBytes = widthPix * (flag*2+1);

	UINT uiCount;
	for (uiCount=0;uiCount < height;uiCount++) {
		BYTE * bpInAdd;
		BYTE * bpOutAdd;
		ULONG lInOff;
		ULONG lOutOff;

		lInOff=uiInWidthBytes * uiCount;
		lOutOff=uiWidthBytes * uiCount;

		bpInAdd= dataBuf + lInOff;
		bpOutAdd= pNew + lOutOff;

		memcpy(bpOutAdd,bpInAdd,uiInWidthBytes);
	}

	*uiOutWidthBytes=uiWidthBytes;
	return pNew;
}

BOOL JpegFile::rightroteBuf(BYTE * inbuf,						// input buf
					   UINT *height,							// input width bytes
					   UINT *width,int flag)							// height
{
	BYTE *temp;
	if(flag==1)
		temp=new BYTE[(*height)*(*width)*3];
	else
		temp=new BYTE[(*height)*(*width)];
	if( temp==NULL) return FALSE;
	if(flag==1)
		memcpy(temp,inbuf,(*height)*(*width)*3);
	else
		memcpy(temp,inbuf,(*height)*(*width));
	long i=0,offest;
	for(int w=(*width)-1;w>=0;w--)
		for(unsigned int h=0;h<*height;h++)
		{
			if(flag==1)
			{
				offest=h*(*width)*3+w*3;
				inbuf[i++]=temp[offest++];
				inbuf[i++]=temp[offest++];
				inbuf[i++]=temp[offest++];
			}
			else
			{
				offest=h*(*width)+w;
				inbuf[i++]=temp[offest++];
			}
		}
	delete [] temp;
	UINT tt=*width;
	*width=*height;
	*height=tt;
	return TRUE;
	
}
BOOL JpegFile::leftroteBuf(BYTE * inbuf,						// input buf
					   UINT *height,							// input width bytes
					   UINT *width,int flag)							// height
{
	BYTE *temp;
	if(flag==1)
		temp=new BYTE[(*height)*(*width)*3];
	else
		temp=new BYTE[(*height)*(*width)];
	if( temp==NULL) return FALSE;
	if(flag==1)
		memcpy(temp,inbuf,(*height)*(*width)*3);
	else
		memcpy(temp,inbuf,(*height)*(*width));
	long i=0,offest;
	for(unsigned int w=0;w<(*width);w++)
		for(int h=(*height)-1;h>=0;h--)
		{
			if(flag==1)
			{
				offest=h*(*width)*3+w*3;
				inbuf[i++]=temp[offest++];
				inbuf[i++]=temp[offest++];
				inbuf[i++]=temp[offest++];
			}
			else
			{
				offest=h*(*width)+w;
				inbuf[i++]=temp[offest++];
				//inbuf[i++]=temp[offest++];
				//inbuf[i++]=temp[offest++];
			}
		}
	delete [] temp;
	UINT tt=*width;
	*width=*height;
	*height=tt;
	return TRUE;
}

BOOL JpegFile::HerzFlipBuf(BYTE * inbuf,
					   UINT height,
					   UINT width,int flag)

{
	BYTE  tb1;
	if (inbuf==NULL) return FALSE;
	UINT colcnt;
	UINT linesize;
	if(flag==1)
		linesize=width*3;
	else
		linesize=width;
	UINT offest;
	for (colcnt=0;colcnt<(width+1)/2;colcnt++) 
	for( unsigned int row=0;row<height;row++)
	{
		offest=row*linesize;
		if(flag==1)
		{
			tb1=inbuf[offest+colcnt*3];inbuf[offest+colcnt*3]=inbuf[offest+(width-colcnt-1)*3];inbuf[offest+(width-colcnt-1)*3]=tb1;
			offest++;
			tb1=inbuf[offest+colcnt*3];inbuf[offest+colcnt*3]=inbuf[offest+(width-colcnt-1)*3];inbuf[offest+(width-colcnt-1)*3]=tb1;
			offest++;
			tb1=inbuf[offest+colcnt*3];inbuf[offest+colcnt*3]=inbuf[offest+(width-colcnt-1)*3];inbuf[offest+(width-colcnt-1)*3]=tb1;
		}
		else
			tb1=inbuf[offest+colcnt];inbuf[offest+colcnt]=inbuf[offest+(width-colcnt-1)];inbuf[offest+(width-colcnt-1)]=tb1;

	}	


	return TRUE;

}
//
//	vertically flip a buffer 
//	note, this operates on a buffer of widthBytes bytes, not pixels!!!
//

BOOL JpegFile::VertFlipBuf(BYTE  * inbuf, 
					   UINT widthBytes, 
					   UINT height)
{   
	BYTE  *tb1;
	BYTE  *tb2;

	if (inbuf==NULL)
		return FALSE;

	UINT bufsize;

	bufsize=widthBytes;

	tb1= (BYTE *)new BYTE[bufsize];
	if (tb1==NULL) {
		return FALSE;
	}

	tb2= (BYTE *)new BYTE [bufsize];
	if (tb2==NULL) {
		return FALSE;
	}
	
	UINT row_cnt;     
	ULONG off1=0;
	ULONG off2=0;

	for (row_cnt=0;row_cnt<(height+1)/2;row_cnt++) {
		off1=row_cnt*bufsize;
		off2=((height-1)-row_cnt)*bufsize;   
		
		memcpy(tb1,inbuf+off1,bufsize);
		memcpy(tb2,inbuf+off2,bufsize);	
		memcpy(inbuf+off1,tb2,bufsize);
		memcpy(inbuf+off2,tb1,bufsize);
	}	

	delete [] tb1;
	delete [] tb2;

	return TRUE;
}        


//
//	swap Rs and Bs
//
//	Note! this does its stuff on buffers with a whole number of pixels
//	per data row!!
//


BOOL JpegFile::BGRFromRGB(BYTE *buf, UINT widthPix, UINT height)
{
	if (buf==NULL)
		return FALSE;

	UINT col, row;
	for (row=0;row<height;row++) {
		for (col=0;col<widthPix;col++) {
			LPBYTE pRed, pGrn, pBlu;
			pRed = buf + row * widthPix * 3 + col * 3;
			pGrn = buf + row * widthPix * 3 + col * 3 + 1;
			pBlu = buf + row * widthPix * 3 + col * 3 + 2;

			// swap red and blue
			BYTE tmp;
			tmp = *pRed;
			*pRed = *pBlu;
			*pBlu = tmp;
		}
	}
	return TRUE;
}

//
//	Note! this does its stuff on buffers with a whole number of pixels
//	per data row!!
//

BOOL JpegFile::MakeGrayScale(BYTE *buf, UINT widthPix, UINT height)
{
	if (buf==NULL)
		return FALSE;

	UINT row,col;
	for (row=0;row<height;row++) {
		for (col=0;col<widthPix;col++) {
			LPBYTE pRed, pGrn, pBlu;
			pRed = buf + row * widthPix * 3 + col * 3;
			pGrn = buf + row * widthPix * 3 + col * 3 + 1;
			pBlu = buf + row * widthPix * 3 + col * 3 + 2;

			// luminance
			int lum = (int)(.299 * (double)(*pRed) + .587 * (double)(*pGrn) + .114 * (double)(*pBlu));

			*pRed = (BYTE)lum;
			*pGrn = (BYTE)lum;
			*pBlu = (BYTE)lum;
		}
	}
	return TRUE;
}