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 ] );
}
