diff options
Diffstat (limited to 'webrtc/modules/video_coding/include')
6 files changed, 963 insertions, 0 deletions
diff --git a/webrtc/modules/video_coding/include/mock/mock_vcm_callbacks.h b/webrtc/modules/video_coding/include/mock/mock_vcm_callbacks.h new file mode 100644 index 0000000000..0185dae333 --- /dev/null +++ b/webrtc/modules/video_coding/include/mock/mock_vcm_callbacks.h @@ -0,0 +1,34 @@ +/* + * 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_INCLUDE_MOCK_MOCK_VCM_CALLBACKS_H_ +#define WEBRTC_MODULES_VIDEO_CODING_INCLUDE_MOCK_MOCK_VCM_CALLBACKS_H_ + +#include "testing/gmock/include/gmock/gmock.h" +#include "webrtc/modules/video_coding/include/video_coding_defines.h" +#include "webrtc/typedefs.h" + +namespace webrtc { + +class MockVCMFrameTypeCallback : public VCMFrameTypeCallback { + public: + MOCK_METHOD0(RequestKeyFrame, int32_t()); + MOCK_METHOD1(SliceLossIndicationRequest, int32_t(const uint64_t pictureId)); +}; + +class MockPacketRequestCallback : public VCMPacketRequestCallback { + public: + MOCK_METHOD2(ResendPackets, + int32_t(const uint16_t* sequenceNumbers, uint16_t length)); +}; + +} // namespace webrtc + +#endif // WEBRTC_MODULES_VIDEO_CODING_INCLUDE_MOCK_MOCK_VCM_CALLBACKS_H_ diff --git a/webrtc/modules/video_coding/include/mock/mock_video_codec_interface.h b/webrtc/modules/video_coding/include/mock/mock_video_codec_interface.h new file mode 100644 index 0000000000..9cb4a83535 --- /dev/null +++ b/webrtc/modules/video_coding/include/mock/mock_video_codec_interface.h @@ -0,0 +1,81 @@ +/* + * 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_INCLUDE_MOCK_MOCK_VIDEO_CODEC_INTERFACE_H_ +#define WEBRTC_MODULES_VIDEO_CODING_INCLUDE_MOCK_MOCK_VIDEO_CODEC_INTERFACE_H_ + +#include <string> +#include <vector> + +#include "testing/gmock/include/gmock/gmock.h" +#include "webrtc/modules/video_coding/include/video_codec_interface.h" +#include "webrtc/typedefs.h" + +namespace webrtc { + +class MockEncodedImageCallback : public EncodedImageCallback { + public: + MOCK_METHOD3(Encoded, + int32_t(const EncodedImage& encodedImage, + const CodecSpecificInfo* codecSpecificInfo, + const RTPFragmentationHeader* fragmentation)); +}; + +class MockVideoEncoder : public VideoEncoder { + public: + MOCK_CONST_METHOD2(Version, int32_t(int8_t* version, int32_t length)); + MOCK_METHOD3(InitEncode, + int32_t(const VideoCodec* codecSettings, + int32_t numberOfCores, + size_t maxPayloadSize)); + MOCK_METHOD3(Encode, + int32_t(const VideoFrame& inputImage, + const CodecSpecificInfo* codecSpecificInfo, + const std::vector<FrameType>* frame_types)); + MOCK_METHOD1(RegisterEncodeCompleteCallback, + int32_t(EncodedImageCallback* callback)); + MOCK_METHOD0(Release, int32_t()); + MOCK_METHOD0(Reset, int32_t()); + MOCK_METHOD2(SetChannelParameters, int32_t(uint32_t packetLoss, int64_t rtt)); + MOCK_METHOD2(SetRates, int32_t(uint32_t newBitRate, uint32_t frameRate)); + MOCK_METHOD1(SetPeriodicKeyFrames, int32_t(bool enable)); +}; + +class MockDecodedImageCallback : public DecodedImageCallback { + public: + MOCK_METHOD1(Decoded, int32_t(VideoFrame& decodedImage)); // NOLINT + MOCK_METHOD2(Decoded, + int32_t(VideoFrame& decodedImage, // NOLINT + int64_t decode_time_ms)); + MOCK_METHOD1(ReceivedDecodedReferenceFrame, + int32_t(const uint64_t pictureId)); + MOCK_METHOD1(ReceivedDecodedFrame, int32_t(const uint64_t pictureId)); +}; + +class MockVideoDecoder : public VideoDecoder { + public: + MOCK_METHOD2(InitDecode, + int32_t(const VideoCodec* codecSettings, int32_t numberOfCores)); + MOCK_METHOD5(Decode, + int32_t(const EncodedImage& inputImage, + bool missingFrames, + const RTPFragmentationHeader* fragmentation, + const CodecSpecificInfo* codecSpecificInfo, + int64_t renderTimeMs)); + MOCK_METHOD1(RegisterDecodeCompleteCallback, + int32_t(DecodedImageCallback* callback)); + MOCK_METHOD0(Release, int32_t()); + MOCK_METHOD0(Reset, int32_t()); + MOCK_METHOD0(Copy, VideoDecoder*()); +}; + +} // namespace webrtc + +#endif // WEBRTC_MODULES_VIDEO_CODING_INCLUDE_MOCK_MOCK_VIDEO_CODEC_INTERFACE_H_ diff --git a/webrtc/modules/video_coding/include/video_codec_interface.h b/webrtc/modules/video_coding/include/video_codec_interface.h new file mode 100644 index 0000000000..19303c0d67 --- /dev/null +++ b/webrtc/modules/video_coding/include/video_codec_interface.h @@ -0,0 +1,99 @@ +/* + * 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_INCLUDE_VIDEO_CODEC_INTERFACE_H_ +#define WEBRTC_MODULES_VIDEO_CODING_INCLUDE_VIDEO_CODEC_INTERFACE_H_ + +#include <vector> + +#include "webrtc/common_types.h" +#include "webrtc/modules/include/module_common_types.h" +#include "webrtc/modules/video_coding/include/video_error_codes.h" +#include "webrtc/typedefs.h" +#include "webrtc/video_decoder.h" +#include "webrtc/video_encoder.h" +#include "webrtc/video_frame.h" + +namespace webrtc { + +class RTPFragmentationHeader; // forward declaration + +// Note: if any pointers are added to this struct, it must be fitted +// with a copy-constructor. See below. +struct CodecSpecificInfoVP8 { + bool hasReceivedSLI; + uint8_t pictureIdSLI; + bool hasReceivedRPSI; + uint64_t pictureIdRPSI; + int16_t pictureId; // Negative value to skip pictureId. + bool nonReference; + uint8_t simulcastIdx; + uint8_t temporalIdx; + bool layerSync; + int tl0PicIdx; // Negative value to skip tl0PicIdx. + int8_t keyIdx; // Negative value to skip keyIdx. +}; + +struct CodecSpecificInfoVP9 { + bool has_received_sli; + uint8_t picture_id_sli; + bool has_received_rpsi; + uint64_t picture_id_rpsi; + int16_t picture_id; // Negative value to skip pictureId. + + bool inter_pic_predicted; // This layer frame is dependent on previously + // coded frame(s). + bool flexible_mode; + bool ss_data_available; + + int tl0_pic_idx; // Negative value to skip tl0PicIdx. + uint8_t temporal_idx; + uint8_t spatial_idx; + bool temporal_up_switch; + bool inter_layer_predicted; // Frame is dependent on directly lower spatial + // layer frame. + uint8_t gof_idx; + + // SS data. + size_t num_spatial_layers; // Always populated. + bool spatial_layer_resolution_present; + uint16_t width[kMaxVp9NumberOfSpatialLayers]; + uint16_t height[kMaxVp9NumberOfSpatialLayers]; + GofInfoVP9 gof; + + // Frame reference data. + uint8_t num_ref_pics; + uint8_t p_diff[kMaxVp9RefPics]; +}; + +struct CodecSpecificInfoGeneric { + uint8_t simulcast_idx; +}; + +struct CodecSpecificInfoH264 {}; + +union CodecSpecificInfoUnion { + CodecSpecificInfoGeneric generic; + CodecSpecificInfoVP8 VP8; + CodecSpecificInfoVP9 VP9; + CodecSpecificInfoH264 H264; +}; + +// Note: if any pointers are added to this struct or its sub-structs, it +// must be fitted with a copy-constructor. This is because it is copied +// in the copy-constructor of VCMEncodedFrame. +struct CodecSpecificInfo { + VideoCodecType codecType; + CodecSpecificInfoUnion codecSpecific; +}; + +} // namespace webrtc + +#endif // WEBRTC_MODULES_VIDEO_CODING_INCLUDE_VIDEO_CODEC_INTERFACE_H_ diff --git a/webrtc/modules/video_coding/include/video_coding.h b/webrtc/modules/video_coding/include/video_coding.h new file mode 100644 index 0000000000..c46896c823 --- /dev/null +++ b/webrtc/modules/video_coding/include/video_coding.h @@ -0,0 +1,519 @@ +/* + * 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_INCLUDE_VIDEO_CODING_H_ +#define WEBRTC_MODULES_VIDEO_CODING_INCLUDE_VIDEO_CODING_H_ + +#if defined(WEBRTC_WIN) +// This is a workaround on Windows due to the fact that some Windows +// headers define CreateEvent as a macro to either CreateEventW or CreateEventA. +// This can cause problems since we use that name as well and could +// declare them as one thing here whereas in another place a windows header +// may have been included and then implementing CreateEvent() causes compilation +// errors. So for consistency, we include the main windows header here. +#include <windows.h> +#endif + +#include "webrtc/modules/include/module.h" +#include "webrtc/modules/include/module_common_types.h" +#include "webrtc/modules/video_coding/include/video_coding_defines.h" +#include "webrtc/system_wrappers/include/event_wrapper.h" +#include "webrtc/video_frame.h" + +namespace webrtc { + +class Clock; +class EncodedImageCallback; +class VideoEncoder; +class VideoDecoder; +struct CodecSpecificInfo; + +class EventFactory { + public: + virtual ~EventFactory() {} + + virtual EventWrapper* CreateEvent() = 0; +}; + +class EventFactoryImpl : public EventFactory { + public: + virtual ~EventFactoryImpl() {} + + virtual EventWrapper* CreateEvent() { return EventWrapper::Create(); } +}; + +// Used to indicate which decode with errors mode should be used. +enum VCMDecodeErrorMode { + kNoErrors, // Never decode with errors. Video will freeze + // if nack is disabled. + kSelectiveErrors, // Frames that are determined decodable in + // VCMSessionInfo may be decoded with missing + // packets. As not all incomplete frames will be + // decodable, video will freeze if nack is disabled. + kWithErrors // Release frames as needed. Errors may be + // introduced as some encoded frames may not be + // complete. +}; + +class VideoCodingModule : public Module { + public: + enum SenderNackMode { kNackNone, kNackAll, kNackSelective }; + + enum ReceiverRobustness { kNone, kHardNack, kSoftNack, kReferenceSelection }; + + static VideoCodingModule* Create( + Clock* clock, + VideoEncoderRateObserver* encoder_rate_observer, + VCMQMSettingsCallback* qm_settings_callback); + + static VideoCodingModule* Create(Clock* clock, EventFactory* event_factory); + + static void Destroy(VideoCodingModule* module); + + // Get supported codec settings using codec type + // + // Input: + // - codecType : The codec type to get settings for + // - codec : Memory where the codec settings will be stored + // + // Return value : VCM_OK, on success + // VCM_PARAMETER_ERROR if codec not supported + static void Codec(VideoCodecType codecType, VideoCodec* codec); + + /* + * Sender + */ + + // Registers a codec to be used for encoding. Calling this + // API multiple times overwrites any previously registered codecs. + // + // NOTE: Must be called on the thread that constructed the VCM instance. + // + // Input: + // - sendCodec : Settings for the codec to be registered. + // - numberOfCores : The number of cores the codec is allowed + // to use. + // - maxPayloadSize : The maximum size each payload is allowed + // to have. Usually MTU - overhead. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t RegisterSendCodec(const VideoCodec* sendCodec, + uint32_t numberOfCores, + uint32_t maxPayloadSize) = 0; + + // Register an external encoder object. This can not be used together with + // external decoder callbacks. + // + // Input: + // - externalEncoder : Encoder object to be used for encoding frames + // inserted + // with the AddVideoFrame API. + // - payloadType : The payload type bound which this encoder is bound + // to. + // + // Return value : VCM_OK, on success. + // < 0, on error. + // TODO(pbos): Remove return type when unused elsewhere. + virtual int32_t RegisterExternalEncoder(VideoEncoder* externalEncoder, + uint8_t payloadType, + bool internalSource = false) = 0; + + // API to get currently configured encoder target bitrate in bits/s. + // + // Return value : 0, on success. + // < 0, on error. + virtual int Bitrate(unsigned int* bitrate) const = 0; + + // API to get currently configured encoder target frame rate. + // + // Return value : 0, on success. + // < 0, on error. + virtual int FrameRate(unsigned int* framerate) const = 0; + + // Sets the parameters describing the send channel. These parameters are + // inputs to the + // Media Optimization inside the VCM and also specifies the target bit rate + // for the + // encoder. Bit rate used by NACK should already be compensated for by the + // user. + // + // Input: + // - target_bitrate : The target bitrate for VCM in bits/s. + // - lossRate : Fractions of lost packets the past second. + // (loss rate in percent = 100 * packetLoss / + // 255) + // - rtt : Current round-trip time in ms. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t SetChannelParameters(uint32_t target_bitrate, + uint8_t lossRate, + int64_t rtt) = 0; + + // Sets the parameters describing the receive channel. These parameters are + // inputs to the + // Media Optimization inside the VCM. + // + // Input: + // - rtt : Current round-trip time in ms. + // with the most amount available bandwidth in + // a conference + // scenario + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t SetReceiveChannelParameters(int64_t rtt) = 0; + + // Register a transport callback which will be called to deliver the encoded + // data and + // side information. + // + // Input: + // - transport : The callback object to register. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t RegisterTransportCallback( + VCMPacketizationCallback* transport) = 0; + + // Register video output information callback which will be called to deliver + // information + // about the video stream produced by the encoder, for instance the average + // frame rate and + // bit rate. + // + // Input: + // - outputInformation : The callback object to register. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t RegisterSendStatisticsCallback( + VCMSendStatisticsCallback* sendStats) = 0; + + // Register a video protection callback which will be called to deliver + // the requested FEC rate and NACK status (on/off). + // + // Input: + // - protection : The callback object to register. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t RegisterProtectionCallback( + VCMProtectionCallback* protection) = 0; + + // Enable or disable a video protection method. + // + // Input: + // - videoProtection : The method to enable or disable. + // - enable : True if the method should be enabled, false if + // it should be disabled. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t SetVideoProtection(VCMVideoProtection videoProtection, + bool enable) = 0; + + // Add one raw video frame to the encoder. This function does all the + // necessary + // processing, then decides what frame type to encode, or if the frame should + // be + // dropped. If the frame should be encoded it passes the frame to the encoder + // before it returns. + // + // Input: + // - videoFrame : Video frame to encode. + // - codecSpecificInfo : Extra codec information, e.g., pre-parsed + // in-band signaling. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t AddVideoFrame( + const VideoFrame& videoFrame, + const VideoContentMetrics* contentMetrics = NULL, + const CodecSpecificInfo* codecSpecificInfo = NULL) = 0; + + // Next frame encoded should be an intra frame (keyframe). + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t IntraFrameRequest(int stream_index) = 0; + + // Frame Dropper enable. Can be used to disable the frame dropping when the + // encoder + // over-uses its bit rate. This API is designed to be used when the encoded + // frames + // are supposed to be stored to an AVI file, or when the I420 codec is used + // and the + // target bit rate shouldn't affect the frame rate. + // + // Input: + // - enable : True to enable the setting, false to disable it. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t EnableFrameDropper(bool enable) = 0; + + /* + * Receiver + */ + + // Register possible receive codecs, can be called multiple times for + // different codecs. + // The module will automatically switch between registered codecs depending on + // the + // payload type of incoming frames. The actual decoder will be created when + // needed. + // + // Input: + // - receiveCodec : Settings for the codec to be registered. + // - numberOfCores : Number of CPU cores that the decoder is allowed + // to use. + // - requireKeyFrame : Set this to true if you don't want any delta + // frames + // to be decoded until the first key frame has been + // decoded. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec, + int32_t numberOfCores, + bool requireKeyFrame = false) = 0; + + // Register an externally defined decoder/renderer object. Can be a decoder + // only or a + // decoder coupled with a renderer. Note that RegisterReceiveCodec must be + // called to + // be used for decoding incoming streams. + // + // Input: + // - externalDecoder : The external decoder/renderer object. + // - payloadType : The payload type which this decoder should + // be + // registered to. + // + virtual void RegisterExternalDecoder(VideoDecoder* externalDecoder, + uint8_t payloadType) = 0; + + // Register a receive callback. Will be called whenever there is a new frame + // ready + // for rendering. + // + // Input: + // - receiveCallback : The callback object to be used by the + // module when a + // frame is ready for rendering. + // De-register with a NULL pointer. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t RegisterReceiveCallback( + VCMReceiveCallback* receiveCallback) = 0; + + // Register a receive statistics callback which will be called to deliver + // information + // about the video stream received by the receiving side of the VCM, for + // instance the + // average frame rate and bit rate. + // + // Input: + // - receiveStats : The callback object to register. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t RegisterReceiveStatisticsCallback( + VCMReceiveStatisticsCallback* receiveStats) = 0; + + // Register a decoder timing callback which will be called to deliver + // information about the timing of the decoder in the receiving side of the + // VCM, for instance the current and maximum frame decode latency. + // + // Input: + // - decoderTiming : The callback object to register. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t RegisterDecoderTimingCallback( + VCMDecoderTimingCallback* decoderTiming) = 0; + + // Register a frame type request callback. This callback will be called when + // the + // module needs to request specific frame types from the send side. + // + // Input: + // - frameTypeCallback : The callback object to be used by the + // module when + // requesting a specific type of frame from + // the send side. + // De-register with a NULL pointer. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t RegisterFrameTypeCallback( + VCMFrameTypeCallback* frameTypeCallback) = 0; + + // Registers a callback which is called whenever the receive side of the VCM + // encounters holes in the packet sequence and needs packets to be + // retransmitted. + // + // Input: + // - callback : The callback to be registered in the VCM. + // + // Return value : VCM_OK, on success. + // <0, on error. + virtual int32_t RegisterPacketRequestCallback( + VCMPacketRequestCallback* callback) = 0; + + // Waits for the next frame in the jitter buffer to become complete + // (waits no longer than maxWaitTimeMs), then passes it to the decoder for + // decoding. + // Should be called as often as possible to get the most out of the decoder. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t Decode(uint16_t maxWaitTimeMs = 200) = 0; + + // Registers a callback which conveys the size of the render buffer. + virtual int RegisterRenderBufferSizeCallback( + VCMRenderBufferSizeCallback* callback) = 0; + + // Reset the decoder state to the initial state. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t ResetDecoder() = 0; + + // API to get the codec which is currently used for decoding by the module. + // + // Input: + // - currentReceiveCodec : Settings for the codec to be registered. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t ReceiveCodec(VideoCodec* currentReceiveCodec) const = 0; + + // API to get the codec type currently used for decoding by the module. + // + // Return value : codecy type, on success. + // kVideoCodecUnknown, on error or if no receive codec is + // registered + virtual VideoCodecType ReceiveCodec() const = 0; + + // Insert a parsed packet into the receiver side of the module. Will be placed + // in the + // jitter buffer waiting for the frame to become complete. Returns as soon as + // the packet + // has been placed in the jitter buffer. + // + // Input: + // - incomingPayload : Payload of the packet. + // - payloadLength : Length of the payload. + // - rtpInfo : The parsed header. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t IncomingPacket(const uint8_t* incomingPayload, + size_t payloadLength, + const WebRtcRTPHeader& rtpInfo) = 0; + + // Minimum playout delay (Used for lip-sync). This is the minimum delay + // required + // to sync with audio. Not included in VideoCodingModule::Delay() + // Defaults to 0 ms. + // + // Input: + // - minPlayoutDelayMs : Additional delay in ms. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs) = 0; + + // Set the time required by the renderer to render a frame. + // + // Input: + // - timeMS : The time in ms required by the renderer to render a + // frame. + // + // Return value : VCM_OK, on success. + // < 0, on error. + virtual int32_t SetRenderDelay(uint32_t timeMS) = 0; + + // The total delay desired by the VCM. Can be less than the minimum + // delay set with SetMinimumPlayoutDelay. + // + // Return value : Total delay in ms, on success. + // < 0, on error. + virtual int32_t Delay() const = 0; + + // Returns the number of packets discarded by the jitter buffer due to being + // too late. This can include duplicated packets which arrived after the + // frame was sent to the decoder. Therefore packets which were prematurely + // NACKed will be counted. + virtual uint32_t DiscardedPackets() const = 0; + + // Robustness APIs + + // Set the receiver robustness mode. The mode decides how the receiver + // responds to losses in the stream. The type of counter-measure (soft or + // hard NACK, dual decoder, RPS, etc.) is selected through the + // robustnessMode parameter. The errorMode parameter decides if it is + // allowed to display frames corrupted by losses. Note that not all + // combinations of the two parameters are feasible. An error will be + // returned for invalid combinations. + // Input: + // - robustnessMode : selected robustness mode. + // - errorMode : selected error mode. + // + // Return value : VCM_OK, on success; + // < 0, on error. + virtual int SetReceiverRobustnessMode(ReceiverRobustness robustnessMode, + VCMDecodeErrorMode errorMode) = 0; + + // Set the decode error mode. The mode decides which errors (if any) are + // allowed in decodable frames. Note that setting decode_error_mode to + // anything other than kWithErrors without enabling nack will cause + // long-term freezes (resulting from frequent key frame requests) if + // packet loss occurs. + virtual void SetDecodeErrorMode(VCMDecodeErrorMode decode_error_mode) = 0; + + // Sets the maximum number of sequence numbers that we are allowed to NACK + // and the oldest sequence number that we will consider to NACK. If a + // sequence number older than |max_packet_age_to_nack| is missing + // a key frame will be requested. A key frame will also be requested if the + // time of incomplete or non-continuous frames in the jitter buffer is above + // |max_incomplete_time_ms|. + virtual void SetNackSettings(size_t max_nack_list_size, + int max_packet_age_to_nack, + int max_incomplete_time_ms) = 0; + + // Setting a desired delay to the VCM receiver. Video rendering will be + // delayed by at least desired_delay_ms. + virtual int SetMinReceiverDelay(int desired_delay_ms) = 0; + + // Lets the sender suspend video when the rate drops below + // |threshold_bps|, and turns back on when the rate goes back up above + // |threshold_bps| + |window_bps|. + virtual void SuspendBelowMinBitrate() = 0; + + // Returns true if SuspendBelowMinBitrate is engaged and the video has been + // suspended due to bandwidth limitations; otherwise false. + virtual bool VideoSuspended() const = 0; + + virtual void RegisterPreDecodeImageCallback( + EncodedImageCallback* observer) = 0; + virtual void RegisterPostEncodeImageCallback( + EncodedImageCallback* post_encode_callback) = 0; + // Releases pending decode calls, permitting faster thread shutdown. + virtual void TriggerDecoderShutdown() = 0; +}; + +} // namespace webrtc + +#endif // WEBRTC_MODULES_VIDEO_CODING_INCLUDE_VIDEO_CODING_H_ diff --git a/webrtc/modules/video_coding/include/video_coding_defines.h b/webrtc/modules/video_coding/include/video_coding_defines.h new file mode 100644 index 0000000000..673a02b713 --- /dev/null +++ b/webrtc/modules/video_coding/include/video_coding_defines.h @@ -0,0 +1,198 @@ +/* + * 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_INCLUDE_VIDEO_CODING_DEFINES_H_ +#define WEBRTC_MODULES_VIDEO_CODING_INCLUDE_VIDEO_CODING_DEFINES_H_ + +#include "webrtc/modules/include/module_common_types.h" +#include "webrtc/typedefs.h" +#include "webrtc/video_frame.h" + +namespace webrtc { + +// Error codes +#define VCM_FRAME_NOT_READY 3 +#define VCM_REQUEST_SLI 2 +#define VCM_MISSING_CALLBACK 1 +#define VCM_OK 0 +#define VCM_GENERAL_ERROR -1 +#define VCM_LEVEL_EXCEEDED -2 +#define VCM_MEMORY -3 +#define VCM_PARAMETER_ERROR -4 +#define VCM_UNKNOWN_PAYLOAD -5 +#define VCM_CODEC_ERROR -6 +#define VCM_UNINITIALIZED -7 +#define VCM_NO_CODEC_REGISTERED -8 +#define VCM_JITTER_BUFFER_ERROR -9 +#define VCM_OLD_PACKET_ERROR -10 +#define VCM_NO_FRAME_DECODED -11 +#define VCM_ERROR_REQUEST_SLI -12 +#define VCM_NOT_IMPLEMENTED -20 + +enum { kDefaultStartBitrateKbps = 300 }; + +enum VCMVideoProtection { + kProtectionNone, + kProtectionNack, + kProtectionFEC, + kProtectionNackFEC, +}; + +enum VCMTemporalDecimation { + kBitrateOverUseDecimation, +}; + +struct VCMFrameCount { + uint32_t numKeyFrames; + uint32_t numDeltaFrames; +}; + +// Callback class used for sending data ready to be packetized +class VCMPacketizationCallback { + public: + virtual int32_t SendData(uint8_t payloadType, + const EncodedImage& encoded_image, + const RTPFragmentationHeader& fragmentationHeader, + const RTPVideoHeader* rtpVideoHdr) = 0; + + virtual void OnEncoderImplementationName(const char* implementation_name) {} + + protected: + virtual ~VCMPacketizationCallback() {} +}; + +// Callback class used for passing decoded frames which are ready to be +// rendered. +class VCMReceiveCallback { + public: + virtual int32_t FrameToRender(VideoFrame& videoFrame) = 0; // NOLINT + virtual int32_t ReceivedDecodedReferenceFrame(const uint64_t pictureId) { + return -1; + } + // Called when the current receive codec changes. + virtual void OnIncomingPayloadType(int payload_type) {} + virtual void OnDecoderImplementationName(const char* implementation_name) {} + + protected: + virtual ~VCMReceiveCallback() {} +}; + +// Callback class used for informing the user of the bit rate and frame rate +// produced by the +// encoder. +class VCMSendStatisticsCallback { + public: + virtual int32_t SendStatistics(const uint32_t bitRate, + const uint32_t frameRate) = 0; + + protected: + virtual ~VCMSendStatisticsCallback() {} +}; + +// Callback class used for informing the user of the incoming bit rate and frame +// rate. +class VCMReceiveStatisticsCallback { + public: + virtual void OnReceiveRatesUpdated(uint32_t bitRate, uint32_t frameRate) = 0; + virtual void OnDiscardedPacketsUpdated(int discarded_packets) = 0; + virtual void OnFrameCountsUpdated(const FrameCounts& frame_counts) = 0; + + protected: + virtual ~VCMReceiveStatisticsCallback() {} +}; + +// Callback class used for informing the user of decode timing info. +class VCMDecoderTimingCallback { + public: + virtual void OnDecoderTiming(int decode_ms, + int max_decode_ms, + int current_delay_ms, + int target_delay_ms, + int jitter_buffer_ms, + int min_playout_delay_ms, + int render_delay_ms) = 0; + + protected: + virtual ~VCMDecoderTimingCallback() {} +}; + +// Callback class used for telling the user about how to configure the FEC, +// and the rates sent the last second is returned to the VCM. +class VCMProtectionCallback { + public: + virtual int ProtectionRequest(const FecProtectionParams* delta_params, + const FecProtectionParams* key_params, + uint32_t* sent_video_rate_bps, + uint32_t* sent_nack_rate_bps, + uint32_t* sent_fec_rate_bps) = 0; + + protected: + virtual ~VCMProtectionCallback() {} +}; + +class VideoEncoderRateObserver { + public: + virtual ~VideoEncoderRateObserver() {} + virtual void OnSetRates(uint32_t bitrate_bps, int framerate) = 0; +}; + +// Callback class used for telling the user about what frame type needed to +// continue decoding. +// Typically a key frame when the stream has been corrupted in some way. +class VCMFrameTypeCallback { + public: + virtual int32_t RequestKeyFrame() = 0; + virtual int32_t SliceLossIndicationRequest(const uint64_t pictureId) { + return -1; + } + + protected: + virtual ~VCMFrameTypeCallback() {} +}; + +// Callback class used for telling the user about which packet sequence numbers +// are currently +// missing and need to be resent. +class VCMPacketRequestCallback { + public: + virtual int32_t ResendPackets(const uint16_t* sequenceNumbers, + uint16_t length) = 0; + + protected: + virtual ~VCMPacketRequestCallback() {} +}; + +// Callback used to inform the user of the the desired resolution +// as subscribed by Media Optimization (Quality Modes) +class VCMQMSettingsCallback { + public: + virtual int32_t SetVideoQMSettings(const uint32_t frameRate, + const uint32_t width, + const uint32_t height) = 0; + + virtual void SetTargetFramerate(int frame_rate) = 0; + + protected: + virtual ~VCMQMSettingsCallback() {} +}; + +// Callback class used for telling the user about the size (in time) of the +// render buffer, that is the size in time of the complete continuous frames. +class VCMRenderBufferSizeCallback { + public: + virtual void RenderBufferSizeMs(int buffer_size_ms) = 0; + + protected: + virtual ~VCMRenderBufferSizeCallback() {} +}; + +} // namespace webrtc + +#endif // WEBRTC_MODULES_VIDEO_CODING_INCLUDE_VIDEO_CODING_DEFINES_H_ diff --git a/webrtc/modules/video_coding/include/video_error_codes.h b/webrtc/modules/video_coding/include/video_error_codes.h new file mode 100644 index 0000000000..360aa87744 --- /dev/null +++ b/webrtc/modules/video_coding/include/video_error_codes.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2011 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_INCLUDE_VIDEO_ERROR_CODES_H_ +#define WEBRTC_MODULES_VIDEO_CODING_INCLUDE_VIDEO_ERROR_CODES_H_ + +// NOTE: in sync with video_coding_module_defines.h + +// Define return values + +#define WEBRTC_VIDEO_CODEC_REQUEST_SLI 2 +#define WEBRTC_VIDEO_CODEC_NO_OUTPUT 1 +#define WEBRTC_VIDEO_CODEC_OK 0 +#define WEBRTC_VIDEO_CODEC_ERROR -1 +#define WEBRTC_VIDEO_CODEC_LEVEL_EXCEEDED -2 +#define WEBRTC_VIDEO_CODEC_MEMORY -3 +#define WEBRTC_VIDEO_CODEC_ERR_PARAMETER -4 +#define WEBRTC_VIDEO_CODEC_ERR_SIZE -5 +#define WEBRTC_VIDEO_CODEC_TIMEOUT -6 +#define WEBRTC_VIDEO_CODEC_UNINITIALIZED -7 +#define WEBRTC_VIDEO_CODEC_ERR_REQUEST_SLI -12 +#define WEBRTC_VIDEO_CODEC_FALLBACK_SOFTWARE -13 +#define WEBRTC_VIDEO_CODEC_TARGET_BITRATE_OVERSHOOT -14 + +#endif // WEBRTC_MODULES_VIDEO_CODING_INCLUDE_VIDEO_ERROR_CODES_H_ |