ppapi/tests/test_audio.cc

   1 // Copyright (c) 2012 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
   5 #include "ppapi/tests/test_audio.h"
   6
   7 #include <string.h>
   8
   9 #include "ppapi/c/ppb_audio_config.h"
  10 #include "ppapi/c/ppb_audio.h"
  11 #include "ppapi/cpp/module.h"
  12 #include "ppapi/tests/testing_instance.h"
  13 #include "ppapi/tests/test_utils.h"
  14
  15 #define ARRAYSIZE_UNSAFE(a) \
  16   ((sizeof(a) / sizeof(*(a))) / \
  17    static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
  18
  19 REGISTER_TEST_CASE(Audio);
  20
  21 TestAudio::TestAudio(TestingInstance* instance)
  22     : TestCase(instance),
  23       audio_callback_method_(NULL),
  24       audio_callback_event_(instance->pp_instance()),
  25       test_done_(false),
  26       audio_interface_(NULL),
  27       audio_interface_1_0_(NULL),
  28       audio_config_interface_(NULL),
  29       core_interface_(NULL) {
  30 }
  31
  32 TestAudio::~TestAudio() {
  33 }
  34
  35 bool TestAudio::Init() {
  36   audio_interface_ = static_cast<const PPB_Audio_1_1*>(
  37       pp::Module::Get()->GetBrowserInterface(PPB_AUDIO_INTERFACE_1_1));
  38   audio_interface_1_0_ = static_cast<const PPB_Audio_1_0*>(
  39       pp::Module::Get()->GetBrowserInterface(PPB_AUDIO_INTERFACE_1_0));
  40   audio_config_interface_ = static_cast<const PPB_AudioConfig*>(
  41       pp::Module::Get()->GetBrowserInterface(PPB_AUDIO_CONFIG_INTERFACE));
  42   core_interface_ = static_cast<const PPB_Core*>(
  43       pp::Module::Get()->GetBrowserInterface(PPB_CORE_INTERFACE));
  44   return audio_interface_ && audio_interface_1_0_ && audio_config_interface_ &&
  45          core_interface_;
  46 }
  47
  48 void TestAudio::RunTests(const std::string& filter) {
  49   RUN_TEST(Creation, filter);
  50   RUN_TEST(DestroyNoStop, filter);
  51   RUN_TEST(Failures, filter);
  52   RUN_TEST(AudioCallback1, filter);
  53   RUN_TEST(AudioCallback2, filter);
  54   RUN_TEST(AudioCallback3, filter);
  55   RUN_TEST(AudioCallback4, filter);
  56 }
  57
  58 // Test creating audio resources for all guaranteed sample rates and various
  59 // frame counts.
  60 std::string TestAudio::TestCreation() {
  61   static const PP_AudioSampleRate kSampleRates[] = {
  62     PP_AUDIOSAMPLERATE_44100,
  63     PP_AUDIOSAMPLERATE_48000
  64   };
  65   static const uint32_t kRequestFrameCounts[] = {
  66     PP_AUDIOMINSAMPLEFRAMECOUNT,
  67     PP_AUDIOMAXSAMPLEFRAMECOUNT,
  68     // Include some "okay-looking" frame counts; check their validity below.
  69     PP_AUDIOSAMPLERATE_44100 / 100,  // 10ms @ 44.1kHz
  70     PP_AUDIOSAMPLERATE_48000 / 100,  // 10ms @ 48kHz
  71     2 * PP_AUDIOSAMPLERATE_44100 / 100,  // 20ms @ 44.1kHz
  72     2 * PP_AUDIOSAMPLERATE_48000 / 100,  // 20ms @ 48kHz
  73     1024,
  74     2048,
  75     4096
  76   };
  77   PP_AudioSampleRate sample_rate = audio_config_interface_->RecommendSampleRate(
  78       instance_->pp_instance());
  79   ASSERT_TRUE(sample_rate == PP_AUDIOSAMPLERATE_NONE ||
  80               sample_rate == PP_AUDIOSAMPLERATE_44100 ||
  81               sample_rate == PP_AUDIOSAMPLERATE_48000);
  82   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kSampleRates); i++) {
  83     PP_AudioSampleRate sample_rate = kSampleRates[i];
  84
  85     for (size_t j = 0; j < ARRAYSIZE_UNSAFE(kRequestFrameCounts); j++) {
  86       // Make a config, create the audio resource, and release the config.
  87       uint32_t request_frame_count = kRequestFrameCounts[j];
  88       uint32_t frame_count = audio_config_interface_->RecommendSampleFrameCount(
  89           instance_->pp_instance(), sample_rate, request_frame_count);
  90       PP_Resource ac = audio_config_interface_->CreateStereo16Bit(
  91           instance_->pp_instance(), sample_rate, frame_count);
  92       ASSERT_TRUE(ac);
  93       PP_Resource audio = audio_interface_->Create(
  94           instance_->pp_instance(), ac, AudioCallbackTrampoline, this);
  95       core_interface_->ReleaseResource(ac);
  96       ac = 0;
  97
  98       ASSERT_TRUE(audio);
  99       ASSERT_TRUE(audio_interface_->IsAudio(audio));
 100
 101       // Check that the config returned for |audio| matches what we gave it.
 102       ac = audio_interface_->GetCurrentConfig(audio);
 103       ASSERT_TRUE(ac);
 104       ASSERT_TRUE(audio_config_interface_->IsAudioConfig(ac));
 105       ASSERT_EQ(sample_rate, audio_config_interface_->GetSampleRate(ac));
 106       ASSERT_EQ(frame_count, audio_config_interface_->GetSampleFrameCount(ac));
 107       core_interface_->ReleaseResource(ac);
 108       ac = 0;
 109
 110       // Start and stop audio playback. The documentation indicates that
 111       // |StartPlayback()| and |StopPlayback()| may fail, but gives no
 112       // indication as to why ... so check that they succeed.
 113       audio_callback_method_ = &TestAudio::AudioCallbackTrivial;
 114       ASSERT_TRUE(audio_interface_->StartPlayback(audio));
 115       ASSERT_TRUE(audio_interface_->StopPlayback(audio));
 116       audio_callback_method_ = NULL;
 117
 118       core_interface_->ReleaseResource(audio);
 119     }
 120   }
 121
 122   PASS();
 123 }
 124
 125 // Test that releasing the resource without calling |StopPlayback()| "works".
 126 std::string TestAudio::TestDestroyNoStop() {
 127   PP_Resource ac = CreateAudioConfig(PP_AUDIOSAMPLERATE_44100, 2048);
 128   ASSERT_TRUE(ac);
 129   audio_callback_method_ = NULL;
 130   PP_Resource audio = audio_interface_->Create(
 131       instance_->pp_instance(), ac, AudioCallbackTrampoline, this);
 132   core_interface_->ReleaseResource(ac);
 133   ac = 0;
 134
 135   ASSERT_TRUE(audio);
 136   ASSERT_TRUE(audio_interface_->IsAudio(audio));
 137
 138   // Start playback and release the resource.
 139   audio_callback_method_ = &TestAudio::AudioCallbackTrivial;
 140   ASSERT_TRUE(audio_interface_->StartPlayback(audio));
 141   core_interface_->ReleaseResource(audio);
 142   audio_callback_method_ = NULL;
 143
 144   PASS();
 145 }
 146
 147 std::string TestAudio::TestFailures() {
 148   // Test invalid parameters to |Create()|.
 149
 150   // We want a valid config for some of our tests of |Create()|.
 151   PP_Resource ac = CreateAudioConfig(PP_AUDIOSAMPLERATE_44100, 2048);
 152   ASSERT_TRUE(ac);
 153
 154   // Failure cases should never lead to the callback being called.
 155   audio_callback_method_ = NULL;
 156
 157   // Invalid instance -> failure.
 158   PP_Resource audio = audio_interface_->Create(
 159       0, ac, AudioCallbackTrampoline, this);
 160   ASSERT_EQ(0, audio);
 161
 162   // Invalid config -> failure.
 163   audio = audio_interface_->Create(
 164       instance_->pp_instance(), 0, AudioCallbackTrampoline, this);
 165   ASSERT_EQ(0, audio);
 166
 167   // Null callback -> failure.
 168   audio = audio_interface_->Create(
 169       instance_->pp_instance(), ac, NULL, NULL);
 170   ASSERT_EQ(0, audio);
 171
 172   core_interface_->ReleaseResource(ac);
 173   ac = 0;
 174
 175   // Test the other functions with an invalid audio resource.
 176   ASSERT_FALSE(audio_interface_->IsAudio(0));
 177   ASSERT_EQ(0, audio_interface_->GetCurrentConfig(0));
 178   ASSERT_FALSE(audio_interface_->StartPlayback(0));
 179   ASSERT_FALSE(audio_interface_->StopPlayback(0));
 180
 181   PASS();
 182 }
 183
 184 // NOTE: |TestAudioCallbackN| assumes that the audio callback is called at least
 185 // once. If the audio stream does not start up correctly or is interrupted this
 186 // may not be the case and these tests will fail. However, in order to properly
 187 // test the audio callbacks, we must have a configuration where audio can
 188 // successfully play, so we assume this is the case on bots.
 189
 190 // This test starts playback and verifies that:
 191 //  1) the audio callback is actually called;
 192 //  2) that |StopPlayback()| waits for the audio callback to finish.
 193 std::string TestAudio::TestAudioCallback1() {
 194   PP_Resource ac = CreateAudioConfig(PP_AUDIOSAMPLERATE_44100, 1024);
 195   ASSERT_TRUE(ac);
 196   audio_callback_method_ = NULL;
 197   PP_Resource audio = audio_interface_->Create(
 198       instance_->pp_instance(), ac, AudioCallbackTrampoline, this);
 199   core_interface_->ReleaseResource(ac);
 200   ac = 0;
 201
 202   audio_callback_event_.Reset();
 203   test_done_ = false;
 204
 205   audio_callback_method_ = &TestAudio::AudioCallbackTest;
 206   ASSERT_TRUE(audio_interface_->StartPlayback(audio));
 207
 208   // Wait for the audio callback to be called.
 209   audio_callback_event_.Wait();
 210   ASSERT_TRUE(audio_interface_->StopPlayback(audio));
 211   test_done_ = true;
 212
 213   // If any more audio callbacks are generated, we should crash (which is good).
 214   audio_callback_method_ = NULL;
 215
 216   core_interface_->ReleaseResource(audio);
 217
 218   PASS();
 219 }
 220
 221 // This is the same as |TestAudioCallback1()|, except that instead of calling
 222 // |StopPlayback()|, it just releases the resource.
 223 std::string TestAudio::TestAudioCallback2() {
 224   PP_Resource ac = CreateAudioConfig(PP_AUDIOSAMPLERATE_44100, 1024);
 225   ASSERT_TRUE(ac);
 226   audio_callback_method_ = NULL;
 227   PP_Resource audio = audio_interface_->Create(
 228       instance_->pp_instance(), ac, AudioCallbackTrampoline, this);
 229   core_interface_->ReleaseResource(ac);
 230   ac = 0;
 231
 232   audio_callback_event_.Reset();
 233   test_done_ = false;
 234
 235   audio_callback_method_ = &TestAudio::AudioCallbackTest;
 236   ASSERT_TRUE(audio_interface_->StartPlayback(audio));
 237
 238   // Wait for the audio callback to be called.
 239   audio_callback_event_.Wait();
 240
 241   core_interface_->ReleaseResource(audio);
 242
 243   test_done_ = true;
 244
 245   // If any more audio callbacks are generated, we should crash (which is good).
 246   audio_callback_method_ = NULL;
 247
 248   PASS();
 249 }
 250
 251 // This is the same as |TestAudioCallback1()|, except that it attempts a second
 252 // round of |StartPlayback| and |StopPlayback| to make sure the callback
 253 // function still responds when using the same audio resource.
 254 std::string TestAudio::TestAudioCallback3() {
 255   PP_Resource ac = CreateAudioConfig(PP_AUDIOSAMPLERATE_44100, 1024);
 256   ASSERT_TRUE(ac);
 257   audio_callback_method_ = NULL;
 258   PP_Resource audio = audio_interface_->Create(
 259       instance_->pp_instance(), ac, AudioCallbackTrampoline, this);
 260   core_interface_->ReleaseResource(ac);
 261   ac = 0;
 262
 263   audio_callback_event_.Reset();
 264   test_done_ = false;
 265
 266   audio_callback_method_ = &TestAudio::AudioCallbackTest;
 267   ASSERT_TRUE(audio_interface_->StartPlayback(audio));
 268
 269   // Wait for the audio callback to be called.
 270   audio_callback_event_.Wait();
 271
 272   ASSERT_TRUE(audio_interface_->StopPlayback(audio));
 273
 274   // Repeat one more |StartPlayback| & |StopPlayback| cycle, and verify again
 275   // that the callback function was invoked.
 276   audio_callback_event_.Reset();
 277   ASSERT_TRUE(audio_interface_->StartPlayback(audio));
 278
 279   // Wait for the audio callback to be called.
 280   audio_callback_event_.Wait();
 281   ASSERT_TRUE(audio_interface_->StopPlayback(audio));
 282   test_done_ = true;
 283
 284   // If any more audio callbacks are generated, we should crash (which is good).
 285   audio_callback_method_ = NULL;
 286
 287   core_interface_->ReleaseResource(audio);
 288
 289   PASS();
 290 }
 291
 292 // This is the same as |TestAudioCallback1()|, except that it uses
 293 // PPB_Audio_1_0.
 294 std::string TestAudio::TestAudioCallback4() {
 295   PP_Resource ac = CreateAudioConfig(PP_AUDIOSAMPLERATE_44100, 1024);
 296   ASSERT_TRUE(ac);
 297   audio_callback_method_ = NULL;
 298   PP_Resource audio = audio_interface_1_0_->Create(
 299       instance_->pp_instance(), ac, AudioCallbackTrampoline1_0, this);
 300   core_interface_->ReleaseResource(ac);
 301   ac = 0;
 302
 303   audio_callback_event_.Reset();
 304   test_done_ = false;
 305
 306   audio_callback_method_ = &TestAudio::AudioCallbackTest;
 307   ASSERT_TRUE(audio_interface_1_0_->StartPlayback(audio));
 308
 309   // Wait for the audio callback to be called.
 310   audio_callback_event_.Wait();
 311   ASSERT_TRUE(audio_interface_1_0_->StopPlayback(audio));
 312   test_done_ = true;
 313
 314   // If any more audio callbacks are generated, we should crash (which is good).
 315   audio_callback_method_ = NULL;
 316
 317   core_interface_->ReleaseResource(audio);
 318
 319   PASS();
 320 }
 321
 322 // TODO(raymes): Test that actually playback happens correctly, etc.
 323
 324 static void Crash() {
 325   *static_cast<volatile unsigned*>(NULL) = 0xdeadbeef;
 326 }
 327
 328 // static
 329 void TestAudio::AudioCallbackTrampoline(void* sample_buffer,
 330                                         uint32_t buffer_size_in_bytes,
 331                                         PP_TimeDelta latency,
 332                                         void* user_data) {
 333   TestAudio* thiz = static_cast<TestAudio*>(user_data);
 334
 335   // Crash if on the main thread.
 336   if (thiz->core_interface_->IsMainThread())
 337     Crash();
 338
 339   AudioCallbackMethod method = thiz->audio_callback_method_;
 340   (thiz->*method)(sample_buffer, buffer_size_in_bytes, latency);
 341 }
 342
 343 // static
 344 void TestAudio::AudioCallbackTrampoline1_0(void* sample_buffer,
 345                                            uint32_t buffer_size_in_bytes,
 346                                            void* user_data) {
 347   AudioCallbackTrampoline(sample_buffer, buffer_size_in_bytes, 0.0, user_data);
 348 }
 349
 350 void TestAudio::AudioCallbackTrivial(void* sample_buffer,
 351                                      uint32_t buffer_size_in_bytes,
 352                                      PP_TimeDelta latency) {
 353   if (latency < 0)
 354     Crash();
 355
 356   memset(sample_buffer, 0, buffer_size_in_bytes);
 357 }
 358
 359 void TestAudio::AudioCallbackTest(void* sample_buffer,
 360                                   uint32_t buffer_size_in_bytes,
 361                                   PP_TimeDelta latency) {
 362   if (test_done_ || latency < 0)
 363     Crash();
 364
 365   memset(sample_buffer, 0, buffer_size_in_bytes);
 366   audio_callback_event_.Signal();
 367 }
 368
 369 PP_Resource TestAudio::CreateAudioConfig(
 370     PP_AudioSampleRate sample_rate,
 371     uint32_t requested_sample_frame_count) {
 372   uint32_t frame_count = audio_config_interface_->RecommendSampleFrameCount(
 373       instance_->pp_instance(), sample_rate, requested_sample_frame_count);
 374   return audio_config_interface_->CreateStereo16Bit(
 375       instance_->pp_instance(), sample_rate, frame_count);
 376 }