1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
/*
* Copyright (c) 2012 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_VIDEO_ENGINE_VIE_CHANNEL_MANAGER_H_
#define WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_MANAGER_H_
#include <list>
#include <map>
#include "engine_configurations.h" // NOLINT
#include "system_wrappers/interface/scoped_ptr.h"
#include "typedefs.h" // NOLINT
#include "video_engine/include/vie_rtp_rtcp.h"
#include "video_engine/vie_channel_group.h"
#include "video_engine/vie_defines.h"
#include "video_engine/vie_manager_base.h"
#include "video_engine/vie_remb.h"
namespace webrtc {
class CriticalSectionWrapper;
class MapWrapper;
class ProcessThread;
class RtcpRttObserver;
class ViEChannel;
class ViEEncoder;
class VoEVideoSync;
class VoiceEngine;
typedef std::list<ChannelGroup*> ChannelGroups;
typedef std::list<ViEChannel*> ChannelList;
typedef std::map<int, ViEChannel*> ChannelMap;
typedef std::map<int, ViEEncoder*> EncoderMap;
class ViEChannelManager: private ViEManagerBase {
friend class ViEChannelManagerScoped;
public:
ViEChannelManager(int engine_id,
int number_of_cores,
const OverUseDetectorOptions& options);
~ViEChannelManager();
void SetModuleProcessThread(ProcessThread* module_process_thread);
// Creates a new channel. 'channel_id' will be the id of the created channel.
int CreateChannel(int* channel_id);
// Creates a new channel grouped with |original_channel|. The new channel
// will get its own |ViEEncoder| if |sender| is set to true. It will be a
// receive only channel, without an own |ViEEncoder| if |sender| is false.
int CreateChannel(int* channel_id, int original_channel, bool sender);
// Deletes a channel.
int DeleteChannel(int channel_id);
// Set the voice engine instance to be used by all video channels.
int SetVoiceEngine(VoiceEngine* voice_engine);
// Enables lip sync of the channel.
int ConnectVoiceChannel(int channel_id, int audio_channel_id);
// Disables lip sync of the channel.
int DisconnectVoiceChannel(int channel_id);
VoiceEngine* GetVoiceEngine();
// Adds a channel to include when sending REMB.
bool SetRembStatus(int channel_id, bool sender, bool receiver);
// Sets the bandwidth estimation mode. This can only be changed before
// adding a channel.
bool SetBandwidthEstimationMode(BandwidthEstimationMode mode);
// Updates the SSRCs for a channel. If one of the SSRCs already is registered,
// it will simply be ignored and no error is returned.
void UpdateSsrcs(int channel_id, const std::list<unsigned int>& ssrcs);
private:
// Creates a channel object connected to |vie_encoder|. Assumed to be called
// protected.
bool CreateChannelObject(int channel_id,
ViEEncoder* vie_encoder,
RtcpBandwidthObserver* bandwidth_observer,
RemoteBitrateEstimator* remote_bitrate_estimator,
RtcpRttObserver* rtcp_rtt_observer,
RtcpIntraFrameObserver* intra_frame_observer,
bool sender);
// Used by ViEChannelScoped, forcing a manager user to use scoped.
// Returns a pointer to the channel with id 'channel_id'.
ViEChannel* ViEChannelPtr(int channel_id) const;
// Methods used by ViECaptureScoped and ViEEncoderScoped.
// Gets the ViEEncoder used as input for video_channel_id
ViEEncoder* ViEEncoderPtr(int video_channel_id) const;
// Returns a free channel id, -1 if failing.
int FreeChannelId();
// Returns a previously allocated channel id.
void ReturnChannelId(int channel_id);
// Returns the iterator to the ChannelGroup containing |channel_id|.
ChannelGroup* FindGroup(int channel_id);
// Returns true if at least one other channels uses the same ViEEncoder as
// channel_id.
bool ChannelUsingViEEncoder(int channel_id) const;
void ChannelsUsingViEEncoder(int channel_id, ChannelList* channels) const;
// Protects channel_map_ and free_channel_ids_.
CriticalSectionWrapper* channel_id_critsect_;
int engine_id_;
int number_of_cores_;
// TODO(mflodman) Make part of channel group.
ChannelMap channel_map_;
bool* free_channel_ids_;
int free_channel_ids_size_;
// List with all channel groups.
std::list<ChannelGroup*> channel_groups_;
// TODO(mflodman) Make part of channel group.
// Maps Channel id -> ViEEncoder.
EncoderMap vie_encoder_map_;
VoEVideoSync* voice_sync_interface_;
VoiceEngine* voice_engine_;
ProcessThread* module_process_thread_;
const OverUseDetectorOptions& over_use_detector_options_;
RemoteBitrateEstimator::EstimationMode bwe_mode_;
};
class ViEChannelManagerScoped: private ViEManagerScopedBase {
public:
explicit ViEChannelManagerScoped(
const ViEChannelManager& vie_channel_manager);
ViEChannel* Channel(int vie_channel_id) const;
ViEEncoder* Encoder(int vie_channel_id) const;
// Returns true if at least one other channels uses the same ViEEncoder as
// channel_id.
bool ChannelUsingViEEncoder(int channel_id) const;
// Returns a list with pointers to all channels using the same encoder as the
// channel with |channel_id|, including the one with the specified id.
void ChannelsUsingViEEncoder(int channel_id, ChannelList* channels) const;
};
} // namespace webrtc
#endif // WEBRTC_VIDEO_ENGINE_VIE_CHANNEL_MANAGER_H_
|
