Avoid overflow in WebRtcSpl_Sqrt

webrtc/common_audio/signal_processing/spl_sqrt.c

 /*
  *  Copyright (c) 2011 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 121 matching lines @@
 
      */
 
     int16_t x_norm, nshift, t16, sh;
     int32_t A;
 
     int16_t k_sqrt_2 = 23170; // 1/sqrt2 (==5a82)
 
     A = value;
 
+    // The convention in this function is to calculate sqrt(abs(A)). Negate the
+    // input if it is negative.
+    if (A == WEBRTC_SPL_WORD32_MIN) {
+        // This number cannot be held in an int32_t after negating.
+        // Map it to the maximum positive value.
+        A = WEBRTC_SPL_WORD32_MAX;
+    } else if (A < 0) {
+        A = -A;
+    }

[kwiberg-webrtc, 2016/02/11 09:28:10]

The optimizer may already be doing this for you, but it might not be a bad idea
to hide the most uncommon condition (WORD32_MIN) behind the less uncommon one
(negative). Also, you can avoid loss of precision by the decrement if you simply
return the correct result:

if (A < 0) {
  if (A == WEBRTC_SPL_WORD32_MIN) {
    COMPILE_ASSERT(WEBRTC_SPL_WORD32_MIN == -2147483648);
    return 46341;  // sqrt(2147483648) = 46340.950012...
  }
  A = -A;
} else if (A == 0) {
  return 0;  // sqrt(0) = 0
}

[hlundin-webrtc, 2016/02/11 22:02:29]

Much better. Done.

+
     if (A == 0)
         return (int32_t)0; // sqrt(0) = 0
 
     sh = WebRtcSpl_NormW32(A); // # shifts to normalize A
     A = WEBRTC_SPL_LSHIFT_W32(A, sh); // Normalize A
     if (A < (WEBRTC_SPL_WORD32_MAX - 32767))
     {
         A = A + ((int32_t)32768); // Round off bit
     } else
     {
@@ skipping 23 matching lines @@
     } else
     {
         A >>= 16;  // A = A>>16
     }
 
     A = A & ((int32_t)0x0000ffff);
     A >>= nshift;  // De-normalize the result.
 
     return A;
 }