void COutArchive::WriteLocalHeader(const CLocalItem &item)
{
SeekTo(m_BasePosition);
bool isZip64 = m_IsZip64 || item.PackSize >= 0xFFFFFFFF || item.UnPackSize >= 0xFFFFFFFF;
WriteUInt32(NSignature::kLocalFileHeader);
{
Byte ver = item.ExtractVersion.Version;
if (isZip64 && ver < NFileHeader::NCompressionMethod::kExtractVersion_Zip64)
ver = NFileHeader::NCompressionMethod::kExtractVersion_Zip64;
WriteByte(ver);
}
WriteByte(item.ExtractVersion.HostOS);
WriteUInt16(item.Flags);
WriteUInt16(item.CompressionMethod);
WriteUInt32(item.Time);
WriteUInt32(item.FileCRC);
WriteUInt32(isZip64 ? 0xFFFFFFFF: (UInt32)item.PackSize);
WriteUInt32(isZip64 ? 0xFFFFFFFF: (UInt32)item.UnPackSize);
WriteUInt16((UInt16)item.Name.Length());
{
UInt16 localExtraSize = (UInt16)((isZip64 ? (4 + 16): 0) + item.LocalExtra.GetSize());
if (localExtraSize > m_ExtraSize)
throw CSystemException(E_FAIL);
}
WriteUInt16((UInt16)m_ExtraSize); // test it;
WriteBytes((const char *)item.Name, item.Name.Length());
UInt32 extraPos = 0;
if (isZip64)
{
extraPos += 4 + 16;
WriteUInt16(NFileHeader::NExtraID::kZip64);
WriteUInt16(16);
WriteUInt64(item.UnPackSize);
WriteUInt64(item.PackSize);
}
WriteExtra(item.LocalExtra);
extraPos += (UInt32)item.LocalExtra.GetSize();
for (; extraPos < m_ExtraSize; extraPos++)
WriteByte(0);
m_OutBuffer.FlushWithCheck();
MoveBasePosition(item.PackSize);
SeekTo(m_BasePosition);
}
XnStatus XnFileDevice::SeekToTimeStamp(XnInt64 nTimeOffset, XnPlayerSeekOrigin origin)
{
XnUInt64 nTimestamp = 0;
if (origin == XN_PLAYER_SEEK_CUR)
{
nTimestamp = m_nCurrTimestamp + nTimeOffset;
}
else if (origin == XN_PLAYER_SEEK_SET)
{
nTimestamp = nTimeOffset;
}
else
{
// TODO: find max timestamp and add offset
return XN_STATUS_NOT_IMPLEMENTED;
}
xnLogInfo(XN_MASK_FILE, "Seeking file to timestamp %llu...", nTimestamp);
if (m_nFileVersion < 4)
{
return BCSeek(nTimestamp);
}
else
{
return SeekTo(nTimestamp, NULL, 0);
}
}
bool BlockFile::OpenReadData()
{
wxASSERT(mMode == BLOCK_MODE_NOT_OPEN);
if (mType == BLOCK_TYPE_ALIAS) {
mInfo = (void *)new SF_INFO;
mSoundFile = (void *)sf_open_read(mAliasFullPath, (SF_INFO *)mInfo);
if (mSoundFile != 0) {
sf_seek((SNDFILE *)mSoundFile, mStart, SEEK_SET);
mMode = BLOCK_MODE_READ_DATA;
mPos = WaveTrack::GetHeaderLen();
return true;
}
return false;
} else {
mFile = new wxFFile();
bool success = mFile->Open((const wxChar *) mFullPath, "rb");
if (success) {
mMode = BLOCK_MODE_READ_DATA;
SeekTo(0); /* seek to the beginning of the data area */
}
return success;
}
}
ErrorType SoundStreamData::ReadOggChunk() {
Int bytes;
Int bitStream;
Int readSize = mProperties.GetSampleCount() *
mProperties.GetChannelCount() *
mProperties.GetSamplesByteCount();
mSamples.SetElementCount(readSize);
bytes = ov_read(&mOggStreamState->mVorbisFile,
(char*)mSamples.GetData(),
readSize, 0, 2, 1, &bitStream);
if (bytes < 0) {
Unload();
return Error::Throw(kErrorEndOfStream,
String("[%s()]", FastFunctionName));
} else if (bytes < readSize) {
if (mIsLooping)
SeekTo(0);
else
Close();
return kErrorNone;
} else {
mSampleOffset += mProperties.GetSampleCount();
return kErrorNone;
}
}
FFMS_Frame *FFLAVFVideo::GetFrame(int n) {
GetFrameCheck(n);
n = Frames.RealFrameNumber(n);
if (LastFrameNum == n)
return &LocalFrame;
int SeekOffset = 0;
bool Seek = true;
do {
bool HasSeeked = false;
if (Seek) {
HasSeeked = SeekTo(n, SeekOffset);
Seek = false;
}
if (CurrentFrame + FFMS_CALCULATE_DELAY >= n || HasSeeked)
CodecContext->skip_frame = AVDISCARD_DEFAULT;
else
CodecContext->skip_frame = AVDISCARD_NONREF;
int64_t StartTime = ffms_av_nopts_value, FilePos = -1;
DecodeNextFrame(&StartTime, &FilePos);
if (!HasSeeked)
continue;
if (StartTime == ffms_av_nopts_value && !Frames.HasTS) {
if (FilePos >= 0) {
CurrentFrame = Frames.FrameFromPos(FilePos);
if (CurrentFrame >= 0)
continue;
}
// If the track doesn't have timestamps or file positions then
// just trust that we got to the right place, since we have no
// way to tell where we are
else {
CurrentFrame = n;
continue;
}
}
CurrentFrame = Frames.FrameFromPTS(StartTime);
// Is the seek destination time known? Does it belong to a frame?
if (CurrentFrame < 0) {
if (SeekMode == 1 || StartTime < 0) {
// No idea where we are so go back a bit further
SeekOffset -= 10;
Seek = true;
}
else
CurrentFrame = Frames.ClosestFrameFromPTS(StartTime);
}
} while (++CurrentFrame <= n);
LastFrameNum = n;
return OutputFrame(DecodeFrame);
}
status_t AudioOffloadPlayer::Play()
{
MOZ_ASSERT(NS_IsMainThread());
if (mResetTimer) {
mResetTimer->Cancel();
mResetTimer = nullptr;
WakeLockRelease();
}
status_t err = OK;
if (!mStarted) {
// Last pause timed out and offloaded audio sink was reset. Start it again
err = Start(false);
if (err != OK) {
return err;
}
// Seek to last play position only when there was no seek during last pause
if (!mSeeking) {
SeekTo(mPositionTimeMediaUs);
}
}
if (!mPlaying) {
CHECK(mAudioSink.get());
err = mAudioSink->Start();
if (err == OK) {
mPlaying = true;
}
}
return err;
}
LRESULT YouTubeWebPageView::OnStateChanged(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
{
T_enPlayerState enState = static_cast<T_enPlayerState>(static_cast<int>(lParam));
ATLTRACE(_T("%08x: OnStateChanged: %s (%i)\n"),
m_hWnd,
GetStateCodeText(enState),
lParam);
if (enState == playerStateInitialized)
{
// simulate a WM_SIZE message to adjust web page size
CRect rc;
GetClientRect(&rc);
BOOL bHandled = false;
OnSize(WM_SIZE, 0, MAKELPARAM(rc.Width(),rc.Height()), bHandled);
}
else
if (enState == playerStateVideoCued)
{
switch(m_enActionWhenReady)
{
case actionPlayVideo:
SetVolume(100);
PlayVideo();
break;
case actionSeekAndPause:
m_uiSeekAndPauseStopCounter = 2;
SetVolume(0);
// note: calling SeekTo starts playing, so we pause the video when we reach the exact second
SeekTo(m_dSeconds, true);
break;
case actionDoNothing:
default:
break;
}
}
else
if (enState == playerStatePlaying) // playing
{
// started playing due to SeekTo() call?
if (m_enActionWhenReady == actionSeekAndPause)
{
CheckSeekToStart();
SetTimer(IDT_SEEK_AND_PAUSE, 200);
}
}
else
if (enState == playerStatePaused) // paused
{
KillTimer(IDT_SEEK_AND_PAUSE);
m_enActionWhenReady = actionDoNothing;
}
return 0;
}
int OpenFile(char * fn, int pos)
{
PLAYRECT rect;
rect.x=0;rect.y=0;
rect.uWidth=352;rect.uHeight=288;
CHECK(Hik_PlayM4_OpenFile(0, fn), -2);
CHECK(Hik_PlayM4_SetDecCallBack(0, DecCallBack), -3);
CHECK(Hik_PlayM4_SetFileEndCallBack(0, FileEndCallBack), -4);
CHECK(Hik_PlayM4_Play(0, rect), -5);
SeekTo(pos);
return 0;
}
XnStatus XnDeviceFileReader::Seek(XnUInt64 nTimestamp)
{
XnStatus nRetVal = XN_STATUS_OK;
xnLogInfo(XN_MASK_FILE, "Seeking file to timestamp %llu...", nTimestamp);
if (m_nFileVersion < 4)
{
return BCSeek(nTimestamp);
}
nRetVal = SeekTo(nTimestamp, 0);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
void COutArchive::WriteCentralDir(const CObjectVector<CItem> &items, const CByteBuffer *comment)
{
SeekTo(m_BasePosition);
UInt64 cdOffset = GetCurrentPosition();
for(int i = 0; i < items.Size(); i++)
WriteCentralHeader(items[i]);
UInt64 cd64EndOffset = GetCurrentPosition();
UInt64 cdSize = cd64EndOffset - cdOffset;
bool cdOffset64 = cdOffset >= 0xFFFFFFFF;
bool cdSize64 = cdSize >= 0xFFFFFFFF;
bool items64 = items.Size() >= 0xFFFF;
bool isZip64 = (cdOffset64 || cdSize64 || items64);
if (isZip64)
{
WriteUInt32(NSignature::kZip64EndOfCentralDir);
WriteUInt64(kZip64EcdSize); // ThisDiskNumber = 0;
WriteUInt16(45); // version
WriteUInt16(45); // version
WriteUInt32(0); // ThisDiskNumber = 0;
WriteUInt32(0); // StartCentralDirectoryDiskNumber;;
WriteUInt64((UInt64)items.Size());
WriteUInt64((UInt64)items.Size());
WriteUInt64((UInt64)cdSize);
WriteUInt64((UInt64)cdOffset);
WriteUInt32(NSignature::kZip64EndOfCentralDirLocator);
WriteUInt32(0); // number of the disk with the start of the zip64 end of central directory
WriteUInt64(cd64EndOffset);
WriteUInt32(1); // total number of disks
}
WriteUInt32(NSignature::kEndOfCentralDir);
WriteUInt16(0); // ThisDiskNumber = 0;
WriteUInt16(0); // StartCentralDirectoryDiskNumber;
WriteUInt16((UInt16)(items64 ? 0xFFFF: items.Size()));
WriteUInt16((UInt16)(items64 ? 0xFFFF: items.Size()));
WriteUInt32(cdSize64 ? 0xFFFFFFFF: (UInt32)cdSize);
WriteUInt32(cdOffset64 ? 0xFFFFFFFF: (UInt32)cdOffset);
UInt32 commentSize = (UInt32)(comment ? comment->GetCapacity() : 0);
WriteUInt16((UInt16)commentSize);
if (commentSize > 0)
WriteBytes((const Byte *)*comment, commentSize);
m_OutBuffer.FlushWithCheck();
}
int OpenFile(char * fn, int pos)
{
printf("the fn in openfile is %s\n", fn);
PLAYRECT rect;
rect.x=0;rect.y=0;
rect.uWidth=704;rect.uHeight=576;
CHECK(Hik_PlayM4_OpenFile(0, fn), -2);
CHECK(Hik_PlayM4_SetDecCallBack(0, DecCallBack), -3);
CHECK(Hik_PlayM4_SetFileEndCallBack(0, FileEndCallBack), -4);
CHECK(Hik_PlayM4_Play(0, rect), -5);
SeekTo(pos);
return 0;
}
XnStatus XnDeviceFileReader::SeekFrame(XnUInt32 nFrameID)
{
XnStatus nRetVal = XN_STATUS_OK;
// don't allow seeking to frame 0
nFrameID = XN_MAX(nFrameID, 1);
xnLogInfo(XN_MASK_FILE, "Seeking file to frame %u...", nFrameID);
if (m_nFileVersion < 4)
{
return BCSeekFrame(nFrameID);
}
nRetVal = SeekTo(0, nFrameID);
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
void CMoFileIO::SetBoundaries( uint32 min, uint32 max )
{
m_FileMin = 0;
m_FileMax = m_FileLen;
ASSERT( min < max );
if( min > m_FileLen )
min = 0;
if( max > m_FileLen )
max = m_FileLen;
SeekTo( min );
m_FileMin = min;
m_FileMax = max;
m_FileLen = m_FileMax - m_FileMin;
}
XnStatus XnFileDevice::SeekToFrame(const XnChar* strNodeName, XnInt32 nFrameOffset, XnPlayerSeekOrigin origin)
{
XnStatus nRetVal = XN_STATUS_OK;
XnNodeInfo* pNodeInfo = NULL;
nRetVal = m_nodeInfoMap.Get(strNodeName, pNodeInfo);
XN_IS_STATUS_OK(nRetVal);
XnInt32 nFrameID = 0;
switch (origin)
{
case XN_PLAYER_SEEK_CUR:
nFrameID = pNodeInfo->nCurrFrameID + nFrameOffset;
break;
case XN_PLAYER_SEEK_SET:
nFrameID = nFrameOffset;
break;
case XN_PLAYER_SEEK_END:
// TODO: handle
return XN_STATUS_NOT_IMPLEMENTED;
}
// don't allow seeking to frame 0
nFrameID = XN_MAX(nFrameID, 1);
xnLogInfo(XN_MASK_FILE, "Seeking file to frameID %u of node %s...", nFrameID, strNodeName);
if (m_nFileVersion < 4)
{
return BCSeekFrame(nFrameID);
}
else
{
nRetVal = SeekTo(0, strNodeName, nFrameID);
XN_IS_STATUS_OK(nRetVal);
}
return (XN_STATUS_OK);
}
HRESULT __stdcall Seek(LARGE_INTEGER where, DWORD whence, ULARGE_INTEGER* pos)
{
UINT64 p;
switch(whence)
{
case STREAM_SEEK_SET:
p = where.QuadPart;
break;
case STREAM_SEEK_CUR:
p = GetPosition() + where.QuadPart;
break;
case STREAM_SEEK_END:
p = GetSize() + where.QuadPart;
break;
default:
return E_INVALIDARG;
}
HRESULT hr = SeekTo(p);
if(SUCCEEDED(hr) && pos)
pos->QuadPart = p;
return hr;
}
status_t AudioOffloadPlayer::ChangeState(MediaDecoder::PlayState aState)
{
MOZ_ASSERT(NS_IsMainThread());
mPlayState = aState;
switch (mPlayState) {
case MediaDecoder::PLAY_STATE_PLAYING: {
status_t err = Play();
if (err != OK) {
return err;
}
StartTimeUpdate();
} break;
case MediaDecoder::PLAY_STATE_SEEKING: {
int64_t seekTimeUs
= mObserver->GetSeekTime();
SeekTo(seekTimeUs, true);
mObserver->ResetSeekTime();
} break;
case MediaDecoder::PLAY_STATE_PAUSED:
case MediaDecoder::PLAY_STATE_SHUTDOWN:
// Just pause here during play state shutdown as well to stop playing
// offload track immediately. Resources will be freed by
// MediaOmxCommonDecoder
Pause();
break;
case MediaDecoder::PLAY_STATE_ENDED:
Pause(true);
break;
default:
break;
}
return OK;
}
ErrorType SoundStreamData::ReadWavChunk() {
Long fileSize = 44 + mNumTotalSamples;
Int readSize = mProperties.GetSampleCount() *
mProperties.GetChannelCount() *
mProperties.GetSamplesByteCount();
Int bytesLeft = (Int)(fileSize - mStreamReader->GetSeekPosition());
if (bytesLeft < readSize)
mSamples.SetElementCount(bytesLeft);
else
mSamples.SetElementCount(readSize);
mStreamReader->Read((Byte*)mSamples.GetData(),
mSamples.GetElementCount());
mSampleOffset += mSamples.GetElementCount() /
(mProperties.GetChannelCount() *
mProperties.GetSamplesByteCount());
if (mSampleOffset >= mNumTotalSamples) {
if (mIsLooping)
SeekTo(0);
else
Close();
}
return kErrorNone;
}
void IncomingDataParser::Parse(const pb::remote::Message& msg) {
close_connection_ = false;
RemoteClient* client = qobject_cast<RemoteClient*>(sender());
// Now check what's to do
switch (msg.type()) {
case pb::remote::CONNECT:
ClientConnect(msg);
break;
case pb::remote::DISCONNECT:
close_connection_ = true;
break;
case pb::remote::REQUEST_PLAYLISTS:
SendPlaylists(msg);
break;
case pb::remote::REQUEST_PLAYLIST_SONGS:
GetPlaylistSongs(msg);
break;
case pb::remote::SET_VOLUME:
emit SetVolume(msg.request_set_volume().volume());
break;
case pb::remote::PLAY:
emit Play();
break;
case pb::remote::PLAYPAUSE:
emit PlayPause();
break;
case pb::remote::PAUSE:
emit Pause();
break;
case pb::remote::STOP:
emit Stop();
break;
case pb::remote::STOP_AFTER:
emit StopAfterCurrent();
break;
case pb::remote::NEXT:
emit Next();
break;
case pb::remote::PREVIOUS:
emit Previous();
break;
case pb::remote::CHANGE_SONG:
ChangeSong(msg);
break;
case pb::remote::SHUFFLE_PLAYLIST:
emit ShuffleCurrent();
break;
case pb::remote::REPEAT:
SetRepeatMode(msg.repeat());
break;
case pb::remote::SHUFFLE:
SetShuffleMode(msg.shuffle());
break;
case pb::remote::SET_TRACK_POSITION:
emit SeekTo(msg.request_set_track_position().position());
break;
case pb::remote::INSERT_URLS:
InsertUrls(msg);
break;
case pb::remote::REMOVE_SONGS:
RemoveSongs(msg);
break;
case pb::remote::OPEN_PLAYLIST:
OpenPlaylist(msg);
break;
case pb::remote::CLOSE_PLAYLIST:
ClosePlaylist(msg);
break;
case pb::remote::LOVE:
emit Love();
break;
case pb::remote::BAN:
emit Ban();
break;
case pb::remote::GET_LYRICS:
emit GetLyrics();
break;
case pb::remote::DOWNLOAD_SONGS:
emit SendSongs(msg.request_download_songs(), client);
break;
case pb::remote::SONG_OFFER_RESPONSE:
emit ResponseSongOffer(client, msg.response_song_offer().accepted());
break;
case pb::remote::GET_LIBRARY:
emit SendLibrary(client);
break;
case pb::remote::RATE_SONG:
RateSong(msg);
break;
default:
break;
}
}
void COutArchive::SeekToPackedDataPosition()
{
SeekTo(m_BasePosition + m_LocalFileHeaderSize);
}
bool MmapFile::SeekBegin() {
return SeekTo(0);
}
bool MmapFile::SeekEnd() {
return SeekTo(_size - 1);
}
bool MmapFile::SeekBehind(int64_t count) {
return SeekTo(_cursor - count);
}
bool MmapFile::SeekAhead(int64_t count) {
return SeekTo(_cursor + count);
}
///////////////////////////////////////////////////////////////////////////////
// Execute
///////////////////////////////////////////////////////////////////////////////
void cDbExplore::Execute( cFCODatabaseFileIter& dbIter )
{
ASSERT( ! dbIter.Done() );
cDbDataSourceIter* pIter = new cDbDataSourceIter( &dbIter.GetDb(), dbIter.GetGenre() );
const iFCOPropDisplayer* pDisplayer = dbIter.GetGenreHeader().GetPropDisplayer();
////////////////////////////
// the main event loop...
////////////////////////////
while( true )
{
TSTRING verb, noun;
TCOUT << _T(">>");
TCIN >> verb;
//
// ok, now we switch on the command...
//
//-----------------------------------------------------------------
// quit
//-----------------------------------------------------------------
if( verb.compare( _T("quit") ) == 0 )
{
// the quit command...
break;
}
//-----------------------------------------------------------------
// print
//-----------------------------------------------------------------
if( verb.compare( _T("print") ) == 0 )
{
GetNoun(noun);
if( SeekTo( pIter, noun ) )
{
if( pIter->HasFCOData() )
{
iFCO* pFCO = pIter->CreateFCO();
PrintFCO( pFCO, pDisplayer );
pFCO->Release();
}
else
{
TCOUT << _T("Object has no data associated with it.") << std::endl;
}
}
else
{
TCOUT << _T("Unable to find object ") << noun << std::endl;
}
}
//-----------------------------------------------------------------
// pwd
//-----------------------------------------------------------------
else if( verb.compare( _T("pwd") ) == 0 )
{
TCOUT << iTWFactory::GetInstance()->GetNameTranslator()->ToStringDisplay( pIter->GetParentName() ) << std::endl;
}
//-----------------------------------------------------------------
// ls
//-----------------------------------------------------------------
else if( verb.compare( _T("ls") ) == 0 )
{
int cnt = 0;
for( pIter->SeekBegin(); ! pIter->Done(); pIter->Next(), cnt++ )
{
TCOUT << _T("[") << cnt ;
if( pIter->CanDescend() )
{
TCOUT << _T("]*\t") ;
}
else
{
TCOUT << _T("]\t") ;
}
TCOUT << pIter->GetShortName() << std::endl;
}
}
//-----------------------------------------------------------------
// cd
//-----------------------------------------------------------------
else if( verb.compare( _T("cd") ) == 0 )
{
GetNoun(noun);
std::vector<TSTRING> vDirs;
SplitString( noun, pIter->GetParentName().GetDelimiter(), vDirs );
for( std::vector<TSTRING>::iterator i = vDirs.begin(); i != vDirs.end(); i++ )
{
if( i->compare( _T("..") ) == 0 )
{
if( pIter->AtRoot() )
{
TCOUT << _T("Can't ascend above root.") << std::endl;
break;
}
else
{
TCOUT << _T("Ascending...") << std::endl;
pIter->Ascend();
}
}
else
{
if( SeekTo( pIter, *i ) )
{
if( pIter->CanDescend() )
{
TCOUT << _T("Descending into ") << *i << std::endl;
pIter->Descend();
}
else
{
TCOUT << *i << _T(" has no children; can't descend.") << std::endl;
break;
}
}
else
{
TCOUT << _T("Unable to find object ") << *i << std::endl;
break;
}
}
}
}
//-----------------------------------------------------------------
// cg
//-----------------------------------------------------------------
else if( verb.compare( _T("cg") ) == 0 )
{
GetNoun(noun);
cGenre::Genre newGenre = cGenreSwitcher::GetInstance()->StringToGenre( noun.c_str() );
if (newGenre != cGenre::GENRE_INVALID)
{
dbIter.SeekToGenre( newGenre );
if( !dbIter.Done() )
{
TCOUT << _T("Changing to Genre ") << noun << std::endl;
//
// create a new db iter for the new genre (db iters can only be
// assocaited with a single genre :-( )
//
delete pIter;
pIter = new cDbDataSourceIter( &dbIter.GetDb(), newGenre );
}
else
{
TCOUT << _T("Unable to find Genre ") << noun << std::endl;
}
}
else
{
TCOUT << _T("Invalid Genre ") << noun << std::endl;
}
}
//-----------------------------------------------------------------
// pwg
//-----------------------------------------------------------------
else if( verb.compare( _T("pwg") ) == 0 )
{
TCOUT << _T("Current Genre: ") << cGenreSwitcher::GetInstance()->GenreToString( (cGenre::Genre)dbIter.GetGenre(), true ) << std::endl;
}
//-----------------------------------------------------------------
// help
//-----------------------------------------------------------------
if( verb.compare( _T("help") ) == 0 )
{
TCOUT << _T("Commands: ") << std::endl
<< _T(" cd <dir_name>") << std::endl
<< _T(" pwd ") << std::endl
<< _T(" ls ") << std::endl
<< _T(" print <object_name>") << std::endl
<< _T(" cg (FS | NTFS | NTREG)")<< std::endl
<< _T(" pwg") << std::endl
<< _T(" quit") << std::endl;
}
// make sure the file is still valid...
//
/*
#ifdef _BLOCKFILE_DEBUG
db.AssertAllBlocksValid() ;
#endif
*/
}
delete pIter;
TCOUT << _T("Exiting...") << std::endl;
}
/* printf("Face %i:\n v0: %f, %f, %f\n v1: %f, %f, %f\n"
" v2: %f, %f, %f\n", i,
tList[i].verts[0][0],
tList[i].verts[0][1],
tList[i].verts[0][2],
tList[i].verts[1][0],
tList[i].verts[1][1],
tList[i].verts[1][2],
tList[i].verts[2][0],
tList[i].verts[2][1],
tList[i].verts[2][2]);
*/
}
}
//==========================================================================
//
// Load3DS
//
//==========================================================================
#if 0 /* 3DS stuff is unused. don't even know whether it's working */
static void Load3DS(FILE *input, triangle_t **triList, int *triangleCount)
{
unsigned int i, j;
qboolean stop;
qboolean foundVertexList;
unsigned int chunkType, chunkPos, chunkSize;
unsigned int editChunkSize, editChunkPos;
unsigned int objectChunkSize, objectChunkPos;
unsigned int meshChunkSize, meshChunkPos;
unsigned int vertex;
unsigned int vertexCount;
struct vList_s
{
float v[3];
} *vList;
unsigned int triCount;
triangle_t *tList;
InputFile = input;
if (ReadShort() != _3DS_MAIN3DS)
{
_3DSError("Missing 3DS main chunk header.\n");
}
SeekTo(16);
if (ReadShort() != _3DS_EDIT3DS)
{
_3DSError("Missing 3DS edit chunk header.\n");
}
editChunkSize = ReadLong();
editChunkPos = FilePosition()-6;
stop = false;
while (stop == false)
{
chunkPos = FilePosition();
chunkType = ReadShort();
switch (chunkType)
{
case _3DS_EDIT_UNKNW01:
case _3DS_EDIT_UNKNW02:
case _3DS_EDIT_UNKNW03:
case _3DS_EDIT_UNKNW04:
case _3DS_EDIT_UNKNW05:
case _3DS_EDIT_UNKNW06:
case _3DS_EDIT_UNKNW07:
case _3DS_EDIT_UNKNW08:
case _3DS_EDIT_UNKNW09:
case _3DS_EDIT_UNKNW10:
case _3DS_EDIT_UNKNW11:
case _3DS_EDIT_UNKNW12:
case _3DS_EDIT_UNKNW13:
case _3DS_EDIT_MATERIAL:
case _3DS_EDIT_VIEW1:
case _3DS_EDIT_BACKGR:
case _3DS_EDIT_AMBIENT:
SeekTo(chunkPos+ReadLong());
break;
case _3DS_EDIT_OBJECT:
stop = true;
default:
break;
}
if (FilePosition()-editChunkPos >= editChunkSize)
{
_3DSError("Couldn't find OBJECT chunk.\n");
}
}
objectChunkSize = ReadLong();
objectChunkPos = FilePosition()-6;
SkipName();
stop = false;
while (stop == false)
{
chunkPos = FilePosition();
chunkType = ReadShort();
switch (chunkType)
{
case _3DS_OBJ_UNKNWN01:
case _3DS_OBJ_UNKNWN02:
case _3DS_OBJ_LIGHT:
case _3DS_OBJ_CAMERA:
SeekTo(chunkPos+ReadLong());
break;
case _3DS_OBJ_TRIMESH:
stop = true;
default:
break;
}
if (FilePosition()-objectChunkPos >= objectChunkSize)
{
_3DSError("Couldn't find TRIMESH chunk.\n");
}
}
meshChunkSize = ReadLong();
meshChunkPos = FilePosition()-6;
stop = false;
foundVertexList = false;
while (stop == false)
{
chunkPos = FilePosition();
chunkType = ReadShort();
switch (chunkType)
{
case _3DS_TRI_FACEL2:
case _3DS_TRI_VISIBLE:
SeekTo(chunkPos+ReadLong());
break;
case _3DS_TRI_VERTEXL:
chunkSize = ReadLong();
vertexCount = ReadShort();
vList = (struct vList_s *) SafeMalloc(vertexCount * sizeof(vList[0]));
for (i = 0; i < vertexCount; i++)
{
vList[i].v[0] = ReadFloat();
vList[i].v[1] = -ReadFloat();
vList[i].v[2] = ReadFloat();
}
SeekTo(chunkPos+chunkSize);
foundVertexList = true;
break;
case _3DS_TRI_FACEL1:
chunkSize = ReadLong();
triCount = ReadShort();
if (triCount >= MAXTRIANGLES)
{
COM_Error("Too many triangles in file %s\n",
InputFileName);
}
*triangleCount = triCount;
tList = (triangle_t *) SafeMalloc(MAXTRIANGLES * sizeof(triangle_t));
*triList = tList;
for (i = 0; i < triCount; i++)
{
for (j = 0; j < 3; j++)
{
vertex = ReadShort();
tList[i].verts[j][0] = vList[vertex].v[0];
tList[i].verts[j][1] = vList[vertex].v[1];
tList[i].verts[j][2] = vList[vertex].v[2];
}
ReadShort(); // Skip face flags
}
stop = true;
break;
default:
break;
}
if (FilePosition()-meshChunkPos >= meshChunkSize)
{
if (foundVertexList == false)
{
_3DSError("Couldn't find TRI_VERTEXL chunk.\n");
}
else
{
_3DSError("Couldn't find TRI_FACEL1 chunk.\n");
}
}
}
}
