void CBone::SaveData(IWriter& F) { F.open_chunk (BONE_CHUNK_DEF); F.w_stringZ (name); F.close_chunk (); F.open_chunk (BONE_CHUNK_MATERIAL); F.w_stringZ (game_mtl); F.close_chunk (); F.open_chunk (BONE_CHUNK_SHAPE); F.w (&shape,sizeof(SBoneShape)); F.close_chunk (); F.open_chunk (BONE_CHUNK_FLAGS); F.w_u32 (IK_data.ik_flags.get()); F.close_chunk (); F.open_chunk (BONE_CHUNK_IK_JOINT); F.w_u32 (IK_data.type); F.w (IK_data.limits,sizeof(SJointLimit)*3); F.w_float (IK_data.spring_factor); F.w_float (IK_data.damping_factor); F.close_chunk (); F.open_chunk (BONE_CHUNK_IK_JOINT_BREAK); F.w_float (IK_data.break_force); F.w_float (IK_data.break_torque); F.close_chunk (); F.open_chunk (BONE_CHUNK_IK_JOINT_FRICTION); F.w_float (IK_data.friction); F.close_chunk (); F.open_chunk (BONE_CHUNK_MASS); F.w_float (mass); F.w_fvector3 (center_of_mass); F.close_chunk (); }
void ESceneWayTool::SaveSelection(IWriter& F) { F.w_chunk (CHUNK_VERSION,(u16*)&WAY_TOOLS_VERSION,sizeof(WAY_TOOLS_VERSION)); inherited::SaveSelection(F); }
int flv2rtmp() { srs_flv_t flv; int ret = 0; flv = srs_flv_open_read("./test.flv"); if(NULL == flv) { srs_human_trace("open flv file failed."); return 2; } char header[13]; if ((ret = srs_flv_read_header(flv, header)) != 0) { srs_human_trace("flv read header failed."); return ret; } u_int32_t timestamp=0; char type=0; int size=0; char* data = NULL; char* pRtmpUrl = (char*)"rtmp://101.201.146.134/hulu/w_test.flv"; bool bRunningFlag=true; #ifndef SEND_RTMP_BY_SRS_LIBRTMP IWriter* pRtmpWriter = CreateWriter(pRtmpUrl); pRtmpWriter->Open(pRtmpUrl, NULL); #else srs_rtmp_t ortmp = srs_rtmp_create(pRtmpUrl, &bRunningFlag); if ((ret = srs_rtmp_handshake(ortmp)) != 0) { srs_human_trace("ortmp simple handshake failed. ret=%d", ret); return ret; } srs_human_trace("ortmp simple handshake success"); if ((ret = srs_rtmp_connect_app(ortmp)) != 0) { srs_human_trace("ortmp connect vhost/app failed. ret=%d", ret); return ret; } srs_human_trace("ortmp connect vhost/app success"); if ((ret = srs_rtmp_publish_stream(ortmp)) != 0) { srs_human_trace("ortmp publish stream failed. ret=%d", ret); return ret; } srs_human_trace("ortmp publish stream success"); #endif for(;;) { // tag header if((ret = srs_flv_read_tag_header(flv, &type, &size, ×tamp)) != 0) { if (srs_flv_is_eof(ret)) { srs_human_trace("parse completed."); return 0; } srs_human_trace("flv get packet failed. ret=%d", ret); return ret; } srs_human_trace("read tag header typd:%d size:%d timestamp:%d. ", type, size, timestamp); if (size <= 0) { srs_human_trace("invalid size=%d", size); break; } data = (char*)malloc(size); if ((ret = srs_flv_read_tag_data(flv, data, size)) != 0) { return ret; } if ((ret = srs_human_print_rtmp_packet(type, timestamp, data, size)) != 0) { srs_human_trace("print packet failed. ret=%d timestamp%d", ret, timestamp); return ret; } #ifndef SEND_RTMP_BY_SRS_LIBRTMP if(8 == type) pushaudio(pRtmpWriter, ×tamp, data, size); else if(9 == type) pushvideo(pRtmpWriter, ×tamp, data, size); free(data); data=NULL; usleep(20*1000); #else if ((ret = srs_human_print_rtmp_packet(type, timestamp, data, size)) != 0) { srs_human_trace("print packet failed. ret=%d timestamp%d", ret, timestamp); return ret; } if ((ret = srs_rtmp_write_packet(ortmp, type, timestamp, data, size)) != 0) { srs_human_trace("irtmp get packet failed. ret=%d", ret); return ret; } usleep(20*1000); #endif } srs_flv_close(flv); }
void CSMotion::Save(IWriter& F) { CCustomMotion::Save(F); F.w_u16 (EOBJ_SMOTION_VERSION); F.w_s8 (m_Flags.get()); F.w_u16 (m_BoneOrPart); F.w_float (fSpeed); F.w_float (fAccrue); F.w_float (fFalloff); F.w_float (fPower); F.w_u16 ((u16)bone_mots.size()); for(BoneMotionIt bm_it=bone_mots.begin(); bm_it!=bone_mots.end(); bm_it++){ xr_strlwr (bm_it->name); F.w_stringZ (bm_it->name); F.w_u8 (bm_it->m_Flags.get()); for (int ch=0; ch<ctMaxChannel; ch++) bm_it->envs[ch]->Save(F); } #if 0 u32 sz = marks.size(); F.w_u32 (sz); for(u32 i=0; i<sz; ++i) marks[i].Save(&F); #else F.w_u32 (0); #endif }
void OGF::Save_Normal_PM (IWriter &fs, ogf_header& H, BOOL bVertexColored) { // clMsg ("- saving: normal or clod"); // Vertices fs.open_chunk (OGF_GCONTAINER); fs.w_u32 (vb_id); fs.w_u32 (vb_start); fs.w_u32 ((u32)vertices.size()); fs.w_u32 (ib_id); fs.w_u32 (ib_start); fs.w_u32 ((u32)faces.size()*3); fs.close_chunk (); // progressive-data, if need it if (H.type == MT_PROGRESSIVE){ // SW fs.open_chunk (OGF_SWIDATA ); fs.w_u32 (m_SWI.reserved[0] ); fs.w_u32 (m_SWI.reserved[1] ); fs.w_u32 (m_SWI.reserved[2] ); fs.w_u32 (m_SWI.reserved[3] ); fs.w_u32 (m_SWI.count ); fs.w (m_SWI.sw,m_SWI.count*sizeof(FSlideWindow)); fs.close_chunk (); } // if has x-vertices/x-faces if (x_vertices.size() && x_faces.size()) { fs.open_chunk (OGF_FASTPATH ); { // Vertices fs.open_chunk (OGF_GCONTAINER); fs.w_u32 (xvb_id); fs.w_u32 (xvb_start); fs.w_u32 ((u32)x_vertices.size()); fs.w_u32 (xib_id); fs.w_u32 (xib_start); fs.w_u32 ((u32)x_faces.size()*3); fs.close_chunk (); // progressive-data, if need it if (H.type == MT_PROGRESSIVE){ // SW fs.open_chunk (OGF_SWIDATA ); fs.w_u32 (x_SWI.reserved[0] ); fs.w_u32 (x_SWI.reserved[1] ); fs.w_u32 (x_SWI.reserved[2] ); fs.w_u32 (x_SWI.reserved[3] ); fs.w_u32 (x_SWI.count ); fs.w (x_SWI.sw,x_SWI.count*sizeof(FSlideWindow)); fs.close_chunk (); } } fs.close_chunk (); } }
void CPatrolPathStorage::save (IWriter &stream) { stream.open_chunk (0); stream.w_u32 (m_registry.size()); stream.close_chunk (); stream.open_chunk (1); PATROL_REGISTRY::iterator I = m_registry.begin(); PATROL_REGISTRY::iterator E = m_registry.end(); for (int i=0; I != E; ++I, ++i) { stream.open_chunk (i); stream.open_chunk (0); save_data ((*I).first,stream); stream.close_chunk (); stream.open_chunk (1); save_data ((*I).second,stream); stream.close_chunk (); stream.close_chunk (); } stream.close_chunk (); }
void EDetail::Save(IWriter& F) { // version F.open_chunk (DETOBJ_CHUNK_VERSION); F.w_u32 (DETOBJ_VERSION); F.close_chunk (); // reference F.open_chunk (DETOBJ_CHUNK_REFERENCE); F.w_stringZ (m_sRefs.c_str()); F.close_chunk (); // scale F.open_chunk (DETOBJ_CHUNK_SCALE_LIMITS); F.w_float (m_fMinScale); F.w_float (m_fMaxScale); F.close_chunk (); // density factor F.open_chunk (DETOBJ_CHUNK_DENSITY_FACTOR); F.w_float (m_fDensityFactor); F.close_chunk (); // flags F.open_chunk (DETOBJ_CHUNK_FLAGS); F.w_u32 (m_Flags.get()); F.close_chunk (); }
bool CInifile::save_as( LPCSTR new_fname ) { // save if needed if (new_fname&&new_fname[0]){ xr_free (fName); fName = xr_strdup(new_fname); } R_ASSERT (fName&&fName[0]); IWriter* F = FS.w_open_ex(fName); if (F){ string512 temp,val; for (RootIt r_it=DATA.begin(); r_it!=DATA.end(); ++r_it) { sprintf_s (temp,sizeof(temp),"[%s]",*(*r_it)->Name); F->w_string (temp); for (SectCIt s_it=(*r_it)->Data.begin(); s_it!=(*r_it)->Data.end(); ++s_it) { const Item& I = *s_it; if (*I.first) { if (*I.second) { _decorate (val,*I.second); #ifdef DEBUG if (*I.comment) { // name, value and comment sprintf_s (temp,sizeof(temp),"%8s%-32s = %-32s ;%s"," ",*I.first,val,*I.comment); } else #endif { // only name and value sprintf_s (temp,sizeof(temp),"%8s%-32s = %-32s"," ",*I.first,val); } } else { #ifdef DEBUG if (*I.comment) { // name and comment sprintf_s(temp,sizeof(temp),"%8s%-32s = ;%s"," ",*I.first,*I.comment); } else #endif { // only name sprintf_s(temp,sizeof(temp),"%8s%-32s = "," ",*I.first); } } } else { // no name, so no value #ifdef DEBUG if (*I.comment) sprintf_s (temp,sizeof(temp),"%8s;%s"," ",*I.comment); else #endif temp[0] = 0; } _TrimRight (temp); if (temp[0]) F->w_string (temp); } F->w_string (" "); } FS.w_close (F); return true; } return false; }
void SGameMtlPair::Save(IWriter& fs) { fs.open_chunk (GAMEMTLPAIR_CHUNK_PAIR); fs.w_u32 (mtl0); fs.w_u32 (mtl1); fs.w_u32 (ID); fs.w_u32 (ID_parent); fs.w_u32 (OwnProps.get()); fs.close_chunk (); // copy from parent if (ID_parent!=GAMEMTL_NONE_ID){ SGameMtlPair* P; if ((0!=(P=GetLastParentValue(this,flBreakingSounds)))&&(P!=this)) BreakingSounds = P->BreakingSounds; if ((0!=(P=GetLastParentValue(this,flStepSounds)))&&(P!=this)) StepSounds = P->StepSounds; if ((0!=(P=GetLastParentValue(this,flCollideSounds)))&&(P!=this)) CollideSounds = P->CollideSounds; if ((0!=(P=GetLastParentValue(this,flCollideParticles)))&&(P!=this)) CollideParticles= P->CollideParticles; if ((0!=(P=GetLastParentValue(this,flCollideMarks)))&&(P!=this)) CollideMarks = P->CollideMarks; } /* else{ OwnProps.zero(); if (!BreakingSounds.IsEmpty()) OwnProps.set(flBreakingSounds,TRUE); if (!StepSounds.IsEmpty()) OwnProps.set(flStepSounds,TRUE); if (!CollideSounds.IsEmpty()) OwnProps.set(flCollideSounds,TRUE); if (!CollideParticles.IsEmpty())OwnProps.set(flCollideParticles,TRUE); if (!CollideMarks.IsEmpty()) OwnProps.set(flCollideMarks,TRUE); } */ // save fs.open_chunk (GAMEMTLPAIR_CHUNK_BREAKING); fs.w_stringZ (BreakingSounds); fs.close_chunk (); fs.open_chunk (GAMEMTLPAIR_CHUNK_STEP); fs.w_stringZ (StepSounds); fs.close_chunk (); fs.open_chunk (GAMEMTLPAIR_CHUNK_COLLIDE); fs.w_stringZ (CollideSounds); fs.w_stringZ (CollideParticles); fs.w_stringZ (CollideMarks); fs.close_chunk (); }
void CBuild::Run (LPCSTR P) { if (strstr(Core.Params,"-att")) gl_linear = TRUE; //****************************************** Open Level strconcat (path,P,"\\") ; string_path lfn ; IWriter* fs = FS.w_open (strconcat(lfn,path,"level.")); fs->open_chunk (fsL_HEADER) ; hdrLEVEL H; H.XRLC_version = XRCL_PRODUCTION_VERSION; H.XRLC_quality = g_params.m_quality; fs->w (&H,sizeof(H)); fs->close_chunk (); //****************************************** Dumb entry in shader-registration RegisterShader (""); //****************************************** Saving lights { string256 fn; IWriter* fs = FS.w_open (strconcat(fn,pBuild->path,"build.lights")); fs->w_chunk (0,&*L_static.rgb.begin(),L_static.rgb.size()*sizeof(R_Light)); fs->w_chunk (1,&*L_static.hemi.begin(),L_static.hemi.size()*sizeof(R_Light)); fs->w_chunk (2,&*L_static.sun.begin(),L_static.sun.size()*sizeof(R_Light)); FS.w_close (fs); } //****************************************** Optimizing + checking for T-junctions FPU::m64r (); Phase ("Optimizing..."); mem_Compact (); PreOptimize (); CorrectTJunctions (); //****************************************** HEMI-Tesselate FPU::m64r (); Phase ("Adaptive HT..."); mem_Compact (); #ifndef CFORM_ONLY xrPhase_AdaptiveHT (); #endif //****************************************** Building normals FPU::m64r (); Phase ("Building normals..."); mem_Compact (); CalcNormals (); //SmoothVertColors (5); //****************************************** Collision DB //should be after normals, so that double-sided faces gets separated FPU::m64r (); Phase ("Building collision database..."); mem_Compact (); BuildCForm (); #ifdef CFORM_ONLY return; #endif BuildPortals (*fs); //****************************************** T-Basis { FPU::m64r (); Phase ("Building tangent-basis..."); xrPhase_TangentBasis (); mem_Compact (); } //****************************************** GLOBAL-RayCast model FPU::m64r (); Phase ("Building rcast-CFORM model..."); mem_Compact (); Light_prepare (); BuildRapid (TRUE); //****************************************** GLOBAL-ILLUMINATION if (b_radiosity) { FPU::m64r (); Phase ("Radiosity-Solver..."); mem_Compact (); Light_prepare (); xrPhase_Radiosity (); } //****************************************** Starting MU FPU::m64r (); Phase ("LIGHT: Starting MU..."); mem_Compact (); Light_prepare (); mu_base.start (xr_new<CMUThread> (0)); //****************************************** Resolve materials FPU::m64r (); Phase ("Resolving materials..."); mem_Compact (); xrPhase_ResolveMaterials (); IsolateVertices (TRUE); //****************************************** UV mapping { FPU::m64r (); Phase ("Build UV mapping..."); mem_Compact (); xrPhase_UVmap (); IsolateVertices (TRUE); } //****************************************** Subdivide geometry FPU::m64r (); Phase ("Subdividing geometry..."); mem_Compact (); xrPhase_Subdivide (); IsolateVertices (TRUE); //****************************************** All lighting + lmaps building and saving Light (); //****************************************** Merge geometry FPU::m64r (); Phase ("Merging geometry..."); mem_Compact (); xrPhase_MergeGeometry (); //****************************************** Convert to OGF FPU::m64r (); Phase ("Converting to OGFs..."); mem_Compact (); Flex2OGF (); //****************************************** Wait for MU FPU::m64r (); Phase ("LIGHT: Waiting for MU-thread..."); mem_Compact (); mu_base.wait (500); mu_secondary.wait (500); //****************************************** Export MU-models FPU::m64r (); Phase ("Converting MU-models to OGFs..."); mem_Compact (); { u32 m; Status ("MU : Models..."); for (m=0; m<mu_models.size(); m++) { mu_models[m]->calc_ogf (); mu_models[m]->export_geometry (); } Status ("MU : References..."); for (m=0; m<mu_refs.size(); m++) mu_refs[m]->export_ogf (); } //****************************************** Destroy RCast-model FPU::m64r (); Phase ("Destroying ray-trace model..."); mem_Compact (); xr_delete (RCAST_Model); //****************************************** Build sectors FPU::m64r (); Phase ("Building sectors..."); mem_Compact (); BuildSectors (); //****************************************** Saving MISC stuff FPU::m64r (); Phase ("Saving..."); mem_Compact (); SaveLights (*fs); fs->open_chunk (fsL_GLOWS); for (u32 i=0; i<glows.size(); i++) { b_glow& G = glows[i]; fs->w (&G,4*sizeof(float)); string1024 sid; strconcat (sid, shader_render[materials[G.dwMaterial].shader].name, "/", textures [materials[G.dwMaterial].surfidx].name ); fs->w_u16 (RegisterShader(sid)); } fs->close_chunk (); SaveTREE (*fs); SaveSectors (*fs); err_save (); }
//------------------------------------------------------------------------------ // IO - routines //------------------------------------------------------------------------------ void SGameMtl::Save(IWriter& fs) { Flags.set (flSlowDown, !fis_zero(1.f-fFlotationFactor,EPS_L)); Flags.set (flShootable, fis_zero(fShootFactor,EPS_L)); Flags.set (flTransparent, fis_zero(fVisTransparencyFactor,EPS_L)); Flags.set (flInjurious, !fis_zero(fInjuriousSpeed,EPS_L)); fs.open_chunk (GAMEMTL_CHUNK_MAIN); fs.w_u32 (ID); fs.w_stringZ (m_Name); fs.close_chunk (); fs.open_chunk (GAMEMTL_CHUNK_DESC); fs.w_stringZ (m_Desc); fs.close_chunk (); fs.open_chunk (GAMEMTL_CHUNK_FLAGS); fs.w_u32 (Flags.get()); fs.close_chunk (); fs.open_chunk (GAMEMTL_CHUNK_PHYSICS); fs.w_float (fPHFriction); fs.w_float (fPHDamping); fs.w_float (fPHSpring); fs.w_float (fPHBounceStartVelocity); fs.w_float (fPHBouncing); fs.close_chunk (); fs.open_chunk (GAMEMTL_CHUNK_FACTORS); fs.w_float (fShootFactor); fs.w_float (fBounceDamageFactor); fs.w_float (fVisTransparencyFactor); fs.w_float (fSndOcclusionFactor); fs.close_chunk (); fs.open_chunk (GAMEMTL_CHUNK_FACTORS_MP); fs.w_float (fShootFactorMP); fs.close_chunk (); fs.open_chunk (GAMEMTL_CHUNK_FLOTATION); fs.w_float (fFlotationFactor); fs.close_chunk (); fs.open_chunk (GAMEMTL_CHUNK_INJURIOUS); fs.w_float (fInjuriousSpeed); fs.close_chunk (); fs.open_chunk (GAMEMTL_CHUNK_DENSITY); fs.w_float (fDensityFactor); fs.close_chunk (); }
void EScenePSTools::SaveSelection(IWriter& F) { F.w_chunk (CHUNK_VERSION,(u16*)&PS_TOOLS_VERSION,sizeof(PS_TOOLS_VERSION)); inherited::SaveSelection(F); }
void CBone::Save(IWriter& F) { F.open_chunk (BONE_CHUNK_VERSION); F.w_u16 (BONE_VERSION); F.close_chunk (); F.open_chunk (BONE_CHUNK_DEF); F.w_stringZ (name); F.w_stringZ (parent_name); F.w_stringZ (wmap); F.close_chunk (); F.open_chunk (BONE_CHUNK_BIND_POSE); F.w_fvector3 (rest_offset); F.w_fvector3 (rest_rotate); F.w_float (rest_length); F.close_chunk (); SaveData (F); }
void CGroupObject::Save(IWriter& F) { CCustomObject::Save(F); F.open_chunk (GROUPOBJ_CHUNK_VERSION); F.w_u16 (GROUPOBJ_CURRENT_VERSION); F.close_chunk (); F.w_chunk (GROUPOBJ_CHUNK_FLAGS,&m_Flags,sizeof(m_Flags)); // objects if (IsOpened()){ F.open_chunk(GROUPOBJ_CHUNK_OPEN_OBJECT_LIST); F.w_u32 (m_Objects.size()); for (ObjectIt it=m_Objects.begin(); it!=m_Objects.end(); it++) F.w_stringZ ((*it)->Name); F.close_chunk (); }else{ Scene->SaveObjects(m_Objects,GROUPOBJ_CHUNK_OBJECT_LIST,F); } F.open_chunk (GROUPOBJ_CHUNK_REFERENCE); F.w_stringZ (m_ReferenceName); F.close_chunk (); }
void DviProtocolUpnpServiceXmlWriter::WriteStateVariable(IWriter& aWriter, const OpenHome::Net::Parameter& aParam, TBool aEvented, const Action* aAction) { aWriter.Write(Brn("<stateVariable sendEvents=")); if (aEvented) { aWriter.Write(Brn("\"yes\">")); } else { aWriter.Write(Brn("\"no\">")); } aWriter.Write(Brn("<name>")); if (aEvented) { aWriter.Write(aParam.Name()); } else { Bwh name; GetRelatedVariableName(name, aAction->Name(), aParam.Name()); aWriter.Write(name); } aWriter.Write(Brn("</name>")); aWriter.Write(Brn("<dataType>")); switch (aParam.Type()) { case OpenHome::Net::Parameter::eTypeBool: aWriter.Write(Brn("boolean")); break; case OpenHome::Net::Parameter::eTypeInt: aWriter.Write(Brn("i4")); break; case OpenHome::Net::Parameter::eTypeUint: aWriter.Write(Brn("ui4")); break; case OpenHome::Net::Parameter::eTypeString: aWriter.Write(Brn("string")); break; case OpenHome::Net::Parameter::eTypeBinary: aWriter.Write(Brn("bin.base64")); break; case OpenHome::Net::Parameter::eTypeRelated: ASSERTS(); break; } aWriter.Write(Brn("</dataType>")); switch (aParam.Type()) { case OpenHome::Net::Parameter::eTypeBool: case OpenHome::Net::Parameter::eTypeBinary: break; case OpenHome::Net::Parameter::eTypeInt: { const OpenHome::Net::ParameterInt& paramInt = static_cast<const OpenHome::Net::ParameterInt&>(aParam); if (paramInt.MinValue() != ParameterInt::kValueMin || paramInt.MaxValue() != ParameterInt::kValueMax || paramInt.Step() != ParameterInt::kStep) { aWriter.Write(Brn("<allowedValueRange>")); aWriter.Write(Brn("<minimum>")); WriterAscii writerAscii(aWriter); writerAscii.WriteInt(paramInt.MinValue()); aWriter.Write(Brn("</minimum>")); aWriter.Write(Brn("<maximum>")); writerAscii.WriteInt(paramInt.MaxValue()); aWriter.Write(Brn("</maximum>")); aWriter.Write(Brn("<step>")); writerAscii.WriteInt(paramInt.Step()); aWriter.Write(Brn("</step>")); aWriter.Write(Brn("</allowedValueRange>")); } } break; case OpenHome::Net::Parameter::eTypeUint: { const OpenHome::Net::ParameterUint& paramUint = static_cast<const OpenHome::Net::ParameterUint&>(aParam); if (paramUint.MinValue() != ParameterUint::kValueMin || paramUint.MaxValue() != ParameterUint::kValueMax || paramUint.Step() != ParameterUint::kStep) { aWriter.Write(Brn("<allowedValueRange>")); aWriter.Write(Brn("<minimum>")); WriterAscii writerAscii(aWriter); writerAscii.WriteUint(paramUint.MinValue()); aWriter.Write(Brn("</minimum>")); aWriter.Write(Brn("<maximum>")); writerAscii.WriteUint(paramUint.MaxValue()); aWriter.Write(Brn("</maximum>")); aWriter.Write(Brn("<step>")); writerAscii.WriteUint(paramUint.Step()); aWriter.Write(Brn("</step>")); aWriter.Write(Brn("</allowedValueRange>")); } } break; case OpenHome::Net::Parameter::eTypeString: { const OpenHome::Net::ParameterString& paramStr = static_cast<const OpenHome::Net::ParameterString&>(aParam); const ParameterString::Map& allowedVals = paramStr.AllowedValues(); if (allowedVals.size() > 0) { aWriter.Write(Brn("<allowedValueList>")); ParameterString::Map::const_iterator it = allowedVals.begin(); while (it != allowedVals.end()) { aWriter.Write(Brn("<allowedValue>")); aWriter.Write(*(it->second)); aWriter.Write(Brn("</allowedValue>")); it++; } aWriter.Write(Brn("</allowedValueList>")); } } break; case OpenHome::Net::Parameter::eTypeRelated: ASSERTS(); break; } aWriter.Write(Brn("</stateVariable>")); }
void ESceneSpawnTool::SaveSelection(IWriter& F) { F.w_chunk (CHUNK_VERSION,(u16*)&SPAWN_TOOLS_VERSION,sizeof(SPAWN_TOOLS_VERSION)); inherited::SaveSelection(F); }
void ESceneSectorTool::SaveSelection(IWriter& F) { F.w_chunk (CHUNK_VERSION,(u16*)&SECTOR_TOOLS_VERSION,sizeof(SECTOR_TOOLS_VERSION)); inherited::SaveSelection(F); }
void OGF_Reference::Save (IWriter &fs) { OGF_Base::Save (fs); // geom_batch_average (vertices.size(),faces.size()); // don't use reference(s) as batch estimate // Texture & shader std::string Tname; for (u32 i=0; i<textures.size(); i++) { if (!Tname.empty()) Tname += ','; string256 t; strcpy (t,*textures[i].name); if (strchr(t,'.')) *strchr(t,'.')=0; Tname += t; } string1024 sid ; strconcat (sid, pBuild->shader_render[pBuild->materials[material].shader].name, "/", Tname.c_str() ); // Create header ogf_header H; H.format_version = xrOGF_FormatVersion; H.type = model->m_SWI.count?MT_TREE_PM:MT_TREE_ST; H.shader_id = RegisterShader (sid); H.bb.min = bbox.min; H.bb.max = bbox.max; H.bs.c = C; H.bs.r = R; // Vertices fs.open_chunk (OGF_GCONTAINER); fs.w_u32 (vb_id); fs.w_u32 (vb_start); fs.w_u32 ((u32)model->vertices.size()); fs.w_u32 (ib_id); fs.w_u32 (ib_start); fs.w_u32 ((u32)model->faces.size()*3); fs.close_chunk (); // Special fs.open_chunk (OGF_TREEDEF2); fs.w (&xform, sizeof(xform)); fs.w (&c_scale, 5*sizeof(float)); fs.w (&c_bias, 5*sizeof(float)); fs.close_chunk (); // Header fs.open_chunk (OGF_HEADER); fs.w (&H,sizeof(H)); fs.close_chunk (); // progressive if (H.type==MT_TREE_PM){ // SW fs.open_chunk (OGF_SWICONTAINER); fs.w_u32 (sw_id); fs.close_chunk (); } }
void CPGDef::Save(IWriter& F) { F.open_chunk (PGD_CHUNK_VERSION); F.w_u16 (PGD_VERSION); F.close_chunk (); F.open_chunk (PGD_CHUNK_NAME); F.w_stringZ (m_Name); F.close_chunk (); F.w_chunk (PGD_CHUNK_FLAGS,&m_Flags,sizeof(m_Flags)); F.open_chunk (PGD_CHUNK_EFFECTS); F.w_u32 (m_Effects.size()); for (EffectIt it=m_Effects.begin(); it!=m_Effects.end(); it++){ F.w_stringZ ((*it)->m_EffectName); F.w_stringZ ((*it)->m_OnPlayChildName); F.w_stringZ ((*it)->m_OnBirthChildName); F.w_stringZ ((*it)->m_OnDeadChildName); F.w_float ((*it)->m_Time0); F.w_float ((*it)->m_Time1); F.w_u32 ((*it)->m_Flags.get()); } F.close_chunk (); F.open_chunk (PGD_CHUNK_TIME_LIMIT); F.w_float (m_fTimeLimit); F.close_chunk (); #ifdef _EDITOR F.open_chunk (PGD_CHUNK_OWNER); F.w_stringZ (m_OwnerName); F.w_stringZ (m_ModifName); F.w (&m_CreateTime,sizeof(m_CreateTime)); F.w (&m_ModifTime,sizeof(m_ModifTime)); F.close_chunk (); #endif }
void STextureParams::Save(IWriter& F) { F.open_chunk (THM_CHUNK_TEXTUREPARAM); F.w (&fmt,sizeof(ETFormat)); F.w_u32 (flags.get()); F.w_u32 (border_color); F.w_u32 (fade_color); F.w_u32 (fade_amount); F.w_u32 (mip_filter); F.w_u32 (width); F.w_u32 (height); F.close_chunk (); F.open_chunk (THM_CHUNK_TEXTURE_TYPE); F.w_u32 (type); F.close_chunk (); F.open_chunk (THM_CHUNK_DETAIL_EXT); F.w_stringZ (detail_name); F.w_float (detail_scale); F.close_chunk (); F.open_chunk (THM_CHUNK_MATERIAL); F.w_u32 (material); F.w_float (material_weight); F.close_chunk (); F.open_chunk (THM_CHUNK_BUMP); F.w_float (bump_virtual_height); F.w_u32 (bump_mode); F.w_stringZ (bump_name); F.close_chunk (); F.open_chunk (THM_CHUNK_EXT_NORMALMAP); F.w_stringZ (ext_normal_map_name); F.close_chunk (); F.open_chunk (THM_CHUNK_FADE_DELAY); F.w_u8 (fade_delay); F.close_chunk (); }
void ResourceTable::Write(const lemon::String & locale,IWriter & writer) const { std::string utf8 = lemon::to_utf8(locale); char localeString[5] = {0}; memset(localeString,0,5); size_t localeStringLength = utf8.size(); if(utf8.size() > 5) localeStringLength = 5; memcpy(localeString,utf8.c_str(),localeStringLength); writer.Write((const lemon::byte_t*)&localeString,5); //i18n -> l10n text table size lemon::uint16_t i18nTextTableSize = htons((lemon::uint16_t)_textTable.size()); writer.Write((const lemon::byte_t*)&i18nTextTableSize,sizeof(i18nTextTableSize)); //trace message table size lemon::uint16_t traceMessageTableSize = htons((lemon::uint16_t)_traceMessageTable.size()); writer.Write((const lemon::byte_t*)&traceMessageTableSize,sizeof(traceMessageTableSize)); //trace catalog table size lemon::uint16_t traceCatalogTableSize = htons((lemon::uint16_t)_traceCatalogTable.size()); writer.Write((const lemon::byte_t*)&traceCatalogTableSize,sizeof(traceCatalogTableSize)); //trace catalog table size lemon::uint16_t errorMessageTableSize = htons((lemon::uint16_t)_errorMessageTable.size()); writer.Write((const lemon::byte_t*)&errorMessageTableSize,sizeof(errorMessageTableSize)); // string table size lemon::uint16_t stringTableSize = htons((lemon::uint16_t)_stringTable.Items()); writer.Write((const lemon::byte_t*)&stringTableSize,sizeof(stringTableSize)); //i18n -> l10n text table { TextTable::const_iterator iter,end = _textTable.end(); for(iter = _textTable.begin() ; iter != end; ++ iter) { const I18nText & text = iter->second; lemon::uint32_t index = htonl(text.key); writer.Write((const lemon::byte_t*)&index,sizeof(index)); index = htonl(text.Message); writer.Write((const lemon::byte_t*)&index,sizeof(index)); } } //trace message table size { TraceMessageTable::const_iterator iter,end = _traceMessageTable.end(); for(iter = _traceMessageTable.begin() ; iter != end; ++ iter) { const TraceMessage & text = iter->second; lemon::uint32_t index = htonl(text.Id); writer.Write((const lemon::byte_t*)&index,sizeof(index)); index = htonl(text.Message); writer.Write((const lemon::byte_t*)&index,sizeof(index)); } } //trace catalog table size { TraceCatalogTable::const_iterator iter,end = _traceCatalogTable.end(); for(iter = _traceCatalogTable.begin() ; iter != end; ++ iter) { const TraceCatalog & text = iter->second; lemon::uint32_t index = htonl(text.Value); writer.Write((const lemon::byte_t*)&index,sizeof(index)); index = htonl(text.Name); writer.Write((const lemon::byte_t*)&index,sizeof(index)); index = htonl(text.Description); writer.Write((const lemon::byte_t*)&index,sizeof(index)); } } // error message { ErrorMessageTable::const_iterator iter,end = _errorMessageTable.end(); for(iter = _errorMessageTable.begin() ; iter != end; ++ iter) { const ErrorMessage & text = iter->second; lemon::uint32_t index = htonl(text.Code); writer.Write((const lemon::byte_t*)&index,sizeof(index)); index = htonl(text.Name); writer.Write((const lemon::byte_t*)&index,sizeof(index)); index = htonl(text.Description); writer.Write((const lemon::byte_t*)&index,sizeof(index)); } } // string table StringTable table; for(size_t i = 0 ; i < _stringTable.Items(); ++ i) { tuple<const lemon::byte_t*,size_t> result = _stringTable.Get((lemon::uint32_t)i); std::string utf8 = lemon::to_utf8((const char_t*)get<0>(result)); table.Push(__cbuf(utf8.c_str())); } table.Write(writer); }
void* h2642rtmp() { InitMediaCommon(NULL, NULL, NULL, NULL); char* h264file = (char*)"./test.h264"; char* pRtmpUrl = (char*)"rtmp://101.201.146.134/hulu/w_test.flv"; int ret = 0; u_int32_t timestamp=0; #ifndef SEND_RTMP_BY_SRS_LIBRTMP IWriter* pRtmpWriter = CreateWriter(pRtmpUrl); pRtmpWriter->Open(pRtmpUrl, NULL); #else srs_rtmp_t ortmp = srs_rtmp_create(pRtmpUrl, &bRunningFlag); if ((ret = srs_rtmp_handshake(ortmp)) != 0) { srs_human_trace("ortmp simple handshake failed. ret=%d", ret); return ret; } srs_human_trace("ortmp simple handshake success"); if ((ret = srs_rtmp_connect_app(ortmp)) != 0) { srs_human_trace("ortmp connect vhost/app failed. ret=%d", ret); return ret; } srs_human_trace("ortmp connect vhost/app success"); if ((ret = srs_rtmp_publish_stream(ortmp)) != 0) { srs_human_trace("ortmp publish stream failed. ret=%d", ret); return ret; } srs_human_trace("ortmp publish stream success"); #endif CVideoCodec* pVideoEncoder = CreateVideoCodec(kVideoCodecRAWH264, kEncoder); CVideoCodec* pVideoEncoderH264 = CreateVideoCodec(kVideoCodecH264, kEncoder); CVideoCodec* pVideoDecoder = CreateVideoCodec(kVideoCodecH264, kDecoder); I420Writer i420writer; i420writer.Open("./test.yuv"); CVideoFilter* pConvert = NULL; pConvert = CreateVideoFilter(kVideoFilterImageConvert); if(NULL == pConvert) { printf("create video filter for image convert failed.\r\n"); return NULL; } pConvert->Init(NULL); if (pVideoEncoder == NULL || NULL == pVideoDecoder) { printf("pVideoEncoder = NULL or pVideoDecoder = NULL\n"); return NULL; } VideoCodecParam encParam; memset(&encParam, 0, sizeof(VideoCodecParam)); encParam.encoder.iPicFormat = kCodecPictureRawH264; encParam.encoder.iFrameRate = FRAME_RATE; encParam.encoder.iWidth = VIDEO_W; encParam.encoder.iHeight = VIDEO_H; encParam.encoder.iMaxBitrate = 150; encParam.encoder.iStartBitrate = 150; encParam.encoder.iMinBitrate = 50; encParam.encoder.qpMax = 56; encParam.encoder.iProfile = kComplexityNormal; encParam.feedbackModeOn = false; encParam.numberofcores = 2; VideoCodecParam encParamYUV; memset(&encParamYUV, 0, sizeof(VideoCodecParam)); encParamYUV.encoder.iPicFormat = kCodecPictureFmtI420; encParamYUV.encoder.iFrameRate = FRAME_RATE; encParamYUV.encoder.iWidth = VIDEO_W; encParamYUV.encoder.iHeight = VIDEO_H; encParamYUV.encoder.iMaxBitrate = 650; encParamYUV.encoder.iStartBitrate = 650; encParamYUV.encoder.iMinBitrate = 50; encParamYUV.encoder.qpMax = 56; encParamYUV.encoder.iProfile = kComplexityNormal; encParamYUV.feedbackModeOn = false; encParamYUV.numberofcores = 2; VideoCodecParam decParam; memset(&decParam, 0, sizeof(VideoCodecParam)); decParam.feedbackModeOn = false; if(!pVideoEncoder->Init(&encParam)) { pVideoEncoder->DeInit(); } if(!pVideoEncoderH264->Init(&encParamYUV)) { pVideoEncoder->DeInit(); pVideoEncoderH264->DeInit(); } if(!pVideoDecoder->Init(&decParam)) { pVideoEncoder->DeInit(); pVideoEncoderH264->DeInit(); pVideoDecoder->DeInit(); } //---- struct timeval tv1; struct timeval tv2; FILE* f = fopen(h264file, "rb"); int frameLen = 100* 1024; uint8_t* frameBuffer= new uint8_t[frameLen]; memset(frameBuffer, 0, frameLen); int nFrame = 0; int TotalByte = 0; int count = 0; int pos = 0; do { int n = fread(frameBuffer + pos,1,frameLen-pos,f); printf("read file pos:%d n:%d. frameLen:%d\r\n", pos, n, frameLen); if(n <=0) { //wlj test break; fseek(f,0,SEEK_SET); printf("file end:\r\n"); n=0; pos=0; continue; } n +=pos ; pos = 0; int prefix; int nal_len = nal_length1(frameBuffer + pos, n, prefix); //printf("nal len:%d\r\n", nal_len); while(nal_len != n ){ FrameDesc frameDesc; frameDesc.iFrameType.h264 = kVideoUnknowFrame; frameDesc.iPreFramesMiss = false; frameDesc.iPts = nFrame * 1000/20; VideoEncodedList encoderList; memset(&encoderList, 0, sizeof(VideoEncodedList)); pVideoEncoder->Process(frameBuffer + pos, nal_len , &frameDesc, &encoderList); for (int i = 0; i < encoderList.iSize; ++i) { frameDesc.iFrameType = encoderList.iPicData[i].iFrameType; // printf("nal len:%d pos:%d frametype:%d\r\n", nal_len, pos, frameDesc.iFrameType); unsigned char* pData = (unsigned char*)encoderList.iPicData[i].iData; int iSize = encoderList.iPicData[i].iDataLen; PictureData pic; memset(&pic, 0, sizeof(PictureData)); pVideoDecoder->Process((const unsigned char*)pData, iSize, &frameDesc, &pic); if(0<pic.iPlaneData) { printf("pic info fmt:%d s1:%d s2:%d s3:%d s4:%d po1:%d po2:%d po3:%d po4:%d w:%d h:%d size:%d tt:%d\r\n", pic.iFormat, pic.iStrides[0], pic.iStrides[1],pic.iStrides[2],pic.iStrides[3], pic.iPlaneOffset[0], pic.iPlaneOffset[1], pic.iPlaneOffset[2], pic.iPlaneOffset[3], pic.iWidth, pic.iHeight, pic.iPlaneDataSize, pic.timestamp ); //convert (s:512 w:480 h:640 size=s*1.5*h) to s:128: w:120 h:80 PictureData picDst; int iDstWidth=120; int iDstHeight=160; int iDstStrideY = 120; int iDstStrideUV = 60; int iDstDataSize = iDstStrideY*iDstHeight*3/2; unsigned char* pDstData = (unsigned char*)malloc(iDstDataSize); int iSrcWidth = pic.iWidth; int iSrcHeight = pic.iHeight; int iSrcStrideY = iSrcWidth; int iSrcStrideUV = iSrcStrideY/2; int iSrcDataSize = iSrcWidth*iSrcHeight*3/2; unsigned char* pSrcData = (unsigned char*)malloc(iSrcDataSize); int iPosCur=0; int i=0; for(i=0;i<iSrcHeight; i++) { memcpy(pSrcData+iPosCur, (unsigned char*)pic.iPlaneData+i*pic.iStrides[0], iSrcWidth); iPosCur+=iSrcWidth; } for(i=0;i<iSrcHeight; i++) { memcpy(pSrcData+iPosCur, (unsigned char*)pic.iPlaneData+pic.iStrides[0]*iSrcHeight+i*pic.iStrides[1], iSrcStrideUV); iPosCur+=(iSrcStrideUV); } ImageConvertContext context; context.imageSrc.format = kCodecPictureFmtI420; context.imageSrc.width = iSrcWidth; context.imageSrc.height = iSrcHeight; context.imageSrc.stride[0] = iSrcStrideY; context.imageSrc.stride[1] = iSrcStrideUV; context.imageSrc.stride[2] = iSrcStrideUV; context.imageSrc.stride[3] = 0; context.imageSrc.plane[0] = (((unsigned char*)(pSrcData))); context.imageSrc.plane[1] = (((unsigned char*)(pSrcData))+iSrcWidth*iSrcHeight); context.imageSrc.plane[2] = (((unsigned char*)(pSrcData))+(iSrcWidth*iSrcHeight+iSrcStrideUV*iSrcHeight/2)); // context.imageSrc.plane[0] = (((unsigned char*)(pic.iPlaneData))+pic.iPlaneOffset[0]); // context.imageSrc.plane[1] = (((unsigned char*)(pic.iPlaneData))+pic.iPlaneOffset[1]); // context.imageSrc.plane[2] = (((unsigned char*)(pic.iPlaneData))+pic.iPlaneOffset[2]); context.imageSrc.plane[3] = NULL; context.imageDst.format = kCodecPictureFmtI420; context.imageDst.width = iDstWidth; context.imageDst.height = iDstHeight; context.imageDst.stride[0] = iDstStrideY; context.imageDst.stride[1] = iDstStrideUV; context.imageDst.stride[2] = iDstStrideUV; context.imageDst.stride[3] = 0; context.imageDst.plane[0] = pDstData; context.imageDst.plane[1] = pDstData+iDstStrideY*iDstHeight; context.imageDst.plane[2] = pDstData+iDstStrideY*iDstHeight+iDstStrideUV*iDstHeight/2; context.imageDst.plane[3] = NULL; gettimeofday(&tv1, NULL); pConvert->Process(&context); gettimeofday(&tv2, NULL); printf("convert pic srcw:%d srch:%d dstw:%d dsth:%d used:%dus.\r\n", iSrcWidth, iSrcHeight, iDstWidth, iDstHeight, ((tv2.tv_sec*1000*1000+tv2.tv_usec)-(tv1.tv_sec*1000*1000+tv1.tv_usec))); gettimeofday(&tv1, NULL); VideoMix(pSrcData, iSrcDataSize, iSrcWidth, iSrcHeight, pDstData, iDstDataSize, iDstWidth, iDstHeight, iDstStrideY, iDstStrideUV); gettimeofday(&tv2, NULL); printf("mix pic srcw:%d srch:%d dstw:%d dsth:%d dstcount:3 used:%dus.\r\n", iSrcWidth, iSrcHeight, iDstWidth, iDstHeight, ((tv2.tv_sec*1000*1000+tv2.tv_usec)-(tv1.tv_sec*1000*1000+tv1.tv_usec))); VideoEncodedList velist; //encode yuv data to h264 data YUV2H264(pVideoEncoderH264, pSrcData, iSrcDataSize, iSrcWidth, iSrcHeight, 16, &velist ); printf("yuv2h264 datasize:%d w:%d h:%d listsize:%d\r\n", iSrcDataSize, iSrcWidth, iSrcHeight, velist.iSize); //send h264 data to rtmp server for(int ii=0;ii<velist.iSize;ii++) { pushvideoEx(pRtmpWriter,velist.iPicData+ii ); free(velist.iPicData[ii].iData); } //write yuv data to file //i420writer.Write((const char*)pSrcData, iSrcDataSize); //i420writer.Write((const char*)pDstData, iDstDataSize); //i420writer.Write((const char*)pic.iPlaneData, pic.iPlaneDataSize); free(pic.iPlaneData); } //wlj // pushvideoEx(pRtmpWriter, encoderList.iPicData+i); // free(encoderList.iPicData[i].iData); TotalByte += encoderList.iPicData[i].iDataLen; } free(encoderList.iPicData); nFrame++; usleep(5*1000); pos += nal_len; n -= nal_len; nal_len = nal_length1(frameBuffer + pos, n, prefix); } memmove(frameBuffer, frameBuffer + pos, n); pos=n; } while (count++ < 1000); i420writer.Close(); if(pVideoEncoder) { ReleaseVideoCodec(pVideoEncoder); } if(NULL != pVideoDecoder) ReleaseVideoCodec(pVideoDecoder); fclose(f); return NULL; }
bool AudioFormat_WAVE::encode(const Wave& wave, IWriter& writer, const WAVEFormat format) const { if (!wave || !writer.isOpened()) { return false; } const uint16 bitsWidth = format == WAVEFormat::Stereo8U ? 1 : format == WAVEFormat::Stereo16S ? 2 : 4; const uint16 channels = 2; const uint32 sampleRate = wave.samplingRate(); const size_t waveSize = wave.size() * channels * bitsWidth; const uint32 headerSize = sizeof(RiffHeader) + sizeof(ChunkHeader) + sizeof(FormatHeader) + sizeof(ChunkHeader); const RiffHeader riffHeader { { 'R', 'I', 'F', 'F' }, static_cast<uint32>(waveSize + headerSize - 8), { 'W', 'A', 'V', 'E' }, }; const ChunkHeader chunkHeader1 { { 'f', 'm', 't', ' ' }, sizeof(FormatHeader), }; const FormatHeader formatHeader { uint16((format == WAVEFormat::Stereo32F) ? WAVE_FORMAT_IEEE_FLOAT : 1), channels, sampleRate, sampleRate * bitsWidth * channels, uint16(bitsWidth * channels), uint16(bitsWidth * 8), }; const ChunkHeader chunkHeader2 { { 'd', 'a', 't', 'a' }, static_cast<uint32>(waveSize), }; writer.write(&riffHeader, sizeof(riffHeader)); writer.write(&chunkHeader1, sizeof(chunkHeader1)); writer.write(&formatHeader, sizeof(formatHeader)); writer.write(&chunkHeader2, sizeof(chunkHeader2)); if (format == WAVEFormat::Stereo8U) { size_t samplesToWrite = wave.size(); const uint32 bufferSize = 16384; Array<WS8bit> buffer(bufferSize); const WaveSample* pSrc = &wave[0]; for (;;) { WS8bit* pDst = buffer.data(); if (samplesToWrite > bufferSize) { for (uint32 i = 0; i < bufferSize; ++i) { pDst->left = static_cast<uint8>((pSrc->left + 1.0f) * 127.999f); pDst->right = static_cast<uint8>((pSrc->right + 1.0f) * 127.999f); ++pDst; ++pSrc; } writer.write(buffer.data(), bufferSize * sizeof(WS8bit)); samplesToWrite -= bufferSize; } else { for (uint32 i = 0; i < samplesToWrite; ++i) { pDst->left = static_cast<uint8>((pSrc->left + 1.0f) * 127.999f); pDst->right = static_cast<uint8>((pSrc->right + 1.0f) * 127.999f); ++pDst; ++pSrc; } writer.write(buffer.data(), samplesToWrite * sizeof(WS8bit)); break; } } } else if (format == WAVEFormat::Stereo16S) { size_t samplesToWrite = wave.size(); const uint32 bufferCount = 16384; Array<WaveSampleS16> buffer(bufferCount); const WaveSample* pSrc = &wave[0]; for (;;) { WaveSampleS16* pDst = buffer.data(); if (samplesToWrite > bufferCount) { for (uint32 i = 0; i < bufferCount; ++i) { pDst->left = static_cast<int16>(pSrc->left * 32767.0f); pDst->right = static_cast<int16>(pSrc->right * 32767.0f); ++pDst; ++pSrc; } writer.write(buffer.data(), bufferCount * sizeof(WaveSampleS16)); samplesToWrite -= bufferCount; } else { for (uint32 i = 0; i < samplesToWrite; ++i) { pDst->left = static_cast<int16>(pSrc->left * 32767.0f); pDst->right = static_cast<int16>(pSrc->right * 32767.0f); ++pDst; ++pSrc; } writer.write(buffer.data(), samplesToWrite * sizeof(WaveSampleS16)); break; } } } else { writer.write(wave.data(), waveSize); } return true; }
//mix two wav file to a wav file void test_mixwave() { InitMediaCommon(NULL, NULL, NULL, NULL); CAudioCodec* pAudioEncoder = CreateAudioCodec(kAudioCodecFDKAAC, kEncoder); if(NULL == pAudioEncoder) { printf("create audio decoder failed. codec type: kAudioCodecFDKAAC.\r\n"); return; } AudioCodecParam audioFormat; audioFormat.iSampleRate = 44100; audioFormat.iBitsOfSample=16; audioFormat.iNumOfChannels = 2; audioFormat.iQuality = 5; audioFormat.iProfile = 29; audioFormat.iHaveAdts = 1; audioFormat.ExtParam.iUsevbr = true; audioFormat.ExtParam.iUsedtx = true; audioFormat.ExtParam.iCvbr = true; audioFormat.ExtParam.iUseInbandfec = true; audioFormat.ExtParam.iPacketlossperc = 25; audioFormat.ExtParam.iComplexity = 8; audioFormat.ExtParam.iFrameDuration = 20*10; if(NULL == pAudioEncoder->Init(&audioFormat)) { printf("init audio decoder failed.\r\n"); return; } int iEncOutSize=0; pAudioEncoder->CalcBufSize(&iEncOutSize, 0); unsigned char* pAudioEncBuf = (unsigned char*)malloc(iEncOutSize); char* pRtmpUrl = (char*)"rtmp://101.201.146.134/hulu/w_test.flv"; int ret = 0; int iAudioFramePos=0; u_int32_t timestamp=0; IWriter* pRtmpWriter = CreateWriter(pRtmpUrl); pRtmpWriter->Open(pRtmpUrl, NULL); int input_size = 2*2*2048; AudioStreamFormat asf; asf.flag = 0; asf.sampleRate = 44100; asf.sampleBits= 16; asf.channelNum = 2; int iAudioTS = 0; double iAudioFrameBufLen = (double)asf.sampleRate * asf.channelNum * asf.sampleBits /8/1000; double dAudioFrameTSLen = (double)input_size/iAudioFrameBufLen; AudioMixer* pAMix = AudioMixer::CreateAudioMixer(asf, 2); //open wav file int format, sample_rate, channels, bits_per_sample; uint8_t* input_buf_1 = (uint8_t*) malloc(input_size); int16_t* convert_buf_1 = (int16_t*) malloc(input_size); uint8_t* input_buf_2 = (uint8_t*) malloc(input_size); int16_t* convert_buf_2 = (int16_t*) malloc(input_size); uint8_t* output_buf = (uint8_t*) malloc(input_size); AudioMixer::AudioDataInfo adInfo[2]; const char* pwavfilename1="input1.wav"; const char* pwavfilename2="input2.wav"; void *wav1= wav_read_open(pwavfilename1); void *wav2= wav_read_open(pwavfilename2); FILE *pfOutWav = fopen("output.pcm", "wb");; if (NULL != wav1) { printf("open wav file %s ok\n", pwavfilename1); if (!wav_get_header(wav1, &format, &channels, &sample_rate, &bits_per_sample, NULL)) { return ; } if (format != 1 || bits_per_sample != 16) { printf("Unsupported WAV format %d\n", format); return ; } } if (NULL != wav2) { printf("open wav file %s ok\n", pwavfilename1); if (!wav_get_header(wav2, &format, &channels, &sample_rate, &bits_per_sample, NULL)) { return ; } if (format != 1 || bits_per_sample != 16) { printf("Unsupported WAV format %d\n", format); return ; } } int read1 = 0; int read2 = 0; if(wav1) { //this data is for offset read1 = wav_read_data(wav1, input_buf_1, input_size); read1 = wav_read_data(wav1, input_buf_1, input_size); read1 = wav_read_data(wav1, input_buf_1, input_size); read1 = wav_read_data(wav1, input_buf_1, input_size); read1 = wav_read_data(wav1, input_buf_1, input_size); } struct timeval tv1; struct timeval tv2; //read wav file and mix wav file while (1) { if(wav1) read1 = wav_read_data(wav1, input_buf_1, input_size); if(wav1 && read1 <= 0) { break; } else if(read1 <=0 ){ memset(input_buf_1,0,input_size); } /* //not use is ok for (int i = 0; i < read1/2; i++) { const uint8_t* in = &input_buf_1[2*i]; convert_buf_1[i] = in[0] | (in[1] << 8); } */ if(wav2) read2 = wav_read_data(wav2, input_buf_2, input_size); if(wav2 && read2 <= 0) break; else if(read2 <=0 ){ memset(input_buf_2,0,input_size); } /* //not use is ok for (int i = 0; i < read2/2; i++) { const uint8_t* in = &input_buf_2[2*i]; convert_buf_2[i] = in[0] | (in[1] << 8); } */ adInfo[0]._bufferSize = adInfo[0]._leftLength = input_size; adInfo[0]._leftData = input_buf_1; adInfo[0]._enabled = true; adInfo[1]._bufferSize = adInfo[1]._leftLength = input_size; adInfo[1]._leftData = input_buf_2; adInfo[1]._enabled = true; int packetLen = channels*bits_per_sample/8; int packnum = input_size/packetLen; gettimeofday(&tv1, NULL); pAMix->MixData(output_buf, packnum, packetLen, 0, adInfo, 2); gettimeofday(&tv2, NULL); printf("mix wav file len:%d used:%dus.\r\n", input_size, ((tv2.tv_sec*1000*1000+tv2.tv_usec)-(tv1.tv_sec*1000*1000+tv1.tv_usec))); //printf("mix data read1:%d read2:%d input_size:%d\r\n", read1, read2, input_size); //write output wav file // fwrite(output_buf, 1, input_size, pfOutWav); //encoder to fdkaac for (int i = 0; i < input_size/2; i++) { const uint8_t* in = &output_buf[2*i]; convert_buf_1[i] = in[0] | (in[1] << 8); } int iAudioEncBufLen = iEncOutSize; pAudioEncoder->Process((unsigned char*)convert_buf_1, input_size, pAudioEncBuf, &iAudioEncBufLen); //send it to rtmp server timestamp = iAudioFramePos * dAudioFrameTSLen; pushaudio(pRtmpWriter, ×tamp, (char*)convert_buf_1, iAudioEncBufLen); printf("push audio framePos:%d wavlen:%d timestamp:%d enclen:%d frametslen:%f\r\n", iAudioFramePos, input_size, timestamp, iAudioEncBufLen, dAudioFrameTSLen); iAudioFramePos++; usleep(40*1000); } if(wav1) wav_read_close(wav1); if(wav2) wav_read_close(wav2); if(pfOutWav) fclose(pfOutWav); }
void ESceneWayTool::SaveStream(IWriter& F) { inherited::SaveStream(F); F.w_chunk (CHUNK_VERSION,(u16*)&WAY_TOOLS_VERSION,sizeof(WAY_TOOLS_VERSION)); }
void CClip::Save(IWriter& F) { F.open_chunk (EOBJ_CLIP_VERSION_CHUNK); F.w_u16 (EOBJ_CLIP_VERSION); F.close_chunk (); F.open_chunk (EOBJ_CLIP_DATA_CHUNK); F.w_stringZ (name); for (int k=0; k<4; k++){ F.w_stringZ (cycles[k].name); F.w_u16 (cycles[k].slot); } F.w_stringZ (fx.name); F.w_u16 (fx.slot); F.w_float (fx_power); F.w_float (length); F.close_chunk (); }
void write( IWriter &w, const CDB::TRI &tri ) { w.w_u32( tri.verts[ 0 ] ); w.w_u32( tri.verts[ 1 ] ); w.w_u32( tri.verts[ 2 ] ); }