MPF_DECLARE(mpf_object_t*) mpf_bridge_create(
mpf_audio_stream_t *source,
mpf_audio_stream_t *sink,
const mpf_codec_manager_t *codec_manager,
const char *name,
apr_pool_t *pool)
{
if(!source || !sink) {
return NULL;
}
if(mpf_audio_stream_rx_validate(source,sink->tx_descriptor,sink->tx_event_descriptor,pool) == FALSE ||
mpf_audio_stream_tx_validate(sink,source->rx_descriptor,source->rx_event_descriptor,pool) == FALSE) {
return NULL;
}
if(mpf_codec_descriptors_match(source->rx_descriptor,sink->tx_descriptor) == TRUE) {
return mpf_null_bridge_create(source,sink,codec_manager,name,pool);
}
if(mpf_codec_lpcm_descriptor_match(source->rx_descriptor) == FALSE) {
mpf_codec_t *codec = mpf_codec_manager_codec_get(codec_manager,source->rx_descriptor,pool);
if(codec) {
/* set decoder before bridge */
mpf_audio_stream_t *decoder = mpf_decoder_create(source,codec,pool);
source = decoder;
}
}
if(mpf_codec_lpcm_descriptor_match(sink->tx_descriptor) == FALSE) {
mpf_codec_t *codec = mpf_codec_manager_codec_get(codec_manager,sink->tx_descriptor,pool);
if(codec) {
/* set encoder after bridge */
mpf_audio_stream_t *encoder = mpf_encoder_create(sink,codec,pool);
sink = encoder;
}
}
if(source->rx_descriptor->sampling_rate != sink->tx_descriptor->sampling_rate) {
/* set resampler before bridge */
mpf_audio_stream_t *resampler = mpf_resampler_create(source,sink,pool);
if(!resampler) {
return NULL;
}
source = resampler;
}
return mpf_linear_bridge_create(source,sink,codec_manager,name,pool);
}
static mpf_object_t* mpf_null_bridge_create(mpf_audio_stream_t *source, mpf_audio_stream_t *sink, const mpf_codec_manager_t *codec_manager, const char *name, apr_pool_t *pool)
{
mpf_codec_t *codec;
apr_size_t frame_size;
mpf_bridge_t *bridge;
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Create Null Audio Bridge %s",name);
bridge = mpf_bridge_base_create(source,sink,name,pool);
if(!bridge) {
return NULL;
}
bridge->base.process = mpf_null_bridge_process;
codec = mpf_codec_manager_codec_get(codec_manager,source->rx_descriptor,pool);
if(!codec) {
return NULL;
}
frame_size = mpf_codec_frame_size_calculate(source->rx_descriptor,codec->attribs);
bridge->codec = codec;
bridge->frame.codec_frame.size = frame_size;
bridge->frame.codec_frame.buffer = apr_palloc(pool,frame_size);
if(mpf_audio_stream_rx_open(source,codec) == FALSE) {
return NULL;
}
if(mpf_audio_stream_tx_open(sink,codec) == FALSE) {
mpf_audio_stream_rx_close(source);
return NULL;
}
return &bridge->base;
}
static mpf_codec_t* mpf_termination_default_codec_create(mpf_termination_t *termination)
{
mpf_codec_t *codec;
const mpf_codec_descriptor_t *default_descriptor = l16_descriptor_get();
mpf_codec_descriptor_t *descriptor = apr_palloc(termination->pool,sizeof(mpf_codec_descriptor_t));
mpf_codec_descriptor_init(descriptor);
*descriptor = *default_descriptor;
codec = mpf_codec_manager_codec_get(
termination->codec_manager,
descriptor,
termination->pool);
return codec;
}
/** Create engine channel and source media termination */
mrcp_engine_channel_t* mrcp_engine_source_channel_create(
mrcp_resource_engine_t *engine,
const mrcp_engine_channel_method_vtable_t *channel_vtable,
const mpf_audio_stream_vtable_t *stream_vtable,
void *method_obj,
mpf_codec_descriptor_t *codec_descriptor,
apr_pool_t *pool)
{
mpf_audio_stream_t *audio_stream;
mpf_termination_t *termination;
/* create audio stream */
audio_stream = mpf_audio_stream_create(
method_obj, /* object to associate */
stream_vtable, /* virtual methods table of audio stream */
STREAM_MODE_RECEIVE, /* stream mode/direction */
pool); /* pool to allocate memory from */
if(engine->codec_manager) {
audio_stream->rx_codec = mpf_codec_manager_codec_get(engine->codec_manager,codec_descriptor,pool);
}
/* create media termination */
termination = mpf_raw_termination_create(
NULL, /* no object to associate */
audio_stream, /* audio stream */
NULL, /* no video stream */
pool); /* pool to allocate memory from */
/* create engine channel base */
return mrcp_engine_channel_create(
engine, /* resource engine */
channel_vtable, /* virtual methods table of engine channel */
method_obj, /* object to associate */
termination, /* media termination, used to terminate audio stream */
pool); /* pool to allocate memory from */
}
MPF_DECLARE(mpf_object_t*) mpf_mixer_create(
mpf_audio_stream_t **source_arr,
apr_size_t source_count,
mpf_audio_stream_t *sink,
const mpf_codec_manager_t *codec_manager,
const char *name,
apr_pool_t *pool)
{
apr_size_t i;
apr_size_t frame_size;
mpf_codec_descriptor_t *descriptor;
mpf_audio_stream_t *source;
mpf_mixer_t *mixer;
if(!source_arr || !source_count || !sink) {
return NULL;
}
apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Create Mixer %s",name);
mixer = apr_palloc(pool,sizeof(mpf_mixer_t));
mixer->source_arr = NULL;
mixer->source_count = 0;
mixer->sink = NULL;
mpf_object_init(&mixer->base,name);
mixer->base.process = mpf_mixer_process;
mixer->base.destroy = mpf_mixer_destroy;
mixer->base.trace = mpf_mixer_trace;
if(mpf_audio_stream_tx_validate(sink,NULL,NULL,pool) == FALSE) {
return NULL;
}
descriptor = sink->tx_descriptor;
if(descriptor && mpf_codec_lpcm_descriptor_match(descriptor) == FALSE) {
mpf_codec_t *codec = mpf_codec_manager_codec_get(codec_manager,descriptor,pool);
if(codec) {
/* set encoder after mixer */
mpf_audio_stream_t *encoder = mpf_encoder_create(sink,codec,pool);
sink = encoder;
}
}
mixer->sink = sink;
mpf_audio_stream_tx_open(sink,NULL);
for(i=0; i<source_count; i++) {
source = source_arr[i];
if(!source) continue;
if(mpf_audio_stream_rx_validate(source,NULL,NULL,pool) == FALSE) {
continue;
}
descriptor = source->rx_descriptor;
if(descriptor && mpf_codec_lpcm_descriptor_match(descriptor) == FALSE) {
mpf_codec_t *codec = mpf_codec_manager_codec_get(codec_manager,descriptor,pool);
if(codec) {
/* set decoder before mixer */
mpf_audio_stream_t *decoder = mpf_decoder_create(source,codec,pool);
source = decoder;
}
}
source_arr[i] = source;
mpf_audio_stream_rx_open(source,NULL);
}
mixer->source_arr = source_arr;
mixer->source_count = source_count;
descriptor = sink->tx_descriptor;
frame_size = mpf_codec_linear_frame_size_calculate(descriptor->sampling_rate,descriptor->channel_count);
mixer->frame.codec_frame.size = frame_size;
mixer->frame.codec_frame.buffer = apr_palloc(pool,frame_size);
mixer->mix_frame.codec_frame.size = frame_size;
mixer->mix_frame.codec_frame.buffer = apr_palloc(pool,frame_size);
return &mixer->base;
}
