Home | History | Annotate | Download | only in video_engine 
      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 #include "webrtc/video_engine/vie_network_impl.h"
     12 
     13 #include <stdio.h>
     14 #if (defined(WIN32_) || defined(WIN64_))
     15 #include <qos.h>
     16 #endif
     17 
     18 #include "webrtc/engine_configurations.h"
     19 #include "webrtc/system_wrappers/interface/logging.h"
     20 #include "webrtc/video_engine/include/vie_errors.h"
     21 #include "webrtc/video_engine/vie_channel.h"
     22 #include "webrtc/video_engine/vie_channel_manager.h"
     23 #include "webrtc/video_engine/vie_defines.h"
     24 #include "webrtc/video_engine/vie_encoder.h"
     25 #include "webrtc/video_engine/vie_impl.h"
     26 #include "webrtc/video_engine/vie_shared_data.h"
     27 
     28 namespace webrtc {
     29 
     30 ViENetwork* ViENetwork::GetInterface(VideoEngine* video_engine) {
     31   if (!video_engine) {
     32     return NULL;
     33   }
     34   VideoEngineImpl* vie_impl = static_cast<VideoEngineImpl*>(video_engine);
     35   ViENetworkImpl* vie_networkImpl = vie_impl;
     36   // Increase ref count.
     37   (*vie_networkImpl)++;
     38   return vie_networkImpl;
     39 }
     40 
     41 int ViENetworkImpl::Release() {
     42   // Decrease ref count.
     43   (*this)--;
     44 
     45   int32_t ref_count = GetCount();
     46   if (ref_count < 0) {
     47     LOG(LS_ERROR) << "ViENetwork release too many times";
     48     shared_data_->SetLastError(kViEAPIDoesNotExist);
     49     return -1;
     50   }
     51   return ref_count;
     52 }
     53 
     54 void ViENetworkImpl::SetNetworkTransmissionState(const int video_channel,
     55                                                  const bool is_transmitting) {
     56   LOG_F(LS_INFO) << "channel: " << video_channel
     57                  << " transmitting: " << (is_transmitting ? "yes" : "no");
     58   ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
     59   ViEEncoder* vie_encoder = cs.Encoder(video_channel);
     60   if (!vie_encoder) {
     61     shared_data_->SetLastError(kViENetworkInvalidChannelId);
     62     return;
     63   }
     64   vie_encoder->SetNetworkTransmissionState(is_transmitting);
     65 }
     66 
     67 ViENetworkImpl::ViENetworkImpl(ViESharedData* shared_data)
     68     : shared_data_(shared_data) {}
     69 
     70 ViENetworkImpl::~ViENetworkImpl() {}
     71 
     72 int ViENetworkImpl::RegisterSendTransport(const int video_channel,
     73                                           Transport& transport) {
     74   LOG_F(LS_INFO) << "channel: " << video_channel;
     75   ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
     76   ViEChannel* vie_channel = cs.Channel(video_channel);
     77   if (!vie_channel) {
     78     shared_data_->SetLastError(kViENetworkInvalidChannelId);
     79     return -1;
     80   }
     81   if (vie_channel->Sending()) {
     82     LOG_F(LS_ERROR) << "Already sending on channel: " << video_channel;
     83     shared_data_->SetLastError(kViENetworkAlreadySending);
     84     return -1;
     85   }
     86   if (vie_channel->RegisterSendTransport(&transport) != 0) {
     87     shared_data_->SetLastError(kViENetworkUnknownError);
     88     return -1;
     89   }
     90   return 0;
     91 }
     92 
     93 int ViENetworkImpl::DeregisterSendTransport(const int video_channel) {
     94   LOG_F(LS_INFO) << "channel: " << video_channel;
     95   ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
     96   ViEChannel* vie_channel = cs.Channel(video_channel);
     97   if (!vie_channel) {
     98     shared_data_->SetLastError(kViENetworkInvalidChannelId);
     99     return -1;
    100   }
    101   if (vie_channel->Sending()) {
    102     LOG_F(LS_ERROR) << "Actively sending on channel: " << video_channel;
    103     shared_data_->SetLastError(kViENetworkAlreadySending);
    104     return -1;
    105   }
    106   if (vie_channel->DeregisterSendTransport() != 0) {
    107     shared_data_->SetLastError(kViENetworkUnknownError);
    108     return -1;
    109   }
    110   return 0;
    111 }
    112 
    113 int ViENetworkImpl::ReceivedRTPPacket(const int video_channel, const void* data,
    114                                       const int length,
    115                                       const PacketTime& packet_time) {
    116   ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
    117   ViEChannel* vie_channel = cs.Channel(video_channel);
    118   if (!vie_channel) {
    119     shared_data_->SetLastError(kViENetworkInvalidChannelId);
    120     return -1;
    121   }
    122   return vie_channel->ReceivedRTPPacket(data, length, packet_time);
    123 }
    124 
    125 int ViENetworkImpl::ReceivedRTCPPacket(const int video_channel,
    126                                        const void* data, const int length) {
    127   ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
    128   ViEChannel* vie_channel = cs.Channel(video_channel);
    129   if (!vie_channel) {
    130     shared_data_->SetLastError(kViENetworkInvalidChannelId);
    131     return -1;
    132   }
    133   return vie_channel->ReceivedRTCPPacket(data, length);
    134 }
    135 
    136 int ViENetworkImpl::SetMTU(int video_channel, unsigned int mtu) {
    137   LOG_F(LS_INFO) << "channel: " << video_channel << " mtu: " << mtu;
    138   ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
    139   ViEChannel* vie_channel = cs.Channel(video_channel);
    140   if (!vie_channel) {
    141     shared_data_->SetLastError(kViENetworkInvalidChannelId);
    142     return -1;
    143   }
    144   if (vie_channel->SetMTU(mtu) != 0) {
    145     shared_data_->SetLastError(kViENetworkUnknownError);
    146     return -1;
    147   }
    148   return 0;
    149 }
    150 
    151 int ViENetworkImpl::ReceivedBWEPacket(const int video_channel,
    152     int64_t arrival_time_ms, int payload_size, const RTPHeader& header) {
    153   ViEChannelManagerScoped cs(*(shared_data_->channel_manager()));
    154   ViEChannel* vie_channel = cs.Channel(video_channel);
    155   if (!vie_channel) {
    156     shared_data_->SetLastError(kViENetworkInvalidChannelId);
    157     return -1;
    158   }
    159 
    160   vie_channel->ReceivedBWEPacket(arrival_time_ms, payload_size, header);
    161   return 0;
    162 }
    163 
    164 bool ViENetworkImpl::SetBandwidthEstimationConfig(
    165     int video_channel, const webrtc::Config& config) {
    166   LOG_F(LS_INFO) << "channel: " << video_channel;
    167   return shared_data_->channel_manager()->SetBandwidthEstimationConfig(
    168       video_channel, config);
    169 }
    170 }  // namespace webrtc
    171