zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactored ViERenderer.

Browse Source 
Only style changes, function and type changes will come in a later CL.

Review URL: http://webrtc-codereview.appspot.com/321001

git-svn-id: http://webrtc.googlecode.com/svn/trunk@1142 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
mflodman@webrtc.org
2011-12-09 05:52:32 +00:00
parent 7fb5d46d3a
commit 5885a4162a
2 changed files with 274 additions and 273 deletions
Download Patch File Download Diff File Expand all files Collapse all files

400
src/video_engine/vie_renderer.cc
View File

@ -8,243 +8,249 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
#include "vie_renderer.h" #include "video_engine/vie_renderer.h"
#include "video_render.h"
#include "video_render_defines.h"
#include "vie_render_manager.h"
#include "common_video/libyuv/include/libyuv.h" #include "common_video/libyuv/include/libyuv.h"
#include "modules/video_render/main/interface/video_render.h"
#include "modules/video_render/main/interface/video_render_defines.h"
#include "video_engine/vie_render_manager.h"
namespace webrtc { namespace webrtc {
ViERenderer* ViERenderer::CreateViERenderer( ViERenderer* ViERenderer::CreateViERenderer(const WebRtc_Word32 render_id,
const WebRtc_Word32 renderId, const WebRtc_Word32 engine_id,
const WebRtc_Word32 engineId, VideoRender& render_module,
VideoRender& renderModule, ViERenderManager& render_manager,
ViERenderManager& renderManager, const WebRtc_UWord32 z_order,
const WebRtc_UWord32 zOrder, const float left,
const float left, const float top,
const float top, const float right,
const float right, const float bottom) {
const float bottom) ViERenderer* self = new ViERenderer(render_id, engine_id, render_module,
{ render_manager);
ViERenderer* self=new ViERenderer(renderId,engineId,renderModule,renderManager); if (!self || self->Init(z_order, left, top, right, bottom) != 0) {
if(!self || self->Init(zOrder,left,top,right,bottom)!=0) delete self;
{ self = NULL;
delete self;
self=NULL;
}
return self;
}
ViERenderer::~ViERenderer(void)
{
if(_ptrRenderCallback)
{
_renderModule.DeleteIncomingRenderStream( _renderId);
}
if(_ptrIncomingExternalCallback){
delete _ptrIncomingExternalCallback;
} }
return self;
} }
ViERenderer::ViERenderer(const WebRtc_Word32 renderId,const WebRtc_Word32 engineId, ViERenderer::~ViERenderer(void) {
VideoRender& renderModule, if (render_callback_)
ViERenderManager& renderManager) render_module_.DeleteIncomingRenderStream(render_id_);
:
_renderId(renderId),
_engineId(engineId),
_renderModule(renderModule),
_renderManager(renderManager),
_ptrRenderCallback(NULL),
_ptrIncomingExternalCallback(new ViEExternalRendererImpl())
{
if (incoming_external_callback_)
delete incoming_external_callback_;
} }
WebRtc_Word32 ViERenderer::Init(const WebRtc_UWord32 zOrder, WebRtc_Word32 ViERenderer::StartRender() {
const float left, return render_module_.StartRender(render_id_);
const float top, }
const float right, WebRtc_Word32 ViERenderer::StopRender() {
const float bottom) return render_module_.StopRender(render_id_);
{
_ptrRenderCallback = (VideoRenderCallback*)_renderModule.AddIncomingRenderStream( _renderId, zOrder, left, top, right, bottom);
if (_ptrRenderCallback == NULL)
{
// Logging done
return -1;
}
return 0;
} }
WebRtc_Word32 ViERenderer::GetLastRenderedFrame(const WebRtc_Word32 renderID, webrtc::VideoFrame& videoFrame) WebRtc_Word32 ViERenderer::GetLastRenderedFrame(const WebRtc_Word32 renderID,
{ VideoFrame& video_frame) {
return _renderModule.GetLastRenderedFrame(renderID, videoFrame); return render_module_.GetLastRenderedFrame(renderID, video_frame);
} }
WebRtc_Word32 ViERenderer::StartRender() WebRtc_Word32 ViERenderer::ConfigureRenderer(const unsigned int z_order,
{ const float left,
return _renderModule.StartRender(_renderId); const float top,
} const float right,
WebRtc_Word32 ViERenderer::StopRender() const float bottom) {
{ return render_module_.ConfigureRenderer(render_id_, z_order, left, top, right,
return _renderModule.StopRender(_renderId); bottom);
} }
// Implement ViEFrameCallback VideoRender& ViERenderer::RenderModule() {
void ViERenderer::DeliverFrame(int id, return render_module_;
webrtc::VideoFrame& videoFrame,
int numCSRCs,
const WebRtc_UWord32 CSRC[kRtpCsrcSize])
{
_ptrRenderCallback->RenderFrame(_renderId,videoFrame);
} }
// Implement ViEFrameCallback WebRtc_Word32 ViERenderer::EnableMirroring(const WebRtc_Word32 render_id,
void ViERenderer::ProviderDestroyed(int id) const bool enable,
{ const bool mirror_xaxis,
_renderManager.RemoveRenderStream(_renderId); // Remove the render stream since the provider is destroyed. const bool mirror_yaxis) {
return render_module_.MirrorRenderStream(render_id, enable, mirror_xaxis,
mirror_yaxis);
} }
VideoRender& ViERenderer::RenderModule() WebRtc_Word32 ViERenderer::SetTimeoutImage(const VideoFrame& timeout_image,
{ const WebRtc_Word32 timeout_value) {
return _renderModule; return render_module_.SetTimeoutImage(render_id_, timeout_image,
timeout_value);
} }
WebRtc_Word32 ViERenderer::ConfigureRenderer(const unsigned int zOrder, WebRtc_Word32 ViERenderer::SetRenderStartImage(const VideoFrame& start_image) {
const float left, return render_module_.SetStartImage(render_id_, start_image);
const float top,
const float right,
const float bottom)
{
return _renderModule.ConfigureRenderer(_renderId, zOrder, left, top, right, bottom);
} }
WebRtc_Word32 ViERenderer::SetExternalRenderer(
const WebRtc_Word32 render_id,
RawVideoType video_input_format,
ExternalRenderer* external_renderer) {
if (!incoming_external_callback_)
return -1;
incoming_external_callback_->SetViEExternalRenderer(external_renderer,
WebRtc_Word32 ViERenderer::SetTimeoutImage(const webrtc::VideoFrame& timeoutImage,const WebRtc_Word32 timeoutValue) video_input_format);
{ return render_module_.AddExternalRenderCallback(render_id,
return _renderModule.SetTimeoutImage(_renderId,timeoutImage,timeoutValue); incoming_external_callback_);
} }
WebRtc_Word32 ViERenderer::SetRenderStartImage(const webrtc::VideoFrame& startImage) ViERenderer::ViERenderer(const WebRtc_Word32 render_id,
{ const WebRtc_Word32 engine_id,
return _renderModule.SetStartImage(_renderId,startImage); VideoRender& render_module,
ViERenderManager& render_manager)
: render_id_(render_id),
engine_id_(engine_id),
render_module_(render_module),
render_manager_(render_manager),
render_callback_(NULL),
incoming_external_callback_(new ViEExternalRendererImpl()) {
} }
WebRtc_Word32 ViERenderer::Init(const WebRtc_UWord32 z_order,
const float left,
WebRtc_Word32 ViERenderer::EnableMirroring(const WebRtc_Word32 renderId, const bool enable, const bool mirrorXAxis, const bool mirrorYAxis) const float top,
{ const float right,
return _renderModule.MirrorRenderStream(renderId, enable, mirrorXAxis, mirrorYAxis); const float bottom) {
} render_callback_ =
static_cast<VideoRenderCallback*>(render_module_.AddIncomingRenderStream(
render_id_, z_order, left, top, right, bottom));
WebRtc_Word32 ViERenderer::SetExternalRenderer(const WebRtc_Word32 renderId, webrtc::RawVideoType videoInputFormat, ExternalRenderer* externalRenderer) if (!render_callback_) {
{ // Logging done.
if(NULL == _ptrIncomingExternalCallback){
return -1; return -1;
} }
_ptrIncomingExternalCallback->SetViEExternalRenderer(externalRenderer, videoInputFormat);
return _renderModule.AddExternalRenderCallback(renderId, _ptrIncomingExternalCallback);
}
ViEExternalRendererImpl::ViEExternalRendererImpl() :
_externalRenderer(NULL),
_externalRendererFormat(),
_externalRendererWidth(0),
_externalRendererHeight(0)
{
}
int ViEExternalRendererImpl::SetViEExternalRenderer(ExternalRenderer* externalRenderer, webrtc::RawVideoType videoInputFormat)
{
_externalRenderer = externalRenderer;
_externalRendererFormat = videoInputFormat;
return 0; return 0;
} }
// implements VideoRenderCallback void ViERenderer::DeliverFrame(int id,
WebRtc_Word32 ViEExternalRendererImpl::RenderFrame(const WebRtc_UWord32 streamId, VideoFrame& video_frame,
webrtc::VideoFrame& videoFrame) int num_csrcs,
{ const WebRtc_UWord32 CSRC[kRtpCsrcSize]) {
webrtc::VideoFrame convertedFrame; render_callback_->RenderFrame(render_id_, video_frame);
webrtc::VideoFrame* pConvertedFrame = &convertedFrame; }
// convert to requested format void ViERenderer::DelayChanged(int id, int frame_delay) {}
switch(_externalRendererFormat)
{ int ViERenderer::GetPreferedFrameSettings(int& width,
case webrtc::kVideoI420: int& height,
pConvertedFrame = &videoFrame; int& frame_rate) {
break; return -1;
case webrtc::kVideoYV12: }
convertedFrame.VerifyAndAllocate(webrtc::CalcBufferSize(webrtc::kYV12,videoFrame.Width(),videoFrame.Height()));
webrtc::ConvertI420ToYV12(videoFrame.Buffer(), convertedFrame.Buffer(), videoFrame.Width(), videoFrame.Height(), 0); void ViERenderer::ProviderDestroyed(int id) {
break; // Remove the render stream since the provider is destroyed.
case webrtc::kVideoYUY2: render_manager_.RemoveRenderStream(render_id_);
convertedFrame.VerifyAndAllocate(webrtc::CalcBufferSize(webrtc::kYUY2,videoFrame.Width(),videoFrame.Height())); }
webrtc::ConvertI420ToYUY2(videoFrame.Buffer(), convertedFrame.Buffer(), videoFrame.Width(), videoFrame.Height(), 0);
break; ViEExternalRendererImpl::ViEExternalRendererImpl()
case webrtc::kVideoUYVY: : external_renderer_(NULL),
convertedFrame.VerifyAndAllocate(webrtc::CalcBufferSize(webrtc::kUYVY,videoFrame.Width(),videoFrame.Height())); external_renderer_format_(kVideoUnknown),
webrtc::ConvertI420ToUYVY(videoFrame.Buffer(), convertedFrame.Buffer(), videoFrame.Width(), videoFrame.Height(), 0); external_renderer_width_(0),
break; external_renderer_height_(0) {
case webrtc::kVideoIYUV: }
// no conversion available
break; int ViEExternalRendererImpl::SetViEExternalRenderer(
case webrtc::kVideoARGB: ExternalRenderer* external_renderer,
convertedFrame.VerifyAndAllocate(webrtc::CalcBufferSize(webrtc::kARGB,videoFrame.Width(),videoFrame.Height())); RawVideoType video_input_format) {
webrtc::ConvertI420ToARGB(videoFrame.Buffer(), convertedFrame.Buffer(), videoFrame.Width(), videoFrame.Height(), 0); external_renderer_ = external_renderer;
break; external_renderer_format_ = video_input_format;
case webrtc::kVideoRGB24: return 0;
convertedFrame.VerifyAndAllocate(webrtc::CalcBufferSize(webrtc::kRGB24,videoFrame.Width(),videoFrame.Height())); }
webrtc::ConvertI420ToRGB24(videoFrame.Buffer(), convertedFrame.Buffer(), videoFrame.Width(), videoFrame.Height());
break; WebRtc_Word32 ViEExternalRendererImpl::RenderFrame(
case webrtc::kVideoRGB565: const WebRtc_UWord32 stream_id,
convertedFrame.VerifyAndAllocate(webrtc::CalcBufferSize(webrtc::kRGB565,videoFrame.Width(),videoFrame.Height())); VideoFrame& video_frame) {
webrtc::ConvertI420ToRGB565(videoFrame.Buffer(), convertedFrame.Buffer(), videoFrame.Width(), videoFrame.Height()); VideoFrame converted_frame;
break; VideoFrame* p_converted_frame = &converted_frame;
case webrtc::kVideoARGB4444:
convertedFrame.VerifyAndAllocate(webrtc::CalcBufferSize(webrtc::kARGB4444,videoFrame.Width(),videoFrame.Height())); // Convert to requested format.
webrtc::ConvertI420ToARGB4444(videoFrame.Buffer(), convertedFrame.Buffer(), videoFrame.Width(), videoFrame.Height(), 0); switch (external_renderer_format_) {
break; case kVideoI420:
case webrtc::kVideoARGB1555 : p_converted_frame = &video_frame;
convertedFrame.VerifyAndAllocate(webrtc::CalcBufferSize(webrtc::kARGB1555,videoFrame.Width(),videoFrame.Height())); break;
webrtc::ConvertI420ToARGB1555(videoFrame.Buffer(), convertedFrame.Buffer(), videoFrame.Width(), videoFrame.Height(), 0); case kVideoYV12:
break; converted_frame.VerifyAndAllocate(CalcBufferSize(kYV12,
default: video_frame.Width(),
// the format is something funny. Should never reach here... video_frame.Height()));
assert(false); ConvertI420ToYV12(video_frame.Buffer(), converted_frame.Buffer(),
pConvertedFrame = NULL; video_frame.Width(), video_frame.Height(), 0);
break; break;
case kVideoYUY2:
converted_frame.VerifyAndAllocate(CalcBufferSize(kYUY2,
video_frame.Width(),
video_frame.Height()));
ConvertI420ToYUY2(video_frame.Buffer(), converted_frame.Buffer(),
video_frame.Width(), video_frame.Height(), 0);
break;
case kVideoUYVY:
converted_frame.VerifyAndAllocate(CalcBufferSize(kUYVY,
video_frame.Width(),
video_frame.Height()));
ConvertI420ToUYVY(video_frame.Buffer(), converted_frame.Buffer(),
video_frame.Width(), video_frame.Height(), 0);
break;
case kVideoIYUV:
// no conversion available
break;
case kVideoARGB:
converted_frame.VerifyAndAllocate(CalcBufferSize(kARGB,
video_frame.Width(),
video_frame.Height()));
ConvertI420ToARGB(video_frame.Buffer(), converted_frame.Buffer(),
video_frame.Width(), video_frame.Height(), 0);
break;
case kVideoRGB24:
converted_frame.VerifyAndAllocate(CalcBufferSize(kRGB24,
video_frame.Width(),
video_frame.Height()));
ConvertI420ToRGB24(video_frame.Buffer(), converted_frame.Buffer(),
video_frame.Width(), video_frame.Height());
break;
case kVideoRGB565:
converted_frame.VerifyAndAllocate(CalcBufferSize(kRGB565,
video_frame.Width(),
video_frame.Height()));
ConvertI420ToRGB565(video_frame.Buffer(), converted_frame.Buffer(),
video_frame.Width(), video_frame.Height());
break;
case kVideoARGB4444:
converted_frame.VerifyAndAllocate(CalcBufferSize(kARGB4444,
video_frame.Width(),
video_frame.Height()));
ConvertI420ToARGB4444(video_frame.Buffer(), converted_frame.Buffer(),
video_frame.Width(), video_frame.Height(), 0);
break;
case kVideoARGB1555 :
converted_frame.VerifyAndAllocate(CalcBufferSize(kARGB1555,
video_frame.Width(),
video_frame.Height()));
ConvertI420ToARGB1555(video_frame.Buffer(), converted_frame.Buffer(),
video_frame.Width(), video_frame.Height(), 0);
break;
default:
assert(false);
p_converted_frame = NULL;
break;
} }
if(_externalRendererWidth!=videoFrame.Width() || _externalRendererHeight!=videoFrame.Height()) if (external_renderer_width_ != video_frame.Width() ||
{ external_renderer_height_ != video_frame.Height()) {
_externalRendererWidth = videoFrame.Width(); external_renderer_width_ = video_frame.Width();
_externalRendererHeight = videoFrame.Height(); external_renderer_height_ = video_frame.Height();
_externalRenderer->FrameSizeChange(_externalRendererWidth, _externalRendererHeight, streamId); external_renderer_->FrameSizeChange(external_renderer_width_,
external_renderer_height_, stream_id);
} }
if(pConvertedFrame) if (p_converted_frame) {
{ external_renderer_->DeliverFrame(p_converted_frame->Buffer(),
_externalRenderer->DeliverFrame(pConvertedFrame->Buffer(), p_converted_frame->Length(),
pConvertedFrame->Length(), video_frame.TimeStamp());
videoFrame.TimeStamp());
} }
return 0; return 0;
} }
} //namespace webrtc } // namespace webrtc

