diff options
Diffstat (limited to 'bindings/_common/ProxyConsumer.cxx')
| -rw-r--r-- | bindings/_common/ProxyConsumer.cxx | 815 |
1 files changed, 815 insertions, 0 deletions
diff --git a/bindings/_common/ProxyConsumer.cxx b/bindings/_common/ProxyConsumer.cxx new file mode 100644 index 0000000..2150654 --- /dev/null +++ b/bindings/_common/ProxyConsumer.cxx @@ -0,0 +1,815 @@ +/* +* Copyright (C) 2010-2011 Mamadou Diop. +* +* Contact: Mamadou Diop <diopmamadou(at)doubango.org> +* +* This file is part of Open Source Doubango Framework. +* +* DOUBANGO is free software: you can redistribute it and/or modify +* it under the terms of the GNU General Public License as published by +* the Free Software Foundation, either version 3 of the License, or +* (at your option) any later version. +* +* DOUBANGO is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with DOUBANGO. +* +*/ + +/**@file ProxyConsumer.c + * @brief Audio/Video proxy consumers. + * + * @author Mamadou Diop <diopmamadou(at)doubango.org> + * + + */ +#include "ProxyConsumer.h" + +#include "AudioResampler.h" + +#include "tsk_memory.h" +#include "tsk_debug.h" + +#include "tinydav/audio/tdav_consumer_audio.h" +#include "tinydav/video/tdav_consumer_video.h" + + +/* ============ Audio Consumer Interface ================= */ + +typedef struct twrap_consumer_proxy_audio_s +{ + TDAV_DECLARE_CONSUMER_AUDIO; + + uint64_t id; + tsk_bool_t started; + const ProxyAudioConsumer* pcConsumer; // thread-safe and will be destroyed at the time as the "struct" +} +twrap_consumer_proxy_audio_t; +#define TWRAP_CONSUMER_PROXY_AUDIO(self) ((twrap_consumer_proxy_audio_t*)(self)) + +int twrap_consumer_proxy_audio_set(tmedia_consumer_t* _self, const tmedia_param_t* param) +{ + twrap_consumer_proxy_audio_t* self = (twrap_consumer_proxy_audio_t*)_self; + if(param->plugin_type == tmedia_ppt_consumer){ + // specific proxy consumer + } + return tdav_consumer_audio_set(TDAV_CONSUMER_AUDIO(self), param); +} + +int twrap_consumer_proxy_audio_prepare(tmedia_consumer_t* self, const tmedia_codec_t* codec) +{ + twrap_consumer_proxy_audio_t* audio = TWRAP_CONSUMER_PROXY_AUDIO(self); + ProxyPluginMgr* manager = NULL; + int ret = -1; + if(codec && (manager = ProxyPluginMgr::getInstance())){ + if((audio->pcConsumer = manager->findAudioConsumer(audio->id)) && audio->pcConsumer->getCallback()){ + self->audio.ptime = TMEDIA_CODEC_PTIME_AUDIO_DECODING(codec); + self->audio.in.channels = TMEDIA_CODEC_CHANNELS_AUDIO_DECODING(codec); + self->audio.in.rate = TMEDIA_CODEC_RATE_DECODING(codec); + + ret = audio->pcConsumer->getCallback()->prepare((int)self->audio.ptime, self->audio.in.rate, self->audio.in.channels); + if(ret == 0 && !audio->pcConsumer->getCallback()->isPivotSettings()){ + // say consumer can output these params + // Out "rate" and "channels" must be defined regardless previous values (already the case in other back-ends) to avoid issues on reINVITE with rate change (e.g. Opus -> PCMA). + /*if(!self->audio.out.rate)*/ self->audio.out.rate = self->audio.in.rate; + /*if(!self->audio.out.channels)*/ self->audio.out.channels = self->audio.in.channels; + } + } + } + else { + TSK_DEBUG_ERROR("Invalid parameter/state: codec=%d, manager=%s", codec, manager ? "no-null" : "null"); + } + + return ret; +} + +int twrap_consumer_proxy_audio_start(tmedia_consumer_t* self) +{ + ProxyPluginMgr* manager; + int ret = -1; + if((manager = ProxyPluginMgr::getInstance())){ + const ProxyAudioConsumer* audioConsumer; + if((audioConsumer = manager->findAudioConsumer(TWRAP_CONSUMER_PROXY_AUDIO(self)->id)) && audioConsumer->getCallback()){ + ret = audioConsumer->getCallback()->start(); + } + } + + TWRAP_CONSUMER_PROXY_AUDIO(self)->started = (ret == 0); + return ret; +} + +int twrap_consumer_proxy_audio_consume(tmedia_consumer_t* self, const void* buffer, tsk_size_t size, const tsk_object_t* proto_hdr) +{ + twrap_consumer_proxy_audio_t* audio = TWRAP_CONSUMER_PROXY_AUDIO(self); + + if(!audio->pcConsumer){ + ProxyPluginMgr* manager; + if((manager = ProxyPluginMgr::getInstance())){ + audio->pcConsumer = manager->findAudioConsumer(audio->id); + } + } + + ProxyAudioConsumerCallback* callback; + int ret = -1; + if(audio->pcConsumer && (callback = audio->pcConsumer->getCallback())){ + if(callback->putInJitterBuffer()){ + ret = tdav_consumer_audio_put(TDAV_CONSUMER_AUDIO(self), buffer, size, proto_hdr); + } + else{ + ret = callback->consume(buffer, size, proto_hdr); + } + } + + return ret; +} + +int twrap_consumer_proxy_audio_pause(tmedia_consumer_t* self) +{ + ProxyPluginMgr* manager; + int ret = -1; + if((manager = ProxyPluginMgr::getInstance())){ + const ProxyAudioConsumer* audioConsumer; + if((audioConsumer = manager->findAudioConsumer(TWRAP_CONSUMER_PROXY_AUDIO(self)->id)) && audioConsumer->getCallback()){ + ret = audioConsumer->getCallback()->pause(); + } + } + + return ret; +} + +int twrap_consumer_proxy_audio_stop(tmedia_consumer_t* self) +{ + ProxyPluginMgr* manager; + int ret = -1; + if((manager = ProxyPluginMgr::getInstance())){ + const ProxyAudioConsumer* audioConsumer; + if((audioConsumer = manager->findAudioConsumer(TWRAP_CONSUMER_PROXY_AUDIO(self)->id)) && audioConsumer->getCallback()){ + ret = audioConsumer->getCallback()->stop(); + } + } + + TWRAP_CONSUMER_PROXY_AUDIO(self)->started = (ret == 0) ? tsk_false : tsk_true; + return ret; +} + + +// +// Audio consumer object definition +// +/* constructor */ +static tsk_object_t* twrap_consumer_proxy_audio_ctor(tsk_object_t * self, va_list * app) +{ + twrap_consumer_proxy_audio_t *consumer = (twrap_consumer_proxy_audio_t *)self; + if(consumer){ + /* init base */ + tdav_consumer_audio_init(TDAV_CONSUMER_AUDIO(consumer)); + /* init self */ + + /* Add the plugin to the manager */ + ProxyPluginMgr* manager = ProxyPluginMgr::getInstance(); + if(manager){ + ProxyPlugin* proxyConsumer = new ProxyAudioConsumer(consumer); + uint64_t id = proxyConsumer->getId(); + manager->addPlugin(&proxyConsumer); + manager->getCallback()->OnPluginCreated(id, twrap_proxy_plugin_audio_consumer); + } + } + return self; +} +/* destructor */ +static tsk_object_t* twrap_consumer_proxy_audio_dtor(tsk_object_t * self) +{ + twrap_consumer_proxy_audio_t *consumer = (twrap_consumer_proxy_audio_t *)self; + if(consumer){ + /* stop */ + if(consumer->started){ + twrap_consumer_proxy_audio_stop(TMEDIA_CONSUMER(consumer)); + } + + /* deinit base */ + tdav_consumer_audio_deinit(TDAV_CONSUMER_AUDIO(consumer)); + /* deinit self */ + + + /* Remove plugin from the manager */ + ProxyPluginMgr* manager = ProxyPluginMgr::getInstance(); + if(manager){ + manager->getCallback()->OnPluginDestroyed(consumer->id, twrap_proxy_plugin_audio_consumer); + manager->removePlugin(consumer->id); + } + } + + return self; +} +/* object definition */ +static const tsk_object_def_t twrap_consumer_proxy_audio_def_s = +{ + sizeof(twrap_consumer_proxy_audio_t), + twrap_consumer_proxy_audio_ctor, + twrap_consumer_proxy_audio_dtor, + tdav_consumer_audio_cmp, +}; +/* plugin definition*/ +static const tmedia_consumer_plugin_def_t twrap_consumer_proxy_audio_plugin_def_s = +{ + &twrap_consumer_proxy_audio_def_s, + + tmedia_audio, + "Audio Proxy Consumer", + + twrap_consumer_proxy_audio_set, + twrap_consumer_proxy_audio_prepare, + twrap_consumer_proxy_audio_start, + twrap_consumer_proxy_audio_consume, + twrap_consumer_proxy_audio_pause, + twrap_consumer_proxy_audio_stop +}; + +/*TINYWRAP_GEXTERN*/ const tmedia_consumer_plugin_def_t *twrap_consumer_proxy_audio_plugin_def_t = &twrap_consumer_proxy_audio_plugin_def_s; + + + +/* ============ ProxyAudioConsumer Class ================= */ +ProxyAudioConsumer::ProxyAudioConsumer(twrap_consumer_proxy_audio_t* pConsumer) +:ProxyPlugin(twrap_proxy_plugin_audio_consumer), +m_pWrappedPlugin(pConsumer), +m_pCallback(tsk_null) +{ + memset(&m_PullBuffer, 0, sizeof(m_PullBuffer)); + memset(&m_Resampler, 0, sizeof(m_Resampler)); + + if(m_pWrappedPlugin){ + m_pWrappedPlugin->id = this->getId(); + } +} + +ProxyAudioConsumer::~ProxyAudioConsumer() +{ + TSK_FREE(m_Resampler.pInBufferPtr); + m_Resampler.nInBufferSizeInByte = 0; + if(m_Resampler.pResampler){ + delete m_Resampler.pResampler, m_Resampler.pResampler = tsk_null; + } +} + +// Use this function to request resampling when your sound card can't honor negotaited record parameters +bool ProxyAudioConsumer::setActualSndCardPlaybackParams(int nPtime, int nRate, int nChannels) +{ + if(m_pWrappedPlugin){ + TSK_DEBUG_INFO("ProxyAudioConsumer::setActualSndCardRecordParams(ptime=%d, rate=%d, channels=%d)", nPtime, nRate, nChannels); + TMEDIA_CONSUMER(m_pWrappedPlugin)->audio.ptime = nPtime; + TMEDIA_CONSUMER(m_pWrappedPlugin)->audio.out.rate = nRate; + TMEDIA_CONSUMER(m_pWrappedPlugin)->audio.out.channels = nChannels; + return true; + } + else{ + TSK_DEBUG_ERROR("Invalid state"); + return false; + } +} + +bool ProxyAudioConsumer::queryForResampler(uint16_t nInFreq, uint16_t nOutFreq, uint16_t nFrameDuration, uint16_t nChannels, uint16_t nResamplerQuality) +{ + TSK_DEBUG_INFO("queryForResampler(%hu,%hu,%hu,%hu,%hu)", nInFreq, nOutFreq, nFrameDuration, nChannels, nResamplerQuality); + if(nResamplerQuality > 10){ + TSK_DEBUG_WARN("%d is invalid value for quality", nResamplerQuality); + } + m_Resampler.pResampler = new AudioResampler(nInFreq, nOutFreq, nFrameDuration, nChannels, nResamplerQuality); + if(!m_Resampler.pResampler){ + TSK_DEBUG_ERROR("Failed to create new 'AudioResampler' object"); + return false; + } + bool bOK = m_Resampler.pResampler->isValid(); + if(!bOK){ + goto bail; + } + m_Resampler.nInBufferSizeInByte = m_Resampler.pResampler->getInputRequiredSizeInShort() * 2; + m_Resampler.pInBufferPtr = tsk_calloc(m_Resampler.nInBufferSizeInByte, 1); + bOK = (m_Resampler.pInBufferPtr != tsk_null); + +bail: + if(!bOK){ + if(m_Resampler.pResampler){ + delete m_Resampler.pResampler, m_Resampler.pResampler = tsk_null; + } + TSK_FREE(m_Resampler.pInBufferPtr); + m_Resampler.nInBufferSizeInByte = 0; + } + return bOK; +} + +bool ProxyAudioConsumer::setPullBuffer(const void* pPullBufferPtr, unsigned nPullBufferSize) +{ + m_PullBuffer.pPullBufferPtr = pPullBufferPtr; + m_PullBuffer.nPullBufferSize = nPullBufferSize; + return true; +} + +unsigned ProxyAudioConsumer::pull(void* _pOutput/*=tsk_null*/, unsigned _nSize/*=0*/) +{ + if((m_pWrappedPlugin = (twrap_consumer_proxy_audio_t*)tsk_object_ref(m_pWrappedPlugin))){ + void* pOutput; + unsigned nSize; + if(_pOutput && _nSize){ + pOutput = _pOutput, nSize = _nSize; + } + else{ + pOutput = (void*)m_PullBuffer.pPullBufferPtr, nSize = m_PullBuffer.nPullBufferSize; + } + + tsk_size_t nRetSize = 0; + + if(m_Resampler.pResampler && m_Resampler.pInBufferPtr){ + nRetSize = tdav_consumer_audio_get(TDAV_CONSUMER_AUDIO(m_pWrappedPlugin), m_Resampler.pInBufferPtr, m_Resampler.nInBufferSizeInByte); + if(nRetSize){ + nRetSize = m_Resampler.pResampler->process(m_Resampler.pInBufferPtr, nRetSize, pOutput, nSize); + } + } + else{ + nRetSize = tdav_consumer_audio_get(TDAV_CONSUMER_AUDIO(m_pWrappedPlugin), pOutput, nSize); + } + + tdav_consumer_audio_tick(TDAV_CONSUMER_AUDIO(m_pWrappedPlugin)); + + m_pWrappedPlugin = (twrap_consumer_proxy_audio_t*)tsk_object_unref(m_pWrappedPlugin); + return nRetSize; + } + return 0; +} + +bool ProxyAudioConsumer::setGain(unsigned nGain) +{ + if(m_pWrappedPlugin){ + // see also: MediaSessionMgr.consumerSetInt32(org.doubango.tinyWRAP.twrap_media_type_t.twrap_media_audio, "gain", nGain); + TMEDIA_CONSUMER(m_pWrappedPlugin)->audio.gain = TSK_MIN(nGain,14); + return true; + } + return false; +} + +unsigned ProxyAudioConsumer::getGain() +{ + if(m_pWrappedPlugin){ + return TMEDIA_CONSUMER(m_pWrappedPlugin)->audio.gain; + } + return 0; +} + +bool ProxyAudioConsumer::reset() +{ + if(m_pWrappedPlugin){ + return (tdav_consumer_audio_reset(TDAV_CONSUMER_AUDIO(m_pWrappedPlugin)) == 0); + } + return false; +} + +bool ProxyAudioConsumer::registerPlugin() +{ + /* HACK: Unregister all other audio plugins */ + tmedia_consumer_plugin_unregister_by_type(tmedia_audio); + /* Register our proxy plugin */ + return (tmedia_consumer_plugin_register(twrap_consumer_proxy_audio_plugin_def_t) == 0); +} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +/* ============ Video Consumer Interface ================= */ + +typedef struct twrap_consumer_proxy_video_s +{ + TDAV_DECLARE_CONSUMER_VIDEO; + + uint64_t id; + tsk_bool_t started; + const ProxyVideoConsumer* pcConsumer; // thread-safe and will be destroyed at the time as the "struct" +} +twrap_consumer_proxy_video_t; +#define TWRAP_CONSUMER_PROXY_VIDEO(self) ((twrap_consumer_proxy_video_t*)(self)) + +int twrap_consumer_proxy_video_set(tmedia_consumer_t* self, const tmedia_param_t* params) +{ + return 0; +} + +int twrap_consumer_proxy_video_prepare(tmedia_consumer_t* self, const tmedia_codec_t* codec) +{ + ProxyPluginMgr* manager; + twrap_consumer_proxy_video_t* video = TWRAP_CONSUMER_PROXY_VIDEO(self); + int ret = -1; + if(codec && (manager = ProxyPluginMgr::getInstance())){ + if((video->pcConsumer = manager->findVideoConsumer(video->id)) && video->pcConsumer->getCallback()){ + self->video.fps = TMEDIA_CODEC_VIDEO(codec)->in.fps; + // in + self->video.in.chroma = tmedia_chroma_yuv420p; + self->video.in.width = TMEDIA_CODEC_VIDEO(codec)->in.width; + self->video.in.height = TMEDIA_CODEC_VIDEO(codec)->in.height; + // display (out) + self->video.display.chroma = video->pcConsumer->getChroma(); + self->video.display.auto_resize = video->pcConsumer->getAutoResizeDisplay(); + if(!self->video.display.width){ + self->video.display.width = self->video.in.width; + } + if(!self->video.display.height){ + self->video.display.height = self->video.in.height; + } + ret = video->pcConsumer->getCallback()->prepare(TMEDIA_CODEC_VIDEO(codec)->in.width, TMEDIA_CODEC_VIDEO(codec)->in.height, TMEDIA_CODEC_VIDEO(codec)->in.fps); + } + } + + return ret; +} + +int twrap_consumer_proxy_video_start(tmedia_consumer_t* self) +{ + ProxyPluginMgr* manager; + int ret = -1; + if((manager = ProxyPluginMgr::getInstance())){ + const ProxyVideoConsumer* videoConsumer; + if((videoConsumer = manager->findVideoConsumer(TWRAP_CONSUMER_PROXY_VIDEO(self)->id)) && videoConsumer->getCallback()){ + ret = videoConsumer->getCallback()->start(); + } + } + + TWRAP_CONSUMER_PROXY_VIDEO(self)->started = (ret == 0); + return ret; +} + +int twrap_consumer_proxy_video_consume(tmedia_consumer_t* self, const void* buffer, tsk_size_t size, const tsk_object_t* proto_hdr) +{ + if(!self || !buffer || !size){ + TSK_DEBUG_ERROR("Invalid parameter"); + return -1; + } + + twrap_consumer_proxy_video_t* video = TWRAP_CONSUMER_PROXY_VIDEO(self); + + if(!video->pcConsumer){ + ProxyPluginMgr* manager; + if((manager = ProxyPluginMgr::getInstance())){ + video->pcConsumer = manager->findVideoConsumer(video->id); + } + } + + int ret = -1; + ProxyVideoConsumerCallback* callback; + + if(video->pcConsumer && (callback = video->pcConsumer->getCallback())){ + if(tdav_consumer_video_has_jb(TDAV_CONSUMER_VIDEO(self))){ + ret = tdav_consumer_video_put(TDAV_CONSUMER_VIDEO(self), buffer, size, proto_hdr); + } + else{ + if(video->pcConsumer->hasConsumeBuffer()){ + unsigned nCopiedSize = video->pcConsumer->copyBuffer(buffer, size); + ret = callback->bufferCopied(nCopiedSize, size); + } + else{ + ProxyVideoFrame* frame = new ProxyVideoFrame(buffer, size, const_cast<ProxyVideoConsumer*>(video->pcConsumer)->getDecodedWidth(), const_cast<ProxyVideoConsumer*>(video->pcConsumer)->getDecodedHeight(), proto_hdr); + ret = callback->consume(frame); + delete frame, frame = tsk_null; + } + } + } + else if(!video->pcConsumer){ + TSK_DEBUG_ERROR("Cannot find consumer with id=%lld", TWRAP_CONSUMER_PROXY_VIDEO(self)->id); + } + + + return ret; +} + +int twrap_consumer_proxy_video_pause(tmedia_consumer_t* self) +{ + ProxyPluginMgr* manager; + int ret = -1; + if((manager = ProxyPluginMgr::getInstance())){ + const ProxyVideoConsumer* videoConsumer; + if((videoConsumer = manager->findVideoConsumer(TWRAP_CONSUMER_PROXY_VIDEO(self)->id)) && videoConsumer->getCallback()){ + ret = videoConsumer->getCallback()->pause(); + } + } + + return ret; +} + +int twrap_consumer_proxy_video_stop(tmedia_consumer_t* self) +{ + ProxyPluginMgr* manager; + int ret = -1; + if((manager = ProxyPluginMgr::getInstance())){ + const ProxyVideoConsumer* videoConsumer; + if((videoConsumer = manager->findVideoConsumer(TWRAP_CONSUMER_PROXY_VIDEO(self)->id)) && videoConsumer->getCallback()){ + ret = videoConsumer->getCallback()->stop(); + } + } + + TWRAP_CONSUMER_PROXY_VIDEO(self)->started = (ret == 0) ? tsk_false : tsk_true; + return ret; +} + + +// +// Video consumer object definition +// +/* constructor */ +static tsk_object_t* twrap_consumer_proxy_video_ctor(tsk_object_t * self, va_list * app) +{ + twrap_consumer_proxy_video_t *consumer = (twrap_consumer_proxy_video_t *)self; + if(consumer){ + /* init base */ + tdav_consumer_video_init(TDAV_CONSUMER_VIDEO(consumer)); + /* init self */ + + /* Add the plugin to the manager */ + ProxyPluginMgr* manager = ProxyPluginMgr::getInstance(); + if(manager){ + ProxyPlugin* proxyConsumer = new ProxyVideoConsumer(ProxyVideoConsumer::getDefaultChroma(), consumer); + uint64_t id = proxyConsumer->getId(); + manager->addPlugin(&proxyConsumer); + manager->getCallback()->OnPluginCreated(id, twrap_proxy_plugin_video_consumer); + } + } + return self; +} +/* destructor */ +static tsk_object_t* twrap_consumer_proxy_video_dtor(tsk_object_t * self) +{ + twrap_consumer_proxy_video_t *consumer = (twrap_consumer_proxy_video_t *)self; + if(consumer){ + + /* stop */ + if(consumer->started){ + twrap_consumer_proxy_video_stop(TMEDIA_CONSUMER(consumer)); + } + + /* deinit base */ + tdav_consumer_video_deinit(TDAV_CONSUMER_VIDEO(consumer)); + /* deinit self */ + + /* Remove plugin from the manager */ + ProxyPluginMgr* manager = ProxyPluginMgr::getInstance(); + if(manager){ + manager->getCallback()->OnPluginDestroyed(consumer->id, twrap_proxy_plugin_video_consumer); + manager->removePlugin(consumer->id); + } + } + + return self; +} +/* object definition */ +static const tsk_object_def_t twrap_consumer_proxy_video_def_s = +{ + sizeof(twrap_consumer_proxy_video_t), + twrap_consumer_proxy_video_ctor, + twrap_consumer_proxy_video_dtor, + tsk_null, +}; +/* plugin definition*/ +static const tmedia_consumer_plugin_def_t twrap_consumer_proxy_video_plugin_def_s = +{ + &twrap_consumer_proxy_video_def_s, + + tmedia_video, + "Video Proxy Consumer", + + twrap_consumer_proxy_video_set, + twrap_consumer_proxy_video_prepare, + twrap_consumer_proxy_video_start, + twrap_consumer_proxy_video_consume, + twrap_consumer_proxy_video_pause, + twrap_consumer_proxy_video_stop +}; + +/*TINYWRAP_GEXTERN*/ const tmedia_consumer_plugin_def_t *twrap_consumer_proxy_video_plugin_def_t = &twrap_consumer_proxy_video_plugin_def_s; + + + +/* ============ ProxyVideoConsumer Class ================= */ +tmedia_chroma_t ProxyVideoConsumer::s_eDefaultChroma = tmedia_chroma_rgb565le; +bool ProxyVideoConsumer::s_bAutoResizeDisplay = false; + +ProxyVideoConsumer::ProxyVideoConsumer(tmedia_chroma_t eChroma, struct twrap_consumer_proxy_video_s* pConsumer) +: m_eChroma(eChroma), +m_bAutoResizeDisplay(ProxyVideoConsumer::getDefaultAutoResizeDisplay()), +m_pWrappedPlugin(pConsumer), +m_pCallback(tsk_null), +ProxyPlugin(twrap_proxy_plugin_video_consumer) +{ + m_pWrappedPlugin->id = this->getId(); + m_ConsumeBuffer.pConsumeBufferPtr = tsk_null; + m_ConsumeBuffer.nConsumeBufferSize = 0; +} + +ProxyVideoConsumer::~ProxyVideoConsumer() +{ +} + +bool ProxyVideoConsumer::setDisplaySize(unsigned nWidth, unsigned nHeight) +{ + if((m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_ref(m_pWrappedPlugin))){ + TMEDIA_CONSUMER(m_pWrappedPlugin)->video.display.width = nWidth; + TMEDIA_CONSUMER(m_pWrappedPlugin)->video.display.height = nHeight; + m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_unref(m_pWrappedPlugin); + return true; + } + TSK_DEBUG_ERROR("This consumer doesn't wrap any plugin"); + return false; +} + +unsigned ProxyVideoConsumer::getDisplayWidth() +{ + unsigned displayWidth = 0; + if((m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_ref(m_pWrappedPlugin))){ + displayWidth = TMEDIA_CONSUMER(m_pWrappedPlugin)->video.display.width; + m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_unref(m_pWrappedPlugin); + } + else{ + TSK_DEBUG_ERROR("This consumer doesn't wrap any plugin"); + } + return displayWidth; +} + +unsigned ProxyVideoConsumer::getDisplayHeight() +{ + unsigned displayHeight = 0; + if((m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_ref(m_pWrappedPlugin))){ + displayHeight = TMEDIA_CONSUMER(m_pWrappedPlugin)->video.display.height; + m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_unref(m_pWrappedPlugin); + } + else{ + TSK_DEBUG_ERROR("This consumer doesn't wrap any plugin"); + } + return displayHeight; +} + +unsigned ProxyVideoConsumer::getDecodedWidth() +{ + unsigned width = 0; + if((m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_ref(m_pWrappedPlugin))){ + width = TMEDIA_CONSUMER(m_pWrappedPlugin)->video.in.width; + m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_unref(m_pWrappedPlugin); + } + else{ + TSK_DEBUG_ERROR("This consumer doesn't wrap any plugin"); + } + return width; +} + +unsigned ProxyVideoConsumer::getDecodedHeight() +{ + unsigned height = 0; + if((m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_ref(m_pWrappedPlugin))){ + height = TMEDIA_CONSUMER(m_pWrappedPlugin)->video.in.height; + m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_unref(m_pWrappedPlugin); + } + else{ + TSK_DEBUG_ERROR("This consumer doesn't wrap any plugin"); + } + return height; +} + +tmedia_chroma_t ProxyVideoConsumer::getChroma()const +{ + return m_eChroma; +} + +bool ProxyVideoConsumer::setAutoResizeDisplay(bool bAutoResizeDisplay){ + if((m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_ref(m_pWrappedPlugin))){ + TMEDIA_CONSUMER(m_pWrappedPlugin)->video.display.auto_resize = bAutoResizeDisplay ? tsk_true : tsk_false; + m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_unref(m_pWrappedPlugin); + m_bAutoResizeDisplay = bAutoResizeDisplay; + return true; + } + TSK_DEBUG_ERROR("This consumer doesn't wrap any plugin"); + return false; +} + +bool ProxyVideoConsumer::getAutoResizeDisplay()const +{ + return m_bAutoResizeDisplay; +} + +bool ProxyVideoConsumer::setConsumeBuffer(const void* pConsumeBufferPtr, unsigned nConsumeBufferSize) +{ + m_ConsumeBuffer.pConsumeBufferPtr = pConsumeBufferPtr; + m_ConsumeBuffer.nConsumeBufferSize = nConsumeBufferSize; + return true; +} + +unsigned ProxyVideoConsumer::copyBuffer(const void* pBuffer, unsigned nSize)const +{ + unsigned nRetsize = 0; + if(pBuffer && nSize && m_ConsumeBuffer.pConsumeBufferPtr && m_ConsumeBuffer.nConsumeBufferSize){ + nRetsize = (nSize > m_ConsumeBuffer.nConsumeBufferSize) ? m_ConsumeBuffer.nConsumeBufferSize : nSize; + memcpy((void*)m_ConsumeBuffer.pConsumeBufferPtr, pBuffer, nRetsize); + } + return nRetsize; +} + +unsigned ProxyVideoConsumer::pull(void* pOutput, unsigned nSize) +{ + if(pOutput && nSize && (m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_ref(m_pWrappedPlugin))){ + tsk_size_t nRetSize = 0; + + if(!tdav_consumer_video_has_jb(TDAV_CONSUMER_VIDEO(m_pWrappedPlugin))){ + TSK_DEBUG_ERROR("This consumer doesn't hold any jitter buffer.\n\nTo pull a buffer you must register a callback ('class ProxyVideoConsumerCallback') and listen for either 'consume' or 'bufferCopied' functions"); + goto done; + } + + nRetSize = tdav_consumer_video_get(TDAV_CONSUMER_VIDEO(m_pWrappedPlugin), pOutput, nSize); + + tdav_consumer_video_tick(TDAV_CONSUMER_VIDEO(m_pWrappedPlugin)); + +done: + m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_unref(m_pWrappedPlugin); + return nRetSize; + } + return 0; +} + +bool ProxyVideoConsumer::reset() +{ + bool ret = false; + if((m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_ref(m_pWrappedPlugin))){ + if(tdav_consumer_video_has_jb(TDAV_CONSUMER_VIDEO(m_pWrappedPlugin))){ + ret = (tdav_consumer_video_reset(TDAV_CONSUMER_VIDEO(m_pWrappedPlugin)) == 0); + } + else{ + TSK_DEBUG_ERROR("This consumer doesn't hold any jitter buffer"); + } + m_pWrappedPlugin = (twrap_consumer_proxy_video_t*)tsk_object_unref(m_pWrappedPlugin); + } + + TSK_DEBUG_ERROR("This consumer doesn't wrap any plugin"); + return ret; +} + +bool ProxyVideoConsumer::registerPlugin() +{ + /* HACK: Unregister all other video plugins */ + tmedia_consumer_plugin_unregister_by_type(tmedia_video); + /* Register our proxy plugin */ + return (tmedia_consumer_plugin_register(twrap_consumer_proxy_video_plugin_def_t) == 0); +} + + + +ProxyVideoFrame::ProxyVideoFrame(const void* pBufferPtr, unsigned nSize, unsigned nFrameWidth, unsigned nFrameHeight, const tsk_object_t* pProtoHdr) +{ + m_pBufferPtr = pBufferPtr; + m_nBufferSize = nSize; + m_nFrameWidth = nFrameWidth; + m_nFrameHeight = nFrameHeight; + m_pProtoHdr = pProtoHdr; +} + +ProxyVideoFrame::~ProxyVideoFrame() +{ +} + +unsigned ProxyVideoFrame::getSize() +{ + return m_nBufferSize; +} + +unsigned ProxyVideoFrame::getContent(void* pOutput, unsigned nMaxsize) +{ + unsigned nRetsize = 0; + if(pOutput && nMaxsize && m_pBufferPtr){ + nRetsize = (m_nBufferSize > nMaxsize) ? nMaxsize : m_nBufferSize; + memcpy(pOutput, m_pBufferPtr, nRetsize); + } + return nRetsize; +} |
