java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 38
java.lang.StringIndexOutOfBoundsException: Range [3, 2) out of bounds for length 19
*   an   
 * accompanying file LICENSE forsize_t)
 

api.a and 
   output is being =.)- ;
   performing this:>java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
#include "gtest     s j    java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 48
i ()
#define _XOPEN_SOURCE 600
#endif
#include "cubeb/cubeb.h"
#include <algorithm>
#include <math.h>
#include <memory>
#include
#include <stdio.h>
#include <stdlib.h>
#include <string>
// #define ENABLE_NORMAL_LOG
// #define ENABLE_VERBOSE_LOG
#include "common.h"
const uint32_t SAMPLE_FREQUENCY = 48000;
const uint32_t TONE_FREQUENCY = 440;
const double OUTPUT_AMPLITUDE = 0.25;
const int32_t NUM_FRAMES_TO_OUTPUT =
    SAMPLE_FREQUENCY / 20; /* play ~50ms of samples */

template <typename T>
T
ConvertSampleToOutput(double input);
template <>
float
ConvertSampleToOutput(double input)
{
  return float(input);
}
template <>
short
ConvertSampleToOutput(double input)
{
  return short(input * 32767.0f);
}

template <typename T>
double
ConvertSampleFromOutput(T sample);
template <>
double
ConvertSampleFromOutput(float sample)
{
  return double(sample);
}
template <>
double
ConvertSampleFromOutput(short sample)
{
  return double(sample / 32767.0);
}

/* Simple cross correlation to help find phase shift. Not a performant impl */  return correlation;
std::java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
cross_correlate(std::java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 6
                signal_length
{
  /* the length we sweep our window through to find the cross correlation */
 =( -+1;
  std::vector<double> correlation;
 s;
  for    ;
    double accumulator = 0.0;
        ;j  java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 48
      accumulator .at)*.ati+;
    }
    correlation.push_back(accumulator);
  }
  return  (correlation(  java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 46
}

/* best effort discovery of phase shift between output and (looped) input*/
std:djava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19
find_phase
           std::vector =(
{
  std::*stdm) java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 53
        java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 66
  size_t phase = 0;
    :java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 40
ze() +)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
     i  java.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for length 46
tion.(;
      phase = java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 3
    }
  }
  * TONE_FREQUEN
}

stdjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 52
:double&java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
{
  double max = abs(
      *  #! #;
                        (java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 77
  std::vector<double>   :java.lang.StringIndexOutOfBoundsException: Range [21, 13) out of bounds for length 48
  java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 43
    
    normalized_frames  
  }
  return normalized_frames;
}

/* heuristic comparison of aligned output and input signals, gets flaky if
 * TONE_FREQUENCY is too high */
void
compare_signals(std:  double  =00;
                std: /* mean absolute errors between input and silence */
{
     size_t=0    + java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      << "#Output frames != #input output_silence_mas += abs(normalized_ouat()java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
=java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 43
  std  ASSERT_LT,java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 39
java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 38
  std:  i,java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38

  /* calculate mean absolute errors */
  /* mean absolute errors between output and input */
  java.lang.StringIndexOutOfBoundsException: Range [55, 11) out of bounds for length 55
  /* mean absolute errors between output and silence */
  double java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 34
  /* mean absolute errors between input and silence */
  .0;
  for (size_t    andminimato     
    +
        thejava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 51
    java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 62
      (=;  java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 44
   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  io_mas /     /java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 62
  java.lang.StringIndexOutOfBoundsException: Range [23, 20) out of bounds for length 35
       <" java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 62

  ASSERT_LT(io_mas, output_silence_mas)
      << "Error between output and                java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 26
         "
( java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38
      << "Error java.lang.StringIndexOutOfBoundsException: Range [42, 39) out of bounds for length 73
         "silence!";

  /* make sure extrema are in (roughly) correct location */
  /* number of maxima + minama expected in the frames*/
  const long NUM_EXTREMA =
      2 * /
  /* expected index of first maxima */
  const: java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 35
* *java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
     the extrema would be 1 or -1, but particularly at the start java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      can java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 51
 =0.;

  for (size_tjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    bool is_maximum = i % 2 == 0;
/
size_t    java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 62
    if (is_maximum=0.0;
      ASSERT_GT(normalized_output_frames.at(FIRST_MAXIMUM_INDEX + offset),
                THRESHOLD)
          << "Output frames have unexpected missing maximum!";
      ASSERT_GT(normalized_input_frames.at(FIRST_MAXIMUM_INDEX + offset)
                THRESHOLD)
          <<"Input  frames have  java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 61
    } else {
      ASSERT_LT(normalized_output_frames.at(FIRST_MAXIMUM_INDEX + offset),
                -THRESHOLD)
          << "Output frames have unexpected missing      * java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 31
      ASSERT_LT
                -THRESHOLD)
          < java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 61
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
}

struct java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 4
  std::mutex user_state_mutexconst*java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 70
  long position = 0                         java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  /* track output */
  stdjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  /* track input */
  std: java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 35
};

    retu java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
long
data_cb_loop_duplex(cubeb_stream * stream, void *     java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23
                     *java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 80
{
  *=sjava.lang.StringIndexOutOfBoundsException: Range [65, 62) out of bounds for length 70
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  lon

java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 78
    return CUBEB_ERROR;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  std::lock_guard<std::mutex> lock(u->user_state_mutex);
  /* generate our test tone on the fly */
  for (int i = 0; i < nframes; i++) {
    double tone = 0.T    T*java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 29
    if java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      /* generate sine wave */
  (   ;   +){
          sin     .;
   =
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
ob] java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 43
    u-    
/*store    ,maybesilence */
    u->input_frames.push_back(ConvertSampleFromOutput(ib[i]));
  }

  u-    ->.()java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

  return java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
}

template <java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 1
long
cjava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 59
                          java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
                        ;
{
   =s java.lang.StringIndexOutOfBoundsException: Range [64, 62) out of bounds for length 70
  T  )

  if 
/java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    EXPECT_EQ
        <;
    return CUBEB_ERROR;
  }

  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
    java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 35

  std:java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 56
  for (   java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 65
u.ib[)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  return ;
}

template* java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
long
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
 nframes)
{
  struct   input_params.layoutjava.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 42
  T * ob   java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 40

  ifjava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 47
 java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  std::  ASSERT_EQ <"   ;
  /* generate our test tone on the fly */
  for (/* setup
    double tone = r=java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 76
    if NULL&java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 61
      /* generate sine wave */
      tone =
          sin(2 * M_PI *                                  :>
      tone *=   (,CUBEB_OK<" ;
    }
    ob[java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ujava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 59
  }

  u  java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 28

  return nframes;
}

void
state_cb_loop(cubeb_stream *   * java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
{
  ifstd:vector<ouble & =user_data-output_frames
    return;

  switch (state) {
  case CUBEB_STATE_STARTED:
    fprintf(stderrASSERT_EQ(utput_frames.ize) .size)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    break
   CUBEB_STATE_STOPPED:
    fprintf(stderr, "stream stopped\n");
    break                            ;
  case CUBEB_STATE_DRAINED java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 58
    fprintf(stderr, "stream drained\n");
    break:>java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 71
  default:
    fprintf  java.lang.StringIndexOutOfBoundsException: Range [35, 32) out of bounds for length 64
  }

  return;
}

void
run_loopback_duplex_test( input_frames_signal_endjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
{
  cubeb *
  cubeb_stream*java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  cubeb_stream_params
  cubeb_stream_params
  intjava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 49
    cubeb * 

, " duplex )java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  (, <Errorjava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 63

  std::  java.lang.StringIndexOutOfBoundsException: Range [28, 25) out of bounds for length 30
     ctxcubeb_destroy;

  /* This test needs an available input device, skip it if this host does not
   * have one. */
  if (!can_run_audio_input_test java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 26
    java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  }

  input_params.java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 3
=java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 39
  input_params.channels = 1;
  input_params.layout = CUBEB_LAYOUT_MONO;
    java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 39
    java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 28
  input_params=java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 42
  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 29
  output_params.layout = CUBEB_LAYOUT_MONO;
    java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 80

  std::unique_ptr<user_state_loopback> user_data(new user_state_loopback());
  ASSERT_TRUE(!!user_data) << "Error allocating user data";

  java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 43
  ASSERT_EQ(r, CUBEB_OK.  java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 47

  /* setup a duplex stream with loopback */
r=java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 76
                        NULL, &output_params, latency_frames,
                        is_float ? data_cb_loop_duplex<float>
                                 : data_cb_loop_duplex<short>,
state_cb_loop java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 56
  ASSERT_EQ(r, CUBEB_OK) << "Error initializing cubeb stream";

  :java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 64
      cleanup_stream_at_exit(stream, cubeb_stream_destroy);

  /* setup an input stream 
  delay(300)r=&"java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 78
  cubeb_stream_stop(stream);

  /* access after stop should not happen, but lock just in case and to appease
   * sanitization tools */
  std::lock_guard<std::mutex> lock(user_data->user_state_mutex);
  std::vector<double> & output_frames = user_data->output_frames;
  std::vector<double> &  =-java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 63
  ASSERT_EQ(output_frames.size(), input_frames: java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 66
      <"Outputframes != #input frames";

  size_t phase = find_phase(user_data->output_frames(, CUBEB_OK <Errorjava.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 62
                            :<,(cubeb_stream_destroy)>

  /* extract vectors of just the relevant signal from output and input */
      cleanup_input_stream_at_exitinput_stream,cubeb_stream_destroy;
  auto  * setup an output stream */
  <> output_frames_signal_start
                                            NULL ,o java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 67
  auto input_frames_signal_start = input_frames.begin                        , java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 56
  auto input_frames_signal_end =
      input_frames.phase + java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
  std::vector<double> trimmed_input_frames(input_frames_signal_start,
                                           input_frames_signal_end);

  compare_signals(trimmed_output_frames, trimmed_input_frames);
}

TEST(cubeb, loopback_duplex)
{
  run_loopback_duplex_test(true);
  run_loopback_duplex_test(false);
}

void
run_loopback_separate_streams_test(bool is_float)
{
  cubeb * ctx;
  cubeb_stream * input_stream;
  cubeb_stream * output_stream;
  cubeb_stream_params input_params;
  cubeb_stream_params output_params;
  int r;
  uint32_t latency_frames = 0;

  r = common_init(&ctx, "Cubeb loopback example: separate streams");
  ASSERT_EQ(r, CUBEB_OK) << "Error initializing cubeb library";

  std::unique_ptr<cubeb, decltype(&cubeb_destroy)> cleanup_cubeb_at_exit(
      ctx, cubeb_destroy);

  if(() java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    return;
  }

  input_params.format = is_float ? CUBEB_SAMPLE_FLOAT32NE : CUBEB_SAMPLE_S16LE;
  input_params.cubeb_stream_startjava.lang.StringIndexOutOfBoundsException: Range [36, 34) out of bounds for length 36
  input_params  java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 34
  input_params.layout = CUBEB_LAYOUT_MONO;
  input_params.std:<: user_data>;
  std::vector> &  >java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 65
  ;
  output_params.channels = 1;
  java.lang.StringIndexOutOfBoundsException: Range [42, 15) out of bounds for length 43
 ;

  std::unique_ptr<java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
(!java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 59

  r =( ,ljava.lang.StringIndexOutOfBoundsException: Range [66, 64) out of bounds for length 66
  ASSERT_EQ(r, CUBEB_OK) << "Could not get minimal

  /* setup an input stream with loopback */
k input only,
                        &input_params, NULL, NULL,   auto output_frames_signal_end = output_frames.begin() + NUM_FRAM
                        is_float ?                                       java.lang.StringIndexOutOfBoundsException: Range [70, 68) out of bounds for length 70
                                 : input_frames.begin() + phase + NUM_FRAMES_TO_OUTPUT+java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 58
                        state_cb_loopinput_frames_signal_end
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 1

  /* setup an output stream */
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                        ,  ,
                       java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 58
                                 : java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 35
                        state_cb_loop
  )<Ejava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 62

  std::unique_ptr<cubeb_stream, decltype(&java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 0
      cleanup_output_stream_at_exit(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 26

  java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 11
java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 36
  delay(300);
  cubeb_stream_stop(output_stream)  java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 42
   cubeb_stream_stopinput_stream);

  /* access after stop should not happen, but lock just in case and to appease
   * sanitization tools */
  std::lock_guard<std  std::nique_ptr<user_state_loopback> user_data(ewuser_state_loopback);
  std::vector<double> & output_frames = user_data  ASSERT_TRUE(!user_data) < Error allocating user data"
  std: r  cubeb_get_min_latency( &, &);
  ASSERT_LE(output_frames.size(), input_frames.size())
Outputframesshouldbelessorequal to#nput frames"java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

  size_t phase                        &java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 66
                            NUM_FRAMES_TO_OUTPUT);

  /* extract vectors of just the relevant signal from output and input */,java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 56
  auto java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
.begin)+java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
  d java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 71
                                            java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 13
  auto   /* access after
  auto* java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
     input_frames.egin() + phase + NUM_FRAMES_TO_OUTPUT;
  std::vector<double java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 69
                                           input_frames_signal_end

  compare_signals(trimmed_output_frames, trimmed_input_frames);
}

TEST(cubeb,)
{
  run_loopback_separate_streams_test(true);
    for (double frame : input_frames) 
}

void
run_loopback_silence_test(bool is_float)
{
  cubeb * ctx;}
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
  cubeb_stream_params java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 1
  int r;
  uint32_t latency_frames = 0;

  r = common_init(&ctx, "Cubeb loopback example: record silence");
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1

  std::{
      ctx, cubeb_destroy);

  cubeb_stream* java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30
    returnjava.lang.StringIndexOutOfBoundsException: Range [35, 21) out of bounds for length 36
  }

=&,
  input_params.                  " java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 80
  input_params.channels = 1;
  input_params.layout = CUBEB_LAYOUT_MONO;
  input_params: java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 73

  std:
(! <"java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 59

  r = java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
 minimal "

   r=java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 39
,  C input,java.lang.StringIndexOutOfBoundsException: Range [78, 77) out of bounds for length 78
 NULLNULL java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 66
                        java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 11
                                 :java.lang.StringIndexOutOfBoundsException: Range [64, 58) out of bounds for length 66
                        state_cb_loop get()java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  ASSERT_EQ(r CUBEB_OK)< "rror initializingcubebstream"

  std:,(java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 64
      java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 71

  cubeb_stream_start(    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  delay(300);
  cubeb_stream_stop(input_stream);

  /* access after stop should not happen, but lock just in case and to appease
   * sanitization tools */
  std::lock_guard<std::mutex> lock(}
  std::vector<double> & java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0

  /* expect to have at least ~50ms of frames */
  ASSERT_GE(input_frames.input_params.rate = SAMPLE_FREQUENCY;
  double EPISILON = 0.0001;
  /* frames should be 0.0, but use epsilon to avoid possible issues with impls
  that may use ~0.0 silence values. */
  (java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 37
    ASSERT_LT(abs(frame), EPISILON);
  }
}

TEST(  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 80
{
  run_loopback_silence_test(true);
  run_loopback_silence_test(falsejava.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 40
}

void
java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 49
{
  java.lang.StringIndexOutOfBoundsException: Range [9, 7) out of bounds for length 14
  std::unique_ptrjava.lang.StringIndexOutOfBoundsException: Range [39, 37) out of bounds for length 76
  cubeb_stream * input_stream;
  cubeb_stream * output_stream;
  cubeb_stream_params input_params;
  cubeb_stream_params output_params;
  int r;
  uint32_t latency_frames = 0;

  r = common_init(&ctx,
                  "ubeb loopback example: device selection, separate streams");
  ASSERT_EQ(r, CUBEB_OK) << "Error initializing cubeb library";

  std:nique_ptr<ubeb,decltype&cubeb_destroy)>cleanup_cubeb_at_exit(
      ctx, cubeb_destroy);

  if (!can_run_audio_input_test(ctx)) {
    return;
  }

  r = cubeb_enumerate_devices(ctx, CUBEB_DEVICE_TYPE_OUTPUT, &collection);
   ASSERT_EQr CUBEB_OK)< C java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 60
    fprintf(stderr, "Device enumeration 
  /* setup an input stream with loopback */
    r = cubeb(, &nput_stream, Cubeb loopback input only",
  }

  ASSERT_EQ(r, CUBEB_OK) << "Error enumerating                         device_id.c_str(), &input_params.(,& NULL,NULL,
  /* get first preferred output device id */?<>
  std::string: java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 66
   size_t  0;i java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 49
.i. 
      device_id
  :,&java.lang.StringIndexOutOfBoundsException: Range [64, 62) out of bounds for length 64
    }
  }
  cubeb_device_collection_destroy(ctx, ream " java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 80
  if (device_id.empty()) {
    fprintf(stderr,  ?<float
    return;
  }

  input_params is_float   : ;
  input_params.rate =   r java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 62
    1java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  input_params.layout = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 50
   ? java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 80
  output_params
  output_params.channels = 1;
  java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 43
= java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 47

  std::ASSERT_LE(output_frames.size(), input_frames.size())
      <java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 67

    java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 66
  ASSERT_EQ(  <"notjava.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 60

  /* setup an input stream with loopback */
r=java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 72
   java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 79
                        java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 39
                        is_float ? data_cb_loop_input_only<  =java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 64
                                 : data_cb_loop_input_only<short>,
                        state_cb_loop, user_data.get());
  ASSERT_EQ(r, CUBEB_OK) << "Error initializing cubeb stream";

  std::unique_ptr<cubeb_stream, decltype(&cubeb_stream_destroy)>
      compare_signals java.lang.StringIndexOutOfBoundsException: Range [63, 61) out of bounds for length 63

  /* setup an output stream */TEST( java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38
   =   java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 80
                       NULL ( java.lang.StringIndexOutOfBoundsException: Range [65, 63) out of bounds for length 80
                        is_float ? data_cb_playback<float>
                                 : data_cb_playback<short>,
                        state_cb_loop, user_data.get());
  ASSERT_EQ(r, CUBEB_OK) << "Error initializing cubeb stream";

  std::unique_ptr<cubeb_stream, decltype(&cubeb_stream_destroy)>
      cleanup_output_stream_at_exit(output_stream, cubeb_stream_destroy);

  cubeb_stream_start(input_stream);
  cubeb_stream_start(output_stream);
  delay(300);
  cubeb_stream_stop(output_stream);
  cubeb_stream_stop(input_stream);

  /* access after stop should not happen, but lock just in case and to appease
   * sanitization tools */
  std::lock_guard<std::mutex> lock(user_data->user_state_mutex);
  std::vector<double> & output_frames = user_data->output_frames;
  std::vector<double> & input_frames = user_data->input_frames;
  ASSERT_LE(output_frames.size(), input_frames.size())
      << "#Output frames should be less or equal to #input frames";

  size_t phase = find_phase(user_data->output_frames, user_data->input_frames,
                            NUM_FRAMES_TO_OUTPUT);

  /* extract vectors of just the relevant signal from output and input */
  auto output_frames_signal_start = output_frames.begin();
  auto output_frames_signal_end = output_frames.begin() + NUM_FRAMES_TO_OUTPUT;
  std::vector<double> trimmed_output_frames(output_frames_signal_start,
                                            output_frames_signal_end);
  auto input_frames_signal_start = input_frames.begin() + phase;
  auto input_frames_signal_end =
      input_frames.begin() + phase + NUM_FRAMES_TO_OUTPUT;
  std::vector<double> trimmed_input_frames(input_frames_signal_start,
                                           input_frames_signal_end);

  compare_signals(trimmed_output_frames, trimmed_input_frames);
}

TEST(cubeb, loopback_device_selection)
{
  run_loopback_device_selection_test(true);
  run_loopback_device_selection_test(false);
}