Home | History | Annotate | Download | only in include 
      1 /*
      2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
      3  *
      4  *  Use of this source code is governed by a BSD-style license
      5  *  that can be found in the LICENSE file in the root of the source
      6  *  tree. An additional intellectual property rights grant can be found
      7  *  in the file PATENTS.  All contributing project authors may
      8  *  be found in the AUTHORS file in the root of the source tree.
      9  */
     10 
     11 #ifndef WEBRTC_MODULES_VIDEO_CODING_INCLUDE_VIDEO_CODING_DEFINES_H_
     12 #define WEBRTC_MODULES_VIDEO_CODING_INCLUDE_VIDEO_CODING_DEFINES_H_
     13 
     14 #include "webrtc/modules/include/module_common_types.h"
     15 #include "webrtc/typedefs.h"
     16 #include "webrtc/video_frame.h"
     17 
     18 namespace webrtc {
     19 
     20 // Error codes
     21 #define VCM_FRAME_NOT_READY 3
     22 #define VCM_REQUEST_SLI 2
     23 #define VCM_MISSING_CALLBACK 1
     24 #define VCM_OK 0
     25 #define VCM_GENERAL_ERROR -1
     26 #define VCM_LEVEL_EXCEEDED -2
     27 #define VCM_MEMORY -3
     28 #define VCM_PARAMETER_ERROR -4
     29 #define VCM_UNKNOWN_PAYLOAD -5
     30 #define VCM_CODEC_ERROR -6
     31 #define VCM_UNINITIALIZED -7
     32 #define VCM_NO_CODEC_REGISTERED -8
     33 #define VCM_JITTER_BUFFER_ERROR -9
     34 #define VCM_OLD_PACKET_ERROR -10
     35 #define VCM_NO_FRAME_DECODED -11
     36 #define VCM_ERROR_REQUEST_SLI -12
     37 #define VCM_NOT_IMPLEMENTED -20
     38 
     39 enum { kDefaultStartBitrateKbps = 300 };
     40 
     41 enum VCMVideoProtection {
     42   kProtectionNone,
     43   kProtectionNack,
     44   kProtectionFEC,
     45   kProtectionNackFEC,
     46 };
     47 
     48 enum VCMTemporalDecimation {
     49   kBitrateOverUseDecimation,
     50 };
     51 
     52 struct VCMFrameCount {
     53   uint32_t numKeyFrames;
     54   uint32_t numDeltaFrames;
     55 };
     56 
     57 // Callback class used for sending data ready to be packetized
     58 class VCMPacketizationCallback {
     59  public:
     60   virtual int32_t SendData(uint8_t payloadType,
     61                            const EncodedImage& encoded_image,
     62                            const RTPFragmentationHeader& fragmentationHeader,
     63                            const RTPVideoHeader* rtpVideoHdr) = 0;
     64 
     65   virtual void OnEncoderImplementationName(const char* implementation_name) {}
     66 
     67  protected:
     68   virtual ~VCMPacketizationCallback() {}
     69 };
     70 
     71 // Callback class used for passing decoded frames which are ready to be
     72 // rendered.
     73 class VCMReceiveCallback {
     74  public:
     75   virtual int32_t FrameToRender(VideoFrame& videoFrame) = 0;  // NOLINT
     76   virtual int32_t ReceivedDecodedReferenceFrame(const uint64_t pictureId) {
     77     return -1;
     78   }
     79   // Called when the current receive codec changes.
     80   virtual void OnIncomingPayloadType(int payload_type) {}
     81   virtual void OnDecoderImplementationName(const char* implementation_name) {}
     82 
     83  protected:
     84   virtual ~VCMReceiveCallback() {}
     85 };
     86 
     87 // Callback class used for informing the user of the bit rate and frame rate
     88 // produced by the
     89 // encoder.
     90 class VCMSendStatisticsCallback {
     91  public:
     92   virtual int32_t SendStatistics(const uint32_t bitRate,
     93                                  const uint32_t frameRate) = 0;
     94 
     95  protected:
     96   virtual ~VCMSendStatisticsCallback() {}
     97 };
     98 
     99 // Callback class used for informing the user of the incoming bit rate and frame
    100 // rate.
    101 class VCMReceiveStatisticsCallback {
    102  public:
    103   virtual void OnReceiveRatesUpdated(uint32_t bitRate, uint32_t frameRate) = 0;
    104   virtual void OnDiscardedPacketsUpdated(int discarded_packets) = 0;
    105   virtual void OnFrameCountsUpdated(const FrameCounts& frame_counts) = 0;
    106 
    107  protected:
    108   virtual ~VCMReceiveStatisticsCallback() {}
    109 };
    110 
    111 // Callback class used for informing the user of decode timing info.
    112 class VCMDecoderTimingCallback {
    113  public:
    114   virtual void OnDecoderTiming(int decode_ms,
    115                                int max_decode_ms,
    116                                int current_delay_ms,
    117                                int target_delay_ms,
    118                                int jitter_buffer_ms,
    119                                int min_playout_delay_ms,
    120                                int render_delay_ms) = 0;
    121 
    122  protected:
    123   virtual ~VCMDecoderTimingCallback() {}
    124 };
    125 
    126 // Callback class used for telling the user about how to configure the FEC,
    127 // and the rates sent the last second is returned to the VCM.
    128 class VCMProtectionCallback {
    129  public:
    130   virtual int ProtectionRequest(const FecProtectionParams* delta_params,
    131                                 const FecProtectionParams* key_params,
    132                                 uint32_t* sent_video_rate_bps,
    133                                 uint32_t* sent_nack_rate_bps,
    134                                 uint32_t* sent_fec_rate_bps) = 0;
    135 
    136  protected:
    137   virtual ~VCMProtectionCallback() {}
    138 };
    139 
    140 class VideoEncoderRateObserver {
    141  public:
    142   virtual ~VideoEncoderRateObserver() {}
    143   virtual void OnSetRates(uint32_t bitrate_bps, int framerate) = 0;
    144 };
    145 
    146 // Callback class used for telling the user about what frame type needed to
    147 // continue decoding.
    148 // Typically a key frame when the stream has been corrupted in some way.
    149 class VCMFrameTypeCallback {
    150  public:
    151   virtual int32_t RequestKeyFrame() = 0;
    152   virtual int32_t SliceLossIndicationRequest(const uint64_t pictureId) {
    153     return -1;
    154   }
    155 
    156  protected:
    157   virtual ~VCMFrameTypeCallback() {}
    158 };
    159 
    160 // Callback class used for telling the user about which packet sequence numbers
    161 // are currently
    162 // missing and need to be resent.
    163 class VCMPacketRequestCallback {
    164  public:
    165   virtual int32_t ResendPackets(const uint16_t* sequenceNumbers,
    166                                 uint16_t length) = 0;
    167 
    168  protected:
    169   virtual ~VCMPacketRequestCallback() {}
    170 };
    171 
    172 // Callback used to inform the user of the the desired resolution
    173 // as subscribed by Media Optimization (Quality Modes)
    174 class VCMQMSettingsCallback {
    175  public:
    176   virtual int32_t SetVideoQMSettings(const uint32_t frameRate,
    177                                      const uint32_t width,
    178                                      const uint32_t height) = 0;
    179 
    180   virtual void SetTargetFramerate(int frame_rate) = 0;
    181 
    182  protected:
    183   virtual ~VCMQMSettingsCallback() {}
    184 };
    185 
    186 // Callback class used for telling the user about the size (in time) of the
    187 // render buffer, that is the size in time of the complete continuous frames.
    188 class VCMRenderBufferSizeCallback {
    189  public:
    190   virtual void RenderBufferSizeMs(int buffer_size_ms) = 0;
    191 
    192  protected:
    193   virtual ~VCMRenderBufferSizeCallback() {}
    194 };
    195 
    196 }  // namespace webrtc
    197 
    198 #endif  // WEBRTC_MODULES_VIDEO_CODING_INCLUDE_VIDEO_CODING_DEFINES_H_
    199