rvmegacomediastream.c

h.248协议源码

/******************************************************************************
Filename   : rvmegacomediastream.c
Description: Methods for MEGACO Media Stream (part of Termination Manager)
******************************************************************************
                Copyright (c) 1999 RADVision Inc.
************************************************************************
NOTICE:
This document contains information that is proprietary to RADVision LTD.
No part of this publication may be reproduced in any form whatsoever 
without written prior approval by RADVision LTD..

RADVision LTD. reserves the right to revise this publication and make 
changes without obligation to notify any person of such revisions or 
changes.
******************************************************************************
$Revision:$
$Date:11.15.00$
$Author: D.Elbert$
******************************************************************************/
#include "rvmegacoerrors.h"
#include "rvmegacotermmgrutil.h"
#include "rvmegacomediastream.h"
#include "rvmegacoterm.h"

void rvMegacoMediaStreamConstructA(RvMegacoMediaStream * x,const RvMegacoStreamDescriptor * descr,RvAlloc * alloc) {
	x->streamDescr = (RvMegacoStreamDescriptor *)descr; 
	x->status = RV_MEGACOSTREAM_NEW;
	x->userData = NULL;
	x->alloc = alloc;
}

void rvMegacoMediaStreamDestruct(RvMegacoMediaStream * x) {
	/* By now nothing is done.. */
	;
}

/* Required for the vector */
RvMegacoMediaStream* rvMegacoMediaStreamConstructCopy(RvMegacoMediaStream* d,const RvMegacoMediaStream * s,RvAlloc* alloc) {
	d->streamDescr = s->streamDescr; 
	d->status = s->status;
	d->userData = s->userData;
	d->alloc = s->alloc;
	return d;
}

/* Compare by id */
RvBool rvMegacoMediaStreamEqual(const RvMegacoMediaStream* d,const RvMegacoMediaStream* s) {
	return rvMegacoMediaStreamMatchId(d,rvMegacoMediaStreamGetId(s));
}

/* TODO: Check if mode,parameters,reserve can also be absent,what to do...*/
static void updateStream(RvMegacoMediaStream * x,const RvMegacoStreamDescriptor * cmdStream) {
	const RvMegacoParameterList* paramList = NULL;

	paramList = rvMegacoStreamDescriptorGetParameterList(cmdStream);
	if( paramList!=NULL &&  !rvMegacoParameterListIsEmpty(paramList)  )
	rvMegacoParameterListCopy(&x->streamDescr->parameters,paramList);

	if(rvMegacoStreamDescriptorIsLocalDescriptorSet(cmdStream)) {
		rvSdpMsgListCopy(&x->streamDescr->localDescriptors,&cmdStream->localDescriptors);
	}

	if( rvMegacoStreamDescriptorIsRemoteDescriptorSet(cmdStream)) {
		rvSdpMsgListCopy(&x->streamDescr->remoteDescriptors,&cmdStream->remoteDescriptors);
	}

	/*TODO: Reset mode only if changed to non default*/
	rvMegacoStreamDescriptorSetMode(x->streamDescr,
									rvMegacoStreamDescriptorGetMode(cmdStream));

	rvMegacoStreamDescriptorSetReserveGroupMode(x->streamDescr,
												rvMegacoStreamDescriptorGetReserveGroupMode(cmdStream));
	rvMegacoStreamDescriptorSetReserveValueMode(x->streamDescr,
												rvMegacoStreamDescriptorGetReserveValueMode(cmdStream));
}


/*TODO: Check if mode,parameters,reserve can also be absent,what to do...*/
static void fillMdmInfo(RvMegacoMediaStream * x,RvMdmMediaStreamDescr * descr,const RvMegacoStreamDescriptor * cmdStream) {
	RvSdpMsgList* local=NULL,* remote=NULL;
	RvMegacoParameterList* paramList = NULL;
	const RvMegacoParameterList* cmdParamList = NULL;
	
	paramList = (RvMegacoParameterList*)rvMegacoStreamDescriptorGetParameterList(x->streamDescr);
	cmdParamList = rvMegacoStreamDescriptorGetParameterList(cmdStream);
	if( cmdParamList==NULL ||  rvMegacoParameterListIsEmpty(cmdParamList) )
		paramList = NULL;

	if(rvMegacoStreamDescriptorIsLocalDescriptorSet(cmdStream))
		local = &x->streamDescr->localDescriptors;

	if( rvMegacoStreamDescriptorIsRemoteDescriptorSet(cmdStream))
		remote = &x->streamDescr->remoteDescriptors;

	rvMdmMediaStreamDescrConstruct_(descr,
		rvMegacoStreamDescriptorGetReserveValueMode(x->streamDescr),
		rvMegacoStreamDescriptorGetReserveGroupMode(x->streamDescr),
		rvMegacoStreamDescriptorGetMode(x->streamDescr),
		paramList,local,remote);
}

RvUint32 rvMegacoMediaStreamGetId(const RvMegacoMediaStream * x) {
	if(x==NULL)
		return 0;
	return rvMegacoStreamDescriptorGetId(x->streamDescr);
}

RvBool rvMegacoMediaStreamMatchId(const RvMegacoMediaStream * x,unsigned int streamId) {
	if(x==NULL) 
		return (streamId==0);
	else
		return streamId==rvMegacoStreamDescriptorGetId(x->streamDescr);
}


