自学教程：C++ ASObject类代码示例

ASFUNCTIONBODY(Array,forEach){	Array* th=static_cast<Array*>(obj);	_NR<IFunction> f;	ARG_UNPACK(f);	if (f.isNull())		return NULL;	ASObject* params[3];	std::map<uint32_t, data_slot>::iterator it=th->data.begin();	for(;it != th->data.end();++it)	{		assert_and_throw(it->second.type==DATA_OBJECT);		params[0] = it->second.data;		it->second.data->incRef();		params[1] = abstract_i(it->first);		params[2] = th;		th->incRef();		ASObject *funcret;		if( argslen == 1 )		{			funcret=f->call(getSys()->getNullRef(), params, 3);		}		else		{			args[1]->incRef();			funcret=f->call(args[1], params, 3);		}		if(funcret)			funcret->decRef();	}	return NULL;}

bool ASObject::hasPropertyByMultiname(const multiname& name, bool considerDynamic){	//We look in all the object's levels	uint32_t validTraits=DECLARED_TRAIT;	if(considerDynamic)		validTraits|=DYNAMIC_TRAIT;	if(Variables.findObjVar(name, NO_CREATE_TRAIT, validTraits)!=NULL)		return true;	if(classdef && classdef->Variables.findObjVar(name, NO_CREATE_TRAIT, BORROWED_TRAIT)!=NULL)		return true;	//Check prototype inheritance chain	if(getClass())	{		ASObject* proto = getClass()->prototype.getPtr();		while(proto)		{			if(proto->findGettable(name, false) != NULL)				return true;			proto = proto->getprop_prototype();		}	}	//Must not ask for non borrowed traits as static class member are not valid	return false;}

ASFUNCTIONBODY(ASObject,propertyIsEnumerable){	assert_and_throw(argslen==1);	multiname name;	name.name_type=multiname::NAME_STRING;	name.name_s=args[0]->toString();	name.ns.push_back(nsNameAndKind("",NAMESPACE));	name.isAttribute=false;	unsigned int index = 0;	if (obj->is<Array>()) // propertyIsEnumerable(index) isn't mentioned in the ECMA specs but is tested for	{		Array* a = static_cast<Array*>(obj);		if (a->isValidMultiname(name,index))		{			return abstract_b(index < (unsigned int)a->size());		}	}	if(obj->getClass())	{		ASObject* proto = obj->getClass()->prototype.getPtr();		if  (proto->hasPropertyByMultiname(name, true))			return abstract_b(false);	}	if (obj->hasPropertyByMultiname(name,true))		return abstract_b(true);	return abstract_b(false);}

ASFUNCTIONBODY(JSON,_stringify){	_NR<ASObject> value;	ARG_UNPACK(value);	std::vector<ASObject *> path;	tiny_string filter;	IFunction* replacer = NULL;	if (argslen > 1 && !args[1]->is<Null>() && !args[1]->is<Undefined>())	{		if (args[1]->is<IFunction>())		{			replacer = args[1]->as<IFunction>();		}		else if (args[1]->is<Array>())		{			filter = " ";			Array* ar = args[1]->as<Array>();			for (uint64_t i = 0; i < ar->size(); i++)			{				filter += ar->at(i)->toString();				filter += " ";			}		}		else			throwError<TypeError>(kJSONInvalidReplacer);	}	tiny_string spaces = "";	if (argslen > 2)	{		ASObject* space = args[2];		spaces = "          ";		if (space->is<Number>() || space->is<Integer>() || space->is<UInteger>())		{			int32_t v = space->toInt();			if (v < 0) v = 0;			if (v > 10) v = 10;			spaces = spaces.substr_bytes(0,v);		}		else if (space->is<Boolean>() || space->is<Null>())		{			spaces = "";		}		else		{			if(space->has_toString())			{				_R<ASObject> ret = space->call_toString();				spaces = ret->toString();			}			else				spaces = space->toString();			if (spaces.numBytes() > 10)				spaces = spaces.substr_bytes(0,10);		}	}	tiny_string res = value->toJSON(path,replacer,spaces,filter);	return Class<ASString>::getInstanceS(res);}

ASFUNCTIONBODY(Array,forEach){	assert_and_throw(argslen == 1 || argslen == 2);	Array* th=static_cast<Array*>(obj);	IFunction* f = static_cast<IFunction*>(args[0]);	ASObject* params[3];	for(unsigned int i=0; i < th->data.size(); i++)	{		assert_and_throw(th->data[i].type==DATA_OBJECT);		params[0] = th->data[i].data;		th->data[i].data->incRef();		params[1] = abstract_i(i);		params[2] = th;		th->incRef();		ASObject *funcret;		if( argslen == 1 )		{			funcret=f->call(new Null, params, 3);		}		else		{			args[1]->incRef();			funcret=f->call(args[1], params, 3);		}		if(funcret)			funcret->decRef();	}	return NULL;}

tiny_string Vector::toJSON(std::vector<ASObject *> &path, IFunction *replacer, const tiny_string &spaces, const tiny_string &filter){	bool ok;	tiny_string res = call_toJSON(ok,path,replacer,spaces,filter);	if (ok)		return res;	// check for cylic reference	if (std::find(path.begin(),path.end(), this) != path.end())		throwError<TypeError>(kJSONCyclicStructure);	path.push_back(this);	res += "[";	bool bfirst = true;	tiny_string newline = (spaces.empty() ? "" : "/n");	for (unsigned int i =0;  i < vec.size(); i++)	{		tiny_string subres;		ASObject* o = vec[i];		if (!o)			o = getSystemState()->getNullRef();		if (replacer != NULL)		{			ASObject* params[2];						params[0] = abstract_di(getSystemState(),i);			params[0]->incRef();			params[1] = o;			params[1]->incRef();			ASObject *funcret=replacer->call(getSystemState()->getNullRef(), params, 2);			if (funcret)				subres = funcret->toJSON(path,NULL,spaces,filter);		}		else		{			subres = o->toJSON(path,replacer,spaces,filter);		}		if (!subres.empty())		{			if (!bfirst)				res += ",";			res += newline+spaces;						bfirst = false;			res += subres;		}	}	if (!bfirst)		res += newline+spaces.substr_bytes(0,spaces.numBytes()/2);	res += "]";	path.pop_back();	return res;}

ASFUNCTIONBODY(Vector, every){	Vector* th=static_cast<Vector*>(obj);	if (argslen < 1)		throwError<ArgumentError>(kWrongArgumentCountError, "Vector.some", "1", Integer::toString(argslen));	if (!args[0]->is<IFunction>())		throwError<TypeError>(kCheckTypeFailedError, args[0]->getClassName(), "Function");	IFunction* f = static_cast<IFunction*>(args[0]);	ASObject* params[3];	ASObject *funcRet;	for(unsigned int i=0; i < th->size(); i++)	{		if (th->vec[i])		{			params[0] = th->vec[i];			th->vec[i]->incRef();		}		else			params[0] = obj->getSystemState()->getNullRef();		params[1] = abstract_i(obj->getSystemState(),i);		params[2] = th;		th->incRef();		if(argslen==1)		{			funcRet=f->call(obj->getSystemState()->getNullRef(), params, 3);		}		else		{			args[1]->incRef();			funcRet=f->call(args[1], params, 3);		}		if(funcRet)		{			if (funcRet->is<Undefined>() || funcRet->is<Null>())				throwError<TypeError>(kCallOfNonFunctionError, funcRet->toString());			if(!Boolean_concrete(funcRet))			{				return funcRet;			}			funcRet->decRef();		}	}	return abstract_b(obj->getSystemState(),true);}

ASFUNCTIONBODY(Vector, every){	Vector* th=static_cast<Vector*>(obj);	if (argslen < 1)		throw Class<ArgumentError>::getInstanceS("Error #1063");	if (!args[0]->is<IFunction>())		throw Class<TypeError>::getInstanceS("Error #1034"); 	IFunction* f = static_cast<IFunction*>(args[0]);	ASObject* params[3];	ASObject *funcRet;	for(unsigned int i=0; i < th->size(); i++)	{		if (th->vec[i])		{			params[0] = th->vec[i];			th->vec[i]->incRef();		}		else			params[0] = getSys()->getNullRef();		params[1] = abstract_i(i);		params[2] = th;		th->incRef();		if(argslen==1)		{			funcRet=f->call(getSys()->getNullRef(), params, 3);		}		else		{			args[1]->incRef();			funcRet=f->call(args[1], params, 3);		}		if(funcRet)		{			if (funcRet->is<Undefined>() || funcRet->is<Null>())				throw Class<TypeError>::getInstanceS("Error #1006");			if(!Boolean_concrete(funcRet))			{				return funcRet;			}			funcRet->decRef();		}	}	return abstract_b(true);}

ASObject* ASObject::getValueAt(int index){	obj_var* obj=Variables.getValueAt(index);	assert_and_throw(obj);	ASObject* ret;	if(obj->getter)	{		//Call the getter		LOG(LOG_CALLS,_("Calling the getter"));		IFunction* getter=obj->getter->getOverride();		incRef();		ret=getter->call(this,NULL,0);		ret->fake_decRef();		LOG(LOG_CALLS,_("End of getter"));	}	else		ret=obj->var;	return ret;}

ASFUNCTIONBODY(Vector, some){	if (argslen < 1)		throw Class<ArgumentError>::getInstanceS("Error #1063");	if (!args[0]->is<IFunction>())		throw Class<TypeError>::getInstanceS("Error #1034"); 	Vector* th=static_cast<Vector*>(obj);	IFunction* f = static_cast<IFunction*>(args[0]);	ASObject* params[3];	ASObject *funcRet;	for(unsigned int i=0; i < th->size(); i++)	{		if (!th->vec[i])			continue;		params[0] = th->vec[i];		th->vec[i]->incRef();		params[1] = abstract_i(i);		params[2] = th;		th->incRef();		if(argslen==1)		{			funcRet=f->call(new Null, params, 3);		}		else		{			args[1]->incRef();			funcRet=f->call(args[1], params, 3);		}		if(funcRet)		{			if(Boolean_concrete(funcRet))			{				return funcRet;			}			funcRet->decRef();		}	}	return abstract_b(false);}

ASObject* Vector::generator(TemplatedClass<Vector>* o_class, ASObject* const* args, const unsigned int argslen){	assert_and_throw(argslen == 1);	assert_and_throw(args[0]->getClass());	assert_and_throw(o_class->getTypes().size() == 1);	Type* type = o_class->getTypes()[0];	if(args[0]->getClass() == Class<Array>::getClass())	{		//create object without calling _constructor		Vector* ret = o_class->getInstance(false,NULL,0);		Array* a = static_cast<Array*>(args[0]);		for(unsigned int i=0;i<a->size();++i)		{			ASObject* obj = a->at(i).getPtr();			obj->incRef();			//Convert the elements of the array to the type of this vector			ret->vec.push_back( type->coerce(obj) );		}		return ret;	}	else if(args[0]->getClass()->getTemplate() == Template<Vector>::getTemplate())	{		Vector* arg = static_cast<Vector*>(args[0]);		//create object without calling _constructor		Vector* ret = o_class->getInstance(false,NULL,0);		for(auto i = arg->vec.begin(); i != arg->vec.end(); ++i)		{			(*i)->incRef();			ret->vec.push_back( type->coerce(*i) );		}		return ret;	}	else	{		throw Class<ArgumentError>::getInstanceS("global Vector() function takes Array or Vector");	}}

ASFUNCTIONBODY(Array,filter){	Array* th=static_cast<Array*>(obj);	assert_and_throw(argslen==1 || argslen==2);	IFunction* f = static_cast<IFunction*>(args[0]);	ASObject* params[3];	Array* ret=Class<Array>::getInstanceS();	ASObject *funcRet;	std::map<uint32_t, data_slot>::iterator it=th->data.begin();	for(;it != th->data.end();++it)	{		assert_and_throw(it->second.type==DATA_OBJECT);		params[0] = it->second.data;		it->second.data->incRef();		params[1] = abstract_i(it->first);		params[2] = th;		th->incRef();		if(argslen==1)		{			funcRet=f->call(getSys()->getNullRef(), params, 3);		}		else		{			args[1]->incRef();			funcRet=f->call(args[1], params, 3);		}		if(funcRet)		{			if(Boolean_concrete(funcRet))			{				it->second.data->incRef();				ret->push(_MR(it->second.data));			}			funcRet->decRef();		}	}	return ret;}

void Proxy::setVariableByMultiname(const multiname& name, ASObject* o, CONST_ALLOWED_FLAG allowConst){	//If a variable named like this already exist, use that	if(ASObject::hasPropertyByMultiname(name, true, false) || !implEnable)	{		ASObject::setVariableByMultiname(name,o,allowConst);		return;	}	//Check if there is a custom setter defined, skipping implementation to avoid recursive calls	multiname setPropertyName(NULL);	setPropertyName.name_type=multiname::NAME_STRING;	setPropertyName.name_s_id=getSys()->getUniqueStringId("setProperty");	setPropertyName.ns.push_back(nsNameAndKind(flash_proxy,NAMESPACE));	_NR<ASObject> proxySetter=getVariableByMultiname(setPropertyName,ASObject::SKIP_IMPL);	if(proxySetter.isNull())	{		ASObject::setVariableByMultiname(name,o,allowConst);		return;	}	assert_and_throw(proxySetter->getObjectType()==T_FUNCTION);	IFunction* f=static_cast<IFunction*>(proxySetter.getPtr());	ASObject* namearg = Class<ASString>::getInstanceS(name.normalizedName());	namearg->setProxyProperty(name);	ASObject* args[2];	args[0]=namearg;	args[1]=o;	//We now suppress special handling	implEnable=false;	LOG(LOG_CALLS,_("Proxy::setProperty"));	incRef();	_R<ASObject> ret=_MR( f->call(this,args,2) );	assert_and_throw(ret->is<Undefined>());	implEnable=true;}

/* * (creates and) sets the property 'prototype' to o * 'prototype' is usually DYNAMIC_TRAIT, but on Class_base * it is a DECLARED_TRAIT, which is gettable only */void ASObject::setprop_prototype(_NR<ASObject>& o){	ASObject* obj = o.getPtr();	obj->incRef();	multiname prototypeName;	prototypeName.name_type=multiname::NAME_STRING;	prototypeName.name_s="prototype";	prototypeName.ns.push_back(nsNameAndKind("",NAMESPACE));	bool has_getter = false;	variable* ret=findSettable(prototypeName,false, &has_getter);	if(!ret && has_getter)		throw Class<ReferenceError>::getInstanceS("Error #1074: Illegal write to read-only property prototype");	if(!ret)		ret = Variables.findObjVar(prototypeName,DYNAMIC_TRAIT,DECLARED_TRAIT|DYNAMIC_TRAIT);	if(ret->setter)	{		this->incRef();		_MR( ret->setter->call(this,&obj,1) );	}	else		ret->setVar(obj);}

bool Proxy::hasPropertyByMultiname(const multiname& name, bool considerDynamic, bool considerPrototype){	if (name.normalizedName() == "isAttribute")		return true;	//If a variable named like this already exist, use that	bool asobject_has_property=ASObject::hasPropertyByMultiname(name, considerDynamic, considerPrototype);	if(asobject_has_property || !implEnable)		return asobject_has_property;	//Check if there is a custom hasProperty defined, skipping implementation to avoid recursive calls	multiname hasPropertyName(NULL);	hasPropertyName.name_type=multiname::NAME_STRING;	hasPropertyName.name_s_id=getSys()->getUniqueStringId("hasProperty");	hasPropertyName.ns.push_back(nsNameAndKind(flash_proxy,NAMESPACE));	_NR<ASObject> proxyHasProperty=getVariableByMultiname(hasPropertyName,ASObject::SKIP_IMPL);	if(proxyHasProperty.isNull())	{		return false;	}	assert_and_throw(proxyHasProperty->getObjectType()==T_FUNCTION);	IFunction* f=static_cast<IFunction*>(proxyHasProperty.getPtr());	ASObject* namearg = Class<ASString>::getInstanceS(name.normalizedName());	namearg->setProxyProperty(name);	ASObject* arg = namearg;	//We now suppress special handling	implEnable=false;	LOG(LOG_CALLS,_("Proxy::hasProperty"));	incRef();	_NR<ASObject> ret=_MNR(f->call(this,&arg,1));	implEnable=true;	Boolean* b = static_cast<Boolean*>(ret.getPtr());	return b->val;}

_NR<ASObject> Proxy::getVariableByMultiname(const multiname& name, GET_VARIABLE_OPTION opt){	//It seems that various kind of implementation works only with the empty namespace	assert_and_throw(name.ns.size()>0);	_NR<ASObject> o;	LOG(LOG_CALLS,"Proxy::getVar "<< name << " " << this->toDebugString());	if(ASObject::hasPropertyByMultiname(name, true, true) || !implEnable || (opt & ASObject::SKIP_IMPL)!=0)		o = ASObject::getVariableByMultiname(name,opt);	if (!o.isNull() || !implEnable || (opt & ASObject::SKIP_IMPL)!=0)		return o;	//Check if there is a custom getter defined, skipping implementation to avoid recursive calls	multiname getPropertyName(NULL);	getPropertyName.name_type=multiname::NAME_STRING;	getPropertyName.name_s_id=getSys()->getUniqueStringId("getProperty");	getPropertyName.ns.push_back(nsNameAndKind(flash_proxy,NAMESPACE));	o=getVariableByMultiname(getPropertyName,ASObject::SKIP_IMPL);	if(o.isNull())		return ASObject::getVariableByMultiname(name,opt);	assert_and_throw(o->getObjectType()==T_FUNCTION);	IFunction* f=static_cast<IFunction*>(o.getPtr());	ASObject* namearg = Class<ASString>::getInstanceS(name.normalizedName());	namearg->setProxyProperty(name);	ASObject* arg = namearg;	//We now suppress special handling	implEnable=false;	LOG(LOG_CALLS,"Proxy::getProperty "<< name.normalizedName() << " " << this->toDebugString());	incRef();	_NR<ASObject> ret=_MNR(f->call(this,&arg,1));	implEnable=true;	return ret;}

bool Proxy::deleteVariableByMultiname(const multiname& name){	//If a variable named like this already exist, use that	if(ASObject::hasPropertyByMultiname(name, true, false) || !implEnable)	{		return ASObject::deleteVariableByMultiname(name);	}	//Check if there is a custom deleter defined, skipping implementation to avoid recursive calls	multiname deletePropertyName(NULL);	deletePropertyName.name_type=multiname::NAME_STRING;	deletePropertyName.name_s_id=getSys()->getUniqueStringId("deleteProperty");	deletePropertyName.ns.push_back(nsNameAndKind(flash_proxy,NAMESPACE));	_NR<ASObject> proxyDeleter=getVariableByMultiname(deletePropertyName,ASObject::SKIP_IMPL);	if(proxyDeleter.isNull())	{		return ASObject::deleteVariableByMultiname(name);	}	assert_and_throw(proxyDeleter->getObjectType()==T_FUNCTION);	IFunction* f=static_cast<IFunction*>(proxyDeleter.getPtr());	ASObject* namearg = Class<ASString>::getInstanceS(name.normalizedName());	namearg->setProxyProperty(name);	ASObject* arg = namearg;	//We now suppress special handling	implEnable=false;	LOG(LOG_CALLS,_("Proxy::deleteProperty"));	incRef();	_NR<ASObject> ret=_MNR(f->call(this,&arg,1));	implEnable=true;	Boolean* b = static_cast<Boolean*>(ret.getPtr());	return b->val;}

//.........这里部分代码省略.........							status=Class<NetStatusEvent>::getInstanceS("status", "NetStream.Buffer.Full");							getVm()->addEvent(this, status);							status->decRef();						}						else						{							videoDecoder->decodeData(tag.packetData,tag.packetLen, frameTime);							decodedVideoFrames++;						}						break;					}					case 18:					{						tag = ScriptDataTag(s);						prevSize=tag.getTotalLen();						//The frameRate of the container overrides the stream												if(tag.metadataDouble.find("framerate") != tag.metadataDouble.end())							frameRate=tag.metadataDouble["framerate"];						break;					}					default:						LOG(LOG_ERROR,_("Unexpected tag type ") << (int)TagType << _(" in FLV"));						threadAbort();				}				if(!tickStarted && isReady())				{					{						multiname onMetaDataName;						onMetaDataName.name_type=multiname::NAME_STRING;						onMetaDataName.name_s="onMetaData";						onMetaDataName.ns.push_back(nsNameAndKind("",NAMESPACE));						ASObject* callback = client->getVariableByMultiname(onMetaDataName);						if(callback && callback->getObjectType() == T_FUNCTION)						{							ASObject* callbackArgs[1];							ASObject* metadata = Class<ASObject>::getInstanceS();							if(tag.metadataDouble.find("width") != tag.metadataDouble.end())								metadata->setVariableByQName("width", "", 										abstract_d(tag.metadataDouble["width"]));							else								metadata->setVariableByQName("width", "", abstract_d(getVideoWidth()));							if(tag.metadataDouble.find("height") != tag.metadataDouble.end())								metadata->setVariableByQName("height", "", 										abstract_d(tag.metadataDouble["height"]));							else								metadata->setVariableByQName("height", "", abstract_d(getVideoHeight()));							if(tag.metadataDouble.find("framerate") != tag.metadataDouble.end())								metadata->setVariableByQName("framerate", "", 										abstract_d(tag.metadataDouble["framerate"]));							if(tag.metadataDouble.find("duration") != tag.metadataDouble.end())								metadata->setVariableByQName("duration", "", 										abstract_d(tag.metadataDouble["duration"]));							if(tag.metadataInteger.find("canseekontime") != tag.metadataInteger.end())								metadata->setVariableByQName("canSeekToEnd", "", 										abstract_b(tag.metadataInteger["canseekontime"] == 1));							if(tag.metadataDouble.find("audiodatarate") != tag.metadataDouble.end())								metadata->setVariableByQName("audiodatarate", "", 										abstract_d(tag.metadataDouble["audiodatarate"]));							if(tag.metadataDouble.find("videodatarate") != tag.metadataDouble.end())								metadata->setVariableByQName("videodatarate", "", 										abstract_d(tag.metadataDouble["videodatarate"]));

_NR<ASObject> ASObject::getVariableByMultiname(const multiname& name, GET_VARIABLE_OPTION opt, Class_base* cls){	check();	assert(!cls || classdef->isSubClass(cls));	//Get from the current object without considering borrowed properties	variable* obj=findGettable(name, false);	if(!obj && cls)	{		//Look for borrowed traits before		obj=cls->findGettable(name,true);	}	if(!obj && cls)	{		//Check prototype chain		ASObject* proto = cls->prototype.getPtr();		while(proto)		{			obj = proto->findGettable(name, false);			if(obj)			{				obj->var->incRef();				return _MNR(obj->var);			}			proto = proto->getprop_prototype();		}	}	if(!obj)		return NullRef;	if(obj->getter)	{		//Call the getter		ASObject* target=this;		if(target->classdef)		{			LOG(LOG_CALLS,_("Calling the getter on type ") << target->classdef->class_name);		}		else		{			LOG(LOG_CALLS,_("Calling the getter"));		}		IFunction* getter=obj->getter;		target->incRef();		ASObject* ret=getter->call(target,NULL,0);		LOG(LOG_CALLS,_("End of getter"));		// No incRef because ret is a new instance		return _MNR(ret);	}	else	{		assert_and_throw(!obj->setter);		assert_and_throw(obj->var);		if(obj->var->getObjectType()==T_FUNCTION && obj->var->as<IFunction>()->isMethod())		{			LOG(LOG_CALLS,"Attaching this " << this << " to function " << name);			//the obj reference is acquired by the smart reference			this->incRef();			IFunction* f=obj->var->as<IFunction>()->bind(_MR(this),-1);			//No incref is needed, as the function is a new instance			return _MNR(f);		}		obj->var->incRef();		return _MNR(obj->var);	}}

void NetStream::execute(){	//checkPolicyFile only applies to per-pixel access, loading and playing is always allowed.	//So there is no need to disallow playing if policy files disallow it.	//We do need to check if per-pixel access is allowed.	SecurityManager::EVALUATIONRESULT evaluationResult = sys->securityManager->evaluatePoliciesURL(url, true);	if(evaluationResult == SecurityManager::NA_CROSSDOMAIN_POLICY)		rawAccessAllowed = true;	if(downloader->hasFailed())	{		this->incRef();		sys->currentVm->addEvent(_MR(this),_MR(Class<Event>::getInstanceS("ioError")));		sys->downloadManager->destroy(downloader);		return;	}	//The downloader hasn't failed yet at this point	istream s(downloader);	s.exceptions ( istream::eofbit | istream::failbit | istream::badbit );	ThreadProfile* profile=sys->allocateProfiler(RGB(0,0,200));	profile->setTag("NetStream");	bool waitForFlush=true;	StreamDecoder* streamDecoder=NULL;	//We need to catch possible EOF and other error condition in the non reliable stream	try	{		Chronometer chronometer;		streamDecoder=new FFMpegStreamDecoder(s);		if(!streamDecoder->isValid())			threadAbort();		bool done=false;		while(!done)		{			//Check if threadAbort has been called, if so, stop this loop			if(closed)				done = true;			bool decodingSuccess=streamDecoder->decodeNextFrame();			if(decodingSuccess==false)				done = true;			if(videoDecoder==NULL && streamDecoder->videoDecoder)			{				videoDecoder=streamDecoder->videoDecoder;				this->incRef();				getVm()->addEvent(_MR(this),						_MR(Class<NetStatusEvent>::getInstanceS("status", "NetStream.Play.Start")));				this->incRef();				getVm()->addEvent(_MR(this),						_MR(Class<NetStatusEvent>::getInstanceS("status", "NetStream.Buffer.Full")));			}			if(audioDecoder==NULL && streamDecoder->audioDecoder)				audioDecoder=streamDecoder->audioDecoder;			if(audioStream==NULL && audioDecoder && audioDecoder->isValid() && sys->audioManager->pluginLoaded())				audioStream=sys->audioManager->createStreamPlugin(audioDecoder);			if(audioStream && audioStream->paused() && !paused)			{				//The audio stream is paused but should not!				//As we have new data fill the stream				audioStream->fill();			}			if(!tickStarted && isReady())			{				multiname onMetaDataName;				onMetaDataName.name_type=multiname::NAME_STRING;				onMetaDataName.name_s="onMetaData";				onMetaDataName.ns.push_back(nsNameAndKind("",NAMESPACE));				ASObject* callback = client->getVariableByMultiname(onMetaDataName);				if(callback && callback->getObjectType() == T_FUNCTION)				{					ASObject* callbackArgs[1];					ASObject* metadata = Class<ASObject>::getInstanceS();					double d;					uint32_t i;					if(streamDecoder->getMetadataDouble("width",d))						metadata->setVariableByQName("width", "",abstract_d(d),DYNAMIC_TRAIT);					else						metadata->setVariableByQName("width", "", abstract_d(getVideoWidth()),DYNAMIC_TRAIT);					if(streamDecoder->getMetadataDouble("height",d))						metadata->setVariableByQName("height", "",abstract_d(d),DYNAMIC_TRAIT);					else						metadata->setVariableByQName("height", "", abstract_d(getVideoHeight()),DYNAMIC_TRAIT);					if(streamDecoder->getMetadataDouble("framerate",d))						metadata->setVariableByQName("framerate", "",abstract_d(d),DYNAMIC_TRAIT);					if(streamDecoder->getMetadataDouble("duration",d))						metadata->setVariableByQName("duration", "",abstract_d(d),DYNAMIC_TRAIT);					if(streamDecoder->getMetadataInteger("canseekontime",i))						metadata->setVariableByQName("canSeekToEnd", "",abstract_b(i == 1),DYNAMIC_TRAIT);					if(streamDecoder->getMetadataDouble("audiodatarate",d))						metadata->setVariableByQName("audiodatarate", "",abstract_d(d),DYNAMIC_TRAIT);					if(streamDecoder->getMetadataDouble("videodatarate",d))						metadata->setVariableByQName("videodatarate", "",abstract_d(d),DYNAMIC_TRAIT);//.........这里部分代码省略.........

// Conversion to ASObjectASObject* ExtVariant::getASObject() const{	ASObject* asobj;	switch(getType())	{	case EV_STRING:		asobj = Class<ASString>::getInstanceS(getString().c_str());		break;	case EV_INT32:		asobj = abstract_i(getInt());		break;	case EV_DOUBLE:		asobj = abstract_d(getDouble());		break;	case EV_BOOLEAN:		asobj = abstract_b(getBoolean());		break;	case EV_OBJECT:		{			ExtObject* objValue = getObject();			ExtVariant* property;			uint32_t count;			// We are converting an array, so lets set indexes			if(objValue->getType() == ExtObject::EO_ARRAY)			{				asobj = Class<Array>::getInstanceS();				count = objValue->getLength();				static_cast<Array*>(asobj)->resize(count);				for(uint32_t i = 0; i < count; i++)				{					property = objValue->getProperty(i);					static_cast<Array*>(asobj)->set(i, property->getASObject());					delete property;				}			}			// We are converting an object, so lets set variables			else			{				asobj = Class<ASObject>::getInstanceS();							ExtIdentifier** ids;				uint32_t count;				std::stringstream conv;				if(objValue != NULL && objValue->enumerate(&ids, &count))				{					for(uint32_t i = 0; i < count; i++)					{						property = objValue->getProperty(*ids[i]);						if(ids[i]->getType() == ExtIdentifier::EI_STRING)						{							asobj->setVariableByQName(ids[i]->getString(), "",									property->getASObject(), DYNAMIC_TRAIT);						}						else						{							conv << ids[i]->getInt();							asobj->setVariableByQName(conv.str().c_str(), "",									property->getASObject(), DYNAMIC_TRAIT);						}						delete property;						delete ids[i];					}				}				delete ids;			}			if(objValue != NULL)				delete objValue;		}		break;	case EV_NULL:		asobj = new Null;		break;	case EV_VOID:	default:		asobj = new Undefined;		break;	}	return asobj;}