直接在内存里进行BMP-->JPG，intel的IJL15库该如何使用？

[possible_Y]

intel的IJL15库该如何使用？我试了2个intel文档里的例子，一个是《A Memory-Mapped Bitmap
implementation of a JPEG Encoder》，结果在Mapped BMP文件时就出错了。
另一个是将一个内存中的DIB数据转化成内存中JPG格式数据（IJL_JBUFF_WRITEWHOLEIMAGE方式），然后我再save到硬盘上，执行成功了，JPG文件也生成了，但是JPG文件用查看器打开看却是乱的（好像还是黑白的）,代码如下：

BOOL bres;
IJLERR jerr;
DWORD dwRgbBufferSize;
BYTE* lpTemp = NULL;
JPEG_CORE_PROPERTIES jcprops;

bres = TRUE;
__try
{
// Initialize the Intel(R) JPEG Library.
jerr = ijlInit(&jcprops);
if(IJL_OK != jerr)
{
bres = FALSE;
__leave;
}

dwRgbBufferSize = m_nWidth * m_nHeight * 3;

lpTemp = new BYTE [dwRgbBufferSize];
if (NULL == lpTemp)
{
bres = FALSE;
__leave;
}

TRACE("%d",IJL_DIB_PAD_BYTES(jcprops.DIBWidth,jcprops.DIBChannels));
// Set up information to
jcprops.DIBWidth = m_nWidth;
jcprops.DIBHeight = m_nHeight; // Implies a bottom-up DIB.
jcprops.DIBBytes = m_pTmpSrcImg;
jcprops.DIBChannels = 3;
jcprops.DIBPadBytes = IJL_DIB_PAD_BYTES(jcprops.DIBWidth,jcprops.DIBChannels);
jcprops.DIBColor = IJL_BGR;

jcprops.JPGWidth = m_nWidth;
jcprops.JPGHeight = m_nHeight;
jcprops.JPGFile = NULL;
jcprops.JPGBytes = lpTemp;
jcprops.JPGSizeBytes = dwRgbBufferSize;
jcprops.JPGChannels = 3;
jcprops.JPGColor = IJL_YCBCR;
jcprops.JPGSubsampling = IJL_411; // 4:1:1 subsampling.
jcprops.jquality = quality; // select "good" image quality

// Write the actual JPEG image from the pixel buffer.
jerr = ijlWrite(&jcprops,IJL_JBUFF_WRITEWHOLEIMAGE);//IJL_JFILE_WRITEWHOLEIMAGE
if(IJL_OK != jerr)
{
bres = FALSE;
__leave;
}
} // try
__finally
{
if(FALSE == bres)
{
if (NULL != lpTemp)
{
delete[] lpTemp;
lpTemp = NULL;
}
}
*lppJpgBuffer = lpTemp;
*lpdwJpgBufferSize = jcprops.JPGSizeBytes;

// Clean up the Intel(R) JPEG Library.
ijlFree(&jcprops);
}

return bres;

后来我用了IJL_JFILE_WRITEWHOLEIMAGE方式直接生成JPG到硬盘上，结果生成的JPG文件用查看器打开看还是乱的
各位有用过IJL来做BMP-->JPG的，请指点指点，如果有Demo源代码最好，请发送到[e-mail]，一定高分相谢！！！！！

[huanyun]

int CXJpegIO::ReadJpegMem (CXImgObj& ImgObj, BYTE* pData, ULONG lLen)
{
int nRet = XFAILURE;
JPEG_CORE_PROPERTIES image;
memset(&image, 0, sizeof(JPEG_CORE_PROPERTIES));
TRY
{
if (ijlInit(&image) != IJL_OK)
{
TRACE("Cannot initialize Intel JPEG library\n");
AfxThrowUserException();
}

image.JPGFile = NULL;
image.JPGBytes = const_cast<BYTE*>(pData);
image.JPGSizeBytes = lLen;
if (ijlRead(&image, IJL_JBUFF_READPARAMS) != IJL_OK)
{
TRACE("Cannot read JPEG file header from %s file\n", image.JPGFile);
AfxThrowUserException();
}

switch (image.JPGChannels)
{
case 1:
image.JPGColor = IJL_G;
image.DIBChannels = 1;
image.DIBColor = IJL_G;
break;

case 3:
image.JPGColor = IJL_YCBCR;
image.DIBChannels = 3;
image.DIBColor = IJL_BGR;
break;

case 4:
image.JPGColor = IJL_YCBCRA_FPX;
image.DIBChannels = 4;
image.DIBColor = IJL_RGBA_FPX;
break;

default:
image.DIBColor = (IJL_COLOR)IJL_OTHER;
image.JPGColor = (IJL_COLOR)IJL_OTHER;
image.DIBChannels = image.JPGChannels;
break;
}
image.DIBWidth = image.JPGWidth;
image.DIBHeight = image.JPGHeight;
image.DIBPadBytes = IJL_DIB_PAD_BYTES(image.DIBWidth,image.DIBChannels);
if (image.DIBColor == IJL_G)
{
ImgObj.InitFromParam(image.DIBWidth, -image.DIBHeight, image.DIBChannels*8, 256);
ImgObj.SetGrayPal();
}
else
{
ImgObj.InitFromParam(image.DIBWidth, -image.DIBHeight, image.DIBChannels*8, 0);
}

if (ImgObj.GetBits() == NULL)
{
TRACE("Cannot allocate memory for image\n");
AfxThrowUserException();
}
image.DIBBytes = ImgObj.GetBits();

if (ijlRead(&image, IJL_JBUFF_READWHOLEIMAGE) != IJL_OK)
{
TRACE("Cannot read image data from %s file\n", image.JPGFile);
AfxThrowUserException();
}

if (ijlFree(&image) != IJL_OK)
{
TRACE("Cannot free Intel(R) JPEG library");
}

if (image.DIBColor == IJL_RGBA_FPX)
{
Change32RGB(ImgObj.GetBits(),image.DIBWidth,image.DIBHeight);
}
nRet = XSUCCESS;
}
CATCH_ALL(e)
{
ijlFree(&image);
AfxMessageBox("Error opening JPEG file");
}
END_CATCH_ALL
return nRet;
}

