static pj_status_t g729_open(pjmedia_codec *codec, pjmedia_codec_param *attr ) { struct g729_private *priv = (struct g729_private*) codec->codec_data; pj_pool_t *pool; priv->pt = attr->info.pt; pool = priv->pool; /* PREPARING THE ENCODER */ priv->encoder = pj_pool_zalloc(pool, g729a_enc_mem_size()); if (!priv->encoder) return PJMEDIA_CODEC_EFAILED; if (!g729a_enc_init(priv->encoder)) return PJMEDIA_CODEC_EFAILED; /* PREPARING THE DECODER */ priv->decoder = pj_pool_zalloc(pool, g729a_dec_mem_size()); if (!priv->decoder) return PJMEDIA_CODEC_EFAILED; if (!g729a_dec_init(priv->decoder)) return PJMEDIA_CODEC_EFAILED; #if !PLC_DISABLED priv->plc_enabled = (attr->setting.plc != 0); #endif priv->vad_enabled = (attr->setting.vad != 0); return PJ_SUCCESS; }
/* * Create the ZRTP transport. */ PJ_DEF(pj_status_t) pjmedia_transport_zrtp_create(pjmedia_endpt *endpt, const char *name, pjmedia_transport *transport, pjmedia_transport **p_tp, pj_bool_t close_slave) { pj_pool_t *pool; struct tp_zrtp *zrtp; pj_status_t rc; if (name == NULL) name = "tzrtp%p"; /* Create the pool and initialize the adapter structure */ pool = pjmedia_endpt_create_pool(endpt, name, 5*1024, 512); zrtp = PJ_POOL_ZALLOC_T(pool, struct tp_zrtp); zrtp->pool = pool; pj_ansi_strncpy(zrtp->base.name, pool->obj_name, sizeof(zrtp->base.name)); zrtp->base.type = (pjmedia_transport_type) (PJMEDIA_TRANSPORT_TYPE_USER + 2); zrtp->base.op = &tp_zrtp_op; #ifndef DYNAMIC_TIMER if (timer_pool == NULL) { timer_pool = pjmedia_endpt_create_pool(endpt, "zrtp_timer", 256, 256); rc = timer_initialize(); if (rc != PJ_SUCCESS) { pj_pool_release(timer_pool); pj_pool_release(zrtp->pool); return rc; } } #else zrtp->timer_heap = pjsip_endpt_get_timer_heap(pjsua_var.endpt); #endif /* Create the empty wrapper */ zrtp->zrtpCtx = zrtp_CreateWrapper(); /* Initialize standard values */ zrtp->clientIdString = clientId; /* Set standard name */ zrtp->zrtpSeq = 1; /* TODO: randomize */ rc = pj_mutex_create_simple(zrtp->pool, "zrtp", &zrtp->zrtpMutex); zrtp->zrtpBuffer = pj_pool_zalloc(pool, MAX_ZRTP_SIZE); zrtp->sendBuffer = pj_pool_zalloc(pool, MAX_RTP_BUFFER_LEN); zrtp->sendBufferCtrl = pj_pool_zalloc(pool, MAX_RTCP_BUFFER_LEN); zrtp->slave_tp = transport; zrtp->close_slave = close_slave; zrtp->mitmMode = PJ_FALSE; /* Done */ zrtp->refcount++; *p_tp = &zrtp->base; return PJ_SUCCESS; }
/* * Create the splitter/combiner. */ PJ_DEF(pj_status_t) pjmedia_splitcomb_create( pj_pool_t *pool, unsigned clock_rate, unsigned channel_count, unsigned samples_per_frame, unsigned bits_per_sample, unsigned options, pjmedia_port **p_splitcomb) { const pj_str_t name = pj_str("splitcomb"); struct splitcomb *sc; /* Sanity check */ PJ_ASSERT_RETURN(pool && clock_rate && channel_count && samples_per_frame && bits_per_sample && p_splitcomb, PJ_EINVAL); /* Only supports 16 bits per sample */ PJ_ASSERT_RETURN(bits_per_sample == 16, PJ_EINVAL); *p_splitcomb = NULL; /* Create the splitter/combiner structure */ sc = pj_pool_zalloc(pool, sizeof(struct splitcomb)); PJ_ASSERT_RETURN(sc != NULL, PJ_ENOMEM); /* Create temporary buffers */ sc->get_buf = pj_pool_alloc(pool, samples_per_frame * sizeof(TMP_SAMP_TYPE) / channel_count); PJ_ASSERT_RETURN(sc->get_buf, PJ_ENOMEM); sc->put_buf = pj_pool_alloc(pool, samples_per_frame * sizeof(TMP_SAMP_TYPE) / channel_count); PJ_ASSERT_RETURN(sc->put_buf, PJ_ENOMEM); /* Save options */ sc->options = options; /* Initialize port */ pjmedia_port_info_init(&sc->base.info, &name, SIGNATURE, clock_rate, channel_count, bits_per_sample, samples_per_frame); sc->base.put_frame = &put_frame; sc->base.get_frame = &get_frame; sc->base.on_destroy = &on_destroy; /* Init ports array */ sc->port_desc = pj_pool_zalloc(pool, channel_count*sizeof(*sc->port_desc)); /* Done for now */ *p_splitcomb = &sc->base; return PJ_SUCCESS; }
/* * Create a media port to generate sine wave samples. */ static pj_status_t create_sine_port(pj_pool_t *pool, unsigned sampling_rate, unsigned channel_count, pjmedia_port **p_port) { pjmedia_port *port; unsigned i; unsigned count; port_data *sine; PJ_ASSERT_RETURN(pool && channel_count > 0 && channel_count <= 2, PJ_EINVAL); port = pj_pool_zalloc(pool, sizeof(pjmedia_port)); PJ_ASSERT_RETURN(port != NULL, PJ_ENOMEM); /* Fill in port info. */ port->info.bits_per_sample = 16; port->info.channel_count = channel_count; port->info.encoding_name = pj_str("pcm"); port->info.has_info = 1; port->info.name = pj_str("sine generator"); port->info.need_info = 0; port->info.pt = 0xFF; port->info.clock_rate = sampling_rate; port->info.samples_per_frame = sampling_rate * 20 / 1000 * channel_count; port->info.bytes_per_frame = port->info.samples_per_frame * 2; port->info.type = PJMEDIA_TYPE_AUDIO; /* Set the function to feed frame */ port->get_frame = &sine_get_frame; /* Create sine port data */ port->port_data.pdata = sine = pj_pool_zalloc(pool, sizeof(port_data)); /* Create samples */ count = port->info.samples_per_frame / channel_count; sine->samples = pj_pool_alloc(pool, count * sizeof(pj_int16_t)); PJ_ASSERT_RETURN(sine->samples != NULL, PJ_ENOMEM); /* initialise sinusoidal wavetable */ for( i=0; i<count; i++ ) { sine->samples[i] = (pj_int16_t) (10000.0 * sin(((double)i/(double)count) * M_PI * 8.) ); } *p_port = port; return PJ_SUCCESS; }
/* * Allocate a new iLBC codec instance. */ static pj_status_t ilbc_alloc_codec(pjmedia_codec_factory *factory, const pjmedia_codec_info *id, pjmedia_codec **p_codec) { pj_pool_t *pool; struct ilbc_codec *codec; PJ_ASSERT_RETURN(factory && id && p_codec, PJ_EINVAL); PJ_ASSERT_RETURN(factory == &ilbc_factory.base, PJ_EINVAL); pool = pjmedia_endpt_create_pool(ilbc_factory.endpt, "iLBC%p", 2000, 2000); PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM); codec = pj_pool_zalloc(pool, sizeof(struct ilbc_codec)); codec->base.op = &ilbc_op; codec->base.factory = factory; codec->pool = pool; pj_ansi_snprintf(codec->obj_name, sizeof(codec->obj_name), "ilbc%p", codec); *p_codec = &codec->base; return PJ_SUCCESS; }
/* * Create client subscription. */ PJ_DEF(pj_status_t) pjsip_pres_create_uac( pjsip_dialog *dlg, const pjsip_evsub_user *user_cb, unsigned options, pjsip_evsub **p_evsub ) { pj_status_t status; pjsip_pres *pres; pjsip_evsub *sub; PJ_ASSERT_RETURN(dlg && p_evsub, PJ_EINVAL); pjsip_dlg_inc_lock(dlg); /* Create event subscription */ status = pjsip_evsub_create_uac( dlg, &pres_user, &STR_PRESENCE, options, &sub); if (status != PJ_SUCCESS) goto on_return; /* Create presence */ pres = pj_pool_zalloc(dlg->pool, sizeof(pjsip_pres)); pres->dlg = dlg; pres->sub = sub; if (user_cb) pj_memcpy(&pres->user_cb, user_cb, sizeof(pjsip_evsub_user)); /* Attach to evsub */ pjsip_evsub_set_mod_data(sub, mod_presence.id, pres); *p_evsub = sub; on_return: pjsip_dlg_dec_lock(dlg); return status; }
PJ_DEF(pj_status_t) pjmedia_silence_det_create( pj_pool_t *pool, unsigned clock_rate, unsigned samples_per_frame, pjmedia_silence_det **p_sd) { pjmedia_silence_det *sd; PJ_ASSERT_RETURN(pool && p_sd, PJ_EINVAL); sd = pj_pool_zalloc(pool, sizeof(struct pjmedia_silence_det)); pj_ansi_strncpy(sd->objname, THIS_FILE, PJ_MAX_OBJ_NAME); sd->objname[PJ_MAX_OBJ_NAME-1] = '\0'; sd->ptime = samples_per_frame * 1000 / clock_rate; sd->signal_cnt = 0; sd->silence_cnt = 0; sd->weakest_signal = 0xFFFFFFFFUL; sd->loudest_silence = 0; /* Default settings */ pjmedia_silence_det_set_params(sd, -1, -1, -1); /* Restart in fixed, silent mode */ sd->in_talk = PJ_FALSE; pjmedia_silence_det_set_adaptive( sd, -1 ); *p_sd = sd; return PJ_SUCCESS; }
PJ_DEF(pj_status_t) pjmedia_null_port_create( pj_pool_t *pool, unsigned sampling_rate, unsigned channel_count, unsigned samples_per_frame, unsigned bits_per_sample, pjmedia_port **p_port ) { pjmedia_port *port; const pj_str_t name = pj_str("null-port"); PJ_ASSERT_RETURN(pool && p_port, PJ_EINVAL); port = pj_pool_zalloc(pool, sizeof(pjmedia_port)); PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM); pjmedia_port_info_init(&port->info, &name, SIGNATURE, sampling_rate, channel_count, bits_per_sample, samples_per_frame); port->get_frame = &null_get_frame; port->put_frame = &null_put_frame; port->on_destroy = &null_on_destroy; *p_port = port; return PJ_SUCCESS; }
static int xml_parse_print_test(const char *doc) { pj_str_t msg; pj_pool_t *pool; pj_xml_node *root; char *output; int output_len; pool = pj_pool_create(mem, "xml", 4096, 1024, NULL); pj_strdup2(pool, &msg, doc); root = pj_xml_parse(pool, msg.ptr, msg.slen); if (!root) { PJ_LOG(1, (THIS_FILE, " Error: unable to parse XML")); return -10; } output = (char*)pj_pool_zalloc(pool, msg.slen + 512); output_len = pj_xml_print(root, output, msg.slen+512, PJ_TRUE); if (output_len < 1) { PJ_LOG(1, (THIS_FILE, " Error: buffer too small to print XML file")); return -20; } output[output_len] = '\0'; pj_pool_release(pool); return 0; }
/* * Create. */ PJ_DEF(pj_status_t) echo_supp_create( pj_pool_t *pool, unsigned clock_rate, unsigned samples_per_frame, unsigned tail_ms, unsigned latency_ms, unsigned options, void **p_state ) { echo_supp *ec; pj_status_t status; PJ_UNUSED_ARG(clock_rate); PJ_UNUSED_ARG(options); PJ_UNUSED_ARG(latency_ms); ec = pj_pool_zalloc(pool, sizeof(struct echo_supp)); ec->samples_per_frame = samples_per_frame; ec->tail_ms = tail_ms; status = pjmedia_silence_det_create(pool, clock_rate, samples_per_frame, &ec->sd); if (status != PJ_SUCCESS) return status; pjmedia_silence_det_set_name(ec->sd, "ecsu%p"); pjmedia_silence_det_set_adaptive(ec->sd, PJMEDIA_ECHO_SUPPRESS_THRESHOLD); pjmedia_silence_det_set_params(ec->sd, 100, 500, 3000); *p_state = ec; return PJ_SUCCESS; }
/* * Make outgoing call. */ static pj_status_t make_call(const pj_str_t *dst_uri) { struct call *call; pjsip_dialog *dlg; pjmedia_sdp_session *sdp; pjsip_tx_data *tdata; pj_status_t status; /* Create UAC dialog */ status = pjsip_dlg_create_uac( pjsip_ua_instance(), &app.local_uri, /* local URI */ &app.local_contact, /* local Contact */ dst_uri, /* remote URI */ dst_uri, /* remote target */ &dlg); /* dialog */ if (status != PJ_SUCCESS) { return status; } /* Create call */ call = pj_pool_zalloc(dlg->pool, sizeof(struct call)); /* Create SDP */ if (app.real_sdp) { status = pjmedia_endpt_create_sdp(app.med_endpt, dlg->pool, 1, app.skinfo, &sdp); if (status != PJ_SUCCESS) { pjsip_dlg_terminate(dlg); return status; } } else sdp = app.dummy_sdp; /* Create the INVITE session. */ status = pjsip_inv_create_uac( dlg, sdp, 0, &call->inv); if (status != PJ_SUCCESS) { pjsip_dlg_terminate(dlg); return status; } /* Create initial INVITE request. * This INVITE request will contain a perfectly good request and * an SDP body as well. */ status = pjsip_inv_invite(call->inv, &tdata); PJ_ASSERT_RETURN(status == PJ_SUCCESS, status); /* Send initial INVITE request. * From now on, the invite session's state will be reported to us * via the invite session callbacks. */ status = pjsip_inv_send_msg(call->inv, tdata); PJ_ASSERT_RETURN(status == PJ_SUCCESS, status); return PJ_SUCCESS; }
/* * Create PLC session. This function will select the PLC algorithm to * use based on the arguments. */ PJ_DEF(pj_status_t) pjmedia_plc_create( pj_pool_t *pool, unsigned clock_rate, unsigned samples_per_frame, unsigned options, pjmedia_plc **p_plc) { pjmedia_plc *plc; PJ_ASSERT_RETURN(pool && clock_rate && samples_per_frame && p_plc, PJ_EINVAL); PJ_ASSERT_RETURN(options == 0, PJ_EINVAL); PJ_UNUSED_ARG(options); plc = pj_pool_zalloc(pool, sizeof(pjmedia_plc)); if (0) ; #if defined(PJMEDIA_HAS_STEVEU_PLC) && PJMEDIA_HAS_STEVEU_PLC!=0 else if (clock_rate == 8000) plc->op = &plc_steveu; #endif else plc->op = &plc_replay; plc->obj = plc->op->plc_create(pool, clock_rate, samples_per_frame); *p_plc = plc; return PJ_SUCCESS; }
/* * Create a media port to generate sine wave samples. */ static pj_status_t create_sine_port(pj_pool_t *pool, unsigned sampling_rate, unsigned channel_count, pjmedia_port **p_port) { pjmedia_port *port; unsigned i; unsigned count; pj_str_t name; port_data *sine; PJ_ASSERT_RETURN(pool && channel_count > 0 && channel_count <= 2, PJ_EINVAL); port = pj_pool_zalloc(pool, sizeof(pjmedia_port)); PJ_ASSERT_RETURN(port != NULL, PJ_ENOMEM); /* Fill in port info. */ name = pj_str("sine generator"); pjmedia_port_info_init(&port->info, &name, PJMEDIA_SIG_CLASS_PORT_AUD('s', 'i'), sampling_rate, channel_count, 16, sampling_rate * 20 / 1000 * channel_count); /* Set the function to feed frame */ port->get_frame = &sine_get_frame; /* Create sine port data */ port->port_data.pdata = sine = pj_pool_zalloc(pool, sizeof(port_data)); /* Create samples */ count = PJMEDIA_PIA_SPF(&port->info) / channel_count; sine->samples = pj_pool_alloc(pool, count * sizeof(pj_int16_t)); PJ_ASSERT_RETURN(sine->samples != NULL, PJ_ENOMEM); /* initialise sinusoidal wavetable */ for( i=0; i<count; i++ ) { sine->samples[i] = (pj_int16_t) (10000.0 * sin(((double)i/(double)count) * M_PI * 8.) ); } *p_port = port; return PJ_SUCCESS; }
void Sdp::setTelephoneEventRtpmap(pjmedia_sdp_media *med) { pjmedia_sdp_attr *attr_rtpmap = NULL; pjmedia_sdp_attr *attr_fmtp = NULL; attr_rtpmap = static_cast<pjmedia_sdp_attr *>(pj_pool_zalloc(memPool_, sizeof(pjmedia_sdp_attr))); attr_rtpmap->name = pj_str((char *) "rtpmap"); attr_rtpmap->value = pj_str((char *) "101 telephone-event/8000"); med->attr[med->attr_count++] = attr_rtpmap; attr_fmtp = static_cast<pjmedia_sdp_attr *>(pj_pool_zalloc(memPool_, sizeof(pjmedia_sdp_attr))); attr_fmtp->name = pj_str((char *) "fmtp"); attr_fmtp->value = pj_str((char *) "101 0-15"); med->attr[med->attr_count++] = attr_fmtp; }
/* * Create the echo canceller. */ pjs_echo_canceller::pjs_echo_canceller(pj_pool_t *pool_, unsigned clock_rate, unsigned samples_per_frame_, unsigned tail_ms, unsigned latency_ms, unsigned options) { int sampling_rate = clock_rate; unsigned ptime, lat_cnt; unsigned delay_buf_opt = 0; lat_ready = PJ_FALSE; /* Create new pool and instantiate and init the EC */ pool = pj_pool_create(pool_->factory, "ec%p", 256, 256, NULL); lock = new PPJ_SemaphoreLock(pool, NULL, 1, 1); samples_per_frame = samples_per_frame_; frm_buf = (pj_int16_t*) pj_pool_alloc(pool, samples_per_frame << 1); state = speex_echo_state_init(samples_per_frame, clock_rate * tail_ms / 1000); speex_echo_ctl(state, SPEEX_ECHO_SET_SAMPLING_RATE, &sampling_rate); preprocess = speex_preprocess_state_init(samples_per_frame, clock_rate); tmp_frame = (pj_int16_t*) pj_pool_zalloc(pool, 2*samples_per_frame); speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_ECHO_STATE, state); pj_list_init(&lat_buf); pj_list_init(&lat_free); PJ_LOG(5, (THIS_FILE, "Creating echo canceler")); /* Create latency buffers */ ptime = samples_per_frame * 1000 / clock_rate; if (latency_ms < ptime) { /* Give at least one frame delay to simplify programming */ latency_ms = ptime; } lat_cnt = latency_ms / ptime; while (lat_cnt--) { struct frame *frm; frm = (struct frame*) pj_pool_alloc(pool, (samples_per_frame << 1) + sizeof(struct frame)); pj_list_push_back(&lat_free, frm); } /* Create delay buffer to compensate drifts */ if (options & PJMEDIA_ECHO_USE_SIMPLE_FIFO) delay_buf_opt |= PJMEDIA_DELAY_BUF_SIMPLE_FIFO; pjmedia_delay_buf_create(pool, NULL, clock_rate, samples_per_frame, 1, (PJMEDIA_SOUND_BUFFER_COUNT + 1) * ptime, delay_buf_opt, &delay_buf); PJ_LOG(4, (THIS_FILE, "ECHO canceller created, clock_rate=%d, channel=%d, " "samples per frame=%d, tail length=%d ms, " "latency=%d ms", clock_rate, 1, samples_per_frame, tail_ms, latency_ms)); }
PJ_DEF(int) jitter_buffer_create(Jitter_Buffer ** jitter_buffer, pj_pool_t *pool, int max_number_of_frames, NACK_MODE nack_mode, int low_rtt_threshold_ms, int high_rtt_threshold_ms) { pj_assert(low_rtt_threshold_ms <= high_rtt_threshold_ms); //alloc jitter buffer Jitter_Buffer *jitter_buffer_internal = (Jitter_Buffer*)pj_pool_zalloc(pool, sizeof(Jitter_Buffer)); //init list alloc list_alloc_init(&jitter_buffer_internal->frame_alloc, pool); list_alloc_init(&jitter_buffer_internal->packet_alloc, pool); //init frame list, don't call frame_buffer_init, //since the header is not used as a real frame pj_list_init(&jitter_buffer_internal->frameList); pj_list_init(&jitter_buffer_internal->decodingFrameList); //init frame number jitter_buffer_internal->max_number_of_frames = max_number_of_frames < MIN_NUM_OF_FRAMES? MIN_NUM_OF_FRAMES : max_number_of_frames; jitter_buffer_internal->number_of_frames = 0; //init decode state decode_state_init(&jitter_buffer_internal->decode_state); //init jitter estimator jitter_estimator_init(&jitter_buffer_internal->jitter_estimator); //init inter_frame_delay inter_frame_delay_init(&jitter_buffer_internal->inter_frame_delay); //init rtt jitter_buffer_internal->rttMs = DEFAULT_RTT_MS; //init nack if(high_rtt_threshold_ms != -1) jitter_buffer_internal->rttMs = 0; jitter_buffer_internal->nack_mode = nack_mode; jitter_buffer_internal->low_rtt_threshold_ms = low_rtt_threshold_ms; jitter_buffer_internal->high_rtt_threshold_ms = high_rtt_threshold_ms; jitter_buffer_internal->nack_seq_num = 0; //init event if(event_create(&jitter_buffer_internal->frame_event) != 0) { return -1; } if(event_create(&jitter_buffer_internal->packet_event) != 0) return -1; //not running jitter_buffer_internal->running = PJ_FALSE; //first packet jitter_buffer_internal->first_packet = PJ_FALSE; //the first frame must be key frame jitter_buffer_internal->waiting_for_key_frame = PJ_TRUE; //waiting for completed frame jitter_buffer_internal->waiting_for_completed_frame.timestamp = 0; jitter_buffer_internal->waiting_for_completed_frame.frame_size = 0; jitter_buffer_internal->waiting_for_completed_frame.latest_packet_timestamp = -1; //init mutex if(pj_mutex_create_simple(pool, NULL, &jitter_buffer_internal->jb_mutex) != PJ_SUCCESS) return -1; //ret *jitter_buffer = jitter_buffer_internal; return 0; }
void queue_init(queue_t *queue, int cap, int data_size, pj_pool_t *p_mempool) { queue->capacity = cap; queue->buffer = pj_pool_zalloc(p_mempool, sizeof(void *) * cap); queue->size = 0; queue->in = 0; queue->out = 0; //#define QEPOOL_SIZE(queue) (5*queue->capacity) // qepool_init(&(queue->qepool), QEPOOL_SIZE(queue), data_size, p_mempool); pthread_mutex_init(&queue->mutex, NULL); pthread_cond_init(&queue->cond_full, NULL); pthread_cond_init(&queue->cond_empty, NULL); }
Jt_Car::Jt_Car(pj_uint32_t id):_id(id) { PJ_LOG(3, ("car.cpp", "build a car")); _pool = pj_pool_create(&g_cp.factory, "car", INIT_POOL_CAR_SIZE, INC_POOL_CAR_SIZE, NULL); _event_track = (jt_e_track_node*)PJ_POOL_ZALLOC_T(_pool, jt_e_track_node); pj_list_init(_event_track); _station_track = (jt_s_track_node*)PJ_POOL_ZALLOC_T(_pool, jt_s_track_node); pj_list_init(_station_track); _station_track->station = NULL; _data = pj_pool_zalloc(_pool, MAX_CAR_DATA_LEN); }
/** * This method is to parse and add the choice type * argument values to command structure. **/ static pj_status_t add_choice_node(pj_cli_t *cli, pj_xml_node *xml_node, pj_cli_arg_spec *arg, pj_cli_get_dyn_choice get_choice) { pj_xml_node *choice_node; pj_xml_node *sub_node; pj_cli_arg_choice_val choice_values[PJ_CLI_MAX_CHOICE_VAL]; pj_status_t status = PJ_SUCCESS; sub_node = xml_node; arg->type = PJ_CLI_ARG_CHOICE; arg->get_dyn_choice = get_choice; choice_node = sub_node->node_head.next; while (choice_node != (pj_xml_node*)&sub_node->node_head) { pj_xml_attr *choice_attr; unsigned *stat_cnt = &arg->stat_choice_cnt; pj_cli_arg_choice_val *choice_val = &choice_values[*stat_cnt]; pj_bzero(choice_val, sizeof(*choice_val)); choice_attr = choice_node->attr_head.next; while (choice_attr != &choice_node->attr_head) { if (!pj_stricmp2(&choice_attr->name, "value")) { pj_strassign(&choice_val->value, &choice_attr->value); } else if (!pj_stricmp2(&choice_attr->name, "desc")) { pj_strassign(&choice_val->desc, &choice_attr->value); } choice_attr = choice_attr->next; } if (++(*stat_cnt) >= PJ_CLI_MAX_CHOICE_VAL) break; choice_node = choice_node->next; } if (arg->stat_choice_cnt > 0) { unsigned i; arg->stat_choice_val = (pj_cli_arg_choice_val *) pj_pool_zalloc(cli->pool, arg->stat_choice_cnt * sizeof(pj_cli_arg_choice_val)); for (i = 0; i < arg->stat_choice_cnt; i++) { pj_strdup(cli->pool, &arg->stat_choice_val[i].value, &choice_values[i].value); pj_strdup(cli->pool, &arg->stat_choice_val[i].desc, &choice_values[i].desc); } } return status; }
static void* plc_replay_create(pj_pool_t *pool, unsigned clock_rate, unsigned samples_per_frame) { struct replay_plc *o; PJ_UNUSED_ARG(clock_rate); o = pj_pool_alloc(pool, sizeof(struct replay_plc)); o->size = samples_per_frame * 2; o->replay_cnt = 0; o->frame = pj_pool_zalloc(pool, o->size); return o; }
/*! * \internal * \brief Insert the header pointers into the linked list. * * For each header in the message, allocate a list entry, * clone the header, then insert the entry. */ static int insert_headers(pj_pool_t * pool, struct hdr_list *list, pjsip_msg * msg) { pjsip_hdr *hdr = msg->hdr.next; struct hdr_list_entry *le; while (hdr && hdr != &msg->hdr) { le = pj_pool_zalloc(pool, sizeof(struct hdr_list_entry)); le->hdr = pjsip_hdr_clone(pool, hdr); AST_LIST_INSERT_TAIL(list, le, nextptr); hdr = hdr->next; } return 0; }
pjmedia_sdp_session_clone( pj_pool_t *pool, const pjmedia_sdp_session *rhs) { pjmedia_sdp_session *sess; unsigned i; PJ_ASSERT_RETURN(pool && rhs, NULL); sess = pj_pool_zalloc(pool, sizeof(pjmedia_sdp_session)); PJ_ASSERT_RETURN(sess != NULL, NULL); /* Clone origin line. */ pj_strdup(pool, &sess->origin.user, &rhs->origin.user); sess->origin.id = rhs->origin.id; sess->origin.version = rhs->origin.version; pj_strdup(pool, &sess->origin.net_type, &rhs->origin.net_type); pj_strdup(pool, &sess->origin.addr_type, &rhs->origin.addr_type); pj_strdup(pool, &sess->origin.addr, &rhs->origin.addr); /* Clone subject line. */ pj_strdup(pool, &sess->name, &rhs->name); /* Clone connection line */ if (rhs->conn) { sess->conn = pjmedia_sdp_conn_clone(pool, rhs->conn); PJ_ASSERT_RETURN(sess->conn != NULL, NULL); } /* Clone time line. */ sess->time.start = rhs->time.start; sess->time.stop = rhs->time.stop; /* Duplicate session attributes. */ sess->attr_count = rhs->attr_count; for (i=0; i<rhs->attr_count; ++i) { sess->attr[i] = pjmedia_sdp_attr_clone(pool, rhs->attr[i]); } /* Duplicate media descriptors. */ sess->media_count = rhs->media_count; for (i=0; i<rhs->media_count; ++i) { sess->media[i] = pjmedia_sdp_media_clone(pool, rhs->media[i]); } return sess; }
PJ_DEF(pj_status_t) pjmedia_mem_player_create( pj_pool_t *pool, const void *buffer, pj_size_t size, unsigned clock_rate, unsigned channel_count, unsigned samples_per_frame, unsigned bits_per_sample, unsigned options, pjmedia_port **p_port ) { struct mem_player *port; pj_str_t name = pj_str("memplayer"); /* Sanity check */ PJ_ASSERT_RETURN(pool && buffer && size && clock_rate && channel_count && samples_per_frame && bits_per_sample && p_port, PJ_EINVAL); /* Can only support 16bit PCM */ PJ_ASSERT_RETURN(bits_per_sample == 16, PJ_EINVAL); port = pj_pool_zalloc(pool, sizeof(struct mem_player)); PJ_ASSERT_RETURN(port != NULL, PJ_ENOMEM); /* Create the port */ pjmedia_port_info_init(&port->base.info, &name, SIGNATURE, clock_rate, channel_count, bits_per_sample, samples_per_frame); port->base.put_frame = &mem_put_frame; port->base.get_frame = &mem_get_frame; port->base.on_destroy = &mem_on_destroy; /* Save the buffer */ port->buffer = port->read_pos = (char*)buffer; port->buf_size = size; /* Options */ port->options = options; *p_port = &port->base; return PJ_SUCCESS; }
static struct playlist_port *create_file_list_port(pj_pool_t *pool, const pj_str_t *name) { struct playlist_port *port; port = pj_pool_zalloc(pool, sizeof(struct playlist_port)); if (!port) return NULL; /* Put in default values. * These will be overriden once the file is read. */ pjmedia_port_info_init(&port->base.info, name, SIGNATURE, 8000, 1, 16, 80); port->base.get_frame = &file_list_get_frame; port->base.on_destroy = &file_list_on_destroy; return port; }
PJ_DEF(pj_status_t) pjmedia_echo_port_create(pj_pool_t *pool, pjmedia_port *dn_port, unsigned tail_ms, unsigned latency_ms, unsigned options, pjmedia_port **p_port ) { const pj_str_t AEC = { "EC", 2 }; struct ec *ec; pj_status_t status; PJ_ASSERT_RETURN(pool && dn_port && p_port, PJ_EINVAL); PJ_ASSERT_RETURN(dn_port->info.bits_per_sample==16 && tail_ms, PJ_EINVAL); /* Create the port and the AEC itself */ ec = pj_pool_zalloc(pool, sizeof(struct ec)); pjmedia_port_info_init(&ec->base.info, &AEC, SIGNATURE, dn_port->info.clock_rate, dn_port->info.channel_count, dn_port->info.bits_per_sample, dn_port->info.samples_per_frame); status = pjmedia_echo_create(pool, dn_port->info.clock_rate, dn_port->info.samples_per_frame, tail_ms, latency_ms, options, &ec->ec); if (status != PJ_SUCCESS) return status; /* More init */ ec->dn_port = dn_port; ec->base.get_frame = &ec_get_frame; ec->base.put_frame = &ec_put_frame; ec->base.on_destroy = &ec_on_destroy; /* Done */ *p_port = &ec->base; return PJ_SUCCESS; }
/* Helper function to create "incoming" packet */ struct recv_list *create_incoming_packet( struct loop_transport *loop, pjsip_tx_data *tdata ) { pj_pool_t *pool; struct recv_list *pkt; pool = pjsip_endpt_create_pool(loop->base.endpt, "rdata", PJSIP_POOL_RDATA_LEN, PJSIP_POOL_RDATA_INC+5); if (!pool) return NULL; pkt = pj_pool_zalloc(pool, sizeof(struct recv_list)); /* Initialize rdata. */ pkt->rdata.tp_info.pool = pool; pkt->rdata.tp_info.transport = &loop->base; /* Copy the packet. */ pj_memcpy(pkt->rdata.pkt_info.packet, tdata->buf.start, tdata->buf.cur - tdata->buf.start); pkt->rdata.pkt_info.len = tdata->buf.cur - tdata->buf.start; /* "Source address" info. */ pkt->rdata.pkt_info.src_addr_len = sizeof(pj_sockaddr_in); if (loop->base.key.type == PJSIP_TRANSPORT_LOOP) pj_ansi_strcpy(pkt->rdata.pkt_info.src_name, ADDR_LOOP); else pj_ansi_strcpy(pkt->rdata.pkt_info.src_name, ADDR_LOOP_DGRAM); pkt->rdata.pkt_info.src_port = loop->base.local_name.port; /* When do we need to "deliver" this packet. */ pj_gettimeofday(&pkt->rdata.pkt_info.timestamp); pkt->rdata.pkt_info.timestamp.msec += loop->recv_delay; pj_time_val_normalize(&pkt->rdata.pkt_info.timestamp); /* Done. */ return pkt; }
PJ_DECL(pj_status_t) pjmedia_plc_port_create(pj_pool_t *pool, pjmedia_port *dn_port, pjmedia_codec *codec, unsigned fpp, em_plc_mode plc_mode, pjmedia_port **p_port) { const pj_str_t plc = { "plc", 3 }; struct plc_port *plcp; pj_status_t status; PJ_ASSERT_RETURN(pool && dn_port && p_port, PJ_EINVAL); /* Create the port itself */ plcp = PJ_POOL_ZALLOC_T(pool, struct plc_port); plcp->frame_buf = pj_pool_zalloc(pool, BUF_SIZE); pjmedia_port_info_init(&plcp->base.info, &plc, SIGNATURE, dn_port->info.clock_rate, dn_port->info.channel_count, dn_port->info.bits_per_sample, dn_port->info.samples_per_frame*fpp); /* More init */ plcp->dn_port = dn_port; plcp->codec = codec; plcp->fpp = fpp; plcp->plc_mode = plc_mode; plcp->base.get_frame = &plc_get_frame; plcp->base.put_frame = &plc_put_frame; plcp->base.on_destroy = &plc_on_destroy; plcp->frame.type = PJMEDIA_FRAME_TYPE_NONE; plcp->frame.buf = plcp->frame_buf; plcp->stats.received = 0; plcp->stats.lost = 0; plcp->stats.total = 0; /* Done */ *p_port = &plcp->base; return PJ_SUCCESS; }
/*! * \internal * \brief Implements PJSIP_HEADER 'add' by inserting the specified header into thge list. * * Retrieve the header_datastore from the session or create one if it doesn't exist. * Create and initialize the list if needed. * Create the pj_strs for name and value. * Create pjsip_msg and hdr_list_entry. * Add the entry to the list. */ static int add_header(void *obj) { struct header_data *data = obj; struct ast_sip_session *session = data->channel->session; pj_pool_t *pool = session->inv_session->dlg->pool; pj_str_t pj_header_name; pj_str_t pj_header_value; struct hdr_list_entry *le; struct hdr_list *list; RAII_VAR(struct ast_datastore *, datastore, ast_sip_session_get_datastore(session, header_datastore.type), ao2_cleanup); if (!datastore) { if (!(datastore = ast_sip_session_alloc_datastore(&header_datastore, header_datastore.type)) || !(datastore->data = pj_pool_alloc(pool, sizeof(struct hdr_list))) || ast_sip_session_add_datastore(session, datastore)) { ast_log(AST_LOG_ERROR, "Unable to create datastore for header functions.\n"); return -1; } AST_LIST_HEAD_INIT((struct hdr_list *) datastore->data); } ast_debug(1, "Adding header %s with value %s\n", data->header_name, data->header_value); pj_cstr(&pj_header_name, data->header_name); pj_cstr(&pj_header_value, data->header_value); le = pj_pool_zalloc(pool, sizeof(struct hdr_list_entry)); le->hdr = (pjsip_hdr *) pjsip_generic_string_hdr_create(pool, &pj_header_name, &pj_header_value); list = datastore->data; AST_LIST_INSERT_TAIL(list, le, nextptr); return 0; }
/** * Create UDP stream transport from existing socket info. */ PJ_DEF(pj_status_t) pjmedia_transport_udp_attach( pjmedia_endpt *endpt, const char *name, const pjmedia_sock_info *si, unsigned options, pjmedia_transport **p_tp) { struct transport_udp *tp; pj_pool_t *pool; pj_ioqueue_t *ioqueue; pj_ioqueue_callback rtp_cb, rtcp_cb; pj_ssize_t size; unsigned i; pj_status_t status; /* Sanity check */ PJ_ASSERT_RETURN(endpt && si && p_tp, PJ_EINVAL); /* Check name */ if (!name) name = "udpmedia"; /* Get ioqueue instance */ ioqueue = pjmedia_endpt_get_ioqueue(endpt); /* Create transport structure */ pool = pjmedia_endpt_create_pool(endpt, name, 4000, 4000); if (!pool) return PJ_ENOMEM; tp = pj_pool_zalloc(pool, sizeof(struct transport_udp)); tp->pool = pool; tp->options = options; pj_ansi_strcpy(tp->base.name, name); tp->base.op = &transport_udp_op; /* Copy socket infos */ tp->rtp_sock = si->rtp_sock; tp->rtp_addr_name = si->rtp_addr_name; tp->rtcp_sock = si->rtcp_sock; tp->rtcp_addr_name = si->rtcp_addr_name; /* If address is 0.0.0.0, use host's IP address */ if (tp->rtp_addr_name.sin_addr.s_addr == 0) { pj_in_addr hostip; status = pj_gethostip(&hostip); if (status != PJ_SUCCESS) goto on_error; tp->rtp_addr_name.sin_addr = hostip; } /* Same with RTCP */ if (tp->rtcp_addr_name.sin_addr.s_addr == 0) { tp->rtcp_addr_name.sin_addr.s_addr = tp->rtp_addr_name.sin_addr.s_addr; } /* Setup RTP socket with the ioqueue */ pj_bzero(&rtp_cb, sizeof(rtp_cb)); rtp_cb.on_read_complete = &on_rx_rtp; status = pj_ioqueue_register_sock(pool, ioqueue, tp->rtp_sock, tp, &rtp_cb, &tp->rtp_key); if (status != PJ_SUCCESS) goto on_error; pj_ioqueue_op_key_init(&tp->rtp_read_op, sizeof(tp->rtp_read_op)); for (i=0; i<PJ_ARRAY_SIZE(tp->rtp_pending_write); ++i) pj_ioqueue_op_key_init(&tp->rtp_pending_write[i].op_key, sizeof(tp->rtp_pending_write[i].op_key)); /* Kick of pending RTP read from the ioqueue */ tp->rtp_addrlen = sizeof(tp->rtp_src_addr); size = sizeof(tp->rtp_pkt); status = pj_ioqueue_recvfrom(tp->rtp_key, &tp->rtp_read_op, tp->rtp_pkt, &size, PJ_IOQUEUE_ALWAYS_ASYNC, &tp->rtp_src_addr, &tp->rtp_addrlen); if (status != PJ_EPENDING) goto on_error; /* Setup RTCP socket with ioqueue */ pj_bzero(&rtcp_cb, sizeof(rtcp_cb)); rtcp_cb.on_read_complete = &on_rx_rtcp; status = pj_ioqueue_register_sock(pool, ioqueue, tp->rtcp_sock, tp, &rtcp_cb, &tp->rtcp_key); if (status != PJ_SUCCESS) goto on_error; pj_ioqueue_op_key_init(&tp->rtcp_read_op, sizeof(tp->rtcp_read_op)); pj_ioqueue_op_key_init(&tp->rtcp_write_op, sizeof(tp->rtcp_write_op)); /* Kick of pending RTCP read from the ioqueue */ size = sizeof(tp->rtcp_pkt); tp->rtcp_addr_len = sizeof(tp->rtcp_src_addr); status = pj_ioqueue_recvfrom( tp->rtcp_key, &tp->rtcp_read_op, tp->rtcp_pkt, &size, PJ_IOQUEUE_ALWAYS_ASYNC, &tp->rtcp_src_addr, &tp->rtcp_addr_len); if (status != PJ_EPENDING) goto on_error; /* Done */ *p_tp = &tp->base; return PJ_SUCCESS; on_error: pjmedia_transport_udp_close(&tp->base); return status; }
/* Calculate the bandwidth for the specific test configuration. * The test is simple: * - create sockpair_cnt number of producer-consumer socket pair. * - create thread_cnt number of worker threads. * - each producer will send buffer_size bytes data as fast and * as soon as it can. * - each consumer will read buffer_size bytes of data as fast * as it could. * - measure the total bytes received by all consumers during a * period of time. */ static int perform_test(pj_bool_t allow_concur, int sock_type, const char *type_name, unsigned thread_cnt, unsigned sockpair_cnt, pj_size_t buffer_size, pj_size_t *p_bandwidth) { enum { MSEC_DURATION = 5000 }; pj_pool_t *pool; test_item *items; pj_thread_t **thread; pj_ioqueue_t *ioqueue; pj_status_t rc; pj_ioqueue_callback ioqueue_callback; pj_uint32_t total_elapsed_usec, total_received; pj_highprec_t bandwidth; pj_timestamp start, stop; unsigned i; TRACE_((THIS_FILE, " starting test..")); ioqueue_callback.on_read_complete = &on_read_complete; ioqueue_callback.on_write_complete = &on_write_complete; thread_quit_flag = 0; pool = pj_pool_create(mem, NULL, 4096, 4096, NULL); if (!pool) return -10; items = (test_item*) pj_pool_alloc(pool, sockpair_cnt*sizeof(test_item)); thread = (pj_thread_t**) pj_pool_alloc(pool, thread_cnt*sizeof(pj_thread_t*)); TRACE_((THIS_FILE, " creating ioqueue..")); rc = pj_ioqueue_create(pool, sockpair_cnt*2, &ioqueue); if (rc != PJ_SUCCESS) { app_perror("...error: unable to create ioqueue", rc); return -15; } rc = pj_ioqueue_set_default_concurrency(ioqueue, allow_concur); if (rc != PJ_SUCCESS) { app_perror("...error: pj_ioqueue_set_default_concurrency()", rc); return -16; } /* Initialize each producer-consumer pair. */ for (i=0; i<sockpair_cnt; ++i) { pj_ssize_t bytes; items[i].ioqueue = ioqueue; items[i].buffer_size = buffer_size; items[i].outgoing_buffer = (char*) pj_pool_alloc(pool, buffer_size); items[i].incoming_buffer = (char*) pj_pool_alloc(pool, buffer_size); items[i].bytes_recv = items[i].bytes_sent = 0; /* randomize outgoing buffer. */ pj_create_random_string(items[i].outgoing_buffer, buffer_size); /* Create socket pair. */ TRACE_((THIS_FILE, " calling socketpair..")); rc = app_socketpair(pj_AF_INET(), sock_type, 0, &items[i].server_fd, &items[i].client_fd); if (rc != PJ_SUCCESS) { app_perror("...error: unable to create socket pair", rc); return -20; } /* Register server socket to ioqueue. */ TRACE_((THIS_FILE, " register(1)..")); rc = pj_ioqueue_register_sock(pool, ioqueue, items[i].server_fd, &items[i], &ioqueue_callback, &items[i].server_key); if (rc != PJ_SUCCESS) { app_perror("...error: registering server socket to ioqueue", rc); return -60; } /* Register client socket to ioqueue. */ TRACE_((THIS_FILE, " register(2)..")); rc = pj_ioqueue_register_sock(pool, ioqueue, items[i].client_fd, &items[i], &ioqueue_callback, &items[i].client_key); if (rc != PJ_SUCCESS) { app_perror("...error: registering server socket to ioqueue", rc); return -70; } /* Start reading. */ TRACE_((THIS_FILE, " pj_ioqueue_recv..")); bytes = items[i].buffer_size; rc = pj_ioqueue_recv(items[i].server_key, &items[i].recv_op, items[i].incoming_buffer, &bytes, 0); if (rc != PJ_EPENDING) { app_perror("...error: pj_ioqueue_recv", rc); return -73; } /* Start writing. */ TRACE_((THIS_FILE, " pj_ioqueue_write..")); bytes = items[i].buffer_size; rc = pj_ioqueue_send(items[i].client_key, &items[i].send_op, items[i].outgoing_buffer, &bytes, 0); if (rc != PJ_SUCCESS && rc != PJ_EPENDING) { app_perror("...error: pj_ioqueue_write", rc); return -76; } items[i].has_pending_send = (rc==PJ_EPENDING); } /* Create the threads. */ for (i=0; i<thread_cnt; ++i) { struct thread_arg *arg; arg = (struct thread_arg*) pj_pool_zalloc(pool, sizeof(*arg)); arg->id = i; arg->ioqueue = ioqueue; arg->counter = 0; rc = pj_thread_create( pool, NULL, &worker_thread, arg, PJ_THREAD_DEFAULT_STACK_SIZE, PJ_THREAD_SUSPENDED, &thread[i] ); if (rc != PJ_SUCCESS) { app_perror("...error: unable to create thread", rc); return -80; } } /* Mark start time. */ rc = pj_get_timestamp(&start); if (rc != PJ_SUCCESS) return -90; /* Start the thread. */ TRACE_((THIS_FILE, " resuming all threads..")); for (i=0; i<thread_cnt; ++i) { rc = pj_thread_resume(thread[i]); if (rc != 0) return -100; } /* Wait for MSEC_DURATION seconds. * This should be as simple as pj_thread_sleep(MSEC_DURATION) actually, * but unfortunately it doesn't work when system doesn't employ * timeslicing for threads. */ TRACE_((THIS_FILE, " wait for few seconds..")); do { pj_thread_sleep(1); /* Mark end time. */ rc = pj_get_timestamp(&stop); if (thread_quit_flag) { TRACE_((THIS_FILE, " transfer limit reached..")); break; } if (pj_elapsed_usec(&start,&stop)<MSEC_DURATION * 1000) { TRACE_((THIS_FILE, " time limit reached..")); break; } } while (1); /* Terminate all threads. */ TRACE_((THIS_FILE, " terminating all threads..")); thread_quit_flag = 1; for (i=0; i<thread_cnt; ++i) { TRACE_((THIS_FILE, " join thread %d..", i)); pj_thread_join(thread[i]); } /* Close all sockets. */ TRACE_((THIS_FILE, " closing all sockets..")); for (i=0; i<sockpair_cnt; ++i) { pj_ioqueue_unregister(items[i].server_key); pj_ioqueue_unregister(items[i].client_key); } /* Destroy threads */ for (i=0; i<thread_cnt; ++i) { pj_thread_destroy(thread[i]); } /* Destroy ioqueue. */ TRACE_((THIS_FILE, " destroying ioqueue..")); pj_ioqueue_destroy(ioqueue); /* Calculate actual time in usec. */ total_elapsed_usec = pj_elapsed_usec(&start, &stop); /* Calculate total bytes received. */ total_received = 0; for (i=0; i<sockpair_cnt; ++i) { total_received = (pj_uint32_t)items[i].bytes_recv; } /* bandwidth = total_received*1000/total_elapsed_usec */ bandwidth = total_received; pj_highprec_mul(bandwidth, 1000); pj_highprec_div(bandwidth, total_elapsed_usec); *p_bandwidth = (pj_uint32_t)bandwidth; PJ_LOG(3,(THIS_FILE, " %.4s %2d %2d %8d KB/s", type_name, thread_cnt, sockpair_cnt, *p_bandwidth)); /* Done. */ pj_pool_release(pool); TRACE_((THIS_FILE, " done..")); return 0; }