audio_buffer_queue_unittest.cc 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381
  1. // Copyright 2013 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "media/base/audio_buffer_queue.h"
  5. #include <stdint.h>
  6. #include <limits>
  7. #include <memory>
  8. #include "base/time/time.h"
  9. #include "media/base/audio_buffer.h"
  10. #include "media/base/audio_bus.h"
  11. #include "media/base/test_helpers.h"
  12. #include "media/base/timestamp_constants.h"
  13. #include "testing/gtest/include/gtest/gtest.h"
  14. namespace media {
  15. constexpr int kSampleRate = 44100;
  16. enum class ValueType { kNormal, kFloat };
  17. static void VerifyBus(AudioBus* bus,
  18. int offset,
  19. int frames,
  20. int buffer_size,
  21. float start,
  22. float increment,
  23. ValueType type = ValueType::kNormal) {
  24. for (int ch = 0; ch < bus->channels(); ++ch) {
  25. const float v = start + ch * buffer_size * increment;
  26. for (int i = offset; i < offset + frames; ++i) {
  27. float expected_value = v + (i - offset) * increment;
  28. if (type == ValueType::kFloat)
  29. expected_value /= std::numeric_limits<uint16_t>::max();
  30. ASSERT_FLOAT_EQ(expected_value, bus->channel(ch)[i])
  31. << "i=" << i << ", ch=" << ch;
  32. }
  33. }
  34. }
  35. template <typename T>
  36. static scoped_refptr<AudioBuffer> MakeTestBuffer(SampleFormat format,
  37. ChannelLayout channel_layout,
  38. T start,
  39. T step,
  40. int frames) {
  41. return MakeAudioBuffer<T>(format, channel_layout,
  42. ChannelLayoutToChannelCount(channel_layout),
  43. kSampleRate, start, step, frames, kNoTimestamp);
  44. }
  45. TEST(AudioBufferQueueTest, AppendAndClear) {
  46. const ChannelLayout channel_layout = CHANNEL_LAYOUT_MONO;
  47. AudioBufferQueue buffer;
  48. EXPECT_EQ(0, buffer.frames());
  49. buffer.Append(
  50. MakeTestBuffer<uint8_t>(kSampleFormatU8, channel_layout, 10, 1, 8));
  51. EXPECT_EQ(8, buffer.frames());
  52. buffer.Clear();
  53. EXPECT_EQ(0, buffer.frames());
  54. buffer.Append(
  55. MakeTestBuffer<uint8_t>(kSampleFormatU8, channel_layout, 20, 1, 8));
  56. EXPECT_EQ(8, buffer.frames());
  57. }
  58. TEST(AudioBufferQueueTest, MultipleAppend) {
  59. const ChannelLayout channel_layout = CHANNEL_LAYOUT_MONO;
  60. AudioBufferQueue buffer;
  61. buffer.Append(
  62. MakeTestBuffer<uint8_t>(kSampleFormatU8, channel_layout, 10, 1, 8));
  63. EXPECT_EQ(8, buffer.frames());
  64. buffer.Append(
  65. MakeTestBuffer<uint8_t>(kSampleFormatU8, channel_layout, 10, 1, 8));
  66. EXPECT_EQ(16, buffer.frames());
  67. buffer.Append(
  68. MakeTestBuffer<uint8_t>(kSampleFormatU8, channel_layout, 10, 1, 8));
  69. EXPECT_EQ(24, buffer.frames());
  70. buffer.Append(
  71. MakeTestBuffer<uint8_t>(kSampleFormatU8, channel_layout, 10, 1, 8));
  72. EXPECT_EQ(32, buffer.frames());
  73. buffer.Append(
  74. MakeTestBuffer<uint8_t>(kSampleFormatU8, channel_layout, 10, 1, 8));
  75. EXPECT_EQ(40, buffer.frames());
  76. }
  77. TEST(AudioBufferQueueTest, IteratorCheck) {
  78. const ChannelLayout channel_layout = CHANNEL_LAYOUT_MONO;
  79. const int channels = ChannelLayoutToChannelCount(channel_layout);
  80. AudioBufferQueue buffer;
  81. std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
  82. // Append 40 frames in 5 buffers. Intersperse ReadFrames() to make the
  83. // iterator is pointing to the correct position.
  84. buffer.Append(MakeTestBuffer<float>(
  85. kSampleFormatF32, channel_layout, 10.0f, 1.0f, 8));
  86. EXPECT_EQ(8, buffer.frames());
  87. EXPECT_EQ(4, buffer.ReadFrames(4, 0, bus.get()));
  88. EXPECT_EQ(4, buffer.frames());
  89. VerifyBus(bus.get(), 0, 4, bus->frames(), 10, 1, ValueType::kFloat);
  90. buffer.Append(MakeTestBuffer<float>(
  91. kSampleFormatF32, channel_layout, 20.0f, 1.0f, 8));
  92. EXPECT_EQ(12, buffer.frames());
  93. buffer.Append(MakeTestBuffer<float>(
  94. kSampleFormatF32, channel_layout, 30.0f, 1.0f, 8));
  95. EXPECT_EQ(20, buffer.frames());
  96. buffer.SeekFrames(16);
  97. EXPECT_EQ(4, buffer.ReadFrames(4, 0, bus.get()));
  98. EXPECT_EQ(0, buffer.frames());
  99. VerifyBus(bus.get(), 0, 4, bus->frames(), 34, 1, ValueType::kFloat);
  100. buffer.Append(MakeTestBuffer<float>(
  101. kSampleFormatF32, channel_layout, 40.0f, 1.0f, 8));
  102. EXPECT_EQ(8, buffer.frames());
  103. buffer.Append(MakeTestBuffer<float>(
  104. kSampleFormatF32, channel_layout, 50.0f, 1.0f, 8));
  105. EXPECT_EQ(16, buffer.frames());
  106. EXPECT_EQ(4, buffer.ReadFrames(4, 0, bus.get()));
  107. VerifyBus(bus.get(), 0, 4, bus->frames(), 40, 1, ValueType::kFloat);
  108. // Read off the end of the buffer.
  109. EXPECT_EQ(12, buffer.frames());
  110. buffer.SeekFrames(8);
  111. EXPECT_EQ(4, buffer.ReadFrames(100, 0, bus.get()));
  112. VerifyBus(bus.get(), 0, 4, bus->frames(), 54, 1, ValueType::kFloat);
  113. }
  114. TEST(AudioBufferQueueTest, Seek) {
  115. const ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
  116. AudioBufferQueue buffer;
  117. // Add 6 frames of data.
  118. buffer.Append(MakeTestBuffer<float>(
  119. kSampleFormatF32, channel_layout, 1.0f, 1.0f, 6));
  120. EXPECT_EQ(6, buffer.frames());
  121. // Seek past 2 frames.
  122. buffer.SeekFrames(2);
  123. EXPECT_EQ(4, buffer.frames());
  124. // Seek to end of data.
  125. buffer.SeekFrames(4);
  126. EXPECT_EQ(0, buffer.frames());
  127. // At end, seek now fails unless 0 specified.
  128. buffer.SeekFrames(0);
  129. }
  130. TEST(AudioBufferQueueTest, ReadBitstream) {
  131. const ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
  132. const int channels = ChannelLayoutToChannelCount(channel_layout);
  133. AudioBufferQueue buffer;
  134. // Add 24 frames of data.
  135. buffer.Append(MakeBitstreamAudioBuffer(kSampleFormatEac3, channel_layout,
  136. channels, kSampleRate, 1, 1, 4, 2,
  137. kNoTimestamp));
  138. buffer.Append(MakeBitstreamAudioBuffer(kSampleFormatEac3, channel_layout,
  139. channels, kSampleRate, 9, 1, 20, 10,
  140. kNoTimestamp));
  141. EXPECT_EQ(24, buffer.frames());
  142. // The first audio buffer contains 4 frames.
  143. std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, buffer.frames());
  144. EXPECT_EQ(4, buffer.ReadFrames(buffer.frames(), 0, bus.get()));
  145. VerifyBitstreamAudioBus(bus.get(), 2, 1, 1);
  146. // The second audio buffer contains 20 frames.
  147. EXPECT_EQ(20, buffer.ReadFrames(buffer.frames(), 0, bus.get()));
  148. VerifyBitstreamAudioBus(bus.get(), 10, 9, 1);
  149. }
  150. TEST(AudioBufferQueueTest, ReadF32) {
  151. const ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
  152. const int channels = ChannelLayoutToChannelCount(channel_layout);
  153. AudioBufferQueue buffer;
  154. // Add 76 frames of data.
  155. buffer.Append(
  156. MakeTestBuffer<float>(kSampleFormatF32, channel_layout, 1.0f, 1.0f, 6));
  157. buffer.Append(
  158. MakeTestBuffer<float>(kSampleFormatF32, channel_layout, 13.0f, 1.0f, 10));
  159. buffer.Append(
  160. MakeTestBuffer<float>(kSampleFormatF32, channel_layout, 33.0f, 1.0f, 60));
  161. EXPECT_EQ(76, buffer.frames());
  162. // Read 3 frames from the buffer.
  163. std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
  164. EXPECT_EQ(3, buffer.ReadFrames(3, 0, bus.get()));
  165. EXPECT_EQ(73, buffer.frames());
  166. VerifyBus(bus.get(), 0, 3, 6, 1, 1, ValueType::kFloat);
  167. // Now read 5 frames, which will span buffers. Append the data into AudioBus.
  168. EXPECT_EQ(5, buffer.ReadFrames(5, 3, bus.get()));
  169. EXPECT_EQ(68, buffer.frames());
  170. VerifyBus(bus.get(), 0, 6, 6, 1, 1, ValueType::kFloat);
  171. VerifyBus(bus.get(), 6, 2, 10, 13, 1, ValueType::kFloat);
  172. // Now skip into the third buffer.
  173. buffer.SeekFrames(20);
  174. EXPECT_EQ(48, buffer.frames());
  175. // Now read 2 frames, which are in the third buffer.
  176. EXPECT_EQ(2, buffer.ReadFrames(2, 0, bus.get()));
  177. VerifyBus(bus.get(), 0, 2, 60, 45, 1, ValueType::kFloat);
  178. }
  179. TEST(AudioBufferQueueTest, ReadU8) {
  180. const ChannelLayout channel_layout = CHANNEL_LAYOUT_4_0;
  181. const int channels = ChannelLayoutToChannelCount(channel_layout);
  182. const int frames = 4;
  183. AudioBufferQueue buffer;
  184. // Add 4 frames of data.
  185. buffer.Append(
  186. MakeTestBuffer<uint8_t>(kSampleFormatU8, channel_layout, 128, 1, frames));
  187. // Read all 4 frames from the buffer.
  188. std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, frames);
  189. EXPECT_EQ(frames, buffer.ReadFrames(frames, 0, bus.get()));
  190. EXPECT_EQ(0, buffer.frames());
  191. VerifyBus(bus.get(), 0, frames, bus->frames(), 0, 1.0f / 127.0f);
  192. }
  193. TEST(AudioBufferQueueTest, ReadS16) {
  194. const ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
  195. const int channels = ChannelLayoutToChannelCount(channel_layout);
  196. AudioBufferQueue buffer;
  197. // Add 24 frames of data.
  198. buffer.Append(
  199. MakeTestBuffer<int16_t>(kSampleFormatS16, channel_layout, 1, 1, 4));
  200. buffer.Append(
  201. MakeTestBuffer<int16_t>(kSampleFormatS16, channel_layout, 9, 1, 20));
  202. EXPECT_EQ(24, buffer.frames());
  203. // Read 6 frames from the buffer.
  204. const int frames = 6;
  205. std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, buffer.frames());
  206. EXPECT_EQ(frames, buffer.ReadFrames(frames, 0, bus.get()));
  207. EXPECT_EQ(18, buffer.frames());
  208. VerifyBus(bus.get(), 0, 4, 4, 1.0f / std::numeric_limits<int16_t>::max(),
  209. 1.0f / std::numeric_limits<int16_t>::max());
  210. VerifyBus(bus.get(), 4, 2, 20, 9.0f / std::numeric_limits<int16_t>::max(),
  211. 1.0f / std::numeric_limits<int16_t>::max());
  212. }
  213. TEST(AudioBufferQueueTest, ReadS32) {
  214. const ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
  215. const int channels = ChannelLayoutToChannelCount(channel_layout);
  216. AudioBufferQueue buffer;
  217. // Add 24 frames of data.
  218. buffer.Append(
  219. MakeTestBuffer<int32_t>(kSampleFormatS32, channel_layout, 1, 1, 4));
  220. buffer.Append(
  221. MakeTestBuffer<int32_t>(kSampleFormatS32, channel_layout, 9, 1, 20));
  222. EXPECT_EQ(24, buffer.frames());
  223. // Read 6 frames from the buffer.
  224. std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
  225. EXPECT_EQ(6, buffer.ReadFrames(6, 0, bus.get()));
  226. EXPECT_EQ(18, buffer.frames());
  227. constexpr float kIncrement =
  228. 1.0f / static_cast<float>(std::numeric_limits<int32_t>::max());
  229. VerifyBus(bus.get(), 0, 4, 4, kIncrement, kIncrement);
  230. VerifyBus(bus.get(), 4, 2, 20, 9.0f * kIncrement, kIncrement);
  231. // Read the next 2 frames.
  232. EXPECT_EQ(2, buffer.ReadFrames(2, 0, bus.get()));
  233. EXPECT_EQ(16, buffer.frames());
  234. VerifyBus(bus.get(), 0, 2, 20, 11.0f * kIncrement, kIncrement);
  235. }
  236. TEST(AudioBufferQueueTest, ReadF32Planar) {
  237. const ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
  238. const int channels = ChannelLayoutToChannelCount(channel_layout);
  239. AudioBufferQueue buffer;
  240. // Add 14 frames of data.
  241. buffer.Append(MakeTestBuffer<float>(
  242. kSampleFormatPlanarF32, channel_layout, 1.0f, 1.0f, 4));
  243. buffer.Append(MakeTestBuffer<float>(
  244. kSampleFormatPlanarF32, channel_layout, 50.0f, 1.0f, 10));
  245. EXPECT_EQ(14, buffer.frames());
  246. // Read 6 frames from the buffer.
  247. std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
  248. EXPECT_EQ(6, buffer.ReadFrames(6, 0, bus.get()));
  249. EXPECT_EQ(8, buffer.frames());
  250. VerifyBus(bus.get(), 0, 4, 4, 1, 1, ValueType::kFloat);
  251. VerifyBus(bus.get(), 4, 2, 10, 50, 1, ValueType::kFloat);
  252. }
  253. TEST(AudioBufferQueueTest, ReadS16Planar) {
  254. const ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
  255. const int channels = ChannelLayoutToChannelCount(channel_layout);
  256. AudioBufferQueue buffer;
  257. // Add 24 frames of data.
  258. buffer.Append(
  259. MakeTestBuffer<int16_t>(kSampleFormatPlanarS16, channel_layout, 1, 1, 4));
  260. buffer.Append(MakeTestBuffer<int16_t>(kSampleFormatPlanarS16, channel_layout,
  261. 5, 1, 20));
  262. EXPECT_EQ(24, buffer.frames());
  263. // Read 6 frames from the buffer.
  264. std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
  265. EXPECT_EQ(6, buffer.ReadFrames(6, 0, bus.get()));
  266. EXPECT_EQ(18, buffer.frames());
  267. VerifyBus(bus.get(), 0, 4, 4, 1.0f / std::numeric_limits<int16_t>::max(),
  268. 1.0f / std::numeric_limits<int16_t>::max());
  269. VerifyBus(bus.get(), 4, 2, 20, 5.0f / std::numeric_limits<int16_t>::max(),
  270. 1.0f / std::numeric_limits<int16_t>::max());
  271. }
  272. TEST(AudioBufferQueueTest, ReadManyChannels) {
  273. const ChannelLayout channel_layout = CHANNEL_LAYOUT_OCTAGONAL;
  274. const int channels = ChannelLayoutToChannelCount(channel_layout);
  275. AudioBufferQueue buffer;
  276. // Add 76 frames of data.
  277. buffer.Append(
  278. MakeTestBuffer<float>(kSampleFormatF32, channel_layout, 0.0f, 1.0f, 6));
  279. buffer.Append(MakeTestBuffer<float>(
  280. kSampleFormatF32, channel_layout, 6.0f * channels, 1.0f, 10));
  281. buffer.Append(MakeTestBuffer<float>(
  282. kSampleFormatF32, channel_layout, 16.0f * channels, 1.0f, 60));
  283. EXPECT_EQ(76, buffer.frames());
  284. // Read 3 frames from the buffer.
  285. std::unique_ptr<AudioBus> bus = AudioBus::Create(channels, 100);
  286. EXPECT_EQ(30, buffer.ReadFrames(30, 0, bus.get()));
  287. EXPECT_EQ(46, buffer.frames());
  288. VerifyBus(bus.get(), 0, 6, 6, 0, 1, ValueType::kFloat);
  289. VerifyBus(bus.get(), 6, 10, 10, 6 * channels, 1, ValueType::kFloat);
  290. VerifyBus(bus.get(), 16, 14, 60, 16 * channels, 1, ValueType::kFloat);
  291. }
  292. TEST(AudioBufferQueueTest, Peek) {
  293. const ChannelLayout channel_layout = CHANNEL_LAYOUT_4_0;
  294. const int channels = ChannelLayoutToChannelCount(channel_layout);
  295. AudioBufferQueue buffer;
  296. // Add 60 frames of data.
  297. const int frames = 60;
  298. buffer.Append(MakeTestBuffer<float>(
  299. kSampleFormatF32, channel_layout, 0.0f, 1.0f, frames));
  300. EXPECT_EQ(frames, buffer.frames());
  301. // Peek at the first 30 frames.
  302. std::unique_ptr<AudioBus> bus1 = AudioBus::Create(channels, frames);
  303. EXPECT_EQ(frames, buffer.frames());
  304. EXPECT_EQ(frames, buffer.PeekFrames(60, 0, 0, bus1.get()));
  305. EXPECT_EQ(30, buffer.PeekFrames(30, 0, 0, bus1.get()));
  306. EXPECT_EQ(frames, buffer.frames());
  307. VerifyBus(bus1.get(), 0, 30, bus1->frames(), 0, 1, ValueType::kFloat);
  308. // Now read the next 30 frames (which should be the same as those peeked at).
  309. std::unique_ptr<AudioBus> bus2 = AudioBus::Create(channels, frames);
  310. EXPECT_EQ(30, buffer.ReadFrames(30, 0, bus2.get()));
  311. VerifyBus(bus2.get(), 0, 30, bus2->frames(), 0, 1, ValueType::kFloat);
  312. // Peek 10 frames forward
  313. bus1->Zero();
  314. EXPECT_EQ(5, buffer.PeekFrames(5, 10, 0, bus1.get()));
  315. VerifyBus(bus1.get(), 0, 5, bus1->frames(), 40, 1, ValueType::kFloat);
  316. // Peek to the end of the buffer.
  317. EXPECT_EQ(30, buffer.frames());
  318. EXPECT_EQ(30, buffer.PeekFrames(60, 0, 0, bus1.get()));
  319. EXPECT_EQ(30, buffer.PeekFrames(30, 0, 0, bus1.get()));
  320. }
  321. } // namespace media