Remove channel ids from various interfaces.

webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.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.
  */
 
 #include "webrtc/modules/rtp_rtcp/source/rtp_receiver_impl.h"
 
 #include <assert.h>
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h"
 #include "webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_receiver_strategy.h"
 #include "webrtc/system_wrappers/interface/logging.h"
 
 namespace webrtc {
 
 using RtpUtility::GetCurrentRTP;
 using RtpUtility::Payload;
 using RtpUtility::StringCompare;
 
 RtpReceiver* RtpReceiver::CreateVideoReceiver(
-    int id, Clock* clock,
+    Clock* clock,
     RtpData* incoming_payload_callback,
     RtpFeedback* incoming_messages_callback,
     RTPPayloadRegistry* rtp_payload_registry) {
   if (!incoming_payload_callback)
     incoming_payload_callback = NullObjectRtpData();
   if (!incoming_messages_callback)
     incoming_messages_callback = NullObjectRtpFeedback();
   return new RtpReceiverImpl(
-      id, clock, NullObjectRtpAudioFeedback(), incoming_messages_callback,
+      clock, NullObjectRtpAudioFeedback(), incoming_messages_callback,
       rtp_payload_registry,
       RTPReceiverStrategy::CreateVideoStrategy(incoming_payload_callback));
 }
 
 RtpReceiver* RtpReceiver::CreateAudioReceiver(
-    int id, Clock* clock,
+    Clock* clock,
     RtpAudioFeedback* incoming_audio_feedback,
     RtpData* incoming_payload_callback,
     RtpFeedback* incoming_messages_callback,
     RTPPayloadRegistry* rtp_payload_registry) {
   if (!incoming_audio_feedback)
     incoming_audio_feedback = NullObjectRtpAudioFeedback();
   if (!incoming_payload_callback)
     incoming_payload_callback = NullObjectRtpData();
   if (!incoming_messages_callback)
     incoming_messages_callback = NullObjectRtpFeedback();
   return new RtpReceiverImpl(
-      id, clock, incoming_audio_feedback, incoming_messages_callback,
+      clock, incoming_audio_feedback, incoming_messages_callback,
       rtp_payload_registry,
-      RTPReceiverStrategy::CreateAudioStrategy(id, incoming_payload_callback,
+      RTPReceiverStrategy::CreateAudioStrategy(incoming_payload_callback,
                                                incoming_audio_feedback));
 }
 
-RtpReceiverImpl::RtpReceiverImpl(int32_t id,
-                         Clock* clock,
-                         RtpAudioFeedback* incoming_audio_messages_callback,
-                         RtpFeedback* incoming_messages_callback,
-                         RTPPayloadRegistry* rtp_payload_registry,
-                         RTPReceiverStrategy* rtp_media_receiver)
+RtpReceiverImpl::RtpReceiverImpl(
+    Clock* clock,
+    RtpAudioFeedback* incoming_audio_messages_callback,
+    RtpFeedback* incoming_messages_callback,
+    RTPPayloadRegistry* rtp_payload_registry,
+    RTPReceiverStrategy* rtp_media_receiver)
     : clock_(clock),
       rtp_payload_registry_(rtp_payload_registry),
       rtp_media_receiver_(rtp_media_receiver),
-      id_(id),
       cb_rtp_feedback_(incoming_messages_callback),
       critical_section_rtp_receiver_(
-        CriticalSectionWrapper::CreateCriticalSection()),
+          CriticalSectionWrapper::CreateCriticalSection()),
       last_receive_time_(0),
       last_received_payload_length_(0),
       ssrc_(0),
       num_csrcs_(0),
       current_remote_csrc_(),
       last_received_timestamp_(0),
       last_received_frame_time_ms_(-1),
       last_received_sequence_number_(0),
       nack_method_(kNackOff) {
   assert(incoming_audio_messages_callback);
   assert(incoming_messages_callback);
 
   memset(current_remote_csrc_, 0, sizeof(current_remote_csrc_));
 }
 
 RtpReceiverImpl::~RtpReceiverImpl() {
   for (int i = 0; i < num_csrcs_; ++i) {
-    cb_rtp_feedback_->OnIncomingCSRCChanged(id_, current_remote_csrc_[i],
-                                            false);
+    cb_rtp_feedback_->OnIncomingCSRCChanged(current_remote_csrc_[i], false);
   }
 }
 
 int32_t RtpReceiverImpl::RegisterReceivePayload(
     const char payload_name[RTP_PAYLOAD_NAME_SIZE],
     const int8_t payload_type,
     const uint32_t frequency,
     const uint8_t channels,
     const uint32_t rate) {
   CriticalSectionScoped lock(critical_section_rtp_receiver_.get());
@@ skipping 187 matching lines @@
           }
         }
       }
       ssrc_ = rtp_header.ssrc;
     }
   }
 
   if (new_ssrc) {
     // We need to get this to our RTCP sender and receiver.
     // We need to do this outside critical section.
-    cb_rtp_feedback_->OnIncomingSSRCChanged(id_, rtp_header.ssrc);
+    cb_rtp_feedback_->OnIncomingSSRCChanged(rtp_header.ssrc);
   }
 
   if (re_initialize_decoder) {
-    if (-1 == cb_rtp_feedback_->OnInitializeDecoder(
-        id_, rtp_header.payloadType, payload_name,
-        rtp_header.payload_type_frequency, channels, rate)) {
+    if (-1 ==
+        cb_rtp_feedback_->OnInitializeDecoder(
+            rtp_header.payloadType, payload_name,
+            rtp_header.payload_type_frequency, channels, rate)) {
       // New stream, same codec.
       LOG(LS_ERROR) << "Failed to create decoder for payload type: "
                     << static_cast<int>(rtp_header.payloadType);
     }
   }
 }
 
 // Implementation note: must not hold critsect when called.
 // TODO(phoglund): Move as much as possible of this code path into the media
 // specific receivers. Basically this method goes through a lot of trouble to
