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

talk/session/media/channel.h

 /*
  * 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 109 matching lines @@
                        ContentAction action,
                        std::string* error_desc);
   bool SetRemoteContent(const MediaContentDescription* content,
                         ContentAction action,
                         std::string* error_desc);
 
   bool Enable(bool enable);
 
   // Multiplexing
   bool AddRecvStream(const StreamParams& sp);
-  bool RemoveRecvStream(uint32 ssrc);
+  bool RemoveRecvStream(uint32_t ssrc);
   bool AddSendStream(const StreamParams& sp);
-  bool RemoveSendStream(uint32 ssrc);
+  bool RemoveSendStream(uint32_t ssrc);
 
   // Monitoring
   void StartConnectionMonitor(int cms);
   void StopConnectionMonitor();
   // For ConnectionStatsGetter, used by ConnectionMonitor
   virtual bool GetConnectionStats(ConnectionInfos* infos) override;
 
-  void set_srtp_signal_silent_time(uint32 silent_time) {
+  void set_srtp_signal_silent_time(uint32_t silent_time) {
     srtp_filter_.set_signal_silent_time(silent_time);
   }
 
   BundleFilter* bundle_filter() { return &bundle_filter_; }
 
   const std::vector<StreamParams>& local_streams() const {
     return local_streams_;
   }
   const std::vector<StreamParams>& remote_streams() const {
     return remote_streams_;
@@ skipping 68 matching lines @@
 
   // Apply the new local/remote session description.
   void OnNewLocalDescription(BaseSession* session, ContentAction action);
   void OnNewRemoteDescription(BaseSession* session, ContentAction action);
 
   void EnableMedia_w();
   void DisableMedia_w();
   void ChannelWritable_w();
   void ChannelNotWritable_w();
   bool AddRecvStream_w(const StreamParams& sp);
-  bool RemoveRecvStream_w(uint32 ssrc);
+  bool RemoveRecvStream_w(uint32_t ssrc);
   bool AddSendStream_w(const StreamParams& sp);
-  bool RemoveSendStream_w(uint32 ssrc);
+  bool RemoveSendStream_w(uint32_t ssrc);
   virtual bool ShouldSetupDtlsSrtp() const;
   // Do the DTLS key expansion and impose it on the SRTP/SRTCP filters.
   // |rtcp_channel| indicates whether to set up the RTP or RTCP filter.
   bool SetupDtlsSrtp(bool rtcp_channel);
   // Set the DTLS-SRTP cipher policy on this channel as appropriate.
   bool SetDtlsSrtpCiphers(TransportChannel *tc, bool rtcp);
 
   virtual void ChangeState() = 0;
 
   // Gets the content info appropriate to the channel (audio or video).
@@ skipping 79 matching lines @@
 
 // VoiceChannel is a specialization that adds support for early media, DTMF,
 // and input/output level monitoring.
 class VoiceChannel : public BaseChannel {
  public:
   VoiceChannel(rtc::Thread* thread, MediaEngineInterface* media_engine,
                VoiceMediaChannel* channel, BaseSession* session,
                const std::string& content_name, bool rtcp);
   ~VoiceChannel();
   bool Init();
-  bool SetRemoteRenderer(uint32 ssrc, AudioRenderer* renderer);
+  bool SetRemoteRenderer(uint32_t ssrc, AudioRenderer* renderer);
 
   // Configure sending media on the stream with SSRC |ssrc|
   // If there is only one sending stream SSRC 0 can be used.
-  bool SetAudioSend(uint32 ssrc, bool mute, const AudioOptions* options,
+  bool SetAudioSend(uint32_t ssrc,
+                    bool mute,
+                    const AudioOptions* options,
                     AudioRenderer* renderer);
 
   // downcasts a MediaChannel
   virtual VoiceMediaChannel* media_channel() const {
     return static_cast<VoiceMediaChannel*>(BaseChannel::media_channel());
   }
 
   bool SetRingbackTone(const void* buf, int len);
   void SetEarlyMedia(bool enable);
   // This signal is emitted when we have gone a period of time without
   // receiving early media. When received, a UI should start playing its
   // own ringing sound
   sigslot::signal1<VoiceChannel*> SignalEarlyMediaTimeout;
 
-  bool PlayRingbackTone(uint32 ssrc, bool play, bool loop);
+  bool PlayRingbackTone(uint32_t ssrc, bool play, bool loop);
   // TODO(ronghuawu): Replace PressDTMF with InsertDtmf.
   bool PressDTMF(int digit, bool playout);
   // Returns if the telephone-event has been negotiated.
   bool CanInsertDtmf();
   // Send and/or play a DTMF |event| according to the |flags|.
   // The DTMF out-of-band signal will be used on sending.
   // The |ssrc| should be either 0 or a valid send stream ssrc.
   // The valid value for the |event| are 0 which corresponding to DTMF
   // event 0-9, *, #, A-D.
-  bool InsertDtmf(uint32 ssrc, int event_code, int duration, int flags);
-  bool SetOutputScaling(uint32 ssrc, double left, double right);
+  bool InsertDtmf(uint32_t ssrc, int event_code, int duration, int flags);
+  bool SetOutputScaling(uint32_t ssrc, double left, double right);
   // Get statistics about the current media session.
   bool GetStats(VoiceMediaInfo* stats);
 
   // Monitoring functions
   sigslot::signal2<VoiceChannel*, const std::vector<ConnectionInfo>&>
       SignalConnectionMonitor;
 
   void StartMediaMonitor(int cms);
   void StopMediaMonitor();
   sigslot::signal2<VoiceChannel*, const VoiceMediaInfo&> SignalMediaMonitor;
 
   void StartAudioMonitor(int cms);
   void StopAudioMonitor();
   bool IsAudioMonitorRunning() const;
   sigslot::signal2<VoiceChannel*, const AudioInfo&> SignalAudioMonitor;
 
   int GetInputLevel_w();
   int GetOutputLevel_w();
   void GetActiveStreams_w(AudioInfo::StreamList* actives);
 
   // Signal errors from VoiceMediaChannel.  Arguments are:
-  //     ssrc(uint32), and error(VoiceMediaChannel::Error).
-  sigslot::signal3<VoiceChannel*, uint32, VoiceMediaChannel::Error>
+  //     ssrc(uint32_t), and error(VoiceMediaChannel::Error).
+  sigslot::signal3<VoiceChannel*, uint32_t, VoiceMediaChannel::Error>
       SignalMediaError;
 
  private:
   // overrides from BaseChannel
   virtual void OnChannelRead(TransportChannel* channel,
                              const char* data, size_t len,
                              const rtc::PacketTime& packet_time,
                              int flags);
   virtual void ChangeState();
   virtual const ContentInfo* GetFirstContent(const SessionDescription* sdesc);
   virtual bool SetLocalContent_w(const MediaContentDescription* content,
                                  ContentAction action,
                                  std::string* error_desc);
   virtual bool SetRemoteContent_w(const MediaContentDescription* content,
                                   ContentAction action,
                                   std::string* error_desc);
   bool SetRingbackTone_w(const void* buf, int len);
-  bool PlayRingbackTone_w(uint32 ssrc, bool play, bool loop);
+  bool PlayRingbackTone_w(uint32_t ssrc, bool play, bool loop);
   void HandleEarlyMediaTimeout();
-  bool InsertDtmf_w(uint32 ssrc, int event, int duration, int flags);
-  bool SetOutputScaling_w(uint32 ssrc, double left, double right);
+  bool InsertDtmf_w(uint32_t ssrc, int event, int duration, int flags);
+  bool SetOutputScaling_w(uint32_t ssrc, double left, double right);
   bool GetStats_w(VoiceMediaInfo* stats);
 
   virtual void OnMessage(rtc::Message* pmsg);
   virtual void GetSrtpCiphers(std::vector<std::string>* ciphers) const;
   virtual void OnConnectionMonitorUpdate(
       ConnectionMonitor* monitor, const std::vector<ConnectionInfo>& infos);
   virtual void OnMediaMonitorUpdate(
       VoiceMediaChannel* media_channel, const VoiceMediaInfo& info);
   void OnAudioMonitorUpdate(AudioMonitor* monitor, const AudioInfo& info);
-  void OnVoiceChannelError(uint32 ssrc, VoiceMediaChannel::Error error);
+  void OnVoiceChannelError(uint32_t ssrc, VoiceMediaChannel::Error error);
   void SendLastMediaError();
-  void OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode, SrtpFilter::Error error);
+  void OnSrtpError(uint32_t ssrc,
+                   SrtpFilter::Mode mode,
+                   SrtpFilter::Error error);
 
   static const int kEarlyMediaTimeout = 1000;
   MediaEngineInterface* media_engine_;
   bool received_media_;
   rtc::scoped_ptr<VoiceMediaMonitor> media_monitor_;
   rtc::scoped_ptr<AudioMonitor> audio_monitor_;
 
   // Last AudioSendParameters sent down to the media_channel() via
   // SetSendParameters.
   AudioSendParameters last_send_params_;
   // Last AudioRecvParameters sent down to the media_channel() via
   // SetRecvParameters.
   AudioRecvParameters last_recv_params_;
 };
 
 // VideoChannel is a specialization for video.
 class VideoChannel : public BaseChannel {
  public:
   VideoChannel(rtc::Thread* thread, VideoMediaChannel* channel,
                BaseSession* session, const std::string& content_name,
                bool rtcp);
   ~VideoChannel();
   bool Init();
 
   // downcasts a MediaChannel
   virtual VideoMediaChannel* media_channel() const {
     return static_cast<VideoMediaChannel*>(BaseChannel::media_channel());
   }
 
-  bool SetRenderer(uint32 ssrc, VideoRenderer* renderer);
+  bool SetRenderer(uint32_t ssrc, VideoRenderer* renderer);
   bool ApplyViewRequest(const ViewRequest& request);
 
   // TODO(pthatcher): Refactor to use a "capture id" instead of an
   // ssrc here as the "key".
   // Passes ownership of the capturer to the channel.
-  bool AddScreencast(uint32 ssrc, VideoCapturer* capturer);
-  bool SetCapturer(uint32 ssrc, VideoCapturer* capturer);
-  bool RemoveScreencast(uint32 ssrc);
+  bool AddScreencast(uint32_t ssrc, VideoCapturer* capturer);
+  bool SetCapturer(uint32_t ssrc, VideoCapturer* capturer);
+  bool RemoveScreencast(uint32_t ssrc);
   // True if we've added a screencast.  Doesn't matter if the capturer
   // has been started or not.
   bool IsScreencasting();
-  int GetScreencastFps(uint32 ssrc);
-  int GetScreencastMaxPixels(uint32 ssrc);
+  int GetScreencastFps(uint32_t ssrc);
+  int GetScreencastMaxPixels(uint32_t ssrc);
   // Get statistics about the current media session.
   bool GetStats(VideoMediaInfo* stats);
 
   sigslot::signal2<VideoChannel*, const std::vector<ConnectionInfo>&>
       SignalConnectionMonitor;
 
   void StartMediaMonitor(int cms);
   void StopMediaMonitor();
   sigslot::signal2<VideoChannel*, const VideoMediaInfo&> SignalMediaMonitor;
-  sigslot::signal2<uint32, rtc::WindowEvent> SignalScreencastWindowEvent;
+  sigslot::signal2<uint32_t, rtc::WindowEvent> SignalScreencastWindowEvent;
 
   bool SendIntraFrame();
   bool RequestIntraFrame();
-  sigslot::signal3<VideoChannel*, uint32, VideoMediaChannel::Error>
+  sigslot::signal3<VideoChannel*, uint32_t, VideoMediaChannel::Error>
       SignalMediaError;
 
   // Configure sending media on the stream with SSRC |ssrc|
   // If there is only one sending stream SSRC 0 can be used.
-  bool SetVideoSend(uint32 ssrc, bool mute, const VideoOptions* options);
+  bool SetVideoSend(uint32_t ssrc, bool mute, const VideoOptions* options);
 
  private:
-  typedef std::map<uint32, VideoCapturer*> ScreencastMap;
+  typedef std::map<uint32_t, VideoCapturer*> ScreencastMap;
   struct ScreencastDetailsData;
 
   // overrides from BaseChannel
   virtual void ChangeState();
   virtual const ContentInfo* GetFirstContent(const SessionDescription* sdesc);
   virtual bool SetLocalContent_w(const MediaContentDescription* content,
                                  ContentAction action,
                                  std::string* error_desc);
   virtual bool SetRemoteContent_w(const MediaContentDescription* content,
                                   ContentAction action,
                                   std::string* error_desc);
   bool ApplyViewRequest_w(const ViewRequest& request);
 
-  bool AddScreencast_w(uint32 ssrc, VideoCapturer* capturer);
-  bool RemoveScreencast_w(uint32 ssrc);
-  void OnScreencastWindowEvent_s(uint32 ssrc, rtc::WindowEvent we);
+  bool AddScreencast_w(uint32_t ssrc, VideoCapturer* capturer);
+  bool RemoveScreencast_w(uint32_t ssrc);
+  void OnScreencastWindowEvent_s(uint32_t ssrc, rtc::WindowEvent we);
   bool IsScreencasting_w() const;
   void GetScreencastDetails_w(ScreencastDetailsData* d) const;
   bool GetStats_w(VideoMediaInfo* stats);
 
   virtual void OnMessage(rtc::Message* pmsg);
   virtual void GetSrtpCiphers(std::vector<std::string>* ciphers) const;
   virtual void OnConnectionMonitorUpdate(
       ConnectionMonitor* monitor, const std::vector<ConnectionInfo>& infos);
   virtual void OnMediaMonitorUpdate(
       VideoMediaChannel* media_channel, const VideoMediaInfo& info);
-  virtual void OnScreencastWindowEvent(uint32 ssrc,
-                                       rtc::WindowEvent event);
+  virtual void OnScreencastWindowEvent(uint32_t ssrc, rtc::WindowEvent event);
   virtual void OnStateChange(VideoCapturer* capturer, CaptureState ev);
-  bool GetLocalSsrc(const VideoCapturer* capturer, uint32* ssrc);
+  bool GetLocalSsrc(const VideoCapturer* capturer, uint32_t* ssrc);
 
-  void OnVideoChannelError(uint32 ssrc, VideoMediaChannel::Error error);
-  void OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode, SrtpFilter::Error error);
+  void OnVideoChannelError(uint32_t ssrc, VideoMediaChannel::Error error);
+  void OnSrtpError(uint32_t ssrc,
+                   SrtpFilter::Mode mode,
+                   SrtpFilter::Error error);
 
   VideoRenderer* renderer_;
   ScreencastMap screencast_capturers_;
   rtc::scoped_ptr<VideoMediaMonitor> media_monitor_;
 
   rtc::WindowEvent previous_we_;
 
   // Last VideoSendParameters sent down to the media_channel() via
   // SetSendParameters.
   VideoSendParameters last_send_params_;
@@ skipping 21 matching lines @@
   void StopMediaMonitor();
 
   // Should be called on the signaling thread only.
   bool ready_to_send_data() const {
     return ready_to_send_data_;
   }
 
   sigslot::signal2<DataChannel*, const DataMediaInfo&> SignalMediaMonitor;
   sigslot::signal2<DataChannel*, const std::vector<ConnectionInfo>&>
       SignalConnectionMonitor;
-  sigslot::signal3<DataChannel*, uint32, DataMediaChannel::Error>
+  sigslot::signal3<DataChannel*, uint32_t, DataMediaChannel::Error>
       SignalMediaError;
   sigslot::signal3<DataChannel*,
                    const ReceiveDataParams&,
                    const rtc::Buffer&>
       SignalDataReceived;
   // Signal for notifying when the channel becomes ready to send data.
   // That occurs when the channel is enabled, the transport is writable,
   // both local and remote descriptions are set, and the channel is unblocked.
   sigslot::signal1<bool> SignalReadyToSendData;
   // Signal for notifying that the remote side has closed the DataChannel.
-  sigslot::signal1<uint32> SignalStreamClosedRemotely;
+  sigslot::signal1<uint32_t> SignalStreamClosedRemotely;
 
  protected:
   // downcasts a MediaChannel.
   virtual DataMediaChannel* media_channel() const {
     return static_cast<DataMediaChannel*>(BaseChannel::media_channel());
   }
 
  private:
   struct SendDataMessageData : public rtc::MessageData {
     SendDataMessageData(const SendDataParams& params,
@@ skipping 48 matching lines @@
 
   virtual void OnMessage(rtc::Message* pmsg);
   virtual void GetSrtpCiphers(std::vector<std::string>* ciphers) const;
   virtual void OnConnectionMonitorUpdate(
       ConnectionMonitor* monitor, const std::vector<ConnectionInfo>& infos);
   virtual void OnMediaMonitorUpdate(
       DataMediaChannel* media_channel, const DataMediaInfo& info);
   virtual bool ShouldSetupDtlsSrtp() const;
   void OnDataReceived(
       const ReceiveDataParams& params, const char* data, size_t len);
-  void OnDataChannelError(uint32 ssrc, DataMediaChannel::Error error);
+  void OnDataChannelError(uint32_t ssrc, DataMediaChannel::Error error);
   void OnDataChannelReadyToSend(bool writable);
-  void OnSrtpError(uint32 ssrc, SrtpFilter::Mode mode, SrtpFilter::Error error);
-  void OnStreamClosedRemotely(uint32 sid);
+  void OnSrtpError(uint32_t ssrc,
+                   SrtpFilter::Mode mode,
+                   SrtpFilter::Error error);
+  void OnStreamClosedRemotely(uint32_t sid);
 
   rtc::scoped_ptr<DataMediaMonitor> media_monitor_;
   // TODO(pthatcher): Make a separate SctpDataChannel and
   // RtpDataChannel instead of using this.
   DataChannelType data_channel_type_;
   bool ready_to_send_data_;
 
   // Last DataSendParameters sent down to the media_channel() via
   // SetSendParameters.
   DataSendParameters last_send_params_;
   // Last DataRecvParameters sent down to the media_channel() via
   // SetRecvParameters.
   DataRecvParameters last_recv_params_;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_SESSION_MEDIA_CHANNEL_H_