admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove webrtc/stream.h and unutilized inheritance.

Browse Source 
Removes inheritance and a virtual call. Also removes a root header that
would have needed to be moved into a subdirectory otherwise to prevent
circular dependencies.

BUG=webrtc:4243
R=kjellander@webrtc.org, solenberg@webrtc.org
TBR=mflodman@webrtc.org

Review-Url: https://codereview.webrtc.org/1924793002
Cr-Commit-Position: refs/heads/master@{#12586}
This commit is contained in:
pbos 2016-05-01 20:18:34 -07:00 committed by Commit bot
parent 60d7e7c77d
commit 1ba8d39a9c
19 changed files with 167 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
webrtc/DEPS
View File

@ -19,7 +19,6 @@ include_rules = [
"+webrtc/common_types.h",
"+webrtc/config.h",
"+webrtc/engine_configurations.h",
"+webrtc/stream.h",
"+webrtc/transport.h",
"+webrtc/typedefs.h",
"+webrtc/video_decoder.h",

80
webrtc/audio/audio_receive_stream.cc
View File

@ -143,46 +143,6 @@ void AudioReceiveStream::Stop() {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
}
void AudioReceiveStream::SignalNetworkState(NetworkState state) {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
}
bool AudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
// TODO(solenberg): Tests call this function on a network thread, libjingle
// calls on the worker thread. We should move towards always using a network
// thread. Then this check can be enabled.
// RTC_DCHECK(!thread_checker_.CalledOnValidThread());
return channel_proxy_->ReceivedRTCPPacket(packet, length);
}
bool AudioReceiveStream::DeliverRtp(const uint8_t* packet,
size_t length,
const PacketTime& packet_time) {
// TODO(solenberg): Tests call this function on a network thread, libjingle
// calls on the worker thread. We should move towards always using a network
// thread. Then this check can be enabled.
// RTC_DCHECK(!thread_checker_.CalledOnValidThread());
RTPHeader header;
if (!rtp_header_parser_->Parse(packet, length, &header)) {
return false;
}
// Only forward if the parsed header has one of the headers necessary for
// bandwidth estimation. RTP timestamps has different rates for audio and
// video and shouldn't be mixed.
if (remote_bitrate_estimator_ &&
header.extension.hasTransportSequenceNumber) {
int64_t arrival_time_ms = TickTime::MillisecondTimestamp();
if (packet_time.timestamp >= 0)
arrival_time_ms = (packet_time.timestamp + 500) / 1000;
size_t payload_size = length - header.headerLength;
remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size,
header, false);
}
return channel_proxy_->ReceivedRTPPacket(packet, length, packet_time);
}
webrtc::AudioReceiveStream::Stats AudioReceiveStream::GetStats() const {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
webrtc::AudioReceiveStream::Stats stats;
@ -241,6 +201,46 @@ const webrtc::AudioReceiveStream::Config& AudioReceiveStream::config() const {
return config_;
}
void AudioReceiveStream::SignalNetworkState(NetworkState state) {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
}
bool AudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
// TODO(solenberg): Tests call this function on a network thread, libjingle
// calls on the worker thread. We should move towards always using a network
// thread. Then this check can be enabled.
// RTC_DCHECK(!thread_checker_.CalledOnValidThread());
return channel_proxy_->ReceivedRTCPPacket(packet, length);
}
bool AudioReceiveStream::DeliverRtp(const uint8_t* packet,
size_t length,
const PacketTime& packet_time) {
// TODO(solenberg): Tests call this function on a network thread, libjingle
// calls on the worker thread. We should move towards always using a network
// thread. Then this check can be enabled.
// RTC_DCHECK(!thread_checker_.CalledOnValidThread());
RTPHeader header;
if (!rtp_header_parser_->Parse(packet, length, &header)) {
return false;
}
// Only forward if the parsed header has one of the headers necessary for
// bandwidth estimation. RTP timestamps has different rates for audio and
// video and shouldn't be mixed.
if (remote_bitrate_estimator_ &&
header.extension.hasTransportSequenceNumber) {
int64_t arrival_time_ms = TickTime::MillisecondTimestamp();
if (packet_time.timestamp >= 0)
arrival_time_ms = (packet_time.timestamp + 500) / 1000;
size_t payload_size = length - header.headerLength;
remote_bitrate_estimator_->IncomingPacket(arrival_time_ms, payload_size,
header, false);
}
return channel_proxy_->ReceivedRTPPacket(packet, length, packet_time);
}
VoiceEngine* AudioReceiveStream::voice_engine() const {
internal::AudioState* audio_state =
static_cast<internal::AudioState*>(audio_state_.get());

15
webrtc/audio/audio_receive_stream.h
View File

@ -36,20 +36,17 @@ class AudioReceiveStream final : public webrtc::AudioReceiveStream {
const rtc::scoped_refptr<webrtc::AudioState>& audio_state);
~AudioReceiveStream() override;
// webrtc::ReceiveStream implementation.
// webrtc::AudioReceiveStream implementation.
void Start() override;
void Stop() override;
void SignalNetworkState(NetworkState state) override;
bool DeliverRtcp(const uint8_t* packet, size_t length) override;
bool DeliverRtp(const uint8_t* packet,
size_t length,
const PacketTime& packet_time) override;
// webrtc::AudioReceiveStream implementation.
webrtc::AudioReceiveStream::Stats GetStats() const override;
void SetSink(std::unique_ptr<AudioSinkInterface> sink) override;
void SignalNetworkState(NetworkState state);
bool DeliverRtcp(const uint8_t* packet, size_t length);
bool DeliverRtp(const uint8_t* packet,
size_t length,
const PacketTime& packet_time);
const webrtc::AudioReceiveStream::Config& config() const;
private:

24
webrtc/audio/audio_send_stream.cc
View File

@ -116,18 +116,6 @@ void AudioSendStream::Stop() {
}
}
void AudioSendStream::SignalNetworkState(NetworkState state) {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
}
bool AudioSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
// TODO(solenberg): Tests call this function on a network thread, libjingle
// calls on the worker thread. We should move towards always using a network
// thread. Then this check can be enabled.
// RTC_DCHECK(!thread_checker_.CalledOnValidThread());
return channel_proxy_->ReceivedRTCPPacket(packet, length);
}
bool AudioSendStream::SendTelephoneEvent(int payload_type, int event,
int duration_ms) {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
@ -218,6 +206,18 @@ webrtc::AudioSendStream::Stats AudioSendStream::GetStats() const {
return stats;
}
void AudioSendStream::SignalNetworkState(NetworkState state) {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
}
bool AudioSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
// TODO(solenberg): Tests call this function on a network thread, libjingle
// calls on the worker thread. We should move towards always using a network
// thread. Then this check can be enabled.
// RTC_DCHECK(!thread_checker_.CalledOnValidThread());
return channel_proxy_->ReceivedRTCPPacket(packet, length);
}
const webrtc::AudioSendStream::Config& AudioSendStream::config() const {
RTC_DCHECK(thread_checker_.CalledOnValidThread());
return config_;

8
webrtc/audio/audio_send_stream.h
View File

@ -34,17 +34,15 @@ class AudioSendStream final : public webrtc::AudioSendStream {
CongestionController* congestion_controller);
~AudioSendStream() override;
// webrtc::SendStream implementation.
// webrtc::AudioSendStream implementation.
void Start() override;
void Stop() override;
void SignalNetworkState(NetworkState state) override;
bool DeliverRtcp(const uint8_t* packet, size_t length) override;
// webrtc::AudioSendStream implementation.
bool SendTelephoneEvent(int payload_type, int event,
int duration_ms) override;
webrtc::AudioSendStream::Stats GetStats() const override;
void SignalNetworkState(NetworkState state);
bool DeliverRtcp(const uint8_t* packet, size_t length);
const webrtc::AudioSendStream::Config& config() const;
private:

14
webrtc/audio_receive_stream.h
View File

@ -16,8 +16,8 @@
#include <string>
#include <vector>
#include "webrtc/common_types.h"
#include "webrtc/config.h"
#include "webrtc/stream.h"
#include "webrtc/transport.h"
#include "webrtc/typedefs.h"
@ -31,7 +31,7 @@ class AudioSinkInterface;
// of WebRtc/Libjingle. Please use the VoiceEngine API instead.
// See: https://bugs.chromium.org/p/webrtc/issues/detail?id=4690
class AudioReceiveStream : public ReceiveStream {
class AudioReceiveStream {
public:
struct Stats {
uint32_t remote_ssrc = 0;
@ -103,6 +103,13 @@ class AudioReceiveStream : public ReceiveStream {
std::map<uint8_t, AudioDecoder*> decoder_map;
};
// Starts stream activity.
// When a stream is active, it can receive, process and deliver packets.
virtual void Start() = 0;
// Stops stream activity.
// When a stream is stopped, it can't receive, process or deliver packets.
virtual void Stop() = 0;
virtual Stats GetStats() const = 0;
// Sets an audio sink that receives unmixed audio from the receive stream.
@ -114,6 +121,9 @@ class AudioReceiveStream : public ReceiveStream {
// is being pulled+rendered and/or if audio is being pulled for the purposes
// of feeding to the AEC.
virtual void SetSink(std::unique_ptr<AudioSinkInterface> sink) = 0;
protected:
virtual ~AudioReceiveStream() {}
};
} // namespace webrtc

13
webrtc/audio_send_stream.h
View File

@ -18,7 +18,6 @@
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/config.h"
#include "webrtc/modules/audio_coding/codecs/audio_encoder.h"
#include "webrtc/stream.h"
#include "webrtc/transport.h"
#include "webrtc/typedefs.h"
@ -29,7 +28,7 @@ namespace webrtc {
// of WebRtc/Libjingle. Please use the VoiceEngine API instead.
// See: https://bugs.chromium.org/p/webrtc/issues/detail?id=4690
class AudioSendStream : public SendStream {
class AudioSendStream {
public:
struct Stats {
// TODO(solenberg): Harmonize naming and defaults with receive stream stats.
@ -90,10 +89,20 @@ class AudioSendStream : public SendStream {
int red_payload_type = -1; // pt, or -1 to disable REDundant coding.
};
// Starts stream activity.
// When a stream is active, it can receive, process and deliver packets.
virtual void Start() = 0;
// Stops stream activity.
// When a stream is stopped, it can't receive, process or deliver packets.
virtual void Stop() = 0;
// TODO(solenberg): Make payload_type a config property instead.
virtual bool SendTelephoneEvent(int payload_type, int event,
int duration_ms) = 0;
virtual Stats GetStats() const = 0;
protected:
virtual ~AudioSendStream() {}
};
} // namespace webrtc

5
webrtc/common_types.h
View File

@ -880,6 +880,11 @@ class StreamDataCountersCallback {
// RTCP mode is described by RFC 5506.
enum class RtcpMode { kOff, kCompound, kReducedSize };
enum NetworkState {
kNetworkUp,
kNetworkDown,
};
} // namespace webrtc
#endif // WEBRTC_COMMON_TYPES_H_

4
webrtc/media/engine/fakewebrtccall.cc
View File

@ -80,10 +80,6 @@ bool FakeAudioReceiveStream::DeliverRtp(const uint8_t* packet,
return true;
}
bool FakeAudioReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
return true;
}
webrtc::AudioReceiveStream::Stats FakeAudioReceiveStream::GetStats() const {
return stats_;
}

36
webrtc/media/engine/fakewebrtccall.h
View File

@ -48,15 +48,10 @@ class FakeAudioSendStream final : public webrtc::AudioSendStream {
bool IsSending() const { return sending_; }
private:
// webrtc::SendStream implementation.
// webrtc::AudioSendStream implementation.
void Start() override { sending_ = true; }
void Stop() override { sending_ = false; }
void SignalNetworkState(webrtc::NetworkState state) override {}
bool DeliverRtcp(const uint8_t* packet, size_t length) override {
return true;
}
// webrtc::AudioSendStream implementation.
bool SendTelephoneEvent(int payload_type, int event,
int duration_ms) override;
webrtc::AudioSendStream::Stats GetStats() const override;
@ -77,18 +72,15 @@ class FakeAudioReceiveStream final : public webrtc::AudioReceiveStream {
int received_packets() const { return received_packets_; }
bool VerifyLastPacket(const uint8_t* data, size_t length) const;
const webrtc::AudioSinkInterface* sink() const { return sink_.get(); }
bool DeliverRtp(const uint8_t* packet,
size_t length,
const webrtc::PacketTime& packet_time) override;
bool DeliverRtcp(const uint8_t* packet, size_t length) override;
const webrtc::PacketTime& packet_time);
private:
// webrtc::ReceiveStream implementation.
// webrtc::AudioReceiveStream implementation.
void Start() override {}
void Stop() override {}
void SignalNetworkState(webrtc::NetworkState state) override {}
// webrtc::AudioReceiveStream implementation.
webrtc::AudioReceiveStream::Stats GetStats() const override;
void SetSink(std::unique_ptr<webrtc::AudioSinkInterface> sink) override;
@ -124,15 +116,9 @@ class FakeVideoSendStream final : public webrtc::VideoSendStream,
private:
void IncomingCapturedFrame(const webrtc::VideoFrame& frame) override;
// webrtc::SendStream implementation.
// webrtc::VideoSendStream implementation.
void Start() override;
void Stop() override;
void SignalNetworkState(webrtc::NetworkState state) override {}
bool DeliverRtcp(const uint8_t* packet, size_t length) override {
return true;
}
// webrtc::VideoSendStream implementation.
webrtc::VideoSendStream::Stats GetStats() override;
void ReconfigureVideoEncoder(
const webrtc::VideoEncoderConfig& config) override;
@ -166,20 +152,10 @@ class FakeVideoReceiveStream final : public webrtc::VideoReceiveStream {
void SetStats(const webrtc::VideoReceiveStream::Stats& stats);
private:
// webrtc::ReceiveStream implementation.
// webrtc::VideoReceiveStream implementation.
void Start() override;
void Stop() override;
void SignalNetworkState(webrtc::NetworkState state) override {}
bool DeliverRtcp(const uint8_t* packet, size_t length) override {
return true;
}
bool DeliverRtp(const uint8_t* packet,
size_t length,
const webrtc::PacketTime& packet_time) override {
return true;
}
// webrtc::VideoReceiveStream implementation.
webrtc::VideoReceiveStream::Stats GetStats() const override;
webrtc::VideoReceiveStream::Config config_;

2
webrtc/modules/congestion_controller/include/congestion_controller.h
View File

@ -15,12 +15,12 @@
#include "webrtc/base/constructormagic.h"
#include "webrtc/base/scoped_ptr.h"
#include "webrtc/common_types.h"
#include "webrtc/modules/include/module.h"
#include "webrtc/modules/include/module_common_types.h"
#include "webrtc/modules/pacing/packet_router.h"
#include "webrtc/modules/remote_bitrate_estimator/remote_estimator_proxy.h"
#include "webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter.h"
#include "webrtc/stream.h"
namespace rtc {
struct SentPacket;

56
webrtc/stream.h
View File

@ -1,56 +0,0 @@
/*
* Copyright (c) 2015 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_STREAM_H_
#define WEBRTC_STREAM_H_
#include "webrtc/common_types.h"
namespace webrtc {
enum NetworkState {
kNetworkUp,
kNetworkDown,
};
// Common base class for streams.
class Stream {
public:
// Starts stream activity.
// When a stream is active, it can receive, process and deliver packets.
virtual void Start() = 0;
// Stops stream activity.
// When a stream is stopped, it can't receive, process or deliver packets.
virtual void Stop() = 0;
// Called to notify that network state has changed, so that the stream can
// respond, e.g. by pausing or resuming activity.
virtual void SignalNetworkState(NetworkState state) = 0;
// Called when a RTCP packet is received.
virtual bool DeliverRtcp(const uint8_t* packet, size_t length) = 0;
protected:
virtual ~Stream() {}
};
// Common base class for receive streams.
class ReceiveStream : public Stream {
public:
// Called when a RTP packet is received.
virtual bool DeliverRtp(const uint8_t* packet,
size_t length,
const PacketTime& packet_time) = 0;
};
// Common base class for send streams.
// A tag class that denotes send stream type.
class SendStream : public Stream {};
} // namespace webrtc
#endif // WEBRTC_STREAM_H_

31
webrtc/video/video_receive_stream.cc
View File

@ -322,6 +322,22 @@ VideoReceiveStream::~VideoReceiveStream() {
->RemoveStream(rtp_stream_receiver_.GetRemoteSsrc());
}
void VideoReceiveStream::SignalNetworkState(NetworkState state) {
rtp_rtcp_->SetRTCPStatus(state == kNetworkUp ? config_.rtp.rtcp_mode
: RtcpMode::kOff);
}
bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
return rtp_stream_receiver_.DeliverRtcp(packet, length);
}
bool VideoReceiveStream::DeliverRtp(const uint8_t* packet,
size_t length,
const PacketTime& packet_time) {
return rtp_stream_receiver_.DeliverRtp(packet, length, packet_time);
}
void VideoReceiveStream::Start() {
if (decode_thread_.IsRunning())
return;
@ -358,16 +374,6 @@ VideoReceiveStream::Stats VideoReceiveStream::GetStats() const {
return stats_proxy_.GetStats();
}
bool VideoReceiveStream::DeliverRtcp(const uint8_t* packet, size_t length) {
return rtp_stream_receiver_.DeliverRtcp(packet, length);
}
bool VideoReceiveStream::DeliverRtp(const uint8_t* packet,
size_t length,
const PacketTime& packet_time) {
return rtp_stream_receiver_.DeliverRtp(packet, length, packet_time);
}
void VideoReceiveStream::FrameCallback(VideoFrame* video_frame) {
stats_proxy_.OnDecodedFrame();
@ -421,11 +427,6 @@ int32_t VideoReceiveStream::Encoded(
return 0;
}
void VideoReceiveStream::SignalNetworkState(NetworkState state) {
rtp_rtcp_->SetRTCPStatus(state == kNetworkUp ? config_.rtp.rtcp_mode
: RtcpMode::kOff);
}
bool VideoReceiveStream::DecodeThreadFunction(void* ptr) {
static_cast<VideoReceiveStream*>(ptr)->Decode();
return true;

12
webrtc/video/video_receive_stream.h
View File

@ -54,16 +54,16 @@ class VideoReceiveStream : public webrtc::VideoReceiveStream,
VieRemb* remb);
~VideoReceiveStream() override;
// webrtc::ReceiveStream implementation.
void Start() override;
void Stop() override;
void SignalNetworkState(NetworkState state) override;
bool DeliverRtcp(const uint8_t* packet, size_t length) override;
void SignalNetworkState(NetworkState state);
bool DeliverRtcp(const uint8_t* packet, size_t length);
bool DeliverRtp(const uint8_t* packet,
size_t length,
const PacketTime& packet_time) override;
const PacketTime& packet_time);
// webrtc::VideoReceiveStream implementation.
void Start() override;
void Stop() override;
webrtc::VideoReceiveStream::Stats GetStats() const override;
// Overrides I420FrameCallback.

46
webrtc/video/video_send_stream.cc
View File

@ -491,8 +491,25 @@ VideoSendStream::~VideoSendStream() {
}
}
VideoCaptureInput* VideoSendStream::Input() {
return &input_;
void VideoSendStream::SignalNetworkState(NetworkState state) {
// When network goes up, enable RTCP status before setting transmission state.
// When it goes down, disable RTCP afterwards. This ensures that any packets
// sent due to the network state changed will not be dropped.
if (state == kNetworkUp) {
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
rtp_rtcp->SetRTCPStatus(config_.rtp.rtcp_mode);
}
vie_encoder_.SetNetworkTransmissionState(state == kNetworkUp);
if (state == kNetworkDown) {
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
rtp_rtcp->SetRTCPStatus(RtcpMode::kOff);
}
}
bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
rtp_rtcp->IncomingRtcpPacket(packet, length);
return true;
}
void VideoSendStream::Start() {
@ -514,6 +531,10 @@ void VideoSendStream::Stop() {
payload_router_.set_active(false);
}
VideoCaptureInput* VideoSendStream::Input() {
return &input_;
}
bool VideoSendStream::EncoderThreadFunction(void* obj) {
static_cast<VideoSendStream*>(obj)->EncoderProcess();
// We're done, return false to abort.
@ -580,12 +601,6 @@ void VideoSendStream::ReconfigureVideoEncoder(
encoder_wakeup_event_.Set();
}
bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
rtp_rtcp->IncomingRtcpPacket(packet, length);
return true;
}
VideoSendStream::Stats VideoSendStream::GetStats() {
return stats_proxy_.GetStats();
}
@ -714,21 +729,6 @@ std::map<uint32_t, RtpState> VideoSendStream::GetRtpStates() const {
return rtp_states;
}
void VideoSendStream::SignalNetworkState(NetworkState state) {
// When network goes up, enable RTCP status before setting transmission state.
// When it goes down, disable RTCP afterwards. This ensures that any packets
// sent due to the network state changed will not be dropped.
if (state == kNetworkUp) {
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
rtp_rtcp->SetRTCPStatus(config_.rtp.rtcp_mode);
}
vie_encoder_.SetNetworkTransmissionState(state == kNetworkUp);
if (state == kNetworkDown) {
for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
rtp_rtcp->SetRTCPStatus(RtcpMode::kOff);
}
}
int VideoSendStream::GetPaddingNeededBps() const {
return vie_encoder_.GetPaddingNeededBps();
}

9
webrtc/video/video_send_stream.h
View File

@ -63,13 +63,12 @@ class VideoSendStream : public webrtc::VideoSendStream,
~VideoSendStream() override;
// webrtc::SendStream implementation.
void Start() override;
void Stop() override;
void SignalNetworkState(NetworkState state) override;
bool DeliverRtcp(const uint8_t* packet, size_t length) override;
void SignalNetworkState(NetworkState state);
bool DeliverRtcp(const uint8_t* packet, size_t length);
// webrtc::VideoSendStream implementation.
void Start() override;
void Stop() override;
VideoCaptureInput* Input() override;
void ReconfigureVideoEncoder(const VideoEncoderConfig& config) override;
Stats GetStats() override;

13
webrtc/video_receive_stream.h
View File

@ -20,14 +20,13 @@
#include "webrtc/common_video/include/frame_callback.h"
#include "webrtc/config.h"
#include "webrtc/media/base/videosinkinterface.h"
#include "webrtc/stream.h"
#include "webrtc/transport.h"
namespace webrtc {
class VideoDecoder;
class VideoReceiveStream : public ReceiveStream {
class VideoReceiveStream {
public:
// TODO(mflodman) Move all these settings to VideoDecoder and move the
// declaration to common_types.h.
@ -176,8 +175,18 @@ class VideoReceiveStream : public ReceiveStream {
int target_delay_ms = 0;
};
// Starts stream activity.
// When a stream is active, it can receive, process and deliver packets.
virtual void Start() = 0;
// Stops stream activity.
// When a stream is stopped, it can't receive, process or deliver packets.
virtual void Stop() = 0;
// TODO(pbos): Add info on currently-received codec to Stats.
virtual Stats GetStats() const = 0;
protected:
virtual ~VideoReceiveStream() {}
};
} // namespace webrtc

13
webrtc/video_send_stream.h
View File

@ -18,7 +18,6 @@
#include "webrtc/common_video/include/frame_callback.h"
#include "webrtc/config.h"
#include "webrtc/media/base/videosinkinterface.h"
#include "webrtc/stream.h"
#include "webrtc/transport.h"
#include "webrtc/media/base/videosinkinterface.h"
@ -39,7 +38,7 @@ class VideoCaptureInput {
virtual ~VideoCaptureInput() {}
};
class VideoSendStream : public SendStream {
class VideoSendStream {
public:
struct StreamStats {
FrameCounts frame_counts;
@ -167,6 +166,13 @@ class VideoSendStream : public SendStream {
bool suspend_below_min_bitrate = false;
};
// Starts stream activity.
// When a stream is active, it can receive, process and deliver packets.
virtual void Start() = 0;
// Stops stream activity.
// When a stream is stopped, it can't receive, process or deliver packets.
virtual void Stop() = 0;
// Gets interface used to insert captured frames. Valid as long as the
// VideoSendStream is valid.
virtual VideoCaptureInput* Input() = 0;
@ -177,6 +183,9 @@ class VideoSendStream : public SendStream {
virtual void ReconfigureVideoEncoder(const VideoEncoderConfig& config) = 0;
virtual Stats GetStats() = 0;
protected:
virtual ~VideoSendStream() {}
};
} // namespace webrtc

1
webrtc/webrtc.gyp
View File

@ -126,7 +126,6 @@
'audio_state.h',
'call.h',
'config.h',
'stream.h',
'transport.h',
'video_receive_stream.h',
'video_send_stream.h',