/*****************************************************************************
* Seek to a specific location in a file
*****************************************************************************/
static int Seek( access_t *p_access, uint64_t i_pos )
{
access_sys_t *p_sys = p_access->p_sys;
/* might happen if called by ACCESS_SET_SEEKPOINT */
i_pos = __MIN( i_pos, p_sys->size );
p_sys->offset = i_pos;
p_access->info.b_eof = false;
/* find correct chapter */
FindSeekpoint( p_access );
/* find correct file */
unsigned i_file = 0;
while( i_file < FILE_COUNT - 1 &&
i_pos >= FILE_SIZE( i_file ) )
{
i_pos -= FILE_SIZE( i_file );
i_file++;
}
if( !SwitchFile( p_access, i_file ) )
return VLC_EGENERIC;
/* adjust position within that file */
return lseek( p_sys->fd, i_pos, SEEK_SET ) != -1 ?
VLC_SUCCESS : VLC_EGENERIC;
}
/*****************************************************************************
* Read and concatenate files
*****************************************************************************/
static ssize_t Read( access_t *p_access, uint8_t *p_buffer, size_t i_len )
{
access_sys_t *p_sys = p_access->p_sys;
if( p_sys->fd == -1 )
{
/* no more data */
p_access->info.b_eof = true;
return 0;
}
ssize_t i_ret = read( p_sys->fd, p_buffer, i_len );
if( i_ret > 0 )
{
/* success */
p_sys->offset += i_ret;
UpdateFileSize( p_access );
FindSeekpoint( p_access );
return i_ret;
}
else if( i_ret == 0 )
{
/* check for new files in case the recording is still active */
if( p_sys->i_current_file >= FILE_COUNT - 1 )
ImportNextFile( p_access );
/* play next file */
SwitchFile( p_access, p_sys->i_current_file + 1 );
return -1;
}
else if( errno == EINTR )
{
/* try again later */
return -1;
}
else
{
/* abort on read error */
msg_Err( p_access, "failed to read (%s)", vlc_strerror_c(errno) );
dialog_Fatal( p_access, _("File reading failed"),
_("VLC could not read the file (%s)."),
vlc_strerror(errno) );
SwitchFile( p_access, -1 );
return 0;
}
}
/*****************************************************************************
* Open a directory
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
access_t *p_access = (access_t*)p_this;
if( !p_access->psz_filepath )
return VLC_EGENERIC;
/* Some tests can be skipped if this module was explicitly requested.
* That way, the user can play "corrupt" recordings if necessary
* and we can avoid false positives in the general case. */
bool b_strict = strcmp( p_access->psz_name, "vdr" );
/* Do a quick test based on the directory name to see if this
* directory might contain a VDR recording. We can be reasonably
* sure if ScanDirectory() actually finds files. */
if( b_strict )
{
char psz_extension[4];
int i_length = 0;
const char *psz_name = BaseName( p_access->psz_filepath );
if( sscanf( psz_name, "%*u-%*u-%*u.%*u.%*u.%*u%*[-.]%*u.%3s%n",
psz_extension, &i_length ) != 1 || strcasecmp( psz_extension, "rec" ) ||
( psz_name[i_length] != DIR_SEP_CHAR && psz_name[i_length] != '\0' ) )
return VLC_EGENERIC;
}
/* Only directories can be recordings */
struct stat st;
if( vlc_stat( p_access->psz_filepath, &st ) ||
!S_ISDIR( st.st_mode ) )
return VLC_EGENERIC;
access_sys_t *p_sys = vlc_calloc( p_this, 1, sizeof( *p_sys ) );
if( unlikely(p_sys == NULL) )
return VLC_ENOMEM;
p_access->p_sys = p_sys;
p_sys->fd = -1;
p_sys->cur_seekpoint = 0;
p_sys->fps = var_InheritFloat( p_access, "vdr-fps" );
ARRAY_INIT( p_sys->file_sizes );
/* Import all files and prepare playback. */
if( !ScanDirectory( p_access ) ||
!SwitchFile( p_access, 0 ) )
{
Close( p_this );
return VLC_EGENERIC;
}
ACCESS_SET_CALLBACKS( Read, NULL, Control, Seek );
return VLC_SUCCESS;
}
void MainFrame::OnPreviousFile()
{
if (documentViews.empty())
return;
OpenDocument(SwitchFile(documentViews.back().GetFileName(), -1));
}
CSerializer* CComponentInstanceManager::Import(const TCHAR* pszFilePath)
{
m_pSerializer->Reset();
m_pSerializer->Serialize(pszFilePath);
CSerializer& serializer = *m_pSerializer;
uint32_t uVersion = 0;
serializer >> uVersion;
if (uVersion != COMPONENT_SYSTEM_VERSION)
{
TCHAR szInfo[256];
_stprintf(szInfo, _T("Data version is %d while our program version is %d"), uVersion, COMPONENT_SYSTEM_VERSION);
MessageBox(BEYONDENGINE_HWND, szInfo, _T("Verion Not Match!"), MB_OK | MB_ICONERROR);
}
else
{
uint32_t uComponentTemplateCount = 0;
serializer >> uComponentTemplateCount;
CComponentProjectDirectory* pRootDirectory = new CComponentProjectDirectory(NULL, _T("Root"));
m_pProject->SetRootDirectory(pRootDirectory);
pRootDirectory->Deserialize(serializer);
uint32_t uStartFile;
serializer >> uStartFile;
m_pProject->SetStartFile(uStartFile);
// 1. Load binarize data and file structure.
uint32_t uFileCount = 0;
serializer >> uFileCount;
std::map<uint32_t, std::vector<uint32_t> > conflictMap;
for (uint32_t i = 0; i < uFileCount; ++i)
{
TString strFileName;
serializer >> strFileName;
// This is a hack way here!
const_cast<std::vector<TString>*>(m_pProject->GetFileList())->push_back(strFileName);
BEATS_ASSERT(conflictMap.size() == 0);
uint32_t uStartPos = 0;
serializer >> uStartPos;
BEATS_ASSERT(uStartPos == (serializer.GetReadPos() - sizeof(uStartPos)), _T("File start pos not match!"));
uint32_t uFileSize = 0;
serializer >> uFileSize;
m_pProject->RegisterFileLayoutInfo(i, uStartPos, uFileSize);
uint32_t uComponentCount = 0;
serializer >> uComponentCount;
for (uint32_t j = 0; j < uComponentCount; ++j)
{
uint32_t uComponentDataSize, uGuid, uId;
uint32_t uComponentStartPos = m_pSerializer->GetReadPos();
serializer >> uComponentDataSize >> uGuid >> uId;
m_pProject->RegisterComponent(i, uGuid, uId);
serializer.SetReadPos(uComponentStartPos + uComponentDataSize);
}
BEATS_ASSERT(uStartPos + uFileSize <= serializer.GetWritePos(), _T("Data overflow!"));
serializer.SetReadPos(uStartPos + uFileSize);
}
BEATS_ASSERT(serializer.GetReadPos() == serializer.GetWritePos(), _T("Some data are not loaded completly. loaded data size %d, all data size %d"), serializer.GetReadPos(), serializer.GetWritePos());
// 2. Load start up file.
SwitchFile(uStartFile);
}
return m_pSerializer;
}
