void Scene::Mesh::Primitive::Init( Mesh& _Owner, const U8*& _pData ) {
int MaterialID = ReadU16( _pData, true );
ASSERT( MaterialID < _Owner.m_Owner.m_MaterialsCount, "Material ID out of range!" );
m_pMaterial = _Owner.m_Owner.m_ppMaterials[MaterialID];
m_FacesCount = ReadU32( _pData );
m_VerticesCount = ReadU32( _pData );
// Read BBox in local space
m_LocalBBoxMin.x = ReadF32( _pData );
m_LocalBBoxMin.y = ReadF32( _pData );
m_LocalBBoxMin.z = ReadF32( _pData );
m_LocalBBoxMax.x = ReadF32( _pData );
m_LocalBBoxMax.y = ReadF32( _pData );
m_LocalBBoxMax.z = ReadF32( _pData );
// Read indices
m_pFaces = new U32[3*m_FacesCount];
if ( m_VerticesCount <= 65536 )
{
for ( U32 FaceIndex=0; FaceIndex < m_FacesCount; FaceIndex++ )
{
m_pFaces[3*FaceIndex+0] = ReadU16( _pData );
m_pFaces[3*FaceIndex+1] = ReadU16( _pData );
m_pFaces[3*FaceIndex+2] = ReadU16( _pData );
}
}
else
{
int IndexBufferSize = 3*m_FacesCount*sizeof(U32);
memcpy( m_pFaces, _pData, IndexBufferSize );
_pData += IndexBufferSize;
}
// Read vertices
m_VertexFormat = (VERTEX_FORMAT) *_pData++;
int VertexSize = 0;
switch ( m_VertexFormat )
{
case P3N3G3B3T2: VertexSize = (3+3+3+3+2) * sizeof(float); break;
}
int VertexBufferSize = m_VerticesCount * VertexSize;
m_pVertices = new U8[VertexBufferSize];
memcpy( m_pVertices, _pData, VertexBufferSize );
_pData += VertexBufferSize;
// Compute global bounding box
m_GlobalBBoxMin = float3::MaxFlt;
m_GlobalBBoxMax = -float3::MaxFlt;
for ( U32 VertexIndex=0; VertexIndex < m_VerticesCount; VertexIndex++ )
{
float3 LocalPosition = *((float3*) ((U8*) m_pVertices + VertexIndex * VertexSize));
float3 WorldPosition = float4( LocalPosition, 1 ) * _Owner.m_Local2World;
m_GlobalBBoxMin = m_GlobalBBoxMin.Min( WorldPosition );
m_GlobalBBoxMax = m_GlobalBBoxMax.Max( WorldPosition );
}
}
int FlcCheckFrame()
{ flc.pFrame=flc.pMembuf+flc.FrameSize-16;
ReadU32(&flc.FrameSize, flc.pFrame+0);
ReadU16(&flc.FrameCheck, flc.pFrame+4);
ReadU16(&flc.FrameChunks, flc.pFrame+6);
ReadU16(&flc.DelayOverride, flc.pFrame+8); // not actually used in UFOINT.FLI, it turns out
#ifdef DEBUG
printf("flc.FrameSize: %d\n", flc.FrameSize);
printf("flc.FrameCheck: %d\n", flc.FrameCheck);
printf("flc.FrameChunks: %d\n", flc.FrameChunks);
printf("flc.DelayOverride: %d\n", flc.DelayOverride);
#endif
flc.pFrame+=16;
if(flc.FrameCheck==0x0f1fa) {
return(0);
}
flc.DelayOverride = 0; // not FRAME_TYPE means the value we read wasn't a delay at all
if(flc.FrameCheck==0x0f100) {
#ifdef DEBUG
printf("Ani info!!!\n");
#endif
return(0);
}
return(1);
} /* FlcCheckFrame */
uint32_t Packet::ReadFloat( float* f )
{
union { float f; uint32_t u; } u;
uint32_t ret = ReadU32( &u.u );
*f = u.f;
return ret;
}
void Scene::Load( U16 _SceneResourceID ) {
U32 SceneSize = 0;
const U8* pData = LoadResourceBinary( _SceneResourceID, "SCENE", &SceneSize );
U32 Version = ReadU32( pData ); // Should be "GCX1"
ASSERT( Version == 0x31584347L, "Unsupported scene version!" );
// ==== Read Materials ====
//
m_MaterialsCount = ReadU16( pData );
m_ppMaterials = new Material*[m_MaterialsCount];
for ( int MaterialIndex=0; MaterialIndex < m_MaterialsCount; MaterialIndex++ ) {
Material* pMaterial = new Material( *this );
m_ppMaterials[MaterialIndex] = pMaterial;
pMaterial->Init( pData );
}
// ==== Read Node Hierarchy ====
//
m_NodesCount = 0;
m_MeshesCount = 0;
m_LightsCount = 0;
m_CamerasCount = 0;
m_ProbesCount = 0;
m_pROOT = CreateNode( NULL, pData );
}
float DataInput::ReadFloat()
{
union {
uint32_t u;
float f;
} ptr;
ptr.u = ReadU32();
return ptr.f;
}
void FlcDoOneFrame()
{ int ChunkCount;
ChunkCount=flc.FrameChunks;
flc.pChunk=flc.pMembuf;
if ( SDL_LockSurface(flc.mainscreen) < 0 )
return;
// if (!ChunkCount) printf("Empty frame! %d\n", flc.FrameCount); // this is normal and used for delays
while(ChunkCount--) {
ReadU32(&flc.ChunkSize, flc.pChunk+0);
ReadU16(&flc.ChunkType, flc.pChunk+4);
#ifdef DEBUG
printf("flc.ChunkSize: %d\n", flc.ChunkSize);
printf("flc.ChunkType: %d aka %x\n", flc.ChunkType, flc.ChunkType);
if (flc.DelayOverride) printf("DelayOverride: %d\n", flc.DelayOverride);
#endif
switch(flc.ChunkType) {
case 4:
COLORS256();
break;
case 7:
SS2();
break;
case 11:
DECODE_COLOR();
break;
case 12:
DECODE_LC();
break;
case 13:
BLACK();
break;
case 15:
DECODE_BRUN();
break;
case 16:
DECODE_COPY();
break;
case 18:
#ifdef DEBUG
printf("Chunk 18 not yet done.\n");
#endif
break;
default:
Log(LOG_WARNING) << "Ieek an non implemented chunk type:" << flc.ChunkType;
}
flc.pChunk+=flc.ChunkSize;
}
SDL_UnlockSurface(flc.mainscreen);
} /* FlcDoOneFrame */
int FlcCheckHeader(const char *filename)
{
if((flc.file=fopen(filename, "rb"))==NULL) {
Log(LOG_ERROR) << "Could not open flx file: " << filename;
return -1;
}
FlcReadFile(128);
ReadU32(&flc.HeaderSize, flc.pMembuf);
ReadU16(&flc.HeaderCheck, flc.pMembuf+4);
ReadU16(&flc.HeaderFrames, flc.pMembuf+6);
ReadU16(&flc.HeaderWidth, flc.pMembuf+8);
ReadU16(&flc.HeaderHeight, flc.pMembuf+10);
ReadU16(&flc.HeaderDepth, flc.pMembuf+12);
ReadU16(&flc.HeaderSpeed, flc.pMembuf+16);
#ifdef DEBUG
printf("flc.HeaderSize: %d\n", flc.HeaderSize);
printf("flc.HeaderCheck: %d\n", flc.HeaderCheck);
printf("flc.HeaderFrames: %d\n", flc.HeaderFrames);
printf("flc.HeaderWidth: %d\n", flc.HeaderWidth);
printf("flc.HeaderHeight: %d\n", flc.HeaderHeight);
printf("flc.HeaderDepth: %d\n", flc.HeaderDepth);
printf("flc.HeaderSpeed: %lf\n", flc.HeaderSpeed);
#endif
if((flc.HeaderCheck==SDL_SwapLE16(0x0AF12)) || (flc.HeaderCheck==SDL_SwapLE16(0x0AF11))) {
flc.screen_w=flc.HeaderWidth;
flc.screen_h=flc.HeaderHeight;
Log(LOG_INFO) << "Playing flx, " << flc.screen_w << "x" << flc.screen_h << ", " << flc.HeaderFrames << " frames";
flc.screen_depth=8;
if(flc.HeaderCheck == SDL_SwapLE16(0x0AF11)){
flc.HeaderSpeed*=1000.0/70.0;
}
return(0);
}
return(1);
} /* FlcCheckHeader */
uint32_t Packet::ReadU32()
{
uint32_t ret = 0;
ReadU32( &ret );
return ret;
}
void bus_put_frame(bus_frame *frame)
{
u16 current_frame_idx = ReadU16(frame->data);
for (PacketNode * p = packetList; p != NULL; p = p->next)
{
for (FrameNode *fp = p->frameList; fp != NULL; fp = fp->next)
{
if (fp->frame.srcId == frame->srcId && fp->frame.sessionId == frame->sessionId)
{
u16 pre_frame_idx = ReadU16(p->frameList->frame.data);
//检查最后插进去的idx 跟这个是不是连续的
if (current_frame_idx == pre_frame_idx + 1)
{
//拼接到后面去
FrameNode *f_temp = my_malloc(sizeof(FrameNode));
memmove(&f_temp->frame, frame, sizeof(bus_frame));
f_temp->next = p->frameList;
p->frameList = f_temp;
if (p->packetLen == ( (current_frame_idx - 1) * 6 + frame->data_len - 2) )
{
//BUS_LOG("收到最后一帧\r\n");
switch (frame->functionId)
{
case BUS_PACK_FUNC_SEND: //用于发送方给接收方传送数据
{
rxHanleCnt++;
//给个ACK 说明肯定接收到了
bus_simple_send(frame->adapterId, frame->srcId, BUS_PACK_FUNC_ACK, frame->sessionId, 0, NULL);
break;
}
case BUS_PACK_FUNC_RETURN: //用于数据发送出去，每一帧的回复 代表接收方收到
{
retHandleCnt++;
break;
}
}
}
}
else
{
//如果不是连续的 那么把这一整个packet 全部删除
for (FrameNode *it = p->frameList; it != NULL;)
{
FrameNode *itemp = it;
it = it->next;
my_free(itemp);
}
p->frameList = NULL;
if (p == packetList)
{
packetList = packetList->next;
my_free(p);
}
else
{
for (PacketNode * p1 = packetList; p1 != NULL; p1 = p1->next)
{
if (p1->next == p)
{
p1->next = p->next;
my_free(p);
break;
}
}
}
goto END; // 清除了之前的死包之后 应该插入新的包 不应该直接return
}
return;
}
else
{
break; //第一个 frame 节点的 srcId 和sessionId 不一样 就没有必要再观察了
}
}
}
END:
//没有找到 看看是不是首帧
if (current_frame_idx != 0)
{
//BUS_LOG("首帧丢失 cur= %d\r\n", current_frame_idx);
}
else
{
//插入的是首帧
PacketNode * temp = my_malloc(sizeof(PacketNode));
FrameNode *f_temp = my_malloc(sizeof(FrameNode));
memmove(&f_temp->frame, frame, sizeof(bus_frame));
// 给 packet 长度赋值
temp->packetLen = ReadU32(frame->data + 2);
f_temp->next = temp->frameList;
temp->frameList = f_temp;
temp->createdTime = bus_os_time_get();
temp->next = packetList;
packetList = temp;
if (temp->packetLen == 0 ) //加入这个帧就一个包 那么也要进行分析
{
//BUS_LOG("收到最后一帧\r\n");
switch (frame->functionId)
{
case BUS_PACK_FUNC_SEND: //用于发送方给接收方传送数据
{
rxHanleCnt++;
//给个ACK 说明肯定接收到了
bus_simple_send(frame->adapterId, frame->srcId, BUS_PACK_FUNC_ACK, frame->sessionId, 0, NULL);
break;
}
case BUS_PACK_FUNC_RETURN: //用于数据发送出去，每一帧的回复 代表接收方收到
{
retHandleCnt++;
break;
}
}
}
}
}
//Publish using RTMP_SendPacket()
int publish_using_packet(){
RTMP *rtmp=NULL;
RTMPPacket *packet=NULL;
uint32_t start_time=0;
uint32_t now_time=0;
//the timestamp of the previous frame
long pre_frame_time=0;
long lasttime=0;
int bNextIsKey=1;
uint32_t preTagsize=0;
//packet attributes
uint32_t type=0;
uint32_t datalength=0;
uint32_t timestamp=0;
uint32_t streamid=0;
FILE*fp=NULL;
fp=fopen("../live.flv","rb");
if (!fp){
RTMP_LogPrintf("Open File Error.\n");
// CleanupSockets();
return -1;
}
/* set log level */
//RTMP_LogLevel loglvl=RTMP_LOGDEBUG;
//RTMP_LogSetLevel(loglvl);
// if (!InitSockets()){
// RTMP_LogPrintf("Init Socket Err\n");
// return -1;
// }
rtmp=RTMP_Alloc();
RTMP_Init(rtmp);
//set connection timeout,default 30s
rtmp->Link.timeout=5;
if(!RTMP_SetupURL(rtmp,"rtmp://101.251.251.93:1935/myapp/mystream"))
{
RTMP_Log(RTMP_LOGERROR,"SetupURL Err\n");
RTMP_Free(rtmp);
// CleanupSockets();
return -1;
}
//if unable,the AMF command would be 'play' instead of 'publish'
RTMP_EnableWrite(rtmp);
if (!RTMP_Connect(rtmp,NULL)){
RTMP_Log(RTMP_LOGERROR,"Connect Err\n");
RTMP_Free(rtmp);
// CleanupSockets();
return -1;
}
if (!RTMP_ConnectStream(rtmp,0)){
RTMP_Log(RTMP_LOGERROR,"ConnectStream Err\n");
RTMP_Close(rtmp);
RTMP_Free(rtmp);
// CleanupSockets();
return -1;
}
packet=(RTMPPacket*)malloc(sizeof(RTMPPacket));
RTMPPacket_Alloc(packet,1024*64);
RTMPPacket_Reset(packet);
packet->m_hasAbsTimestamp = 0;
packet->m_nChannel = 0x04;
packet->m_nInfoField2 = rtmp->m_stream_id;
RTMP_LogPrintf("Start to send data ...\n");
//jump over FLV Header
fseek(fp,9,SEEK_SET);
//jump over previousTagSizen
fseek(fp,4,SEEK_CUR);
start_time=RTMP_GetTime();
while(1)
{
if((((now_time=RTMP_GetTime())-start_time)
<(pre_frame_time)) && bNextIsKey){
//wait for 1 sec if the send process is too fast
//this mechanism is not very good,need some improvement
if(pre_frame_time>lasttime){
RTMP_LogPrintf("TimeStamp:%8lu ms\n",pre_frame_time);
lasttime=pre_frame_time;
}
sleep(1);
continue;
}
//not quite the same as FLV spec
if(!ReadU8(&type,fp))
break;
if(!ReadU24(&datalength,fp))
break;
if(!ReadTime(×tamp,fp))
break;
if(!ReadU24(&streamid,fp))
break;
if (type!=0x08&&type!=0x09){
//jump over non_audio and non_video frame，
//jump over next previousTagSizen at the same time
fseek(fp,datalength+4,SEEK_CUR);
continue;
}
if(fread(packet->m_body,1,datalength,fp)!=datalength)
break;
packet->m_headerType = RTMP_PACKET_SIZE_LARGE;
packet->m_nTimeStamp = timestamp;
packet->m_packetType = type;
packet->m_nBodySize = datalength;
pre_frame_time=timestamp;
if (!RTMP_IsConnected(rtmp)){
RTMP_Log(RTMP_LOGERROR,"rtmp is not connect\n");
break;
}
if (!RTMP_SendPacket(rtmp,packet,0)){
RTMP_Log(RTMP_LOGERROR,"Send Error\n");
break;
}
if(!ReadU32(&preTagsize,fp))
break;
if(!PeekU8(&type,fp))
break;
if(type==0x09){
if(fseek(fp,11,SEEK_CUR)!=0)
break;
if(!PeekU8(&type,fp)){
break;
}
if(type==0x17)
bNextIsKey=1;
else
bNextIsKey=0;
fseek(fp,-11,SEEK_CUR);
}
}
RTMP_LogPrintf("\nSend Data Over\n");
if(fp)
fclose(fp);
if (rtmp!=NULL){
RTMP_Close(rtmp);
RTMP_Free(rtmp);
rtmp=NULL;
}
if (packet!=NULL){
RTMPPacket_Free(packet);
free(packet);
packet=NULL;
}
// CleanupSockets();
return 0;
}
bool LoadWavFromFileInMemory(const u8 *fileData, size_t numBytes, std::vector<u8> &dst, bool *isStereo, bool *is16Bit, int *frequency)
{
if (!fileData || numBytes == 0)
{
LogError("Null input data passed in");
return false;
}
if (!isStereo || !is16Bit || !frequency)
{
LogError("Outputs not set");
return false;
}
unsigned int index = 0;
u8 riff_text[4];
ReadBytes(riff_text, fileData, index, 4);
if (!!memcmp(riff_text, "RIFF", 4))
{
LogError("No RIFF chunk in WAV data");
return false;
}
if (index >= numBytes)
return false;
ReadU32(fileData, index);
u8 wave_text[4];
ReadBytes(wave_text, fileData, index, 4);
if (!!memcmp(wave_text, "WAVE", 4))
{
LogError("No WAVE chunk in WAV data");
return false;
}
// Search for the fmt chunk
for(;;)
{
if (index >= numBytes)
{
LogError("No fmt chunk in WAV data");
return false;
}
u8 chunk_text[4];
ReadBytes(chunk_text, fileData, index, 4);
unsigned int chunk_size = ReadU32(fileData, index);
if (!memcmp(chunk_text, "fmt ", 4))
break;
if (!chunk_size)
return false;
index += chunk_size;
}
if (index >= numBytes)
return false;
u16 format = ReadU16(fileData, index);
u16 channels = ReadU16(fileData, index);
unsigned int sampleFrequency = ReadU32(fileData, index);
/*unsigned int avgbytes =*/ ReadU32(fileData, index);
/*unsigned int blockalign =*/ ReadU16(fileData, index);
u16 bits = ReadU16(fileData, index);
if (format != 1)
{
LogError("Sound is not PCM data");
return false;
}
if (channels != 1 && channels != 2)
{
LogError("Sound is not either mono or stereo");
return false;
}
if (bits != 8 && bits != 16)
{
LogError("Sound is not either 8bit or 16bit");
return false;
}
// Search for the data chunk
unsigned int data_length = 0;
for(;;)
{
if (index >= numBytes)
{
LogError("No data chunk in WAV data");
return false;
}
u8 chunk_text[4];
ReadBytes(chunk_text, fileData, index, 4);
data_length = ReadU32(fileData, index);
if (!memcmp(chunk_text, "data", 4))
break;
if (!data_length) return false;
index += data_length;
}
if (!data_length)
{
LogError("Zero numBytes data chunk in WAV data");
return false;
}
std::ostringstream msg;
msg << "Loaded WAV sound with " << channels << " channels " << bits << " bits, frequency " << sampleFrequency << " datasize " << data_length;
LogDebug(msg.str());
dst.clear();
dst.insert(dst.end(), &fileData[index], &fileData[index + data_length]);
*isStereo = (channels == 2);
*is16Bit = (bits == 16);
*frequency = sampleFrequency;
return true;
}
bool WavLoader::LoadFromBuffer(Sound* sound, u8* data, uint size)
{
uint index = 0;
if (index >= size) return false;
u8 riff_text[4];
ReadBytes(riff_text, data, index, 4);
if (memcmp(riff_text, "RIFF", 4))
{
OpenALAudioModule::LogError("No RIFF chunk in WAV data");
return false;
}
if (index >= size) return false;
uint total_size = ReadU32(data, index);
u8 wave_text[4];
ReadBytes(wave_text, data, index, 4);
if (memcmp(wave_text, "WAVE", 4))
{
OpenALAudioModule::LogError("No WAVE chunk in WAV data");
return false;
}
// Search for the fmt chunk
for (;;)
{
if (index >= size)
{
OpenALAudioModule::LogError("No fmt chunk in WAV data");
return false;
}
u8 chunk_text[4];
ReadBytes(chunk_text, data, index, 4);
uint chunk_size = ReadU32(data, index);
if (!memcmp(chunk_text, "fmt ", 4))
break;
if (!chunk_size) return false;
index += chunk_size;
}
if (index >= size) return false;
u16 format = ReadU16(data, index);
u16 channels = ReadU16(data, index);
uint frequency = ReadU32(data, index);
uint avgbytes = ReadU32(data, index);
uint blockalign = ReadU16(data, index);
u16 bits = ReadU16(data, index);
if (format != 1)
{
OpenALAudioModule::LogError("Sound is not PCM data");
return false;
}
if (channels != 1 && channels != 2)
{
OpenALAudioModule::LogError("Sound is not either mono or stereo");
return false;
}
if (bits != 8 && bits != 16)
{
OpenALAudioModule::LogError("Sound is not either 8bit or 16bit");
return false;
}
// Search for the data chunk
uint data_length = 0;
for (;;)
{
if (index >= size)
{
OpenALAudioModule::LogError("No data chunk in WAV data");
return false;
}
u8 chunk_text[4];
ReadBytes(chunk_text, data, index, 4);
data_length = ReadU32(data, index);
if (!memcmp(chunk_text, "data", 4))
break;
if (!data_length) return false;
index += data_length;
}
if (!data_length)
{
OpenALAudioModule::LogError("Zero size data chunk in WAV data");
return false;
}
std::ostringstream msg;
msg << "Loaded WAV sound with " << channels << " channels " << bits << " bits, frequency " << frequency << " datasize " << data_length;
OpenALAudioModule::LogDebug(msg.str());
Foundation::SoundServiceInterface::SoundBuffer wav_buffer;
wav_buffer.data_.resize(data_length);
memcpy(&wav_buffer.data_[0], &data[index], data_length);
wav_buffer.frequency_ = frequency;
wav_buffer.sixteenbit_ = (bits == 16);
wav_buffer.stereo_ = (channels == 2);
return sound->LoadFromBuffer(wav_buffer);
}