Fixing a few tests for the upcoming Opus 1.2-alpha.

webrtc/modules/audio_coding/codecs/opus/opus_unittest.cc

 /*
  *  Copyright (c) 2013 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 626 matching lines @@
             static_cast<size_t>(WebRtcOpus_DurationEst(
                 opus_decoder_, bitstream_,
                 static_cast<size_t>(encoded_bytes_int))));
 
   // Free memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
 }
 
 TEST_P(OpusTest, OpusDecodeRepacketized) {
-  const int kPackets = 6;
+  constexpr size_t kPackets = 6;
 
   PrepareSpeechData(channels_, 20, 20 * kPackets);
 
   // Create encoder memory.
   ASSERT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
                                         channels_,
                                         application_));
   ASSERT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_,
                                         channels_));
 
   // Set bitrate.
   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_encoder_,
                                      channels_ == 1 ? 32000 : 64000));
 
   // Check number of channels for decoder.
   EXPECT_EQ(channels_, WebRtcOpus_DecoderChannels(opus_decoder_));
 
   // Encode & decode.
   int16_t audio_type;
   std::unique_ptr<int16_t[]> output_data_decode(
       new int16_t[kPackets * kOpus20msFrameSamples * channels_]);
   OpusRepacketizer* rp = opus_repacketizer_create();
 
-  for (int idx = 0; idx < kPackets; idx++) {
+  size_t num_packets = 0;
+  constexpr size_t kMaxCycles = 100;
+  for (size_t idx = 0; idx < kMaxCycles; ++idx) {
     auto speech_block = speech_data_.GetNextBlock();
     encoded_bytes_ =
         WebRtcOpus_Encode(opus_encoder_, speech_block.data(),
                           rtc::CheckedDivExact(speech_block.size(), channels_),
                           kMaxBytes, bitstream_);
-    EXPECT_EQ(OPUS_OK, opus_repacketizer_cat(rp, bitstream_, encoded_bytes_));
+    if (opus_repacketizer_cat(rp, bitstream_, encoded_bytes_) == OPUS_OK) {
+      ++num_packets;
+      if (num_packets == kPackets) {
+        break;
+      }
+    } else {
+      // Opus repacketizer cannot guarantee a success. We try again if it fails.
+      opus_repacketizer_init(rp);
+      num_packets = 0;
+    }
   }
+  EXPECT_EQ(kPackets, num_packets);
 
   encoded_bytes_ = opus_repacketizer_out(rp, bitstream_, kMaxBytes);
 
   EXPECT_EQ(kOpus20msFrameSamples * kPackets,
             static_cast<size_t>(WebRtcOpus_DurationEst(
                 opus_decoder_, bitstream_, encoded_bytes_)));
 
   EXPECT_EQ(kOpus20msFrameSamples * kPackets,
             static_cast<size_t>(WebRtcOpus_Decode(
                 opus_decoder_, bitstream_, encoded_bytes_,
                 output_data_decode.get(), &audio_type)));
 
   // Free memory.
   opus_repacketizer_destroy(rp);
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
 }
 
 INSTANTIATE_TEST_CASE_P(VariousMode,
                         OpusTest,
                         Combine(Values(1, 2), Values(0, 1)));
 
 
 }  // namespace webrtc