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