//! Implement VideoInput::GrabNext()
bool ImagesVideo::GrabNext( unsigned char* image, bool /*wait*/ )
{
if(next_frame_id < loaded.size()) {
Frame& frame = loaded[next_frame_id];
if(frame.size() != num_channels) {
LoadFrame(next_frame_id);
}
for(size_t c=0; c < num_channels; ++c){
TypedImage& img = frame[c];
if(!img.ptr || img.w != streams[c].Width() || img.h != streams[c].Height() ) {
return false;
}
const StreamInfo& si = streams[c];
std::memcpy(image + (size_t)si.Offset(), img.ptr, si.SizeBytes());
img.Dealloc();
}
frame.clear();
next_frame_id++;
return true;
}
return false;
}
BOOL CMainWindow::Create() {
newWindowX = newWindowY = 0;
BOOL retval = LoadFrame( IDR_MAINWINDOW );
userListWnd = NULL;
if ( retval ) {
retval = toolbar.Create( this, WS_CHILD | WS_VISIBLE | CBRS_TOP | CBRS_FLYBY | CBRS_TOOLTIPS );
}
if ( retval ) {
retval = toolbar.LoadToolBar( IDR_MAINWINDOW );
}
if ( retval ) {
status.Create( this );
UINT indicator = ID_SEPARATOR;
status.SetIndicators( &indicator, 1 );
}
if ( retval ) {
chooser = new CStudentChooserWnd();
retval = chooser->Create( this );
}
chooser->ShowWindow( preferences.GetInt( "ChooserWindowState" ) );
if ( !preferences.GetBool( "ShowStudentChooser" ) ) {
chooser->ShowWindow( SW_HIDE );
}
return retval;
}
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CD3DFile::CreateFromResource( LPDIRECT3DDEVICE9 pd3dDevice, TCHAR* strResource, TCHAR* strType )
{
LPDIRECTXFILE pDXFile = NULL;
LPDIRECTXFILEENUMOBJECT pEnumObj = NULL;
LPDIRECTXFILEDATA pFileData = NULL;
HRESULT hr;
// Create a x file object
if( FAILED( hr = DirectXFileCreate( &pDXFile ) ) )
return E_FAIL;
// Register templates for d3drm and patch extensions.
if( FAILED( hr = pDXFile->RegisterTemplates( (void*)D3DRM_XTEMPLATES,
D3DRM_XTEMPLATE_BYTES ) ) )
{
pDXFile->Release();
return E_FAIL;
}
CHAR strTypeAnsi[MAX_PATH];
DXUtil_ConvertGenericStringToAnsiCb( strTypeAnsi, strType, sizeof(strTypeAnsi) );
DXFILELOADRESOURCE dxlr;
dxlr.hModule = NULL;
dxlr.lpName = strResource;
dxlr.lpType = (TCHAR*) strTypeAnsi;
// Create enum object
hr = pDXFile->CreateEnumObject( (void*)&dxlr, DXFILELOAD_FROMRESOURCE,
&pEnumObj );
if( FAILED(hr) )
{
pDXFile->Release();
return hr;
}
// Enumerate top level objects (which are always frames)
while( SUCCEEDED( pEnumObj->GetNextDataObject( &pFileData ) ) )
{
hr = LoadFrame( pd3dDevice, pFileData, this );
pFileData->Release();
if( FAILED(hr) )
{
pEnumObj->Release();
pDXFile->Release();
return E_FAIL;
}
}
SAFE_RELEASE( pFileData );
SAFE_RELEASE( pEnumObj );
SAFE_RELEASE( pDXFile );
return S_OK;
}
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CD3DFile::Create( LPDIRECT3DDEVICE9 pd3dDevice, TCHAR* strFilename )
{
LPDIRECTXFILE pDXFile = NULL;
LPDIRECTXFILEENUMOBJECT pEnumObj = NULL;
LPDIRECTXFILEDATA pFileData = NULL;
HRESULT hr;
// Create a x file object
if( FAILED( hr = DirectXFileCreate( &pDXFile ) ) )
return E_FAIL;
// Register templates for d3drm and patch extensions.
if( FAILED( hr = pDXFile->RegisterTemplates( (void*)D3DRM_XTEMPLATES,
D3DRM_XTEMPLATE_BYTES ) ) )
{
pDXFile->Release();
return E_FAIL;
}
// Find the path to the file, and convert it to ANSI (for the D3DXOF API)
TCHAR strPath[MAX_PATH];
CHAR strPathANSI[MAX_PATH];
DXUtil_FindMediaFileCb( strPath, sizeof(strPath), strFilename );
DXUtil_ConvertGenericStringToAnsiCb( strPathANSI, strPath, sizeof(strPathANSI) );
// Create enum object
hr = pDXFile->CreateEnumObject( (void*)strPathANSI, DXFILELOAD_FROMFILE,
&pEnumObj );
if( FAILED(hr) )
{
pDXFile->Release();
return hr;
}
// Enumerate top level objects (which are always frames)
while( SUCCEEDED( pEnumObj->GetNextDataObject( &pFileData ) ) )
{
hr = LoadFrame( pd3dDevice, pFileData, this );
pFileData->Release();
if( FAILED(hr) )
{
pEnumObj->Release();
pDXFile->Release();
return E_FAIL;
}
}
SAFE_RELEASE( pFileData );
SAFE_RELEASE( pEnumObj );
SAFE_RELEASE( pDXFile );
return S_OK;
}
int main(void)
{
BYTE nI;
LED_Init();
USART1_Config(); //串口初始化
WT_GPIO_Config(); //控制WT1000的IO引脚初始化
AMBEReset(); //复位WT1K和WT1027
SOCK(0);
SOSTRB(1);
PD2(0); //串行模式下PD2必须下拉或者接地
pFrameData[0] = 0x13;
pFrameData[1] = 0xec;
for(nI = 2; nI < 34; nI++)
{
pFrameData[nI] = 0; //初始化pFrameData数组
}
while(!EPR);
AMBEReadSerial();
while(1)
{
LED0=~LED0;
while(!EPR); //读EPR信号
AMBEReadSerial(); //串行读WT1K编码数据
LoadreadBUF(); //将独到的语音编码数据放到发送缓冲区pTXBUF中
UART1SendData(pTXBUF,VOICELENGTH+2); //串口发送
while(!DPE); //读DPE信号
if(bReceived ==1) //串口中断接收到一包完整的数据bReceived=1;收到的数据放在接收缓冲区pRXBUF
{
noReceived=0;
LoadFrame(); //将接收缓冲区pRXBUF的语音数据移到pFrameData中
AMBEWriteSerial(); //串行写WT1K
bReceived = 0;
}
else
{
noReceived++;
if(noReceived==4) //连续4包没收到完整数据向WT1K写静音数据
{
noReceived=3;
LoadNoVoice();
AMBEWriteSerial();
}
}
}
}
int playVideo(char *directory, int x, int y, int w, int h, int numFrames)
{
char temp[80];
Sprite *tempSprite;
static int i = 1;
sprintf(temp, "%s/%04d.png",directory, i);
tempSprite=LoadFrame( temp, w, h);
DrawFrame(tempSprite, x, y, 0, 2.0f );
FreeSprite(tempSprite);
if(i >= numFrames)return 1;
i++;
return 0;
}
ImagesVideo::ImagesVideo(const std::string& wildcard_path)
: num_files(-1), num_channels(0), next_frame_id(0),
unknowns_are_raw(false)
{
// Work out which files to sequence
PopulateFilenames(wildcard_path);
// Load first image in order to determine stream sizes etc
LoadFrame(next_frame_id);
ConfigureStreamSizes();
// TODO: Queue frames in another thread.
}
ImagesVideo::ImagesVideo(const std::string& wildcard_path,
const VideoPixelFormat& raw_fmt,
size_t raw_width, size_t raw_height
) : num_files(-1), num_channels(0), next_frame_id(0),
unknowns_are_raw(true), raw_fmt(raw_fmt),
raw_width(raw_width), raw_height(raw_height)
{
// Work out which files to sequence
PopulateFilenames(wildcard_path);
// Load first image in order to determine stream sizes etc
LoadFrame(next_frame_id);
ConfigureStreamSizes();
// TODO: Queue frames in another thread.
}
//@override
bool CAdvancedAnnotator::GoToSpecificFrame( int nSpecFrame )
{
if(m_nCurrFrame != nSpecFrame)
{
SyncXmlFrameInfo();
m_pXMLDoc->SaveFile((m_strPathAbsolute+m_strXMLFileName).c_str());
}
if(nSpecFrame < 0 || nSpecFrame >= m_nTotalFrame)
{
char szErr[100];
sprintf_s(szErr, "frame is out-of-range : it should be 0~%d..\n",m_nTotalFrame-1);
LOG_OUT(szErr);
return false;
}
LoadFrame(nSpecFrame);
return true;
}
//-----------------------------------------------------------------------------
HRESULT CDXUTMeshFile::LoadFrame( LPDIRECT3DDEVICE9 pd3dDevice,
LPD3DXFILEDATA pFileData,
CDXUTMeshFrame* pParentFrame )
{
LPD3DXFILEDATA pChildData = NULL;
GUID Guid;
SIZE_T cbSize;
CDXUTMeshFrame* pCurrentFrame;
HRESULT hr;
// Get the type of the object
if( FAILED( hr = pFileData->GetType( &Guid ) ) )
return hr;
if( Guid == TID_D3DRMMesh )
{
hr = LoadMesh( pd3dDevice, pFileData, pParentFrame );
if( FAILED(hr) )
return hr;
}
if( Guid == TID_D3DRMFrameTransformMatrix )
{
D3DXMATRIX* pmatMatrix;
hr = pFileData->Lock(&cbSize, (LPCVOID*)&pmatMatrix );
if( FAILED(hr) )
return hr;
// Update the parent's matrix with the new one
pParentFrame->SetMatrix( pmatMatrix );
}
if( Guid == TID_D3DRMFrame )
{
// Get the frame name
CHAR strAnsiName[512] = "";
WCHAR strName[512];
SIZE_T dwNameLength = 512;
SIZE_T cChildren;
if( FAILED( hr = pFileData->GetName( strAnsiName, &dwNameLength ) ) )
return hr;
WideCharToMultiByte( CP_ACP, 0, strName, -1, strAnsiName, 512, NULL, NULL );
strName[511] = 0;
// Create the frame
pCurrentFrame = new CDXUTMeshFrame( strName );
if( pCurrentFrame == NULL )
return E_OUTOFMEMORY;
pCurrentFrame->m_pNext = pParentFrame->m_pChild;
pParentFrame->m_pChild = pCurrentFrame;
// Enumerate child objects
pFileData->GetChildren(&cChildren);
for (UINT iChild = 0; iChild < cChildren; iChild++)
{
// Query the child for its FileData
hr = pFileData->GetChild(iChild, &pChildData );
if( SUCCEEDED(hr) )
{
hr = LoadFrame( pd3dDevice, pChildData, pCurrentFrame );
SAFE_RELEASE( pChildData );
}
if( FAILED(hr) )
return hr;
}
}
return S_OK;
}
bool XFileUtils::LoadFrameHierarchy(
ID3DXFileEnumObject* pFileData,
IDirect3DDevice9* pDevice,
GFrameContainer** pNewFrameContainer)
{
GFrameContainer* pFrameContainer = new GFrameContainer();
SIZE_T numChild = 0;
pFileData->GetChildren(&numChild);
struct FrameFD {
GFrame* pFrame;
ID3DXFileData* pFileData;
};
//读取用栈
std::vector<FrameFD> FrameStack;
//框架GUID
const GUID& frameGuid = _XTemplate("Frame");
//创建根框架
GFrame* pRootFrame = new GFrame();
pRootFrame->Name = GROOTFRAME;
pFrameContainer->m_pRootFrames = pRootFrame;
pFrameContainer->InsertFrame(pRootFrame);
//得到第一层 框架
//*********************************
{
GFrame* pPreSiblingFrame = nullptr;
for (size_t i = 0; i < numChild; ++i)
{
ID3DXFileData* pTopFileData = nullptr;
GFrame* pTopChild = nullptr;
pFileData->GetChild(i, &pTopFileData);
GUID cguid;
pTopFileData->GetType(&cguid);
if (cguid == frameGuid)
{
if (!LoadFrame(pTopFileData, pDevice, &pTopChild))
return false;
if (pRootFrame->pFrameFirstChild == nullptr)
{
pRootFrame->pFrameFirstChild = pTopChild;
pFrameContainer->InsertFrame(pTopChild);
pPreSiblingFrame = pTopChild;
}
else {
pPreSiblingFrame->pFrameSibling = pTopChild;
pPreSiblingFrame = pTopChild;
}
FrameFD fd;
fd.pFileData = pTopFileData;
fd.pFrame = pTopChild;
FrameStack.push_back(fd);
}
}
}
//*********************************
//得到第一层 框架
while (!FrameStack.empty())
{
//上一个兄弟节点
GFrame* pPreSiblingFrame = nullptr;
//栈弹出
FrameFD fd = FrameStack.back();
FrameStack.pop_back();
GFrame* pParentFrame = fd.pFrame;
ID3DXFileData* pParentFileData = fd.pFileData;
//得到孩子个数
SIZE_T numChild = 0;
pParentFileData->GetChildren(&numChild);
//开始解析该节点的孩子
for (size_t i = 0; i < numChild; ++i)
{
//读取孩子
ID3DXFileData* pChildFileData = nullptr;
pParentFileData->GetChild(i, &pChildFileData);
GFrame* pChildFrame = nullptr;
//解析该 孩子框架,失败进入条件返回 false
GUID cguid;
pChildFileData->GetType(&cguid);
if (cguid != frameGuid)
continue;
if (!LoadFrame(pChildFileData, pDevice, &pChildFrame))
{
char DebugText[512] = { 0 };
sprintf_s(DebugText, "LoadFrame Error: %s \n", pParentFrame->Name.c_str());
OutputDebugStringA(DebugText);
continue;
}
if (pPreSiblingFrame == nullptr)
{
//如果是第一个孩子节点，则将pFirstChild指向该节点，
//并将preSiblingFrame指针指向它, 并压入解析用栈
pParentFrame->pFrameFirstChild = pChildFrame;
pPreSiblingFrame = pChildFrame;
}
else {
//上一个兄弟节点指针连接, preSiblingFrame指针往下移
pPreSiblingFrame->pFrameSibling = pChildFrame;
pPreSiblingFrame = pChildFrame;
}
FrameFD tmp_fd;
tmp_fd.pFrame = pChildFrame;
tmp_fd.pFileData = pChildFileData;
FrameStack.push_back(tmp_fd);
pFrameContainer->InsertFrame(pChildFrame);
}
}
*pNewFrameContainer = pFrameContainer;
return true;
}
CMainWnd::CMainWnd()
{
theApp.m_pMainWnd = this;
LoadFrame( IDR_MAINFRAME, WS_OVERLAPPEDWINDOW );
}
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CD3DFile::LoadFrame( LPDIRECT3DDEVICE9 pd3dDevice,
LPDIRECTXFILEDATA pFileData,
CD3DFrame* pParentFrame )
{
LPDIRECTXFILEDATA pChildData = NULL;
LPDIRECTXFILEOBJECT pChildObj = NULL;
const GUID* pGUID;
DWORD cbSize;
CD3DFrame* pCurrentFrame;
HRESULT hr;
// Get the type of the object
if( FAILED( hr = pFileData->GetType( &pGUID ) ) )
return hr;
if( *pGUID == TID_D3DRMMesh )
{
hr = LoadMesh( pd3dDevice, pFileData, pParentFrame );
if( FAILED(hr) )
return hr;
}
if( *pGUID == TID_D3DRMFrameTransformMatrix )
{
D3DXMATRIX* pmatMatrix;
hr = pFileData->GetData( NULL, &cbSize, (void**)&pmatMatrix );
if( FAILED(hr) )
return hr;
// Update the parent's matrix with the new one
pParentFrame->SetMatrix( pmatMatrix );
}
if( *pGUID == TID_D3DRMFrame )
{
// Get the frame name
CHAR strAnsiName[512] = "";
TCHAR strName[512];
DWORD dwNameLength = 512;
if( FAILED( hr = pFileData->GetName( strAnsiName, &dwNameLength ) ) )
return hr;
DXUtil_ConvertAnsiStringToGenericCb( strName, strAnsiName, sizeof(strName) );
// Create the frame
pCurrentFrame = new CD3DFrame( strName );
if( pCurrentFrame == NULL )
return E_OUTOFMEMORY;
pCurrentFrame->m_pNext = pParentFrame->m_pChild;
pParentFrame->m_pChild = pCurrentFrame;
// Enumerate child objects
while( SUCCEEDED( pFileData->GetNextObject( &pChildObj ) ) )
{
// Query the child for its FileData
hr = pChildObj->QueryInterface( IID_IDirectXFileData,
(void**)&pChildData );
if( SUCCEEDED(hr) )
{
hr = LoadFrame( pd3dDevice, pChildData, pCurrentFrame );
pChildData->Release();
}
pChildObj->Release();
if( FAILED(hr) )
return hr;
}
}
return S_OK;
}
bool SIFSpritesSect::Decode(const uint8_t *data, int datalen, \
SIFSprite *sprites, int *nsprites_out, int maxsprites)
{
const uint8_t *data_end = data + (datalen - 1);
int i, f, nsprites;
nsprites = read_U16(&data, data_end);
if (nsprites_out) *nsprites_out = nsprites;
if (nsprites >= maxsprites)
{
NX_ERR("SIFSpritesSect::Decode: too many sprites in file (nsprites=%d, maxsprites=%d)\n", nsprites, maxsprites);
return 1;
}
NX_LOG("SIFSpritesSect: loading %d sprites\n", nsprites);
for(i=0;i<nsprites;i++)
{
if (data > data_end)
{
NX_ERR("SIFSpritesSect::Decode: section corrupt: overran end of data\n");
return 1;
}
// read sprite-level fields
sprites[i].w = read_U8(&data, data_end);
sprites[i].h = read_U8(&data, data_end);
sprites[i].spritesheet = read_U8(&data, data_end);
sprites[i].nframes = read_U8(&data, data_end);
sprites[i].ndirs = read_U8(&data, data_end);
if (sprites[i].ndirs > SIF_MAX_DIRS)
{
NX_ERR("SIFSpritesSect::Decode: SIF_MAX_DIRS exceeded on sprite %d (ndirs=%d)\n", i, sprites[i].ndirs);
return 1;
}
LoadRect(&sprites[i].bbox, &data, data_end);
LoadRect(&sprites[i].solidbox, &data, data_end);
LoadPoint(&sprites[i].spawn_point, &data, data_end);
LoadPointList(&sprites[i].block_l, &data, data_end);
LoadPointList(&sprites[i].block_r, &data, data_end);
LoadPointList(&sprites[i].block_u, &data, data_end);
LoadPointList(&sprites[i].block_d, &data, data_end);
// malloc enough space to hold the specified number
// of apple fritters, i mean, frames.
sprites[i].frame = (SIFFrame *)malloc(sizeof(SIFFrame) * sprites[i].nframes);
// then load all frames
for(f=0;f<sprites[i].nframes;f++)
{
if (LoadFrame(&sprites[i].frame[f], sprites[i].ndirs, &data, data_end))
return 1;
}
}
return 0;
}
void sndTest()
{
char buf[80];
// int i, vol, numchans;
int selectedTrack = 0;
//MusicPlayerTrack * t;
LoadFrame();
DrawFrame(1,28,1,18);
vwClear(1);
vwWrite(0,0,"\x80\x1A\x80\x1B");
sprintf(buf, "%d. %s",selectedTrack,songNames[selectedTrack]);
vwWrite(24,0,buf);
/*
vwWrite(0,16,"Song header");
vwWrite(80,16,"Not playing");
vwWrite(0,32,"Tracks");
vwWrite(0,48,"Mix channels");
vwWrite(0,64,"Volume");
*/
vwSetLine(3,24,2,96,15);
vwSetLine(3,24,6,160,15);
vwSetLine(3,24,8,224,15);
vwSetLine(3,24,10,288,15);
vwSetLine(3,24,12,352,15);
vw_SetSmall();
vwWrite(4,129,"¦SELECT ¢PLAY £STOP");
vwSetLine(2,18,16, 608, 15);
vw_SetBig();
while(1)
{
DoVBlank();
KeyRead();
if(Trg & KEY_START)
{
*(u16*)0x05000000 = 0x7FFF;
sndWaitForCry(315, 30);
*(u16*)0x05000000 = 0x0000;
}
if(Trg & KEY_SELECT)
sndWaitForCry(25, 30);
//sndPlayFanfare(12);
if((Trg & L_KEY) || (Trg & R_KEY))
{
selectedTrack = wrap(selectedTrack + key_tri_horz(), 0, (const)( sizeof(songNames) / sizeof(const char*) ) );
vwClearLine(1,0);
vwClearLine(1,1);
vwWrite(0,0,"\x80\x1A\x80\x1B");
sprintf(buf, "%d. %s",selectedTrack,songNames[selectedTrack]);
vwWrite(24,0,buf);
}
if(Trg & A_BUTTON)
{
sndPlaySound(selectedTrack, 0);
//sprintf(buf, "0x%08x", (unsigned int)mplay_table[0].ma->song);
//vwWrite(80,16, buf);
}
if(Trg & B_BUTTON)
{
if(sndIsMusicPlaying())
sndPauseSound();
else
SoftReset();
}
}
}
// CMainWindow constructor:
// Create the window with the appropriate style, size, menu, etc.
//
CMainWindow::CMainWindow()
{
LoadFrame(IDR_MAINFRAME);
}
//-----------------------------------------------------------------------------
HRESULT CDXUTMeshFile::CreateFromResource( LPDIRECT3DDEVICE9 pd3dDevice, LPCWSTR strResource, LPCWSTR strType )
{
LPD3DXFILE pDXFile = NULL;
LPD3DXFILEENUMOBJECT pEnumObj = NULL;
LPD3DXFILEDATA pFileData = NULL;
HRESULT hr;
SIZE_T cChildren;
// Create a x file object
if( FAILED( hr = D3DXFileCreate( &pDXFile ) ) )
return E_FAIL;
// Register templates for d3drm and patch extensions.
if( FAILED( hr = pDXFile->RegisterTemplates( (void*)D3DRM_XTEMPLATES,
D3DRM_XTEMPLATE_BYTES ) ) )
{
SAFE_RELEASE( pDXFile );
return E_FAIL;
}
CHAR strTypeAnsi[MAX_PATH];
CHAR strResourceAnsi[MAX_PATH];
WideCharToMultiByte( CP_ACP, 0, strType, -1, strTypeAnsi, MAX_PATH, NULL, NULL );
strTypeAnsi[MAX_PATH-1] = 0;
WideCharToMultiByte( CP_ACP, 0, strResource, -1, strResourceAnsi, MAX_PATH, NULL, NULL );
strResourceAnsi[MAX_PATH-1] = 0;
D3DXF_FILELOADRESOURCE dxlr;
dxlr.hModule = NULL;
dxlr.lpName = strResourceAnsi;
dxlr.lpType = strTypeAnsi;
// Create enum object
hr = pDXFile->CreateEnumObject( (void*)&dxlr, D3DXF_FILELOAD_FROMRESOURCE,
&pEnumObj );
if( FAILED(hr) )
{
SAFE_RELEASE( pDXFile );
return hr;
}
// Enumerate top level objects (which are always frames)
pEnumObj->GetChildren(&cChildren);
for (UINT iChild = 0; iChild < cChildren; iChild++)
{
hr = pEnumObj->GetChild(iChild, &pFileData);
if (FAILED(hr))
return hr;
hr = LoadFrame( pd3dDevice, pFileData, this );
SAFE_RELEASE( pFileData );
if( FAILED(hr) )
{
SAFE_RELEASE( pEnumObj );
SAFE_RELEASE( pDXFile );
return E_FAIL;
}
}
SAFE_RELEASE( pFileData );
SAFE_RELEASE( pEnumObj );
SAFE_RELEASE( pDXFile );
return S_OK;
}
//-----------------------------------------------------------------------------
HRESULT CDXUTMeshFile::Create( LPDIRECT3DDEVICE9 pd3dDevice, LPCWSTR strFilename )
{
LPD3DXFILE pDXFile = NULL;
LPD3DXFILEENUMOBJECT pEnumObj = NULL;
LPD3DXFILEDATA pFileData = NULL;
HRESULT hr;
SIZE_T cChildren;
// Create a x file object
if( FAILED( hr = D3DXFileCreate( &pDXFile ) ) )
return E_FAIL;
// Register templates for d3drm and patch extensions.
if( FAILED( hr = pDXFile->RegisterTemplates( (void*)D3DRM_XTEMPLATES,
D3DRM_XTEMPLATE_BYTES ) ) )
{
SAFE_RELEASE( pDXFile );
return E_FAIL;
}
// Find the path to the file, and convert it to ANSI (for the D3DXOF API)
WCHAR strPath[MAX_PATH];
CHAR strPathANSI[MAX_PATH];
DXUTFindDXSDKMediaFileCch( strPath, sizeof(strPath) / sizeof(WCHAR), strFilename );
WideCharToMultiByte( CP_ACP, 0, strPath, -1, strPathANSI, MAX_PATH, NULL, NULL );
strPathANSI[MAX_PATH-1] = 0;
// Create enum object
hr = pDXFile->CreateEnumObject( (void*)strPathANSI, D3DXF_FILELOAD_FROMFILE,
&pEnumObj );
if( FAILED(hr) )
{
SAFE_RELEASE( pDXFile );
return hr;
}
// Enumerate top level objects (which are always frames)
pEnumObj->GetChildren(&cChildren);
for (UINT iChild = 0; iChild < cChildren; iChild++)
{
hr = pEnumObj->GetChild(iChild, &pFileData);
if (FAILED(hr))
return hr;
hr = LoadFrame( pd3dDevice, pFileData, this );
SAFE_RELEASE( pFileData );
if( FAILED(hr) )
{
SAFE_RELEASE( pEnumObj );
SAFE_RELEASE( pDXFile );
return E_FAIL;
}
}
SAFE_RELEASE( pFileData );
SAFE_RELEASE( pEnumObj );
SAFE_RELEASE( pDXFile );
return S_OK;
}
void CFFMPEGLoader::Seek(const UINT &iSec, const uint64_t &iFrame, const bool &bExact, const int &dst_pix_fmt ) {
int64_t seek_target=0;
for(UINT i=0; i<iPKTVideoLength; i++) {
if(pktLastVideo[i].data) {
av_free_packet(&pktLastVideo[i]);
pktLastVideo[i].data=NULL;
}
}
iPKTVideoLength = 0;
bLock=true;
for(UINT i=0; i<iPKTAudioLength; i++) {
if(pktLastAudio[i].data) {
av_free_packet(&pktLastAudio[i]);
pktLastAudio[i].data=NULL;
}
}
iPKTAudioLength = 0;
bLock=false;
AVRational temp;
temp.num=1;
temp.den=AV_TIME_BASE;
/* seek_target = av_rescale_q(iFrame+iSec*pFormatCon->streams[videoStream]->time_base.den, temp,
pFormatCon->streams[videoStream]->time_base);
av_seek_frame( pFormatCon, -1, seek_target, AVSEEK_FLAG_BACKWARD );
pVCodecCon->hurry_up = 1;
int gotFrame;
AVPacket Packet;
uint64_t MyPts=0;
do {
av_read_frame( pFormatCon, &Packet );
// should really be checking that this is a video packet
MyPts=av_rescale( Packet.pts,
AV_TIME_BASE * (int64_t) pFormatCon->streams[videoStream]->time_base.num,
pFormatCon->streams[videoStream]->time_base.den );
// Once we pass the target point, break from the loop
if( MyPts >= seek_target )
break;
avcodec_decode_video( pVCodecCon, pFrame, &gotFrame, Packet.data,
Packet.size );
av_free_packet( &Packet );
} while(1);
pVCodecCon->hurry_up = 0;*/
if(pVCodecCon) {
int64_t si_st = iFrame+iSec*GetFPS();//)*pVCodecCon->time_base.den; //av_rescale_q( (iFrame+iSec*pFormatCon->streams[videoStream]->time_base.den), temp,
//pFormatCon->streams[videoStream]->time_base);
//seek_target=av_rescale( iFrame+iSec*pVCodecCon->time_base.den,
// AV_TIME_BASE * (int64_t) pFormatCon->streams[videoStream]->time_base.num,
// pFormatCon->streams[videoStream]->time_base.den );
seek_target= si_st;//av_rescale_q(iSec*AV_TIME_BASE+iFrame*AV_TIME_BASE/GetFPS(), temp,
//pFormatCon->streams[videoStream]->time_base);
int gotFrame;
bool bIFrame=false;
//AVPacket Packet;
//uint64_t MyPts=0;
//av_read_frame( pFormatCon, &Packet );
//MyPts=av_rescale_q( Packet.pts, temp,
// pFormatCon->streams[videoStream]->time_base );
//MyPts=av_rescale( Packet.dts,
// AV_TIME_BASE * (int64_t) pFormatCon->streams[videoStream]->time_base.num,
// pFormatCon->streams[videoStream]->time_base.den );
//if(Packet.dts > si_st|| (MyPts<seek_target-20*pFormatCon->streams[videoStream]->time_base.den&&seek_target>=20*pFormatCon->streams[videoStream]->time_base.den) ) {
if(av_seek_frame(pFormatCon, videoStream,
seek_target, AVSEEK_FLAG_BACKWARD) < 0)
cout<<"error while seeking\n";
//}
//pVCodecCon->hurry_up = 1;
do {
UINT w=0,h=0;
if(dst_pix_fmt==-1) {
while( ReadVideoData(NULL,&w,&h)==0 )
if(LoadFrame()<0) return;
}
else {
unsigned char *buf;
while( ReadVideoData(&buf,&w,&h,dst_pix_fmt,&buf)==0 )
if(LoadFrame()<0) return;
}
/*if(iPKTAudioLength>0){
if(pktLastAudio[0].data)
av_free_packet(&pktLastAudio[0]);
iPKTAudioLength--;
for(UINT i=0; i<iPKTAudioLength;i++)
pktLastAudio[i]=pktLastAudio[i+1];
pktLastAudio[iPKTAudioLength].data=NULL;
}*/
static unsigned char buffer[4096];
ReadAudioData(buffer,4096);
if( pktLastVideo[0].dts >= seek_target ) {
if(!bIFrame&&bExact&&iSec!=0) {
Seek(iSec-2,iFrame,false,dst_pix_fmt);
bIFrame=true;
// cout<<"SHIT";
//if(iSec!=0)
;//Seek(iSec>1?iSec-1:0);
}
else
break;
}
//avcodec_decode_video( pVCodecCon, pFrame, &gotFrame, Packet.data,
// Packet.size );
int pt=0;
if(dst_pix_fmt==-1)
pt=pFrame->pict_type;
else
pt=pFrameRGB->pict_type;
if(pt==FF_I_TYPE) {
if(!bExact) break;
bIFrame=true;
}
} while(1);
//pVCodecCon->hurry_up = 0;
//if(av_seek_frame(pFormatCon, audioStream,
// seek_target, 0) < 0)
// cout<<"error while seeking\n";
}
/*if(pACodecCon) {
seek_target = av_rescale_q(iFrame+iSec*pFormatCon->streams[audioStream]->time_base.den, temp,
pFormatCon->streams[audioStream]->time_base);
if(av_seek_frame(pFormatCon, audioStream,
seek_target, 0) < 0)
cout<<"error while seeking\n";
}*/
}
