Fix UBSan errors (left shift on negative value)

webrtc/modules/audio_processing/agc/legacy/digital_agc.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 99 matching lines @@
     {
         assert(0);
         return -1;
     }
 
     // Calculate the limiter level and index:
     //  limiterLvlX = analogTarget - limiterOffset
     //  limiterLvl  = targetLevelDbfs + limiterOffset/compRatio
     limiterLvlX = analogTarget - limiterOffset;
     limiterIdx =
-        2 + WebRtcSpl_DivW32W16ResW16((int32_t)limiterLvlX << 13, kLog10_2 / 2);
+        2 + WebRtcSpl_DivW32W16ResW16((int32_t)limiterLvlX * (1 << 13),
+                                      kLog10_2 / 2);
     tmp16no1 = WebRtcSpl_DivW32W16ResW16(limiterOffset + (kCompRatio >> 1), kCompRatio);
     limiterLvl = targetLevelDbfs + tmp16no1;
 
     // Calculate (through table lookup):
     //  constMaxGain = log2(1+2^(log2(e)*diffGain)); (in Q8)
     constMaxGain = kGenFuncTable[diffGain]; // in Q8
 
     // Calculate a parameter used to approximate the fractional part of 2^x with a
     // piecewise linear function in Q14:
     //  constLinApprox = round(3/2*(4*(3-2*sqrt(2))/(log(2)^2)-0.5)*2^14);
     constLinApprox = 22817; // in Q14
 
     // Calculate a denominator used in the exponential part to convert from dB to linear scale:
     //  den = 20*constMaxGain (in Q8)
     den = WEBRTC_SPL_MUL_16_U16(20, constMaxGain); // in Q8
 
     for (i = 0; i < 32; i++)
     {
         // Calculate scaled input level (compressor):
         //  inLevel = fix((-constLog10_2*(compRatio-1)*(1-i)+fix(compRatio/2))/compRatio)
         tmp16 = (int16_t)((kCompRatio - 1) * (i - 1));  // Q0
         tmp32 = WEBRTC_SPL_MUL_16_U16(tmp16, kLog10_2) + 1; // Q14
         inLevel = WebRtcSpl_DivW32W16(tmp32, kCompRatio); // Q14
 
         // Calculate diffGain-inLevel, to map using the genFuncTable
-        inLevel = ((int32_t)diffGain << 14) - inLevel;  // Q14
+        inLevel = (int32_t)diffGain * (1 << 14) - inLevel;  // Q14
 
         // Make calculations on abs(inLevel) and compensate for the sign afterwards.
         absInLevel = (uint32_t)WEBRTC_SPL_ABS_W32(inLevel); // Q14
 
         // LUT with interpolation
         intPart = (uint16_t)(absInLevel >> 14);
         fracPart = (uint16_t)(absInLevel & 0x00003FFF); // extract the fractional part
         tmpU16 = kGenFuncTable[intPart + 1] - kGenFuncTable[intPart]; // Q8
         tmpU32no1 = tmpU16 * fracPart;  // Q22
         tmpU32no1 += (uint32_t)kGenFuncTable[intPart] << 14;  // Q22
@@ skipping 21 matching lines @@
             {
                 tmpU32no2 = WEBRTC_SPL_UMUL_32_16(absInLevel, kLogE_1); // Q28
                 tmpU32no2 >>= 6;  // Q22
             }
             logApprox = 0;
             if (tmpU32no2 < tmpU32no1)
             {
                 logApprox = (tmpU32no1 - tmpU32no2) >> (8 - zerosScale);  //Q14
             }
         }
-        numFIX = (maxGain * constMaxGain) << 6;  // Q14
+        numFIX = (maxGain * constMaxGain) * (1 << 6);  // Q14
         numFIX -= (int32_t)logApprox * diffGain;  // Q14
 
         // Calculate ratio
         // Shift |numFIX| as much as possible.
         // Ensure we avoid wrap-around in |den| as well.
         if (numFIX > (den >> 8))  // |den| is Q8.
         {
             zeros = WebRtcSpl_NormW32(numFIX);
         } else
         {
             zeros = WebRtcSpl_NormW32(den) + 8;
         }
-        numFIX <<= zeros;  // Q(14+zeros)
+        numFIX *= 1 << zeros;  // Q(14+zeros)
 
         // Shift den so we end up in Qy1
         tmp32no1 = WEBRTC_SPL_SHIFT_W32(den, zeros - 8); // Q(zeros)
         if (numFIX < 0)
         {
             numFIX -= tmp32no1 / 2;
         } else
         {
             numFIX += tmp32no1 / 2;
         }
         y32 = numFIX / tmp32no1;  // in Q14
         if (limiterEnable && (i < limiterIdx))
         {
             tmp32 = WEBRTC_SPL_MUL_16_U16(i - 1, kLog10_2); // Q14
-            tmp32 -= limiterLvl << 14;  // Q14
+            tmp32 -= limiterLvl * (1 << 14);  // Q14
             y32 = WebRtcSpl_DivW32W16(tmp32 + 10, 20);
         }
         if (y32 > 39000)
         {
             tmp32 = (y32 >> 1) * kLog10 + 4096;  // in Q27
             tmp32 >>= 13;  // In Q14.
         } else
         {
             tmp32 = y32 * kLog10 + 8192;  // in Q28
             tmp32 >>= 14;  // In Q14.
@@ skipping 325 matching lines @@
         if (gains[k] > gains[k + 1])
         {
             gains[k] = gains[k + 1];
         }
     }
     // save start gain for next frame
     stt->gain = gains[10];
 
     // Apply gain
     // handle first sub frame separately
-    delta = (gains[1] - gains[0]) << (4 - L2);
-    gain32 = gains[0] << 4;
+    delta = (gains[1] - gains[0]) * (1 << (4 - L2));
+    gain32 = gains[0] * (1 << 4);
     // iterate over samples
     for (n = 0; n < L; n++)
     {
         for (i = 0; i < num_bands; ++i)
         {
             tmp32 = out[i][n] * ((gain32 + 127) >> 7);
             out_tmp = tmp32 >> 16;
             if (out_tmp > 4095)
             {
                 out[i][n] = (int16_t)32767;
             } else if (out_tmp < -4096)
             {
                 out[i][n] = (int16_t)-32768;
             } else
             {
                 tmp32 = out[i][n] * (gain32 >> 4);
                 out[i][n] = (int16_t)(tmp32 >> 16);
             }
         }
         //
 
         gain32 += delta;
     }
     // iterate over subframes
     for (k = 1; k < 10; k++)
     {
-        delta = (gains[k+1] - gains[k]) << (4 - L2);
-        gain32 = gains[k] << 4;
+        delta = (gains[k+1] - gains[k]) * (1 << (4 - L2));
+        gain32 = gains[k] * (1 << 4);
         // iterate over samples
         for (n = 0; n < L; n++)
         {
             for (i = 0; i < num_bands; ++i)
             {
                 tmp32 = out[i][k * L + n] * (gain32 >> 4);
                 out[i][k * L + n] = (int16_t)(tmp32 >> 16);
             }
             gain32 += delta;
         }
@@ skipping 161 matching lines @@
     {
         state->logRatio = 2048;
     }
     if (state->logRatio < -2048)
     {
         state->logRatio = -2048;
     }
 
     return state->logRatio; // Q10
 }