/* How to build a response:
   Create the difference lists in place
   Copy the new media stuff - Because is saved in the termination
  	
  Note: in general (modify) needs to give to the application only the modified parameters,
  those are also the ones coming back...
  This must be copied but only once...
*/
static void buildRsp(RvMegacoMediaStream * x,RvMdmMediaStreamDescr * mdmMediaInfo,const RvMegacoStreamDescriptor * cmdStream,RvMegacoMediaDescriptor * rspMedia,RvAlloc * alloc) {
	/* Build response */
	/* For each stream,set the LocalDescr,RemoteDescr,LocalControl differences */
	RvMegacoStreamDescriptor tmpStream;
	RvMegacoStreamDescriptor * rspStreamDescr;
	RvMegacoParameterList * rspList;
	const RvMegacoParameterList * inList;

	rvMegacoStreamDescriptorConstructA(&tmpStream,rvMegacoMediaStreamGetId(x),alloc);
	rvMegacoMediaDescriptorAddStream(rspMedia,&tmpStream);

	rspStreamDescr = (RvMegacoStreamDescriptor *)rvMegacoMediaDescriptorGetStream(rspMedia,
														   rvMegacoMediaDescriptorGetNumStreams(rspMedia)-1);

	/* Check if response is required */
	if(rvMdmMediaStreamDescrIsReportLocal_(mdmMediaInfo) && rvMdmMediaStreamDescrGetLocalDescr(mdmMediaInfo)) {
		rvMegacoStreamDescriptorAddEmptyLocalDescriptor(rspStreamDescr);
		rvSdpMsgListCopy(&rspStreamDescr->localDescriptors,rvMdmMediaStreamDescrGetLocalDescr(mdmMediaInfo));
	}		

	/* Check if response is required */
	if(rvMdmMediaStreamDescrIsReportRemote_(mdmMediaInfo) && rvMdmMediaStreamDescrGetRemoteDescr(mdmMediaInfo)) {
		rvMegacoStreamDescriptorAddEmptyRemoteDescriptor(rspStreamDescr);
		rvSdpMsgListCopy(&rspStreamDescr->remoteDescriptors,rvMdmMediaStreamDescrGetRemoteDescr(mdmMediaInfo));
	}
			
	/* Check if response is required */
	/* Extract the parameter list from the media response */
	if(rvMdmMediaStreamDescrIsReportControl_(mdmMediaInfo)) {
		rspList = (RvMegacoParameterList *)rvMegacoStreamDescriptorGetParameterList(rspStreamDescr);
		inList = rvMegacoStreamDescriptorGetParameterList(cmdStream);
		rvMegacoTermMgrUtilParamListFillDif(inList,rvMdmMediaStreamDescrGetControlParameters(mdmMediaInfo),rspList);
	}
}


RvBool rvMegacoMediaStreamCreateMdmMedia(RvMegacoMediaStream * x,RvMegacoTerm * term,const RvMegacoStreamDescriptor * cmdStream,RvMegacoCommandReply * commReply) {
	RvMdmMediaStreamDescr mdmMediaInfo;
	RvMdmError mdmError;
	RvMdmTerm * mdmTerm = &term->mdmTerm;
	/* Get the media descriptor from the response */
	RvMegacoMediaDescriptor * rspMedia = (RvMegacoMediaDescriptor *)rvMegacoCommandReplyGetMedia(commReply); 

	rvMdmErrorConstruct_(&mdmError);

	/* Fill the mdm object with the media information */
	fillMdmInfo(x,&mdmMediaInfo,cmdStream);
		
	/* Call application callback to create a new media stream and set parameters */
	if(rvMdmTermCreateMediaStream_(mdmTerm,x,
									  &mdmMediaInfo,&mdmError)==rvFalse) {
		/* Build error response */
		return rvMegacoTermMgrUtilAddError2(commReply,&mdmError,
										RV_MEGACOERROR_INTERNAL,"Error creating Stream",term->alloc);
	}
	/* Build response */
	buildRsp(x,&mdmMediaInfo,cmdStream,rspMedia,term->alloc);
	return rvTrue;
}

RvBool rvMegacoMediaStreamUpdateMdmMedia(RvMegacoMediaStream * x,RvMegacoTerm * term,const RvMegacoStreamDescriptor * cmdStream,RvMegacoCommandReply * commReply) {
	RvMdmMediaStreamDescr mdmMediaInfo;
	RvMdmError mdmError;
	RvMdmTerm * mdmTerm = &term->mdmTerm;
	/* Get the media descriptor from the response */
	RvMegacoMediaDescriptor * rspMedia = (RvMegacoMediaDescriptor *)rvMegacoCommandReplyGetMedia(commReply); 

	rvMdmErrorConstruct_(&mdmError);

	/* Update the stream information */
	updateStream(x,cmdStream);

	/* Fill the mdm object with the media information */
	fillMdmInfo(x,&mdmMediaInfo,cmdStream);
		
	if(rvMdmTermModifyMediaStream_(mdmTerm,x,&mdmMediaInfo,&mdmError)==rvFalse) {
		/* Build error response */
		return rvMegacoTermMgrUtilAddError2(commReply,&mdmError,
							RV_MEGACOERROR_INTERNAL,"Error modifying Stream",term->alloc);
	}
	/* Build response */
	buildRsp(x,&mdmMediaInfo,cmdStream,rspMedia,term->alloc);
	return rvTrue;
}

void rvMegacoMediaStreamReleaseMdmMedia(RvMegacoMediaStream * x,RvMegacoTerm * term,RvMegacoCommandReply * commReply) {
	RvMdmError error;
	rvMdmErrorConstruct_(&error);

	if(!rvMdmTermDestroyMediaStream_(&term->mdmTerm,x,&error)) {
		rvMegacoTermMgrUtilAddError2(commReply,&error,
								RV_MEGACOERROR_INTERNAL,"Error releasing stream",term->alloc);		
	}
}