
Also wires up target_enc_bitrate in WebRtcVideoEngine2. BUG=1667,1788 R=mflodman@webrtc.org, stefan@webrtc.org Review URL: https://webrtc-codereview.appspot.com/42479004 Cr-Commit-Position: refs/heads/master@{#8515} git-svn-id: http://webrtc.googlecode.com/svn/trunk@8515 4adac7df-926f-26a2-2b94-8c16560cd09d
194 lines
7.2 KiB
C++
194 lines
7.2 KiB
C++
/*
|
|
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#ifndef WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_CODEC_DATABASE_H_
|
|
#define WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_CODEC_DATABASE_H_
|
|
|
|
#include <map>
|
|
|
|
#include "webrtc/modules/video_coding/codecs/interface/video_codec_interface.h"
|
|
#include "webrtc/modules/video_coding/main/interface/video_coding.h"
|
|
#include "webrtc/modules/video_coding/main/source/generic_decoder.h"
|
|
#include "webrtc/modules/video_coding/main/source/generic_encoder.h"
|
|
#include "webrtc/system_wrappers/interface/scoped_ptr.h"
|
|
#include "webrtc/typedefs.h"
|
|
|
|
namespace webrtc {
|
|
|
|
struct VCMDecoderMapItem {
|
|
public:
|
|
VCMDecoderMapItem(VideoCodec* settings,
|
|
int number_of_cores,
|
|
bool require_key_frame);
|
|
|
|
scoped_ptr<VideoCodec> settings;
|
|
int number_of_cores;
|
|
bool require_key_frame;
|
|
};
|
|
|
|
struct VCMExtDecoderMapItem {
|
|
public:
|
|
VCMExtDecoderMapItem(VideoDecoder* external_decoder_instance,
|
|
uint8_t payload_type,
|
|
bool internal_render_timing);
|
|
|
|
uint8_t payload_type;
|
|
VideoDecoder* external_decoder_instance;
|
|
bool internal_render_timing;
|
|
};
|
|
|
|
class VCMCodecDataBase {
|
|
public:
|
|
explicit VCMCodecDataBase(VideoEncoderRateObserver* encoder_rate_observer);
|
|
~VCMCodecDataBase();
|
|
|
|
// Sender Side
|
|
// Returns the number of supported codecs (or -1 in case of error).
|
|
static int NumberOfCodecs();
|
|
|
|
// Returns the default settings for the codec with id |list_id|.
|
|
static bool Codec(int list_id, VideoCodec* settings);
|
|
|
|
// Returns the default settings for the codec with type |codec_type|.
|
|
static bool 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.
|
|
bool SetSendCodec(const VideoCodec* send_codec,
|
|
int number_of_cores,
|
|
size_t 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.
|
|
bool SendCodec(VideoCodec* current_send_codec) const;
|
|
|
|
// Gets current send side codec type. Relevant for internal codecs only.
|
|
// Returns kVideoCodecUnknown if there is no send codec.
|
|
VideoCodecType SendCodec() const;
|
|
|
|
// Registers and initializes an external encoder object.
|
|
// |internal_source| should be set to true if the codec has an internal
|
|
// video source and doesn't need the user to provide it with frames via
|
|
// the Encode() method.
|
|
void RegisterExternalEncoder(VideoEncoder* external_encoder,
|
|
uint8_t payload_type,
|
|
bool internal_source);
|
|
|
|
// Deregisters an external encoder. Returns true if the encoder was
|
|
// found and deregistered, false otherwise. |was_send_codec| is set to true
|
|
// if the external encoder was the send codec before being deregistered.
|
|
bool DeregisterExternalEncoder(uint8_t payload_type, bool* was_send_codec);
|
|
|
|
VCMGenericEncoder* GetEncoder();
|
|
|
|
bool SetPeriodicKeyFrames(bool enable);
|
|
|
|
// Receiver Side
|
|
void ResetReceiver();
|
|
|
|
// Deregisters an external decoder object specified by |payload_type|.
|
|
bool DeregisterExternalDecoder(uint8_t payload_type);
|
|
|
|
// Registers an external decoder object to the payload type |payload_type|.
|
|
// |internal_render_timing| is set to true if the |external_decoder| has
|
|
// built in rendering which is able to obey the render timestamps of the
|
|
// encoded frames.
|
|
bool RegisterExternalDecoder(VideoDecoder* external_decoder,
|
|
uint8_t payload_type,
|
|
bool internal_render_timing);
|
|
|
|
bool DecoderRegistered() const;
|
|
|
|
bool RegisterReceiveCodec(const VideoCodec* receive_codec,
|
|
int number_of_cores,
|
|
bool require_key_frame);
|
|
|
|
bool DeregisterReceiveCodec(uint8_t payload_type);
|
|
|
|
// Get current receive side codec. Relevant for internal codecs only.
|
|
bool ReceiveCodec(VideoCodec* current_receive_codec) const;
|
|
|
|
// Get current receive side codec type. Relevant for internal codecs only.
|
|
VideoCodecType ReceiveCodec() const;
|
|
|
|
// Returns a decoder specified by |payload_type|. The decoded frame callback
|
|
// of the encoder is set to |decoded_frame_callback|. If no such decoder
|
|
// already exists an instance will be created and initialized.
|
|
// NULL is returned if no encoder with the specified payload type was found
|
|
// and the function failed to create one.
|
|
VCMGenericDecoder* GetDecoder(
|
|
uint8_t payload_type, VCMDecodedFrameCallback* decoded_frame_callback);
|
|
|
|
// Returns a deep copy of the currently active decoder.
|
|
VCMGenericDecoder* CreateDecoderCopy() const;
|
|
|
|
// Deletes the memory of the decoder instance |decoder|. Used to delete
|
|
// deep copies returned by CreateDecoderCopy().
|
|
void ReleaseDecoder(VCMGenericDecoder* decoder) const;
|
|
|
|
// Creates a deep copy of |decoder| and replaces the currently used decoder
|
|
// with it.
|
|
void CopyDecoder(const VCMGenericDecoder& decoder);
|
|
|
|
// Returns true if the currently active decoder supports render scheduling,
|
|
// that is, it is able to render frames according to the render timestamp of
|
|
// the encoded frames.
|
|
bool SupportsRenderScheduling() const;
|
|
|
|
private:
|
|
typedef std::map<uint8_t, VCMDecoderMapItem*> DecoderMap;
|
|
typedef std::map<uint8_t, VCMExtDecoderMapItem*> ExternalDecoderMap;
|
|
|
|
VCMGenericDecoder* CreateAndInitDecoder(uint8_t payload_type,
|
|
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;
|
|
|
|
void DeleteEncoder();
|
|
|
|
// Create an internal Decoder given a codec type
|
|
VCMGenericDecoder* CreateDecoder(VideoCodecType type) const;
|
|
|
|
const VCMDecoderMapItem* FindDecoderItem(uint8_t payload_type) const;
|
|
|
|
const VCMExtDecoderMapItem* FindExternalDecoderItem(
|
|
uint8_t payload_type) const;
|
|
|
|
int number_of_cores_;
|
|
size_t max_payload_size_;
|
|
bool periodic_key_frames_;
|
|
bool pending_encoder_reset_;
|
|
bool current_enc_is_external_;
|
|
VideoCodec send_codec_;
|
|
VideoCodec receive_codec_;
|
|
uint8_t external_payload_type_;
|
|
VideoEncoder* external_encoder_;
|
|
bool internal_source_;
|
|
VideoEncoderRateObserver* const encoder_rate_observer_;
|
|
VCMGenericEncoder* ptr_encoder_;
|
|
VCMGenericDecoder* ptr_decoder_;
|
|
bool current_dec_is_external_;
|
|
DecoderMap dec_map_;
|
|
ExternalDecoderMap dec_external_map_;
|
|
}; // VCMCodecDataBase
|
|
|
|
} // namespace webrtc
|
|
|
|
#endif // WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_CODEC_DATABASE_H_
|