147
src/video_engine/vie_renderer.h
View File

@ -8,18 +8,13 @@
* be found in the AUTHORS file in the root of the source tree. * be found in the AUTHORS file in the root of the source tree.
*/ */
/* #ifndef WEBRTC_VIDEO_ENGINE_VIE_RENDERER_H_
* vie_renderer.h #define WEBRTC_VIDEO_ENGINE_VIE_RENDERER_H_
*/
#ifndef WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_RENDERER_H_ #include "modules/video_render/main/interface/video_render_defines.h"
#define WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_RENDERER_H_ #include "system_wrappers/interface/map_wrapper.h"
#include "video_engine/main/interface/vie_render.h"
#include "video_engine/vie_frame_provider_base.h"
#include "vie_frame_provider_base.h"
#include "map_wrapper.h"
#include "vie_render.h"
#include "video_render_defines.h"
namespace webrtc { namespace webrtc {
@ -27,94 +22,94 @@ class VideoRender;
class VideoRenderCallback; class VideoRenderCallback;
class ViERenderManager; class ViERenderManager;
class ViEExternalRendererImpl : public VideoRenderCallback {
class ViEExternalRendererImpl : public VideoRenderCallback public:
{
public:
ViEExternalRendererImpl(); ViEExternalRendererImpl();
int SetViEExternalRenderer(ExternalRenderer* externalRenderer, webrtc::RawVideoType videoInputFormat); virtual ~ViEExternalRendererImpl() {}
// implements VideoRenderCallback int SetViEExternalRenderer(ExternalRenderer* external_renderer,
virtual WebRtc_Word32 RenderFrame(const WebRtc_UWord32 streamId, RawVideoType video_input_format);
webrtc::VideoFrame& videoFrame);
virtual ~ViEExternalRendererImpl(){}; // Implements VideoRenderCallback.
virtual WebRtc_Word32 RenderFrame(const WebRtc_UWord32 stream_id,
VideoFrame& video_frame);
private: private:
ExternalRenderer* _externalRenderer; ExternalRenderer* external_renderer_;
webrtc::RawVideoType _externalRendererFormat; RawVideoType external_renderer_format_;
WebRtc_UWord32 _externalRendererWidth; WebRtc_UWord32 external_renderer_width_;
WebRtc_UWord32 _externalRendererHeight; WebRtc_UWord32 external_renderer_height_;
}; };
class ViERenderer: public ViEFrameCallback {
class ViERenderer: public ViEFrameCallback public:
{ static ViERenderer* CreateViERenderer(const WebRtc_Word32 render_id,
public: const WebRtc_Word32 engine_id,
static ViERenderer* CreateViERenderer(const WebRtc_Word32 renderId, VideoRender& render_module,
const WebRtc_Word32 engineId, ViERenderManager& render_manager,
VideoRender& renderModule, const WebRtc_UWord32 z_order,
ViERenderManager& renderManager, const float left,
const WebRtc_UWord32 zOrder, const float top,
const float left, const float right,
const float top, const float bottom);
const float right,
const float bottom);
~ViERenderer(void); ~ViERenderer(void);
WebRtc_Word32 StartRender(); WebRtc_Word32 StartRender();
WebRtc_Word32 StopRender(); WebRtc_Word32 StopRender();
WebRtc_Word32 GetLastRenderedFrame(const WebRtc_Word32 renderID, webrtc::VideoFrame& videoFrame); WebRtc_Word32 GetLastRenderedFrame(const WebRtc_Word32 renderID,
VideoFrame& video_frame);
WebRtc_Word32 ConfigureRenderer(const unsigned int zOrder,
const float left,
const float top,
const float right,
const float bottom);
WebRtc_Word32 ConfigureRenderer(const unsigned int z_order,
const float left,
const float top,
const float right,
const float bottom);
VideoRender& RenderModule(); VideoRender& RenderModule();
WebRtc_Word32 EnableMirroring(const WebRtc_Word32 renderId, const bool enable, const bool mirrorXAxis, const bool mirrorYAxis); WebRtc_Word32 EnableMirroring(const WebRtc_Word32 render_id,
const bool enable,
const bool mirror_xaxis,
const bool mirror_yaxis);
WebRtc_Word32 SetTimeoutImage(const webrtc::VideoFrame& timeoutImage,const WebRtc_Word32 timeoutValue); WebRtc_Word32 SetTimeoutImage(const VideoFrame& timeout_image,
WebRtc_Word32 SetRenderStartImage(const webrtc::VideoFrame& startImage); const WebRtc_Word32 timeout_value);
WebRtc_Word32 SetExternalRenderer(const WebRtc_Word32 renderId, webrtc::RawVideoType videoInputFormat, ExternalRenderer* externalRenderer); WebRtc_Word32 SetRenderStartImage(const VideoFrame& start_image);
WebRtc_Word32 SetExternalRenderer(const WebRtc_Word32 render_id,
RawVideoType video_input_format,
ExternalRenderer* external_renderer);
private: private:
WebRtc_Word32 Init(const WebRtc_UWord32 zOrder, ViERenderer(const WebRtc_Word32 render_id, const WebRtc_Word32 engine_id,
const float left, VideoRender& render_module,
const float top, ViERenderManager& render_manager);
const float right,
const float bottom);
ViERenderer(const WebRtc_Word32 renderId,const WebRtc_Word32 engineId,
VideoRender& renderModule,
ViERenderManager& renderManager);
WebRtc_Word32 Init(const WebRtc_UWord32 z_order,
const float left,
const float top,
const float right,
const float bottom);
// Implement ViEFrameCallback // Implement ViEFrameCallback
virtual void DeliverFrame(int id,
virtual void DeliverFrame(int id, VideoFrame& videoFrame, int numCSRCs = 0, VideoFrame& video_frame,
int num_csrcs = 0,
const WebRtc_UWord32 CSRC[kRtpCsrcSize] = NULL); const WebRtc_UWord32 CSRC[kRtpCsrcSize] = NULL);
virtual void DelayChanged(int id, int frameDelay){return;} virtual void DelayChanged(int id, int frame_delay);
virtual int GetPreferedFrameSettings(int &width, int &height, virtual int GetPreferedFrameSettings(int& width,
int &frameRate){return -1;} int& height,
int& frame_rate);
virtual void ProviderDestroyed(int id); virtual void ProviderDestroyed(int id);
WebRtc_UWord32 render_id_;
WebRtc_UWord32 _renderId; WebRtc_Word32 engine_id_;
WebRtc_Word32 _engineId; VideoRender& render_module_;
VideoRender& _renderModule; ViERenderManager& render_manager_;
ViERenderManager& _renderManager; VideoRenderCallback* render_callback_;
VideoRenderCallback* _ptrRenderCallback; ViEExternalRendererImpl* incoming_external_callback_;
ViEExternalRendererImpl* _ptrIncomingExternalCallback;
}; };
} //namespace webrtc } // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_RENDERER_H_ #endif // WEBRTC_VIDEO_ENGINE_VIE_RENDERER_H_