generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactored ViEFileImpl and ViEExternalCodec.

Browse Source 
Review URL: http://webrtc-codereview.appspot.com/330007

git-svn-id: http://webrtc.googlecode.com/svn/trunk@1246 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
mflodman@webrtc.org 2011-12-20 10:39:30 +00:00
parent f3cea2336b
commit 813b4ef2ea
4 changed files with 1215 additions and 1635 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

193
src/video_engine/vie_external_codec_impl.cc
View File

@ -8,103 +8,75 @@
* 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 "video_engine/vie_external_codec_impl.h"
* vie_external_codec_impl.cc
*/
#include "engine_configurations.h" #include "engine_configurations.h"
#include "vie_external_codec_impl.h" #include "system_wrappers/interface/trace.h"
#include "vie_errors.h" #include "video_engine/main/interface/vie_errors.h"
#include "trace.h" #include "video_engine/vie_channel.h"
#include "vie_impl.h" #include "video_engine/vie_channel_manager.h"
#include "vie_channel.h" #include "video_engine/vie_encoder.h"
#include "vie_encoder.h" #include "video_engine/vie_impl.h"
#include "vie_channel_manager.h"
namespace webrtc namespace webrtc {
{
// ---------------------------------------------------------------------------- ViEExternalCodec* ViEExternalCodec::GetInterface(VideoEngine* video_engine) {
// GetInterface
// ----------------------------------------------------------------------------
ViEExternalCodec* ViEExternalCodec::GetInterface(VideoEngine* videoEngine)
{
#ifdef WEBRTC_VIDEO_ENGINE_EXTERNAL_CODEC_API #ifdef WEBRTC_VIDEO_ENGINE_EXTERNAL_CODEC_API
if (videoEngine == NULL) if (video_engine == NULL) {
{
return NULL; return NULL;
} }
VideoEngineImpl* vieImpl = reinterpret_cast<VideoEngineImpl*> (videoEngine); VideoEngineImpl* vie_impl = reinterpret_cast<VideoEngineImpl*>(video_engine);
ViEExternalCodecImpl* vieExternalCodecImpl = vieImpl; ViEExternalCodecImpl* vie_external_codec_impl = vie_impl;
(*vieExternalCodecImpl)++; // Increase ref count // Increase ref count.
(*vie_external_codec_impl)++;
return vieExternalCodecImpl; return vie_external_codec_impl;
#else #else
return NULL; return NULL;
#endif #endif
} }
// ---------------------------------------------------------------------------- int ViEExternalCodecImpl::Release() {
// Release WEBRTC_TRACE(kTraceApiCall, kTraceVideo, instance_id_,
//
// Releases the interface, i.e. reduces the reference counter. The number of
// remaining references is returned, -1 if released too many times.
// ----------------------------------------------------------------------------
int ViEExternalCodecImpl::Release()
{
WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideo, instance_id_,
"ViEExternalCodec::Release()"); "ViEExternalCodec::Release()");
(*this)--; // Decrease ref count // Decrease ref count.
(*this)--;
WebRtc_Word32 refCount = GetCount(); WebRtc_Word32 ref_count = GetCount();
if (refCount < 0) if (ref_count < 0) {
{ WEBRTC_TRACE(kTraceWarning, kTraceVideo, instance_id_,
WEBRTC_TRACE(webrtc::kTraceWarning, webrtc::kTraceVideo, instance_id_,
"ViEExternalCodec release too many times"); "ViEExternalCodec release too many times");
SetLastError(kViEAPIDoesNotExist); SetLastError(kViEAPIDoesNotExist);
return -1; return -1;
} }
WEBRTC_TRACE(webrtc::kTraceInfo, webrtc::kTraceVideo, instance_id_, WEBRTC_TRACE(kTraceInfo, kTraceVideo, instance_id_,
"ViEExternalCodec reference count: %d", refCount); "ViEExternalCodec reference count: %d", ref_count);
return refCount; return ref_count;
} }
// ---------------------------------------------------------------------------- int ViEExternalCodecImpl::RegisterExternalSendCodec(const int video_channel,
// RegisterExternalSendCodec const unsigned char pl_type,
// ---------------------------------------------------------------------------- VideoEncoder* encoder) {
WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_),
int ViEExternalCodecImpl::RegisterExternalSendCodec(const int videoChannel, "%s channel %d pl_type %d encoder 0x%x", __FUNCTION__,
const unsigned char plType, video_channel, pl_type, encoder);
VideoEncoder* encoder)
{
WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideo, ViEId(instance_id_),
"%s channel %d plType %d encoder 0x%x", __FUNCTION__,
videoChannel, plType, encoder);
ViEChannelManagerScoped cs(channel_manager_); ViEChannelManagerScoped cs(channel_manager_);
ViEEncoder* vieEncoder = cs.Encoder(videoChannel); ViEEncoder* vie_encoder = cs.Encoder(video_channel);
if (!vieEncoder) if (!vie_encoder) {
{ WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, "%s: Invalid argument video_channel %u. Does it exist?",
ViEId(instance_id_, videoChannel), __FUNCTION__, video_channel);
"%s: Invalid argument videoChannel %u. Does it exist?",
__FUNCTION__, videoChannel);
SetLastError(kViECodecInvalidArgument); SetLastError(kViECodecInvalidArgument);
return -1; return -1;
} }
if (!encoder) if (!encoder) {
{ WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
ViEId(instance_id_, videoChannel),
"%s: Invalid argument Encoder 0x%x.", __FUNCTION__, encoder); "%s: Invalid argument Encoder 0x%x.", __FUNCTION__, encoder);
SetLastError(kViECodecInvalidArgument); SetLastError(kViECodecInvalidArgument);
return -1; return -1;
} }
if (vieEncoder->RegisterExternalEncoder(encoder, plType) != 0) if (vie_encoder->RegisterExternalEncoder(encoder, pl_type) != 0) {
{
SetLastError(kViECodecUnknownError); SetLastError(kViECodecUnknownError);
return -1; return -1;
} }
@ -112,64 +84,57 @@ int ViEExternalCodecImpl::RegisterExternalSendCodec(const int videoChannel,
} }
int ViEExternalCodecImpl::DeRegisterExternalSendCodec( int ViEExternalCodecImpl::DeRegisterExternalSendCodec(
const int videoChannel, const unsigned char plType) const int video_channel, const unsigned char pl_type) {
{ WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_),
WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideo, ViEId(instance_id_), "%s channel %d pl_type %d", __FUNCTION__, video_channel,
"%s channel %d plType %d", __FUNCTION__, videoChannel, plType); pl_type);
ViEChannelManagerScoped cs(channel_manager_); ViEChannelManagerScoped cs(channel_manager_);
ViEEncoder* vieEncoder = cs.Encoder(videoChannel); ViEEncoder* vie_encoder = cs.Encoder(video_channel);
if (!vieEncoder) if (!vie_encoder) {
{ WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, "%s: Invalid argument video_channel %u. Does it exist?",
ViEId(instance_id_, videoChannel), __FUNCTION__, video_channel);
"%s: Invalid argument videoChannel %u. Does it exist?",
__FUNCTION__, videoChannel);
SetLastError(kViECodecInvalidArgument); SetLastError(kViECodecInvalidArgument);
return -1; return -1;
} }
if (vieEncoder->DeRegisterExternalEncoder(plType) != 0) if (vie_encoder->DeRegisterExternalEncoder(pl_type) != 0) {
{
SetLastError(kViECodecUnknownError); SetLastError(kViECodecUnknownError);
return -1; return -1;
} }
return 0; return 0;
} }
int ViEExternalCodecImpl::RegisterExternalReceiveCodec( int ViEExternalCodecImpl::RegisterExternalReceiveCodec(
const int videoChannel, const unsigned int plType, VideoDecoder* decoder, const int video_channel,
bool decoderRender /*= false*/, int renderDelay /*= 0*/) const unsigned int pl_type,
{ VideoDecoder* decoder,
WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideo, ViEId(instance_id_), bool decoder_render,
"%s channel %d plType %d decoder 0x%x, decoderRender %d, " int render_delay) {
"renderDelay %d", __FUNCTION__, videoChannel, plType, decoder, WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_),
decoderRender, renderDelay); "%s channel %d pl_type %d decoder 0x%x, decoder_render %d, "
"renderDelay %d", __FUNCTION__, video_channel, pl_type, decoder,
decoder_render, render_delay);
ViEChannelManagerScoped cs(channel_manager_); ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vieChannel = cs.Channel(videoChannel); ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vieChannel) if (!vie_channel) {
{ WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, "%s: Invalid argument video_channel %u. Does it exist?",
ViEId(instance_id_, videoChannel), __FUNCTION__, video_channel);
"%s: Invalid argument videoChannel %u. Does it exist?",
__FUNCTION__, videoChannel);
SetLastError(kViECodecInvalidArgument); SetLastError(kViECodecInvalidArgument);
return -1; return -1;
} }
if (!decoder) if (!decoder) {
{ WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo,
ViEId(instance_id_, videoChannel),
"%s: Invalid argument decoder 0x%x.", __FUNCTION__, decoder); "%s: Invalid argument decoder 0x%x.", __FUNCTION__, decoder);
SetLastError(kViECodecInvalidArgument); SetLastError(kViECodecInvalidArgument);
return -1; return -1;
} }
if (vieChannel->RegisterExternalDecoder(plType, decoder, decoderRender, if (vie_channel->RegisterExternalDecoder(pl_type, decoder, decoder_render,
renderDelay) != 0) render_delay) != 0) {
{
SetLastError(kViECodecUnknownError); SetLastError(kViECodecUnknownError);
return -1; return -1;
} }
@ -177,27 +142,25 @@ int ViEExternalCodecImpl::RegisterExternalReceiveCodec(
} }
int ViEExternalCodecImpl::DeRegisterExternalReceiveCodec( int ViEExternalCodecImpl::DeRegisterExternalReceiveCodec(
const int videoChannel, const unsigned char plType) const int video_channel, const unsigned char pl_type) {
{ WEBRTC_TRACE(kTraceApiCall, kTraceVideo, ViEId(instance_id_),
WEBRTC_TRACE(webrtc::kTraceApiCall, webrtc::kTraceVideo, ViEId(instance_id_), "%s channel %d pl_type %u", __FUNCTION__, video_channel,
"%s channel %d plType %u", __FUNCTION__, videoChannel, plType); pl_type);
ViEChannelManagerScoped cs(channel_manager_); ViEChannelManagerScoped cs(channel_manager_);
ViEChannel* vieChannel = cs.Channel(videoChannel); ViEChannel* vie_channel = cs.Channel(video_channel);
if (!vieChannel) if (!vie_channel) {
{ WEBRTC_TRACE(kTraceError, kTraceVideo, ViEId(instance_id_, video_channel),
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideo, "%s: Invalid argument video_channel %u. Does it exist?",
ViEId(instance_id_, videoChannel), __FUNCTION__, video_channel);
"%s: Invalid argument videoChannel %u. Does it exist?",
__FUNCTION__, videoChannel);
SetLastError(kViECodecInvalidArgument); SetLastError(kViECodecInvalidArgument);
return -1; return -1;
} }
if (vieChannel->DeRegisterExternalDecoder(plType) != 0) if (vie_channel->DeRegisterExternalDecoder(pl_type) != 0) {
{
SetLastError(kViECodecUnknownError); SetLastError(kViECodecUnknownError);
return -1; return -1;
} }
return 0; return 0;
} }
} // namespace webrtc } // namespace webrtc

