Remove channel ids from various interfaces.

webrtc/voice_engine/channel.cc

 /*
  *  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.
  */
 
@@ skipping 199 matching lines @@
     CriticalSectionScoped cs(&_callbackCritSect);
     if (_rxVadObserverPtr)
     {
         _rxVadObserverPtr->OnRxVad(_channelId, vadDecision);
     }
 
     return 0;
 }
 
 int
-Channel::SendPacket(int channel, const void *data, size_t len)
+Channel::SendPacket(const void *data, size_t len)
 {
-    channel = VoEChannelId(channel);
-    assert(channel == _channelId);
-
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::SendPacket(channel=%d, len=%" PRIuS ")", channel,
-                 len);
+                 "Channel::SendPacket(channel=%d, len=%" PRIuS ")", len);
 
     CriticalSectionScoped cs(&_callbackCritSect);
 
     if (_transportPtr == NULL)
     {
         WEBRTC_TRACE(kTraceError, kTraceVoice, VoEId(_instanceId,_channelId),
                      "Channel::SendPacket() failed to send RTP packet due to"
                      " invalid transport object");
         return -1;
     }
 
     uint8_t* bufferToSendPtr = (uint8_t*)data;
     size_t bufferLength = len;
 
-    int n = _transportPtr->SendPacket(channel, bufferToSendPtr,
-                                      bufferLength);
+    int n = _transportPtr->SendPacket(bufferToSendPtr, bufferLength);
     if (n < 0) {
       std::string transport_name =
           _externalTransport ? "external transport" : "WebRtc sockets";
       WEBRTC_TRACE(kTraceError, kTraceVoice,
                    VoEId(_instanceId,_channelId),
                    "Channel::SendPacket() RTP transmission using %s failed",
                    transport_name.c_str());
       return -1;
     }
     return n;
 }
 
 int
-Channel::SendRTCPPacket(int channel, const void *data, size_t len)
+Channel::SendRTCPPacket(const void *data, size_t len)
 {
-    channel = VoEChannelId(channel);
-    assert(channel == _channelId);
-
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::SendRTCPPacket(channel=%d, len=%" PRIuS ")", channel,
-                 len);
+                 "Channel::SendRTCPPacket(len=%" PRIuS ")", len);
 
     CriticalSectionScoped cs(&_callbackCritSect);
     if (_transportPtr == NULL)
     {
         WEBRTC_TRACE(kTraceError, kTraceVoice,
                      VoEId(_instanceId,_channelId),
                      "Channel::SendRTCPPacket() failed to send RTCP packet"
                      " due to invalid transport object");
         return -1;
     }
 
     uint8_t* bufferToSendPtr = (uint8_t*)data;
     size_t bufferLength = len;
 
-    int n = _transportPtr->SendRTCPPacket(channel,
-                                          bufferToSendPtr,
-                                          bufferLength);
+    int n = _transportPtr->SendRTCPPacket(bufferToSendPtr, bufferLength);
     if (n < 0) {
       std::string transport_name =
           _externalTransport ? "external transport" : "WebRtc sockets";
       WEBRTC_TRACE(kTraceInfo, kTraceVoice,
                    VoEId(_instanceId,_channelId),
                    "Channel::SendRTCPPacket() transmission using %s failed",
                    transport_name.c_str());
       return -1;
     }
     return n;
 }
 
-void
-Channel::OnPlayTelephoneEvent(int32_t id,
-                              uint8_t event,
-                              uint16_t lengthMs,
-                              uint8_t volume)
-{
+void Channel::OnPlayTelephoneEvent(uint8_t event,
+                                   uint16_t lengthMs,
+                                   uint8_t volume) {
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::OnPlayTelephoneEvent(id=%d, event=%u, lengthMs=%u,"
-                 " volume=%u)", id, event, lengthMs, volume);
+                 "Channel::OnPlayTelephoneEvent(event=%u, lengthMs=%u,"
+                 " volume=%u)", event, lengthMs, volume);
 
     if (!_playOutbandDtmfEvent || (event > 15))
     {
         // Ignore callback since feedback is disabled or event is not a
         // Dtmf tone event.
         return;
     }
 
     assert(_outputMixerPtr != NULL);
 
     // Start playing out the Dtmf tone (if playout is enabled).
     // Reduce length of tone with 80ms to the reduce risk of echo.
     _outputMixerPtr->PlayDtmfTone(event, lengthMs - 80, volume);
 }
 
 void
-Channel::OnIncomingSSRCChanged(int32_t id, uint32_t ssrc)
+Channel::OnIncomingSSRCChanged(uint32_t ssrc)
 {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::OnIncomingSSRCChanged(id=%d, SSRC=%d)",
-                 id, ssrc);
+                 "Channel::OnIncomingSSRCChanged(SSRC=%d)", ssrc);
 
     // Update ssrc so that NTP for AV sync can be updated.
     _rtpRtcpModule->SetRemoteSSRC(ssrc);
 }
 
