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);
}
PAVIFILE AVIFILE_CreateAVITempFile(int nStreams, const PAVISTREAM *ppStreams)
{
ITmpFileImpl *tmpFile;
int i;
tmpFile = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ITmpFileImpl));
if (tmpFile == NULL)
return NULL;
tmpFile->IAVIFile_iface.lpVtbl = &itmpft;
tmpFile->ref = 1;
memset(&tmpFile->fInfo, 0, sizeof(tmpFile->fInfo));
tmpFile->fInfo.dwStreams = nStreams;
tmpFile->ppStreams = HeapAlloc(GetProcessHeap(), 0, nStreams * sizeof(PAVISTREAM));
if (tmpFile->ppStreams == NULL) {
HeapFree(GetProcessHeap(), 0, tmpFile);
return NULL;
}
for (i = 0; i < nStreams; i++) {
AVISTREAMINFOW sInfo;
tmpFile->ppStreams[i] = ppStreams[i];
AVIStreamAddRef(ppStreams[i]);
AVIStreamInfoW(ppStreams[i], &sInfo, sizeof(sInfo));
if (i == 0) {
tmpFile->fInfo.dwScale = sInfo.dwScale;
tmpFile->fInfo.dwRate = sInfo.dwRate;
if (!sInfo.dwScale || !sInfo.dwRate) {
tmpFile->fInfo.dwScale = 1;
tmpFile->fInfo.dwRate = 100;
}
}
if (tmpFile->fInfo.dwSuggestedBufferSize < sInfo.dwSuggestedBufferSize)
tmpFile->fInfo.dwSuggestedBufferSize = sInfo.dwSuggestedBufferSize;
{
DWORD tmp;
tmp = MulDiv(AVIStreamSampleToTime(ppStreams[i], sInfo.dwLength),
tmpFile->fInfo.dwScale, tmpFile->fInfo.dwRate * 1000);
if (tmpFile->fInfo.dwLength < tmp)
tmpFile->fInfo.dwLength = tmp;
tmp = sInfo.rcFrame.right - sInfo.rcFrame.left;
if (tmpFile->fInfo.dwWidth < tmp)
tmpFile->fInfo.dwWidth = tmp;
tmp = sInfo.rcFrame.bottom - sInfo.rcFrame.top;
if (tmpFile->fInfo.dwHeight < tmp)
tmpFile->fInfo.dwHeight = tmp;
}
}
return &tmpFile->IAVIFile_iface;
}
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;
}
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 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;
}
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;
}
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;
}
// Return the time in milliseconds corresponding to the currently playing audio sample, or -1 if no audio is playing.
LONG CALLBACK aviaudioTime(void)
{
MMTIME mmtime;
if (audioPlayable <= 0)
return -1;
if (!sfPlaying)
return -1;
//not sure
if (recalc) {
streamEnd = AVIStreamEnd(spavi);
streamStart = AVIStreamStart(spavi);
recalc = 0;
//ErrMsg("recalc");
}
if ((streamEnd<=streamStart) || (streamEnd<=0))
return -1;
mmtime.wType = TIME_SAMPLES;
waveOutGetPosition(shWaveOut, &mmtime, sizeof(mmtime));
if (mmtime.wType == TIME_SAMPLES)
return AVIStreamSampleToTime(spavi, slBegin) + muldiv32(mmtime.u.sample, 1000, sdwSamplesPerSec);
else if (mmtime.wType == TIME_BYTES)
return AVIStreamSampleToTime(spavi, slBegin) + muldiv32(mmtime.u.cb, 1000, sdwBytesPerSec);
else
return -1;
}
