Use suffixed {uint,int}{8,16,32,64}_t types.

talk/media/webrtc/webrtcvoiceengine.cc

 /*
  * libjingle
  * Copyright 2004 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 846 matching lines @@
         new webrtc::ExperimentalNs(experimental_ns));
   }
 
   // We check audioproc for the benefit of tests, since FakeWebRtcVoiceEngine
   // returns NULL on audio_processing().
   webrtc::AudioProcessing* audioproc = voe_wrapper_->base()->audio_processing();
   if (audioproc) {
     audioproc->SetExtraOptions(config);
   }
 
-  uint32 recording_sample_rate;
+  uint32_t recording_sample_rate;
   if (options.recording_sample_rate.Get(&recording_sample_rate)) {
     LOG(LS_INFO) << "Recording sample rate is " << recording_sample_rate;
     if (voe_wrapper_->hw()->SetRecordingSampleRate(recording_sample_rate)) {
       LOG_RTCERR1(SetRecordingSampleRate, recording_sample_rate);
     }
   }
 
-  uint32 playout_sample_rate;
+  uint32_t playout_sample_rate;
   if (options.playout_sample_rate.Get(&playout_sample_rate)) {
     LOG(LS_INFO) << "Playout sample rate is " << playout_sample_rate;
     if (voe_wrapper_->hw()->SetPlayoutSampleRate(playout_sample_rate)) {
       LOG_RTCERR1(SetPlayoutSampleRate, playout_sample_rate);
     }
   }
 
   return true;
 }
 
@@ skipping 405 matching lines @@
     std::string msg(trace + 71, length - 72);
     if (!ShouldIgnoreTrace(msg)) {
       LOG_V(sev) << "webrtc: " << msg;
     }
   }
 }
 
 void WebRtcVoiceEngine::CallbackOnError(int channel_num, int err_code) {
   rtc::CritScope lock(&channels_cs_);
   WebRtcVoiceMediaChannel* channel = NULL;
-  uint32 ssrc = 0;
+  uint32_t ssrc = 0;
   LOG(LS_WARNING) << "VoiceEngine error " << err_code << " reported on channel "
                   << channel_num << ".";
   if (FindChannelAndSsrc(channel_num, &channel, &ssrc)) {
     RTC_DCHECK(channel != NULL);
     channel->OnError(ssrc, err_code);
   } else {
     LOG(LS_ERROR) << "VoiceEngine channel " << channel_num
                   << " could not be found in channel list when error reported.";
   }
 }
 
-bool WebRtcVoiceEngine::FindChannelAndSsrc(
-    int channel_num, WebRtcVoiceMediaChannel** channel, uint32* ssrc) const {
+bool WebRtcVoiceEngine::FindChannelAndSsrc(int channel_num,
+                                           WebRtcVoiceMediaChannel** channel,
+                                           uint32_t* ssrc) const {
   RTC_DCHECK(channel != NULL && ssrc != NULL);
 
   *channel = NULL;
   *ssrc = 0;
   // Find corresponding channel and ssrc
   for (WebRtcVoiceMediaChannel* ch : channels_) {
     RTC_DCHECK(ch != NULL);
     if (ch->FindSsrc(channel_num, ssrc)) {
       *channel = ch;
       return true;
     }
   }
 
   return false;
 }
 
 // This method will search through the WebRtcVoiceMediaChannels and
 // obtain the voice engine's channel number.
 bool WebRtcVoiceEngine::FindChannelNumFromSsrc(
-    uint32 ssrc, MediaProcessorDirection direction, int* channel_num) {
+    uint32_t ssrc,
+    MediaProcessorDirection direction,
+    int* channel_num) {
   RTC_DCHECK(channel_num != NULL);
   RTC_DCHECK(direction == MPD_RX || direction == MPD_TX);
 
   *channel_num = -1;
   // Find corresponding channel for ssrc.
   for (const WebRtcVoiceMediaChannel* ch : channels_) {
     RTC_DCHECK(ch != NULL);
     if (direction & MPD_RX) {
       *channel_num = ch->GetReceiveChannelNum(ssrc);
     }
@@ skipping 69 matching lines @@
   if (voe_wrapper_->processing()->StartDebugRecording(aec_dump_file_stream) !=
       webrtc::AudioProcessing::kNoError) {
     LOG_RTCERR0(StartDebugRecording);
     fclose(aec_dump_file_stream);
     return false;
   }
   is_dumping_aec_ = true;
   return true;
 }
 
-bool WebRtcVoiceEngine::RegisterProcessor(
-    uint32 ssrc,
-    VoiceProcessor* voice_processor,
-    MediaProcessorDirection direction) {
+bool WebRtcVoiceEngine::RegisterProcessor(uint32_t ssrc,
+                                          VoiceProcessor* voice_processor,
+                                          MediaProcessorDirection direction) {
   bool register_with_webrtc = false;
   int channel_id = -1;
   bool success = false;
-  uint32* processor_ssrc = NULL;
+  uint32_t* processor_ssrc = NULL;
   bool found_channel = FindChannelNumFromSsrc(ssrc, direction, &channel_id);
   if (voice_processor == NULL || !found_channel) {
     LOG(LS_WARNING) << "Media Processing Registration Failed. ssrc: " << ssrc
         << " foundChannel: " << found_channel;
     return false;
   }
 
   webrtc::ProcessingTypes processing_type;
   {
     rtc::CritScope cs(&signal_media_critical_);
@@ skipping 35 matching lines @@
   } else {
     // If we don't have to register with the engine, we just needed to
     // connect a new processor, set success to true;
     success = true;
   }
   return success;
 }
 
 bool WebRtcVoiceEngine::UnregisterProcessorChannel(
     MediaProcessorDirection channel_direction,
-    uint32 ssrc,
+    uint32_t ssrc,
     VoiceProcessor* voice_processor,
     MediaProcessorDirection processor_direction) {
   bool success = true;
   FrameSignal* signal;
   webrtc::ProcessingTypes processing_type;
-  uint32* processor_ssrc = NULL;
+  uint32_t* processor_ssrc = NULL;
   if (channel_direction == MPD_RX) {
     signal = &SignalRxMediaFrame;
     processing_type = webrtc::kPlaybackAllChannelsMixed;
     processor_ssrc = &rx_processor_ssrc_;
   } else {
     signal = &SignalTxMediaFrame;
     processing_type = webrtc::kRecordingPerChannel;
     processor_ssrc = &tx_processor_ssrc_;
   }
 
@@ skipping 21 matching lines @@
     } else {
       LOG_RTCERR2(DeRegisterExternalMediaProcessing,
                   deregister_id,
                   processing_type);
       success = false;
     }
   }
   return success;
 }
 
-bool WebRtcVoiceEngine::UnregisterProcessor(
-    uint32 ssrc,
-    VoiceProcessor* voice_processor,
-    MediaProcessorDirection direction) {
+bool WebRtcVoiceEngine::UnregisterProcessor(uint32_t ssrc,
+                                            VoiceProcessor* voice_processor,
+                                            MediaProcessorDirection direction) {
   bool success = true;
   if (voice_processor == NULL) {
     LOG(LS_WARNING) << "Media Processing Deregistration Failed. ssrc: "
                     << ssrc;
     return false;
   }
   if (!UnregisterProcessorChannel(MPD_RX, ssrc, voice_processor, direction)) {
     success = false;
   }
   if (!UnregisterProcessorChannel(MPD_TX, ssrc, voice_processor, direction)) {
@@ skipping 819 matching lines @@
     RTC_DCHECK(send == SEND_NOTHING);
     if (engine()->voe()->base()->StopSend(channel) == -1) {
       LOG_RTCERR1(StopSend, channel);
       return false;
     }
   }
 
   return true;
 }
 
-bool WebRtcVoiceMediaChannel::SetAudioSend(uint32 ssrc, bool mute,
+bool WebRtcVoiceMediaChannel::SetAudioSend(uint32_t ssrc,
+                                           bool mute,
                                            const AudioOptions* options,
                                            AudioRenderer* renderer) {
   // TODO(solenberg): The state change should be fully rolled back if any one of
   //                  these calls fail.
   if (!SetLocalRenderer(ssrc, renderer)) {
     return false;
   }
   if (!MuteStream(ssrc, mute)) {
     return false;
   }
@@ skipping 101 matching lines @@
     return false;
   }
 
   // Set the current codecs to be used for the new channel.
   if (!send_codecs_.empty() && !SetSendCodecs(channel, send_codecs_))
     return false;
 
   return ChangeSend(channel, desired_send_);
 }
 
-bool WebRtcVoiceMediaChannel::RemoveSendStream(uint32 ssrc) {
+bool WebRtcVoiceMediaChannel::RemoveSendStream(uint32_t ssrc) {
   ChannelMap::iterator it = send_channels_.find(ssrc);
   if (it == send_channels_.end()) {
     LOG(LS_WARNING) << "Try to remove stream with ssrc " << ssrc
                     << " which doesn't exist.";
     return false;
   }
 
   int channel = it->second->channel();
   ChangeSend(channel, SEND_NOTHING);
 
@@ skipping 19 matching lines @@
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::AddRecvStream(const StreamParams& sp) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   rtc::CritScope lock(&receive_channels_cs_);
 
   if (!VERIFY(sp.ssrcs.size() == 1))
     return false;
-  uint32 ssrc = sp.first_ssrc();
+  uint32_t ssrc = sp.first_ssrc();
 
   if (ssrc == 0) {
     LOG(LS_WARNING) << "AddRecvStream with 0 ssrc is not supported.";
     return false;
   }
 
   if (receive_channels_.find(ssrc) != receive_channels_.end()) {
     LOG(LS_ERROR) << "Stream already exists with ssrc " << ssrc;
     return false;
   }
@@ skipping 103 matching lines @@
   SetNack(channel, nack_enabled_);
 
   // Set RTP header extension for the new channel.
   if (!SetChannelRecvRtpHeaderExtensions(channel, receive_extensions_)) {
     return false;
   }
 
   return SetPlayout(channel, playout_);
 }
 
-bool WebRtcVoiceMediaChannel::RemoveRecvStream(uint32 ssrc) {
+bool WebRtcVoiceMediaChannel::RemoveRecvStream(uint32_t ssrc) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   rtc::CritScope lock(&receive_channels_cs_);
   ChannelMap::iterator it = receive_channels_.find(ssrc);
   if (it == receive_channels_.end()) {
     LOG(LS_WARNING) << "Try to remove stream with ssrc " << ssrc
                     << " which doesn't exist.";
     return false;
   }
 
   RemoveAudioReceiveStream(ssrc);
@@ skipping 37 matching lines @@
     enable_default_channel_playout = true;
   }
   if (enable_default_channel_playout && playout_) {
     LOG(LS_INFO) << "Enabling playback on the default voice channel";
     SetPlayout(voe_channel(), true);
   }
 
   return true;
 }
 
-bool WebRtcVoiceMediaChannel::SetRemoteRenderer(uint32 ssrc,
+bool WebRtcVoiceMediaChannel::SetRemoteRenderer(uint32_t ssrc,
                                                 AudioRenderer* renderer) {
   ChannelMap::iterator it = receive_channels_.find(ssrc);
   if (it == receive_channels_.end()) {
     if (renderer) {
       // Return an error if trying to set a valid renderer with an invalid ssrc.
       LOG(LS_ERROR) << "SetRemoteRenderer failed with ssrc "<< ssrc;
       return false;
     }
 
     // The channel likely has gone away, do nothing.
     return true;
   }
 
   if (renderer)
     it->second->Start(renderer);
   else
     it->second->Stop();
 
   return true;
 }
 
-bool WebRtcVoiceMediaChannel::SetLocalRenderer(uint32 ssrc,
+bool WebRtcVoiceMediaChannel::SetLocalRenderer(uint32_t ssrc,
                                                AudioRenderer* renderer) {
   ChannelMap::iterator it = send_channels_.find(ssrc);
   if (it == send_channels_.end()) {
     if (renderer) {
       // Return an error if trying to set a valid renderer with an invalid ssrc.
       LOG(LS_ERROR) << "SetLocalRenderer failed with ssrc "<< ssrc;
       return false;
     }
 
     // The channel likely has gone away, do nothing.
@@ skipping 50 matching lines @@
   if (engine()->voe()->processing()->SetTypingDetectionParameters(
           time_window, cost_per_typing,
           reporting_threshold, penalty_decay, type_event_delay) == -1) {
     // In case of error, log the info and continue
     LOG_RTCERR5(SetTypingDetectionParameters, time_window,
                 cost_per_typing, reporting_threshold, penalty_decay,
                 type_event_delay);
   }
 }
 
-bool WebRtcVoiceMediaChannel::SetOutputScaling(
-    uint32 ssrc, double left, double right) {
+bool WebRtcVoiceMediaChannel::SetOutputScaling(uint32_t ssrc,
+                                               double left,
+                                               double right) {
   rtc::CritScope lock(&receive_channels_cs_);
   // Collect the channels to scale the output volume.
   std::vector<int> channels;
   if (0 == ssrc) {  // Collect all channels, including the default one.
     // Default channel is not in receive_channels_ if it is not being used for
     // playout.
     if (default_receive_ssrc_ == 0)
       channels.push_back(voe_channel());
     for (const auto& ch : receive_channels_) {
       channels.push_back(ch.second->channel());
@@ skipping 31 matching lines @@
                  << " for channel " << ch_id << " and ssrc " << ssrc;
   }
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::SetRingbackTone(const char *buf, int len) {
   ringback_tone_.reset(new WebRtcSoundclipStream(buf, len));
   return true;
 }
 
-bool WebRtcVoiceMediaChannel::PlayRingbackTone(uint32 ssrc,
-                                             bool play, bool loop) {
+bool WebRtcVoiceMediaChannel::PlayRingbackTone(uint32_t ssrc,
+                                               bool play,
+                                               bool loop) {
   if (!ringback_tone_) {
     return false;
   }
 
   // The voe file api is not available in chrome.
   if (!engine()->voe()->file()) {
     return false;
   }
 
   // Determine which VoiceEngine channel to play on.
@@ skipping 24 matching lines @@
     ringback_channels_.erase(channel);
   }
 
   return true;
 }
 
 bool WebRtcVoiceMediaChannel::CanInsertDtmf() {
   return dtmf_allowed_;
 }
 
-bool WebRtcVoiceMediaChannel::InsertDtmf(uint32 ssrc, int event,
-                                         int duration, int flags) {
+bool WebRtcVoiceMediaChannel::InsertDtmf(uint32_t ssrc,
+                                         int event,
+                                         int duration,
+                                         int flags) {
   if (!dtmf_allowed_) {
     return false;
   }
 
   // Send the event.
   if (flags & cricket::DF_SEND) {
     int channel = -1;
     if (ssrc == 0) {
       bool default_channel_is_inuse = false;
       for (const auto& ch : send_channels_) {
@@ skipping 119 matching lines @@
     // Make sure not sending the same packet to default channel more than once.
     if (IsDefaultChannel(ch.second->channel()) &&
         has_sent_to_default_channel)
       continue;
 
     engine()->voe()->network()->ReceivedRTCPPacket(
         ch.second->channel(), packet->data(), packet->size());
   }
 }
 
-bool WebRtcVoiceMediaChannel::MuteStream(uint32 ssrc, bool muted) {
+bool WebRtcVoiceMediaChannel::MuteStream(uint32_t ssrc, bool muted) {
   int channel = (ssrc == 0) ? voe_channel() : GetSendChannelNum(ssrc);
   if (channel == -1) {
     LOG(LS_WARNING) << "The specified ssrc " << ssrc << " is not in use.";
     return false;
   }
   if (engine()->voe()->volume()->SetInputMute(channel, muted) == -1) {
     LOG_RTCERR2(SetInputMute, channel, muted);
     return false;
   }
   // We set the AGC to mute state only when all the channels are muted.
@@ skipping 251 matching lines @@
       rinfo.audio_level = (engine()->voe()->volume()->
           GetSpeechOutputLevelFullRange(ch_id, level) != -1) ? level : -1;
       info->receivers.push_back(rinfo);
     }
   }
 
   return true;
 }
 
 void WebRtcVoiceMediaChannel::GetLastMediaError(
-    uint32* ssrc, VoiceMediaChannel::Error* error) {
+    uint32_t* ssrc,
+    VoiceMediaChannel::Error* error) {
   RTC_DCHECK(ssrc != NULL);
   RTC_DCHECK(error != NULL);
   FindSsrc(voe_channel(), ssrc);
   *error = WebRtcErrorToChannelError(GetLastEngineError());
 }
 
-bool WebRtcVoiceMediaChannel::FindSsrc(int channel_num, uint32* ssrc) {
+bool WebRtcVoiceMediaChannel::FindSsrc(int channel_num, uint32_t* ssrc) {
   rtc::CritScope lock(&receive_channels_cs_);
   RTC_DCHECK(ssrc != NULL);
   if (channel_num == -1 && send_ != SEND_NOTHING) {
     // Sometimes the VoiceEngine core will throw error with channel_num = -1.
     // This means the error is not limited to a specific channel.  Signal the
     // message using ssrc=0.  If the current channel is sending, use this
     // channel for sending the message.
     *ssrc = 0;
     return true;
   } else {
     // Check whether this is a sending channel.
     for (const auto& ch : send_channels_) {
       if (ch.second->channel() == channel_num) {
         // This is a sending channel.
-        uint32 local_ssrc = 0;
+        uint32_t local_ssrc = 0;
         if (engine()->voe()->rtp()->GetLocalSSRC(
                 channel_num, local_ssrc) != -1) {
           *ssrc = local_ssrc;
         }
         return true;
       }
     }
 
     // Check whether this is a receiving channel.
     for (const auto& ch : receive_channels_) {
       if (ch.second->channel() == channel_num) {
         *ssrc = ch.first;
         return true;
       }
     }
   }
   return false;
 }
 
-void WebRtcVoiceMediaChannel::OnError(uint32 ssrc, int error) {
+void WebRtcVoiceMediaChannel::OnError(uint32_t ssrc, int error) {
   if (error == VE_TYPING_NOISE_WARNING) {
     typing_noise_detected_ = true;
   } else if (error == VE_TYPING_NOISE_OFF_WARNING) {
     typing_noise_detected_ = false;
   }
   SignalMediaError(ssrc, WebRtcErrorToChannelError(error));
 }
 
 int WebRtcVoiceMediaChannel::GetOutputLevel(int channel) {
   unsigned int ulevel;
   int ret =
       engine()->voe()->volume()->GetSpeechOutputLevel(channel, ulevel);
   return (ret == 0) ? static_cast<int>(ulevel) : -1;
 }
 
-int WebRtcVoiceMediaChannel::GetReceiveChannelNum(uint32 ssrc) const {
+int WebRtcVoiceMediaChannel::GetReceiveChannelNum(uint32_t ssrc) const {
   ChannelMap::const_iterator it = receive_channels_.find(ssrc);
   if (it != receive_channels_.end())
     return it->second->channel();
   return (ssrc == default_receive_ssrc_) ? voe_channel() : -1;
 }
 
-int WebRtcVoiceMediaChannel::GetSendChannelNum(uint32 ssrc) const {
+int WebRtcVoiceMediaChannel::GetSendChannelNum(uint32_t ssrc) const {
   ChannelMap::const_iterator it = send_channels_.find(ssrc);
   if (it != send_channels_.end())
     return it->second->channel();
 
   return -1;
 }
 
 bool WebRtcVoiceMediaChannel::GetRedSendCodec(const AudioCodec& red_codec,
     const std::vector<AudioCodec>& all_codecs, webrtc::CodecInst* send_codec) {
   // Get the RED encodings from the parameter with no name. This may
@@ skipping 73 matching lines @@
       LOG_RTCERR1(StartPlayout, channel);
       return false;
     }
   } else {
     LOG(LS_INFO) << "Stopping playout for channel #" << channel;
     engine()->voe()->base()->StopPlayout(channel);
   }
   return true;
 }
 
-uint32 WebRtcVoiceMediaChannel::ParseSsrc(const void* data, size_t len,
-                                        bool rtcp) {
+uint32_t WebRtcVoiceMediaChannel::ParseSsrc(const void* data,
+                                            size_t len,
+                                            bool rtcp) {
   size_t ssrc_pos = (!rtcp) ? 8 : 4;
-  uint32 ssrc = 0;
+  uint32_t ssrc = 0;
   if (len >= (ssrc_pos + sizeof(ssrc))) {
     ssrc = rtc::GetBE32(static_cast<const char*>(data) + ssrc_pos);
   }
   return ssrc;
 }
 
 // Convert VoiceEngine error code into VoiceMediaChannel::Error enum.
 VoiceMediaChannel::Error
     WebRtcVoiceMediaChannel::WebRtcErrorToChannelError(int err_code) {
   switch (err_code) {
@@ skipping 46 matching lines @@
 void WebRtcVoiceMediaChannel::RecreateAudioReceiveStreams() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   for (const auto& it : receive_channels_) {
     RemoveAudioReceiveStream(it.first);
   }
   for (const auto& it : receive_channels_) {
     AddAudioReceiveStream(it.first);
   }
 }
 
-void WebRtcVoiceMediaChannel::AddAudioReceiveStream(uint32 ssrc) {
+void WebRtcVoiceMediaChannel::AddAudioReceiveStream(uint32_t ssrc) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   WebRtcVoiceChannelRenderer* channel = receive_channels_[ssrc];
   RTC_DCHECK(channel != nullptr);
   RTC_DCHECK(receive_streams_.find(ssrc) == receive_streams_.end());
   webrtc::AudioReceiveStream::Config config;
   config.rtp.remote_ssrc = ssrc;
   // Only add RTP extensions if we support combined A/V BWE.
   config.rtp.extensions = recv_rtp_extensions_;
   config.combined_audio_video_bwe =
       options_.combined_audio_video_bwe.GetWithDefaultIfUnset(false);
   config.voe_channel_id = channel->channel();
   config.sync_group = receive_stream_params_[ssrc].sync_label;
   webrtc::AudioReceiveStream* s = call_->CreateAudioReceiveStream(config);
   receive_streams_.insert(std::make_pair(ssrc, s));
 }
 
-void WebRtcVoiceMediaChannel::RemoveAudioReceiveStream(uint32 ssrc) {
+void WebRtcVoiceMediaChannel::RemoveAudioReceiveStream(uint32_t ssrc) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   auto stream_it = receive_streams_.find(ssrc);
   if (stream_it != receive_streams_.end()) {
     call_->DestroyAudioReceiveStream(stream_it->second);
     receive_streams_.erase(stream_it);
   }
 }
 
 bool WebRtcVoiceMediaChannel::SetRecvCodecsInternal(
     const std::vector<AudioCodec>& new_codecs) {
@@ skipping 41 matching lines @@
 
 int WebRtcSoundclipStream::Rewind() {
   mem_.Rewind();
   // Return -1 to keep VoiceEngine from looping.
   return (loop_) ? 0 : -1;
 }
 
 }  // namespace cricket
 
 #endif  // HAVE_WEBRTC_VOICE