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

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

125
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 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(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, WebRtc_Word32 ConfigureRenderer(const unsigned int z_order,
const float left, const float left,
const float top, const float top,
const float right, const float right,
const float bottom); 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,
VideoRender& render_module,
ViERenderManager& render_manager);
WebRtc_Word32 Init(const WebRtc_UWord32 z_order,
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(const WebRtc_Word32 renderId,const WebRtc_Word32 engineId,
VideoRender& renderModule,
ViERenderManager& renderManager);
// 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_