[huanyun]

int CXJpegIO::WriteJpegMem (CXImgObj& ImgObj, CXBuffer<BYTE>& Buf, int* nLen, BOOL bColor, UINT nQuality)
{
*nLen = -1;
int nRet = XFAILURE;
BOOL bChange24 = FALSE;
CXImgObj *pImg,xImg24;

pImg = &ImgObj;
if((ImgObj.GetBitCount() == 32 && !bColor) || ImgObj.GetBitCount() != 24)
{
xImg24.Create(24, ImgObj);
pImg = &xImg24;
bChange24 = TRUE;
}

BYTE *pBuf = Buf.GetBuf(pImg->GetBitsSize());
if(pBuf == NULL) return nRet;

JPEG_CORE_PROPERTIES image;
ZeroMemory(&image, sizeof(JPEG_CORE_PROPERTIES));
TRY
{
if (ijlInit(&image) != IJL_OK)
{
TRACE("Can't initialize Intel(R) JPEG library\n");
AfxThrowUserException();
}

image.jquality = nQuality;
image.upsampling_reqd = image.cconversion_reqd = FALSE;

image.DIBWidth = pImg->GetWidth();
if(pImg->IsTopDown())
image.DIBHeight = pImg->GetHeight();
else
image.DIBHeight = -pImg->GetHeight();
image.DIBBytes = pImg->GetBits();

image.JPGFile = NULL;
image.JPGBytes = pBuf;
image.JPGSizeBytes = pImg->GetBitsSize();
image.JPGWidth = pImg->GetWidth();
image.JPGHeight = pImg->GetHeight();

switch (pImg->GetBitCount())
{
case 24:
image.DIBColor = IJL_BGR;
image.DIBChannels = 3;
image.DIBPadBytes = IJL_DIB_PAD_BYTES(image.DIBWidth,3);
if(bColor)
{
image.JPGColor = IJL_YCBCR;
image.JPGChannels = 3;
image.JPGSubsampling = IJL_411;
}
else
{
image.JPGColor = IJL_G;
image.JPGChannels = 1;
image.JPGSubsampling = IJL_NONE;
}
break;

case 32:
image.DIBColor = IJL_RGBA_FPX;
image.DIBChannels = 4;
image.DIBPadBytes = IJL_DIB_PAD_BYTES(image.DIBWidth,4);
image.JPGColor = IJL_YCBCRA_FPX;
image.JPGChannels = 4;
image.JPGSubsampling = IJL_4114;
break;
default:
break;
}

if (image.DIBColor == IJL_RGBA_FPX)
{
Change32RGB(image.DIBBytes,image.DIBWidth,image.DIBHeight);
}


if (ijlWrite(&image, IJL_JBUFF_WRITEWHOLEIMAGE) != IJL_OK)
{
TRACE("Can't write image\n");
AfxThrowUserException();
}

if (ijlFree(&image) != IJL_OK)
{
TRACE("Can't free Intel(R) JPEG library\n");
}
*nLen = image.JPGSizeBytes;
nRet = XSUCCESS;
}
CATCH_ALL(e)
{
ijlFree(&image);
AfxMessageBox("Error storing JPEG file");
}
END_CATCH_ALL
return nRet;
}

[酒红绿叶]

CxImage方便些。

[possible_Y]

恩，我下载了个CxImage，搞定了，真的很方便啊