Fix division by zero in FindTMMBRBoundingSet

webrtc/modules/rtp_rtcp/source/tmmbr_help.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.
  */
 
 #include "webrtc/modules/rtp_rtcp/source/tmmbr_help.h"
 
 #include <assert.h>
 #include <string.h>
 
 #include <limits>
 
+#include "webrtc/base/checks.h"
 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_config.h"
 
 namespace webrtc {
 TMMBRSet::TMMBRSet() :
     _sizeOfSet(0),
     _lengthOfSet(0)
 {
 }
 
 TMMBRSet::~TMMBRSet()
@@ skipping 265 matching lines @@
                     }
                 }
             }
             // keep lowest bitrate
             for (uint32_t j = 0; j < candidateSet.sizeOfSet(); j++)
             {
               if(candidateSet.PacketOH(j) == currentPacketOH
                   && j != currentMinIndexTMMBR)
                 {
                     candidateSet.ClearEntry(j);
+                    numCandidates--;
                 }
             }
         }
     }
     // 3. Select and remove tuple w/ lowest tmmbr.
     // (If more than 1, choose the one w/ highest OH).
     uint32_t minTMMBR = 0;
     uint32_t minIndexTMMBR = 0;
     for (uint32_t i = 0; i < candidateSet.sizeOfSet(); i++)
     {
@@ skipping 16 matching lines @@
     }
     // first member of selected list
     _boundingSet.SetEntry(numBoundingSet,
                           candidateSet.Tmmbr(minIndexTMMBR),
                           candidateSet.PacketOH(minIndexTMMBR),
                           candidateSet.Ssrc(minIndexTMMBR));
 
     // set intersection value
     _ptrIntersectionBoundingSet[numBoundingSet] = 0;
     // calculate its maximum packet rate (where its line crosses x-axis)
-    _ptrMaxPRBoundingSet[numBoundingSet]
-        = _boundingSet.Tmmbr(numBoundingSet) * 1000
-        / float(8 * _boundingSet.PacketOH(numBoundingSet));
+    uint32_t packet_overhead_bits = 8 * _boundingSet.PacketOH(numBoundingSet);
+    if (packet_overhead_bits == 0) {
+      // Avoid division by zero.
+      _ptrMaxPRBoundingSet[numBoundingSet] = std::numeric_limits<float>::max();
+    } else {
+      _ptrMaxPRBoundingSet[numBoundingSet] =
+          _boundingSet.Tmmbr(numBoundingSet) * 1000 /
+          static_cast<float>(packet_overhead_bits);
+    }
     numBoundingSet++;
     // remove from candidate list
     candidateSet.ClearEntry(minIndexTMMBR);
     numCandidates--;
 
     // 4. Discard from candidate list all tuple w/ lower OH
     // (next tuple must be steeper)
     for (uint32_t i = 0; i < candidateSet.sizeOfSet(); i++)
     {
         if(candidateSet.Tmmbr(i) > 0
             && candidateSet.PacketOH(i) < _boundingSet.PacketOH(0))
         {
             candidateSet.ClearEntry(i);
             numCandidates--;
         }
     }
 
     if (numCandidates == 0)
     {
         // Should be true already:_boundingSet.lengthOfSet = numBoundingSet;
         assert(_boundingSet.lengthOfSet() == numBoundingSet);
         return numBoundingSet;
     }
 
     bool getNewCandidate = true;
-    int curCandidateTMMBR = 0;
-    int curCandidateIndex = 0;
-    int curCandidatePacketOH = 0;
-    int curCandidateSSRC = 0;
+    uint32_t curCandidateTMMBR = 0;
+    size_t curCandidateIndex = 0;
+    uint32_t curCandidatePacketOH = 0;
+    uint32_t curCandidateSSRC = 0;
     do
     {
         if (getNewCandidate)
         {
             // 5. Remove first remaining tuple from candidate list
             for (uint32_t i = 0; i < candidateSet.sizeOfSet(); i++)
             {
                 if (candidateSet.Tmmbr(i) > 0)
                 {
                     curCandidateTMMBR    = candidateSet.Tmmbr(i);
                     curCandidatePacketOH = candidateSet.PacketOH(i);
                     curCandidateSSRC     = candidateSet.Ssrc(i);
                     curCandidateIndex    = i;
                     candidateSet.ClearEntry(curCandidateIndex);
                     break;
                 }
             }
         }
 
         // 6. Calculate packet rate and intersection of the current
         // line with line of last tuple in selected list
+        RTC_DCHECK_NE(curCandidatePacketOH,
+                      _boundingSet.PacketOH(numBoundingSet - 1));
         float packetRate
             = float(curCandidateTMMBR
                     - _boundingSet.Tmmbr(numBoundingSet-1))*1000
             / (8*(curCandidatePacketOH
                   - _boundingSet.PacketOH(numBoundingSet-1)));
 
         // 7. If the packet rate is equal or lower than intersection of
         //    last tuple in selected list,
         //    remove last tuple in selected list & go back to step 6
         if(packetRate <= _ptrIntersectionBoundingSet[numBoundingSet-1])
         {
             // remove last tuple and goto step 6
             numBoundingSet--;
             _boundingSet.ClearEntry(numBoundingSet);
             _ptrIntersectionBoundingSet[numBoundingSet] = 0;
             _ptrMaxPRBoundingSet[numBoundingSet]        = 0;
             getNewCandidate = false;
         } else
         {
             // 8. If packet rate is lower than maximum packet rate of
             // last tuple in selected list, add current tuple to selected
             // list
             if (packetRate < _ptrMaxPRBoundingSet[numBoundingSet-1])
             {
                 _boundingSet.SetEntry(numBoundingSet,
                                       curCandidateTMMBR,
                                       curCandidatePacketOH,
                                       curCandidateSSRC);
                 _ptrIntersectionBoundingSet[numBoundingSet] = packetRate;
-                _ptrMaxPRBoundingSet[numBoundingSet]
-                    = _boundingSet.Tmmbr(numBoundingSet)*1000
-                    / float(8*_boundingSet.PacketOH(numBoundingSet));
+                float packet_overhead_bits =
+                    8 * _boundingSet.PacketOH(numBoundingSet);
+                RTC_DCHECK_NE(packet_overhead_bits, 0.0f);
+                _ptrMaxPRBoundingSet[numBoundingSet] =
+                    _boundingSet.Tmmbr(numBoundingSet) * 1000 /
+                    packet_overhead_bits;
                 numBoundingSet++;
             }
             numCandidates--;
             getNewCandidate = true;
         }
 
         // 9. Go back to step 5 if any tuple remains in candidate list
     } while (numCandidates > 0);
 
     return numBoundingSet;
@@ skipping 29 matching lines @@
     uint32_t curNetBitRateKbit = _candidateSet.Tmmbr(i);
     if (curNetBitRateKbit < MIN_VIDEO_BW_MANAGEMENT_BITRATE) {
       curNetBitRateKbit = MIN_VIDEO_BW_MANAGEMENT_BITRATE;
     }
     *minBitrateKbit = curNetBitRateKbit < *minBitrateKbit ?
         curNetBitRateKbit : *minBitrateKbit;
   }
   return true;
 }
 }  // namespace webrtc