dom/media/driftcontrol/gtest/TestAudioChunkList.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   4  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "gtest/gtest.h"
   7
   8 #include "AudioChunkList.h"
   9 #include "nsContentUtils.h"
  10
  11 using namespace mozilla;
  12
  13 TEST(TestAudioChunkList, Basic1)
  14 {
  15   const PrincipalHandle testPrincipal =
  16       MakePrincipalHandle(nsContentUtils::GetSystemPrincipal());
  17   AudioChunkList list(256, 2, testPrincipal);
  18   list.SetSampleFormat(AUDIO_FORMAT_FLOAT32);
  19   EXPECT_EQ(list.ChunkCapacity(), 128u);
  20   EXPECT_EQ(list.TotalCapacity(), 256u);
  21
  22   AudioChunk& c1 = list.GetNext();
  23   float* c1_ch1 = c1.ChannelDataForWrite<float>(0);
  24   float* c1_ch2 = c1.ChannelDataForWrite<float>(1);
  25   EXPECT_EQ(c1.mPrincipalHandle, testPrincipal);
  26   EXPECT_EQ(c1.mBufferFormat, AUDIO_FORMAT_FLOAT32);
  27   for (uint32_t i = 0; i < list.ChunkCapacity(); ++i) {
  28     c1_ch1[i] = c1_ch2[i] = 0.01f * static_cast<float>(i);
  29   }
  30   AudioChunk& c2 = list.GetNext();
  31   EXPECT_EQ(c2.mPrincipalHandle, testPrincipal);
  32   EXPECT_EQ(c2.mBufferFormat, AUDIO_FORMAT_FLOAT32);
  33   EXPECT_NE(c1.mBuffer.get(), c2.mBuffer.get());
  34   AudioChunk& c3 = list.GetNext();
  35   EXPECT_EQ(c3.mPrincipalHandle, testPrincipal);
  36   EXPECT_EQ(c3.mBufferFormat, AUDIO_FORMAT_FLOAT32);
  37   // Cycle
  38   EXPECT_EQ(c1.mBuffer.get(), c3.mBuffer.get());
  39   float* c3_ch1 = c3.ChannelDataForWrite<float>(0);
  40   float* c3_ch2 = c3.ChannelDataForWrite<float>(1);
  41   for (uint32_t i = 0; i < list.ChunkCapacity(); ++i) {
  42     EXPECT_FLOAT_EQ(c1_ch1[i], c3_ch1[i]);
  43     EXPECT_FLOAT_EQ(c1_ch2[i], c3_ch2[i]);
  44   }
  45 }
  46
  47 TEST(TestAudioChunkList, Basic2)
  48 {
  49   const PrincipalHandle testPrincipal =
  50       MakePrincipalHandle(nsContentUtils::GetSystemPrincipal());
  51   AudioChunkList list(256, 2, testPrincipal);
  52   list.SetSampleFormat(AUDIO_FORMAT_S16);
  53   EXPECT_EQ(list.ChunkCapacity(), 256u);
  54   EXPECT_EQ(list.TotalCapacity(), 512u);
  55
  56   AudioChunk& c1 = list.GetNext();
  57   EXPECT_EQ(c1.mPrincipalHandle, testPrincipal);
  58   EXPECT_EQ(c1.mBufferFormat, AUDIO_FORMAT_S16);
  59   short* c1_ch1 = c1.ChannelDataForWrite<short>(0);
  60   short* c1_ch2 = c1.ChannelDataForWrite<short>(1);
  61   for (uint32_t i = 0; i < list.ChunkCapacity(); ++i) {
  62     c1_ch1[i] = c1_ch2[i] = static_cast<short>(i);
  63   }
  64   AudioChunk& c2 = list.GetNext();
  65   EXPECT_EQ(c2.mPrincipalHandle, testPrincipal);
  66   EXPECT_EQ(c2.mBufferFormat, AUDIO_FORMAT_S16);
  67   EXPECT_NE(c1.mBuffer.get(), c2.mBuffer.get());
  68   AudioChunk& c3 = list.GetNext();
  69   EXPECT_EQ(c3.mPrincipalHandle, testPrincipal);
  70   EXPECT_EQ(c3.mBufferFormat, AUDIO_FORMAT_S16);
  71   AudioChunk& c4 = list.GetNext();
  72   EXPECT_EQ(c4.mPrincipalHandle, testPrincipal);
  73   EXPECT_EQ(c4.mBufferFormat, AUDIO_FORMAT_S16);
  74   // Cycle
  75   AudioChunk& c5 = list.GetNext();
  76   EXPECT_EQ(c5.mPrincipalHandle, testPrincipal);
  77   EXPECT_EQ(c5.mBufferFormat, AUDIO_FORMAT_S16);
  78   EXPECT_EQ(c1.mBuffer.get(), c5.mBuffer.get());
  79   short* c5_ch1 = c5.ChannelDataForWrite<short>(0);
  80   short* c5_ch2 = c5.ChannelDataForWrite<short>(1);
  81   for (uint32_t i = 0; i < list.ChunkCapacity(); ++i) {
  82     EXPECT_EQ(c1_ch1[i], c5_ch1[i]);
  83     EXPECT_EQ(c1_ch2[i], c5_ch2[i]);
  84   }
  85 }
  86
  87 TEST(TestAudioChunkList, Basic3)
  88 {
  89   AudioChunkList list(260, 2, PRINCIPAL_HANDLE_NONE);
  90   list.SetSampleFormat(AUDIO_FORMAT_FLOAT32);
  91   EXPECT_EQ(list.ChunkCapacity(), 128u);
  92   EXPECT_EQ(list.TotalCapacity(), 256u + 128u);
  93
  94   AudioChunk& c1 = list.GetNext();
  95   AudioChunk& c2 = list.GetNext();
  96   EXPECT_NE(c1.mBuffer.get(), c2.mBuffer.get());
  97   AudioChunk& c3 = list.GetNext();
  98   EXPECT_NE(c1.mBuffer.get(), c3.mBuffer.get());
  99   AudioChunk& c4 = list.GetNext();
 100   EXPECT_EQ(c1.mBuffer.get(), c4.mBuffer.get());
 101 }
 102
 103 TEST(TestAudioChunkList, Basic4)
 104 {
 105   AudioChunkList list(260, 2, PRINCIPAL_HANDLE_NONE);
 106   list.SetSampleFormat(AUDIO_FORMAT_S16);
 107   EXPECT_EQ(list.ChunkCapacity(), 256u);
 108   EXPECT_EQ(list.TotalCapacity(), 512u + 256u);
 109
 110   AudioChunk& c1 = list.GetNext();
 111   AudioChunk& c2 = list.GetNext();
 112   EXPECT_NE(c1.mBuffer.get(), c2.mBuffer.get());
 113   AudioChunk& c3 = list.GetNext();
 114   EXPECT_NE(c1.mBuffer.get(), c3.mBuffer.get());
 115   AudioChunk& c4 = list.GetNext();
 116   EXPECT_EQ(c1.mBuffer.get(), c4.mBuffer.get());
 117 }
 118
 119 TEST(TestAudioChunkList, UpdateChannels)
 120 {
 121   AudioChunkList list(256, 2, PRINCIPAL_HANDLE_NONE);
 122   list.SetSampleFormat(AUDIO_FORMAT_FLOAT32);
 123
 124   AudioChunk& c1 = list.GetNext();
 125   AudioChunk& c2 = list.GetNext();
 126   EXPECT_EQ(c1.ChannelCount(), 2u);
 127   EXPECT_EQ(c2.ChannelCount(), 2u);
 128
 129   // Update to Quad
 130   list.Update(4);
 131
 132   AudioChunk& c3 = list.GetNext();
 133   AudioChunk& c4 = list.GetNext();
 134   EXPECT_EQ(c3.ChannelCount(), 4u);
 135   EXPECT_EQ(c4.ChannelCount(), 4u);
 136 }
 137
 138 TEST(TestAudioChunkList, UpdateBetweenMonoAndStereo)
 139 {
 140   AudioChunkList list(256, 2, PRINCIPAL_HANDLE_NONE);
 141   list.SetSampleFormat(AUDIO_FORMAT_FLOAT32);
 142
 143   AudioChunk& c1 = list.GetNext();
 144   float* c1_ch1 = c1.ChannelDataForWrite<float>(0);
 145   float* c1_ch2 = c1.ChannelDataForWrite<float>(1);
 146   for (uint32_t i = 0; i < list.ChunkCapacity(); ++i) {
 147     c1_ch1[i] = c1_ch2[i] = 0.01f * static_cast<float>(i);
 148   }
 149
 150   AudioChunk& c2 = list.GetNext();
 151   EXPECT_EQ(c1.ChannelCount(), 2u);
 152   EXPECT_EQ(c2.ChannelCount(), 2u);
 153
 154   // Downmix to mono
 155   list.Update(1);
 156
 157   AudioChunk& c3 = list.GetNext();
 158   float* c3_ch1 = c3.ChannelDataForWrite<float>(0);
 159   for (uint32_t i = 0; i < list.ChunkCapacity(); ++i) {
 160     EXPECT_FLOAT_EQ(c3_ch1[i], c1_ch1[i]);
 161   }
 162
 163   AudioChunk& c4 = list.GetNext();
 164   EXPECT_EQ(c3.ChannelCount(), 1u);
 165   EXPECT_EQ(c4.ChannelCount(), 1u);
 166   EXPECT_EQ(static_cast<SharedChannelArrayBuffer<float>*>(c3.mBuffer.get())
 167                 ->mBuffers[0]
 168                 .Length(),
 169             list.ChunkCapacity());
 170
 171   // Upmix to stereo
 172   list.Update(2);
 173
 174   AudioChunk& c5 = list.GetNext();
 175   AudioChunk& c6 = list.GetNext();
 176   EXPECT_EQ(c5.ChannelCount(), 2u);
 177   EXPECT_EQ(c6.ChannelCount(), 2u);
 178   EXPECT_EQ(static_cast<SharedChannelArrayBuffer<float>*>(c5.mBuffer.get())
 179                 ->mBuffers[0]
 180                 .Length(),
 181             list.ChunkCapacity());
 182   EXPECT_EQ(static_cast<SharedChannelArrayBuffer<float>*>(c5.mBuffer.get())
 183                 ->mBuffers[1]
 184                 .Length(),
 185             list.ChunkCapacity());
 186
 187   // Downmix to mono
 188   list.Update(1);
 189
 190   AudioChunk& c7 = list.GetNext();
 191   float* c7_ch1 = c7.ChannelDataForWrite<float>(0);
 192   for (uint32_t i = 0; i < list.ChunkCapacity(); ++i) {
 193     EXPECT_FLOAT_EQ(c7_ch1[i], c1_ch1[i]);
 194   }
 195
 196   AudioChunk& c8 = list.GetNext();
 197   EXPECT_EQ(c7.ChannelCount(), 1u);
 198   EXPECT_EQ(c8.ChannelCount(), 1u);
 199   EXPECT_EQ(static_cast<SharedChannelArrayBuffer<float>*>(c7.mBuffer.get())
 200                 ->mBuffers[0]
 201                 .Length(),
 202             list.ChunkCapacity());
 203 }
 204
 205 TEST(TestAudioChunkList, ConsumeAndForget)
 206 {
 207   AudioSegment s;
 208   AudioChunkList list(256, 2, PRINCIPAL_HANDLE_NONE);
 209   list.SetSampleFormat(AUDIO_FORMAT_FLOAT32);
 210
 211   AudioChunk& c1 = list.GetNext();
 212   AudioChunk tmp1 = c1;
 213   s.AppendAndConsumeChunk(std::move(tmp1));
 214   EXPECT_FALSE(c1.mBuffer.get() == nullptr);
 215   EXPECT_EQ(c1.ChannelData<float>().Length(), 2u);
 216
 217   AudioChunk& c2 = list.GetNext();
 218   AudioChunk tmp2 = c2;
 219   s.AppendAndConsumeChunk(std::move(tmp2));
 220   EXPECT_FALSE(c2.mBuffer.get() == nullptr);
 221   EXPECT_EQ(c2.ChannelData<float>().Length(), 2u);
 222
 223   s.ForgetUpTo(256);
 224   list.GetNext();
 225   list.GetNext();
 226 }