Avoid overflow in WebRtcSpl_DotProductWithScale

webrtc/common_audio/signal_processing/include/signal_processing_library.h

 /*
  *  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.
  */
 
 
 /*
  * This header file includes all of the fix point signal processing library (SPL) function
  * descriptions and declarations.
  * For specific function calls, see bottom of file.
  */
 
 #ifndef WEBRTC_SPL_SIGNAL_PROCESSING_LIBRARY_H_
 #define WEBRTC_SPL_SIGNAL_PROCESSING_LIBRARY_H_
 
 #include <string.h>
+#include "webrtc/common_audio/signal_processing/dot_product_with_scale.h"
 #include "webrtc/typedefs.h"
 
 // Macros specific for the fixed point implementation
 #define WEBRTC_SPL_WORD16_MAX       32767
 #define WEBRTC_SPL_WORD16_MIN       -32768
 #define WEBRTC_SPL_WORD32_MAX       (int32_t)0x7fffffff
 #define WEBRTC_SPL_WORD32_MIN       (int32_t)0x80000000
 #define WEBRTC_SPL_MAX_LPC_ORDER    14
 #define WEBRTC_SPL_MIN(A, B)        (A < B ? A : B)  // Get min value
 #define WEBRTC_SPL_MAX(A, B)        (A > B ? A : B)  // Get max value
@@ skipping 569 matching lines @@
 //
 // Input:
 //      - vector1       : Vector 1
 //      - vector2       : Vector 2
 //      - vector_length : Number of samples used in the dot product
 //      - scaling       : The number of right bit shifts to apply on each term
 //                        during calculation to avoid overflow, i.e., the
 //                        output will be in Q(-|scaling|)
 //
 // Return value         : The dot product in Q(-scaling)
-int32_t WebRtcSpl_DotProductWithScale(const int16_t* vector1,
-                                      const int16_t* vector2,
-                                      size_t length,
-                                      int scaling);
+// int32_t WebRtcSpl_DotProductWithScale(const int16_t* vector1,

[hlundin-webrtc, 2017/02/28 12:35:17]

The declaration is intentionally left in this file. I think this is the pattern
used here, so that this file serves as the master catalog for SPL functions.

[kwiberg-webrtc, 2017/02/28 12:51:01]

I think this is a bad idea. It's just a question of time before this comment and
the real declaration diverge.

This is a job for doxygen or something similar.

[hlundin-webrtc, 2017/03/06 12:43:26]

Would you like me to keep lines 601--611 in this file?

[kwiberg-webrtc, 2017/03/06 14:35:50]

I would prefer that you delete WebRtcSpl_DotProductWithScale entirely from this
file and have it just in the new header. Having it just in this file is still
better than duplicating the information, though. Duplication is a public health
hazard...

Oh, but wait. If you keep it here, you'll need to make this header part of both
build targets. (You can't put it in just one and have a dep for the other,
because you'll end up with circular deps.) If that's OK, you can keep the
declaration here. Otherwise, my recommendation is the usual 1:1 relationship
between .h and .cc files...

[hlundin-webrtc, 2017/03/06 15:44:23]

Done.

+//                                       const int16_t* vector2,
+//                                       size_t length,
+//                                       int scaling);
 
 // Filter operations.
 size_t WebRtcSpl_FilterAR(const int16_t* ar_coef,
                           size_t ar_coef_length,
                           const int16_t* in_vector,
                           size_t in_vector_length,
                           int16_t* filter_state,
                           size_t filter_state_length,
                           int16_t* filter_state_low,
                           size_t filter_state_low_length,
@@ skipping 1008 matching lines @@
 // This function multiply a 16-bit word by a 16-bit word, and accumulate this
 // value to a 32-bit integer.
 //
 // Input:
 //      - a    : The value of the first 16-bit word.
 //      - b    : The value of the second 16-bit word.
 //      - c    : The value of an 32-bit integer.
 //
 // Return Value: The value of a * b + c.
 //