Miscellaneous changes split from https://codereview.webrtc.org/1230503003 .

webrtc/modules/audio_coding/neteq/test/RTPencode.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.
  */
 
@@ skipping 436 matching lines @@
   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);
      return -1;
   }
-  printf("Packet size: %i\n", packet_size);
+  printf("Packet size: %d\n", packet_size);
 
   // 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 1097 matching lines @@
   int16_t* tempdata;
   static int first_cng = 1;
   int16_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++) {
       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. */
-      while (tempLen >= 10 * sampleRate / 1000) {
-        if ((tempLen % 30 * sampleRate / 1000) ==
-            0) {  // tempLen is multiple of 30ms
+      while (tempLen >= sampleRate_10) {
+        if ((tempLen % sampleRate_30) == 0) {  // tempLen is multiple of 30ms

[kwiberg-webrtc, 2015/07/12 18:40:30]

I don't think this means the same thing as the old code. % and * and / have the
same precedence.

Hmm. But the comment indicates that the new code is how it was supposed to work.
Does the test succeed both with the old and the new code?

[Peter Kasting, 2015/07/13 02:41:24]

Yes.  Which suggests the test is insufficient, since if the old code functions
differently I think it must be wrong.

[Peter Kasting, 2015/07/13 22:25:04]

It looks to me as if the behavior of this code will differ in cases where the
packet size provided on the command line is a multiple of 30, but not a multiple
of (30 * sampleRate / 1000).  So for sampleRate == 10000, for example, a packet
size of 300 will behave the same as before, but 330 will not.

So the question is whether this test was ever being run with command-line
arguments that exercised that difference.  My guess is no, and thus the bug in
the old code was never detected.

[kwiberg-webrtc, 2015/07/15 01:10:53]

OK. As long as it doesn't break the test, it can hardly be a change for the
worse.

           localVad |= WebRtcVad_Process(VAD_inst[k], sampleRate, tempdata,
-                                        30 * sampleRate / 1000);
-          tempdata += 30 * sampleRate / 1000;
-          tempLen -= 30 * sampleRate / 1000;
-        } else if (tempLen >= 20 * sampleRate / 1000) {  // tempLen >= 20ms
+                                        sampleRate_30);
+          tempdata += sampleRate_30;
+          tempLen -= sampleRate_30;
+        } else if (tempLen >= sampleRate_20) {  // tempLen >= 20ms
           localVad |= WebRtcVad_Process(VAD_inst[k], sampleRate, tempdata,
-                                        20 * sampleRate / 1000);
-          tempdata += 20 * sampleRate / 1000;
-          tempLen -= 20 * sampleRate / 1000;
+                                        sampleRate_20);
+          tempdata += sampleRate_20;
+          tempLen -= sampleRate_20;
         } else {  // use 10ms
           localVad |= WebRtcVad_Process(VAD_inst[k], sampleRate, tempdata,
-                                        10 * sampleRate / 1000);
-          tempdata += 10 * sampleRate / 1000;
-          tempLen -= 10 * sampleRate / 1000;
+                                        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;
@@ skipping 224 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;
   }
 }