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!" ); }