57
src/video_engine/vie_external_codec_impl.h
View File

@ -8,47 +8,36 @@
* 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_EXTERNAL_CODEC_IMPL_H_
* vie_external_codec_impl.h #define WEBRTC_VIDEO_ENGINE_VIE_EXTERNAL_CODEC_IMPL_H_
*/
#ifndef WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_EXTERNAL_CODEC_IMPL_H_ #include "video_engine/main/interface/vie_external_codec.h"
#define WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_EXTERNAL_CODEC_IMPL_H_ #include "video_engine/vie_ref_count.h"
#include "video_engine/vie_shared_data.h"
#include "vie_external_codec.h" namespace webrtc {
#include "vie_ref_count.h"
#include "vie_shared_data.h"
namespace webrtc class ViEExternalCodecImpl
{ : public virtual ViESharedData,
// ----------------------------------------------------------------------------
// ViEExternalCodec
// ----------------------------------------------------------------------------
class ViEExternalCodecImpl : public virtual ViESharedData,
public ViEExternalCodec, public ViEExternalCodec,
public ViERefCount public ViERefCount {
{
public: public:
// Implements ViEExternalCodec.
virtual int Release(); virtual int Release();
virtual int RegisterExternalSendCodec(const int video_channel,
virtual int RegisterExternalSendCodec(const int videoChannel, const unsigned char pl_type,
const unsigned char plType,
VideoEncoder* encoder); VideoEncoder* encoder);
virtual int DeRegisterExternalSendCodec(const int video_channel,
virtual int DeRegisterExternalSendCodec(const int videoChannel, const unsigned char pl_type);
const unsigned char plType); virtual int RegisterExternalReceiveCodec(const int video_channel,
const unsigned int pl_type,
virtual int RegisterExternalReceiveCodec(const int videoChannel,
const unsigned int plType,
VideoDecoder* decoder, VideoDecoder* decoder,
bool decoderRender = false, bool decoder_render = false,
int renderDelay = 0); int render_delay = 0);
virtual int DeRegisterExternalReceiveCodec(const int video_channel,
virtual int DeRegisterExternalReceiveCodec(const int videoChannel, const unsigned char pl_type);
const unsigned char plType);
}; };
} // namespace webrtc } // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_EXTERNAL_CODEC_IMPL_H_
#endif // WEBRTC_VIDEO_ENGINE_VIE_EXTERNAL_CODEC_IMPL_H_

