MSFilter *set_CODECFilter(RtpProfile *profile, int pt, int mode){
PayloadType *payload;
switch(mode){
case MEDIA_API_DECODER:
payload = rtp_profile_get_payload(profile, pt);
if(payload == NULL){
api_error("media_api: undefined payload in URL\n");
return NULL;
}
return ms_decoder_new_with_string_id(payload->mime_type);
//Commented this to include the new RtpProfile
/*if(pt != -1) return ms_decoder_new_with_pt(pt);
*else return ms_copy_new();
*/
case MEDIA_API_ENCODER:
payload = rtp_profile_get_payload(profile, pt);
if(payload == NULL){
api_error("media_api: undefined payload in URL\n");
return NULL;
}
return ms_encoder_new_with_string_id(payload->mime_type);
/*if(pt != -1) return ms_encoder_new_with_pt(pt);
*else return ms_copy_new();
*/
}
}
bool myAudioStream::init_filters(const QString & payload)
{
/** Init filters **/
stream->soundwrite = ms_snd_card_create_writer(playcard);
RtpProfile *profile = rtp_session_get_profile(stream->session);
PayloadType *pt;
/* List all available payloads */
QMap<QString,int> payloads;
for (int i = 0; i < RTP_PROFILE_MAX_PAYLOADS; i++) {
pt = rtp_profile_get_payload(profile,i);
if (pt != 0) {
QString payload(pt->mime_type);
if (payloads.contains(payload)) {
payload.append(" " + QString::number(pt->clock_rate));
}
payloads.insert(payload,i);
}
}
if (!payloads.contains(payload)) {
ms_error("Could not find payload %s", payload.toStdString().c_str());
return false;
}
int payload_type_number = payloads.value(payload);
/* Create filters */
pt = rtp_profile_get_payload(profile,payload_type_number);
stream->decoder = ms_filter_create_decoder(pt->mime_type);
stream->rtprecv = ms_filter_new(MS_RTP_RECV_ID);
stream->dtmfgen = ms_filter_new(MS_DTMF_GEN_ID);
/** Configure filter options **/
/* Set payload type to use when receiving */
rtp_session_set_payload_type(stream->session, payload_type_number);
/* Set session used by rtprecv */
ms_filter_call_method(stream->rtprecv,MS_RTP_RECV_SET_SESSION,stream->session);
/* Setup soundwrite and decoder parameters */
int sr = pt->clock_rate;
int chan = pt->channels;
if (ms_filter_call_method(stream->soundwrite, MS_FILTER_SET_SAMPLE_RATE, &sr) !=0 ) {
ms_error("Problem setting sample rate on soundwrite filter!");
return false;
}
if (ms_filter_call_method(stream->soundwrite, MS_FILTER_SET_NCHANNELS, &chan) != 0) {
ms_error("Failed to set sample rate on soundwrite filter!");
return false;
}
if (ms_filter_call_method(stream->decoder, MS_FILTER_SET_SAMPLE_RATE, &sr) != 0) {
ms_error("Problem setting sample rate on decoder filter!");
return false;
}
return true;
}
PayloadType * rtp_profile_get_payload_from_mime(RtpProfile *profile,const char *mime)
{
int pt;
pt=rtp_profile_get_payload_number_from_mime(profile,mime);
if (pt==-1) return NULL;
else return rtp_profile_get_payload(profile,pt);
}
PayloadType * rtp_profile_find_payload(RtpProfile *prof,const char *mime,int rate,int channels)
{
int i;
i=rtp_profile_find_payload_number(prof,mime,rate,channels);
if (i>=0) return rtp_profile_get_payload(prof,i);
return NULL;
}
uint16_t rtp_session_get_avpf_rr_interval(RtpSession *session) {
PayloadType *pt = rtp_profile_get_payload(session->rcv.profile, session->rcv.pt);
PayloadTypeAvpfParams params;
if (!pt) return RTCP_DEFAULT_REPORT_INTERVAL;
params=payload_type_get_avpf_params(pt);
return (uint16_t)params.trr_interval;
}
static void receiver_process(MSFilter * f)
{
ReceiverData *d = (ReceiverData *) f->data;
mblk_t *m;
uint32_t timestamp;
if (d->session == NULL)
return;
if (d->reset_jb){
ms_message("Reseting jitter buffer");
rtp_session_resync(d->session);
d->reset_jb=FALSE;
}
if (d->starting){
PayloadType *pt=rtp_profile_get_payload(
rtp_session_get_profile(d->session),
rtp_session_get_recv_payload_type(d->session));
if (pt && pt->type!=PAYLOAD_VIDEO)
rtp_session_flush_sockets(d->session);
d->starting=FALSE;
}
timestamp = (uint32_t) (f->ticker->time * (d->rate/1000));
while ((m = rtp_session_recvm_with_ts(d->session, timestamp)) != NULL) {
mblk_set_timestamp_info(m, rtp_get_timestamp(m));
mblk_set_marker_info(m, rtp_get_markbit(m));
mblk_set_cseq(m, rtp_get_seqnumber(m));
rtp_get_payload(m,&m->b_rptr);
ms_queue_put(f->outputs[0], m);
}
}
static void init_video_streams(video_stream_tester_t *vst1, video_stream_tester_t *vst2, bool_t avpf, bool_t one_way, OrtpNetworkSimulatorParams *params, int payload_type) {
PayloadType *pt;
create_video_stream(vst1, payload_type);
create_video_stream(vst2, payload_type);
/* Enable/disable avpf. */
pt = rtp_profile_get_payload(&rtp_profile, payload_type);
CU_ASSERT_PTR_NOT_NULL_FATAL(pt);
if (avpf == TRUE) {
payload_type_set_flag(pt, PAYLOAD_TYPE_RTCP_FEEDBACK_ENABLED);
} else {
payload_type_unset_flag(pt, PAYLOAD_TYPE_RTCP_FEEDBACK_ENABLED);
}
/* Configure network simulator. */
if ((params != NULL) && (params->enabled == TRUE)) {
rtp_session_enable_network_simulation(vst1->vs->ms.sessions.rtp_session, params);
rtp_session_enable_network_simulation(vst2->vs->ms.sessions.rtp_session, params);
}
if (one_way == TRUE) {
video_stream_set_direction(vst1->vs, VideoStreamRecvOnly);
}
CU_ASSERT_EQUAL(video_stream_start(vst1->vs, &rtp_profile, vst2->local_ip, vst2->local_rtp, vst2->local_ip, vst2->local_rtcp, payload_type, 50, vst1->cam), 0);
CU_ASSERT_EQUAL(video_stream_start(vst2->vs, &rtp_profile, vst1->local_ip, vst1->local_rtp, vst1->local_ip, vst1->local_rtcp, payload_type, 50, vst2->cam), 0);
}
static int get_receiver_output_fmt(MSFilter *f, void *arg) {
ReceiverData *d = (ReceiverData *) f->data;
MSPinFormat *pinFmt = (MSPinFormat *)arg;
PayloadType *pt = rtp_profile_get_payload(rtp_session_get_profile(d->session), rtp_session_get_send_payload_type(d->session));
pinFmt->fmt = ms_factory_get_audio_format(f->factory, pt->mime_type, pt->clock_rate, pt->channels, NULL);
return 0;
}
/*this function must be called from the MSTicker thread:
it replaces one filter by another one.
This is a dirty hack that works anyway.
It would be interesting to have something that does the job
simplier within the MSTicker api
*/
void video_stream_change_decoder(VideoStream *stream, int payload){
RtpSession *session=stream->session;
RtpProfile *prof=rtp_session_get_profile(session);
PayloadType *pt=rtp_profile_get_payload(prof,payload);
if (pt!=NULL){
MSFilter *dec=ms_filter_create_decoder(pt->mime_type);
if (dec!=NULL){
ms_filter_unlink(stream->rtprecv, 0, stream->decoder, 0);
ms_filter_unlink(stream->decoder,0,stream->output,0);
ms_filter_postprocess(stream->decoder);
ms_filter_destroy(stream->decoder);
stream->decoder=dec;
if (pt->recv_fmtp!=NULL)
ms_filter_call_method(stream->decoder,MS_FILTER_ADD_FMTP,(void*)pt->recv_fmtp);
ms_filter_link (stream->rtprecv, 0, stream->decoder, 0);
ms_filter_link (stream->decoder,0 , stream->output, 0);
ms_filter_preprocess(stream->decoder,stream->ticker);
}else{
ms_warning("No decoder found for %s",pt->mime_type);
}
}else{
ms_warning("No payload defined with number %i",payload);
}
}
/*returns TRUE if the packet is ok to be sent to output queue*/
static bool_t receiver_check_payload_type(MSFilter *f, ReceiverData *d, mblk_t *m){
int ptn=rtp_get_payload_type(m);
PayloadType *pt;
if (ptn==d->current_pt) return TRUE;
pt=rtp_profile_get_payload(rtp_session_get_profile(d->session), ptn);
if (pt==NULL){
ms_warning("Discarding packet with unknown payload type %i",ptn);
return FALSE;
}
if (strcasecmp(pt->mime_type,"CN")==0){
MSCngData cngdata;
uint8_t *data=NULL;
int datasize=rtp_get_payload(m, &data);
if (data){
if (datasize<= sizeof(cngdata.data)){
memcpy(cngdata.data, data, datasize);
cngdata.datasize=datasize;
ms_filter_notify(f, MS_RTP_RECV_GENERIC_CN_RECEIVED, &cngdata);
}else{
ms_warning("CN packet has unexpected size %i", datasize);
}
}
return FALSE;
}
d->current_pt = ptn;
return TRUE;
}
void linphone_core_setup_local_rtp_profile(LinphoneCore *lc)
{
int i;
MSList *audiopt,*videopt;
PayloadType *payload;
bool_t prepend;
lc->local_profile=rtp_profile_clone_full(&av_profile);
/* first look at the list given by configuration file to see if
it is correct */
audiopt=fix_codec_list(lc->local_profile,lc->codecs_conf.audio_codecs);
videopt=fix_codec_list(lc->local_profile,lc->codecs_conf.video_codecs);
/* now find and add payloads that are not listed in the configuration
codec list */
for (i=0;i<127;i++)
{
payload=rtp_profile_get_payload(lc->local_profile,i);
if (payload!=NULL){
if (payload_type_get_user_data(payload)!=NULL) continue;
/* find a mediastreamer codec for this payload type */
if (ms_filter_codec_supported(payload->mime_type)){
MSFilterDesc *desc=ms_filter_get_encoder(payload->mime_type);
ms_message("Adding new codec %s/%i",payload->mime_type,payload->clock_rate);
payload_type_set_enable(payload,1);
payload_type_set_user_data(payload,(void *)desc->text);
prepend=FALSE;
/* by default, put speex and theora on top of list*/
if (strcmp(payload->mime_type,"speex")==0)
prepend=TRUE;
if (strcmp(payload->mime_type,"theora")==0)
prepend=TRUE;
switch (payload->type){
case PAYLOAD_AUDIO_CONTINUOUS:
case PAYLOAD_AUDIO_PACKETIZED:
if (prepend)
audiopt=ms_list_prepend(audiopt,(void *)payload);
else
audiopt=ms_list_append(audiopt,(void *)payload);
break;
case PAYLOAD_VIDEO:
if (prepend)
videopt=ms_list_prepend(videopt,(void *)payload);
else
videopt=ms_list_append(videopt,(void *)payload);
break;
default:
ms_error("Unsupported rtp media type.");
}
}
}
}
ms_list_for_each(lc->codecs_conf.audio_codecs,(void (*)(void*))payload_type_destroy);
ms_list_for_each(lc->codecs_conf.video_codecs,(void (*)(void *))payload_type_destroy);
ms_list_free(lc->codecs_conf.audio_codecs);
ms_list_free(lc->codecs_conf.video_codecs);
/* set the fixed lists instead:*/
lc->codecs_conf.audio_codecs=audiopt;
lc->codecs_conf.video_codecs=videopt;
}
static bool_t simple_analyzer_process_rtcp(MSQosAnalyzer *objbase, mblk_t *rtcp){
MSSimpleQosAnalyzer *obj=(MSSimpleQosAnalyzer*)objbase;
rtpstats_t *cur;
const report_block_t *rb=NULL;
bool_t got_stats=FALSE;
if (rtcp_is_SR(rtcp)){
rb=rtcp_SR_get_report_block(rtcp,0);
}else if (rtcp_is_RR(rtcp)){
rb=rtcp_RR_get_report_block(rtcp,0);
}
if (rb && report_block_get_ssrc(rb)==rtp_session_get_send_ssrc(obj->session)){
obj->curindex++;
cur=&obj->stats[obj->curindex % STATS_HISTORY];
if (obj->clockrate==0){
PayloadType *pt=rtp_profile_get_payload(rtp_session_get_send_profile(obj->session),rtp_session_get_send_payload_type(obj->session));
if (pt!=NULL) obj->clockrate=pt->clock_rate;
else return FALSE;
}
if (ortp_loss_rate_estimator_process_report_block(objbase->lre,&obj->session->rtp,rb)){
cur->lost_percentage=ortp_loss_rate_estimator_get_value(objbase->lre);
cur->int_jitter=1000.0*(float)report_block_get_interarrival_jitter(rb)/(float)obj->clockrate;
cur->rt_prop=rtp_session_get_round_trip_propagation(obj->session);
ms_message("MSSimpleQosAnalyzer: lost_percentage=%f, int_jitter=%f ms, rt_prop=%f sec",
cur->lost_percentage,cur->int_jitter,cur->rt_prop);
got_stats=TRUE;
}
}
return got_stats;
}
static int payload_type_fill_from_rtpmap(PayloadType *pt, const char *rtpmap){
if (rtpmap==NULL){
PayloadType *refpt=rtp_profile_get_payload(&av_profile,payload_type_get_number(pt));
if (refpt){
pt->mime_type=ms_strdup(refpt->mime_type);
pt->clock_rate=refpt->clock_rate;
}else{
ms_error("payload number %i has no rtpmap and is unknown in AV Profile, ignored.",
payload_type_get_number(pt));
return -1;
}
}else{
char *mime=ms_strdup(rtpmap);
char *p=strchr(mime,'/');
if (p){
char *chans;
*p='\0';
p++;
chans=strchr(p,'/');
if (chans){
*chans='\0';
chans++;
pt->channels=atoi(chans);
}else pt->channels=1;
pt->clock_rate=atoi(p);
}
pt->mime_type=mime;
}
return 0;
}
int video_stream_recv_only_start (VideoStream *stream, RtpProfile *profile, const char *remip, int remport,int payload, int jitt_comp){
PayloadType *pt;
MSPixFmt format;
MSVideoSize vsize;
RtpSession *rtps=stream->session;
vsize.width=MS_VIDEO_SIZE_CIF_W;
vsize.height=MS_VIDEO_SIZE_CIF_H;
rtp_session_set_profile(rtps,profile);
if (remport>0) rtp_session_set_remote_addr(rtps,remip,remport);
rtp_session_set_payload_type(rtps,payload);
rtp_session_set_jitter_compensation(rtps,jitt_comp);
/* creates rtp filters to recv streams */
rtp_session_set_recv_buf_size(rtps,MAX_RTP_SIZE);
stream->rtprecv = ms_filter_new (MS_RTP_RECV_ID);
ms_filter_call_method(stream->rtprecv,MS_RTP_RECV_SET_SESSION,rtps);
/* creates the filters */
pt=rtp_profile_get_payload(profile,payload);
if (pt==NULL){
ms_error("videostream.c: undefined payload type.");
return -1;
}
stream->decoder=ms_filter_create_decoder(pt->mime_type);
if (stream->decoder==NULL){
/* big problem: we have not a registered codec for this payload...*/
ms_error("videostream.c: No codecs available for payload %i:%s.",payload,pt->mime_type);
return -1;
}
stream->output=ms_filter_new(MS_VIDEO_OUT_ID);
/*force the decoder to output YUV420P */
format=MS_YUV420P;
/*ask the size-converter to always output CIF */
vsize.width=MS_VIDEO_SIZE_CIF_W;
vsize.height=MS_VIDEO_SIZE_CIF_H;
ms_message("Setting output vsize=%ix%i",vsize.width,vsize.height);
ms_filter_call_method(stream->decoder,MS_FILTER_SET_PIX_FMT,&format);
ms_filter_call_method(stream->output,MS_FILTER_SET_PIX_FMT,&format);
ms_filter_call_method(stream->output,MS_FILTER_SET_VIDEO_SIZE,&vsize);
if (pt->recv_fmtp!=NULL) {
ms_message("pt->recv_fmtp: %s", pt->recv_fmtp);
ms_filter_call_method(stream->decoder,MS_FILTER_ADD_FMTP,(void*)pt->recv_fmtp);
}
/* and then connect all */
ms_filter_link (stream->rtprecv, 0, stream->decoder, 0);
ms_filter_link (stream->decoder,0 , stream->output, 0);
/* create the ticker */
stream->ticker = ms_ticker_new();
/* attach it the graph */
ms_ticker_attach (stream->ticker, stream->rtprecv);
return 0;
}
bool_t rtp_session_avpf_payload_type_feature_enabled(RtpSession *session, unsigned char feature) {
PayloadType *pt = rtp_profile_get_payload(session->rcv.profile, session->rcv.pt);
PayloadTypeAvpfParams params;
if (!pt) return FALSE;
params = payload_type_get_avpf_params(pt);
if (params.features & feature) return TRUE;
return FALSE;
}
/**
*rtp_session_set_jitter_compensation:
*@session: a RtpSession
*@milisec: the time interval in milisec to be jitter compensed.
*
* Sets the time interval for which packet are buffered instead of being delivered to the
* application.
**/
void
rtp_session_set_jitter_compensation (RtpSession * session, int milisec)
{
PayloadType *payload=NULL;
if (session->rcv.pt!=-1) {
payload = rtp_profile_get_payload (session->rcv.profile,session->rcv.pt);
}/*else not set yet */
jitter_control_init(&session->rtp.jittctl,milisec,payload);
}
/**
* Allocates a new rtp packet to be used to add named telephony events. The application can use
* then rtp_session_add_telephone_event() to add named events to the packet.
* Finally the packet has to be sent with rtp_session_sendm_with_ts().
*
* @param session a rtp session.
* @param start boolean to indicate if the marker bit should be set.
*
* @return a message block containing the rtp packet if successfull, NULL if the rtp session
* cannot support telephony event (because the rtp profile it is bound to does not include
* a telephony event payload type).
**/
mblk_t *rtp_session_create_telephone_event_packet(RtpSession *session, int start)
{
mblk_t *mp;
rtp_header_t *rtp;
PayloadType *cur_pt=rtp_profile_get_payload(session->snd.profile, rtp_session_get_send_payload_type(session));
int tev_pt = session->tev_send_pt;
if (tev_pt != -1){
PayloadType *cur_tev_pt=rtp_profile_get_payload(session->snd.profile, tev_pt);
if (!cur_tev_pt){
ortp_error("Undefined telephone-event payload type %i choosen for sending telephone event", tev_pt);
tev_pt = -1;
}else if (cur_pt && cur_tev_pt->clock_rate != cur_pt->clock_rate){
ortp_warning("Telephone-event payload type %i has clockrate %i while main audio codec has clockrate %i: this is not permitted.",
tev_pt, cur_tev_pt->clock_rate, cur_pt->clock_rate);
}
}
if (tev_pt == -1){
tev_pt = rtp_profile_find_payload_number(session->snd.profile, "telephone-event", cur_pt ? cur_pt->clock_rate : 8000, 1);
}
return_val_if_fail(tev_pt!=-1,NULL);
mp=allocb(RTP_FIXED_HEADER_SIZE+TELEPHONY_EVENTS_ALLOCATED_SIZE,BPRI_MED);
if (mp==NULL) return NULL;
rtp=(rtp_header_t*)mp->b_rptr;
rtp->version = 2;
rtp->markbit=start;
rtp->padbit = 0;
rtp->extbit = 0;
rtp->cc = 0;
rtp->ssrc = session->snd.ssrc;
/* timestamp set later, when packet is sended */
/*seq number set later, when packet is sended */
/*set the payload type */
rtp->paytype=tev_pt;
/*copy the payload */
mp->b_wptr+=RTP_FIXED_HEADER_SIZE;
return mp;
}
static RtpProfile *make_profile(LinphoneCall *call, const SalMediaDescription *md, const SalStreamDescription *desc, int *used_pt){
int bw;
const MSList *elem;
RtpProfile *prof=rtp_profile_new("Call profile");
bool_t first=TRUE;
int remote_bw=0;
LinphoneCore *lc=call->core;
int up_ptime=0;
*used_pt=-1;
for(elem=desc->payloads;elem!=NULL;elem=elem->next){
PayloadType *pt=(PayloadType*)elem->data;
int number;
if ((pt->flags & PAYLOAD_TYPE_FLAG_CAN_SEND) && first) {
if (desc->type==SalAudio){
linphone_core_update_allocated_audio_bandwidth_in_call(call,pt);
up_ptime=linphone_core_get_upload_ptime(lc);
}
*used_pt=payload_type_get_number(pt);
first=FALSE;
}
if (desc->bandwidth>0) remote_bw=desc->bandwidth;
else if (md->bandwidth>0) {
/*case where b=AS is given globally, not per stream*/
remote_bw=md->bandwidth;
if (desc->type==SalVideo){
remote_bw=get_video_bandwidth(remote_bw,call->audio_bw);
}
}
if (desc->type==SalAudio){
bw=get_min_bandwidth(call->audio_bw,remote_bw);
}else bw=get_min_bandwidth(get_video_bandwidth(linphone_core_get_upload_bandwidth (lc),call->audio_bw),remote_bw);
if (bw>0) pt->normal_bitrate=bw*1000;
else if (desc->type==SalAudio){
pt->normal_bitrate=-1;
}
if (desc->ptime>0){
up_ptime=desc->ptime;
}
if (up_ptime>0){
char tmp[40];
snprintf(tmp,sizeof(tmp),"ptime=%i",up_ptime);
payload_type_append_send_fmtp(pt,tmp);
}
number=payload_type_get_number(pt);
if (rtp_profile_get_payload(prof,number)!=NULL){
ms_warning("A payload type with number %i already exists in profile !",number);
}else
rtp_profile_set_payload(prof,number,pt);
}
return prof;
}
static void receiver_preprocess(MSFilter * f){
ReceiverData *d = (ReceiverData *) f->data;
if (d->session){
PayloadType *pt=rtp_profile_get_payload(
rtp_session_get_profile(d->session),
rtp_session_get_recv_payload_type(d->session));
if (pt){
if (pt->type!=PAYLOAD_VIDEO)
rtp_session_flush_sockets(d->session);
}
}
}
static void uninit_video_streams(video_stream_tester_t *vst1, video_stream_tester_t *vst2) {
float rtcp_send_bandwidth;
PayloadType *vst1_pt;
PayloadType *vst2_pt;
vst1_pt = rtp_profile_get_payload(&rtp_profile, vst1->payload_type);
CU_ASSERT_PTR_NOT_NULL_FATAL(vst1_pt);
vst2_pt = rtp_profile_get_payload(&rtp_profile, vst2->payload_type);
CU_ASSERT_PTR_NOT_NULL_FATAL(vst2_pt);
rtcp_send_bandwidth = rtp_session_get_rtcp_send_bandwidth(vst1->vs->ms.sessions.rtp_session);
ms_message("vst1: rtcp_send_bandwidth=%f, payload_type_bitrate=%d, rtcp_target_bandwidth=%f",
rtcp_send_bandwidth, payload_type_get_bitrate(vst1_pt), 0.06 * payload_type_get_bitrate(vst1_pt));
CU_ASSERT_TRUE(rtcp_send_bandwidth <= (0.06 * payload_type_get_bitrate(vst1_pt)));
rtcp_send_bandwidth = rtp_session_get_rtcp_send_bandwidth(vst2->vs->ms.sessions.rtp_session);
ms_message("vst2: rtcp_send_bandwidth=%f, payload_type_bitrate=%d, rtcp_target_bandwidth=%f",
rtcp_send_bandwidth, payload_type_get_bitrate(vst2_pt), 0.06 * payload_type_get_bitrate(vst2_pt));
CU_ASSERT_TRUE(rtcp_send_bandwidth <= (0.06 * payload_type_get_bitrate(vst2_pt)));
destroy_video_stream(vst1);
destroy_video_stream(vst2);
}
/*clone a profile and its payloads */
RtpProfile * rtp_profile_clone_full(RtpProfile *prof)
{
int i;
PayloadType *pt;
RtpProfile *newprof=rtp_profile_new(prof->name);
for (i=0; i<RTP_PROFILE_MAX_PAYLOADS; i++) {
pt=rtp_profile_get_payload(prof,i);
if (pt!=NULL) {
rtp_profile_set_payload(newprof,i,payload_type_clone(pt));
}
}
return newprof;
}
static void start_adaptive_stream(StreamType type, stream_manager_t ** pmarielle, stream_manager_t ** pmargaux,
int payload, int initial_bitrate, int target_bw, float loss_rate, int latency, float dup_ratio) {
OrtpNetworkSimulatorParams params={0};
params.enabled=TRUE;
params.loss_rate=loss_rate;
params.max_bandwidth=target_bw;
params.latency=latency;
int pause_time=0;
MediaStream *marielle_ms,*margaux_ms;
#if VIDEO_ENABLED
MSWebCam * marielle_webcam=ms_web_cam_manager_get_default_cam (ms_web_cam_manager_get());
#endif
stream_manager_t *marielle=*pmarielle=stream_manager_new(type);
stream_manager_t *margaux=*pmargaux=stream_manager_new(type);
if (type == AudioStreamType){
marielle_ms=&marielle->audio_stream->ms;
margaux_ms=&margaux->audio_stream->ms;
}else{
marielle_ms=&marielle->video_stream->ms;
margaux_ms=&margaux->video_stream->ms;
}
/* Disable avpf. */
PayloadType* pt = rtp_profile_get_payload(&rtp_profile, VP8_PAYLOAD_TYPE);
CU_ASSERT_PTR_NOT_NULL_FATAL(pt);
payload_type_unset_flag(pt, PAYLOAD_TYPE_RTCP_FEEDBACK_ENABLED);
media_stream_enable_adaptive_bitrate_control(marielle_ms,TRUE);
rtp_session_set_duplication_ratio(marielle_ms->sessions.rtp_session, dup_ratio);
if (marielle->type == AudioStreamType){
audio_manager_start(marielle,payload,margaux->local_rtp,initial_bitrate,HELLO_16K_1S_FILE,NULL);
ms_filter_call_method(marielle->audio_stream->soundread,MS_FILE_PLAYER_LOOP,&pause_time);
audio_manager_start(margaux,payload,marielle->local_rtp,0,NULL,RECORDED_16K_1S_FILE);
}else{
#if VIDEO_ENABLED
video_manager_start(marielle,payload,margaux->local_rtp,0,marielle_webcam);
video_stream_set_direction(margaux->video_stream,VideoStreamRecvOnly);
video_manager_start(margaux,payload,marielle->local_rtp,0,NULL);
#else
ms_fatal("Unsupported stream type [%s]",ms_stream_type_to_string(marielle->type));
#endif
}
rtp_session_enable_network_simulation(margaux_ms->sessions.rtp_session,¶ms);
}
static int sender_set_session(MSFilter * f, void *arg)
{
SenderData *d = (SenderData *) f->data;
RtpSession *s = (RtpSession *) arg;
PayloadType *pt =
rtp_profile_get_payload(rtp_session_get_profile(s),
rtp_session_get_send_payload_type(s));
if (pt != NULL) {
d->rate = pt->clock_rate;
} else {
ms_warning("Sending undefined payload type ?");
}
d->session = s;
return 0;
}
phcodec_t *ph_media_lookup_codec(int payload)
{
PayloadType *pt = rtp_profile_get_payload(&av_profile, payload);
phcodec_t *codec = ph_codec_list;
int mlen;
while(codec)
{
mlen = strlen(codec->mime);
if (!strnicmp(codec->mime, pt->mime_type, mlen))
return codec;
codec = codec->next;
}
return 0;
}
static int receiver_get_ch(MSFilter *f, void *arg) {
ReceiverData *d = (ReceiverData *)f->data;
PayloadType *pt;
if (d->session==NULL) {
ms_warning("MSRtpRecv: Could not obtain sample rate, session is not set.");
return -1;
}
pt=rtp_profile_get_payload(rtp_session_get_profile(d->session), rtp_session_get_recv_payload_type(d->session));
if (pt == NULL) {
ms_warning("MSRtpRecv: could not obtain number of channels, payload type is unknown.");
return -1;
}
*(int *)arg = pt->channels;
return 0;
}
void MastTool::set_payloadtype_index( int idx )
{
// Lookup the payload type
PayloadType* pt = rtp_profile_get_payload( profile, idx );
if (pt==NULL) MAST_WARNING("Failed to get payload type for index %d", idx);
this->payloadtype = pt;
// Store it
this->payloadtype_index = idx;
MAST_INFO( "Payload type index: %d", idx );
// Apply it to the session
if (rtp_session_set_send_payload_type( session, idx )) {
MAST_FATAL("Failed to set session payload type index");
}
}
int rtp_profile_get_payload_number_from_mime_and_flag(RtpProfile *profile, const char *mime, int flag)
{
PayloadType *pt;
int i;
for (i = 0; i < RTP_PROFILE_MAX_PAYLOADS; i++) {
pt = rtp_profile_get_payload(profile, i);
if (pt != NULL) {
if (strcasecmp(pt->mime_type, mime) == 0) {
if (flag < 0 || pt->flags & flag) {
return i;
}
}
}
}
return -1;
}
void rtp_profile_destroy(RtpProfile *prof)
{
int i;
PayloadType *payload;
if (prof->name) {
ortp_free(prof->name);
prof->name = NULL;
}
for (i=0; i<RTP_PROFILE_MAX_PAYLOADS; i++)
{
payload=rtp_profile_get_payload(prof,i);
if (payload!=NULL && (payload->flags & PAYLOAD_TYPE_ALLOCATED))
payload_type_destroy(payload);
}
ortp_free(prof);
}
int ph_media_supported_payload(ph_media_payload_t *pt, const char *ptstring)
{
PayloadType *rtppt;
pt->number = rtp_profile_get_payload_number_from_rtpmap(&av_profile, ptstring);
if (pt->number == -1)
return 0;
rtppt = rtp_profile_get_payload(&av_profile, pt->number);
strncpy(pt->string, rtppt->mime_type, sizeof(pt->string));
pt->rate = rtppt->clock_rate;
return 1;
}
static int receiver_set_session(MSFilter * f, void *arg)
{
ReceiverData *d = (ReceiverData *) f->data;
RtpSession *s = (RtpSession *) arg;
PayloadType *pt;
d->current_pt=rtp_session_get_recv_payload_type(s);
pt = rtp_profile_get_payload(rtp_session_get_profile(s),d->current_pt);
if (pt != NULL) {
d->rate = pt->clock_rate;
} else {
ms_warning("receiver_set_session(): receiving undefined payload type %i ?",
rtp_session_get_recv_payload_type(s));
}
d->session = s;
return 0;
}
