Update audio code to use size_t more correctly,

webrtc/modules/audio_coding/neteq/test/RTPencode.cc

 /*

[hlundin-webrtc, 2015/08/10 11:30:01]

Just FYI: This is very old and hairy code. Here be dragons...

  *  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.
  */
 
 // TODO(hlundin): Reformat file to meet style guide.
 
 /* header includes */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #ifdef WIN32
 #include <winsock2.h>
 #endif
 #ifdef WEBRTC_LINUX
 #include <netinet/in.h>
 #endif
 
 #include <assert.h>
 
+#include <algorithm>
+
 #include "webrtc/typedefs.h"
 // needed for NetEqDecoder
 #include "webrtc/modules/audio_coding/neteq/audio_decoder_impl.h"
 #include "webrtc/modules/audio_coding/neteq/interface/neteq.h"
 
 /************************/
 /* Define payload types */
 /************************/
 
 #include "PayloadTypes.h"
@@ skipping 33 matching lines @@
 #define STEREO_MODE_SAMPLE_1 1  // 1 octet per sample
 #define STEREO_MODE_SAMPLE_2 2  // 2 octets per sample
 
 /*************************/
 /* Function declarations */
 /*************************/
 
 void NetEQTest_GetCodec_and_PT(char* name,
                                webrtc::NetEqDecoder* codec,
                                int* PT,
-                               int frameLen,
+                               size_t frameLen,
                                int* fs,
                                int* bitrate,
                                int* useRed);
 int NetEQTest_init_coders(webrtc::NetEqDecoder coder,
-                          int enc_frameSize,
+                          size_t enc_frameSize,
                           int bitrate,
                           int sampfreq,
                           int vad,
-                          int numChannels);
+                          size_t numChannels);
 void defineCodecs(webrtc::NetEqDecoder* usedCodec, int* noOfCodecs);
-int NetEQTest_free_coders(webrtc::NetEqDecoder coder, int numChannels);
-int NetEQTest_encode(int coder,
-                     int16_t* indata,
-                     int frameLen,
-                     unsigned char* encoded,
-                     int sampleRate,
-                     int* vad,
-                     int useVAD,
-                     int bitrate,
-                     int numChannels);
+int NetEQTest_free_coders(webrtc::NetEqDecoder coder, size_t numChannels);
+size_t NetEQTest_encode(int coder,
+                        int16_t* indata,
+                        size_t frameLen,
+                        unsigned char* encoded,
+                        int sampleRate,
+                        int* vad,
+                        int useVAD,
+                        int bitrate,
+                        size_t numChannels);
 void makeRTPheader(unsigned char* rtp_data,
                    int payloadType,
                    int seqNo,
                    uint32_t timestamp,
                    uint32_t ssrc);
 int makeRedundantHeader(unsigned char* rtp_data,
                         int* payloadType,
                         int numPayloads,
                         uint32_t* timestamp,
                         uint16_t* blockLen,
                         int seqNo,
                         uint32_t ssrc);
-int makeDTMFpayload(unsigned char* payload_data,
-                    int Event,
-                    int End,
-                    int Volume,
-                    int Duration);
-void stereoDeInterleave(int16_t* audioSamples, int numSamples);
-void stereoInterleave(unsigned char* data, int dataLen, int stride);
+size_t makeDTMFpayload(unsigned char* payload_data,
+                       int Event,
+                       int End,
+                       int Volume,
+                       int Duration);
+void stereoDeInterleave(int16_t* audioSamples, size_t numSamples);
+void stereoInterleave(unsigned char* data, size_t dataLen, size_t stride);
 
 /*********************/
 /* Codec definitions */
 /*********************/
 
 #include "webrtc_vad.h"
 
 #if ((defined CODEC_PCM16B) || (defined NETEQ_ARBITRARY_CODEC))
 #include "pcm16b.h"
 #endif
