int ResampleKeepAspect(CxImage &image, unsigned int width, unsigned int height)
{
bool bResize = false;
float fAspect = ((float)image.GetWidth()) / ((float)image.GetHeight());
unsigned int newwidth = image.GetWidth();
unsigned int newheight = image.GetHeight();
if (newwidth > width)
{
bResize = true;
newwidth = width;
newheight = (DWORD)( ( (float)newwidth) / fAspect);
}
if (newheight > height)
{
bResize = true;
newheight = height;
newwidth = (DWORD)( fAspect * ( (float)newheight) );
}
if (bResize)
{
if (!image.Resample(newwidth, newheight, RESAMPLE_QUALITY) || !image.IsValid())
{
printf("PICTURE::SaveThumb: Unable to resample picture: Error:%s\n", image.GetLastError());
return -1;
}
}
return bResize ? 1 : 0;
}
__declspec(dllexport) bool LoadImage(const char *file, unsigned int maxwidth, unsigned int maxheight, ImageInfo *info)
{
if (!file || !info) return false;
if (IsDir(file))
return false;
// load the image
DWORD dwImageType = GetImageType(file);
CxImage *image = new CxImage(dwImageType);
if (!image) return false;
int actualwidth = maxwidth;
int actualheight = maxheight;
try
{
if (!image->Load(file, dwImageType, actualwidth, actualheight) || !image->IsValid())
{
#if !defined(_LINUX) && !defined(__APPLE__)
int nErr = GetLastError();
#else
int nErr = errno;
#endif
printf("PICTURE::LoadImage: Unable to open image: %s Error:%s (%d)\n", file, image->GetLastError(),nErr);
delete image;
return false;
}
}
catch (...)
{
printf("PICTURE::LoadImage: Unable to open image: %s\n", file);
delete image;
return false;
}
// ok, now resample the image down if necessary
if (ResampleKeepAspect(*image, maxwidth, maxheight) < 0)
{
printf("PICTURE::LoadImage: Unable to resample picture: %s\n", file);
delete image;
return false;
}
// make sure our image is 24bit minimum
image->IncreaseBpp(24);
// fill in our struct
info->width = image->GetWidth();
info->height = image->GetHeight();
info->originalwidth = actualwidth;
info->originalheight = actualheight;
memcpy(&info->exifInfo, image->GetExifInfo(), sizeof(EXIFINFO));
// create our texture
info->context = image;
info->texture = image->GetBits();
info->alpha = image->AlphaGetBits();
return (info->texture != NULL);
};
HBITMAP CSkin::LoadImage(const char *filename)
{
CxImage image;
image.Load(filename);
if(!image.IsValid()) {
return NULL;
}
return image.MakeBitmap(NULL);
}
bool SaveThumb(CxImage &image, const char *file, const char *thumb, int maxWidth, int maxHeight, bool bNeedToConvert = true, bool autoRotate = true)
{
// ok, now resample the image down if necessary
int ret = ResampleKeepAspectArea(image, maxWidth * maxHeight);
if (ret < 0) return false;
if (ret) bNeedToConvert = true;
// if we don't have a png but have a < 24 bit image, then convert to 24bits
if ( image.GetNumColors())
{
if (!image.IncreaseBpp(24) || !image.IsValid())
{
printf("PICTURE::SaveThumb: Unable to convert to 24bpp: Error:%s\n", image.GetLastError());
return false;
}
bNeedToConvert = true;
}
if ( autoRotate && image.GetExifInfo()->Orientation > 1)
{
image.RotateExif(image.GetExifInfo()->Orientation);
bNeedToConvert = true;
}
#ifndef _LINUX
::DeleteFile(thumb);
#else
unlink(thumb);
#endif
// only resave the image if we have to (quality of the JPG saver isn't too hot!)
if (bNeedToConvert)
{
// May as well have decent quality thumbs
image.SetJpegQuality(90);
if (!image.Save(thumb, image.AlphaIsValid() ? CXIMAGE_FORMAT_PNG : CXIMAGE_FORMAT_JPG))
{
printf("PICTURE::SaveThumb: Unable to save image: %s Error:%s\n", thumb, image.GetLastError());
::DeleteFile(thumb);
return false;
}
}
else
{ // Don't need to convert the file - copy it instead
if (!CopyFile(file, thumb))
{
printf("PICTURE::SaveThumb: Unable to copy file %s\n", file);
::DeleteFile(thumb);
return false;
}
}
return true;
}
UINT CFrameGrabThread::GrabFrames(){
#define TIMEBETWEENFRAMES 50.0 // could be a param later, if needed
for (int i = 0; i!= nFramesToGrab; i++)
imgResults[i] = NULL;
try{
HRESULT hr;
CComPtr<IMediaDet> pDet;
hr = pDet.CoCreateInstance(__uuidof(MediaDet));
if (!SUCCEEDED(hr))
return 0;
// Convert the file name to a BSTR.
CComBSTR bstrFilename(strFileName);
hr = pDet->put_Filename(bstrFilename);
long lStreams;
bool bFound = false;
hr = pDet->get_OutputStreams(&lStreams);
for (long i = 0; i < lStreams; i++)
{
GUID major_type;
hr = pDet->put_CurrentStream(i);
hr = pDet->get_StreamType(&major_type);
if (major_type == MEDIATYPE_Video)
{
bFound = true;
break;
}
}
if (!bFound)
return 0;
double dLength = 0;
pDet->get_StreamLength(&dLength);
if (dStartTime > dLength)
dStartTime = 0;
long width = 0, height = 0;
AM_MEDIA_TYPE mt;
hr = pDet->get_StreamMediaType(&mt);
if (mt.formattype == FORMAT_VideoInfo)
{
VIDEOINFOHEADER *pVih = (VIDEOINFOHEADER*)(mt.pbFormat);
width = pVih->bmiHeader.biWidth;
height = pVih->bmiHeader.biHeight;
// We want the absolute height, don't care about orientation.
if (height < 0) height *= -1;
}
else {
return 0; // Should not happen, in theory.
}
/*FreeMediaType(mt); = */
if (mt.cbFormat != 0){
CoTaskMemFree((PVOID)mt.pbFormat);
mt.cbFormat = 0;
mt.pbFormat = NULL;
}
if (mt.pUnk != NULL){
mt.pUnk->Release();
mt.pUnk = NULL;
}
/**/
long size;
uint32 nFramesGrabbed;
for (nFramesGrabbed = 0; nFramesGrabbed != nFramesToGrab; nFramesGrabbed++){
hr = pDet->GetBitmapBits(dStartTime + (nFramesGrabbed*TIMEBETWEENFRAMES), &size, NULL, width, height);
if (SUCCEEDED(hr))
{
// we could also directly create a Bitmap in memory, however this caused problems/failed with *some* movie files
// when I tried it for the MMPreview, while this method works always - so I'll continue to use this one
long nFullBufferLen = sizeof( BITMAPFILEHEADER ) + size;
char* buffer = new char[nFullBufferLen];
BITMAPFILEHEADER bfh;
memset( &bfh, 0, sizeof( bfh ) );
bfh.bfType = 'MB';
bfh.bfSize = nFullBufferLen;
bfh.bfOffBits = sizeof( BITMAPINFOHEADER ) + sizeof( BITMAPFILEHEADER );
memcpy(buffer,&bfh,sizeof( bfh ) );
try {
hr = pDet->GetBitmapBits(dStartTime+ (nFramesGrabbed*TIMEBETWEENFRAMES), NULL, buffer + sizeof( bfh ), width, height);
}
catch (...) {
ASSERT(0);
hr = E_FAIL;
}
if (SUCCEEDED(hr))
{
// decode
CxImage* imgResult = new CxImage();
imgResult->Decode((BYTE*)buffer, nFullBufferLen, CXIMAGE_FORMAT_BMP);
delete[] buffer;
if (!imgResult->IsValid()){
delete imgResult;
break;
}
// resize if needed
if (nMaxWidth > 0 && nMaxWidth < width){
float scale = (float)nMaxWidth / imgResult->GetWidth();
int nMaxHeigth = (int)(imgResult->GetHeight() * scale);
imgResult->Resample(nMaxWidth, nMaxHeigth, 0);
}
// decrease bpp if needed
if (bReduceColor){
RGBQUAD* ppal=(RGBQUAD*)malloc(256*sizeof(RGBQUAD));
if (ppal) {
CQuantizer q(256,8);
q.ProcessImage(imgResult->GetDIB());
q.SetColorTable(ppal);
imgResult->DecreaseBpp(8, true, ppal);
free(ppal);
}
}
//CString TestName;
//TestName.Format("G:\\testframe%i.png",nFramesGrabbed);
//imgResult->Save(TestName,CXIMAGE_FORMAT_PNG);
// done
imgResults[nFramesGrabbed] = imgResult;
}
else{
delete[] buffer;
break;
}
}
}
return nFramesGrabbed;
}
catch(...){
ASSERT(0);
return 0;
}
}
__declspec(dllexport) bool LoadImageFromMemory(const BYTE *buffer, unsigned int size, const char *mime, unsigned int maxwidth, unsigned int maxheight, ImageInfo *info)
{
if (!buffer || !size || !mime || !info) return false;
// load the image
DWORD dwImageType = CXIMAGE_FORMAT_UNKNOWN;
if (strlen(mime))
dwImageType = GetImageType(mime);
if (dwImageType == CXIMAGE_FORMAT_UNKNOWN)
dwImageType = DetectFileType(buffer, size);
if (dwImageType == CXIMAGE_FORMAT_UNKNOWN)
{
printf("PICTURE::LoadImageFromMemory: Unable to determine image type.");
return false;
}
CxImage *image = new CxImage(dwImageType);
if (!image)
return false;
int actualwidth = maxwidth;
int actualheight = maxheight;
try
{
bool success = image->Decode((BYTE*)buffer, size, dwImageType, actualwidth, actualheight);
if (!success && dwImageType != CXIMAGE_FORMAT_UNKNOWN)
{ // try to decode with unknown imagetype
success = image->Decode((BYTE*)buffer, size, CXIMAGE_FORMAT_UNKNOWN);
}
if (!success || !image->IsValid())
{
printf("PICTURE::LoadImageFromMemory: Unable to decode image. Error:%s\n", image->GetLastError());
delete image;
return false;
}
}
catch (...)
{
printf("PICTURE::LoadImageFromMemory: Unable to decode image.");
delete image;
return false;
}
// ok, now resample the image down if necessary
if (ResampleKeepAspect(*image, maxwidth, maxheight) < 0)
{
printf("PICTURE::LoadImage: Unable to resample picture\n");
delete image;
return false;
}
// make sure our image is 24bit minimum
image->IncreaseBpp(24);
// fill in our struct
info->width = image->GetWidth();
info->height = image->GetHeight();
info->originalwidth = actualwidth;
info->originalheight = actualheight;
memcpy(&info->exifInfo, image->GetExifInfo(), sizeof(EXIFINFO));
// create our texture
info->context = image;
info->texture = image->GetBits();
info->alpha = image->AlphaGetBits();
return (info->texture != NULL);
};
