void *get_frame_data(int frame_num)
{
if (num_frames<=0)
return NULL;
if (frame_num<0)
frame_num = (frame_num % num_frames) + num_frames;
else
if (frame_num>=num_frames)
frame_num = frame_num % num_frames;
LPBITMAPINFOHEADER lpbi = NULL;
lpbi = (LPBITMAPINFOHEADER)AVIStreamGetFrame(getFrame, frame_num);
if (lpbi)
{
//frame pixel data is 40 bytes past the bitmapinfoheader
void *bitmap = ((unsigned char *)lpbi) + 40;
return bitmap;
}
return NULL;
}
/////////////////////////////////////////////////////////
//get frame - we not give frame number- get next frame
/////////////////////////////////////////////////////////
DWORD CAviMan::GetFrame(LPBYTE pImageData,DWORD dwNumFrame)
{
if(dwNumFrame==-1) dwNumFrame = (++m_dwCurrentFrame); //if frame number not set
if(m_dwCurrentFrame>=m_dwTotalFrame) return 1;
LPBYTE pAviFrame = (BYTE*)AVIStreamGetFrame(m_aviGetFrame,dwNumFrame);
if((pAviFrame) && (pImageData))
{
DWORD dwWidth = m_bmpHeader.bmiHeader.biWidth;
DWORD dwHeight = m_bmpHeader.bmiHeader.biHeight;
switch(m_bmpHeader.bmiHeader.biBitCount)
{
case(24):dwWidth*=3;break;
case(16):dwWidth*=2;break;
}
LPBYTE pFrom = (pAviFrame+sizeof( BITMAPINFO )) + m_dwImageSize - dwWidth-1;
LPBYTE pTo = pImageData;
for(DWORD i=0;i<dwHeight;i++,pFrom-=dwWidth,pTo+=dwWidth)
memcpy(pTo,pFrom,dwWidth);
// memcpy(pImageData,(pAviFrame+sizeof( BITMAPINFO )),m_dwImageSize);
}
return 0;
}
bool VideoComponent::grabAviFrame(int frame)
{
if (m_pgf != 0x0 && frame >= 0 && frame < m_lastframe && m_hdd && m_hdc)
{
LPBITMAPINFOHEADER lpbi; // Holds The Bitmap Header Information
lpbi = (LPBITMAPINFOHEADER)AVIStreamGetFrame(m_pgf, frame); // Grab Data From The AVI Stream
// Convert Data To Requested Bitmap Format
if (m_resize)
{
// Temporarly get the frame in m_pdata
// (Skip The Header Info To Get To The Data)
m_pdata=(unsigned char *)lpbi+lpbi->biSize+lpbi->biClrUsed * sizeof(RGBQUAD); // Pointer To Data Returned By AVIStreamGetFrame
if (!DrawDibDraw (m_hdd, m_hdc, 0, 0, m_resizeWidth, m_resizeHeight, lpbi, m_pdata, 0, 0, m_width, m_height, 0))
{
GameLog::errorMessage("Error resizing video to requested size: %d x %d", m_resizeWidth, m_resizeHeight);
return false;
}
}
else
{
// Directly get the frame in m_data
// (Skip The Header Info To Get To The Data)
m_data=(unsigned char *)lpbi+lpbi->biSize+lpbi->biClrUsed * sizeof(RGBQUAD); // Pointer To Data Returned By AVIStreamGetFrame
}
convertFrameData(m_data, m_bgraData); // convert to horde format
return true;
}
return false;
}
void CExtAviLabel::OnAviPaintCurrentFrame( CDC & dc, const CRect & rcDrawDst, const CSize & sizeAvi )
{
ASSERT_VALID( this );
ASSERT( GetSafeHwnd() != NULL );
ASSERT( dc.GetSafeHdc() != NULL );
if( sizeAvi.cx <= 0 || sizeAvi.cy <= 0 )
return;
LPBITMAPINFOHEADER pBIH = (LPBITMAPINFOHEADER)AVIStreamGetFrame(m_pGF, (LONG)m_nAviFrameCurrent);
// ASSERT( pBIH != NULL );
if( pBIH == NULL )
return;
CExtMemoryDC dcProcessingSurface( &dc, rcDrawDst, CExtMemoryDC::MDCOPT_TO_MEMORY|CExtMemoryDC::MDCOPT_FORCE_DIB|CExtMemoryDC::MDCOPT_RTL_COMPATIBILITY );
VERIFY(
::DrawDibDraw(
m_hDrawDib, dcProcessingSurface.GetSafeHdc(),
rcDrawDst.left + m_ptAviOffset.x, rcDrawDst.top + m_ptAviOffset.y, sizeAvi.cx, sizeAvi.cy,
pBIH, NULL, 0, 0, -1, -1, 0
)
);
COLORREF clrTransparentPixels = ( ( AviStyleGet() & __EXT_AVI_TRANSPARENT_VIDEO ) != 0 ) ? m_clrTransparentEffective : PmBridge_GetPM()->GetColor( COLOR_WINDOW );
CExtPaintManager::stat_TransparentBlt(
dc.m_hDC,
rcDrawDst.left + m_ptAviOffset.x, rcDrawDst.top + m_ptAviOffset.y, sizeAvi.cx, sizeAvi.cy,
dcProcessingSurface.GetSafeHdc(),
rcDrawDst.left + m_ptAviOffset.x, rcDrawDst.top + m_ptAviOffset.y, sizeAvi.cx, sizeAvi.cy,
clrTransparentPixels
);
dcProcessingSurface.__Flush( FALSE );
}
static LPVOID AVIFILE_ReadFrame(IAVIEditStreamImpl* const This,
PAVISTREAM pstream, LONG pos)
{
PGETFRAME pg;
TRACE("(%p,%p,%d)\n",This,pstream,pos);
if (pstream == NULL)
return NULL;
/* if stream changes make sure that only palette changes */
if (This->pCurStream != pstream) {
pg = AVIStreamGetFrameOpen(pstream, NULL);
if (pg == NULL)
return NULL;
if (This->pg != NULL) {
if (IGetFrame_SetFormat(pg, This->lpFrame, NULL, 0, 0, -1, -1) != S_OK) {
AVIStreamGetFrameClose(pg);
ERR(": IGetFrame_SetFormat failed\n");
return NULL;
}
AVIStreamGetFrameClose(This->pg);
}
This->pg = pg;
This->pCurStream = pstream;
}
/* now get the decompressed frame */
This->lpFrame = AVIStreamGetFrame(This->pg, pos);
if (This->lpFrame != NULL)
This->sInfo.dwSuggestedBufferSize = This->lpFrame->biSizeImage;
return This->lpFrame;
}
DWORD WINAPI AviFrameGraber::_ThreadFunc (LPVOID lpParameter){
AviFrameGraber* avi_frame_graber;
avi_frame_graber = (AviFrameGraber*) lpParameter;
woodychang0611::image::ImageRGB24 image ((UINT16)avi_frame_graber->avi_info_.dwWidth,(UINT16)avi_frame_graber->avi_info_.dwHeight);
avi_frame_graber->image_pointer_ = ℑ
//the thread will end itself if status is FRAME_SUBJECT_STOP
while(avi_frame_graber->GetStatus() !=FRAME_SUBJECT_STOP){
unsigned char* dib_pointer;
switch(avi_frame_graber->GetStatus()){
case FRAME_SUBJECT_PLAY:
dib_pointer = (unsigned char*) AVIStreamGetFrame(avi_frame_graber->frame_,avi_frame_graber->current_frame_);
if (avi_frame_graber->GetStatus()==FRAME_SUBJECT_STOP) return 0;
if (dib_pointer){
//Copy the from source DIB to woodychang0611::ImageRGB24
for (UINT16 j=0;j<image.GetImageHeight();++j){
for (UINT16 i=0;i<image.GetImageWidth();++i){
UINT32 pos = (image.GetImageHeight()-j-1)*
image.GetBytePerLine()+i*3+40;
image.GetPixel(i,j).b_ = dib_pointer[pos];
image.GetPixel(i,j).g_ = dib_pointer[pos+1];
image.GetPixel(i,j).r_ = dib_pointer[pos+2];
}
}
// Update frame info
avi_frame_graber->frame_info_.current_frame_ = avi_frame_graber->current_frame_;
std::time_t frame_time = mktime(&avi_frame_graber->initial_time_)+(INT32)
((avi_frame_graber->current_frame_-avi_frame_graber->start_frame_)/
avi_frame_graber->frame_info_.frame_per_second_);
tm tm_frame;
localtime_s(&tm_frame,&frame_time);
avi_frame_graber->frame_info_.frame_time_=tm_frame;
avi_frame_graber->NotifyObserver();
}
avi_frame_graber->current_frame_++;
//Check end
if (avi_frame_graber->current_frame_ >=
avi_frame_graber-> start_frame_+avi_frame_graber->frame_length_){
if(avi_frame_graber->auto_replay_){
avi_frame_graber->current_frame_=avi_frame_graber->start_frame_;
}
else{
avi_frame_graber->current_frame_ = avi_frame_graber->start_frame_;
avi_frame_graber->SetStatus(FRAME_SUBJECT_PAUSE);
}
}
break;
default:
break;
}//end of switch(avi_frame_graber->GetStatus())
}//end of while(avi_frame_graber->GetStatus() !=FRAME_SUBJECT_STOP)
return 0;
}
static HRESULT WINAPI ICMStream_fnReadFormat(IAVIStream *iface, LONG pos,
LPVOID format, LONG *formatsize)
{
IAVIStreamImpl *This = impl_from_IAVIStream(iface);
LPBITMAPINFOHEADER lpbi;
HRESULT hr;
TRACE("(%p,%d,%p,%p)\n", iface, pos, format, formatsize);
if (formatsize == NULL)
return AVIERR_BADPARAM;
if (This->pg == NULL) {
hr = AVIFILE_OpenGetFrame(This);
if (FAILED(hr))
return hr;
}
lpbi = AVIStreamGetFrame(This->pg, pos);
if (lpbi == NULL)
return AVIERR_MEMORY;
if (This->hic == NULL) {
LONG size = lpbi->biSize + lpbi->biClrUsed * sizeof(RGBQUAD);
if (size > 0) {
if (This->sInfo.dwSuggestedBufferSize < lpbi->biSizeImage)
This->sInfo.dwSuggestedBufferSize = lpbi->biSizeImage;
This->cbOutput = size;
if (format != NULL) {
if (This->lpbiOutput != NULL)
memcpy(format, This->lpbiOutput, min(*formatsize, This->cbOutput));
else
memcpy(format, lpbi, min(*formatsize, size));
}
}
} else if (format != NULL)
memcpy(format, This->lpbiOutput, min(*formatsize, This->cbOutput));
if (*formatsize < This->cbOutput)
hr = AVIERR_BUFFERTOOSMALL;
else
hr = AVIERR_OK;
*formatsize = This->cbOutput;
return hr;
}
void AVIOBJ::GrabAVIFrame(int frame,HDC nhdc) // Grabs A Frame From The Stream
{
LPBITMAPINFOHEADER lpbi; // Holds The Bitmap Header Information
if (pgf)
{
lpbi = (LPBITMAPINFOHEADER)AVIStreamGetFrame(pgf, frame); // Grab Data From The AVI Stream
if (lpbi)
{
pdata=(char *)lpbi+lpbi->biSize+lpbi->biClrUsed * sizeof(RGBQUAD); // Pointer To Data Returned By AVIStreamGetFrame
DrawDibDraw (hdd, nhdc, 0, 0, right-left,bottom-top, lpbi, pdata, 0, 0, width, height, 0);
}
}
}
void CAvi::GrabAVIFrame( int frame )
{
char* pdata;
LPBITMAPINFOHEADER lpbi; // Holds The Bitmap Header Information
lpbi = (LPBITMAPINFOHEADER)AVIStreamGetFrame(m_pgf, frame); // Grab Data From The CAvi Stream
pdata=(char *)lpbi+lpbi->biSize+lpbi->biClrUsed * sizeof(RGBQUAD); // Pointer To Data Returned By AVIStreamGetFrame
// Convert Data To Requested Bitmap Format
DrawDibDraw (m_hdd, m_hDC, 0, 0, 1024, 512, lpbi, pdata, 0, 0, m_width, m_height, 0);
//Flip( data );
// Update The Texture
glBindTexture( GL_TEXTURE_2D, m_textureId );
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, 1024, 512, GL_BGR_EXT, GL_UNSIGNED_BYTE, m_data);
}
static ImBuf *avi_fetchibuf(struct anim *anim, int position)
{
ImBuf *ibuf = NULL;
int *tmp;
int y;
if (anim == NULL) {
return NULL;
}
#if defined(_WIN32) && !defined(FREE_WINDOWS)
if (anim->avistreams) {
LPBITMAPINFOHEADER lpbi;
if (anim->pgf) {
lpbi = AVIStreamGetFrame(anim->pgf, position + AVIStreamStart(anim->pavi[anim->firstvideo]));
if (lpbi) {
ibuf = IMB_ibImageFromMemory((unsigned char *) lpbi, 100, IB_rect, anim->colorspace, "<avi_fetchibuf>");
//Oh brother...
}
}
}
else
#endif
{
ibuf = IMB_allocImBuf(anim->x, anim->y, 24, IB_rect);
tmp = AVI_read_frame(anim->avi, AVI_FORMAT_RGB32, position,
AVI_get_stream(anim->avi, AVIST_VIDEO, 0));
if (tmp == NULL) {
printf("Error reading frame from AVI: '%s'\n", anim->name);
IMB_freeImBuf(ibuf);
return NULL;
}
for (y = 0; y < anim->y; y++) {
memcpy(&(ibuf->rect)[((anim->y - y) - 1) * anim->x], &tmp[y * anim->x],
anim->x * 4);
}
MEM_freeN(tmp);
}
ibuf->rect_colorspace = colormanage_colorspace_get_named(anim->colorspace);
return ibuf;
}
/***********************************************************************
* AVIStreamGetFrame (AVIFILE.110)
*/
SEGPTR WINAPI AVIStreamGetFrame16(PGETFRAME pg, LONG pos)
{
struct frame_wrapper16 *wrapper = (void *)pg;
BITMAPINFOHEADER *bih;
if (!pg) return 0;
bih = AVIStreamGetFrame(wrapper->pg, pos);
if (bih)
{
DWORD size = bih->biSize + bih->biSizeImage;
return alloc_segptr_frame(wrapper, bih, size);
}
return 0;
}
void Movie::renderTexture(Texture* Tex)
{
if (!Tex || Tex->getImageBuffer()->getType() != IMAGEBUFFER_UBYTE || mcrAVIData->State != MOVIESTATE_PLAYED)
return;
/* Proceed to the next frame */
mcrAVIData->Time = clock();
mcrAVIData->Next += (s32)( Speed_ * (mcrAVIData->Time - mcrAVIData->LastTime) );
mcrAVIData->LastTime = clock();
mcrAVIData->Frame = mcrAVIData->Next / mcrAVIData->VideoMPF;
/* Check if the movie is finish */
if (finish())
{
mcrAVIData->Next = mcrAVIData->Frame = 0;
if (!mcrAVIData->Looped)
{
mcrAVIData->State = MOVIESTATE_STOPED;
return;
}
}
/* Get frame's video stream */
LPBITMAPINFOHEADER pBitmapInfoHeader = (LPBITMAPINFOHEADER)AVIStreamGetFrame(mcrAVIData->pGetFrame, mcrAVIData->Frame);
if (!pBitmapInfoHeader)
return;
mcrAVIData->VideoData = (s8*)pBitmapInfoHeader + pBitmapInfoHeader->biSize + pBitmapInfoHeader->biClrUsed * sizeof(RGBQUAD);
DrawDibDraw(
mcrAVIData->hDrawDIB, mcrAVIData->hDeviceContext,
0, 0,
mcrAVIData->Resolution, mcrAVIData->Resolution,
pBitmapInfoHeader, mcrAVIData->VideoData,
0, 0,
mcrAVIData->Size.Width, mcrAVIData->Size.Height,
0
);
//flipDataBuffer(MovieData->RawData, MovieData->Resolution * MovieData->Resolution * 3);
/* Copy to texture */
if (Tex->getSize() == dim::size2di(mcrAVIData->Resolution) && Tex->getImageBuffer()->getFormatSize() == 3)
Tex->setupImageBuffer(mcrAVIData->RawData);
}
/*
---------------------------------------------------------------------------------------
- Grabs A Frame From The Stream
---------------------------------------------------------------------------------------
*/
void AviVideoRenderer::GrabAVIFrame(int frame)
{
LPBITMAPINFOHEADER lpbi; // Holds The Bitmap Header Information
lpbi = (LPBITMAPINFOHEADER)AVIStreamGetFrame(_AVR_pgf, frame); // Grab Data From The AVI Stream
char* _tex_pdata=(char *)lpbi+lpbi->biSize+lpbi->biClrUsed * sizeof(RGBQUAD); // Pointer To Data Returned By AVIStreamGetFrame
// Convert Data To Requested Bitmap Format
DrawDibDraw (_AVR_hdd, _AVR_hdc, 0, 0, _heights[0], _widths[0], lpbi, _tex_pdata, 0, 0, _video_width, _video_height, 0);
flipIt(_img_data, _heights[0], _widths[0]); // Swap The Red And Blue Bytes (GL Compatability)
// Update The Texture
glBindTexture(GL_TEXTURE_2D, _textures[0]);
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, _heights[0], _widths[0], GL_RGB, GL_UNSIGNED_BYTE, _img_data);
}
void AVI :: Set(float time) // Grabs A Frame From The Stream
{
// anything to do?
if(!tman || mpf==0)
NTHROW("AVI :: Set - Video not created before call to set.");
// move position forward by time
pos+=time;
// get the frame number
int frame=(int)((float)pos/mpf);
// have we gone past the end?
if(frame>=lastframe)
{
if(loop)
{
pos=0.0f;
frame=0; // reset the animation
}else
frame=lastframe-1; // hold at the last frame
}
LPBITMAPINFOHEADER lpbi; // Holds The Bitmap Header Information
lpbi = (LPBITMAPINFOHEADER)AVIStreamGetFrame(pgf, frame); // Grab Data From The AVI Stream
pdata=(BYTE *)lpbi+lpbi->biSize+lpbi->biClrUsed * sizeof(RGBQUAD); // Pointer To Data Returned By AVIStreamGetFrame
// Convert Data To Requested Bitmap Format
DrawDibDraw (hdd, hdc, 0, 0, 256, 256, lpbi, pdata, 0, 0, width, height, 0);
flipIt(data); // Swap The Red And Blue Bytes (GL Compatability)
// set our texture
tman->Set(texid);
// Update The Texture
glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, 256, 256, GL_RGB, GL_UNSIGNED_BYTE, data);
}
void CAviHelper::AVItoBmp(const wstring& strAVIFileName, const wstring& strBmpDir)
{
AVIFileInit();
PAVIFILE avi;
int res = AVIFileOpen(&avi, WS2S(strAVIFileName).c_str(), OF_READ, NULL);
int n = GetLastError();
if (res!=AVIERR_OK)
{
//an error occures
if (avi!=NULL)
AVIFileRelease(avi);
return ;
}
AVIFILEINFO avi_info;
AVIFileInfo(avi, &avi_info, sizeof(AVIFILEINFO));
PAVISTREAM pStream;
res=AVIFileGetStream(avi, &pStream, streamtypeVIDEO /*video stream*/, 0 /*first stream*/);
if (res!=AVIERR_OK)
{
if (pStream!=NULL)
AVIStreamRelease(pStream);
AVIFileExit();
return ;
}
//do some task with the stream
int iNumFrames;
int iFirstFrame;
iFirstFrame = AVIStreamStart(pStream);
if (iFirstFrame==-1)
{
//Error getteing the frame inside the stream
if (pStream!=NULL)
AVIStreamRelease(pStream);
AVIFileExit();
return ;
}
iNumFrames = AVIStreamLength(pStream);
if (iNumFrames==-1)
{
//Error getteing the number of frames inside the stream
if (pStream!=NULL)
AVIStreamRelease(pStream);
AVIFileExit();
return ;
}
//getting bitmap from frame
BITMAPINFOHEADER bih;
ZeroMemory(&bih, sizeof(BITMAPINFOHEADER));
bih.biBitCount=24; //24 bit per pixel
bih.biClrImportant=0;
bih.biClrUsed = 0;
bih.biCompression = BI_RGB;
bih.biPlanes = 1;
bih.biSize = 40;
bih.biXPelsPerMeter = 0;
bih.biYPelsPerMeter = 0;
//calculate total size of RGBQUAD scanlines (DWORD aligned)
bih.biSizeImage = (((bih.biWidth * 3) + 3) & 0xFFFC) * bih.biHeight ;
PGETFRAME pFrame;
pFrame=AVIStreamGetFrameOpen(pStream, NULL );
AVISTREAMINFO streaminfo;
AVIStreamInfo(pStream,&streaminfo,sizeof(AVISTREAMINFO));
//Get the first frame
BITMAPINFOHEADER bih2;
long lsize = sizeof(bih2);
int index= 0;
for (int i = iFirstFrame; i < iNumFrames; i++)
{
index= i-iFirstFrame;
BYTE* pDIB = (BYTE*) AVIStreamGetFrame(pFrame, index); //
AVIStreamReadFormat(pStream,index,&bih2,&lsize);
BITMAPFILEHEADER stFileHdr;
BYTE* Bits=new BYTE[bih2.biSizeImage];
AVIStreamRead(pStream,index,1,Bits,bih2.biSizeImage,NULL,NULL);
//RtlMoveMemory(Bits, pDIB + sizeof(BITMAPINFOHEADER), bih2.biSizeImage);
bih2.biClrUsed =0;
stFileHdr.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
stFileHdr.bfSize=sizeof(BITMAPFILEHEADER);
stFileHdr.bfType=0x4d42;
CString FileName;
FileName.Format(_T("Frame-%05d.bmp"), index);
CString strtemp;
strtemp.Format(_T("%s\\%s"), strBmpDir.c_str(), FileName);
FILE* fp=_tfopen(strtemp ,_T("wb"));
fwrite(&stFileHdr,1,sizeof(BITMAPFILEHEADER),fp);
fwrite(&bih2,1,sizeof(BITMAPINFOHEADER),fp);
int ff = fwrite(Bits,1,bih2.biSizeImage,fp);
int e = GetLastError();
fclose(fp);
/////
delete Bits;
//CreateFromPackedDIBPointer(pDIB, index);
}
AVIStreamGetFrameClose(pFrame);
//close the stream after finishing the task
if (pStream!=NULL)
AVIStreamRelease(pStream);
AVIFileExit();
}
LPBITMAPINFOHEADER CAviToBmp::GetFrame(DWORD Frame)
{
return((LPBITMAPINFOHEADER)AVIStreamGetFrame(m_pGetFrame, Frame));
}
static HRESULT WINAPI ICMStream_fnRead(IAVIStream *iface, LONG start,
LONG samples, LPVOID buffer,
LONG buffersize, LPLONG bytesread,
LPLONG samplesread)
{
IAVIStreamImpl *This = impl_from_IAVIStream(iface);
LPBITMAPINFOHEADER lpbi;
TRACE("(%p,%d,%d,%p,%d,%p,%p)\n", iface, start, samples, buffer,
buffersize, bytesread, samplesread);
/* clear return parameters if given */
if (bytesread != NULL)
*bytesread = 0;
if (samplesread != NULL)
*samplesread = 0;
if (samples == 0)
return AVIERR_OK;
/* check parameters */
if (samples != 1 && (bytesread == NULL && samplesread == NULL))
return AVIERR_BADPARAM;
if (samples == -1) /* read as much as we could */
samples = 1;
if (This->pg == NULL) {
HRESULT hr = AVIFILE_OpenGetFrame(This);
if (FAILED(hr))
return hr;
}
/* compress or decompress? */
if (This->hic == NULL) {
/* decompress */
lpbi = AVIStreamGetFrame(This->pg, start);
if (lpbi == NULL)
return AVIERR_MEMORY;
if (buffer != NULL && buffersize > 0) {
/* check buffersize */
if (buffersize < lpbi->biSizeImage)
return AVIERR_BUFFERTOOSMALL;
memcpy(buffer, DIBPTR(lpbi), lpbi->biSizeImage);
}
/* fill out return parameters if given */
if (bytesread != NULL)
*bytesread = lpbi->biSizeImage;
} else {
/* compress */
if (This->lCurrent > start)
AVIFILE_Reset(This);
while (start > This->lCurrent) {
HRESULT hr;
lpbi = AVIStreamGetFrame(This->pg, ++This->lCurrent);
if (lpbi == NULL) {
AVIFILE_Reset(This);
return AVIERR_MEMORY;
}
hr = AVIFILE_EncodeFrame(This, lpbi, DIBPTR(lpbi));
if (FAILED(hr)) {
AVIFILE_Reset(This);
return hr;
}
}
if (buffer != NULL && buffersize > 0) {
/* check buffersize */
if (This->lpbiCur->biSizeImage > buffersize)
return AVIERR_BUFFERTOOSMALL;
memcpy(buffer, This->lpCur, This->lpbiCur->biSizeImage);
}
/* fill out return parameters if given */
if (bytesread != NULL)
*bytesread = This->lpbiCur->biSizeImage;
}
/* fill out return parameters if given */
if (samplesread != NULL)
*samplesread = 1;
return AVIERR_OK;
}
static HRESULT AVIFILE_OpenGetFrame(IAVIStreamImpl *This)
{
LPBITMAPINFOHEADER lpbi;
DWORD size;
/* pre-conditions */
assert(This != NULL);
assert(This->pStream != NULL);
assert(This->pg == NULL);
This->pg = AVIStreamGetFrameOpen(This->pStream, NULL);
if (This->pg == NULL)
return AVIERR_ERROR;
/* When we only decompress this is enough */
if (This->sInfo.fccHandler == comptypeDIB)
return AVIERR_OK;
assert(This->hic != NULL);
assert(This->lpbiOutput == NULL);
/* get input format */
lpbi = AVIStreamGetFrame(This->pg, This->sInfo.dwStart);
if (lpbi == NULL)
return AVIERR_MEMORY;
/* get memory for output format */
size = ICCompressGetFormatSize(This->hic, lpbi);
if ((LONG)size < (LONG)sizeof(BITMAPINFOHEADER))
return AVIERR_COMPRESSOR;
This->lpbiOutput = HeapAlloc(GetProcessHeap(), 0, size);
if (This->lpbiOutput == NULL)
return AVIERR_MEMORY;
This->cbOutput = size;
if (ICCompressGetFormat(This->hic, lpbi, This->lpbiOutput) < S_OK)
return AVIERR_BADFORMAT;
/* update AVISTREAMINFO structure */
This->sInfo.rcFrame.right =
This->sInfo.rcFrame.left + This->lpbiOutput->biWidth;
This->sInfo.rcFrame.bottom =
This->sInfo.rcFrame.top + This->lpbiOutput->biHeight;
This->sInfo.dwSuggestedBufferSize =
ICCompressGetSize(This->hic, lpbi, This->lpbiOutput);
/* prepare codec for compression */
if (ICCompressBegin(This->hic, lpbi, This->lpbiOutput) != S_OK)
return AVIERR_COMPRESSOR;
/* allocate memory for current frame */
size += This->sInfo.dwSuggestedBufferSize;
This->lpbiCur = HeapAlloc(GetProcessHeap(), 0, size);
if (This->lpbiCur == NULL)
return AVIERR_MEMORY;
memcpy(This->lpbiCur, This->lpbiOutput, This->cbOutput);
This->lpCur = DIBPTR(This->lpbiCur);
/* allocate memory for last frame if needed */
if (This->lKeyFrameEvery != 1 &&
(This->dwICMFlags & VIDCF_FASTTEMPORALC) == 0) {
size = ICDecompressGetFormatSize(This->hic, This->lpbiOutput);
This->lpbiPrev = HeapAlloc(GetProcessHeap(), 0, size);
if (This->lpbiPrev == NULL)
return AVIERR_MEMORY;
if (ICDecompressGetFormat(This->hic, This->lpbiOutput, This->lpbiPrev) < S_OK)
return AVIERR_COMPRESSOR;
if (This->lpbiPrev->biSizeImage == 0) {
This->lpbiPrev->biSizeImage =
DIBWIDTHBYTES(*This->lpbiPrev) * This->lpbiPrev->biHeight;
}
/* get memory for format and picture */
size += This->lpbiPrev->biSizeImage;
This->lpbiPrev = HeapReAlloc(GetProcessHeap(), 0, This->lpbiPrev, size );
if (This->lpbiPrev == NULL)
return AVIERR_MEMORY;
This->lpPrev = DIBPTR(This->lpbiPrev);
/* prepare codec also for decompression */
if (ICDecompressBegin(This->hic,This->lpbiOutput,This->lpbiPrev) != S_OK)
return AVIERR_COMPRESSOR;
}
return AVIERR_OK;
}
bool CAviLoader::grabFrame()
{
if( avistream )
bmih = (BITMAPINFOHEADER*)AVIStreamGetFrame( getframe, pos++ );
return bmih != 0;
}
static ImBuf *avi_fetchibuf(struct anim *anim, int position)
{
ImBuf *ibuf = NULL;
int *tmp;
int y;
if (anim == NULL) {
return NULL;
}
#if defined(_WIN32) && !defined(FREE_WINDOWS)
if (anim->avistreams) {
LPBITMAPINFOHEADER lpbi;
if (anim->pgf) {
lpbi = AVIStreamGetFrame(anim->pgf, position + AVIStreamStart(anim->pavi[anim->firstvideo]));
if (lpbi) {
ibuf = IMB_ibImageFromMemory((unsigned char *) lpbi, 100, IB_rect, anim->colorspace, "<avi_fetchibuf>");
//Oh brother...
}
}
}
else {
#else
if (1) {
#endif
ibuf = IMB_allocImBuf(anim->x, anim->y, 24, IB_rect);
tmp = AVI_read_frame(anim->avi, AVI_FORMAT_RGB32, position,
AVI_get_stream(anim->avi, AVIST_VIDEO, 0));
if (tmp == NULL) {
printf("Error reading frame from AVI: '%s'\n", anim->name);
IMB_freeImBuf(ibuf);
return NULL;
}
for (y = 0; y < anim->y; y++) {
memcpy(&(ibuf->rect)[((anim->y - y) - 1) * anim->x], &tmp[y * anim->x],
anim->x * 4);
}
MEM_freeN(tmp);
}
ibuf->rect_colorspace = colormanage_colorspace_get_named(anim->colorspace);
return ibuf;
}
#endif /* WITH_AVI */
#ifdef WITH_FFMPEG
static int startffmpeg(struct anim *anim)
{
int i, videoStream;
AVCodec *pCodec;
AVFormatContext *pFormatCtx = NULL;
AVCodecContext *pCodecCtx;
int frs_num;
double frs_den;
int streamcount;
#ifdef FFMPEG_SWSCALE_COLOR_SPACE_SUPPORT
/* The following for color space determination */
int srcRange, dstRange, brightness, contrast, saturation;
int *table;
const int *inv_table;
#endif
if (anim == 0) return(-1);
streamcount = anim->streamindex;
if (avformat_open_input(&pFormatCtx, anim->name, NULL, NULL) != 0) {
return -1;
}
if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
av_close_input_file(pFormatCtx);
return -1;
}
av_dump_format(pFormatCtx, 0, anim->name, 0);
/* Find the video stream */
videoStream = -1;
for (i = 0; i < pFormatCtx->nb_streams; i++)
if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
if (streamcount > 0) {
streamcount--;
continue;
}
videoStream = i;
break;
}
if (videoStream == -1) {
av_close_input_file(pFormatCtx);
return -1;
}
pCodecCtx = pFormatCtx->streams[videoStream]->codec;
/* Find the decoder for the video stream */
pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
if (pCodec == NULL) {
av_close_input_file(pFormatCtx);
return -1;
}
pCodecCtx->workaround_bugs = 1;
if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
av_close_input_file(pFormatCtx);
return -1;
}
anim->duration = ceil(pFormatCtx->duration *
av_q2d(pFormatCtx->streams[videoStream]->r_frame_rate) /
AV_TIME_BASE);
frs_num = pFormatCtx->streams[videoStream]->r_frame_rate.num;
frs_den = pFormatCtx->streams[videoStream]->r_frame_rate.den;
frs_den *= AV_TIME_BASE;
while (frs_num % 10 == 0 && frs_den >= 2.0 && frs_num > 10) {
frs_num /= 10;
frs_den /= 10;
}
anim->frs_sec = frs_num;
anim->frs_sec_base = frs_den;
anim->params = 0;
anim->x = pCodecCtx->width;
anim->y = av_get_cropped_height_from_codec(pCodecCtx);
anim->pFormatCtx = pFormatCtx;
anim->pCodecCtx = pCodecCtx;
anim->pCodec = pCodec;
anim->videoStream = videoStream;
anim->interlacing = 0;
anim->orientation = 0;
anim->framesize = anim->x * anim->y * 4;
anim->curposition = -1;
anim->last_frame = 0;
anim->last_pts = -1;
anim->next_pts = -1;
anim->next_packet.stream_index = -1;
anim->pFrame = avcodec_alloc_frame();
anim->pFrameComplete = FALSE;
anim->pFrameDeinterlaced = avcodec_alloc_frame();
anim->pFrameRGB = avcodec_alloc_frame();
if (avpicture_get_size(PIX_FMT_RGBA, anim->x, anim->y) !=
anim->x * anim->y * 4)
{
fprintf(stderr,
"ffmpeg has changed alloc scheme ... ARGHHH!\n");
avcodec_close(anim->pCodecCtx);
av_close_input_file(anim->pFormatCtx);
av_free(anim->pFrameRGB);
av_free(anim->pFrameDeinterlaced);
av_free(anim->pFrame);
anim->pCodecCtx = NULL;
return -1;
}
if (anim->ib_flags & IB_animdeinterlace) {
avpicture_fill((AVPicture *) anim->pFrameDeinterlaced,
MEM_callocN(avpicture_get_size(
anim->pCodecCtx->pix_fmt,
anim->pCodecCtx->width,
anim->pCodecCtx->height),
"ffmpeg deinterlace"),
anim->pCodecCtx->pix_fmt,
anim->pCodecCtx->width,
anim->pCodecCtx->height);
}
if (pCodecCtx->has_b_frames) {
anim->preseek = 25; /* FIXME: detect gopsize ... */
}
else {
anim->preseek = 0;
}
anim->img_convert_ctx = sws_getContext(
anim->x,
anim->y,
anim->pCodecCtx->pix_fmt,
anim->x,
anim->y,
PIX_FMT_RGBA,
SWS_FAST_BILINEAR | SWS_PRINT_INFO | SWS_FULL_CHR_H_INT,
NULL, NULL, NULL);
if (!anim->img_convert_ctx) {
fprintf(stderr,
"Can't transform color space??? Bailing out...\n");
avcodec_close(anim->pCodecCtx);
av_close_input_file(anim->pFormatCtx);
av_free(anim->pFrameRGB);
av_free(anim->pFrameDeinterlaced);
av_free(anim->pFrame);
anim->pCodecCtx = NULL;
return -1;
}
#ifdef FFMPEG_SWSCALE_COLOR_SPACE_SUPPORT
/* Try do detect if input has 0-255 YCbCR range (JFIF Jpeg MotionJpeg) */
if (!sws_getColorspaceDetails(anim->img_convert_ctx, (int **)&inv_table, &srcRange,
&table, &dstRange, &brightness, &contrast, &saturation))
{
srcRange = srcRange || anim->pCodecCtx->color_range == AVCOL_RANGE_JPEG;
inv_table = sws_getCoefficients(anim->pCodecCtx->colorspace);
if (sws_setColorspaceDetails(anim->img_convert_ctx, (int *)inv_table, srcRange,
table, dstRange, brightness, contrast, saturation))
{
fprintf(stderr, "Warning: Could not set libswscale colorspace details.\n");
}
}
else {
fprintf(stderr, "Warning: Could not set libswscale colorspace details.\n");
}
#endif
return (0);
}
HRESULT CAviBitmap::GetAllFrames(LPCTSTR lpszFolderName)
{
if(m_pGetFrame == NULL)
{
m_szLastErrorMsg.Format(_T("Not initialized yet"));
return E_FAIL;
}
HRESULT hr = S_OK;
int nBmpInfoHdrSize = sizeof(BITMAPINFO) + sizeof(RGBQUAD) * 256;
BITMAPINFOHEADER* lpBmpInfoHdr = (BITMAPINFOHEADER*)(new BYTE[nBmpInfoHdrSize]);
LONG lpcbFormat = nBmpInfoHdrSize;
BYTE* lpDib = NULL;
BYTE* lpBuffer = NULL;
LONG lBytes = 0, lSamples = 0;
BOOL bReadRaw = FALSE;
int nPos = 0;
int nSampleCount = min(m_lSampleCount, 101);
for(nPos = 0; nPos < nSampleCount; nPos++)
{
//Get the frame format
hr = AVIStreamReadFormat(m_pAviStream, nPos, lpBmpInfoHdr, &lpcbFormat);
if(hr != S_OK)
{
m_szLastErrorMsg.Format(_T("Unable to Get the sample format: %d"), nPos);
break;
}
lpBuffer = NULL;
//Try to read raw data when the bitmap is BI_RGB
if(lpBmpInfoHdr->biCompression == BI_RGB && (lpBmpInfoHdr->biBitCount == 24 || lpBmpInfoHdr->biBitCount == 32))
{
//Get the frame data
lpBuffer = new BYTE[m_biWanted.biSizeImage];
hr = AVIStreamRead(m_pAviStream, nPos, 1, lpBuffer, m_biWanted.biSizeImage, &lBytes, &lSamples);
if(hr != S_OK)
{
m_szLastErrorMsg.Format(_T("Unable to Get the sample data: %d"), nPos);
break;
}
}
else
{
CString szFourCC;
FourCC2Str(m_aviInfo.fccHandler, szFourCC);
AfxTrace(_T("Non-RGB format at frame(%03d)=%s, 0x%08X\n"), nPos, szFourCC, lpBmpInfoHdr->biCompression);
}
//Get the frame at nPos
lpDib = (BYTE*)AVIStreamGetFrame(m_pGetFrame, nPos);
if(lpDib == NULL)
{
m_szLastErrorMsg.Format(_T("Unable to Get the sample: %d"), nPos);
hr = E_FAIL;
break;
}
//compare the data retrieved in 2 ways if needed
if(lpBuffer != NULL)
{
if(memcmp(lpBuffer, lpDib + sizeof(BITMAPINFOHEADER), lpBmpInfoHdr->biSizeImage) != 0)
{
m_szLastErrorMsg.Format(_T("not equals: %d"), nPos);
hr = E_FAIL;
break;
}
}
CString szFileName;
if(lpszFolderName == NULL)
{
szFileName.Format(_T(".\\Frame%03d.bmp"), nPos);
}
else
{
szFileName.Format(_T("%s\\Frame%03d.bmp"), lpszFolderName, nPos);
}
BITMAPINFOHEADER* pTemp = (BITMAPINFOHEADER*)lpDib;
// hr = SaveBitmap(lpBmpInfoHdr, lpBuffer, lpBmpInfoHdr->biSizeImage, szFileName);
hr = SaveBitmap(&m_biWanted, lpDib + sizeof(BITMAPINFOHEADER), m_biWanted.biSizeImage, szFileName);
if(lpBuffer != NULL)
{
delete [] lpBuffer;
lpBuffer = NULL;
}
//Done
}
if(lpBuffer != NULL)
{
delete [] lpBuffer;
lpBuffer = NULL;
}
if(lpBmpInfoHdr != NULL)
{
delete [] lpBmpInfoHdr;
lpBmpInfoHdr = NULL;
}
ReleaseMemory();
return hr;
}
void AVIDump::StoreFrame(const void* data)
{
if (s_bitmap.biSizeImage > s_stored_frame_size)
{
void* temp_stored_frame = realloc(s_stored_frame, s_bitmap.biSizeImage);
if (temp_stored_frame)
{
s_stored_frame = temp_stored_frame;
}
else
{
free(s_stored_frame);
PanicAlertT("Something has gone seriously wrong.\n"
"Stopping video recording.\n"
"Your video will likely be broken.");
Stop();
}
s_stored_frame_size = s_bitmap.biSizeImage;
memset(s_stored_frame, 0, s_bitmap.biSizeImage);
}
if (s_stored_frame)
{
//PanicAlertT("Width: %i, Height: %i, Bit Count: %i", s_bitmap.biWidth, s_bitmap.biHeight, s_bitmap.biBitCount);
if (data && (s_file_count || !Movie::cmp_isRunning || s_frame_count > 0))
{
bool lastSide = false, readOnly = false;
if (Movie::cmp_isRunning && (Movie::cmp_leftFinished || Movie::cmp_rightFinished))
lastSide = true;
if (lastSide && Movie::cmp_startTimerFrame > Movie::cmp_curentBranchFrame) //Dragonbane: Combine frames
readOnly = true;
else
readOnly = false;
if (readOnly && s_getFrame_temp)
{
size_t totalBytes = s_bitmap.biSizeImage / 2;
size_t rowSize = (s_bitmap.biWidth * (s_bitmap.biBitCount / 8)) / 2;
size_t currentByte = 0;
if (s_last_key_temp < 2)
{
BOOL result = AVIStreamIsKeyFrame(s_stream_temp, s_last_key_temp);
if (!result)
s_last_key_temp = AVIStreamNextKeyFrame(s_stream_temp, s_last_key_temp);
}
u64 samplePos = AVIStreamFindSample(s_stream_temp, s_last_key_temp, FIND_ANY);
u64 s_last_key_old = s_last_key_temp;
s_last_key_temp = AVIStreamNextKeyFrame(s_stream_temp, s_last_key_temp);
void* s_uncompressed_frame = AVIStreamGetFrame(s_getFrame_temp, samplePos);
std::string movie_file_name;
if (!s_uncompressed_frame || s_stopTempFile)
{
//Close current file
if (s_getFrame_temp)
{
AVIStreamGetFrameClose(s_getFrame_temp);
s_getFrame_temp = nullptr;
}
if (s_stream_temp)
{
AVIStreamClose(s_stream_temp);
s_stream_temp = nullptr;
}
if (s_file_temp)
{
AVIFileRelease(s_file_temp);
s_file_temp = nullptr;
movie_file_name = GetCurrDumpFile(tempFileCount, true);
if (File::Exists(movie_file_name))
File::Delete(movie_file_name);
}
//Check if we have another temp file
tempFileCount++;
s_stopTempFile = false;
movie_file_name = GetCurrDumpFile(tempFileCount, true);
if (File::Exists(movie_file_name)) //Dragonbane: Open temp file for reading
{
HRESULT h2 = AVIFileOpenA(&s_file_temp, movie_file_name.c_str(), OF_READ, nullptr);
HRESULT h3 = AVIFileGetStream(s_file_temp, &s_stream_temp, streamtypeVIDEO, 0);
s_last_key_temp = 0; //Not the first file anymore, so start from keyframe 0
s_getFrame_temp = AVIStreamGetFrameOpen(s_stream_temp, &s_bitmap);
if (!s_getFrame_temp)
{
PanicAlertT("Your chosen compression codec can not be decompressed again! Can't continue video comparison!");
Movie::CancelComparison();
return;
}
BOOL result = AVIStreamIsKeyFrame(s_stream_temp, s_last_key_temp);
if (!result)
s_last_key_temp = AVIStreamNextKeyFrame(s_stream_temp, s_last_key_temp);
samplePos = AVIStreamFindSample(s_stream_temp, s_last_key_temp, FIND_ANY);
s_last_key_old = s_last_key_temp;
s_last_key_temp = AVIStreamNextKeyFrame(s_stream_temp, s_last_key_temp);
s_uncompressed_frame = AVIStreamGetFrame(s_getFrame_temp, samplePos);
if (!s_uncompressed_frame)
{
//PanicAlertT("Last frame stored. Start timer now!");
Movie::cmp_startTimerFrame = Movie::cmp_curentBranchFrame;
memcpy(s_stored_frame, data, s_bitmap.biSizeImage);
return;
}
}
else
{
//PanicAlertT("Last frame stored. Start timer now!");
Movie::cmp_startTimerFrame = Movie::cmp_curentBranchFrame;
memcpy(s_stored_frame, data, s_bitmap.biSizeImage);
return;
}
}
//Stop temp file on next frame if last frame is processed
if (s_last_key_old == s_last_key_temp || AVIStreamFindSample(s_stream_temp, s_last_key_temp, FIND_ANY) == samplePos)
s_stopTempFile = true;
void* memptr1 = s_uncompressed_frame;
memptr1 = static_cast<u8*>(memptr1) + sizeof(BITMAPINFOHEADER);
if (Movie::cmp_leftFinished)
{
memcpy(s_stored_frame, memptr1, s_bitmap.biSizeImage);
for (u64 currentRow = 0; currentRow < s_bitmap.biHeight; currentRow++)
{
currentByte += rowSize;
void* memptr = s_stored_frame;
const void* memptr2 = data;
memptr = static_cast<u8*>(memptr) + currentByte;
memptr2 = static_cast<const u8*>(memptr2) + currentByte;
memcpy(memptr, memptr2, rowSize);
currentByte += rowSize;
}
}
else if (Movie::cmp_rightFinished)
{
memcpy(s_stored_frame, memptr1, s_bitmap.biSizeImage);
//BITMAPINFOHEADER test;
//memset(&test, 0, sizeof(BITMAPINFOHEADER));
//memcpy(&test, s_uncompressed_frame, sizeof(BITMAPINFOHEADER));
for (u64 currentRow = 0; currentRow < s_bitmap.biHeight; currentRow++)
{
void* memptr = s_stored_frame;
const void* memptr2 = data;
memptr = static_cast<u8*>(memptr) + currentByte;
memptr2 = static_cast<const u8*>(memptr2) + currentByte;
memcpy(memptr, memptr2, rowSize);
currentByte += rowSize * 2;
}
}
else
{
memcpy(s_stored_frame, data, s_bitmap.biSizeImage);
}
}
else
{
memcpy(s_stored_frame, data, s_bitmap.biSizeImage);
}
}
else // pitch black frame
{
memset(s_stored_frame, 0, s_bitmap.biSizeImage);
}
}
}
static FIMULTIBITMAP* ReadFromAvi(const char* filename) {
int err=0;
AVIFileInit();
PAVISTREAM pavi; // Handle To An Open Stream
if( AVIStreamOpenFromFile(&pavi, filename, streamtypeVIDEO, 0, OF_READ, NULL) != 0) {
AVIFileExit();
return NULL;
}
AVISTREAMINFO psi; // Pointer To A Structure Containing Stream Info
AVIStreamInfo(pavi, &psi, sizeof(psi)); // Reads Information About The Stream Into psi
int width = psi.rcFrame.right-psi.rcFrame.left; // Width Is Right Side Of Frame Minus Left
int height = psi.rcFrame.bottom-psi.rcFrame.top; // Height Is Bottom Of Frame Minus Top
int frameCount = AVIStreamLength(pavi); // The Last Frame Of The Stream
double mpf = AVIStreamSampleToTime(pavi, frameCount) / (double)frameCount; // Calculate Rough Milliseconds Per Frame
PGETFRAME pgf = AVIStreamGetFrameOpen(pavi, NULL); // Create The PGETFRAME Using Our Request Mode
if (pgf==NULL)
{
// An Error Occurred Opening The Frame
error("Failed To Open frame from AVI");
}
//HDC hdc = GetDC(0);
HDRAWDIB hdd = DrawDibOpen(); // Handle For Our Dib
BITMAPINFOHEADER bmih; // Header Information For DrawDibDraw Decoding
bmih.biSize = sizeof (BITMAPINFOHEADER); // Size Of The BitmapInfoHeader
bmih.biPlanes = 1; // Bitplanes
bmih.biBitCount = 24; // Bits Format We Want (24 Bit, 3 Bytes)
bmih.biWidth = width; // Width We Want (256 Pixels)
bmih.biHeight = height; // Height We Want (256 Pixels)
bmih.biCompression = BI_RGB; // Requested Mode = RGB
char *data; // Pointer To Texture Data
HBITMAP hBitmap = CreateDIBSection(hdc, (BITMAPINFO*)(&bmih), DIB_RGB_COLORS, (void**)(&data), NULL, NULL);
SelectObject(hdc, hBitmap); // Select hBitmap Into Our Device Context (hdc)
// create a new freeimage anim
someError=false;
FIMULTIBITMAP* ret = FreeImage_OpenMultiBitmap(FIF_TIFF, "temp.tiff", TRUE, FALSE);
if (!ret || someError) {
error("Couldnt create multibitmap");
}
for (int frame=0; frame<frameCount; frame++) {
fprintf(stderr, "Loading frame %i\n", frame);
// Grab Data From The AVI Stream
LPBITMAPINFOHEADER lpbi = (LPBITMAPINFOHEADER)AVIStreamGetFrame(pgf, frame);
// Pointer To Data Returned By AVIStreamGetFrame
// (Skip The Header Info To Get To The Data)
char* pdata = (char *)lpbi + lpbi->biSize + lpbi->biClrUsed * sizeof(RGBQUAD);
// Convert Data To Requested Bitmap Format
DrawDibDraw(hdd, hdc, 0, 0, width, height, lpbi, pdata, 0, 0, width, height, 0);
// copy into the freeimage thing
FIBITMAP* fiBitmap = FreeImage_ConvertFromRawBits((BYTE*)data, width, height, width*3, 24, 0xFF0000, 0x00FF00, 0x0000FF);
/* BYTE* src = (BYTE*)data;
for (int y=0; y<height; y++) {
BYTE* dst = FreeImage_GetScanLine(fiBitmap, y);
for (int x=0; x<width; x++) {
//src++;
*dst++ = *src++;
*dst++ = *src++;
*dst++ = *src++;
}
}
*/
FIBITMAP* grayBitmap = FreeImage_ConvertToGreyscale(fiBitmap);
FreeImage_Unload(fiBitmap);
FreeImage_AppendPage(ret, grayBitmap);
}
FreeImage_CloseMultiBitmap(ret);
ret = FreeImage_OpenMultiBitmap(FIF_TIFF, "temp.tiff", FALSE, TRUE);
DeleteObject(hBitmap); // Delete The Device Dependant Bitmap Object
DrawDibClose(hdd); // Closes The DrawDib Device Context
AVIStreamGetFrameClose(pgf); // Deallocates The GetFrame Resources
AVIStreamRelease(pavi); // Release The Stream
AVIFileExit(); // Release The File
return ret;
}
void CLoaderAVI::update(unsigned int frameTime)
{
if (!m_play || m_frameTime == 0)
{
return;
}
m_time += frameTime;
unsigned int new_frame = m_time / m_frameTime;
// La frame n'a pas changée
if (new_frame == m_frame)
{
return;
}
// La vidéo est terminée
if (new_frame >= m_lastFrame)
{
if (m_loop)
{
m_frame = 0;
m_time = 0;
}
// Dernière frame
else
{
if (new_frame == m_lastFrame)
{
// On remplace la vidéo par une image noire
for (int i = 0; i < m_width * m_height; ++i)
{
m_pixels[4 * i + 0] = 0x00;
m_pixels[4 * i + 1] = 0x00;
m_pixels[4 * i + 2] = 0x00;
m_pixels[4 * i + 3] = 0xFF;
}
// Mise-à-jour de la texture
CImage img(m_width, m_height, reinterpret_cast<CColor *>(&m_pixels[0]));
Game::textureManager->reloadTexture(m_texture, img);
}
m_frame = m_lastFrame;
m_time = m_lastFrame * m_frameTime;
m_play = false;
return;
}
}
else
{
m_frame = new_frame;
}
#ifdef T_SYSTEM_WINDOWS
// On récupère la frame (plante !)
LPBITMAPINFOHEADER lpbi = reinterpret_cast<LPBITMAPINFOHEADER>(AVIStreamGetFrame(m_pgf, m_frame));
if (lpbi == nullptr)
{
CApplication::getApp()->log("AVIStreamGetFrame retourne un pointeur nul", ILogger::Error);
return;
}
// DEBUG
if (lpbi->biBitCount != 24)
{
CApplication::getApp()->log(CString::fromUTF8("La vidéo n'utilise pas 3 composantes par couleur (%1)").arg(lpbi->biBitCount), ILogger::Error);
return;
}
unsigned char * temp = reinterpret_cast<unsigned char *>(lpbi) + lpbi->biSize + lpbi->biClrUsed * sizeof(RGBQUAD);
CColor * tempRGBA = new CColor[m_width * m_height];
for (int h = 0; h < m_height; ++h)
{
for (int w = 0; w < m_width; ++w)
{
tempRGBA[(m_height - h - 1) * m_width + w].setBlue(temp[(h * m_width + w) * 3 + 0]);
tempRGBA[(m_height - h - 1) * m_width + w].setGreen(temp[(h * m_width + w) * 3 + 1]);
tempRGBA[(m_height - h - 1) * m_width + w].setRed(temp[(h * m_width + w) * 3 + 2]);
}
}
// Mise-à-jour de la texture
CImage img(m_width, m_height, tempRGBA);
Game::textureManager->reloadTexture(m_texture, img);
#endif
}
bool CvCaptureAVI_VFW::grabFrame()
{
if( avistream )
bmih = (BITMAPINFOHEADER*)AVIStreamGetFrame( getframe, pos++ );
return bmih != 0;
}
BOOL ExtractAVIFrames(CString szFileName)
{
AVIFileInit();
PAVIFILE avi;
int res = AVIFileOpen(&avi, szFileName, OF_READ, NULL);
if (res != AVIERR_OK)
{
//an error occures
if (avi != NULL)
AVIFileRelease(avi);
return FALSE;
}
AVIFILEINFO avi_info;
AVIFileInfo(avi, &avi_info, sizeof(AVIFILEINFO));
CString szFileInfo;
szFileInfo.Format("Dimention: %dx%d\n"
"Length: %d frames\n"
"Max bytes per second: %d\n"
"Samples per second: %d\n"
"Streams: %d\n"
"File Type: %d", avi_info.dwWidth,
avi_info.dwHeight,
avi_info.dwLength,
avi_info.dwMaxBytesPerSec,
(DWORD)(avi_info.dwRate / avi_info.dwScale),
avi_info.dwStreams,
avi_info.szFileType);
AfxMessageBox(szFileInfo, MB_ICONINFORMATION | MB_OK);
PAVISTREAM pStream;
res = AVIFileGetStream(avi, &pStream, streamtypeVIDEO /*video stream*/,
0 /*first stream*/);
if (res != AVIERR_OK)
{
if (pStream != NULL)
AVIStreamRelease(pStream);
AVIFileExit();
return FALSE;
}
//do some task with the stream
int iNumFrames;
int iFirstFrame;
iFirstFrame = AVIStreamStart(pStream);
if (iFirstFrame == -1)
{
//Error getteing the frame inside the stream
if (pStream != NULL)
AVIStreamRelease(pStream);
AVIFileExit();
return FALSE;
}
iNumFrames = AVIStreamLength(pStream);
if (iNumFrames == -1)
{
//Error getteing the number of frames inside the stream
if (pStream != NULL)
AVIStreamRelease(pStream);
AVIFileExit();
return FALSE;
}
//getting bitmap from frame
BITMAPINFOHEADER bih;
ZeroMemory(&bih, sizeof(BITMAPINFOHEADER));
bih.biBitCount = 24; //24 bit per pixel
bih.biClrImportant = 0;
bih.biClrUsed = 0;
bih.biCompression = BI_RGB;
bih.biPlanes = 1;
bih.biSize = 40;
bih.biXPelsPerMeter = 0;
bih.biYPelsPerMeter = 0;
//calculate total size of RGBQUAD scanlines (DWORD aligned)
bih.biSizeImage = (((bih.biWidth * 3) + 3) & 0xFFFC) * bih.biHeight;
PGETFRAME pFrame;
pFrame = AVIStreamGetFrameOpen(pStream,
NULL/*(BITMAPINFOHEADER*) AVIGETFRAMEF_BESTDISPLAYFMT*/ /*&bih*/);
//Get the first frame
int index = 0;
for (int i = iFirstFrame; i<iNumFrames; i++)
{
index = i - iFirstFrame;
BYTE* pDIB = (BYTE*)AVIStreamGetFrame(pFrame, index);
CreateFromPackedDIBPointer(pDIB, index);
}
AVIStreamGetFrameClose(pFrame);
//close the stream after finishing the task
if (pStream != NULL)
AVIStreamRelease(pStream);
AVIFileExit();
return TRUE;
}
