void SS2()
{ Uint8 *pSrc, *pDst, *pTmpDst;
Sint8 CountData;
Uint8 ColumSkip, Fill1, Fill2;
Uint16 Lines, Count;
pSrc=flc.pChunk+6;
pDst=(Uint8*)flc.mainscreen->pixels + flc.offset;
ReadU16(&Lines, pSrc);
pSrc+=2;
while(Lines--) {
ReadU16(&Count, pSrc);
pSrc+=2;
while(Count & 0xc000) {
/* Upper bits 11 - Lines skip
*/
if((Count & 0xc000)==0xc000) { // 0xc000h = 1100000000000000
pDst+=(0x10000-Count)*flc.mainscreen->pitch;
}
if((Count & 0xc000)==0x4000) { // 0x4000h = 0100000000000000
/* Upper bits 01 - Last pixel
*/
#ifdef DEBUG
printf("Last pixel not implemented");
#endif
}
ReadU16(&Count, pSrc);
pSrc+=2;
}
if((Count & SDL_SwapLE16(0xc000))==0x0000) { // 0xc000h = 1100000000000000
pTmpDst=pDst;
while(Count--) {
ColumSkip=*(pSrc++);
pTmpDst+=ColumSkip;
CountData=*(pSrc++);
if(CountData>0) {
while(CountData--) {
*(pTmpDst++)=*(pSrc++);
*(pTmpDst++)=*(pSrc++);
}
} else {
if(CountData<0) {
CountData=(0x100-CountData);
Fill1=*(pSrc++);
Fill2=*(pSrc++);
while(CountData--) {
*(pTmpDst++)=Fill1;
*(pTmpDst++)=Fill2;
}
}
}
}
pDst+=flc.mainscreen->pitch;
}
}
} /* SS2 */
void Scene::Material::Init( const U8*& _pData ) {
m_ID = ReadU16( _pData, true );
m_DiffuseAlbedo.x = ReadF32( _pData );
m_DiffuseAlbedo.y = ReadF32( _pData );
m_DiffuseAlbedo.z = ReadF32( _pData );
m_TexDiffuseAlbedo.m_ID = ReadU16( _pData, true );
m_SpecularAlbedo.x = ReadF32( _pData );
m_SpecularAlbedo.y = ReadF32( _pData );
m_SpecularAlbedo.z = ReadF32( _pData );
m_TexSpecularAlbedo.m_ID = ReadU16( _pData, true );
m_SpecularExponent.x = ReadF32( _pData );
m_SpecularExponent.y = ReadF32( _pData );
m_SpecularExponent.z = ReadF32( _pData );
m_TexNormal.m_ID = ReadU16( _pData, true );
m_EmissiveColor.x = ReadF32( _pData );
m_EmissiveColor.y = ReadF32( _pData );
m_EmissiveColor.z = ReadF32( _pData );
ReadEndMaterialMarker( _pData );
}
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 */
//找包函数 找到了返回 1 没找到返回 0
u8 bus_find_packet_data(u8 adapterId, u8 srcId, u8 sessionId, u8 functionId, u8 *functionIdOut , uint8_t * data, u32 *dataLenout)
{
for (PacketNode * p = packetList; p != NULL; p = p->next)
{
if ( ((p->packetLen == (ReadU16(p->frameList->frame.data)-1) * 6 + p->frameList->frame.data_len-2 ) ||
p->packetLen == 0
)
&& //已经收到整个包
p->frameList->frame.srcId == srcId && //源地址相同
p->frameList->frame.sessionId == sessionId && //会话相同
(p->frameList->frame.functionId | functionId) //功能相同
)
{
*dataLenout = p->packetLen;
*functionIdOut = p->frameList->frame.functionId;
for (FrameNode *fp = p->frameList; fp != NULL;)
{
int frameIdx = ReadU16(fp->frame.data);
int frameLen = fp->frame.data_len - 2;
if (frameIdx != 0)
{
for (int i = 0; i < frameLen; i++)
{
data[(frameIdx - 1) * 6 + i] = fp->frame.data[i + 2];
}
}
//这个节点要删除
FrameNode *temp = fp;
fp = fp->next;
my_free(temp);
//printf("x");
}
//p->frameList = NULL;
//这个packet要删除
if (p == packetList)
{
packetList = packetList->next;;
my_free(p);
}
else
{
for (PacketNode * p1 = packetList; p1 != NULL; p1 = p1->next)
{
if (p1->next == p)
{
PacketNode * needToDel = p;
p1->next = p->next;
my_free(needToDel);
break;
}
}
}
return 1;
}
}
return 0;
}
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 );
}
}
void CMapReader::ReadBlockP(FILE *fp)
{
m_blockP = new SBlockP[m_header.numBlockP];
memset(m_blockP, 0, sizeof(SBlockP)*m_header.numBlockP);
SBlockP *p = m_blockP;
for(u32 i=0; i<m_header.numBlockP; i++, p++)
{
p->un0 = ReadU16(fp);
p->un1 = ReadU16(fp);
}
}
void CMapReader::ReadBlockN(FILE *fp)
{
m_blockN = new SBlockN[m_header.numBlockN];
memset(m_blockN, 0, sizeof(SBlockN)*m_header.numBlockN);
SBlockN *p = m_blockN;
for(u32 i=0; i<m_header.numBlockN; i++, p++)
{
p->un0 = ReadU16(fp);
p->un1 = ReadU16(fp);
p->un2 = ReadU16(fp);
}
}
void CMapReader::ReadBlockG(FILE *fp)
{
m_blockG = new SBlockG[m_header.numBlockG];
memset(m_blockG, 0, sizeof(SBlockG)*m_header.numBlockG);
SBlockG *b = m_blockG;
for(u32 i=0; i<m_header.numBlockG; i++, b++)
{
b->un0 = ReadU16(fp);
b->un1 = ReadU16(fp);
b->un2 = ReadU16(fp);
}
}
void CMapReader::ReadBlockM(FILE *fp)
{
m_blockM = new SBlockM[m_header.numBlockM];
memset(m_blockM, 0, sizeof(SBlockM)*m_header.numBlockM);
SBlockM *b = m_blockM;
for(u32 i=0; i<m_header.numBlockM; i++, b++)
{
for(u32 j=0; j<10; j++)
b->un[j] = ReadU16(fp);
for(u32 j=0; j<8; j++)
b->pad[j] = ReadU16(fp);
}
}
//在接收池里面查找已经接收完整了的 发送包 注意是 发送包 这个数据需要送给接收回调函数
//返回的值 是一个帧链表 需要进行重新组织
PacketNode * bus_get_packet(void)
{
PacketNode * rt = NULL;
for (PacketNode * p = packetList; p != NULL; p = p->next)
{
if ( ((p->packetLen == (ReadU16(p->frameList->frame.data)-1) * 6 + p->frameList->frame.data_len - 2) ||
p->packetLen == 0
)
&& //已经收到整个包
(p->frameList->frame.functionId == BUS_PACK_FUNC_SEND) //功能相同
)
{
rt = p;
//这个packet要删除
if (p == packetList)
{
packetList = packetList->next;
}
else
{
for (PacketNode * p1 = packetList; p1 != NULL; p1 = p1->next)
{
if (p1->next == p)
{
p1->next = p->next;
break;
}
}
}
break;
}
}
return rt;
}
bool CMapReader::CheckBlockEnd(u16 data,FILE *fp)
{
if(ReadU16(fp) == data)
return true;
else
return false;
}
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 );
}
void DECODE_COLOR()
{ Uint8 *pSrc;
Uint16 NumColors, NumColorPackets;
Uint8 NumColorsSkip;
int i;
pSrc=flc.pChunk+6;
ReadU16(&NumColorPackets, pSrc);
pSrc+=2;
while(NumColorPackets--) {
NumColorsSkip=*(pSrc++);
if(!(NumColors=*(pSrc++))) {
NumColors=256;
}
i=0;
while(NumColors--) {
flc.colors[i].r=*(pSrc++)<<2;
flc.colors[i].g=*(pSrc++)<<2;
flc.colors[i].b=*(pSrc++)<<2;
i++;
}
flc.realscreen->setPalette(flc.colors, NumColorsSkip, i);
SDL_SetColors(flc.mainscreen, flc.colors, NumColorsSkip, i);
flc.realscreen->getSurface(); // force palette update to really happen
}
} /* DECODE_COLOR */
void CMapReader::ReadTriUVFaces(FILE *fp)
{
m_triUVFaces = new STriUVFace[m_header.numTriUVFaces];
memset(m_triUVFaces, 0, sizeof(STriUVFace)*m_header.numTriUVFaces);
STriUVFace *f = m_triUVFaces;
for(int i=0; i<m_header.numTriUVFaces; i++, f++)
{
f->u0 = ReadU8(fp); f->v0 = ReadU8(fp);
f->u1 = ReadU8(fp); f->v1 = ReadU8(fp);
f->u2 = ReadU8(fp); f->v2 = ReadU8(fp);
f->texture = ReadU16(fp);
f->pad[0] = ReadU16(fp);
f->pad[1] = ReadU16(fp);
f->pad[2] = ReadU16(fp);
f->pad[3] = ReadU16(fp);
}
}
void CMapReader::ReadBlockK(FILE *fp)
{
m_blockK = new SBlockK[m_header.numBlockK];
memset(m_blockK, 0, sizeof(SBlockK)*m_header.numBlockK);
SBlockK *b = m_blockK;
for(u32 i=0; i<m_header.numBlockK; i++, b++)
{
for(u32 j=0; j<27; j++)
b->un[j] = ReadU16(fp);
}
}
void DECODE_LC()
{ Uint8 *pSrc, *pDst, *pTmpDst;
Sint8 CountData;
Uint8 CountSkip;
Uint8 Fill;
Uint16 Lines, tmp;
int PacketsCount;
pSrc=flc.pChunk+6;
pDst=(Uint8*)flc.mainscreen->pixels;
ReadU16(&tmp, pSrc);
pSrc+=2;
pDst+=tmp*flc.mainscreen->pitch;
ReadU16(&Lines, pSrc);
pSrc+=2;
while(Lines--) {
pTmpDst=pDst;
PacketsCount=*(pSrc++);
while(PacketsCount--) {
CountSkip=*(pSrc++);
pTmpDst+=CountSkip;
CountData=*(pSrc++);
if(CountData>0) {
while(CountData--) {
*(pTmpDst++)=*(pSrc++);
}
} else {
if(CountData<0) {
CountData=(0x100-CountData);
Fill=*(pSrc++);
while(CountData--) {
*(pTmpDst++)=Fill;
}
}
}
}
pDst+=flc.mainscreen->pitch;
}
} /* DECODE_LC */
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 */
void CMapReader::ReadBlockI(FILE *fp)
{
m_blockI = new SBlockI[m_header.numBlockI];
memset(m_blockI, 0, sizeof(SBlockI)*m_header.numBlockI);
SBlockI *b = m_blockI;
for(u32 i=0; i<m_header.numBlockI; i++, b++)
{
b->un0 = ReadU16(fp);
b->un1 = ReadU16(fp);
b->un2 = ReadU16(fp);
b->un3 = ReadU16(fp);
b->un4 = ReadU16(fp);
b->un5 = ReadU16(fp);
b->un6 = ReadU16(fp);
b->un7 = ReadU16(fp);
}
}
void CMapReader::ReadBlockR(FILE *fp)
{
m_blockR = new SBlockR[m_header.numBlockR];
memset(m_blockR, 0, sizeof(SBlockR)*m_header.numBlockR);
SBlockR *p = m_blockR;
for(u32 i=0; i<m_header.numBlockR; i++, p++)
{
p->un0 = ReadU16(fp);
p->un1 = ReadU16(fp);
p->un2 = ReadU16(fp);
p->un3 = ReadU16(fp);
p->un4 = ReadU16(fp);
p->un5 = ReadU16(fp);
p->un6 = ReadU16(fp);
p->un7 = ReadU16(fp);
}
}
void CMapReader::ReadBlockO(FILE *fp)
{
m_blockO = new SBlockO[m_header.numBlockO];
memset(m_blockO, 0, sizeof(SBlockO)*m_header.numBlockO);
SBlockO *p = m_blockO;
for(u32 i=0; i<m_header.numBlockO; i++, p++)
{
p->pos0X = ReadS16(fp);
p->pos0Y = ReadS16(fp);
p->pos0Z = ReadS16(fp);
p->pos1X = ReadS16(fp);
p->pos1Y = ReadS16(fp);
p->pos1Z = ReadS16(fp);
p->un0 = ReadU16(fp);
}
}
void Scene::Mesh::InitSpecific( const U8*& _pData ) {
m_LocalBBoxMin = float3::MaxFlt;
m_LocalBBoxMax = -float3::MaxFlt;
m_GlobalBBoxMin = float3::MaxFlt;
m_GlobalBBoxMax = -float3::MaxFlt;
m_PrimitivesCount = ReadU16( _pData );
m_pPrimitives = new Primitive[m_PrimitivesCount];
for ( int PrimitiveIndex=0; PrimitiveIndex < m_PrimitivesCount; PrimitiveIndex++ ) {
Primitive& P = m_pPrimitives[PrimitiveIndex];
P.Init( *this, _pData );
// Expand our own BBox
m_LocalBBoxMin = m_LocalBBoxMin.Min( P.m_LocalBBoxMin );
m_LocalBBoxMax = m_LocalBBoxMax.Max( P.m_LocalBBoxMax );
m_GlobalBBoxMin = m_GlobalBBoxMin.Min( P.m_GlobalBBoxMin );
m_GlobalBBoxMax = m_GlobalBBoxMax.Max( P.m_GlobalBBoxMax );
}
}
Scene::Node* Scene::CreateNode( Node* _pParent, const U8*& _pData ) {
Node* pResult = NULL;
Node::TYPE NodeType = (Node::TYPE) *_pData;
switch ( NodeType )
{
case Node::GENERIC:
pResult = new Node( *this, _pParent );
break;
case Node::LIGHT:
pResult = new Light( *this, _pParent );
break;
case Node::CAMERA:
pResult = new Camera( *this, _pParent );
break;
case Node::MESH:
pResult = new Mesh( *this, _pParent );
break;
// Special nodes
case Node::PROBE:
pResult = new Probe( *this, _pParent );
break;
default:
ASSERT( false, "Unsupported node type!" );
}
// Init the node
pResult->Init( _pData );
// Process children
pResult->m_ChildrenCount = ReadU16( _pData );
if ( pResult->m_ChildrenCount > 0 ) {
pResult->m_ppChildren = new Node*[pResult->m_ChildrenCount];
for ( int ChildIndex=0; ChildIndex < pResult->m_ChildrenCount; ChildIndex++ ) {
Node* pChild = CreateNode( pResult, _pData );
pResult->m_ppChildren[ChildIndex] = pChild;
}
}
return pResult;
}
void CMapReader::ReadTerrainCells(FILE *fp)
{
int num = 128*128;
m_terrainCells = new STerrainCell[num];
memset(m_terrainCells, 0, sizeof(STerrainCell)*num);
STerrainCell *c = m_terrainCells;
for(int i=0; i<num; i++, c++)
{
c->uvFace = ReadU16(fp);
c->un0 = ReadU16(fp);
c->un1 = ReadU16(fp);
c->vertHeight = ReadS16(fp);
c->un2 = ReadU16(fp);
c->un3 = ReadU16(fp);
c->un4 = ReadU16(fp);
c->un5 = ReadU16(fp);
c->un6 = ReadU16(fp);
}
}
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 */
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;
}
}
}
}
}
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;
}
String* DataInput::ReadUTF()
{
return ReadUTFBytes(ReadU16());
}
//队列等待线程
void rx_packet_thread(void *data)
{
while (1)
{
bus_os_pend_sem(&frame_q.sem, 0);
if (frame_q.size > 0)
{
//BUS_LOG("get a frame\r\n");
//从一级队列里面移动到数据结构里面去
bus_frame *frame = &frame_q.q[frame_q.readIdx++];
//看下这个帧是不是应答帧 如果是的 那么直接post就完了
if (frame->functionId == BUS_PACK_FUNC_ACK)
{
ack_map_post(frame->adapterId, frame->srcId, frame->sessionId);
frame_q.size--;
continue;
}
bus_put_frame(frame);
frame_q.size--;
//不断的寻找发送包 并且进行调用接收回调函数
if (rxHanleCnt > 0)
{
CPU_DEF();
PacketNode * get;
CPU_PEND();
get = bus_get_packet();
CPU_POST();
if (get)
{
rxHanleCnt--;
if (packet_q.size < 16)
{
bus_packet *packet = &packet_q.q[packet_q.writeIdx];
packet_q.writeIdx++;
u8 * data = my_malloc(get->packetLen);
//BUS_LOG("packlen = %d\r\n", get->packetLen);
packet->data = data;
packet->data_len = get->packetLen;
packet->adapterId = get->frameList->frame.adapterId;
packet->srcId = get->frameList->frame.srcId;
packet->desId = get->frameList->frame.desId;
packet->sessionId = get->frameList->frame.sessionId;
packet->functionId = get->frameList->frame.functionId;
CPU_PEND();
for (FrameNode *fp = get->frameList; fp != NULL;)
{
int frameIdx = ReadU16(fp->frame.data); //获取 帧索引
int frameLen = fp->frame.data_len - 2; //获取 数据长度 除掉帧索引
if (frameIdx != 0) // 第一帧不能做操作的
{
for (int i = 0; i < frameLen; i++)
{
data[(frameIdx - 1) * 6 + i] = fp->frame.data[i + 2];
}
}
//这个节点要删除
FrameNode *temp = fp;
fp = fp->next;
my_free(temp);
}
//把包引用也要free掉
my_free(get);
//压到 packet队列里面去 然后给信号量
packet_q.size++;
bus_os_post_sem(&packet_q.sem);
CPU_POST();
}
else
{
BUS_LOG("call back queue full\r\n");
}
}
}
}
}
}
void Scene::ReadEndMaterialMarker( const U8*& _pData )
{
U16 EndMarker = ReadU16( _pData );
ASSERT( EndMarker == 0x1234, "Failed to reach end material marker!" );
}
void Scene::ReadEndNodeMarker( const U8*& _pData )
{
U16 EndMarker = ReadU16( _pData );
ASSERT( EndMarker == 0xABCD, "Failed to reach end node marker!" );
}
