int tdav_consumer_audio_set(tdav_consumer_audio_t* self, const tmedia_param_t* param)
{
if(!self){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
if(param->plugin_type == tmedia_ppt_consumer){
if(param->value_type == tmedia_pvt_int32){
if(tsk_striequals(param->key, "gain")){
int32_t gain = *((int32_t*)param->value);
if(gain<TDAV_AUDIO_GAIN_MAX && gain>=0){
TMEDIA_CONSUMER(self)->audio.gain = (uint8_t)gain;
TSK_DEBUG_INFO("audio consumer gain=%u", gain);
}
else{
TSK_DEBUG_ERROR("%u is invalid as gain value", gain);
return -2;
}
}
else if(tsk_striequals(param->key, "volume")){
TMEDIA_CONSUMER(self)->audio.volume = TSK_TO_INT32((uint8_t*)param->value);
TMEDIA_CONSUMER(self)->audio.volume = TSK_CLAMP(0, TMEDIA_CONSUMER(self)->audio.volume, 100);
}
}
}
return 0;
}
/* ============ Media Producer Interface ================= */
static int _tdav_producer_video_v4l2_set(tmedia_producer_t *p_self, const tmedia_param_t* pc_param)
{
int ret = 0;
tdav_producer_video_v4l2_t* p_v4l2 = (tdav_producer_video_v4l2_t*)p_self;
if (!p_v4l2 || !pc_param) {
V4L2_DEBUG_ERROR("Invalid parameter");
return -1;
}
if (pc_param->value_type == tmedia_pvt_pchar) {
if (tsk_striequals(pc_param->key, "local-hwnd") || tsk_striequals(pc_param->key, "preview-hwnd")) {
V4L2_DEBUG_ERROR("Not implemented yet");
}
else if (tsk_striequals(pc_param->key, "src-hwnd")) {
V4L2_DEBUG_ERROR("Not implemented yet");
}
}
else if (pc_param->value_type == tmedia_pvt_int32) {
if (tsk_striequals(pc_param->key, "mute")) {
p_v4l2->b_muted = (TSK_TO_INT32((uint8_t*)pc_param->value) != 0);
}
}
return ret;
}
/* ============ Media Producer Interface ================= */
int tdav_producer_audiounit_set(tmedia_producer_t* self, const tmedia_param_t* param)
{
if(param->plugin_type == tmedia_ppt_producer){
if(param->value_type == tmedia_pvt_int32){
if(tsk_striequals(param->key, "mute")){
int32_t mute = TSK_TO_INT32((uint8_t*)param->value);
return tdav_audiounit_handle_mute(((tdav_producer_audiounit_t*)self)->audioUnitHandle, mute ? tsk_true : tsk_false);
}
}
}
return tdav_producer_audio_set(TDAV_PRODUCER_AUDIO(self), param);
}
//#define tdav_producer_audioqueue_set tsk_null
int tdav_producer_audioqueue_set(tmedia_producer_t* self, const tmedia_param_t* param)
{
tdav_producer_audioqueue_t* producer = (tdav_producer_audioqueue_t*)self;
if(param->plugin_type == tmedia_ppt_producer){
if(param->value_type == tmedia_pvt_int32){
if(tsk_striequals(param->key, "mute")){
producer->muted = TSK_TO_INT32((uint8_t*)param->value);
return 1;
}
}
}
return tdav_producer_audio_set(TDAV_PRODUCER_AUDIO(self), param);
}
static int tdav_codec_mp4ves_set(tmedia_codec_t* self, const tmedia_param_t* param)
{
tdav_codec_mp4ves_t* mp4ves = (tdav_codec_mp4ves_t*)self;
if(!self->opened){
TSK_DEBUG_ERROR("Codec not opened");
return -1;
}
if(param->value_type == tmedia_pvt_int32){
if(tsk_striequals(param->key, "action")){
tmedia_codec_action_t action = (tmedia_codec_action_t)TSK_TO_INT32((uint8_t*)param->value);
switch(action){
case tmedia_codec_action_encode_idr:
{
mp4ves->encoder.force_idr = tsk_true;
break;
}
case tmedia_codec_action_bw_down:
{
mp4ves->encoder.quality = TSK_CLAMP(1, (mp4ves->encoder.quality + 1), 31);
mp4ves->encoder.context->global_quality = FF_QP2LAMBDA * mp4ves->encoder.quality;
break;
}
case tmedia_codec_action_bw_up:
{
mp4ves->encoder.quality = TSK_CLAMP(1, (mp4ves->encoder.quality - 1), 31);
mp4ves->encoder.context->global_quality = FF_QP2LAMBDA * mp4ves->encoder.quality;
break;
}
}
}
else if(tsk_striequals(param->key, "rotation")){
int rotation = *((int32_t*)param->value);
if(mp4ves->encoder.rotation != rotation){
if(self->opened){
int ret;
mp4ves->encoder.rotation = rotation;
if((ret = tdav_codec_mp4ves_close_encoder(mp4ves))){
return ret;
}
if((ret = tdav_codec_mp4ves_open_encoder(mp4ves))){
return ret;
}
}
}
return 0;
}
}
return -1;
}
/* ============ Media Producer Interface ================= */
int tdav_producer_audiounit_set(tmedia_producer_t* self, const tmedia_param_t* param)
{
tdav_producer_audiounit_t* producer = (tdav_producer_audiounit_t*)self;
if(param->plugin_type == tmedia_ppt_producer){
if(param->value_type == tmedia_pvt_int32){
if (tsk_striequals(param->key, "mute")) {
producer->muted = TSK_TO_INT32((uint8_t*)param->value);
return tdav_audiounit_handle_mute(((tdav_producer_audiounit_t*)self)->audioUnitHandle, producer->muted);
}
else if (tsk_striequals(param->key, "interrupt")) {
int32_t interrupt = *((uint8_t*)param->value) ? 1 : 0;
return tdav_audiounit_handle_interrupt(producer->audioUnitHandle, interrupt);
}
}
}
return tdav_producer_audio_set(TDAV_PRODUCER_AUDIO(self), param);
}
static int tdav_codec_h264_set(tmedia_codec_t* self, const tmedia_param_t* param)
{
tdav_codec_h264_t* h264 = (tdav_codec_h264_t*)self;
if (param->value_type == tmedia_pvt_int32) {
if(tsk_striequals(param->key, "action")){
tmedia_codec_action_t action = (tmedia_codec_action_t)TSK_TO_INT32((uint8_t*)param->value);
switch(action){
case tmedia_codec_action_encode_idr:
{
h264->encoder.force_idr = tsk_true;
break;
}
case tmedia_codec_action_bw_down:
{
h264->encoder.quality = TSK_CLAMP(1, (h264->encoder.quality + 1), 31);
#if HAVE_FFMPEG
if (h264->encoder.context) {
h264->encoder.context->global_quality = FF_QP2LAMBDA * h264->encoder.quality;
}
#endif
break;
}
case tmedia_codec_action_bw_up:
{
h264->encoder.quality = TSK_CLAMP(1, (h264->encoder.quality - 1), 31);
#if HAVE_FFMPEG
if (h264->encoder.context) {
h264->encoder.context->global_quality = FF_QP2LAMBDA * h264->encoder.quality;
}
#endif
break;
}
}
return 0;
}
else if(tsk_striequals(param->key, "bw_kbps")){
int32_t max_bw_userdefine = self->bandwidth_max_upload;
int32_t max_bw_new = *((int32_t*)param->value);
if (max_bw_userdefine > 0) {
// do not use more than what the user defined in it's configuration
h264->encoder.max_bw_kpbs = TSK_MIN(max_bw_new, max_bw_userdefine);
}
else {
h264->encoder.max_bw_kpbs = max_bw_new;
}
return 0;
}
else if(tsk_striequals(param->key, "bypass-encoding")){
h264->encoder.passthrough = *((int32_t*)param->value) ? tsk_true : tsk_false;
TSK_DEBUG_INFO("[H.264] bypass-encoding = %d", h264->encoder.passthrough);
return 0;
}
else if(tsk_striequals(param->key, "bypass-decoding")){
h264->decoder.passthrough = *((int32_t*)param->value) ? tsk_true : tsk_false;
TSK_DEBUG_INFO("[H.264] bypass-decoding = %d", h264->decoder.passthrough);
return 0;
}
else if(tsk_striequals(param->key, "rotation")){
int32_t rotation = *((int32_t*)param->value);
if(h264->encoder.rotation != rotation){
h264->encoder.rotation = rotation;
if (self->opened) {
int ret;
if ((ret = tdav_codec_h264_close_encoder(h264, kResetRotationFalse))) {
return ret;
}
if ((ret = tdav_codec_h264_open_encoder(h264))) {
return ret;
}
#if 0 // Not working
if((ret = avcodec_close(h264->encoder.context))){
TSK_DEBUG_ERROR("Failed to close [%s] codec", TMEDIA_CODEC(h264)->plugin->desc);
return ret;
}
h264->encoder.context->width = (rotation == 90 || rotation == 270) ? TMEDIA_CODEC_VIDEO(h264)->out.height : TMEDIA_CODEC_VIDEO(h264)->out.width;
h264->encoder.context->height = (rotation == 90 || rotation == 270) ? TMEDIA_CODEC_VIDEO(h264)->out.width : TMEDIA_CODEC_VIDEO(h264)->out.height;
if((ret = avcodec_open(h264->encoder.context, h264->encoder.codec)) < 0){
TSK_DEBUG_ERROR("Failed to open [%s] codec", TMEDIA_CODEC(h264)->plugin->desc);
return ret;
}
h264->encoder.force_idr = tsk_true;
#endif
}
}
return 0;
}
}
return -1;
}
