bool AviFrameGraber::_Open(void){
//thread_handle_ !=NULL means it is already opened
if (thread_handle_!=NULL) return false;
int res=AVIFileOpen(&avi_file_, file_path_.c_str(), OF_READ, NULL);
if (res!=AVIERR_OK){
woodychang0611::diagnostics::SendError(_T("AviFrameGraber Open File Fail"));
_Close();
return false;
}
res=AVIFileGetStream(avi_file_, &stream_, streamtypeVIDEO, 0/*first stream*/);
if (res!=AVIERR_OK){
woodychang0611::diagnostics::SendError(_T("AviFrameGraber Get Stream Fail"));
_Close();
return false;
}
if (AVIStreamStart(stream_)==-1 || AVIStreamLength(stream_)==-1){
woodychang0611::diagnostics::SendError(_T("AviFrameGraber Stream Start or Length no correct"));
_Close();
return false;
}
AVIFileInfo(avi_file_, &avi_info_, sizeof(AVIFILEINFO));
BITMAPINFOHEADER bih;
bih.biSize = sizeof(BITMAPINFOHEADER);
bih.biWidth = avi_info_.dwWidth;
bih.biHeight = avi_info_.dwHeight;
bih.biPlanes = 1;
bih.biBitCount = 24;
bih.biCompression = BI_RGB;
bih.biSizeImage = 0;
bih.biXPelsPerMeter = 0;
bih.biYPelsPerMeter = 0;
bih.biClrUsed = 0;
bih.biClrImportant = 0;
frame_=AVIStreamGetFrameOpen(stream_, (LPBITMAPINFOHEADER) &bih);
if (frame_ !=NULL){
start_frame_ = AVIStreamStart(stream_);
frame_length_ = AVIStreamLength(stream_);
current_frame_ = start_frame_;
//Set Frame info
frame_info_.start_frame_=start_frame_;
frame_info_.frame_length_ =frame_length_;
frame_info_.frame_per_second_=(FLOAT32)avi_info_.dwRate/avi_info_.dwScale;
frame_info_.frame_width_=(UINT16) avi_info_.dwWidth;
frame_info_.frame_height_=(UINT16) avi_info_.dwHeight;
_status = FRAME_SUBJECT_PAUSE;
thread_handle_ =CreateThread(NULL ,0,this->_ThreadFunc,this,0,NULL);
return true;
}else{
woodychang0611::diagnostics::SendError(_T("AviFrameGraber Get Frame Failed"));
}
return false;
}
HRESULT CBSoundAVI::InitializeBuffer(PAVISTREAM Stream)
{
if(!Stream) return E_FAIL;
SetStreaming(true);
m_Type = SOUND_SFX;
m_Looping = false;
m_AudioStream = Stream;
LONG FormatSize;
if(AVIStreamReadFormat(m_AudioStream, 0, NULL, &FormatSize)!=0) return E_FAIL;
LPWAVEFORMAT Format = (LPWAVEFORMAT)new BYTE[FormatSize];
if(AVIStreamReadFormat(m_AudioStream, 0, Format, &FormatSize)!=0){
delete [] (BYTE*)Format;
return E_FAIL;
}
m_TotalDataLength = AVIStreamLength(m_AudioStream) * Format->nBlockAlign;
HRESULT ret;
memcpy(&m_Format, Format, sizeof(PCMWAVEFORMAT));
m_Format.wf.wFormatTag = WAVE_FORMAT_PCM;
// create buffer
ret = CreateSoundBuffer(m_TotalDataLength, (PCMWAVEFORMAT*)Format);
delete [] (BYTE*)Format;
return ret;
}
int AVIOBJ::OpenAVI(LPCSTR szFile) // Opens An AVI File (szFile)
{
AVIFileInit(); // Opens The AVIFile Library
pgf=NULL;
if (AVIStreamOpenFromFile(&pavi, szFile, streamtypeVIDEO, 0, OF_READ, NULL) !=0)
return(0);
AVIStreamInfo(pavi, &psi, sizeof(psi)); // Reads Information About The Stream Into psi
width=psi.rcFrame.right-psi.rcFrame.left; // Width Is Right Side Of Frame Minus Left
height=psi.rcFrame.bottom-psi.rcFrame.top; // Height Is Bottom Of Frame Minus Top
lastframe=AVIStreamLength(pavi); // The Last Frame Of The Stream
mpf=AVIStreamSampleToTime(pavi,lastframe)/lastframe; // Calculate Rough Milliseconds Per Frame
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
bmih.biHeight = height; // Height We Want
bmih.biCompression = BI_RGB; // Requested Mode = RGB
hBitmap = CreateDIBSection (hdc, (BITMAPINFO*)(&bmih), DIB_RGB_COLORS, (void**)(&data), NULL, 0);
SelectObject (hdc, hBitmap); // Select hBitmap Into Our Device Context (hdc)
pgf=AVIStreamGetFrameOpen(pavi, NULL); // Create The PGETFRAME Using Our Request Mode
if (pgf==NULL) return(0);
return(1);
}
bool AVI :: Load(std :: string fname,bool loopflag,Texture *tex) // Opens An AVI File
{
// copy over looping flag
loop=loopflag;
// do we have a texture manager?
if(!tex)
return false;
// copy it over
tman=tex;
hdc=CreateCompatibleDC(0); // Get a compatible DC
hdd = DrawDibOpen(); // Grab A Device Context For Our Dib
AVIFileInit(); // Opens The AVIFile Library
// Opens The AVI Stream
if (AVIStreamOpenFromFile(&pavi, fname.c_str(), streamtypeVIDEO, 0, OF_READ, NULL) !=0)
return false;
AVIStreamInfo(pavi, &psi, sizeof(psi)); // Reads Information About The Stream Into psi
width=psi.rcFrame.right-psi.rcFrame.left; // Width Is Right Side Of Frame Minus Left
height=psi.rcFrame.bottom-psi.rcFrame.top; // Height Is Bottom Of Frame Minus Top
lastframe=AVIStreamLength(pavi); // The Last Frame Of The Stream
mpf=AVIStreamSampleToTime(pavi,lastframe)/lastframe; // Calculate Rough Milliseconds Per Frame
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 = 256; // Width We Want (256 Pixels)
bmih.biHeight = 256; // Height We Want (256 Pixels)
bmih.biCompression = BI_RGB; // Requested Mode = RGB
hBitmap = CreateDIBSection (hdc, (BITMAPINFO*)(&bmih), DIB_RGB_COLORS, (void**)(&data), NULL, NULL);
SelectObject (hdc, hBitmap); // Select hBitmap Into Our Device Context (hdc)
pgf=AVIStreamGetFrameOpen(pavi, NULL); // Create The PGETFRAME Using Our Request Mode
if (pgf==NULL)
return false;
// create the texture
Image img;
img.Create(256,256,false); // set dimensions of texture
img.SetImage(data); // set the texture information
texid=tman->Create(&img); // create the texture
// clear the time position
pos=0;
// success
return true;
}
/*
---------------------------------------------------------------------------------------
- Opens An AVI File (szFile)
---------------------------------------------------------------------------------------
*/
bool AviVideoRenderer::OpenAVI(const char * szFile)
{
// Opens The AVI Stream
if (AVIStreamOpenFromFileA(&_AVR_pavi, szFile, streamtypeVIDEO, 0, OF_READ, NULL) !=0)
return false;
AVIStreamInfo(_AVR_pavi, &_AVR_psi, sizeof(_AVR_psi)); // Reads Information About The Stream Into psi
_video_width=_AVR_psi.rcFrame.right-_AVR_psi.rcFrame.left; // Width Is Right Side Of Frame Minus Left
_video_height=_AVR_psi.rcFrame.bottom-_AVR_psi.rcFrame.top; // Height Is Bottom Of Frame Minus Top
_endFrame=AVIStreamLength(_AVR_pavi); // The Last Frame Of The Stream
_timeperframe=AVIStreamSampleToTime(_AVR_pavi,_endFrame)/_endFrame; // Calculate Rough Milliseconds Per Frame
int sizet = 1024;
if((_video_width < 128) && (_video_height < 128))
sizet = 128;
else if((_video_width < 256) && (_video_height < 256))
sizet = 256;
else if((_video_width < 512) && (_video_height < 512))
sizet = 512;
_widths.push_back(sizet);
_heights.push_back(sizet);
// initialize the host texture
InitializeTexture();
_AVR_bmih.biSize = sizeof (BITMAPINFOHEADER); // Size Of The BitmapInfoHeader
_AVR_bmih.biPlanes = 1; // Bitplanes
_AVR_bmih.biBitCount = 24; // Bits Format We Want (24 Bit, 3 Bytes)
_AVR_bmih.biWidth = _widths[0]; // Width We Want
_AVR_bmih.biHeight = _heights[0]; // Height We Want
_AVR_bmih.biCompression = BI_RGB; // Requested Mode = RGB
_AVR_hBitmap = CreateDIBSection (_AVR_hdc, (BITMAPINFO*)(&_AVR_bmih), DIB_RGB_COLORS, (void**)(&_img_data), NULL, NULL);
SelectObject (_AVR_hdc, _AVR_hBitmap); // Select hBitmap Into Our Device Context (hdc)
_AVR_pgf=AVIStreamGetFrameOpen(_AVR_pavi, NULL); // Create The PGETFRAME Using Our Request Mode
_avi_opened = true;
return(_AVR_pgf!=NULL);
}
bool CAvi::OpenAVI( LPCWSTR szFile )
{
AVISTREAMINFO psi;
AVIFileInit();
if( AVIStreamOpenFromFile( &m_pavi, szFile, streamtypeVIDEO, 0, OF_READ, NULL) !=0)
{
MessageBox( NULL, _T("Couldnt open the CAvi stream."), _T("VandaEngine Error"), MB_OK | MB_ICONERROR );
return 0;
}
AVIStreamInfo(m_pavi, &psi, sizeof(psi)); // Reads Information About The Stream Into psi
m_width=psi.rcFrame.right-psi.rcFrame.left; // Width Is Right Side Of Frame Minus Left
m_height=psi.rcFrame.bottom-psi.rcFrame.top; // Height Is Bottom Of Frame Minus Top
m_lastFrame = AVIStreamLength(m_pavi);
m_mpf=AVIStreamSampleToTime(m_pavi,m_lastFrame)/m_lastFrame; // Calculate Rough Milliseconds Per Frame
if( m_mpf == 0 )
{
MessageBox( NULL, _T("MPF is 0"), _T("VandaEngine Error"), MB_OK | MB_ICONINFORMATION );
return 0;
}
BITMAPINFOHEADER bmih;
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 = 1024; // Width We Want (512 Pixels)
bmih.biHeight = 512; // Height We Want (256 Pixels)
bmih.biCompression = BI_RGB; // Requested Mode = RGB
m_hBitmap = CreateDIBSection (m_hDC, (BITMAPINFO*)(&bmih), DIB_RGB_COLORS, (void**)(&m_data), NULL, NULL);
SelectObject (m_hDC, m_hBitmap); // Select m_hBitmap Into Our Device Context (hdc)
m_pgf=AVIStreamGetFrameOpen(m_pavi, NULL); // Create The PGETFRAME Using Our Request Mode
if (m_pgf==NULL)
{
//An Error Occurred Opening The Frame
MessageBox( NULL, _T("Couldn't open the CAvi frame."), _T("VandaEngine Error"), MB_OK | MB_ICONINFORMATION );
return 0;
}
return 1;
}
bool CAviToBmp::Open(LPCTSTR Path)
{
Close();
if (FAILED(m_hr = AVIFileOpen(&m_pFile, Path, OF_READ, NULL)))
return(FALSE);
if (FAILED(m_hr = AVIFileGetStream(m_pFile, &m_pStream, streamtypeVIDEO, 0)))
return(FALSE);
m_FrameCount = AVIStreamLength(m_pStream);
long Start = AVIStreamStart(m_pStream);
if (Start < 0)
return(FALSE);
long FmtSize;
if (FAILED(m_hr = AVIStreamReadFormat(m_pStream, Start, NULL, &FmtSize)))
return(FALSE);
m_pBmpInfo = (LPBITMAPINFO)new BYTE[FmtSize];
if (FAILED(m_hr = AVIStreamReadFormat(m_pStream, Start, m_pBmpInfo, &FmtSize)))
return(FALSE);
m_pGetFrame = AVIStreamGetFrameOpen(m_pStream, (LPBITMAPINFOHEADER)AVIGETFRAMEF_BESTDISPLAYFMT);
if (m_pGetFrame == NULL)
return(FALSE);
return(TRUE);
}
static int startavi(struct anim *anim)
{
AviError avierror;
#if defined(_WIN32) && !defined(FREE_WINDOWS)
HRESULT hr;
int i, firstvideo = -1;
int streamcount;
BYTE abFormat[1024];
LONG l;
LPBITMAPINFOHEADER lpbi;
AVISTREAMINFO avis;
streamcount = anim->streamindex;
#endif
anim->avi = MEM_callocN(sizeof(AviMovie), "animavi");
if (anim->avi == NULL) {
printf("Can't open avi: %s\n", anim->name);
return -1;
}
avierror = AVI_open_movie(anim->name, anim->avi);
#if defined(_WIN32) && !defined(FREE_WINDOWS)
if (avierror == AVI_ERROR_COMPRESSION) {
AVIFileInit();
hr = AVIFileOpen(&anim->pfile, anim->name, OF_READ, 0L);
if (hr == 0) {
anim->pfileopen = 1;
for (i = 0; i < MAXNUMSTREAMS; i++) {
if (AVIFileGetStream(anim->pfile, &anim->pavi[i], 0L, i) != AVIERR_OK) {
break;
}
AVIStreamInfo(anim->pavi[i], &avis, sizeof(avis));
if ((avis.fccType == streamtypeVIDEO) && (firstvideo == -1)) {
if (streamcount > 0) {
streamcount--;
continue;
}
anim->pgf = AVIStreamGetFrameOpen(anim->pavi[i], NULL);
if (anim->pgf) {
firstvideo = i;
/* get stream length */
anim->avi->header->TotalFrames = AVIStreamLength(anim->pavi[i]);
/* get information about images inside the stream */
l = sizeof(abFormat);
AVIStreamReadFormat(anim->pavi[i], 0, &abFormat, &l);
lpbi = (LPBITMAPINFOHEADER)abFormat;
anim->avi->header->Height = lpbi->biHeight;
anim->avi->header->Width = lpbi->biWidth;
}
else {
FIXCC(avis.fccHandler);
FIXCC(avis.fccType);
printf("Can't find AVI decoder for type : %4.4hs/%4.4hs\n",
(LPSTR)&avis.fccType,
(LPSTR)&avis.fccHandler);
}
}
}
/* register number of opened avistreams */
anim->avistreams = i;
/*
* Couldn't get any video streams out of this file
*/
if ((anim->avistreams == 0) || (firstvideo == -1)) {
avierror = AVI_ERROR_FORMAT;
}
else {
avierror = AVI_ERROR_NONE;
anim->firstvideo = firstvideo;
}
}
else {
AVIFileExit();
}
}
#endif
if (avierror != AVI_ERROR_NONE) {
AVI_print_error(avierror);
printf("Error loading avi: %s\n", anim->name);
free_anim_avi(anim);
return -1;
}
anim->duration = anim->avi->header->TotalFrames;
anim->params = NULL;
anim->x = anim->avi->header->Width;
anim->y = anim->avi->header->Height;
anim->interlacing = 0;
anim->orientation = 0;
anim->framesize = anim->x * anim->y * 4;
anim->curposition = 0;
anim->preseek = 0;
/* printf("x:%d y:%d size:%d interl:%d dur:%d\n", anim->x, anim->y, anim->framesize, anim->interlacing, anim->duration);*/
return 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;
}
void CRotateAVIDlg::ProcessAVI(const TCHAR *source_filename, const TCHAR *dest_filename, eRotation rot)
{
TCHAR error_buf[1024];
PAVIFILE source_avi = 0;
PAVIFILE dest_avi = 0;
PAVISTREAM pSrcVidStream = 0;
PAVISTREAM pSrcAudioStream = 0;
PAVISTREAM pDestVidStream = 0;
PAVISTREAM pDestAudioStream = 0;
char *pSrcBuffer = 0;
char *pJPGBuffer = 0;
char *pDecompBuffer = 0;
char *pRotateBuffer = 0;
char *pDestBuffer = 0;
AVIFileInit();
// source setup
if (AVIFileOpen(&source_avi, source_filename, OF_READ, NULL) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Couldn't open file %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
AVIFILEINFO src_avi_info;
AVIFileInfo(source_avi, &src_avi_info, sizeof(AVIFILEINFO));
if (AVIFileGetStream(source_avi, &pSrcVidStream, streamtypeVIDEO, 0) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("No video stream in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
BITMAPINFOHEADER srcBIH;
long srcvidstreamsize;
AVIStreamFormatSize(pSrcVidStream, 0, &srcvidstreamsize);
if (srcvidstreamsize > sizeof(BITMAPINFOHEADER))
{
_stprintf(error_buf, TEXT("Unable to handle video stream format in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
srcvidstreamsize = sizeof(BITMAPINFOHEADER);
if (AVIStreamReadFormat(pSrcVidStream, 0, &srcBIH, &srcvidstreamsize) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Error reading stream format in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
if (srcBIH.biCompression != MKFOURCC('M','J','P','G'))
{
_stprintf(error_buf, TEXT("%s is not motion JPEG format"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
AVISTREAMINFO vidstream_info;
if (AVIStreamInfo(pSrcVidStream, &vidstream_info, sizeof(AVISTREAMINFO)) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Error reading stream info in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
int firstVidSrcFrame = AVIStreamStart(pSrcVidStream);
if (firstVidSrcFrame == -1)
{
_stprintf(error_buf, TEXT("Video stream start error in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
int numVidSrcFrames = AVIStreamLength(pSrcVidStream);
if (numVidSrcFrames == -1)
{
_stprintf(error_buf, TEXT("Video stream length error in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
AVIFileGetStream(source_avi, &pSrcAudioStream, streamtypeAUDIO, 0);
int firstAudioSrcFrame = 0;
int numAudioSrcFrames = 0;
if (pSrcAudioStream)
{
firstAudioSrcFrame = AVIStreamStart(pSrcAudioStream);
if (firstAudioSrcFrame == -1)
{
_stprintf(error_buf, TEXT("Audio stream start error in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
numAudioSrcFrames = AVIStreamLength(pSrcAudioStream);
if (numAudioSrcFrames == -1)
{
_stprintf(error_buf, TEXT("Audio stream length error in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
}
// dest setup
BITMAPINFOHEADER destBIH;
destBIH = srcBIH;
if (rot != CW_180)
{
destBIH.biWidth = srcBIH.biHeight;
destBIH.biHeight = srcBIH.biWidth;
}
if (AVIFileOpen(&dest_avi, dest_filename, OF_CREATE | OF_WRITE, NULL) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Couldn't open file %s"), dest_filename);
MessageBox(error_buf);
goto cleanup;
}
vidstream_info.rcFrame.left = vidstream_info.rcFrame.top = 0;
vidstream_info.rcFrame.right = destBIH.biWidth;
vidstream_info.rcFrame.bottom = destBIH.biHeight;
if (AVIFileCreateStream(dest_avi, &pDestVidStream, &vidstream_info) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Error creating video stream in %s"), dest_filename);
MessageBox(error_buf);
goto cleanup;
}
if (AVIStreamSetFormat(pDestVidStream, 0, &destBIH, sizeof(BITMAPINFOHEADER)) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Error setting video stream format in %s"), dest_filename);
MessageBox(error_buf);
goto cleanup;
}
if (AVIStreamSetFormat(pDestVidStream, 0, &destBIH, sizeof(BITMAPINFOHEADER)) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Error setting video stream format in %s"), dest_filename);
MessageBox(error_buf);
goto cleanup;
}
// video memory
int img_rgb_size = srcBIH.biHeight * srcBIH.biWidth * 3;
pSrcBuffer = new char[img_rgb_size];
pJPGBuffer = new char[img_rgb_size];
pDecompBuffer = new char[img_rgb_size];
pRotateBuffer = new char[img_rgb_size];
pDestBuffer = new char[img_rgb_size];
long bytes_read;
long bytes_written;
for (int i = firstVidSrcFrame; i < numVidSrcFrames; ++i)
{
if (AVIStreamRead(pSrcVidStream, i, 1, pSrcBuffer, img_rgb_size, &bytes_read, 0) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Error reading video stream from %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
// well-form the jpg
int jpglen = ConstructWellFormedJPEG(pSrcBuffer, pJPGBuffer, bytes_read);
// decompress
JPEGHandler jpgh_decomp(pJPGBuffer, jpglen);
jpgh_decomp.DecompressToRGB(pDecompBuffer, img_rgb_size);
// rotate
int destx, desty;
char *pRotSrc;
char *pRotDest;
switch (rot)
{
case CW_90:
for (int srcy = 0; srcy < srcBIH.biHeight; ++srcy)
{
for (int srcx = 0; srcx < srcBIH.biWidth; ++srcx)
{
destx = srcBIH.biHeight-1-srcy;
desty = srcx;
pRotSrc = &pDecompBuffer[(srcy * srcBIH.biWidth + srcx) * 3];
pRotDest = &pRotateBuffer[(desty * srcBIH.biHeight + destx) * 3];
*pRotDest++ = *pRotSrc++;
*pRotDest++ = *pRotSrc++;
*pRotDest++ = *pRotSrc++;
}
}
break;
case CW_180:
for (int srcy = 0; srcy < srcBIH.biHeight; ++srcy)
{
for (int srcx = 0; srcx < srcBIH.biWidth; ++srcx)
{
destx = srcBIH.biWidth-1-srcx;
desty = srcBIH.biHeight-1-srcy;
pRotSrc = &pDecompBuffer[(srcy * srcBIH.biWidth + srcx) * 3];
pRotDest = &pRotateBuffer[(desty * srcBIH.biWidth + destx) * 3];
*pRotDest++ = *pRotSrc++;
*pRotDest++ = *pRotSrc++;
*pRotDest++ = *pRotSrc++;
}
}
break;
case ACW_90:
for (int srcy = 0; srcy < srcBIH.biHeight; ++srcy)
{
for (int srcx = 0; srcx < srcBIH.biWidth; ++srcx)
{
destx = srcy;
desty = srcBIH.biWidth-1-srcx;
pRotSrc = &pDecompBuffer[(srcy * srcBIH.biWidth + srcx) * 3];
pRotDest = &pRotateBuffer[(desty * srcBIH.biHeight + destx) * 3];
*pRotDest++ = *pRotSrc++;
*pRotDest++ = *pRotSrc++;
*pRotDest++ = *pRotSrc++;
}
}
break;
}
// compress
JPEGHandler jpgh_comp(pRotateBuffer, img_rgb_size);
if (rot != CW_180)
destBIH.biSizeImage = jpgh_comp.CompressFromRGB(pDestBuffer, img_rgb_size, srcBIH.biHeight, srcBIH.biWidth);
else
destBIH.biSizeImage = jpgh_comp.CompressFromRGB(pDestBuffer, img_rgb_size, srcBIH.biWidth, srcBIH.biHeight);
if (AVIStreamWrite(pDestVidStream, i, 1, pDestBuffer, destBIH.biSizeImage, AVIIF_KEYFRAME, NULL, &bytes_written) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Error writing video stream to %s"), dest_filename);
MessageBox(error_buf);
goto cleanup;
}
}
cleanup:
delete[] pSrcBuffer;
delete[] pDestBuffer;
delete[] pJPGBuffer;
delete[] pDecompBuffer;
delete[] pRotateBuffer;
if (pDestAudioStream) AVIStreamRelease(pDestAudioStream);
if (pDestVidStream) AVIStreamRelease(pDestVidStream);
if (pSrcAudioStream) AVIStreamRelease(pSrcAudioStream);
if (pSrcVidStream) AVIStreamRelease(pSrcVidStream);
if (dest_avi) AVIFileRelease(dest_avi);
if (source_avi) AVIFileRelease(source_avi);
AVIFileExit();
}
bool CMusic::loadFromVideo(const CString& fileName)
{
m_loaded = false;
m_fileName = fileName;
m_file = nullptr;
m_fromVideo = true;
#ifdef T_SYSTEM_WINDOWS
m_sampleCount = 0;
ALenum error = alGetError();
CApplication::getApp()->log(CString::fromUTF8("Chargement de la musique de la vidéo %1").arg(m_fileName));
// Ouverture du flux audio
if (AVIStreamOpenFromFile(&m_aviStream, m_fileName.toCharArray(), streamtypeAUDIO, 0, OF_READ, nullptr))
{
CApplication::getApp()->log("AVIStreamOpenFromFile : impossible de lire le flux audio", ILogger::Error);
return false;
}
LONG buffer_size;
AVIStreamRead(m_aviStream, AVIStreamStart(m_aviStream), (-1L), nullptr, 0, &buffer_size, nullptr);
PBYTE tmp_format = new BYTE[buffer_size];
AVIStreamReadFormat(m_aviStream, AVIStreamStart(m_aviStream), tmp_format, &buffer_size);
LPWAVEFORMATEX wave_format = reinterpret_cast<LPWAVEFORMATEX>(tmp_format);
// Lecture du nombre d'échantillons et du taux d'échantillonnage
m_nbrSamples = AVIStreamLength(m_aviStream);
m_sampleRate = wave_format->nSamplesPerSec;
// Détermination du format en fonction du nombre de canaux
switch (wave_format->nChannels)
{
case 1:
m_format = AL_FORMAT_MONO16;
break;
case 2:
m_format = AL_FORMAT_STEREO16;
break;
case 4:
if (!CSoundEngine::isOALExtension("AL_EXT_MCFORMATS"))
{
return false;
}
m_format = alGetEnumValue("AL_FORMAT_QUAD16");
break;
case 6:
if (!CSoundEngine::isOALExtension("AL_EXT_MCFORMATS"))
{
return false;
}
m_format = alGetEnumValue("AL_FORMAT_51CHN16");
break;
case 7:
if (!CSoundEngine::isOALExtension("AL_EXT_MCFORMATS"))
{
return false;
}
m_format = alGetEnumValue("AL_FORMAT_61CHN16");
break;
case 8:
if (!CSoundEngine::isOALExtension("AL_EXT_MCFORMATS"))
{
return false;
}
m_format = alGetEnumValue("AL_FORMAT_71CHN16");
break;
default:
return false;
}
// Création des buffers OpenAL
if (m_buffer[0] == 0 || m_buffer[1] == 0)
{
alGenBuffers(2, m_buffer);
// Traitement des erreurs
if ((error = alGetError()) != AL_NO_ERROR)
{
CSoundEngine::displayOpenALError(error, "alGenBuffers", __LINE__);
return false;
}
// Les buffers sont invalides
if (m_buffer[0] == 0 || m_buffer[1] == 0)
{
CApplication::getApp()->log("Les buffers audio sont invalides", ILogger::Error);
return false;
}
}
// Création d'une source
if (m_source == 0)
{
alGenSources(1, &m_source);
// Traitement des erreurs
if ((error = alGetError()) != AL_NO_ERROR)
{
CSoundEngine::displayOpenALError(error, "alGenSources", __LINE__);
return false;
}
// La source est invalide
if (m_source == 0)
{
CApplication::getApp()->log("La source audio est invalide", ILogger::Error);
return false;
}
}
// On remplit les deux buffers
readData(m_buffer[0], 44100);
readData(m_buffer[1], 44100);
// Remplissage avec les échantillons lus
alSourceQueueBuffers(m_source, 2, m_buffer);
// Traitement des erreurs
if ((error = alGetError()) != AL_NO_ERROR)
{
CSoundEngine::displayOpenALError(error, "alSourceQueueBuffers", __LINE__);
return false;
}
// Paramètres de la source
alSourcei(m_source, AL_LOOPING, false);
// Traitement des erreurs
if ((error = alGetError()) != AL_NO_ERROR)
{
CSoundEngine::displayOpenALError(error, "alGetSourcei", __LINE__);
}
alSourcef(m_source, AL_PITCH, 1.0f);
// Traitement des erreurs
if ((error = alGetError()) != AL_NO_ERROR)
{
CSoundEngine::displayOpenALError(error, "alSourcef", __LINE__);
}
alSourcef(m_source, AL_GAIN, 1.0f);
// Traitement des erreurs
if ((error = alGetError() ) != AL_NO_ERROR)
{
CSoundEngine::displayOpenALError(error, "alSourcef", __LINE__);
}
alSource3f(m_source, AL_POSITION, 0.0f, 0.0f, 0.0f);
// Traitement des erreurs
if ((error = alGetError()) != AL_NO_ERROR)
{
CSoundEngine::displayOpenALError(error, "alSource3f", __LINE__);
}
m_loaded = true;
#endif
return true;
}
int load_avi_file()
{
bitm.valid=false;
const char *avifilename = filename->get().c_str();
HRESULT res = AVIFileOpen(&m_aviFile, avifilename, OF_READ, NULL);
if (res!=AVIERR_OK)
{
printf("Couldn't open avi file %s\n",filename->get().c_str());
return 0;
}
res = AVIFileGetStream(m_aviFile, &streamVid, streamtypeVIDEO, 0);
if (res!=AVIERR_OK)
{
AVIFileRelease(m_aviFile);
m_aviFile = NULL;
streamVid = NULL;
printf("Couldn't get stream");
return 0;
}
LONG format_length = 0;
AVIStreamReadFormat(streamVid,0,NULL,&format_length);
//if format_data is not a reasonable size, fail
if (format_length>128)
{
printf("Format data too big");
return 0;
}
//make room for at least 128 bytes, sizeof(int) aligned
int format_data[(128/sizeof(int)) + 1];
AVIStreamReadFormat(streamVid,0,format_data,&format_length);
BITMAPINFOHEADER *bi = (BITMAPINFOHEADER *)format_data;
//only 24 bit output is supported
if (bi->biBitCount!=24)
{
printf("Bitcount %d not supported",bi->biBitCount);
return 0;
}
// Create the PGETFRAME
getFrame = AVIStreamGetFrameOpen(streamVid,NULL);
//unable to decode the .avi?
if (getFrame==NULL)
{
printf("AVIStreamGetFrameOpen returned NULL");
return 0;
}
// Define the length of the video (necessary for loop reading)
// and its size.
num_frames = AVIStreamLength(streamVid);
if (num_frames<1)
{
printf("Zero frames");
return 0;
}
AVISTREAMINFO psi;
AVIStreamInfo(streamVid, &psi, sizeof(AVISTREAMINFO));
width = psi.rcFrame.right - psi.rcFrame.left;
height = psi.rcFrame.bottom - psi.rcFrame.top;
dwRate = psi.dwRate;
dwScale = psi.dwScale;
bitm.bpp=(int)(bi->biBitCount/8);
bitm.bformat=GL_BGR;
bitm.size_x=width;
bitm.size_y=height;
bitm.valid=true;
return 1;
}
// AVI_stream_open() will open the AVI file and prepare it for reading, but will not
// store any of the frame data.
//
// returns: 0 ==> success
// !0 ==> could not open the AVI stream
//
// The filename is expected to be an absolute pathname (or file in the current working directory)
//
int AVI_stream_open(char* filename)
{
if ( !AVI_stream_inited )
AVI_stream_init();
int hr;
PAVIFILE pfile;
PAVISTREAM pstream;
AVISTREAMINFO avi_stream_info;
Assert( !(AVI_stream.flags & AVI_STREAM_F_USED) );
// Open the AVI file
hr = AVIFileOpen(&pfile, filename, OF_SHARE_DENY_WRITE, 0);
if (hr != 0){
// nprintf(("Warning", "AVI ==> Unable to open %s", filename));
return -1;
}
strcpy(AVI_stream.filename, filename);
// Get a handle to the video stream within the AVI file
hr = AVIFileGetStream(pfile, &pstream, streamtypeVIDEO, 0);
if (hr != 0){
//nprintf(("Warning", "AVI ==> Unable to open video stream in %s", filename));
return -1;
}
// Store the pointer to stream, since we'll need it later to read from disk
AVI_stream.pstream = pstream;
AVI_stream.pfile = pfile;
// Get information on the stream
hr = AVIStreamInfo( pstream, &avi_stream_info, sizeof(AVISTREAMINFO) );
if (hr != 0){
//nprintf(("Warning", "AVI ==> Unable to retreive stream info in %s", filename));
return -1;
}
int buffer_size;
int start_sample = AVIStreamStart(pstream);
Assert( start_sample == 0 );
int end_sample = AVIStreamEnd(pstream);
Assert( end_sample >= start_sample );
// store the number of frames in the AVI_info[] structure
AVI_stream.num_frames = end_sample; // start sample must be 0
Assert(AVI_stream.num_frames == AVIStreamLength(pstream) );
// Get information on the stream
hr = AVIStreamInfo( pstream, &avi_stream_info, sizeof(AVISTREAMINFO) );
if (hr != 0){
//nprintf(("Warning", "AVI ==> Unable to retreive stream info in %s", filename));
return -1;
}
buffer_size = avi_stream_info.dwSuggestedBufferSize;
Assert( buffer_size > 0 );
AVI_stream.min_compressed_buffer_size = buffer_size;
// determine the format of the AVI image data
ubyte* format_buffer;
long format_buffer_size;
BITMAPINFO* bitmap_info;
hr = AVIStreamFormatSize(pstream, 0, &format_buffer_size);
Assert( format_buffer_size > 0 );
format_buffer = (ubyte*) malloc(format_buffer_size);
Assert(format_buffer != NULL); // format_buffer is free'ed when AVI is free'ed, since memory is used by b_info member in AVI_info[] structure
hr = AVIStreamReadFormat(pstream, 0, format_buffer, &format_buffer_size);
bitmap_info = (BITMAPINFO*)format_buffer;
switch ( bitmap_info->bmiHeader.biCompression ) {
case BI_RLE8:
break;
default:
Assert(0);
break;
}
AVI_stream.w = bitmap_info->bmiHeader.biWidth;
AVI_stream.h = bitmap_info->bmiHeader.biHeight;
AVI_stream.bpp = bitmap_info->bmiHeader.biBitCount;
// create the palette translation look-up table
//
// Transparency: If the palette color is full green, then treat as transparent
//
RGBQUAD* pal;
pal = (RGBQUAD*)(bitmap_info->bmiColors);
// Store the palette in the AVI stream structure
for ( int i = 0; i < 256; i++ ) {
AVI_stream.palette[i*3] = pal[i].rgbRed;
AVI_stream.palette[i*3+1] = pal[i].rgbGreen;
AVI_stream.palette[i*3+2] = pal[i].rgbBlue;
}
// memcpy(AVI_stream.palette, pal, 256*3);
/*
int transparent_found = 0;
for ( i = 0; i < 256; i++ ) {
//nprintf(("AVI", "AVI ==> R: %d G: %d B: %d\n", pal[i].rgbRed, pal[i].rgbGreen, pal[i].rgbBlue));
if ( pal[i].rgbRed < 5 && pal[i].rgbGreen > 250 && pal[i].rgbBlue < 5 ) {
avi_stream->pal_translation[i] = TRANSPARENT_INDEX;
break; // found transparent, continue in j for loop, since don't need check any more
}
else
avi_stream->pal_translation[i] = palette_find( pal[i].rgbRed, pal[i].rgbGreen, pal[i].rgbBlue );
}
for ( j = i+1; j < 256; j++ ) {
avi_stream->pal_translation[j] = palette_find( pal[j].rgbRed, pal[j].rgbGreen, pal[j].rgbBlue );
}
*/
free(format_buffer);
// set the flag to used, so to make sure we only process one AVI stream at a time
AVI_stream.flags |= AVI_STREAM_F_USED;
return 0;
}
HRESULT CAviBitmap::Init()
{
HRESULT hr = E_FAIL;
do
{
//Open file
hr = AVIFileOpen(&m_pAviFile, m_szFileName, OF_READ, NULL);
if(hr != S_OK)
{
m_szLastErrorMsg.Format(_T("Unable to Open the Movie File"));
break;
}
//Get video stream
hr = AVIFileGetStream(m_pAviFile, &m_pAviStream, streamtypeVIDEO /*video stream*/, 0 /*first stream*/);
if(hr != S_OK)
{
m_szLastErrorMsg.Format(_T("Unable to Get the video stream"));
break;
}
hr = AVIStreamInfo(m_pAviStream, &m_aviInfo, sizeof(AVISTREAMINFO));
if(hr != S_OK)
{
m_szLastErrorMsg.Format(_T("Unable to Get the video stream info"));
break;
}
CString szFourCC;
FourCC2Str(m_aviInfo.fccHandler, szFourCC);
AfxTrace(_T("fccHandler=%s, 0x%08X\n"), szFourCC, m_aviInfo.fccHandler);
ZeroMemory(&m_biWanted, sizeof(m_biWanted));
LONG lFormat = sizeof(m_biWanted);
hr = AVIStreamReadFormat(m_pAviStream, 0, &m_biWanted, &lFormat);
if(hr != S_OK)
{
m_szLastErrorMsg.Format(_T("Unable to Get the foramt of the 1st frame"));
break;
}
m_biWanted.biCompression = BI_RGB;
m_biWanted.biBitCount = 32;
m_biWanted.biSizeImage = m_biWanted.biWidth * 4 * m_biWanted.biHeight;
//Set the result to Fail
hr = E_FAIL;
//Get the GETFRAME handle
m_pGetFrame = AVIStreamGetFrameOpen(m_pAviStream, &m_biWanted);
if(m_pGetFrame == NULL)
{
m_szLastErrorMsg.Format(_T("Unable to Get the GETFRAME handle"));
break;
}
//Get the 1st sample
m_lFirstSample = AVIStreamStart(m_pAviStream);
if(m_lFirstSample == -1)
{
m_szLastErrorMsg.Format(_T("Unable to Get the first sample"));
break;
}
//Get the total sample count
m_lSampleCount = AVIStreamLength(m_pAviStream);
if(m_lSampleCount == -1)
{
m_szLastErrorMsg.Format(_T("Unable to Get the sample count"));
break;
}
//Done
hr = S_OK;
} while (FALSE);
if(hr != S_OK)
{
ReleaseMemory();
}
return hr;
}
bool VideoComponent::openAvi(const std::string& filename)
{
// Stop any currently loaded avi
closeAvi();
AVIFileInit(); // Opens The AVIFile Library
// Opens The AVI Stream
if (AVIStreamOpenFromFile(&m_pavi, filename.c_str(), streamtypeVIDEO, 0, OF_READ, NULL) !=0)
{
GameLog::errorMessage("Error opening avi: %s", filename.c_str());
// An Error Occurred Opening The Stream
AVIFileExit(); // Release The File
return false;
}
AVIStreamInfo(m_pavi, &m_psi, sizeof(m_psi)); // Reads Information About The Stream Into psi
m_width = m_psi.rcFrame.right-m_psi.rcFrame.left; // Width Is Right Side Of Frame Minus Left
m_height = m_psi.rcFrame.bottom-m_psi.rcFrame.top; // Height Is Bottom Of Frame Minus Top
if (!m_resize)
{
// Size should be kept
m_resizeWidth = m_width;
m_resizeHeight = m_height;
}
m_lastframe = AVIStreamLength(m_pavi); // The Last Frame Of The Stream
m_timePerFrame = ((float)AVIStreamSampleToTime(m_pavi, m_lastframe) / (float) m_lastframe) / 1000.0f; // Calculate Rough Seconds Per Frame
m_bmih.biSize = sizeof (BITMAPINFOHEADER); // Size Of The BitmapInfoHeader
m_bmih.biPlanes = 1; // Bitplanes
m_bmih.biBitCount = 24; // Bits Format We Want 24 / 8 = 3 bytes
m_bmih.biWidth = m_resizeWidth; // Width We Want
m_bmih.biHeight = m_resizeHeight; // Height We Want
m_bmih.biCompression= BI_RGB; // Requested Mode = RGB
m_hBitmap = CreateDIBSection (m_hdc, (BITMAPINFO*)(&m_bmih), DIB_RGB_COLORS, (void**)(&m_data), NULL, NULL);
SelectObject (m_hdc, m_hBitmap); // Select hBitmap Into Our Device Context (hdc)
// Bitmapinfo header for decoding (needed for xvid)
m_bmiavih.biSize = sizeof(BITMAPINFOHEADER);
m_bmiavih.biPlanes = 1; // Bitplanes
m_bmiavih.biBitCount = 24; // Bits Format We Want 24 / 8 = 3 bytes
m_bmiavih.biWidth = m_width; // Width We Want
m_bmiavih.biHeight = m_height; // Height We Want
m_bmiavih.biCompression = BI_RGB; // Requested Mode = RGB
// And some more infos
m_bmiavih.biClrImportant = 0;
m_bmiavih.biClrUsed = 0;
m_bmiavih.biXPelsPerMeter = 0;
m_bmiavih.biYPelsPerMeter = 0;
m_bmiavih.biSizeImage = (((m_bmiavih.biWidth * 3) + 3) & 0xFFFC) * m_bmiavih.biHeight;
m_pgf=AVIStreamGetFrameOpen(m_pavi, &m_bmiavih);// Create The PGETFRAME Using Our Request Mode
if (m_pgf==0x0)
{
GameLog::errorMessage("Error opening first frame of avi: %s", filename.c_str());
// An Error Occurred Opening The Frame
DeleteObject(m_hBitmap); // Delete The Device Dependant Bitmap Object
AVIStreamRelease(m_pavi); // Release The Stream
AVIFileExit(); // Release The File
return false;
}
m_fileName = filename;
// Create buffer for converted data
// width*height = count pixel; each pixel has 4 channels for rgba with each one byte
int dataSize = 4*m_resizeWidth*m_resizeHeight;
m_bgraData = new unsigned char[dataSize];
// Initialize with 255 (black screen with full alpha)
memset(m_bgraData, 255, dataSize);
// Prepare horde texture stream named like the video file name, to get a unique name
m_videoTexture = h3dCreateTexture(filename.c_str(), m_resizeWidth, m_resizeHeight, H3DFormats::TEX_BGRA8, H3DResFlags::NoTexMipmaps);
if (m_videoTexture == 0)
{
GameLog::errorMessage("Error creating texture for playing avi: %s", filename.c_str());
// Failure creating the dynamic texture
closeAvi();
return false;
}
// Find the sampler index within the material
m_samplerIndex = h3dFindResElem(m_material, H3DMatRes::SamplerElem, H3DMatRes::SampNameStr, "albedoMap");
if (m_samplerIndex == -1)
{
GameLog::errorMessage("Error preparing material with resID %d for playing avi: %s", m_material, filename.c_str());
// No sampler found in material
closeAvi();
return false;
}
// Store old sampler
m_originalSampler = h3dGetResParamI(m_material, H3DMatRes::SamplerElem, m_samplerIndex, H3DMatRes::SampTexResI);
// Now open the audio stream
PAVISTREAM audioStream;
if (AVIStreamOpenFromFile(&audioStream, filename.c_str(), streamtypeAUDIO, 0, OF_READ, NULL) == 0)
{
// Audio stream found
// Get format info
PCMWAVEFORMAT audioFormat;
long formatSize = sizeof(audioFormat);
int start = AVIStreamStart(audioStream);
// TODO get channelsmask and use it
AVIStreamReadFormat(audioStream, start, &audioFormat, &formatSize);
long numSamples = AVIStreamLength(audioStream);
int bitsPerSample = (audioFormat.wf.nAvgBytesPerSec * 8) / (audioFormat.wf.nSamplesPerSec * audioFormat.wf.nChannels);
/*if (audioFormat.wf.wFormatTag == WAVE_FORMAT_MPEGLAYER3)
{
// TODO
MPEGLAYER3WAVEFORMAT mp3Format;
formatSize = sizeof(mp3Format);
AVIStreamReadFormat(audioStream, start, &mp3Format, &formatSize);
}*/
// Create buffer with appropriate size
long bufferSize = (bitsPerSample * numSamples) / 8;
char* buffer = new char[bufferSize];
// Read the audio data
long bytesWritten = 0;
AVIStreamRead(audioStream, start, numSamples, buffer, bufferSize, &bytesWritten, 0x0);
if (bytesWritten > 0)
{
// Send the audio data to the sound component
SoundResourceData eventData(buffer, bytesWritten, audioFormat.wf.nSamplesPerSec, bitsPerSample, audioFormat.wf.nChannels);
GameEvent event(GameEvent::E_SET_SOUND_WITH_USER_DATA, &eventData, this);
m_owner->executeEvent(&event);
m_hasAudio = true;
}
// Delete the buffer data
delete[] buffer;
}
if (m_autoStart)
// Play video directly
playAvi();
return true;
}
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();
}
bool CLoaderAVI::loadFromFile(const CString& fileName)
{
CApplication::getApp()->log(CString::fromUTF8("Chargement de la vidéo %1").arg(fileName));
#ifdef T_SYSTEM_WINDOWS
AVIStreamGetFrameClose(m_pgf);
// Suppression des flux
if (m_video)
AVIStreamRelease(m_video);
if (m_audio)
{
//AVIStreamRelease(m_audio);
Game::soundEngine->removeMusic(m_audio);
delete m_audio;
m_audio = nullptr;
}
Game::textureManager->deleteTexture(m_texture);
AVIFileExit();
#endif
m_time = 0;
m_play = false;
// Suppression de la précédente texture
if (m_texture)
{
Game::textureManager->deleteTexture(m_texture);
}
#ifdef T_SYSTEM_WINDOWS
AVIFileInit();
// Ouverture du flux vidéo
if (AVIStreamOpenFromFile(&m_video, fileName.toCharArray(), streamtypeVIDEO, 0, OF_READ, nullptr))
{
CApplication::getApp()->log(CString::fromUTF8("AVIStreamOpenFromFile : impossible de lire le flux video."), ILogger::Error);
return false;
}
// Infos sur le stream video
AVISTREAMINFO psi;
if (AVIStreamInfo(m_video, &psi, sizeof(psi)))
{
CApplication::getApp()->log("AVIStreamInfo donne une erreur", ILogger::Error);
return false;
}
// Dimensions de la vidéo
m_width = psi.rcFrame.right - psi.rcFrame.left;
m_height = psi.rcFrame.bottom - psi.rcFrame.top;
m_fileName = fileName;
m_pixels.resize(4 * m_width * m_height);
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;
}
// Création de la texture
CImage img(m_width, m_height, reinterpret_cast<CColor *>(&m_pixels[0]));
m_texture = Game::textureManager->loadTexture(m_fileName, img, CTextureManager::FilterNone);
m_lastFrame = AVIStreamLength(m_video);
if (m_lastFrame == 0)
{
return false;
}
m_frameTime = AVIStreamSampleToTime(m_video, m_lastFrame) / m_lastFrame;
m_pgf = AVIStreamGetFrameOpen(m_video, nullptr);
// On ne peut pas récupérer les frames
if (m_pgf == nullptr)
{
CApplication::getApp()->log("AVIStreamGetFrameOpen retourne un pointeur nul", ILogger::Error);
return false;
}
// Ouverture du flux audio
m_audio = new CMusic();
m_audio->loadFromVideo(m_fileName);
if (m_loop)
{
m_audio->setLoop();
}
m_audio->play();
Game::soundEngine->addMusic(m_audio);
#endif
//m_play = true;
return true;
}
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;
}
bool Movie::reload(const io::stringc &Filename, const s32 Resolution)
{
if (DataPointer_)
close();
/* Information message */
io::Log::message("Load movie: \"" + Filename + "\"");
io::Log::upperTab();
/* General settings */
SMovieSequencePacket* MovieData = new SMovieSequencePacket;
DataPointer_ = MovieData;
MovieData->Next = MovieData->Frame = 0;
MovieData->State = MOVIESTATE_STOPED;
MovieData->Time = MovieData->LastTime = 0;
MovieData->RawData = 0;
MovieData->Resolution = Resolution;
MovieData->hDeviceContext = CreateCompatibleDC(0);
MovieData->hDrawDIB = DrawDibOpen();
AVIFileInit();
/* Open video stream */
if (AVIStreamOpenFromFile(&MovieData->pVideoStream, Filename.c_str(), streamtypeVIDEO, 0, OF_READ, 0) != 0)
return exitWithError("Could not open video stream");
if (AVIStreamInfo(MovieData->pVideoStream, &MovieData->VideoStreamInfo, sizeof(MovieData->VideoStreamInfo)) != 0)
return exitWithError("Video stream information process failed");
MovieData->VideoLastFrame = AVIStreamLength(MovieData->pVideoStream);
if (MovieData->VideoLastFrame == -1)
return exitWithError("Video stream length is invalid");
MovieData->VideoMPF = AVIStreamSampleToTime(MovieData->pVideoStream, MovieData->VideoLastFrame) / MovieData->VideoLastFrame;
if (MovieData->VideoMPF == -1)
return exitWithError("Video stream sample is invalid");
#if 0
/* Open audio stream */
if (AVIStreamOpenFromFile(&MovieData->pAudioStream, Filename.c_str(), streamtypeAUDIO, 0, OF_READ, 0))
return exitWithError("Could not open audio stream");
if (AVIStreamInfo(MovieData->pAudioStream, &MovieData->AudioStreamInfo, sizeof(MovieData->AudioStreamInfo)))
return exitWithError("Audio stream information process failed");
MovieData->AudioLastFrame = AVIStreamLength(MovieData->pAudioStream);
if (MovieData->AudioLastFrame == -1)
return exitWithError("Audio stream length is invalid");
MovieData->AudioMPF = AVIStreamSampleToTime(MovieData->pAudioStream, MovieData->AudioLastFrame) / MovieData->AudioLastFrame;
if (MovieData->AudioMPF == -1)
return exitWithError("Audio stream sample is invalid");
#endif
/* Start configuration process */
MovieData->Size.Width = MovieData->VideoStreamInfo.rcFrame.right - MovieData->VideoStreamInfo.rcFrame.left;
MovieData->Size.Height = MovieData->VideoStreamInfo.rcFrame.bottom - MovieData->VideoStreamInfo.rcFrame.top;
MovieData->BitmapInfoHeader.biSize = sizeof(BITMAPINFOHEADER);
MovieData->BitmapInfoHeader.biPlanes = 1;
MovieData->BitmapInfoHeader.biBitCount = 24;
MovieData->BitmapInfoHeader.biWidth = MovieData->Resolution;
MovieData->BitmapInfoHeader.biHeight = MovieData->Resolution;
MovieData->BitmapInfoHeader.biCompression = BI_RGB;
/* Create the movie bitmap context */
MovieData->hBitmap = CreateDIBSection(
MovieData->hDeviceContext,
(BITMAPINFO*)(&MovieData->BitmapInfoHeader),
DIB_RGB_COLORS,
(void**)(&MovieData->RawData),
0, 0
);
if (!MovieData->hBitmap)
return exitWithError("Could not create device independent bitmap (DIB) for video stream");
SelectObject(MovieData->hDeviceContext, MovieData->hBitmap);
MovieData->BitmapInfoHeader.biWidth = MovieData->Size.Width;
MovieData->BitmapInfoHeader.biHeight = MovieData->Size.Height;
MovieData->BitmapInfoHeader.biSizeImage = 0;
MovieData->BitmapInfoHeader.biClrUsed = 0;
MovieData->BitmapInfoHeader.biClrImportant = 0;
/* Get first video frame */
MovieData->pGetFrame = AVIStreamGetFrameOpen(MovieData->pVideoStream, &MovieData->BitmapInfoHeader);
if (!MovieData->pGetFrame)
return exitWithError("Could not open first video stream");
io::Log::lowerTab();
return true;
}
