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

talk/media/base/mediachannel.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 270 matching lines @@
   Settable<bool> typing_detection;
   Settable<bool> aecm_generate_comfort_noise;
   Settable<bool> conference_mode;
   Settable<int> adjust_agc_delta;
   Settable<bool> experimental_agc;
   Settable<bool> extended_filter_aec;
   Settable<bool> delay_agnostic_aec;
   Settable<bool> experimental_ns;
   Settable<bool> aec_dump;
   // Note that tx_agc_* only applies to non-experimental AGC.
-  Settable<uint16> tx_agc_target_dbov;
-  Settable<uint16> tx_agc_digital_compression_gain;
+  Settable<uint16_t> tx_agc_target_dbov;
+  Settable<uint16_t> tx_agc_digital_compression_gain;
   Settable<bool> tx_agc_limiter;
-  Settable<uint16> rx_agc_target_dbov;
-  Settable<uint16> rx_agc_digital_compression_gain;
+  Settable<uint16_t> rx_agc_target_dbov;
+  Settable<uint16_t> rx_agc_digital_compression_gain;
   Settable<bool> rx_agc_limiter;
-  Settable<uint32> recording_sample_rate;
-  Settable<uint32> playout_sample_rate;
+  Settable<uint32_t> recording_sample_rate;
+  Settable<uint32_t> playout_sample_rate;
   // Set DSCP value for packet sent from audio channel.
   Settable<bool> dscp;
   // Enable combined audio+bandwidth BWE.
   Settable<bool> combined_audio_video_bwe;
 };
 
 // Options that can be applied to a VideoMediaChannel or a VideoMediaEngine.
 // Used to be flags, but that makes it hard to selectively apply options.
 // We are moving all of the setting of options to structs like this,
 // but some things currently still use flags.
@@ skipping 241 matching lines @@
   virtual void OnRtcpReceived(rtc::Buffer* packet,
                               const rtc::PacketTime& packet_time) = 0;
   // Called when the socket's ability to send has changed.
   virtual void OnReadyToSend(bool ready) = 0;
   // Creates a new outgoing media stream with SSRCs and CNAME as described
   // by sp.
   virtual bool AddSendStream(const StreamParams& sp) = 0;
   // Removes an outgoing media stream.
   // ssrc must be the first SSRC of the media stream if the stream uses
   // multiple SSRCs.
-  virtual bool RemoveSendStream(uint32 ssrc) = 0;
+  virtual bool RemoveSendStream(uint32_t ssrc) = 0;
   // Creates a new incoming media stream with SSRCs and CNAME as described
   // by sp.
   virtual bool AddRecvStream(const StreamParams& sp) = 0;
   // Removes an incoming media stream.
   // ssrc must be the first SSRC of the media stream if the stream uses
   // multiple SSRCs.
-  virtual bool RemoveRecvStream(uint32 ssrc) = 0;
+  virtual bool RemoveRecvStream(uint32_t ssrc) = 0;
 
   // Returns the absoulte sendtime extension id value from media channel.
   virtual int GetRtpSendTimeExtnId() const {
     return -1;
   }
 
   // Base method to send packet using NetworkInterface.
   bool SendPacket(rtc::Buffer* packet) {
     return DoSendPacket(packet, false);
   }
