Home | History | Annotate | Download | only in webrtc 
      1 /*
      2  *  Copyright (c) 2013 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 #ifndef WEBRTC_CALL_H_
     11 #define WEBRTC_CALL_H_
     12 
     13 #include <string>
     14 #include <vector>
     15 
     16 #include "webrtc/common_types.h"
     17 #include "webrtc/video_receive_stream.h"
     18 #include "webrtc/video_send_stream.h"
     19 
     20 namespace webrtc {
     21 
     22 class VoiceEngine;
     23 
     24 const char* Version();
     25 
     26 class PacketReceiver {
     27  public:
     28   enum DeliveryStatus {
     29     DELIVERY_OK,
     30     DELIVERY_UNKNOWN_SSRC,
     31     DELIVERY_PACKET_ERROR,
     32   };
     33 
     34   virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
     35                                        size_t length) = 0;
     36 
     37  protected:
     38   virtual ~PacketReceiver() {}
     39 };
     40 
     41 // Callback interface for reporting when a system overuse is detected.
     42 // The detection is based on the jitter of incoming captured frames.
     43 class OveruseCallback {
     44  public:
     45   // Called as soon as an overuse is detected.
     46   virtual void OnOveruse() = 0;
     47   // Called periodically when the system is not overused any longer.
     48   virtual void OnNormalUse() = 0;
     49 
     50  protected:
     51   virtual ~OveruseCallback() {}
     52 };
     53 
     54 // A Call instance can contain several send and/or receive streams. All streams
     55 // are assumed to have the same remote endpoint and will share bitrate estimates
     56 // etc.
     57 class Call {
     58  public:
     59   enum NetworkState {
     60     kNetworkUp,
     61     kNetworkDown,
     62   };
     63   struct Config {
     64     explicit Config(newapi::Transport* send_transport)
     65         : webrtc_config(NULL),
     66           send_transport(send_transport),
     67           voice_engine(NULL),
     68           overuse_callback(NULL),
     69           start_bitrate_bps(-1) {}
     70 
     71     webrtc::Config* webrtc_config;
     72 
     73     newapi::Transport* send_transport;
     74 
     75     // VoiceEngine used for audio/video synchronization for this Call.
     76     VoiceEngine* voice_engine;
     77 
     78     // Callback for overuse and normal usage based on the jitter of incoming
     79     // captured frames. 'NULL' disables the callback.
     80     OveruseCallback* overuse_callback;
     81 
     82     // Start bitrate used before a valid bitrate estimate is calculated. '-1'
     83     // lets the call decide start bitrate.
     84     // Note: This currently only affects video.
     85     int start_bitrate_bps;
     86   };
     87 
     88   static Call* Create(const Call::Config& config);
     89 
     90   static Call* Create(const Call::Config& config,
     91                       const webrtc::Config& webrtc_config);
     92 
     93   virtual VideoSendStream* CreateVideoSendStream(
     94       const VideoSendStream::Config& config,
     95       const VideoEncoderConfig& encoder_config) = 0;
     96 
     97   virtual void DestroyVideoSendStream(VideoSendStream* send_stream) = 0;
     98 
     99   virtual VideoReceiveStream* CreateVideoReceiveStream(
    100       const VideoReceiveStream::Config& config) = 0;
    101   virtual void DestroyVideoReceiveStream(
    102       VideoReceiveStream* receive_stream) = 0;
    103 
    104   // All received RTP and RTCP packets for the call should be inserted to this
    105   // PacketReceiver. The PacketReceiver pointer is valid as long as the
    106   // Call instance exists.
    107   virtual PacketReceiver* Receiver() = 0;
    108 
    109   // Returns the estimated total send bandwidth. Note: this can differ from the
    110   // actual encoded bitrate.
    111   virtual uint32_t SendBitrateEstimate() = 0;
    112 
    113   // Returns the total estimated receive bandwidth for the call. Note: this can
    114   // differ from the actual receive bitrate.
    115   virtual uint32_t ReceiveBitrateEstimate() = 0;
    116 
    117   virtual void SignalNetworkState(NetworkState state) = 0;
    118 
    119   virtual ~Call() {}
    120 };
    121 }  // namespace webrtc
    122 
    123 #endif  // WEBRTC_CALL_H_
    124