@@ skipping 128 matching lines @@
 CNG_enc_inst* CNGenc_inst[2];
 #endif
 #ifdef CODEC_SPEEX_8
 SPEEX_encinst_t* SPEEX8enc_inst[2];
 #endif
 #ifdef CODEC_SPEEX_16
 SPEEX_encinst_t* SPEEX16enc_inst[2];
 #endif
 
 int main(int argc, char* argv[]) {
-  int packet_size, fs;
+  size_t packet_size;
+  int fs;
   webrtc::NetEqDecoder usedCodec;
   int payloadType;
   int bitrate = 0;
   int useVAD, vad;
   int useRed = 0;
-  int len, enc_len;
+  size_t len, enc_len;
   int16_t org_data[4000];
   unsigned char rtp_data[8000];
   int16_t seqNo = 0xFFF;
   uint32_t ssrc = 1235412312;
   uint32_t timestamp = 0xAC1245;
   uint16_t length, plen;
   uint32_t offset;
   double sendtime = 0;
   int red_PT[2] = {0};
   uint32_t red_TS[2] = {0};
   uint16_t red_len[2] = {0};
-  int RTPheaderLen = 12;
+  size_t RTPheaderLen = 12;
   uint8_t red_data[8000];
 #ifdef INSERT_OLD_PACKETS
   uint16_t old_length, old_plen;
-  int old_enc_len;
+  size_t old_enc_len;
   int first_old_packet = 1;
   unsigned char old_rtp_data[8000];
-  int packet_age = 0;
+  size_t packet_age = 0;
 #endif
 #ifdef INSERT_DTMF_PACKETS
   int NTone = 1;
   int DTMFfirst = 1;
   uint32_t DTMFtimestamp;
   bool dtmfSent = false;
 #endif
   bool usingStereo = false;
-  int stereoMode = 0;
-  int numChannels = 1;
+  size_t stereoMode = 0;
+  size_t numChannels = 1;
 
   /* check number of parameters */
   if ((argc != 6) && (argc != 7)) {
     /* print help text and exit */
     printf("Application to encode speech into an RTP stream.\n");
     printf("The program reads a PCM file and encodes is using the specified "
            "codec.\n");
     printf("The coded speech is packetized in RTP packest and written to the "
            "output file.\n");
     printf("The format of the RTP stream file is simlilar to that of "
@@ skipping 129 matching lines @@
 
     return (0);
   }
 
   FILE* in_file = fopen(argv[1], "rb");
   CHECK_NOT_NULL(in_file);
   printf("Input file: %s\n", argv[1]);
   FILE* out_file = fopen(argv[2], "wb");
   CHECK_NOT_NULL(out_file);
   printf("Output file: %s\n\n", argv[2]);
-  packet_size = atoi(argv[3]);
-  if (packet_size <= 0) {
-     printf("Packet size %d must be positive", packet_size);
+  int packet_size_int = atoi(argv[3]);
+  if (packet_size_int <= 0) {
+     printf("Packet size %d must be positive", packet_size_int);
      return -1;
   }
-  printf("Packet size: %d\n", packet_size);
+  printf("Packet size: %d\n", packet_size_int);
+  packet_size = static_cast<size_t>(packet_size_int);
 
   // check for stereo
   if (argv[4][strlen(argv[4]) - 1] == '*') {
     // use stereo
     usingStereo = true;
     numChannels = 2;
     argv[4][strlen(argv[4]) - 1] = '\0';
   }
 
   NetEQTest_GetCodec_and_PT(argv[4], &usedCodec, &payloadType, packet_size, &fs,
@@ skipping 178 matching lines @@
     /* If DTMF is sent, we should not send any speech packets during the same
      * time */
     if (dtmfSent) {
       enc_len = 0;
     } else {
 #endif
       /* encode frame */
       enc_len =
           NetEQTest_encode(usedCodec, org_data, packet_size, &rtp_data[12], fs,
                            &vad, useVAD, bitrate, numChannels);
-      if (enc_len == -1) {
-        printf("Error encoding frame\n");
-        exit(0);
-      }
 
       if (usingStereo && stereoMode != STEREO_MODE_FRAME && vad == 1) {
         // interleave the encoded payload for sample-based codecs (not for CNG)
         stereoInterleave(&rtp_data[12], enc_len, stereoMode);
       }
 #ifdef NO_DTMF_OVERDUB
     }
 #endif
 
     if (enc_len > 0 &&
@@ skipping 52 matching lines @@
         if (fwrite(&length, 2, 1, out_file) != 1) {
           return -1;
         }
         if (fwrite(&plen, 2, 1, out_file) != 1) {
           return -1;
         }
         if (fwrite(&offset, 4, 1, out_file) != 1) {
           return -1;
         }
 #ifdef RANDOM_DATA
-        for (int k = 0; k < 12 + enc_len; k++) {
+        for (size_t k = 0; k < 12 + enc_len; k++) {
           rtp_data[k] = rand() + rand();
         }
 #endif
 #ifdef RANDOM_PAYLOAD_DATA
-        for (int k = 12; k < 12 + enc_len; k++) {
+        for (size_t k = 12; k < 12 + enc_len; k++) {
           rtp_data[k] = rand() + rand();
         }
 #endif
         if (fwrite(rtp_data, 12 + enc_len, 1, out_file) != 1) {
           return -1;
         }
 #ifdef MULTIPLE_SAME_TIMESTAMP
       } while ((seqNo % REPEAT_PACKET_DISTANCE == 0) &&
                (mult_pack++ < REPEAT_PACKET_COUNT));
 #endif  // MULTIPLE_SAME_TIMESTAMP
@@ skipping 67 matching lines @@
   return (0);
 }
 
 /****************/
 /* Subfunctions */
 /****************/
 
 void NetEQTest_GetCodec_and_PT(char* name,
                                webrtc::NetEqDecoder* codec,
                                int* PT,
-                               int frameLen,
+                               size_t frameLen,
                                int* fs,
                                int* bitrate,
                                int* useRed) {
   *bitrate = 0; /* Default bitrate setting */
   *useRed = 0;  /* Default no redundancy */
 
   if (!strcmp(name, "pcmu")) {
     *codec = webrtc::kDecoderPCMu;
     *PT = NETEQ_CODEC_PCMU_PT;
     *fs = 8000;
@@ skipping 44 matching lines @@
     *PT = NETEQ_CODEC_ISAC_PT; /* this will be the PT for the sub-headers */
     *fs = 16000;
     *useRed = 1;
   } else {
     printf("Error: Not a supported codec (%s)\n", name);
     exit(0);
   }
 }
 
 int NetEQTest_init_coders(webrtc::NetEqDecoder coder,
-                          int enc_frameSize,
+                          size_t enc_frameSize,
                           int bitrate,
                           int sampfreq,
                           int vad,
-                          int numChannels) {
+                          size_t numChannels) {
   int ok = 0;
 
-  for (int k = 0; k < numChannels; k++) {
+  for (size_t k = 0; k < numChannels; k++) {
     VAD_inst[k] = WebRtcVad_Create();
     if (!VAD_inst[k]) {
       printf("Error: Couldn't allocate memory for VAD instance\n");
       exit(0);
     }
     ok = WebRtcVad_Init(VAD_inst[k]);
     if (ok == -1) {
       printf("Error: Initialization of VAD struct failed\n");
       exit(0);
     }
@@ skipping 47 matching lines @@
               exit(0);
             }
           } else {
             printf("\nError: g729 only supports 10, 20, 30, 40, 50 or 60 "
                    "ms!!\n\n");
             exit(0);
           }
           WebRtcG729_EncoderInit(G729enc_inst[k], vad);
           if ((vad == 1) && (enc_frameSize != 80)) {
             printf("\nError - This simulation only supports VAD for G729 at "
-                   "10ms packets (not %dms)\n", (enc_frameSize >> 3));
+                   "10ms packets (not %" PRIuS "ms)\n", (enc_frameSize >> 3));
           }
         } else {
           printf("\nError - g729 is only developed for 8kHz \n");
           exit(0);
         }
         break;
 #endif
 #ifdef CODEC_G729_1
       case webrtc::kDecoderG729_1:
         if (sampfreq == 16000) {
@@ skipping 35 matching lines @@
               printf("Error: Couldn't allocate memory for Speex encoding "
                      "instance\n");
               exit(0);
             }
           } else {
             printf("\nError: Speex only supports 20, 40, and 60 ms!!\n\n");
             exit(0);
           }
           if ((vad == 1) && (enc_frameSize != 160)) {
             printf("\nError - This simulation only supports VAD for Speex at "
-                   "20ms packets (not %dms)\n",
+                   "20ms packets (not %" PRIuS "ms)\n",
                 (enc_frameSize >> 3));
             vad = 0;
           }
           ok = WebRtcSpeex_EncoderInit(SPEEX8enc_inst[k], 0 /*vbr*/,
                                        3 /*complexity*/, vad);
           if (ok != 0)
             exit(0);
         } else {
           printf("\nError - Speex8 called with sample frequency other than 8 "
                  "kHz.\n\n");
@@ skipping 10 matching lines @@
               printf("Error: Couldn't allocate memory for Speex encoding "
                      "instance\n");
               exit(0);
             }
           } else {
             printf("\nError: Speex only supports 20, 40, and 60 ms!!\n\n");
             exit(0);
           }
           if ((vad == 1) && (enc_frameSize != 320)) {
             printf("\nError - This simulation only supports VAD for Speex at "
-                   "20ms packets (not %dms)\n",
+                   "20ms packets (not %" PRIuS "ms)\n",
                 (enc_frameSize >> 4));
             vad = 0;
           }
           ok = WebRtcSpeex_EncoderInit(SPEEX16enc_inst[k], 0 /*vbr*/,
                                        3 /*complexity*/, vad);
           if (ok != 0)
             exit(0);
         } else {
           printf("\nError - Speex16 called with sample frequency other than 16 "
                  "kHz.\n\n");
@@ skipping 168 matching lines @@
 #endif
 #ifdef CODEC_AMRWB
       case webrtc::kDecoderAMRWB:
         if (sampfreq == 16000) {
           ok = WebRtcAmrWb_CreateEnc(&AMRWBenc_inst[k]);
           if (ok != 0) {
             printf("Error: Couldn't allocate memory for AMRWB encoding "
                    "instance\n");
             exit(0);
           }
-          if (((enc_frameSize / 320) < 0) || ((enc_frameSize / 320) > 3) ||
-              ((enc_frameSize % 320) != 0)) {
+          if (((enc_frameSize / 320) > 3) || ((enc_frameSize % 320) != 0)) {
             printf("\nError - AMRwb must have frameSize of 20, 40 or 60ms\n");
             exit(0);
           }
           WebRtcAmrWb_EncoderInit(AMRWBenc_inst[k], vad);
           if (bitrate == 7000) {
             AMRWB_bitrate = AMRWB_MODE_7k;
           } else if (bitrate == 9000) {
             AMRWB_bitrate = AMRWB_MODE_9k;
           } else if (bitrate == 12000) {
             AMRWB_bitrate = AMRWB_MODE_12k;
@@ skipping 60 matching lines @@
             printf("\nError - iSAC only supports frameSize (30 and 60 ms)\n");
             exit(0);
           }
           WebRtcIsac_EncoderInit(ISAC_inst[k], 1);
           if ((bitrate < 10000) || (bitrate > 32000)) {
             printf("\nError - iSAC bitrate has to be between 10000 and 32000 "
                    "bps (not %i)\n",
                 bitrate);
             exit(0);
           }
-          WebRtcIsac_Control(ISAC_inst[k], bitrate, enc_frameSize >> 4);
+          WebRtcIsac_Control(ISAC_inst[k], bitrate,
+                             static_cast<int>(enc_frameSize >> 4));
         } else {
           printf("\nError - iSAC only supports 480 or 960 enc_frameSize (30 or "
                  "60 ms)\n");
           exit(0);
         }
         break;
 #endif
 #ifdef NETEQ_ISACFIX_CODEC
       case webrtc::kDecoderISAC:
         if (sampfreq == 16000) {
@@ skipping 38 matching lines @@
           if (ok != 0) {
             printf("Error: Couldn't set sample rate for iSAC SWB instance\n");
             exit(0);
           }
           WebRtcIsac_EncoderInit(ISACSWB_inst[k], 1);
           if ((bitrate < 32000) || (bitrate > 56000)) {
             printf("\nError - iSAC SWB bitrate has to be between 32000 and "
                    "56000 bps (not %i)\n", bitrate);
             exit(0);
           }
-          WebRtcIsac_Control(ISACSWB_inst[k], bitrate, enc_frameSize >> 5);
+          WebRtcIsac_Control(ISACSWB_inst[k], bitrate,
+                             static_cast<int>(enc_frameSize >> 5));
         } else {
           printf("\nError - iSAC SWB only supports 960 enc_frameSize (30 "
                  "ms)\n");
           exit(0);
         }
         break;
 #endif
 #ifdef CODEC_GSMFR
       case webrtc::kDecoderGSMFR:
         if (sampfreq == 8000) {
@@ skipping 24 matching lines @@
     }
 
     if (ok != 0) {
       return (ok);
     }
   }  // end for
 
   return (0);
 }
 
