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