@@ skipping 71 matching lines @@
           re_initialize_decoder = false;
         }
       }
     } else {
       rtp_media_receiver_->GetLastMediaSpecificPayload(specific_payload);
       is_red = false;
     }
   }  // End critsect.
 
   if (re_initialize_decoder) {
-    if (-1 == rtp_media_receiver_->InvokeOnInitializeDecoder(
-        cb_rtp_feedback_, id_, payload_type, payload_name,
-        *specific_payload)) {
+    if (-1 ==
+        rtp_media_receiver_->InvokeOnInitializeDecoder(
+            cb_rtp_feedback_, payload_type, payload_name, *specific_payload)) {
       return -1;  // Wrong payload type.
     }
   }
   return 0;
 }
 
 // Implementation note: must not hold critsect when called.
 void RtpReceiverImpl::CheckCSRC(const WebRtcRTPHeader& rtp_header) {
   int32_t num_csrcs_diff = 0;
   uint32_t old_remote_csrc[kRtpCsrcSize];
@@ skipping 36 matching lines @@
     bool found_match = false;
     for (uint8_t j = 0; j < old_num_csrcs; ++j) {
       if (csrc == old_remote_csrc[j]) {  // old list
         found_match = true;
         break;
       }
     }
     if (!found_match && csrc) {
       // Didn't find it, report it as new.
       have_called_callback = true;
-      cb_rtp_feedback_->OnIncomingCSRCChanged(id_, csrc, true);
+      cb_rtp_feedback_->OnIncomingCSRCChanged(csrc, true);
     }
   }
   // Search for old CSRC in new array.
   for (uint8_t i = 0; i < old_num_csrcs; ++i) {
     const uint32_t csrc = old_remote_csrc[i];
 
     bool found_match = false;
     for (uint8_t j = 0; j < rtp_header.header.numCSRCs; ++j) {
       if (csrc == rtp_header.header.arrOfCSRCs[j]) {
         found_match = true;
         break;
       }
     }
     if (!found_match && csrc) {
       // Did not find it, report as removed.
       have_called_callback = true;
-      cb_rtp_feedback_->OnIncomingCSRCChanged(id_, csrc, false);
+      cb_rtp_feedback_->OnIncomingCSRCChanged(csrc, false);
     }
   }
   if (!have_called_callback) {
     // If the CSRC list contain non-unique entries we will end up here.
     // Using CSRC 0 to signal this event, not interop safe, other
     // implementations might have CSRC 0 as a valid value.
     if (num_csrcs_diff > 0) {
-      cb_rtp_feedback_->OnIncomingCSRCChanged(id_, 0, true);
+      cb_rtp_feedback_->OnIncomingCSRCChanged(0, true);
     } else if (num_csrcs_diff < 0) {
-      cb_rtp_feedback_->OnIncomingCSRCChanged(id_, 0, false);
+      cb_rtp_feedback_->OnIncomingCSRCChanged(0, false);
     }
   }
 }
 
 }  // namespace webrtc