Home | History | Annotate | Download | only in video 
      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 
     11 #include "webrtc/video/video_receive_stream.h"
     12 
     13 #include <assert.h>
     14 #include <stdlib.h>
     15 
     16 #include <string>
     17 
     18 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
     19 #include "webrtc/system_wrappers/interface/clock.h"
     20 #include "webrtc/system_wrappers/interface/logging.h"
     21 #include "webrtc/video/receive_statistics_proxy.h"
     22 #include "webrtc/video_engine/include/vie_base.h"
     23 #include "webrtc/video_engine/include/vie_capture.h"
     24 #include "webrtc/video_engine/include/vie_codec.h"
     25 #include "webrtc/video_engine/include/vie_external_codec.h"
     26 #include "webrtc/video_engine/include/vie_image_process.h"
     27 #include "webrtc/video_engine/include/vie_network.h"
     28 #include "webrtc/video_engine/include/vie_render.h"
     29 #include "webrtc/video_engine/include/vie_rtp_rtcp.h"
     30 #include "webrtc/video_receive_stream.h"
     31 
     32 namespace webrtc {
     33 namespace internal {
     34 
     35 VideoReceiveStream::VideoReceiveStream(webrtc::VideoEngine* video_engine,
     36                                        const VideoReceiveStream::Config& config,
     37                                        newapi::Transport* transport,
     38                                        webrtc::VoiceEngine* voice_engine,
     39                                        int base_channel)
     40     : transport_adapter_(transport),
     41       encoded_frame_proxy_(config.pre_decode_callback),
     42       config_(config),
     43       clock_(Clock::GetRealTimeClock()),
     44       channel_(-1) {
     45   video_engine_base_ = ViEBase::GetInterface(video_engine);
     46   video_engine_base_->CreateReceiveChannel(channel_, base_channel);
     47   assert(channel_ != -1);
     48 
     49   rtp_rtcp_ = ViERTP_RTCP::GetInterface(video_engine);
     50   assert(rtp_rtcp_ != NULL);
     51 
     52   // TODO(pbos): This is not fine grained enough...
     53   rtp_rtcp_->SetNACKStatus(channel_, config_.rtp.nack.rtp_history_ms > 0);
     54   rtp_rtcp_->SetKeyFrameRequestMethod(channel_, kViEKeyFrameRequestPliRtcp);
     55   SetRtcpMode(config_.rtp.rtcp_mode);
     56 
     57   assert(config_.rtp.remote_ssrc != 0);
     58   // TODO(pbos): What's an appropriate local_ssrc for receive-only streams?
     59   assert(config_.rtp.local_ssrc != 0);
     60   assert(config_.rtp.remote_ssrc != config_.rtp.local_ssrc);
     61 
     62   rtp_rtcp_->SetLocalSSRC(channel_, config_.rtp.local_ssrc);
     63   // TODO(pbos): Support multiple RTX, per video payload.
     64   Config::Rtp::RtxMap::const_iterator it = config_.rtp.rtx.begin();
     65   if (it != config_.rtp.rtx.end()) {
     66     assert(it->second.ssrc != 0);
     67     assert(it->second.payload_type != 0);
     68 
     69     rtp_rtcp_->SetRemoteSSRCType(channel_, kViEStreamTypeRtx, it->second.ssrc);
     70     rtp_rtcp_->SetRtxReceivePayloadType(channel_, it->second.payload_type);
     71   }
     72 
     73   rtp_rtcp_->SetRembStatus(channel_, false, config_.rtp.remb);
     74 
     75   for (size_t i = 0; i < config_.rtp.extensions.size(); ++i) {
     76     const std::string& extension = config_.rtp.extensions[i].name;
     77     int id = config_.rtp.extensions[i].id;
     78     if (extension == RtpExtension::kTOffset) {
     79       if (rtp_rtcp_->SetReceiveTimestampOffsetStatus(channel_, true, id) != 0)
     80         abort();
     81     } else if (extension == RtpExtension::kAbsSendTime) {
     82       if (rtp_rtcp_->SetReceiveAbsoluteSendTimeStatus(channel_, true, id) != 0)
     83         abort();
     84     } else {
     85       abort();  // Unsupported extension.
     86     }
     87   }
     88 
     89   network_ = ViENetwork::GetInterface(video_engine);
     90   assert(network_ != NULL);
     91 
     92   network_->RegisterSendTransport(channel_, transport_adapter_);
     93 
     94   codec_ = ViECodec::GetInterface(video_engine);
     95 
     96   if (config_.rtp.fec.ulpfec_payload_type != -1) {
     97     // ULPFEC without RED doesn't make sense.
     98     assert(config_.rtp.fec.red_payload_type != -1);
     99     VideoCodec codec;
    100     memset(&codec, 0, sizeof(codec));
    101     codec.codecType = kVideoCodecULPFEC;
    102     strcpy(codec.plName, "ulpfec");
    103     codec.plType = config_.rtp.fec.ulpfec_payload_type;
    104     if (codec_->SetReceiveCodec(channel_, codec) != 0) {
    105       LOG(LS_ERROR) << "Could not set ULPFEC codec. This shouldn't happen.";
    106       abort();
    107     }
    108   }
    109   if (config_.rtp.fec.red_payload_type != -1) {
    110     VideoCodec codec;
    111     memset(&codec, 0, sizeof(codec));
    112     codec.codecType = kVideoCodecRED;
    113     strcpy(codec.plName, "red");
    114     codec.plType = config_.rtp.fec.red_payload_type;
    115     if (codec_->SetReceiveCodec(channel_, codec) != 0) {
    116       LOG(LS_ERROR) << "Could not set RED codec. This shouldn't happen.";
    117       abort();
    118     }
    119   }
    120 
    121   assert(!config_.codecs.empty());
    122   for (size_t i = 0; i < config_.codecs.size(); ++i) {
    123     if (codec_->SetReceiveCodec(channel_, config_.codecs[i]) != 0) {
    124       // TODO(pbos): Abort gracefully, this can be a runtime error.
    125       //             Factor out to an Init() method.
    126       abort();
    127     }
    128   }
    129 
    130   stats_proxy_.reset(new ReceiveStatisticsProxy(
    131       config_.rtp.local_ssrc, clock_, rtp_rtcp_, codec_, channel_));
    132 
    133   if (rtp_rtcp_->RegisterReceiveChannelRtcpStatisticsCallback(
    134           channel_, stats_proxy_.get()) != 0)
    135     abort();
    136 
    137   if (rtp_rtcp_->RegisterReceiveChannelRtpStatisticsCallback(
    138           channel_, stats_proxy_.get()) != 0)
    139     abort();
    140 
    141   if (codec_->RegisterDecoderObserver(channel_, *stats_proxy_) != 0)
    142     abort();
    143 
    144   external_codec_ = ViEExternalCodec::GetInterface(video_engine);
    145   for (size_t i = 0; i < config_.external_decoders.size(); ++i) {
    146     const ExternalVideoDecoder& decoder = config_.external_decoders[i];
    147     if (external_codec_->RegisterExternalReceiveCodec(
    148             channel_,
    149             decoder.payload_type,
    150             decoder.decoder,
    151             decoder.renderer,
    152             decoder.expected_delay_ms) != 0) {
    153       // TODO(pbos): Abort gracefully? Can this be a runtime error?
    154       abort();
    155     }
    156   }
    157 
    158   render_ = ViERender::GetInterface(video_engine);
    159   assert(render_ != NULL);
    160 
    161   render_->AddRenderCallback(channel_, this);
    162 
    163   if (voice_engine) {
    164     video_engine_base_->SetVoiceEngine(voice_engine);
    165     video_engine_base_->ConnectAudioChannel(channel_, config_.audio_channel_id);
    166   }
    167 
    168   image_process_ = ViEImageProcess::GetInterface(video_engine);
    169   if (config.pre_decode_callback) {
    170     image_process_->RegisterPreDecodeImageCallback(channel_,
    171                                                    &encoded_frame_proxy_);
    172   }
    173   image_process_->RegisterPreRenderCallback(channel_, this);
    174 
    175   if (config.rtp.rtcp_xr.receiver_reference_time_report) {
    176     rtp_rtcp_->SetRtcpXrRrtrStatus(channel_, true);
    177   }
    178 }
    179 
    180 VideoReceiveStream::~VideoReceiveStream() {
    181   image_process_->DeRegisterPreRenderCallback(channel_);
    182   image_process_->DeRegisterPreDecodeCallback(channel_);
    183 
    184   render_->RemoveRenderer(channel_);
    185 
    186   for (size_t i = 0; i < config_.external_decoders.size(); ++i) {
    187     external_codec_->DeRegisterExternalReceiveCodec(
    188         channel_, config_.external_decoders[i].payload_type);
    189   }
    190 
    191   network_->DeregisterSendTransport(channel_);
    192 
    193   video_engine_base_->SetVoiceEngine(NULL);
    194   image_process_->Release();
    195   video_engine_base_->Release();
    196   external_codec_->Release();
    197   codec_->DeregisterDecoderObserver(channel_);
    198   rtp_rtcp_->DeregisterReceiveChannelRtpStatisticsCallback(channel_,
    199                                                            stats_proxy_.get());
    200   rtp_rtcp_->DeregisterReceiveChannelRtcpStatisticsCallback(channel_,
    201                                                             stats_proxy_.get());
    202   codec_->Release();
    203   network_->Release();
    204   render_->Release();
    205   rtp_rtcp_->Release();
    206 }
    207 
    208 void VideoReceiveStream::Start() {
    209   transport_adapter_.Enable();
    210   if (render_->StartRender(channel_) != 0)
    211     abort();
    212   if (video_engine_base_->StartReceive(channel_) != 0)
    213     abort();
    214 }
    215 
    216 void VideoReceiveStream::Stop() {
    217   if (render_->StopRender(channel_) != 0)
    218     abort();
    219   if (video_engine_base_->StopReceive(channel_) != 0)
    220     abort();
    221   transport_adapter_.Disable();
    222 }
    223 
    224 VideoReceiveStream::Stats VideoReceiveStream::GetStats() const {
    225   return stats_proxy_->GetStats();
    226 }
    227 
    228 void VideoReceiveStream::GetCurrentReceiveCodec(VideoCodec* receive_codec) {
    229   // TODO(pbos): Implement
    230 }
    231 
    232 bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
    233   return network_->ReceivedRTCPPacket(
    234              channel_, packet, static_cast<int>(length)) == 0;
    235 }
    236 
    237 bool VideoReceiveStream::DeliverRtp(const uint8_t* packet, size_t length) {
    238   return network_->ReceivedRTPPacket(
    239              channel_, packet, static_cast<int>(length), PacketTime()) == 0;
    240 }
    241 
    242 void VideoReceiveStream::FrameCallback(I420VideoFrame* video_frame) {
    243   stats_proxy_->OnDecodedFrame();
    244 
    245   if (config_.pre_render_callback)
    246     config_.pre_render_callback->FrameCallback(video_frame);
    247 }
    248 
    249 int32_t VideoReceiveStream::RenderFrame(const uint32_t stream_id,
    250                                         I420VideoFrame& video_frame) {
    251   if (config_.renderer != NULL)
    252     config_.renderer->RenderFrame(
    253         video_frame,
    254         video_frame.render_time_ms() - clock_->TimeInMilliseconds());
    255 
    256   stats_proxy_->OnRenderedFrame();
    257 
    258   return 0;
    259 }
    260 
    261 void VideoReceiveStream::SignalNetworkState(Call::NetworkState state) {
    262   if (state == Call::kNetworkUp)
    263     SetRtcpMode(config_.rtp.rtcp_mode);
    264   network_->SetNetworkTransmissionState(channel_, state == Call::kNetworkUp);
    265   if (state == Call::kNetworkDown)
    266     rtp_rtcp_->SetRTCPStatus(channel_, kRtcpNone);
    267 }
    268 
    269 void VideoReceiveStream::SetRtcpMode(newapi::RtcpMode mode) {
    270   switch (mode) {
    271     case newapi::kRtcpCompound:
    272       rtp_rtcp_->SetRTCPStatus(channel_, kRtcpCompound_RFC4585);
    273       break;
    274     case newapi::kRtcpReducedSize:
    275       rtp_rtcp_->SetRTCPStatus(channel_, kRtcpNonCompound_RFC5506);
    276       break;
    277   }
    278 }
    279 }  // namespace internal
    280 }  // namespace webrtc
    281