@@ skipping 55 matching lines @@
 // Media contains a vector of SSRC infos that are exclusively used by this
 // media. (SSRCs shared between media streams can't be represented.)
 
 // Information about an SSRC.
 // This data may be locally recorded, or received in an RTCP SR or RR.
 struct SsrcSenderInfo {
   SsrcSenderInfo()
       : ssrc(0),
     timestamp(0) {
   }
-  uint32 ssrc;
+  uint32_t ssrc;
   double timestamp;  // NTP timestamp, represented as seconds since epoch.
 };
 
 struct SsrcReceiverInfo {
   SsrcReceiverInfo()
       : ssrc(0),
         timestamp(0) {
   }
-  uint32 ssrc;
+  uint32_t ssrc;
   double timestamp;
 };
 
 struct MediaSenderInfo {
   MediaSenderInfo()
       : bytes_sent(0),
         packets_sent(0),
         packets_lost(0),
         fraction_lost(0.0),
         rtt_ms(0) {
   }
   void add_ssrc(const SsrcSenderInfo& stat) {
     local_stats.push_back(stat);
   }
   // Temporary utility function for call sites that only provide SSRC.
   // As more info is added into SsrcSenderInfo, this function should go away.
-  void add_ssrc(uint32 ssrc) {
+  void add_ssrc(uint32_t ssrc) {
     SsrcSenderInfo stat;
     stat.ssrc = ssrc;
     add_ssrc(stat);
   }
   // Utility accessor for clients that are only interested in ssrc numbers.
-  std::vector<uint32> ssrcs() const {
-    std::vector<uint32> retval;
+  std::vector<uint32_t> ssrcs() const {
+    std::vector<uint32_t> retval;
     for (std::vector<SsrcSenderInfo>::const_iterator it = local_stats.begin();
          it != local_stats.end(); ++it) {
       retval.push_back(it->ssrc);
     }
     return retval;
   }
   // Utility accessor for clients that make the assumption only one ssrc
   // exists per media.
   // This will eventually go away.
-  uint32 ssrc() const {
+  uint32_t ssrc() const {
     if (local_stats.size() > 0) {
       return local_stats[0].ssrc;
     } else {
       return 0;
     }
   }
-  int64 bytes_sent;
+  int64_t bytes_sent;
   int packets_sent;
   int packets_lost;
   float fraction_lost;
   int64_t rtt_ms;
   std::string codec_name;
   std::vector<SsrcSenderInfo> local_stats;
   std::vector<SsrcReceiverInfo> remote_stats;
 };
 
 template<class T>
@@ skipping 15 matching lines @@
       : bytes_rcvd(0),
         packets_rcvd(0),
         packets_lost(0),
         fraction_lost(0.0) {
   }
   void add_ssrc(const SsrcReceiverInfo& stat) {
     local_stats.push_back(stat);
   }
   // Temporary utility function for call sites that only provide SSRC.
   // As more info is added into SsrcSenderInfo, this function should go away.
-  void add_ssrc(uint32 ssrc) {
+  void add_ssrc(uint32_t ssrc) {
     SsrcReceiverInfo stat;
     stat.ssrc = ssrc;
     add_ssrc(stat);
   }
-  std::vector<uint32> ssrcs() const {
-    std::vector<uint32> retval;
+  std::vector<uint32_t> ssrcs() const {
+    std::vector<uint32_t> retval;
     for (std::vector<SsrcReceiverInfo>::const_iterator it = local_stats.begin();
          it != local_stats.end(); ++it) {
       retval.push_back(it->ssrc);
     }
     return retval;
   }
   // Utility accessor for clients that make the assumption only one ssrc
   // exists per media.
   // This will eventually go away.
-  uint32 ssrc() const {
+  uint32_t ssrc() const {
     if (local_stats.size() > 0) {
       return local_stats[0].ssrc;
     } else {
       return 0;
     }
   }
 
-  int64 bytes_rcvd;
+  int64_t bytes_rcvd;
   int packets_rcvd;
   int packets_lost;
   float fraction_lost;
   std::string codec_name;
   std::vector<SsrcReceiverInfo> local_stats;
   std::vector<SsrcSenderInfo> remote_stats;
 };
 
 struct VoiceSenderInfo : public MediaSenderInfo {
   VoiceSenderInfo()
@@ skipping 56 matching lines @@
   float accelerate_rate;
   // Fraction of data inserted through time stretching.
   float preemptive_expand_rate;
   int decoding_calls_to_silence_generator;
   int decoding_calls_to_neteq;
   int decoding_normal;
   int decoding_plc;
   int decoding_cng;
   int decoding_plc_cng;
   // Estimated capture start time in NTP time in ms.
-  int64 capture_start_ntp_time_ms;
+  int64_t capture_start_ntp_time_ms;
 };
 
 struct VideoSenderInfo : public MediaSenderInfo {
   VideoSenderInfo()
       : packets_cached(0),
         firs_rcvd(0),
         plis_rcvd(0),
         nacks_rcvd(0),
         input_frame_width(0),
         input_frame_height(0),
@@ skipping 83 matching lines @@
   int min_playout_delay_ms;
   // Requested latency to account for rendering delay.
   int render_delay_ms;
   // Target overall delay: network+decode+render, accounting for
   // min_playout_delay_ms.
   int target_delay_ms;
   // Current overall delay, possibly ramping towards target_delay_ms.
   int current_delay_ms;
 
   // Estimated capture start time in NTP time in ms.
-  int64 capture_start_ntp_time_ms;
+  int64_t capture_start_ntp_time_ms;
 };
 
 struct DataSenderInfo : public MediaSenderInfo {
   DataSenderInfo()
       : ssrc(0) {
   }
 
-  uint32 ssrc;
+  uint32_t ssrc;
 };
 
 struct DataReceiverInfo : public MediaReceiverInfo {
   DataReceiverInfo()
       : ssrc(0) {
   }
 
-  uint32 ssrc;
+  uint32_t ssrc;
 };
 
 struct BandwidthEstimationInfo {
   BandwidthEstimationInfo()
       : available_send_bandwidth(0),
         available_recv_bandwidth(0),
         target_enc_bitrate(0),
         actual_enc_bitrate(0),
         retransmit_bitrate(0),
         transmit_bitrate(0),
@@ skipping 102 matching lines @@
 
   VoiceMediaChannel() {}
   virtual ~VoiceMediaChannel() {}
   virtual bool SetSendParameters(const AudioSendParameters& params) = 0;
   virtual bool SetRecvParameters(const AudioRecvParameters& params) = 0;
   // Starts or stops playout of received audio.
   virtual bool SetPlayout(bool playout) = 0;
   // Starts or stops sending (and potentially capture) of local audio.
   virtual bool SetSend(SendFlags flag) = 0;
   // Configure stream for sending.
-  virtual bool SetAudioSend(uint32 ssrc, bool mute, const AudioOptions* options,
+  virtual bool SetAudioSend(uint32_t ssrc,
+                            bool mute,
+                            const AudioOptions* options,
                             AudioRenderer* renderer) = 0;
   // Sets the renderer object to be used for the specified remote audio stream.
-  virtual bool SetRemoteRenderer(uint32 ssrc, AudioRenderer* renderer) = 0;
+  virtual bool SetRemoteRenderer(uint32_t ssrc, AudioRenderer* renderer) = 0;
   // Gets current energy levels for all incoming streams.
   virtual bool GetActiveStreams(AudioInfo::StreamList* actives) = 0;
   // Get the current energy level of the stream sent to the speaker.
   virtual int GetOutputLevel() = 0;
   // Get the time in milliseconds since last recorded keystroke, or negative.
   virtual int GetTimeSinceLastTyping() = 0;
   // Temporarily exposed field for tuning typing detect options.
   virtual void SetTypingDetectionParameters(int time_window,
     int cost_per_typing, int reporting_threshold, int penalty_decay,
     int type_event_delay) = 0;
   // Set left and right scale for speaker output volume of the specified ssrc.
-  virtual bool SetOutputScaling(uint32 ssrc, double left, double right) = 0;
+  virtual bool SetOutputScaling(uint32_t ssrc, double left, double right) = 0;
   // Specifies a ringback tone to be played during call setup.
   virtual bool SetRingbackTone(const char *buf, int len) = 0;
   // Plays or stops the aforementioned ringback tone
-  virtual bool PlayRingbackTone(uint32 ssrc, bool play, bool loop) = 0;
+  virtual bool PlayRingbackTone(uint32_t ssrc, bool play, bool loop) = 0;
   // Returns if the telephone-event has been negotiated.
   virtual bool CanInsertDtmf() { return false; }
   // 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 to 15 which corresponding to
   // DTMF event 0-9, *, #, A-D.
-  virtual bool InsertDtmf(uint32 ssrc, int event, int duration, int flags) = 0;
+  virtual bool InsertDtmf(uint32_t ssrc,
+                          int event,
+                          int duration,
+                          int flags) = 0;
   // Gets quality stats for the channel.
   virtual bool GetStats(VoiceMediaInfo* info) = 0;
   // Gets last reported error for this media channel.
-  virtual void GetLastMediaError(uint32* ssrc,
+  virtual void GetLastMediaError(uint32_t* ssrc,
                                  VoiceMediaChannel::Error* error) {
     ASSERT(error != NULL);
     *error = ERROR_NONE;
   }
 
   // Signal errors from MediaChannel.  Arguments are:
-  //     ssrc(uint32), and error(VoiceMediaChannel::Error).
-  sigslot::signal2<uint32, VoiceMediaChannel::Error> SignalMediaError;
+  //     ssrc(uint32_t), and error(VoiceMediaChannel::Error).
+  sigslot::signal2<uint32_t, VoiceMediaChannel::Error> SignalMediaError;
 };
 
 struct VideoSendParameters : RtpSendParameters<VideoCodec, VideoOptions> {
 };
 
 struct VideoRecvParameters : RtpParameters<VideoCodec> {
 };
 
 class VideoMediaChannel : public MediaChannel {
  public:
@@ skipping 13 matching lines @@
   };
 
   VideoMediaChannel() : renderer_(NULL) {}
   virtual ~VideoMediaChannel() {}
 
   virtual bool SetSendParameters(const VideoSendParameters& params) = 0;
   virtual bool SetRecvParameters(const VideoRecvParameters& params) = 0;
   // Gets the currently set codecs/payload types to be used for outgoing media.
   virtual bool GetSendCodec(VideoCodec* send_codec) = 0;
   // Sets the format of a specified outgoing stream.
-  virtual bool SetSendStreamFormat(uint32 ssrc, const VideoFormat& format) = 0;
+  virtual bool SetSendStreamFormat(uint32_t ssrc,
+                                   const VideoFormat& format) = 0;
   // Starts or stops playout of received video.
   virtual bool SetRender(bool render) = 0;
   // Starts or stops transmission (and potentially capture) of local video.
   virtual bool SetSend(bool send) = 0;
   // Configure stream for sending.
-  virtual bool SetVideoSend(uint32 ssrc, bool mute,
+  virtual bool SetVideoSend(uint32_t ssrc,
+                            bool mute,
                             const VideoOptions* options) = 0;
   // Sets the renderer object to be used for the specified stream.
   // If SSRC is 0, the renderer is used for the 'default' stream.
-  virtual bool SetRenderer(uint32 ssrc, VideoRenderer* renderer) = 0;
+  virtual bool SetRenderer(uint32_t ssrc, VideoRenderer* renderer) = 0;
   // If |ssrc| is 0, replace the default capturer (engine capturer) with
   // |capturer|. If |ssrc| is non zero create a new stream with |ssrc| as SSRC.
-  virtual bool SetCapturer(uint32 ssrc, VideoCapturer* capturer) = 0;
+  virtual bool SetCapturer(uint32_t ssrc, VideoCapturer* capturer) = 0;
   // Gets quality stats for the channel.
   virtual bool GetStats(VideoMediaInfo* info) = 0;
   // Send an intra frame to the receivers.
   virtual bool SendIntraFrame() = 0;
   // Reuqest each of the remote senders to send an intra frame.
   virtual bool RequestIntraFrame() = 0;
   virtual void UpdateAspectRatio(int ratio_w, int ratio_h) = 0;
 
   // Signal errors from MediaChannel.  Arguments are:
-  //     ssrc(uint32), and error(VideoMediaChannel::Error).
-  sigslot::signal2<uint32, Error> SignalMediaError;
+  //     ssrc(uint32_t), and error(VideoMediaChannel::Error).
+  sigslot::signal2<uint32_t, Error> SignalMediaError;
 
  protected:
   VideoRenderer *renderer_;
 };
 
 enum DataMessageType {
   // Chrome-Internal use only.  See SctpDataMediaChannel for the actual PPID
   // values.
   DMT_NONE = 0,
   DMT_CONTROL = 1,
   DMT_BINARY = 2,
   DMT_TEXT = 3,
 };
 
 // Info about data received in DataMediaChannel.  For use in
 // DataMediaChannel::SignalDataReceived and in all of the signals that
 // signal fires, on up the chain.
 struct ReceiveDataParams {
   // The in-packet stream indentifier.
   // For SCTP, this is really SID, not SSRC.
-  uint32 ssrc;
+  uint32_t ssrc;
   // The type of message (binary, text, or control).
   DataMessageType type;
   // A per-stream value incremented per packet in the stream.
   int seq_num;
   // A per-stream value monotonically increasing with time.
   int timestamp;
 
   ReceiveDataParams() :
       ssrc(0),
       type(DMT_TEXT),
       seq_num(0),
       timestamp(0) {
   }
 };
 
 struct SendDataParams {
   // The in-packet stream indentifier.
   // For SCTP, this is really SID, not SSRC.
-  uint32 ssrc;
+  uint32_t ssrc;
   // The type of message (binary, text, or control).
   DataMessageType type;
 
   // For SCTP, whether to send messages flagged as ordered or not.
   // If false, messages can be received out of order.
   bool ordered;
   // For SCTP, whether the messages are sent reliably or not.
   // If false, messages may be lost.
   bool reliable;
   // For SCTP, if reliable == false, provide partial reliability by
@@ skipping 64 matching lines @@
 
   virtual bool SendData(
       const SendDataParams& params,
       const rtc::Buffer& payload,
       SendDataResult* result = NULL) = 0;
   // Signals when data is received (params, data, len)
   sigslot::signal3<const ReceiveDataParams&,
                    const char*,
                    size_t> SignalDataReceived;
   // Signal errors from MediaChannel.  Arguments are:
-  //     ssrc(uint32), and error(DataMediaChannel::Error).
-  sigslot::signal2<uint32, DataMediaChannel::Error> SignalMediaError;
+  //     ssrc(uint32_t), and error(DataMediaChannel::Error).
+  sigslot::signal2<uint32_t, DataMediaChannel::Error> SignalMediaError;
   // Signal when the media channel is ready to send the stream. Arguments are:
   //     writable(bool)
   sigslot::signal1<bool> SignalReadyToSend;
   // Signal for notifying that the remote side has closed the DataChannel.
-  sigslot::signal1<uint32> SignalStreamClosedRemotely;
+  sigslot::signal1<uint32_t> SignalStreamClosedRemotely;
 };
 
 }  // namespace cricket
 
 #endif  // TALK_MEDIA_BASE_MEDIACHANNEL_H_