TestAudioRingBuffer.cpp (40218B)
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ 2 /* vim: set ts=2 et sw=2 tw=80: */ 3 /* This Source Code Form is subject to the terms of the Mozilla Public 4 * License, v. 2.0. If a copy of the MPL was not distributed with this file, 5 * You can obtain one at http://mozilla.org/MPL/2.0/. */ 6 7 #include "AudioRingBuffer.h" 8 #include "gmock/gmock.h" 9 #include "gtest/gtest.h" 10 #include "mozilla/PodOperations.h" 11 12 using namespace mozilla; 13 using testing::ElementsAre; 14 15 TEST(TestAudioRingBuffer, BasicFloat) 16 { 17 AudioRingBuffer ringBuffer(11 * sizeof(float)); 18 ringBuffer.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 19 20 EXPECT_TRUE(ringBuffer.IsEmpty()); 21 EXPECT_TRUE(!ringBuffer.IsFull()); 22 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 23 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 24 25 uint32_t rv = ringBuffer.WriteSilence(4); 26 EXPECT_EQ(rv, 4u); 27 EXPECT_TRUE(!ringBuffer.IsEmpty()); 28 EXPECT_TRUE(!ringBuffer.IsFull()); 29 EXPECT_EQ(ringBuffer.AvailableWrite(), 6u); 30 EXPECT_EQ(ringBuffer.AvailableRead(), 4u); 31 32 float in[4] = {.1, .2, .3, .4}; 33 rv = ringBuffer.Write(Span(in, 4)); 34 EXPECT_EQ(rv, 4u); 35 EXPECT_TRUE(!ringBuffer.IsEmpty()); 36 EXPECT_TRUE(!ringBuffer.IsFull()); 37 EXPECT_EQ(ringBuffer.AvailableWrite(), 2u); 38 EXPECT_EQ(ringBuffer.AvailableRead(), 8u); 39 40 rv = ringBuffer.WriteSilence(4); 41 EXPECT_EQ(rv, 2u); 42 EXPECT_TRUE(!ringBuffer.IsEmpty()); 43 EXPECT_TRUE(ringBuffer.IsFull()); 44 EXPECT_EQ(ringBuffer.AvailableWrite(), 0u); 45 EXPECT_EQ(ringBuffer.AvailableRead(), 10u); 46 47 rv = ringBuffer.Write(Span(in, 4)); 48 EXPECT_EQ(rv, 0u); 49 EXPECT_TRUE(!ringBuffer.IsEmpty()); 50 EXPECT_TRUE(ringBuffer.IsFull()); 51 EXPECT_EQ(ringBuffer.AvailableWrite(), 0u); 52 EXPECT_EQ(ringBuffer.AvailableRead(), 10u); 53 54 float out[4] = {}; 55 rv = ringBuffer.Read(Span(out, 4)); 56 EXPECT_EQ(rv, 4u); 57 EXPECT_TRUE(!ringBuffer.IsEmpty()); 58 EXPECT_TRUE(!ringBuffer.IsFull()); 59 EXPECT_EQ(ringBuffer.AvailableWrite(), 4u); 60 EXPECT_EQ(ringBuffer.AvailableRead(), 6u); 61 for (float f : out) { 62 EXPECT_FLOAT_EQ(f, 0.0); 63 } 64 65 rv = ringBuffer.Read(Span(out, 4)); 66 EXPECT_EQ(rv, 4u); 67 EXPECT_TRUE(!ringBuffer.IsEmpty()); 68 EXPECT_TRUE(!ringBuffer.IsFull()); 69 EXPECT_EQ(ringBuffer.AvailableWrite(), 8u); 70 EXPECT_EQ(ringBuffer.AvailableRead(), 2u); 71 for (uint32_t i = 0; i < 4; ++i) { 72 EXPECT_FLOAT_EQ(in[i], out[i]); 73 } 74 75 rv = ringBuffer.Read(Span(out, 4)); 76 EXPECT_EQ(rv, 2u); 77 EXPECT_TRUE(ringBuffer.IsEmpty()); 78 EXPECT_TRUE(!ringBuffer.IsFull()); 79 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 80 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 81 for (uint32_t i = 0; i < 2; ++i) { 82 EXPECT_FLOAT_EQ(out[i], 0.0); 83 } 84 85 rv = ringBuffer.Clear(); 86 EXPECT_EQ(rv, 0u); 87 EXPECT_TRUE(ringBuffer.IsEmpty()); 88 EXPECT_TRUE(!ringBuffer.IsFull()); 89 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 90 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 91 } 92 93 TEST(TestAudioRingBuffer, BasicShort) 94 { 95 AudioRingBuffer ringBuffer(11 * sizeof(short)); 96 ringBuffer.SetSampleFormat(AUDIO_FORMAT_S16); 97 98 EXPECT_TRUE(ringBuffer.IsEmpty()); 99 EXPECT_TRUE(!ringBuffer.IsFull()); 100 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 101 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 102 103 uint32_t rv = ringBuffer.WriteSilence(4); 104 EXPECT_EQ(rv, 4u); 105 EXPECT_TRUE(!ringBuffer.IsEmpty()); 106 EXPECT_TRUE(!ringBuffer.IsFull()); 107 EXPECT_EQ(ringBuffer.AvailableWrite(), 6u); 108 EXPECT_EQ(ringBuffer.AvailableRead(), 4u); 109 110 short in[4] = {1, 2, 3, 4}; 111 rv = ringBuffer.Write(Span(in, 4)); 112 EXPECT_EQ(rv, 4u); 113 EXPECT_TRUE(!ringBuffer.IsEmpty()); 114 EXPECT_TRUE(!ringBuffer.IsFull()); 115 EXPECT_EQ(ringBuffer.AvailableWrite(), 2u); 116 EXPECT_EQ(ringBuffer.AvailableRead(), 8u); 117 118 rv = ringBuffer.WriteSilence(4); 119 EXPECT_EQ(rv, 2u); 120 EXPECT_TRUE(!ringBuffer.IsEmpty()); 121 EXPECT_TRUE(ringBuffer.IsFull()); 122 EXPECT_EQ(ringBuffer.AvailableWrite(), 0u); 123 EXPECT_EQ(ringBuffer.AvailableRead(), 10u); 124 125 rv = ringBuffer.Write(Span(in, 4)); 126 EXPECT_EQ(rv, 0u); 127 EXPECT_TRUE(!ringBuffer.IsEmpty()); 128 EXPECT_TRUE(ringBuffer.IsFull()); 129 EXPECT_EQ(ringBuffer.AvailableWrite(), 0u); 130 EXPECT_EQ(ringBuffer.AvailableRead(), 10u); 131 132 short out[4] = {}; 133 rv = ringBuffer.Read(Span(out, 4)); 134 EXPECT_EQ(rv, 4u); 135 EXPECT_TRUE(!ringBuffer.IsEmpty()); 136 EXPECT_TRUE(!ringBuffer.IsFull()); 137 EXPECT_EQ(ringBuffer.AvailableWrite(), 4u); 138 EXPECT_EQ(ringBuffer.AvailableRead(), 6u); 139 for (float f : out) { 140 EXPECT_EQ(f, 0); 141 } 142 143 rv = ringBuffer.Read(Span(out, 4)); 144 EXPECT_EQ(rv, 4u); 145 EXPECT_TRUE(!ringBuffer.IsEmpty()); 146 EXPECT_TRUE(!ringBuffer.IsFull()); 147 EXPECT_EQ(ringBuffer.AvailableWrite(), 8u); 148 EXPECT_EQ(ringBuffer.AvailableRead(), 2u); 149 for (uint32_t i = 0; i < 4; ++i) { 150 EXPECT_EQ(in[i], out[i]); 151 } 152 153 rv = ringBuffer.Read(Span(out, 4)); 154 EXPECT_EQ(rv, 2u); 155 EXPECT_TRUE(ringBuffer.IsEmpty()); 156 EXPECT_TRUE(!ringBuffer.IsFull()); 157 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 158 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 159 for (uint32_t i = 0; i < 2; ++i) { 160 EXPECT_EQ(out[i], 0); 161 } 162 163 rv = ringBuffer.Clear(); 164 EXPECT_EQ(rv, 0u); 165 EXPECT_TRUE(ringBuffer.IsEmpty()); 166 EXPECT_TRUE(!ringBuffer.IsFull()); 167 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 168 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 169 } 170 171 TEST(TestAudioRingBuffer, BasicFloat2) 172 { 173 AudioRingBuffer ringBuffer(11 * sizeof(float)); 174 ringBuffer.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 175 176 EXPECT_TRUE(ringBuffer.IsEmpty()); 177 EXPECT_TRUE(!ringBuffer.IsFull()); 178 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 179 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 180 181 float in[4] = {.1, .2, .3, .4}; 182 uint32_t rv = ringBuffer.Write(Span(in, 4)); 183 EXPECT_EQ(rv, 4u); 184 EXPECT_TRUE(!ringBuffer.IsEmpty()); 185 EXPECT_TRUE(!ringBuffer.IsFull()); 186 EXPECT_EQ(ringBuffer.AvailableWrite(), 6u); 187 EXPECT_EQ(ringBuffer.AvailableRead(), 4u); 188 189 rv = ringBuffer.Write(Span(in, 4)); 190 EXPECT_EQ(rv, 4u); 191 EXPECT_TRUE(!ringBuffer.IsEmpty()); 192 EXPECT_TRUE(!ringBuffer.IsFull()); 193 EXPECT_EQ(ringBuffer.AvailableWrite(), 2u); 194 EXPECT_EQ(ringBuffer.AvailableRead(), 8u); 195 196 float out[4] = {}; 197 rv = ringBuffer.Read(Span(out, 4)); 198 EXPECT_EQ(rv, 4u); 199 EXPECT_TRUE(!ringBuffer.IsEmpty()); 200 EXPECT_TRUE(!ringBuffer.IsFull()); 201 EXPECT_EQ(ringBuffer.AvailableWrite(), 6u); 202 EXPECT_EQ(ringBuffer.AvailableRead(), 4u); 203 for (uint32_t i = 0; i < 4; ++i) { 204 EXPECT_FLOAT_EQ(in[i], out[i]); 205 } 206 207 // WriteIndex = 12 208 rv = ringBuffer.Write(Span(in, 4)); 209 EXPECT_EQ(rv, 4u); 210 EXPECT_TRUE(!ringBuffer.IsEmpty()); 211 EXPECT_TRUE(!ringBuffer.IsFull()); 212 EXPECT_EQ(ringBuffer.AvailableWrite(), 2u); 213 EXPECT_EQ(ringBuffer.AvailableRead(), 8u); 214 215 rv = ringBuffer.Read(Span(out, 4)); 216 EXPECT_EQ(rv, 4u); 217 EXPECT_TRUE(!ringBuffer.IsEmpty()); 218 EXPECT_TRUE(!ringBuffer.IsFull()); 219 EXPECT_EQ(ringBuffer.AvailableWrite(), 6u); 220 EXPECT_EQ(ringBuffer.AvailableRead(), 4u); 221 for (uint32_t i = 0; i < 4; ++i) { 222 EXPECT_FLOAT_EQ(in[i], out[i]); 223 } 224 225 rv = ringBuffer.Read(Span(out, 8)); 226 EXPECT_EQ(rv, 4u); 227 EXPECT_TRUE(ringBuffer.IsEmpty()); 228 EXPECT_TRUE(!ringBuffer.IsFull()); 229 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 230 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 231 for (uint32_t i = 0; i < 4; ++i) { 232 EXPECT_FLOAT_EQ(in[i], out[i]); 233 } 234 235 rv = ringBuffer.Read(Span(out, 8)); 236 EXPECT_EQ(rv, 0u); 237 EXPECT_TRUE(ringBuffer.IsEmpty()); 238 EXPECT_TRUE(!ringBuffer.IsFull()); 239 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 240 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 241 for (uint32_t i = 0; i < 4; ++i) { 242 EXPECT_FLOAT_EQ(in[i], out[i]); 243 } 244 245 // WriteIndex = 16 246 rv = ringBuffer.Write(Span(in, 4)); 247 EXPECT_EQ(rv, 4u); 248 EXPECT_TRUE(!ringBuffer.IsEmpty()); 249 EXPECT_TRUE(!ringBuffer.IsFull()); 250 EXPECT_EQ(ringBuffer.AvailableWrite(), 6u); 251 EXPECT_EQ(ringBuffer.AvailableRead(), 4u); 252 253 rv = ringBuffer.Write(Span(in, 4)); 254 EXPECT_EQ(rv, 4u); 255 EXPECT_TRUE(!ringBuffer.IsEmpty()); 256 EXPECT_TRUE(!ringBuffer.IsFull()); 257 EXPECT_EQ(ringBuffer.AvailableWrite(), 2u); 258 EXPECT_EQ(ringBuffer.AvailableRead(), 8u); 259 260 rv = ringBuffer.Write(Span(in, 4)); 261 EXPECT_EQ(rv, 2u); 262 EXPECT_TRUE(!ringBuffer.IsEmpty()); 263 EXPECT_TRUE(ringBuffer.IsFull()); 264 EXPECT_EQ(ringBuffer.AvailableWrite(), 0u); 265 EXPECT_EQ(ringBuffer.AvailableRead(), 10u); 266 267 rv = ringBuffer.Write(Span(in, 4)); 268 EXPECT_EQ(rv, 0u); 269 EXPECT_TRUE(!ringBuffer.IsEmpty()); 270 EXPECT_TRUE(ringBuffer.IsFull()); 271 EXPECT_EQ(ringBuffer.AvailableWrite(), 0u); 272 EXPECT_EQ(ringBuffer.AvailableRead(), 10u); 273 } 274 275 TEST(TestAudioRingBuffer, BasicShort2) 276 { 277 AudioRingBuffer ringBuffer(11 * sizeof(int16_t)); 278 ringBuffer.SetSampleFormat(AUDIO_FORMAT_S16); 279 280 EXPECT_TRUE(ringBuffer.IsEmpty()); 281 EXPECT_TRUE(!ringBuffer.IsFull()); 282 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 283 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 284 285 int16_t in[4] = {1, 2, 3, 4}; 286 uint32_t rv = ringBuffer.Write(Span(in, 4)); 287 EXPECT_EQ(rv, 4u); 288 EXPECT_TRUE(!ringBuffer.IsEmpty()); 289 EXPECT_TRUE(!ringBuffer.IsFull()); 290 EXPECT_EQ(ringBuffer.AvailableWrite(), 6u); 291 EXPECT_EQ(ringBuffer.AvailableRead(), 4u); 292 293 rv = ringBuffer.Write(Span(in, 4)); 294 EXPECT_EQ(rv, 4u); 295 EXPECT_TRUE(!ringBuffer.IsEmpty()); 296 EXPECT_TRUE(!ringBuffer.IsFull()); 297 EXPECT_EQ(ringBuffer.AvailableWrite(), 2u); 298 EXPECT_EQ(ringBuffer.AvailableRead(), 8u); 299 300 int16_t out[4] = {}; 301 rv = ringBuffer.Read(Span(out, 4)); 302 EXPECT_EQ(rv, 4u); 303 EXPECT_TRUE(!ringBuffer.IsEmpty()); 304 EXPECT_TRUE(!ringBuffer.IsFull()); 305 EXPECT_EQ(ringBuffer.AvailableWrite(), 6u); 306 EXPECT_EQ(ringBuffer.AvailableRead(), 4u); 307 for (uint32_t i = 0; i < 4; ++i) { 308 EXPECT_EQ(in[i], out[i]); 309 } 310 311 // WriteIndex = 12 312 rv = ringBuffer.Write(Span(in, 4)); 313 EXPECT_EQ(rv, 4u); 314 EXPECT_TRUE(!ringBuffer.IsEmpty()); 315 EXPECT_TRUE(!ringBuffer.IsFull()); 316 EXPECT_EQ(ringBuffer.AvailableWrite(), 2u); 317 EXPECT_EQ(ringBuffer.AvailableRead(), 8u); 318 319 rv = ringBuffer.Read(Span(out, 4)); 320 EXPECT_EQ(rv, 4u); 321 EXPECT_TRUE(!ringBuffer.IsEmpty()); 322 EXPECT_TRUE(!ringBuffer.IsFull()); 323 EXPECT_EQ(ringBuffer.AvailableWrite(), 6u); 324 EXPECT_EQ(ringBuffer.AvailableRead(), 4u); 325 for (uint32_t i = 0; i < 4; ++i) { 326 EXPECT_EQ(in[i], out[i]); 327 } 328 329 rv = ringBuffer.Read(Span(out, 8)); 330 EXPECT_EQ(rv, 4u); 331 EXPECT_TRUE(ringBuffer.IsEmpty()); 332 EXPECT_TRUE(!ringBuffer.IsFull()); 333 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 334 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 335 for (uint32_t i = 0; i < 4; ++i) { 336 EXPECT_EQ(in[i], out[i]); 337 } 338 339 rv = ringBuffer.Read(Span(out, 8)); 340 EXPECT_EQ(rv, 0u); 341 EXPECT_TRUE(ringBuffer.IsEmpty()); 342 EXPECT_TRUE(!ringBuffer.IsFull()); 343 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 344 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 345 for (uint32_t i = 0; i < 4; ++i) { 346 EXPECT_EQ(in[i], out[i]); 347 } 348 349 // WriteIndex = 16 350 rv = ringBuffer.Write(Span(in, 4)); 351 EXPECT_EQ(rv, 4u); 352 EXPECT_TRUE(!ringBuffer.IsEmpty()); 353 EXPECT_TRUE(!ringBuffer.IsFull()); 354 EXPECT_EQ(ringBuffer.AvailableWrite(), 6u); 355 EXPECT_EQ(ringBuffer.AvailableRead(), 4u); 356 357 rv = ringBuffer.Write(Span(in, 4)); 358 EXPECT_EQ(rv, 4u); 359 EXPECT_TRUE(!ringBuffer.IsEmpty()); 360 EXPECT_TRUE(!ringBuffer.IsFull()); 361 EXPECT_EQ(ringBuffer.AvailableWrite(), 2u); 362 EXPECT_EQ(ringBuffer.AvailableRead(), 8u); 363 364 rv = ringBuffer.Write(Span(in, 4)); 365 EXPECT_EQ(rv, 2u); 366 EXPECT_TRUE(!ringBuffer.IsEmpty()); 367 EXPECT_TRUE(ringBuffer.IsFull()); 368 EXPECT_EQ(ringBuffer.AvailableWrite(), 0u); 369 EXPECT_EQ(ringBuffer.AvailableRead(), 10u); 370 371 rv = ringBuffer.Write(Span(in, 4)); 372 EXPECT_EQ(rv, 0u); 373 EXPECT_TRUE(!ringBuffer.IsEmpty()); 374 EXPECT_TRUE(ringBuffer.IsFull()); 375 EXPECT_EQ(ringBuffer.AvailableWrite(), 0u); 376 EXPECT_EQ(ringBuffer.AvailableRead(), 10u); 377 } 378 379 TEST(TestAudioRingBuffer, NoCopyFloat) 380 { 381 AudioRingBuffer ringBuffer(11 * sizeof(float)); 382 ringBuffer.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 383 384 float in[8] = {.0, .1, .2, .3, .4, .5, .6, .7}; 385 ringBuffer.Write(Span(in, 6)); 386 // v ReadIndex 387 // [x0: .0, x1: .1, x2: .2, x3: .3, x4: .4, 388 // x5: .5, x6: .0, x7: .0, x8: .0, x9: .0, x10: .0] 389 390 float out[10] = {}; 391 float* out_ptr = out; 392 393 uint32_t rv = 394 ringBuffer.ReadNoCopy([&out_ptr](const Span<const float> aInBuffer) { 395 PodMove(out_ptr, aInBuffer.data(), aInBuffer.Length()); 396 out_ptr += aInBuffer.Length(); 397 return aInBuffer.Length(); 398 }); 399 EXPECT_EQ(rv, 6u); 400 EXPECT_TRUE(ringBuffer.IsEmpty()); 401 EXPECT_TRUE(!ringBuffer.IsFull()); 402 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 403 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 404 for (uint32_t i = 0; i < rv; ++i) { 405 EXPECT_FLOAT_EQ(out[i], in[i]); 406 } 407 408 ringBuffer.Write(Span(in, 8)); 409 // Now the buffer contains: 410 // [x0: .5, x1: .6, x2: .2, x3: .3, x4: .4, 411 // x5: .5, x6: .0, x7: .1, x8: .2, x9: .3, x10: .4 412 // ^ ReadIndex 413 out_ptr = out; // reset the pointer before lambdas reuse 414 rv = ringBuffer.ReadNoCopy([&out_ptr](const Span<const float> aInBuffer) { 415 PodMove(out_ptr, aInBuffer.data(), aInBuffer.Length()); 416 out_ptr += aInBuffer.Length(); 417 return aInBuffer.Length(); 418 }); 419 EXPECT_EQ(rv, 8u); 420 EXPECT_TRUE(ringBuffer.IsEmpty()); 421 EXPECT_TRUE(!ringBuffer.IsFull()); 422 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 423 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 424 for (uint32_t i = 0; i < rv; ++i) { 425 EXPECT_FLOAT_EQ(out[i], in[i]); 426 } 427 } 428 429 TEST(TestAudioRingBuffer, NoCopyShort) 430 { 431 AudioRingBuffer ringBuffer(11 * sizeof(short)); 432 ringBuffer.SetSampleFormat(AUDIO_FORMAT_S16); 433 434 short in[8] = {0, 1, 2, 3, 4, 5, 6, 7}; 435 ringBuffer.Write(Span(in, 6)); 436 // v ReadIndex 437 // [x0: 0, x1: 1, x2: 2, x3: 3, x4: 4, 438 // x5: 5, x6: 0, x7: 0, x8: 0, x9: 0, x10: 0] 439 440 short out[10] = {}; 441 short* out_ptr = out; 442 443 uint32_t rv = 444 ringBuffer.ReadNoCopy([&out_ptr](const Span<const short> aInBuffer) { 445 PodMove(out_ptr, aInBuffer.data(), aInBuffer.Length()); 446 out_ptr += aInBuffer.Length(); 447 return aInBuffer.Length(); 448 }); 449 EXPECT_EQ(rv, 6u); 450 EXPECT_TRUE(ringBuffer.IsEmpty()); 451 EXPECT_TRUE(!ringBuffer.IsFull()); 452 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 453 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 454 for (uint32_t i = 0; i < rv; ++i) { 455 EXPECT_EQ(out[i], in[i]); 456 } 457 458 ringBuffer.Write(Span(in, 8)); 459 // Now the buffer contains: 460 // [x0: 5, x1: 6, x2: 2, x3: 3, x4: 4, 461 // x5: 5, x6: 0, x7: 1, x8: 2, x9: 3, x10: 4 462 // ^ ReadIndex 463 out_ptr = out; // reset the pointer before lambdas reuse 464 rv = ringBuffer.ReadNoCopy([&out_ptr](const Span<const short> aInBuffer) { 465 PodMove(out_ptr, aInBuffer.data(), aInBuffer.Length()); 466 out_ptr += aInBuffer.Length(); 467 return aInBuffer.Length(); 468 }); 469 EXPECT_EQ(rv, 8u); 470 EXPECT_TRUE(ringBuffer.IsEmpty()); 471 EXPECT_TRUE(!ringBuffer.IsFull()); 472 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 473 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 474 for (uint32_t i = 0; i < rv; ++i) { 475 EXPECT_EQ(out[i], in[i]); 476 } 477 } 478 479 TEST(TestAudioRingBuffer, NoCopyFloat2) 480 { 481 AudioRingBuffer ringBuffer(11 * sizeof(float)); 482 ringBuffer.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 483 484 float in[8] = {.0, .1, .2, .3, .4, .5, .6, .7}; 485 ringBuffer.Write(Span(in, 6)); 486 // v ReadIndex 487 // [x0: .0, x1: .1, x2: .2, x3: .3, x4: .4, 488 // x5: .5, x6: .0, x7: .0, x8: .0, x9: .0, x10: .0] 489 490 float out[10] = {}; 491 float* out_ptr = out; 492 uint32_t total_frames = 3; 493 494 uint32_t rv = ringBuffer.ReadNoCopy( 495 [&out_ptr, &total_frames](const Span<const float>& aInBuffer) { 496 uint32_t inFramesUsed = 497 std::min<uint32_t>(total_frames, aInBuffer.Length()); 498 PodMove(out_ptr, aInBuffer.data(), inFramesUsed); 499 out_ptr += inFramesUsed; 500 total_frames -= inFramesUsed; 501 return inFramesUsed; 502 }); 503 // v ReadIndex 504 // [x0: .0, x1: .1, x2: .2, x3: .3, x4: .4, 505 // x5: .5, x6: .0, x7: .0, x8: .0, x9: .0, x10: .0] 506 EXPECT_EQ(rv, 3u); 507 EXPECT_TRUE(!ringBuffer.IsEmpty()); 508 EXPECT_TRUE(!ringBuffer.IsFull()); 509 EXPECT_EQ(ringBuffer.AvailableWrite(), 7u); 510 EXPECT_EQ(ringBuffer.AvailableRead(), 3u); 511 for (uint32_t i = 0; i < rv; ++i) { 512 EXPECT_FLOAT_EQ(out[i], in[i]); 513 } 514 515 total_frames = 3; 516 rv = ringBuffer.ReadNoCopy( 517 [&out_ptr, &total_frames](const Span<const float>& aInBuffer) { 518 uint32_t inFramesUsed = 519 std::min<uint32_t>(total_frames, aInBuffer.Length()); 520 PodMove(out_ptr, aInBuffer.data(), inFramesUsed); 521 out_ptr += inFramesUsed; 522 total_frames -= inFramesUsed; 523 return inFramesUsed; 524 }); 525 // [x0: .0, x1: .1, x2: .2, x3: .3, x4: .4, 526 // x5: .5, x6: .0, x7: .0, x8: .0, x9: .0, x10: .0] 527 // ^ ReadIndex 528 EXPECT_EQ(rv, 3u); 529 EXPECT_TRUE(ringBuffer.IsEmpty()); 530 EXPECT_TRUE(!ringBuffer.IsFull()); 531 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 532 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 533 for (uint32_t i = 0; i < rv; ++i) { 534 EXPECT_FLOAT_EQ(out[i + 3], in[i + 3]); 535 } 536 537 ringBuffer.Write(Span(in, 8)); 538 // Now the buffer contains: 539 // [x0: .5, x1: .6, x2: .7, x3: .3, x4: .4, 540 // x5: .5, x6: .0, x7: .1, x8: .2, x9: .3, x10: .4 541 // ^ ReadIndex 542 543 // reset the pointer before lambdas reuse 544 out_ptr = out; 545 total_frames = 3; 546 rv = ringBuffer.ReadNoCopy( 547 [&out_ptr, &total_frames](const Span<const float>& aInBuffer) { 548 uint32_t inFramesUsed = 549 std::min<uint32_t>(total_frames, aInBuffer.Length()); 550 PodMove(out_ptr, aInBuffer.data(), inFramesUsed); 551 out_ptr += inFramesUsed; 552 total_frames -= inFramesUsed; 553 return inFramesUsed; 554 }); 555 // Now the buffer contains: 556 // [x0: .5, x1: .6, x2: .2, x3: .3, x4: .4, 557 // x5: .5, x6: .0, x7: .1, x8: .2, x9: .3, x10: .4 558 // ^ ReadIndex 559 EXPECT_EQ(rv, 3u); 560 EXPECT_TRUE(!ringBuffer.IsEmpty()); 561 EXPECT_TRUE(!ringBuffer.IsFull()); 562 EXPECT_EQ(ringBuffer.AvailableWrite(), 5u); 563 EXPECT_EQ(ringBuffer.AvailableRead(), 5u); 564 for (uint32_t i = 0; i < rv; ++i) { 565 EXPECT_FLOAT_EQ(out[i], in[i]); 566 } 567 568 total_frames = 3; 569 rv = ringBuffer.ReadNoCopy( 570 [&out_ptr, &total_frames](const Span<const float>& aInBuffer) { 571 uint32_t inFramesUsed = 572 std::min<uint32_t>(total_frames, aInBuffer.Length()); 573 PodMove(out_ptr, aInBuffer.data(), inFramesUsed); 574 out_ptr += inFramesUsed; 575 total_frames -= inFramesUsed; 576 return inFramesUsed; 577 }); 578 // Now the buffer contains: 579 // v ReadIndex 580 // [x0: .5, x1: .6, x2: .7, x3: .3, x4: .4, 581 // x5: .5, x6: .0, x7: .1, x8: .2, x9: .3, x10: .4 582 EXPECT_EQ(rv, 3u); 583 EXPECT_TRUE(!ringBuffer.IsEmpty()); 584 EXPECT_TRUE(!ringBuffer.IsFull()); 585 EXPECT_EQ(ringBuffer.AvailableWrite(), 8u); 586 EXPECT_EQ(ringBuffer.AvailableRead(), 2u); 587 for (uint32_t i = 0; i < rv; ++i) { 588 EXPECT_FLOAT_EQ(out[i + 3], in[i + 3]); 589 } 590 591 total_frames = 3; 592 rv = ringBuffer.ReadNoCopy( 593 [&out_ptr, &total_frames](const Span<const float>& aInBuffer) { 594 uint32_t inFramesUsed = 595 std::min<uint32_t>(total_frames, aInBuffer.Length()); 596 PodMove(out_ptr, aInBuffer.data(), inFramesUsed); 597 out_ptr += inFramesUsed; 598 total_frames -= inFramesUsed; 599 return inFramesUsed; 600 }); 601 // Now the buffer contains: 602 // v ReadIndex 603 // [x0: .5, x1: .6, x2: .7, x3: .3, x4: .4, 604 // x5: .5, x6: .0, x7: .1, x8: .2, x9: .3, x10: .4 605 EXPECT_EQ(rv, 2u); 606 EXPECT_EQ(total_frames, 1u); 607 EXPECT_TRUE(ringBuffer.IsEmpty()); 608 EXPECT_TRUE(!ringBuffer.IsFull()); 609 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 610 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 611 for (uint32_t i = 0; i < rv; ++i) { 612 EXPECT_FLOAT_EQ(out[i + 6], in[i + 6]); 613 } 614 } 615 616 TEST(TestAudioRingBuffer, NoCopyShort2) 617 { 618 AudioRingBuffer ringBuffer(11 * sizeof(short)); 619 ringBuffer.SetSampleFormat(AUDIO_FORMAT_S16); 620 621 short in[8] = {0, 1, 2, 3, 4, 5, 6, 7}; 622 ringBuffer.Write(Span(in, 6)); 623 // v ReadIndex 624 // [x0: 0, x1: 1, x2: 2, x3: 3, x4: 4, 625 // x5: 5, x6: 0, x7: 0, x8: 0, x9: 0, x10: 0] 626 627 short out[10] = {}; 628 short* out_ptr = out; 629 uint32_t total_frames = 3; 630 631 uint32_t rv = ringBuffer.ReadNoCopy( 632 [&out_ptr, &total_frames](const Span<const short>& aInBuffer) { 633 uint32_t inFramesUsed = 634 std::min<uint32_t>(total_frames, aInBuffer.Length()); 635 PodMove(out_ptr, aInBuffer.data(), inFramesUsed); 636 out_ptr += inFramesUsed; 637 total_frames -= inFramesUsed; 638 return inFramesUsed; 639 }); 640 // v ReadIndex 641 // [x0: 0, x1: 1, x2: 2, x3: 3, x4: 4, 642 // x5: 5, x6: 0, x7: 0, x8: 0, x9: 0, x10: 0] 643 EXPECT_EQ(rv, 3u); 644 EXPECT_TRUE(!ringBuffer.IsEmpty()); 645 EXPECT_TRUE(!ringBuffer.IsFull()); 646 EXPECT_EQ(ringBuffer.AvailableWrite(), 7u); 647 EXPECT_EQ(ringBuffer.AvailableRead(), 3u); 648 for (uint32_t i = 0; i < rv; ++i) { 649 EXPECT_EQ(out[i], in[i]); 650 } 651 652 total_frames = 3; 653 rv = ringBuffer.ReadNoCopy( 654 [&out_ptr, &total_frames](const Span<const short>& aInBuffer) { 655 uint32_t inFramesUsed = 656 std::min<uint32_t>(total_frames, aInBuffer.Length()); 657 PodMove(out_ptr, aInBuffer.data(), inFramesUsed); 658 out_ptr += inFramesUsed; 659 total_frames -= inFramesUsed; 660 return inFramesUsed; 661 }); 662 // [x0: 0, x1: 1, x2: 2, x3: 3, x4: 4, 663 // x5: 5, x6: 0, x7: 0, x8: 0, x9: 0, x10: .0] 664 // ^ ReadIndex 665 EXPECT_EQ(rv, 3u); 666 EXPECT_TRUE(ringBuffer.IsEmpty()); 667 EXPECT_TRUE(!ringBuffer.IsFull()); 668 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 669 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 670 for (uint32_t i = 0; i < rv; ++i) { 671 EXPECT_EQ(out[i + 3], in[i + 3]); 672 } 673 674 ringBuffer.Write(Span(in, 8)); 675 // Now the buffer contains: 676 // [x0: 5, x1: 6, x2: 7, x3: 3, x4: 4, 677 // x5: 5, x6: 0, x7: 1, x8: 2, x9: 3, x10: 4 678 // ^ ReadIndex 679 680 // reset the pointer before lambdas reuse 681 out_ptr = out; 682 total_frames = 3; 683 rv = ringBuffer.ReadNoCopy( 684 [&out_ptr, &total_frames](const Span<const short>& aInBuffer) { 685 uint32_t inFramesUsed = 686 std::min<uint32_t>(total_frames, aInBuffer.Length()); 687 PodMove(out_ptr, aInBuffer.data(), inFramesUsed); 688 out_ptr += inFramesUsed; 689 total_frames -= inFramesUsed; 690 return inFramesUsed; 691 }); 692 // Now the buffer contains: 693 // [x0: 5, x1: 6, x2: 2, x3: 3, x4: 4, 694 // x5: 5, x6: 0, x7: 1, x8: 2, x9: 3, x10: 4 695 // ^ ReadIndex 696 EXPECT_EQ(rv, 3u); 697 EXPECT_TRUE(!ringBuffer.IsEmpty()); 698 EXPECT_TRUE(!ringBuffer.IsFull()); 699 EXPECT_EQ(ringBuffer.AvailableWrite(), 5u); 700 EXPECT_EQ(ringBuffer.AvailableRead(), 5u); 701 for (uint32_t i = 0; i < rv; ++i) { 702 EXPECT_EQ(out[i], in[i]); 703 } 704 705 total_frames = 3; 706 rv = ringBuffer.ReadNoCopy( 707 [&out_ptr, &total_frames](const Span<const short>& aInBuffer) { 708 uint32_t inFramesUsed = 709 std::min<uint32_t>(total_frames, aInBuffer.Length()); 710 PodMove(out_ptr, aInBuffer.data(), inFramesUsed); 711 out_ptr += inFramesUsed; 712 total_frames -= inFramesUsed; 713 return inFramesUsed; 714 }); 715 // Now the buffer contains: 716 // v ReadIndex 717 // [x0: 5, x1: 6, x2: 7, x3: 3, x4: 4, 718 // x5: 5, x6: 0, x7: 1, x8: 2, x9: 3, x10: 4 719 EXPECT_EQ(rv, 3u); 720 EXPECT_TRUE(!ringBuffer.IsEmpty()); 721 EXPECT_TRUE(!ringBuffer.IsFull()); 722 EXPECT_EQ(ringBuffer.AvailableWrite(), 8u); 723 EXPECT_EQ(ringBuffer.AvailableRead(), 2u); 724 for (uint32_t i = 0; i < rv; ++i) { 725 EXPECT_EQ(out[i + 3], in[i + 3]); 726 } 727 728 total_frames = 3; 729 rv = ringBuffer.ReadNoCopy( 730 [&out_ptr, &total_frames](const Span<const short>& aInBuffer) { 731 uint32_t inFramesUsed = 732 std::min<uint32_t>(total_frames, aInBuffer.Length()); 733 PodMove(out_ptr, aInBuffer.data(), inFramesUsed); 734 out_ptr += inFramesUsed; 735 total_frames -= inFramesUsed; 736 return inFramesUsed; 737 }); 738 // Now the buffer contains: 739 // v ReadIndex 740 // [x0: 5, x1: 6, x2: 7, x3: 3, x4: 4, 741 // x5: 5, x6: 0, x7: 1, x8: 2, x9: 3, x10: 4 742 EXPECT_EQ(rv, 2u); 743 EXPECT_EQ(total_frames, 1u); 744 EXPECT_TRUE(ringBuffer.IsEmpty()); 745 EXPECT_TRUE(!ringBuffer.IsFull()); 746 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 747 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 748 for (uint32_t i = 0; i < rv; ++i) { 749 EXPECT_EQ(out[i + 6], in[i + 6]); 750 } 751 } 752 753 TEST(TestAudioRingBuffer, DiscardFloat) 754 { 755 AudioRingBuffer ringBuffer(11 * sizeof(float)); 756 ringBuffer.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 757 758 float in[8] = {.0, .1, .2, .3, .4, .5, .6, .7}; 759 ringBuffer.Write(Span(in, 8)); 760 761 uint32_t rv = ringBuffer.Discard(3); 762 EXPECT_EQ(rv, 3u); 763 EXPECT_TRUE(!ringBuffer.IsEmpty()); 764 EXPECT_TRUE(!ringBuffer.IsFull()); 765 EXPECT_EQ(ringBuffer.AvailableWrite(), 5u); 766 EXPECT_EQ(ringBuffer.AvailableRead(), 5u); 767 768 float out[8] = {}; 769 rv = ringBuffer.Read(Span(out, 3)); 770 EXPECT_EQ(rv, 3u); 771 EXPECT_TRUE(!ringBuffer.IsEmpty()); 772 EXPECT_TRUE(!ringBuffer.IsFull()); 773 EXPECT_EQ(ringBuffer.AvailableWrite(), 8u); 774 EXPECT_EQ(ringBuffer.AvailableRead(), 2u); 775 for (uint32_t i = 0; i < rv; ++i) { 776 EXPECT_FLOAT_EQ(out[i], in[i + 3]); 777 } 778 779 rv = ringBuffer.Discard(3); 780 EXPECT_EQ(rv, 2u); 781 EXPECT_TRUE(ringBuffer.IsEmpty()); 782 EXPECT_TRUE(!ringBuffer.IsFull()); 783 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 784 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 785 786 ringBuffer.WriteSilence(4); 787 rv = ringBuffer.Discard(6); 788 EXPECT_EQ(rv, 4u); 789 EXPECT_TRUE(ringBuffer.IsEmpty()); 790 EXPECT_TRUE(!ringBuffer.IsFull()); 791 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 792 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 793 } 794 795 TEST(TestAudioRingBuffer, DiscardShort) 796 { 797 AudioRingBuffer ringBuffer(11 * sizeof(short)); 798 ringBuffer.SetSampleFormat(AUDIO_FORMAT_S16); 799 800 short in[8] = {0, 1, 2, 3, 4, 5, 6, 7}; 801 ringBuffer.Write(Span(in, 8)); 802 803 uint32_t rv = ringBuffer.Discard(3); 804 EXPECT_EQ(rv, 3u); 805 EXPECT_TRUE(!ringBuffer.IsEmpty()); 806 EXPECT_TRUE(!ringBuffer.IsFull()); 807 EXPECT_EQ(ringBuffer.AvailableWrite(), 5u); 808 EXPECT_EQ(ringBuffer.AvailableRead(), 5u); 809 810 short out[8] = {}; 811 rv = ringBuffer.Read(Span(out, 3)); 812 EXPECT_EQ(rv, 3u); 813 EXPECT_TRUE(!ringBuffer.IsEmpty()); 814 EXPECT_TRUE(!ringBuffer.IsFull()); 815 EXPECT_EQ(ringBuffer.AvailableWrite(), 8u); 816 EXPECT_EQ(ringBuffer.AvailableRead(), 2u); 817 for (uint32_t i = 0; i < rv; ++i) { 818 EXPECT_EQ(out[i], in[i + 3]); 819 } 820 821 rv = ringBuffer.Discard(3); 822 EXPECT_EQ(rv, 2u); 823 EXPECT_TRUE(ringBuffer.IsEmpty()); 824 EXPECT_TRUE(!ringBuffer.IsFull()); 825 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 826 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 827 828 ringBuffer.WriteSilence(4); 829 rv = ringBuffer.Discard(6); 830 EXPECT_EQ(rv, 4u); 831 EXPECT_TRUE(ringBuffer.IsEmpty()); 832 EXPECT_TRUE(!ringBuffer.IsFull()); 833 EXPECT_EQ(ringBuffer.AvailableWrite(), 10u); 834 EXPECT_EQ(ringBuffer.AvailableRead(), 0u); 835 } 836 837 TEST(TestRingBuffer, WriteFromRing1) 838 { 839 AudioRingBuffer ringBuffer1(11 * sizeof(float)); 840 ringBuffer1.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 841 AudioRingBuffer ringBuffer2(11 * sizeof(float)); 842 ringBuffer2.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 843 844 float in[4] = {.1, .2, .3, .4}; 845 uint32_t rv = ringBuffer1.Write(Span<const float>(in, 4)); 846 EXPECT_EQ(rv, 4u); 847 848 EXPECT_EQ(ringBuffer2.AvailableRead(), 0u); 849 rv = ringBuffer2.Write(ringBuffer1, 4); 850 EXPECT_EQ(rv, 4u); 851 EXPECT_EQ(ringBuffer2.AvailableRead(), 4u); 852 853 float out[4] = {}; 854 rv = ringBuffer2.Read(Span<float>(out, 4)); 855 EXPECT_EQ(rv, 4u); 856 for (uint32_t i = 0; i < 4; ++i) { 857 EXPECT_FLOAT_EQ(in[i], out[i]); 858 } 859 } 860 861 TEST(TestRingBuffer, WriteFromRing2) 862 { 863 AudioRingBuffer ringBuffer1(11 * sizeof(float)); 864 ringBuffer1.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 865 AudioRingBuffer ringBuffer2(11 * sizeof(float)); 866 ringBuffer2.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 867 868 // Advance the index 869 ringBuffer2.WriteSilence(8); 870 ringBuffer2.Clear(); 871 872 float in[4] = {.1, .2, .3, .4}; 873 uint32_t rv = ringBuffer1.Write(Span<const float>(in, 4)); 874 EXPECT_EQ(rv, 4u); 875 rv = ringBuffer2.Write(ringBuffer1, 4); 876 EXPECT_EQ(rv, 4u); 877 EXPECT_EQ(ringBuffer2.AvailableRead(), 4u); 878 879 float out[4] = {}; 880 rv = ringBuffer2.Read(Span<float>(out, 4)); 881 EXPECT_EQ(rv, 4u); 882 for (uint32_t i = 0; i < 4; ++i) { 883 EXPECT_FLOAT_EQ(in[i], out[i]); 884 } 885 } 886 887 TEST(TestRingBuffer, WriteFromRing3) 888 { 889 AudioRingBuffer ringBuffer1(11 * sizeof(float)); 890 ringBuffer1.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 891 AudioRingBuffer ringBuffer2(11 * sizeof(float)); 892 ringBuffer2.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 893 894 // Advance the index 895 ringBuffer2.WriteSilence(8); 896 ringBuffer2.Clear(); 897 ringBuffer2.WriteSilence(4); 898 ringBuffer2.Clear(); 899 900 float in[4] = {.1, .2, .3, .4}; 901 uint32_t rv = ringBuffer1.Write(Span<const float>(in, 4)); 902 EXPECT_EQ(rv, 4u); 903 rv = ringBuffer2.Write(ringBuffer1, 4); 904 EXPECT_EQ(rv, 4u); 905 EXPECT_EQ(ringBuffer2.AvailableRead(), 4u); 906 907 float out[4] = {}; 908 rv = ringBuffer2.Read(Span<float>(out, 4)); 909 EXPECT_EQ(rv, 4u); 910 for (uint32_t i = 0; i < 4; ++i) { 911 EXPECT_FLOAT_EQ(in[i], out[i]); 912 } 913 } 914 915 TEST(TestAudioRingBuffer, WriteFromRingShort) 916 { 917 AudioRingBuffer ringBuffer1(11 * sizeof(short)); 918 ringBuffer1.SetSampleFormat(AUDIO_FORMAT_S16); 919 920 short in[8] = {0, 1, 2, 3, 4, 5, 6, 7}; 921 uint32_t rv = ringBuffer1.Write(Span(in, 8)); 922 EXPECT_EQ(rv, 8u); 923 924 AudioRingBuffer ringBuffer2(11 * sizeof(short)); 925 ringBuffer2.SetSampleFormat(AUDIO_FORMAT_S16); 926 927 rv = ringBuffer2.Write(ringBuffer1, 4); 928 EXPECT_EQ(rv, 4u); 929 EXPECT_EQ(ringBuffer2.AvailableRead(), 4u); 930 EXPECT_EQ(ringBuffer1.AvailableRead(), 8u); 931 932 short out[4] = {}; 933 rv = ringBuffer2.Read(Span(out, 4)); 934 for (uint32_t i = 0; i < rv; ++i) { 935 EXPECT_EQ(out[i], in[i]); 936 } 937 938 rv = ringBuffer2.Write(ringBuffer1, 4); 939 EXPECT_EQ(rv, 4u); 940 EXPECT_EQ(ringBuffer2.AvailableRead(), 4u); 941 EXPECT_EQ(ringBuffer1.AvailableRead(), 8u); 942 943 ringBuffer1.Discard(4); 944 rv = ringBuffer2.Write(ringBuffer1, 4); 945 EXPECT_EQ(rv, 4u); 946 EXPECT_EQ(ringBuffer2.AvailableRead(), 8u); 947 EXPECT_EQ(ringBuffer1.AvailableRead(), 4u); 948 949 short out2[8] = {}; 950 rv = ringBuffer2.Read(Span(out2, 8)); 951 for (uint32_t i = 0; i < rv; ++i) { 952 EXPECT_EQ(out2[i], in[i]); 953 } 954 } 955 956 TEST(TestAudioRingBuffer, WriteFromRingFloat) 957 { 958 AudioRingBuffer ringBuffer1(11 * sizeof(float)); 959 ringBuffer1.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 960 961 float in[8] = {.0, .1, .2, .3, .4, .5, .6, .7}; 962 uint32_t rv = ringBuffer1.Write(Span(in, 8)); 963 EXPECT_EQ(rv, 8u); 964 965 AudioRingBuffer ringBuffer2(11 * sizeof(float)); 966 ringBuffer2.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 967 968 rv = ringBuffer2.Write(ringBuffer1, 4); 969 EXPECT_EQ(rv, 4u); 970 EXPECT_EQ(ringBuffer2.AvailableRead(), 4u); 971 EXPECT_EQ(ringBuffer1.AvailableRead(), 8u); 972 973 float out[4] = {}; 974 rv = ringBuffer2.Read(Span(out, 4)); 975 for (uint32_t i = 0; i < rv; ++i) { 976 EXPECT_FLOAT_EQ(out[i], in[i]); 977 } 978 979 rv = ringBuffer2.Write(ringBuffer1, 4); 980 EXPECT_EQ(rv, 4u); 981 EXPECT_EQ(ringBuffer2.AvailableRead(), 4u); 982 EXPECT_EQ(ringBuffer1.AvailableRead(), 8u); 983 984 ringBuffer1.Discard(4); 985 rv = ringBuffer2.Write(ringBuffer1, 4); 986 EXPECT_EQ(rv, 4u); 987 EXPECT_EQ(ringBuffer2.AvailableRead(), 8u); 988 EXPECT_EQ(ringBuffer1.AvailableRead(), 4u); 989 990 float out2[8] = {}; 991 rv = ringBuffer2.Read(Span(out2, 8)); 992 for (uint32_t i = 0; i < rv; ++i) { 993 EXPECT_FLOAT_EQ(out2[i], in[i]); 994 } 995 } 996 997 TEST(TestAudioRingBuffer, PrependSilenceWrapsFloat) 998 { 999 AudioRingBuffer rb(9 * sizeof(float)); 1000 rb.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 1001 1002 float in[6] = {.2, .3, .4, .5, .6, .7}; 1003 uint32_t rv = rb.Write(Span(in, 6)); 1004 EXPECT_EQ(rv, 6u); 1005 1006 float out[8] = {}; 1007 auto outSpan = Span(out, 8); 1008 rv = rb.Read(outSpan.Subspan(0, 1)); 1009 EXPECT_EQ(rv, 1u); 1010 1011 // PrependSilence will have to wrap around the start and put the silent 1012 // samples at indices 0 and 8 of the ring buffer. 1013 rv = rb.PrependSilence(2); 1014 EXPECT_EQ(rv, 2u); 1015 1016 rv = rb.Read(outSpan.Subspan(1, 7)); 1017 EXPECT_EQ(rv, 7u); 1018 1019 EXPECT_THAT(out, ElementsAre(.2, 0, 0, .3, .4, .5, .6, .7)); 1020 } 1021 1022 TEST(TestAudioRingBuffer, PrependSilenceWrapsShort) 1023 { 1024 AudioRingBuffer rb(9 * sizeof(short)); 1025 rb.SetSampleFormat(AUDIO_FORMAT_S16); 1026 1027 short in[6] = {2, 3, 4, 5, 6, 7}; 1028 uint32_t rv = rb.Write(Span(in, 6)); 1029 EXPECT_EQ(rv, 6u); 1030 1031 short out[8] = {}; 1032 auto outSpan = Span(out, 8); 1033 rv = rb.Read(outSpan.Subspan(0, 1)); 1034 EXPECT_EQ(rv, 1u); 1035 1036 // PrependSilence will have to wrap around the start and put the silent 1037 // samples at indices 0 and 8 of the ring buffer. 1038 rv = rb.PrependSilence(2); 1039 EXPECT_EQ(rv, 2u); 1040 1041 rv = rb.Read(outSpan.Subspan(1, 7)); 1042 EXPECT_EQ(rv, 7u); 1043 1044 EXPECT_THAT(out, ElementsAre(2, 0, 0, 3, 4, 5, 6, 7)); 1045 } 1046 1047 TEST(TestAudioRingBuffer, PrependSilenceNoWrapFloat) 1048 { 1049 AudioRingBuffer rb(9 * sizeof(float)); 1050 rb.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 1051 1052 float in[6] = {.2, .3, .4, .5, .6, .7}; 1053 uint32_t rv = rb.Write(Span(in, 6)); 1054 EXPECT_EQ(rv, 6u); 1055 1056 float out[8] = {}; 1057 auto outSpan = Span(out, 8); 1058 rv = rb.Read(outSpan.To(4)); 1059 EXPECT_EQ(rv, 4u); 1060 1061 // PrependSilence will put the silent samples at indices 2 and 3 of the ring 1062 // buffer. 1063 rv = rb.PrependSilence(2); 1064 EXPECT_EQ(rv, 2u); 1065 1066 rv = rb.Read(outSpan.Subspan(4, 4)); 1067 EXPECT_EQ(rv, 4u); 1068 1069 EXPECT_THAT(out, ElementsAre(.2, .3, .4, .5, 0, 0, .6, .7)); 1070 } 1071 1072 TEST(TestAudioRingBuffer, PrependSilenceNoWrapShort) 1073 { 1074 AudioRingBuffer rb(9 * sizeof(short)); 1075 rb.SetSampleFormat(AUDIO_FORMAT_S16); 1076 1077 short in[6] = {2, 3, 4, 5, 6, 7}; 1078 uint32_t rv = rb.Write(Span(in, 6)); 1079 EXPECT_EQ(rv, 6u); 1080 1081 short out[8] = {}; 1082 auto outSpan = Span(out, 8); 1083 rv = rb.Read(outSpan.To(4)); 1084 EXPECT_EQ(rv, 4u); 1085 1086 // PrependSilence will put the silent samples at indices 2 and 3 of the ring 1087 // buffer. 1088 rv = rb.PrependSilence(2); 1089 EXPECT_EQ(rv, 2u); 1090 1091 rv = rb.Read(outSpan.Subspan(4, 4)); 1092 EXPECT_EQ(rv, 4u); 1093 1094 EXPECT_THAT(out, ElementsAre(2, 3, 4, 5, 0, 0, 6, 7)); 1095 } 1096 1097 TEST(TestAudioRingBuffer, EnsureLengthBytesNoWrapFloat) 1098 { 1099 AudioRingBuffer rb(6 * sizeof(float)); 1100 rb.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 1101 1102 float in[5] = {.1, .2, .3, .4, .5}; 1103 uint32_t rv = rb.Write(Span(in, 5)); 1104 EXPECT_EQ(rv, 5u); 1105 EXPECT_EQ(rb.AvailableRead(), 5u); 1106 EXPECT_EQ(rb.AvailableWrite(), 0u); 1107 EXPECT_EQ(rb.Capacity(), 6u); 1108 1109 EXPECT_TRUE(rb.EnsureLengthBytes(11 * sizeof(float))); 1110 float out[10] = {}; 1111 rv = rb.Read(Span(out, 10)); 1112 EXPECT_EQ(rv, 5u); 1113 EXPECT_EQ(rb.AvailableRead(), 0u); 1114 EXPECT_EQ(rb.AvailableWrite(), 10u); 1115 EXPECT_EQ(rb.Capacity(), 11u); 1116 EXPECT_THAT(out, ElementsAre(.1, .2, .3, .4, .5, 0, 0, 0, 0, 0)); 1117 } 1118 1119 TEST(TestAudioRingBuffer, EnsureLengthBytesNoWrapShort) 1120 { 1121 AudioRingBuffer rb(6 * sizeof(short)); 1122 rb.SetSampleFormat(AUDIO_FORMAT_S16); 1123 1124 short in[5] = {1, 2, 3, 4, 5}; 1125 uint32_t rv = rb.Write(Span(in, 5)); 1126 EXPECT_EQ(rv, 5u); 1127 EXPECT_EQ(rb.AvailableRead(), 5u); 1128 EXPECT_EQ(rb.AvailableWrite(), 0u); 1129 EXPECT_EQ(rb.Capacity(), 6u); 1130 1131 EXPECT_TRUE(rb.EnsureLengthBytes(11 * sizeof(short))); 1132 short out[10] = {}; 1133 rv = rb.Read(Span(out, 10)); 1134 EXPECT_EQ(rv, 5u); 1135 EXPECT_EQ(rb.AvailableRead(), 0u); 1136 EXPECT_EQ(rb.AvailableWrite(), 10u); 1137 EXPECT_EQ(rb.Capacity(), 11u); 1138 EXPECT_THAT(out, ElementsAre(1, 2, 3, 4, 5, 0, 0, 0, 0, 0)); 1139 } 1140 1141 TEST(TestAudioRingBuffer, EnsureLengthBytesWrap1PartFloat) 1142 { 1143 AudioRingBuffer rb(6 * sizeof(float)); 1144 rb.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 1145 1146 EXPECT_EQ(rb.WriteSilence(3), 3u); 1147 EXPECT_EQ(rb.AvailableRead(), 3u); 1148 EXPECT_EQ(rb.AvailableWrite(), 2u); 1149 EXPECT_EQ(rb.Capacity(), 6u); 1150 1151 float outSilence[3] = {}; 1152 EXPECT_EQ(rb.Read(Span(outSilence, 3)), 3u); 1153 EXPECT_EQ(rb.AvailableRead(), 0u); 1154 EXPECT_EQ(rb.AvailableWrite(), 5u); 1155 1156 float in[5] = {.1, .2, .3, .4, .5}; 1157 EXPECT_EQ(rb.Write(Span(in, 5)), 5u); 1158 EXPECT_EQ(rb.AvailableRead(), 5u); 1159 EXPECT_EQ(rb.AvailableWrite(), 0u); 1160 1161 EXPECT_TRUE(rb.EnsureLengthBytes(11 * sizeof(float))); 1162 EXPECT_EQ(rb.AvailableRead(), 5u); 1163 EXPECT_EQ(rb.AvailableWrite(), 5u); 1164 1165 float in2[2] = {.6, .7}; 1166 EXPECT_EQ(rb.Write(Span(in2, 2)), 2u); 1167 EXPECT_EQ(rb.AvailableRead(), 7u); 1168 EXPECT_EQ(rb.AvailableWrite(), 3u); 1169 1170 float out[10] = {}; 1171 EXPECT_EQ(rb.Read(Span(out, 10)), 7u); 1172 EXPECT_EQ(rb.AvailableRead(), 0u); 1173 EXPECT_EQ(rb.AvailableWrite(), 10u); 1174 EXPECT_EQ(rb.Capacity(), 11u); 1175 EXPECT_THAT(out, ElementsAre(.1, .2, .3, .4, .5, .6, .7, 0, 0, 0)); 1176 } 1177 1178 TEST(TestAudioRingBuffer, EnsureLengthBytesWrap1PartShort) 1179 { 1180 AudioRingBuffer rb(6 * sizeof(short)); 1181 rb.SetSampleFormat(AUDIO_FORMAT_S16); 1182 1183 EXPECT_EQ(rb.WriteSilence(3), 3u); 1184 EXPECT_EQ(rb.AvailableRead(), 3u); 1185 EXPECT_EQ(rb.AvailableWrite(), 2u); 1186 EXPECT_EQ(rb.Capacity(), 6u); 1187 1188 short outSilence[3] = {}; 1189 EXPECT_EQ(rb.Read(Span(outSilence, 3)), 3u); 1190 EXPECT_EQ(rb.AvailableRead(), 0u); 1191 EXPECT_EQ(rb.AvailableWrite(), 5u); 1192 1193 short in[5] = {1, 2, 3, 4, 5}; 1194 EXPECT_EQ(rb.Write(Span(in, 5)), 5u); 1195 EXPECT_EQ(rb.AvailableRead(), 5u); 1196 EXPECT_EQ(rb.AvailableWrite(), 0u); 1197 1198 EXPECT_TRUE(rb.EnsureLengthBytes(11 * sizeof(short))); 1199 EXPECT_EQ(rb.AvailableRead(), 5u); 1200 EXPECT_EQ(rb.AvailableWrite(), 5u); 1201 1202 short in2[2] = {6, 7}; 1203 EXPECT_EQ(rb.Write(Span(in2, 2)), 2u); 1204 EXPECT_EQ(rb.AvailableRead(), 7u); 1205 EXPECT_EQ(rb.AvailableWrite(), 3u); 1206 1207 short out[10] = {}; 1208 EXPECT_EQ(rb.Read(Span(out, 10)), 7u); 1209 EXPECT_EQ(rb.AvailableRead(), 0u); 1210 EXPECT_EQ(rb.AvailableWrite(), 10u); 1211 EXPECT_EQ(rb.Capacity(), 11u); 1212 EXPECT_THAT(out, ElementsAre(1, 2, 3, 4, 5, 6, 7, 0, 0, 0)); 1213 } 1214 1215 TEST(TestAudioRingBuffer, EnsureLengthBytesWrap2PartsFloat) 1216 { 1217 AudioRingBuffer rb(6 * sizeof(float)); 1218 rb.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 1219 1220 EXPECT_EQ(rb.WriteSilence(3), 3u); 1221 EXPECT_EQ(rb.AvailableRead(), 3u); 1222 EXPECT_EQ(rb.AvailableWrite(), 2u); 1223 EXPECT_EQ(rb.Capacity(), 6u); 1224 1225 float outSilence[3] = {}; 1226 EXPECT_EQ(rb.Read(Span(outSilence, 3)), 3u); 1227 EXPECT_EQ(rb.AvailableRead(), 0u); 1228 EXPECT_EQ(rb.AvailableWrite(), 5u); 1229 1230 float in[5] = {.1, .2, .3, .4, .5}; 1231 EXPECT_EQ(rb.Write(Span(in, 5)), 5u); 1232 EXPECT_EQ(rb.AvailableRead(), 5u); 1233 EXPECT_EQ(rb.AvailableWrite(), 0u); 1234 1235 EXPECT_TRUE(rb.EnsureLengthBytes(8 * sizeof(float))); 1236 EXPECT_EQ(rb.AvailableRead(), 5u); 1237 EXPECT_EQ(rb.AvailableWrite(), 2u); 1238 1239 float in2[2] = {.6, .7}; 1240 EXPECT_EQ(rb.Write(Span(in2, 2)), 2u); 1241 EXPECT_EQ(rb.AvailableRead(), 7u); 1242 EXPECT_EQ(rb.AvailableWrite(), 0u); 1243 1244 float out[8] = {}; 1245 EXPECT_EQ(rb.Read(Span(out, 8)), 7u); 1246 EXPECT_EQ(rb.AvailableRead(), 0u); 1247 EXPECT_EQ(rb.AvailableWrite(), 7u); 1248 EXPECT_EQ(rb.Capacity(), 8u); 1249 EXPECT_THAT(out, ElementsAre(.1, .2, .3, .4, .5, .6, .7, 0)); 1250 } 1251 1252 TEST(TestAudioRingBuffer, EnsureLengthBytesWrap2PartsShort) 1253 { 1254 AudioRingBuffer rb(6 * sizeof(short)); 1255 rb.SetSampleFormat(AUDIO_FORMAT_S16); 1256 1257 EXPECT_EQ(rb.WriteSilence(3), 3u); 1258 EXPECT_EQ(rb.AvailableRead(), 3u); 1259 EXPECT_EQ(rb.AvailableWrite(), 2u); 1260 EXPECT_EQ(rb.Capacity(), 6u); 1261 1262 short outSilence[3] = {}; 1263 EXPECT_EQ(rb.Read(Span(outSilence, 3)), 3u); 1264 EXPECT_EQ(rb.AvailableRead(), 0u); 1265 EXPECT_EQ(rb.AvailableWrite(), 5u); 1266 1267 short in[5] = {1, 2, 3, 4, 5}; 1268 EXPECT_EQ(rb.Write(Span(in, 5)), 5u); 1269 EXPECT_EQ(rb.AvailableRead(), 5u); 1270 EXPECT_EQ(rb.AvailableWrite(), 0u); 1271 1272 EXPECT_TRUE(rb.EnsureLengthBytes(8 * sizeof(short))); 1273 EXPECT_EQ(rb.AvailableRead(), 5u); 1274 EXPECT_EQ(rb.AvailableWrite(), 2u); 1275 1276 short in2[2] = {6, 7}; 1277 EXPECT_EQ(rb.Write(Span(in2, 2)), 2u); 1278 EXPECT_EQ(rb.AvailableRead(), 7u); 1279 EXPECT_EQ(rb.AvailableWrite(), 0u); 1280 1281 short out[8] = {}; 1282 EXPECT_EQ(rb.Read(Span(out, 8)), 7u); 1283 EXPECT_EQ(rb.AvailableRead(), 0u); 1284 EXPECT_EQ(rb.AvailableWrite(), 7u); 1285 EXPECT_EQ(rb.Capacity(), 8u); 1286 EXPECT_THAT(out, ElementsAre(1, 2, 3, 4, 5, 6, 7, 0)); 1287 } 1288 1289 TEST(TestAudioRingBuffer, EnsureLengthShorter) 1290 { 1291 AudioRingBuffer rb(5 * sizeof(float)); 1292 rb.SetSampleFormat(AUDIO_FORMAT_FLOAT32); 1293 1294 float in[5] = {.1, .2, .3, .4, .5}; 1295 EXPECT_EQ(rb.Write(Span(in, 5)), 4u); 1296 EXPECT_EQ(rb.AvailableRead(), 4u); 1297 EXPECT_EQ(rb.AvailableWrite(), 0u); 1298 EXPECT_EQ(rb.Capacity(), 5u); 1299 1300 float out[5] = {}; 1301 EXPECT_EQ(rb.Read(Span(out, 3)), 3u); 1302 EXPECT_THAT(out, ElementsAre(.1, .2, .3, 0, 0)); 1303 EXPECT_EQ(rb.AvailableRead(), 1u); 1304 EXPECT_EQ(rb.AvailableWrite(), 3u); 1305 1306 EXPECT_TRUE(rb.EnsureLengthBytes(3 * sizeof(float))); 1307 EXPECT_EQ(rb.AvailableRead(), 1u); 1308 EXPECT_EQ(rb.AvailableWrite(), 3u); 1309 EXPECT_EQ(rb.Capacity(), 5u); 1310 EXPECT_EQ(rb.Write(Span(in, 5)), 3u); 1311 EXPECT_EQ(rb.Read(Span(out, 5)), 4u); 1312 EXPECT_THAT(out, ElementsAre(.4, .1, .2, .3, 0)); 1313 }