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

Avoid resetting encoder on identical settings.

Browse Source 
BUG=1681
R=holmer@google.com, stefan@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/1481005

git-svn-id: http://webrtc.googlecode.com/svn/trunk@4049 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
pbos@webrtc.org
2013-05-16 18:40:48 +00:00
parent 890f6092e6
commit b9bb3d1e7d
4 changed files with 172 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

187
webrtc/modules/video_coding/main/source/codec_database.cc
View File

@@ -47,6 +47,7 @@ VCMCodecDataBase::VCMCodecDataBase(int id)
number_of_cores_(0),
max_payload_size_(kDefaultPayloadSize),
periodic_key_frames_(false),
pending_encoder_reset_(true),
current_enc_is_external_(false),
send_codec_(),
receive_codec_(),
@@ -148,17 +149,18 @@ void VCMCodecDataBase::ResetSender() {
}
// Assuming only one registered encoder - since only one used, no need for more.
bool VCMCodecDataBase::RegisterSendCodec(
bool VCMCodecDataBase::SetSendCodec(
const VideoCodec* send_codec,
int number_of_cores,
int max_payload_size) {
int max_payload_size,
VCMEncodedFrameCallback* encoded_frame_callback) {
if (!send_codec) {
return false;
}
if (max_payload_size <= 0) {
max_payload_size = kDefaultPayloadSize;
}
if (number_of_cores < 0 || number_of_cores > 32) {
if (number_of_cores <= 0 || number_of_cores > 32) {
return false;
}
if (send_codec->plType <= 0) {
@@ -171,23 +173,86 @@ bool VCMCodecDataBase::RegisterSendCodec(
if (send_codec->codecType == kVideoCodecUnknown) {
return false;
}
number_of_cores_ = number_of_cores;
max_payload_size_ = max_payload_size;
bool reset_required = pending_encoder_reset_;
if (number_of_cores_ != number_of_cores) {
number_of_cores_ = number_of_cores;
reset_required = true;
}
if (max_payload_size_ != max_payload_size) {
max_payload_size_ = max_payload_size;
reset_required = true;
}
memcpy(&send_codec_, send_codec, sizeof(VideoCodec));
VideoCodec new_send_codec;
memcpy(&new_send_codec, send_codec, sizeof(new_send_codec));
if (send_codec_.maxBitrate == 0) {
if (new_send_codec.maxBitrate == 0) {
// max is one bit per pixel
send_codec_.maxBitrate = (static_cast<int>(send_codec_.height) *
static_cast<int>(send_codec_.width) *
static_cast<int>(send_codec_.maxFramerate)) / 1000;
if (send_codec_.startBitrate > send_codec_.maxBitrate) {
new_send_codec.maxBitrate = (static_cast<int>(send_codec->height) *
static_cast<int>(send_codec->width) *
static_cast<int>(send_codec->maxFramerate)) / 1000;
if (send_codec->startBitrate > new_send_codec.maxBitrate) {
// But if the user tries to set a higher start bit rate we will
// increase the max accordingly.
send_codec_.maxBitrate = send_codec_.startBitrate;
new_send_codec.maxBitrate = send_codec->startBitrate;
}
}
if (!reset_required) {
reset_required = RequiresEncoderReset(new_send_codec);
}
memcpy(&send_codec_, &new_send_codec, sizeof(send_codec_));
if (!reset_required) {
encoded_frame_callback->SetPayloadType(send_codec->plType);
if (ptr_encoder_->RegisterEncodeCallback(encoded_frame_callback) < 0) {
return false;
}
return true;
}
// If encoder exists, will destroy it and create new one.
DeleteEncoder();
if (send_codec->plType == external_payload_type_) {
// External encoder.
ptr_encoder_ = new VCMGenericEncoder(*external_encoder_, internal_source_);
current_enc_is_external_ = true;
} else {
ptr_encoder_ = CreateEncoder(send_codec->codecType);
current_enc_is_external_ = false;
}
encoded_frame_callback->SetPayloadType(send_codec->plType);
if (!ptr_encoder_) {
WEBRTC_TRACE(webrtc::kTraceError,
webrtc::kTraceVideoCoding,
VCMId(id_),
"Failed to create encoder: %s.",
send_codec->plName);
return false;
}
if (ptr_encoder_->InitEncode(send_codec,
number_of_cores_,
max_payload_size_) < 0) {
WEBRTC_TRACE(webrtc::kTraceError,
webrtc::kTraceVideoCoding,
VCMId(id_),
"Failed to initialize encoder: %s.",
send_codec->plName);
DeleteEncoder();
return false;
} else if (ptr_encoder_->RegisterEncodeCallback(encoded_frame_callback) < 0) {
DeleteEncoder();
return false;
}
// Intentionally don't check return value since the encoder registration
// shouldn't fail because the codec doesn't support changing the periodic key
// frame setting.
ptr_encoder_->SetPeriodicKeyFrames(periodic_key_frames_);
pending_encoder_reset_ = false;
return true;
}
@@ -239,48 +304,72 @@ void VCMCodecDataBase::RegisterExternalEncoder(
external_encoder_ = external_encoder;
external_payload_type_ = payload_type;
internal_source_ = internal_source;
pending_encoder_reset_ = true;
}
VCMGenericEncoder* VCMCodecDataBase::GetEncoder(
const VideoCodec* settings,
VCMEncodedFrameCallback* encoded_frame_callback) {
// If encoder exists, will destroy it and create new one.
DeleteEncoder();
if (settings->plType == external_payload_type_) {
// External encoder.
ptr_encoder_ = new VCMGenericEncoder(*external_encoder_, internal_source_);
current_enc_is_external_ = true;
} else {
ptr_encoder_ = CreateEncoder(settings->codecType);
current_enc_is_external_ = false;
bool VCMCodecDataBase::RequiresEncoderReset(const VideoCodec& new_send_codec) {
if (ptr_encoder_ == NULL) {
return true;
}
encoded_frame_callback->SetPayloadType(settings->plType);
if (!ptr_encoder_) {
WEBRTC_TRACE(webrtc::kTraceError,
webrtc::kTraceVideoCoding,
VCMId(id_),
"Failed to create encoder: %s.",
settings->plName);
return NULL;
// Does not check startBitrate or maxFramerate
if (new_send_codec.codecType != send_codec_.codecType ||
strcmp(new_send_codec.plName, send_codec_.plName) != 0 ||
new_send_codec.plType != send_codec_.plType ||
new_send_codec.width != send_codec_.width ||
new_send_codec.height != send_codec_.height ||
new_send_codec.maxBitrate != send_codec_.maxBitrate ||
new_send_codec.minBitrate != send_codec_.minBitrate ||
new_send_codec.qpMax != send_codec_.qpMax ||
new_send_codec.numberOfSimulcastStreams !=
send_codec_.numberOfSimulcastStreams ||
new_send_codec.mode != send_codec_.mode ||
new_send_codec.extra_options != send_codec_.extra_options) {
return true;
}
if (ptr_encoder_->InitEncode(settings, number_of_cores_, max_payload_size_) <
0) {
WEBRTC_TRACE(webrtc::kTraceError,
webrtc::kTraceVideoCoding,
VCMId(id_),
"Failed to initialize encoder: %s.",
settings->plName);
DeleteEncoder();
return NULL;
} else if (ptr_encoder_->RegisterEncodeCallback(encoded_frame_callback) <
0) {
DeleteEncoder();
return NULL;
switch (new_send_codec.codecType) {
case kVideoCodecVP8:
if (memcmp(&new_send_codec.codecSpecific.VP8,
&send_codec_.codecSpecific.VP8,
sizeof(new_send_codec.codecSpecific.VP8)) !=
0) {
return true;
}
break;
case kVideoCodecGeneric:
if (memcmp(&new_send_codec.codecSpecific.Generic,
&send_codec_.codecSpecific.Generic,
sizeof(new_send_codec.codecSpecific.Generic)) !=
0) {
return true;
}
break;
// Known codecs without payload-specifics
case kVideoCodecI420:
case kVideoCodecRED:
case kVideoCodecULPFEC:
break;
// Unknown codec type, reset just to be sure.
case kVideoCodecUnknown:
return true;
}
// Intentionally don't check return value since the encoder registration
// shouldn't fail because the codec doesn't support changing the periodic key
// frame setting.
ptr_encoder_->SetPeriodicKeyFrames(periodic_key_frames_);
if (new_send_codec.numberOfSimulcastStreams > 0) {
for (unsigned char i = 0; i < new_send_codec.numberOfSimulcastStreams;
++i) {
if (memcmp(&new_send_codec.simulcastStream[i],
&send_codec_.simulcastStream[i],
sizeof(new_send_codec.simulcastStream[i])) !=
0) {
return true;
}
}
}
return false;
}
VCMGenericEncoder* VCMCodecDataBase::GetEncoder() {
return ptr_encoder_;
}

21
webrtc/modules/video_coding/main/source/codec_database.h
View File

@@ -68,9 +68,10 @@ class VCMCodecDataBase {
// Sets the sender side codec and initiates the desired codec given the
// VideoCodec struct.
// Returns true if the codec was successfully registered, false otherwise.
bool RegisterSendCodec(const VideoCodec* send_codec,
int number_of_cores,
int max_payload_size);
bool SetSendCodec(const VideoCodec* send_codec,
int number_of_cores,
int max_payload_size,
VCMEncodedFrameCallback* encoded_frame_callback);
// Gets the current send codec. Relevant for internal codecs only.
// Returns true if there is a send codec, false otherwise.
@@ -93,15 +94,7 @@ class VCMCodecDataBase {
// if the external encoder was the send codec before being deregistered.
bool DeregisterExternalEncoder(uint8_t payload_type, bool* was_send_codec);
// Returns an encoder specified by the payload type in |settings|. The
// encoded frame callback of the encoder is set to |encoded_frame_callback|.
// If no such encoder already exists an instance will be created and
// initialized using |settings|.
// NULL is returned if no encoder with the specified payload type was found
// and the function failed to create one.
VCMGenericEncoder* GetEncoder(
const VideoCodec* settings,
VCMEncodedFrameCallback* encoded_frame_callback);
VCMGenericEncoder* GetEncoder();
bool SetPeriodicKeyFrames(bool enable);
@@ -165,6 +158,9 @@ class VCMCodecDataBase {
VideoCodec* new_codec,
bool* external) const;
// Determines whether a new codec has to be created or not.
// Checks every setting apart from maxFramerate and startBitrate.
bool RequiresEncoderReset(const VideoCodec& send_codec);
// Create an internal encoder given a codec type.
VCMGenericEncoder* CreateEncoder(const VideoCodecType type) const;
@@ -182,6 +178,7 @@ class VCMCodecDataBase {
int number_of_cores_;
int max_payload_size_;
bool periodic_key_frames_;
bool pending_encoder_reset_;
bool current_enc_is_external_;
VideoCodec send_codec_;
VideoCodec receive_codec_;

35
webrtc/modules/video_coding/main/source/generic_encoder.h
View File

@@ -85,40 +85,41 @@ public:
VCMGenericEncoder(VideoEncoder& encoder, bool internalSource = false);
~VCMGenericEncoder();
/**
* Free encoder memory
* Free encoder memory
*/
int32_t Release();
/**
* Initialize the encoder with the information from the VideoCodec
* Initialize the encoder with the information from the VideoCodec
*/
int32_t InitEncode(const VideoCodec* settings,
int32_t numberOfCores,
uint32_t maxPayloadSize);
int32_t numberOfCores,
uint32_t maxPayloadSize);
/**
* Encode raw image
* inputFrame : Frame containing raw image
* codecSpecificInfo : Specific codec data
* cameraFrameRate : request or information from the remote side
* frameType : The requested frame type to encode
* Encode raw image
* inputFrame : Frame containing raw image
* codecSpecificInfo : Specific codec data
* cameraFrameRate : Request or information from the remote side
* frameType : The requested frame type to encode
*/
int32_t Encode(const I420VideoFrame& inputFrame,
const CodecSpecificInfo* codecSpecificInfo,
const std::vector<FrameType>& frameTypes);
const CodecSpecificInfo* codecSpecificInfo,
const std::vector<FrameType>& frameTypes);
/**
* Set new target bitrate (bits/s) and framerate.
* Return Value: new bit rate if OK, otherwise <0s.
*/
int32_t SetRates(uint32_t target_bitrate,
uint32_t frameRate);
int32_t SetRates(uint32_t target_bitrate, uint32_t frameRate);
/**
* Set a new packet loss rate and a new round-trip time in milliseconds.
*/
int32_t SetChannelParameters(int32_t packetLoss, int rtt);
int32_t CodecConfigParameters(uint8_t* buffer, int32_t size);
/**
* Register a transport callback which will be called to deliver the encoded buffers
* Register a transport callback which will be called to deliver the encoded
* buffers
*/
int32_t RegisterEncodeCallback(VCMEncodedFrameCallback* VCMencodedFrameCallback);
int32_t RegisterEncodeCallback(
VCMEncodedFrameCallback* VCMencodedFrameCallback);
/**
* Get encoder bit rate
*/
@@ -138,8 +139,8 @@ private:
VideoEncoder& _encoder;
VideoCodecType _codecType;
VCMEncodedFrameCallback* _VCMencodedFrameCallback;
uint32_t _bitRate;
uint32_t _frameRate;
uint32_t _bitRate;
uint32_t _frameRate;
bool _internalSource;
}; // end of VCMGenericEncoder class

18
webrtc/modules/video_coding/main/source/video_coding_impl.cc
View File

@@ -325,26 +325,22 @@ VideoCodingModuleImpl::RegisterSendCodec(const VideoCodec* sendCodec,
uint32_t maxPayloadSize)
{
CriticalSectionScoped cs(_sendCritSect);
if (sendCodec == NULL)
{
if (sendCodec == NULL) {
return VCM_PARAMETER_ERROR;
}
bool ret = _codecDataBase.RegisterSendCodec(sendCodec, numberOfCores,
maxPayloadSize);
if (!ret)
{
return -1;
}
_encoder = _codecDataBase.GetEncoder(sendCodec, &_encodedFrameCallback);
if (_encoder == NULL)
{
bool ret = _codecDataBase.SetSendCodec(sendCodec, numberOfCores,
maxPayloadSize,
&_encodedFrameCallback);
if (!ret) {
WEBRTC_TRACE(webrtc::kTraceError,
webrtc::kTraceVideoCoding,
VCMId(_id),
"Failed to initialize encoder");
return VCM_CODEC_ERROR;
}
_encoder = _codecDataBase.GetEncoder();
_sendCodecType = sendCodec->codecType;
int numLayers = (_sendCodecType != kVideoCodecVP8) ? 1 :
sendCodec->codecSpecific.VP8.numberOfTemporalLayers;