1350
src/video_engine/vie_file_impl.cc
View File

File diff suppressed because it is too large Load Diff

210
src/video_engine/vie_file_impl.h
View File

@ -8,168 +8,120 @@
* 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_FILE_IMPL_H_
* vie_file_impl.h #define WEBRTC_VIDEO_ENGINE_VIE_FILE_IMPL_H_
*/
#ifndef WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_FILE_IMPL_H_
#define WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_FILE_IMPL_H_
#include "typedefs.h" #include "typedefs.h"
#include "vie_defines.h" #include "video_engine/main/interface/vie_file.h"
#include "vie_file.h" #include "video_engine/vie_defines.h"
#include "vie_frame_provider_base.h" #include "video_engine/vie_frame_provider_base.h"
#include "vie_ref_count.h" #include "video_engine/vie_ref_count.h"
#include "vie_shared_data.h" #include "video_engine/vie_shared_data.h"
namespace webrtc {
namespace webrtc
{
class ConditionVariableWrapper; class ConditionVariableWrapper;
// ---------------------------------------------------------------------------- class ViECaptureSnapshot : public ViEFrameCallback {
// ViECaptureSnapshot
// ----------------------------------------------------------------------------
class ViECaptureSnapshot: public ViEFrameCallback
{
public: public:
ViECaptureSnapshot(); ViECaptureSnapshot();
~ViECaptureSnapshot(); ~ViECaptureSnapshot();
bool GetSnapshot(VideoFrame& videoFrame, unsigned int maxWaitTime); bool GetSnapshot(VideoFrame& video_frame, unsigned int max_wait_time);
// From ViEFrameCallback // Implements ViEFrameCallback.
virtual void DeliverFrame(int id, VideoFrame& videoFrame, int numCSRCs = 0, virtual void DeliverFrame(int id, 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 frame_delay) {}
virtual void DelayChanged(int id, int frameDelay) {}
virtual int GetPreferedFrameSettings(int& width, int& height, virtual int GetPreferedFrameSettings(int& width, int& height,
int &frameRate) int& frame_rate) {
{
return -1; return -1;
} }
virtual void ProviderDestroyed(int id) {} virtual void ProviderDestroyed(int id) {}
private: private:
CriticalSectionWrapper& _crit; CriticalSectionWrapper& crit_;
ConditionVariableWrapper& _conditionVaraible; ConditionVariableWrapper& condition_varaible_;
VideoFrame* _ptrVideoFrame; VideoFrame* video_frame_;
}; };
// ---------------------------------------------------------------------------- class ViEFileImpl
// VideoFileImpl : public virtual ViESharedData,
// ----------------------------------------------------------------------------
class ViEFileImpl: public virtual ViESharedData,
public ViEFile, public ViEFile,
public ViERefCount public ViERefCount {
{
public: public:
// Implements ViEFile.
virtual int Release(); virtual int Release();
virtual int StartPlayFile(const char* file_nameUTF8, int& file_id,
// Play file
virtual int StartPlayFile(const char* fileNameUTF8, int& fileId,
const bool loop = false, const bool loop = false,
const webrtc::FileFormats fileFormat = const FileFormats file_format = kFileFormatAviFile);
webrtc::kFileFormatAviFile); virtual int StopPlayFile(const int file_id);
virtual int RegisterObserver(int file_id, ViEFileObserver& observer);
virtual int StopPlayFile(const int fileId); virtual int DeregisterObserver(int file_id, ViEFileObserver& observer);
virtual int SendFileOnChannel(const int file_id, const int video_channel);
virtual int RegisterObserver(int fileId, ViEFileObserver& observer); virtual int StopSendFileOnChannel(const int video_channel);
virtual int StartPlayFileAsMicrophone(const int file_id,
virtual int DeregisterObserver(int fileId, ViEFileObserver& observer); const int audio_channel,
bool mix_microphone = false,
virtual int SendFileOnChannel(const int fileId, const int videoChannel); float volume_scaling = 1);
virtual int StopPlayFileAsMicrophone(const int file_id,
virtual int StopSendFileOnChannel(const int videoChannel); const int audio_channel);
virtual int StartPlayAudioLocally(const int file_id, const int audio_channel,
virtual int StartPlayFileAsMicrophone(const int fileId, float volume_scaling = 1);
const int audioChannel, virtual int StopPlayAudioLocally(const int file_id, const int audio_channel);
bool mixMicrophone = false, virtual int StartRecordOutgoingVideo(
float volumeScaling = 1); const int video_channel,
const char* file_nameUTF8,
virtual int StopPlayFileAsMicrophone(const int fileId, AudioSource audio_source,
const int audioChannel); const CodecInst& audio_codec,
const VideoCodec& video_codec,
virtual int StartPlayAudioLocally(const int fileId, const int audioChannel, const FileFormats file_format = kFileFormatAviFile);
float volumeScaling = 1); virtual int StartRecordIncomingVideo(
const int video_channel,
virtual int StopPlayAudioLocally(const int fileId, const int audioChannel); const char* file_nameUTF8,
AudioSource audio_source,
virtual int StartRecordOutgoingVideo(const int videoChannel, const CodecInst& audio_codec,
const char* fileNameUTF8, const VideoCodec& video_codec,
AudioSource audioSource, const FileFormats file_format = kFileFormatAviFile);
const webrtc::CodecInst& audioCodec, virtual int StopRecordOutgoingVideo(const int video_channel);
const VideoCodec& videoCodec, virtual int StopRecordIncomingVideo(const int video_channel);
const webrtc::FileFormats fileFormat = virtual int GetFileInformation(
webrtc::kFileFormatAviFile); const char* file_name,
VideoCodec& video_codec,
virtual int StartRecordIncomingVideo(const int videoChannel, CodecInst& audio_codec,
const char* fileNameUTF8, const FileFormats file_format = kFileFormatAviFile);
AudioSource audioSource, virtual int GetRenderSnapshot(const int video_channel,
const webrtc::CodecInst& audioCodec, const char* file_nameUTF8);
const VideoCodec& videoCodec, virtual int GetRenderSnapshot(const int video_channel, ViEPicture& picture);
const webrtc::FileFormats fileFormat =
webrtc::kFileFormatAviFile);
virtual int StopRecordOutgoingVideo(const int videoChannel);
virtual int StopRecordIncomingVideo(const int videoChannel);
// File information
virtual int GetFileInformation(const char* fileName,
VideoCodec& videoCodec,
webrtc::CodecInst& audioCodec,
const webrtc::FileFormats fileFormat =
webrtc::kFileFormatAviFile);
// Snapshot
virtual int GetRenderSnapshot(const int videoChannel,
const char* fileNameUTF8);
virtual int GetRenderSnapshot(const int videoChannel, ViEPicture& picture);
virtual int FreePicture(ViEPicture& picture); virtual int FreePicture(ViEPicture& picture);
virtual int GetCaptureDeviceSnapshot(const int capture_id,
virtual int GetCaptureDeviceSnapshot(const int captureId, const char* file_nameUTF8);
const char* fileNameUTF8); virtual int GetCaptureDeviceSnapshot(const int capture_id,
virtual int GetCaptureDeviceSnapshot(const int captureId,
ViEPicture& picture); ViEPicture& picture);
virtual int SetCaptureDeviceImage(const int capture_id,
// Capture device images const char* file_nameUTF8);
virtual int SetCaptureDeviceImage(const int captureId, virtual int SetCaptureDeviceImage(const int capture_id,
const char* fileNameUTF8);
virtual int SetCaptureDeviceImage(const int captureId,
const ViEPicture& picture); const ViEPicture& picture);
// Render images virtual int SetRenderStartImage(const int video_channel,
virtual int SetRenderStartImage(const int videoChannel, const char* file_nameUTF8);
const char* fileNameUTF8); virtual int SetRenderStartImage(const int video_channel,
virtual int SetRenderStartImage(const int videoChannel,
const ViEPicture& picture); const ViEPicture& picture);
virtual int SetRenderTimeoutImage(const int video_channel,
// Timeout image const char* file_nameUTF8,
virtual int SetRenderTimeoutImage(const int videoChannel, const unsigned int timeout_ms);
const char* fileNameUTF8, virtual int SetRenderTimeoutImage(const int video_channel,
const unsigned int timeoutMs);
virtual int SetRenderTimeoutImage(const int videoChannel,
const ViEPicture& picture, const ViEPicture& picture,
const unsigned int timeoutMs); const unsigned int timeout_ms);
protected: protected:
ViEFileImpl(); ViEFileImpl();
virtual ~ViEFileImpl(); virtual ~ViEFileImpl();
private: private:
WebRtc_Word32 GetNextCapturedFrame(WebRtc_Word32 captureId, WebRtc_Word32 GetNextCapturedFrame(WebRtc_Word32 capture_id,
VideoFrame& videoFrame); VideoFrame& video_frame);
}; };
} // namespace webrtc } // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_MAIN_SOURCE_VIE_FILE_IMPL_H_
#endif // WEBRTC_VIDEO_ENGINE_VIE_FILE_IMPL_H_