-int NetEQTest_free_coders(webrtc::NetEqDecoder coder, int numChannels) {
-  for (int k = 0; k < numChannels; k++) {
+int NetEQTest_free_coders(webrtc::NetEqDecoder coder, size_t numChannels) {
+  for (size_t k = 0; k < numChannels; k++) {
     WebRtcVad_Free(VAD_inst[k]);
 #if (defined(CODEC_CNGCODEC8) || defined(CODEC_CNGCODEC16) || \
      defined(CODEC_CNGCODEC32) || defined(CODEC_CNGCODEC48))
     WebRtcCng_FreeEnc(CNGenc_inst[k]);
 #endif
 
     switch (coder) {
 #ifdef CODEC_PCM16B
       case webrtc::kDecoderPCM16B:
 #endif
@@ skipping 106 matching lines @@
       default:
         printf("Error: unknown codec in call to NetEQTest_init_coders.\n");
         exit(0);
         break;
     }
   }
 
   return (0);
 }
 
-int NetEQTest_encode(int coder,
-                     int16_t* indata,
-                     int frameLen,
-                     unsigned char* encoded,
-                     int sampleRate,
-                     int* vad,
-                     int useVAD,
-                     int bitrate,
-                     int numChannels) {
-  int cdlen = 0;
+size_t NetEQTest_encode(int coder,
+                        int16_t* indata,
+                        size_t frameLen,
+                        unsigned char* encoded,
+                        int sampleRate,
+                        int* vad,
+                        int useVAD,
+                        int bitrate,
+                        size_t numChannels) {
+  size_t cdlen = 0;
   int16_t* tempdata;
   static int first_cng = 1;
-  int16_t tempLen;
-
+  size_t tempLen;
   *vad = 1;
 
   // check VAD first
   if (useVAD) {
     *vad = 0;
 
-    int sampleRate_10 = 10 * sampleRate / 1000;
-    int sampleRate_20 = 20 * sampleRate / 1000;
-    int sampleRate_30 = 30 * sampleRate / 1000;
-    for (int k = 0; k < numChannels; k++) {
+    size_t sampleRate_10 = static_cast<size_t>(10 * sampleRate / 1000);
+    size_t sampleRate_20 = static_cast<size_t>(20 * sampleRate / 1000);
+    size_t sampleRate_30 = static_cast<size_t>(30 * sampleRate / 1000);
+    for (size_t k = 0; k < numChannels; k++) {
       tempLen = frameLen;
       tempdata = &indata[k * frameLen];
       int localVad = 0;
       /* Partition the signal and test each chunk for VAD.
-      All chunks must be VAD=0 to produce a total VAD=0. */
+         All chunks must be VAD=0 to produce a total VAD=0. */
       while (tempLen >= sampleRate_10) {
         if ((tempLen % sampleRate_30) == 0) {  // tempLen is multiple of 30ms
           localVad |= WebRtcVad_Process(VAD_inst[k], sampleRate, tempdata,
                                         sampleRate_30);
           tempdata += sampleRate_30;
           tempLen -= sampleRate_30;
         } else if (tempLen >= sampleRate_20) {  // tempLen >= 20ms
           localVad |= WebRtcVad_Process(VAD_inst[k], sampleRate, tempdata,
                                         sampleRate_20);
           tempdata += sampleRate_20;
           tempLen -= sampleRate_20;
         } else {  // use 10ms
           localVad |= WebRtcVad_Process(VAD_inst[k], sampleRate, tempdata,
                                         sampleRate_10);
           tempdata += sampleRate_10;
           tempLen -= sampleRate_10;
         }
       }
 
       // aggregate all VAD decisions over all channels
       *vad |= localVad;
     }
 
     if (!*vad) {
       // all channels are silent
       cdlen = 0;
-      for (int k = 0; k < numChannels; k++) {
+      for (size_t k = 0; k < numChannels; k++) {
         WebRtcCng_Encode(CNGenc_inst[k], &indata[k * frameLen],
                          (frameLen <= 640 ? frameLen : 640) /* max 640 */,
                          encoded, &tempLen, first_cng);
         encoded += tempLen;
         cdlen += tempLen;
       }
       *vad = 0;
       first_cng = 0;
       return (cdlen);
     }
   }
 
   // loop over all channels
-  int totalLen = 0;
+  size_t totalLen = 0;
 
-  for (int k = 0; k < numChannels; k++) {
+  for (size_t k = 0; k < numChannels; k++) {
     /* Encode with the selected coder type */
     if (coder == webrtc::kDecoderPCMu) { /*g711 u-law */
 #ifdef CODEC_G711
       cdlen = WebRtcG711_EncodeU(indata, frameLen, encoded);
 #endif
     } else if (coder == webrtc::kDecoderPCMa) { /*g711 A-law */
 #ifdef CODEC_G711
       cdlen = WebRtcG711_EncodeA(indata, frameLen, encoded);
     }
 #endif
 #ifdef CODEC_PCM16B
     else if ((coder == webrtc::kDecoderPCM16B) ||
              (coder == webrtc::kDecoderPCM16Bwb) ||
              (coder == webrtc::kDecoderPCM16Bswb32kHz) ||
              (coder == webrtc::
                            kDecoderPCM16Bswb48kHz)) { /*pcm16b (8kHz, 16kHz,
                                                          32kHz or 48kHz) */
       cdlen = WebRtcPcm16b_Encode(indata, frameLen, encoded);
     }
 #endif
 #ifdef CODEC_G722
     else if (coder == webrtc::kDecoderG722) { /*g722 */
       cdlen = WebRtcG722_Encode(g722EncState[k], indata, frameLen, encoded);
       assert(cdlen == frameLen >> 1);
     }
 #endif
 #ifdef CODEC_ILBC
     else if (coder == webrtc::kDecoderILBC) { /*iLBC */
-      cdlen = WebRtcIlbcfix_Encode(iLBCenc_inst[k], indata, frameLen, encoded);
+      cdlen = static_cast<size_t>(std::max(
+          WebRtcIlbcfix_Encode(iLBCenc_inst[k], indata, frameLen, encoded), 0));
     }
 #endif
 #if (defined(CODEC_ISAC) || \
      defined(NETEQ_ISACFIX_CODEC))            // TODO(hlundin): remove all
                                               // NETEQ_ISACFIX_CODEC
     else if (coder == webrtc::kDecoderISAC) { /*iSAC */
       int noOfCalls = 0;
-      cdlen = 0;
-      while (cdlen <= 0) {
+      int res = 0;
+      while (res <= 0) {
 #ifdef CODEC_ISAC /* floating point */
-        cdlen =
+        res =
             WebRtcIsac_Encode(ISAC_inst[k], &indata[noOfCalls * 160], encoded);
 #else /* fixed point */
-        cdlen = WebRtcIsacfix_Encode(ISAC_inst[k], &indata[noOfCalls * 160],
-                                     encoded);
+        res = WebRtcIsacfix_Encode(ISAC_inst[k], &indata[noOfCalls * 160],
+                                   encoded);
 #endif
         noOfCalls++;
       }
+      cdlen = static_cast<size_t>(res);
     }
 #endif
 #ifdef CODEC_ISAC_SWB
     else if (coder == webrtc::kDecoderISACswb) { /* iSAC SWB */
       int noOfCalls = 0;
-      cdlen = 0;
-      while (cdlen <= 0) {
-        cdlen = WebRtcIsac_Encode(ISACSWB_inst[k], &indata[noOfCalls * 320],
-                                  encoded);
+      int res = 0;
+      while (res <= 0) {
+        res = WebRtcIsac_Encode(ISACSWB_inst[k], &indata[noOfCalls * 320],
+                                encoded);
         noOfCalls++;
       }
+      cdlen = static_cast<size_t>(res);
     }
 #endif
     indata += frameLen;
     encoded += cdlen;
     totalLen += cdlen;
 
   }  // end for
 
   first_cng = 1;
   return (totalLen);
@@ skipping 55 matching lines @@
 
   // Bit  |0|1234567|
   //      |0|payload|
   //      | |  type |
   rtpPointer[0] = payloadType[numPayloads - 1] & 0x7F;
   ++rtpPointer;
 
   return rtpPointer - rtp_data;  // length of header in bytes
 }
 
-int makeDTMFpayload(unsigned char* payload_data,
-                    int Event,
-                    int End,
-                    int Volume,
-                    int Duration) {
+size_t makeDTMFpayload(unsigned char* payload_data,
+                       int Event,
+                       int End,
+                       int Volume,
+                       int Duration) {
   unsigned char E, R, V;
   R = 0;
   V = (unsigned char)Volume;
   if (End == 0) {
     E = 0x00;
   } else {
     E = 0x80;
   }
   payload_data[0] = (unsigned char)Event;
   payload_data[1] = (unsigned char)(E | R | V);
   // Duration equals 8 times time_ms, default is 8000 Hz.
   payload_data[2] = (unsigned char)((Duration >> 8) & 0xFF);
   payload_data[3] = (unsigned char)(Duration & 0xFF);
   return (4);
 }
 
-void stereoDeInterleave(int16_t* audioSamples, int numSamples) {
+void stereoDeInterleave(int16_t* audioSamples, size_t numSamples) {
   int16_t* tempVec;
   int16_t* readPtr, *writeL, *writeR;
 
-  if (numSamples <= 0)
+  if (numSamples == 0)
     return;
 
   tempVec = (int16_t*)malloc(sizeof(int16_t) * numSamples);
   if (tempVec == NULL) {
     printf("Error allocating memory\n");
     exit(0);
   }
 
   memcpy(tempVec, audioSamples, numSamples * sizeof(int16_t));
 
   writeL = audioSamples;
   writeR = &audioSamples[numSamples / 2];
   readPtr = tempVec;
 
-  for (int k = 0; k < numSamples; k += 2) {
+  for (size_t k = 0; k < numSamples; k += 2) {
     *writeL = *readPtr;
     readPtr++;
     *writeR = *readPtr;
     readPtr++;
     writeL++;
     writeR++;
   }
 
   free(tempVec);
 }
 
-void stereoInterleave(unsigned char* data, int dataLen, int stride) {
+void stereoInterleave(unsigned char* data, size_t dataLen, size_t stride) {
   unsigned char* ptrL, *ptrR;
   unsigned char temp[10];
 
   if (stride > 10) {
     exit(0);
   }
 
   if (dataLen % 1 != 0) {
     // must be even number of samples
     printf("Error: cannot interleave odd sample number\n");
@@ skipping 11 matching lines @@
     memmove(ptrL + stride, ptrL, ptrR - ptrL);
 
     // copy from temp to left pointer
     memcpy(ptrL, temp, stride);
 
     // advance pointers
     ptrL += stride * 2;
     ptrR += stride;
   }
 }