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

Remove VideoReceiveStream deregister of decoders.

Browse Source 
Also doing some simplifications inside video_coding. No CHECKs added,
since they appear to have introduced breakages in downstream tests.

Overall reducing the number of potential ways a decoder could possibly
be set null. Removing deregistration of external decoders should also
give a quicker shutdown time since that may attempt to register
internal decoders.

BUG=chromium:563299
TBR=stefan@webrtc.org

Review URL: https://codereview.webrtc.org/1483423002 .

Cr-Commit-Position: refs/heads/master@{#10858}
This commit is contained in:
Peter Boström
2015-12-01 17:20:01 +01:00
parent 04a6bb9b63
commit 187db63fdf
7 changed files with 43 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
webrtc/modules/video_coding/codec_database.cc
View File

@ -111,8 +111,12 @@ VCMCodecDataBase::VCMCodecDataBase(
dec_external_map_() {}
VCMCodecDataBase::~VCMCodecDataBase() {
ResetSender();
ResetReceiver();
DeleteEncoder();
ReleaseDecoder(ptr_decoder_);
for (auto& kv : dec_map_)
delete kv.second;
for (auto& kv : dec_external_map_)
delete kv.second;
}
void VCMCodecDataBase::Codec(VideoCodecType codec_type, VideoCodec* settings) {
@ -188,11 +192,6 @@ void VCMCodecDataBase::Codec(VideoCodecType codec_type, VideoCodec* settings) {
}
}
void VCMCodecDataBase::ResetSender() {
DeleteEncoder();
periodic_key_frames_ = false;
}
// Assuming only one registered encoder - since only one used, no need for more.
bool VCMCodecDataBase::SetSendCodec(const VideoCodec* send_codec,
int number_of_cores,
@ -397,22 +396,6 @@ bool VCMCodecDataBase::SetPeriodicKeyFrames(bool enable) {
return true;
}
void VCMCodecDataBase::ResetReceiver() {
ReleaseDecoder(ptr_decoder_);
ptr_decoder_ = nullptr;
memset(&receive_codec_, 0, sizeof(VideoCodec));
while (!dec_map_.empty()) {
DecoderMap::iterator it = dec_map_.begin();
delete (*it).second;
dec_map_.erase(it);
}
while (!dec_external_map_.empty()) {
ExternalDecoderMap::iterator external_it = dec_external_map_.begin();
delete (*external_it).second;
dec_external_map_.erase(external_it);
}
}
bool VCMCodecDataBase::DeregisterExternalDecoder(uint8_t payload_type) {
ExternalDecoderMap::iterator it = dec_external_map_.find(payload_type);
if (it == dec_external_map_.end()) {
@ -423,13 +406,13 @@ bool VCMCodecDataBase::DeregisterExternalDecoder(uint8_t payload_type) {
// because payload type may be out of date (e.g. before we decode the first
// frame after RegisterReceiveCodec)
if (ptr_decoder_ != nullptr &&
&ptr_decoder_->_decoder == (*it).second->external_decoder_instance) {
ptr_decoder_->_decoder == (*it).second->external_decoder_instance) {
// Release it if it was registered and in use.
ReleaseDecoder(ptr_decoder_);
ptr_decoder_ = nullptr;
}
DeregisterReceiveCodec(payload_type);
delete (*it).second;
delete it->second;
dec_external_map_.erase(it);
return true;
}
@ -476,8 +459,7 @@ bool VCMCodecDataBase::DeregisterReceiveCodec(
if (it == dec_map_.end()) {
return false;
}
VCMDecoderMapItem* dec_item = (*it).second;
delete dec_item;
delete it->second;
dec_map_.erase(it);
if (receive_codec_.plType == payload_type) {
// This codec is currently in use.
@ -533,10 +515,10 @@ VCMGenericDecoder* VCMCodecDataBase::GetDecoder(
void VCMCodecDataBase::ReleaseDecoder(VCMGenericDecoder* decoder) const {
if (decoder) {
assert(&decoder->_decoder);
assert(decoder->_decoder);
decoder->Release();
if (!decoder->External()) {
delete &decoder->_decoder;
delete decoder->_decoder;
}
delete decoder;
}
@ -571,7 +553,7 @@ VCMGenericDecoder* VCMCodecDataBase::CreateAndInitDecoder(
if (external_dec_item) {
// External codec.
ptr_decoder = new VCMGenericDecoder(
*external_dec_item->external_decoder_instance, true);
external_dec_item->external_decoder_instance, true);
} else {
// Create decoder.
ptr_decoder = CreateDecoder(decoder_item->settings->codecType);
@ -607,14 +589,14 @@ void VCMCodecDataBase::DeleteEncoder() {
VCMGenericDecoder* VCMCodecDataBase::CreateDecoder(VideoCodecType type) const {
switch (type) {
case kVideoCodecVP8:
return new VCMGenericDecoder(*(VP8Decoder::Create()));
return new VCMGenericDecoder(VP8Decoder::Create());
case kVideoCodecVP9:
return new VCMGenericDecoder(*(VP9Decoder::Create()));
return new VCMGenericDecoder(VP9Decoder::Create());
case kVideoCodecI420:
return new VCMGenericDecoder(*(new I420Decoder));
return new VCMGenericDecoder(new I420Decoder());
case kVideoCodecH264:
if (H264Decoder::IsSupported()) {
return new VCMGenericDecoder(*(H264Decoder::Create()));
return new VCMGenericDecoder(H264Decoder::Create());
}
break;
default:

5
webrtc/modules/video_coding/codec_database.h
View File

@ -54,8 +54,6 @@ class VCMCodecDataBase {
// Returns the default settings for the codec with type |codec_type|.
static void Codec(VideoCodecType codec_type, VideoCodec* settings);
void ResetSender();
// Sets the sender side codec and initiates the desired codec given the
// VideoCodec struct.
// Returns true if the codec was successfully registered, false otherwise.
@ -88,9 +86,6 @@ class VCMCodecDataBase {
bool SetPeriodicKeyFrames(bool enable);
// Receiver Side
void ResetReceiver();
// Deregisters an external decoder object specified by |payload_type|.
bool DeregisterExternalDecoder(uint8_t payload_type);

41
webrtc/modules/video_coding/generic_decoder.cc
View File

@ -131,21 +131,16 @@ int32_t VCMDecodedFrameCallback::Pop(uint32_t timestamp)
return VCM_OK;
}
VCMGenericDecoder::VCMGenericDecoder(VideoDecoder& decoder, bool isExternal)
:
_callback(NULL),
VCMGenericDecoder::VCMGenericDecoder(VideoDecoder* decoder, bool isExternal)
: _callback(NULL),
_frameInfos(),
_nextFrameInfoIdx(0),
_decoder(decoder),
_codecType(kVideoCodecUnknown),
_isExternal(isExternal),
_keyFrameDecoded(false)
{
}
_keyFrameDecoded(false) {}
VCMGenericDecoder::~VCMGenericDecoder()
{
}
VCMGenericDecoder::~VCMGenericDecoder() {}
int32_t VCMGenericDecoder::InitDecode(const VideoCodec* settings,
int32_t numberOfCores)
@ -153,7 +148,7 @@ int32_t VCMGenericDecoder::InitDecode(const VideoCodec* settings,
TRACE_EVENT0("webrtc", "VCMGenericDecoder::InitDecode");
_codecType = settings->codecType;
return _decoder.InitDecode(settings, numberOfCores);
return _decoder->InitDecode(settings, numberOfCores);
}
int32_t VCMGenericDecoder::Decode(const VCMEncodedFrame& frame, int64_t nowMs) {
@ -165,11 +160,9 @@ int32_t VCMGenericDecoder::Decode(const VCMEncodedFrame& frame, int64_t nowMs) {
_callback->Map(frame.TimeStamp(), &_frameInfos[_nextFrameInfoIdx]);
_nextFrameInfoIdx = (_nextFrameInfoIdx + 1) % kDecoderFrameMemoryLength;
int32_t ret = _decoder.Decode(frame.EncodedImage(),
frame.MissingFrame(),
int32_t ret = _decoder->Decode(frame.EncodedImage(), frame.MissingFrame(),
frame.FragmentationHeader(),
frame.CodecSpecific(),
frame.RenderTimeMs());
frame.CodecSpecific(), frame.RenderTimeMs());
if (ret < WEBRTC_VIDEO_CODEC_OK)
{
@ -187,25 +180,21 @@ int32_t VCMGenericDecoder::Decode(const VCMEncodedFrame& frame, int64_t nowMs) {
return ret;
}
int32_t
VCMGenericDecoder::Release()
{
return _decoder.Release();
int32_t VCMGenericDecoder::Release() {
return _decoder->Release();
}
int32_t VCMGenericDecoder::Reset()
{
return _decoder.Reset();
int32_t VCMGenericDecoder::Reset() {
return _decoder->Reset();
}
int32_t VCMGenericDecoder::RegisterDecodeCompleteCallback(VCMDecodedFrameCallback* callback)
{
int32_t VCMGenericDecoder::RegisterDecodeCompleteCallback(
VCMDecodedFrameCallback* callback) {
_callback = callback;
return _decoder.RegisterDecodeCompleteCallback(callback);
return _decoder->RegisterDecodeCompleteCallback(callback);
}
bool VCMGenericDecoder::External() const
{
bool VCMGenericDecoder::External() const {
return _isExternal;
}

4
webrtc/modules/video_coding/generic_decoder.h
View File

@ -65,7 +65,7 @@ class VCMGenericDecoder
{
friend class VCMCodecDataBase;
public:
VCMGenericDecoder(VideoDecoder& decoder, bool isExternal = false);
VCMGenericDecoder(VideoDecoder* decoder, bool isExternal = false);
~VCMGenericDecoder();
/**
@ -102,7 +102,7 @@ private:
VCMDecodedFrameCallback* _callback;
VCMFrameInformation _frameInfos[kDecoderFrameMemoryLength];
uint32_t _nextFrameInfoIdx;
VideoDecoder& _decoder;
VideoDecoder* const _decoder;
VideoCodecType _codecType;
bool _isExternal;
bool _keyFrameDecoded;

3
webrtc/video/video_receive_stream.cc
View File

@ -295,9 +295,6 @@ VideoReceiveStream::~VideoReceiveStream() {
vie_channel_->RegisterPreRenderCallback(nullptr);
vie_channel_->RegisterPreDecodeImageCallback(nullptr);
for (size_t i = 0; i < config_.decoders.size(); ++i)
vie_channel_->DeRegisterExternalDecoder(config_.decoders[i].payload_type);
call_stats_->DeregisterStatsObserver(vie_channel_->GetStatsObserver());
congestion_controller_->SetChannelRembStatus(false, false,
vie_channel_->rtp_rtcp());

15
webrtc/video_engine/vie_channel.cc
View File

@ -187,6 +187,7 @@ ViEChannel::~ViEChannel() {
module_process_thread_->DeRegisterModule(rtp_rtcp);
delete rtp_rtcp;
}
if (!sender_)
StopDecodeThread();
// Release modules.
VideoCodingModule::Destroy(vcm_);
@ -439,20 +440,6 @@ int32_t ViEChannel::RegisterExternalDecoder(const uint8_t pl_type,
return vcm_->SetRenderDelay(render_delay);
}
int32_t ViEChannel::DeRegisterExternalDecoder(const uint8_t pl_type) {
RTC_DCHECK(!sender_);
VideoCodec current_receive_codec;
int32_t result = 0;
result = vcm_->ReceiveCodec(&current_receive_codec);
vcm_->RegisterExternalDecoder(NULL, pl_type, false);
if (result == 0 && current_receive_codec.plType == pl_type) {
result = vcm_->RegisterReceiveCodec(&current_receive_codec,
number_of_cores_, false);
}
return result;
}
int32_t ViEChannel::ReceiveCodecStatistics(uint32_t* num_key_frames,
uint32_t* num_delta_frames) {
CriticalSectionScoped cs(crit_.get());

1
webrtc/video_engine/vie_channel.h
View File

@ -94,7 +94,6 @@ class ViEChannel : public VCMFrameTypeCallback,
VideoDecoder* decoder,
bool buffered_rendering,
int32_t render_delay);
int32_t DeRegisterExternalDecoder(const uint8_t pl_type);
int32_t ReceiveCodecStatistics(uint32_t* num_key_frames,
uint32_t* num_delta_frames);
uint32_t DiscardedPackets() const;