-void Channel::OnIncomingCSRCChanged(int32_t id,
-                                    uint32_t CSRC,
-                                    bool added)
-{
-    WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::OnIncomingCSRCChanged(id=%d, CSRC=%d, added=%d)",
-                 id, CSRC, added);
+void Channel::OnIncomingCSRCChanged(uint32_t CSRC, bool added) {
+  WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
+               "Channel::OnIncomingCSRCChanged(CSRC=%d, added=%d)", CSRC,
+               added);
 }
 
-int32_t
-Channel::OnInitializeDecoder(
-    int32_t id,
+int32_t Channel::OnInitializeDecoder(
     int8_t payloadType,
     const char payloadName[RTP_PAYLOAD_NAME_SIZE],
     int frequency,
     uint8_t channels,
-    uint32_t rate)
-{
+    uint32_t rate) {
     WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId,_channelId),
-                 "Channel::OnInitializeDecoder(id=%d, payloadType=%d, "
+                 "Channel::OnInitializeDecoder(payloadType=%d, "
                  "payloadName=%s, frequency=%u, channels=%u, rate=%u)",
-                 id, payloadType, payloadName, frequency, channels, rate);
-
-    assert(VoEChannelId(id) == _channelId);
+                 payloadType, payloadName, frequency, channels, rate);
 
     CodecInst receiveCodec = {0};
     CodecInst dummyCodec = {0};
 
     receiveCodec.pltype = payloadType;
     receiveCodec.plfreq = frequency;
     receiveCodec.channels = channels;
     receiveCodec.rate = rate;
     strncpy(receiveCodec.plname, payloadName, RTP_PAYLOAD_NAME_SIZE - 1);
 
@@ skipping 355 matching lines @@
     _callbackCritSect(*CriticalSectionWrapper::CreateCriticalSection()),
     volume_settings_critsect_(*CriticalSectionWrapper::CreateCriticalSection()),
     _instanceId(instanceId),
     _channelId(channelId),
     rtp_header_parser_(RtpHeaderParser::Create()),
     rtp_payload_registry_(
         new RTPPayloadRegistry(RTPPayloadStrategy::CreateStrategy(true))),
     rtp_receive_statistics_(
         ReceiveStatistics::Create(Clock::GetRealTimeClock())),
     rtp_receiver_(
-        RtpReceiver::CreateAudioReceiver(VoEModuleId(instanceId, channelId),
-                                         Clock::GetRealTimeClock(),
+        RtpReceiver::CreateAudioReceiver(Clock::GetRealTimeClock(),
                                          this,
                                          this,
                                          this,
                                          rtp_payload_registry_.get())),
     telephone_event_handler_(rtp_receiver_->GetTelephoneEventHandler()),
     _outputAudioLevel(),
     _externalTransport(false),
     _inputFilePlayerPtr(NULL),
     _outputFilePlayerPtr(NULL),
     _outputFileRecorderPtr(NULL),
@@ skipping 70 matching lines @@
     acm_config.neteq_config.enable_fast_accelerate =
         config.Get<NetEqFastAccelerate>().enabled;
     acm_config.event_log = event_log;
     audio_coding_.reset(AudioCodingModule::Create(acm_config));
 
     _inbandDtmfQueue.ResetDtmf();
     _inbandDtmfGenerator.Init();
     _outputAudioLevel.Clear();
 
     RtpRtcp::Configuration configuration;
-    configuration.id = VoEModuleId(instanceId, channelId);
     configuration.audio = true;
     configuration.outgoing_transport = this;
     configuration.audio_messages = this;
     configuration.receive_statistics = rtp_receive_statistics_.get();
     configuration.bandwidth_callback = rtcp_observer_.get();
 
     _rtpRtcpModule.reset(RtpRtcp::CreateRtpRtcp(configuration));
 
     statistics_proxy_.reset(new StatisticsProxy(_rtpRtcpModule->SSRC()));
     rtp_receive_statistics_->RegisterRtcpStatisticsCallback(
@@ skipping 3052 matching lines @@
 int32_t
 Channel::SendPacketRaw(const void *data, size_t len, bool RTCP)
 {
     CriticalSectionScoped cs(&_callbackCritSect);
     if (_transportPtr == NULL)
     {
         return -1;
     }
     if (!RTCP)
     {
-        return _transportPtr->SendPacket(_channelId, data, len);
+        return _transportPtr->SendPacket(data, len);
     }
     else
     {
-        return _transportPtr->SendRTCPPacket(_channelId, data, len);
+        return _transportPtr->SendRTCPPacket(data, len);
     }
 }
 
 void Channel::UpdatePlayoutTimestamp(bool rtcp) {
   uint32_t playout_timestamp = 0;
 
   if (audio_coding_->PlayoutTimestamp(&playout_timestamp) == -1)  {
     // This can happen if this channel has not been received any RTP packet. In
     // this case, NetEq is not capable of computing playout timestamp.
     return;
@@ skipping 240 matching lines @@
   int64_t min_rtt = 0;
   if (_rtpRtcpModule->RTT(remoteSSRC, &rtt, &avg_rtt, &min_rtt, &max_rtt)
       != 0) {
     return 0;
   }
   return rtt;
 }
 
 }  // namespace voe
 }  // namespace webrtc