1/* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package com.android.mediaframeworktest.functional.audio; 18 19import com.android.mediaframeworktest.MediaFrameworkTest; 20import com.android.mediaframeworktest.MediaNames; 21 22import android.media.AudioFormat; 23import android.media.AudioManager; 24import android.media.AudioTrack; 25import android.test.ActivityInstrumentationTestCase2; 26import android.util.Log; 27import android.test.suitebuilder.annotation.LargeTest; 28import android.test.suitebuilder.annotation.MediumTest; 29import android.test.suitebuilder.annotation.Suppress; 30 31/** 32 * Junit / Instrumentation test case for the media AudioTrack api 33 34 */ 35public class MediaAudioTrackTest extends ActivityInstrumentationTestCase2<MediaFrameworkTest> { 36 private String TAG = "MediaAudioTrackTest"; 37 38 public MediaAudioTrackTest() { 39 super("com.android.mediaframeworktest", MediaFrameworkTest.class); 40 } 41 42 @Override 43 protected void setUp() throws Exception { 44 super.setUp(); 45 } 46 47 @Override 48 protected void tearDown() throws Exception { 49 super.tearDown(); 50 } 51 52 private static void assumeTrue(String message, boolean cond) { 53 assertTrue("(assume)"+message, cond); 54 } 55 56 private void log(String testName, String message) { 57 Log.v(TAG, "["+testName+"] "+message); 58 } 59 60 private void loge(String testName, String message) { 61 Log.e(TAG, "["+testName+"] "+message); 62 } 63 64 //----------------------------------------------------------------- 65 // private class to hold test reslts 66 public class TestResults { 67 public boolean mResult = false; 68 public String mResultLog = ""; 69 public TestResults(boolean b, String s) { mResult = b; mResultLog = s; } 70 } 71 72 //----------------------------------------------------------------- 73 // generic test methods 74 public TestResults constructorTestMultiSampleRate( 75 // parameters tested by this method 76 int _inTest_streamType, int _inTest_mode, 77 int _inTest_config, int _inTest_format, 78 // parameter-dependent expected results 79 int _expected_stateForMode) { 80 81 int[] testSampleRates = {8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000}; 82 String failedRates = "Failure for rate(s): "; 83 boolean localRes, finalRes = true; 84 85 for (int i = 0 ; i < testSampleRates.length ; i++) { 86 //Log.v("MediaAudioTrackTest", "[ constructorTestMultiSampleRate ] testing "+ testSampleRates[i]); 87 AudioTrack track = null; 88 try { 89 track = new AudioTrack( 90 _inTest_streamType, 91 testSampleRates[i], 92 _inTest_config, 93 _inTest_format, 94 AudioTrack.getMinBufferSize(testSampleRates[i], 95 _inTest_config, _inTest_format), 96 _inTest_mode); 97 } catch(IllegalArgumentException iae) { 98 Log.e("MediaAudioTrackTest", "[ constructorTestMultiSampleRate ] exception at SR " 99 + testSampleRates[i]+": \n" + iae); 100 localRes = false; 101 } 102 if (track != null) { 103 localRes = (track.getState() == _expected_stateForMode); 104 track.release(); 105 } 106 else { 107 localRes = false; 108 } 109 110 if (!localRes) { 111 //log the error for the test runner 112 failedRates += Integer.toString(testSampleRates[i]) + "Hz "; 113 //log the error for logcat 114 log("constructorTestMultiSampleRate", "failed to construct " 115 +"AudioTrack(streamType="+_inTest_streamType 116 +", sampleRateInHz=" + testSampleRates[i] 117 +", channelConfig=" + _inTest_config 118 +", audioFormat=" + _inTest_format 119 +", bufferSizeInBytes=" + AudioTrack.getMinBufferSize(testSampleRates[i], 120 _inTest_config, AudioFormat.ENCODING_PCM_16BIT) 121 +", mode="+ _inTest_mode ); 122 //mark test as failed 123 finalRes = false; 124 } 125 } 126 return new TestResults(finalRes, failedRates); 127 } 128 129 //----------------------------------------------------------------- 130 // AUDIOTRACK TESTS: 131 //---------------------------------- 132 133 //----------------------------------------------------------------- 134 // AudioTrack constructor and AudioTrack.getMinBufferSize(...) for 16bit PCM 135 //---------------------------------- 136 137 //Test case 1: constructor for streaming AudioTrack, mono, 16bit at misc valid sample rates 138 @LargeTest 139 public void testConstructorMono16MusicStream() throws Exception { 140 141 TestResults res = constructorTestMultiSampleRate( 142 AudioManager.STREAM_MUSIC, AudioTrack.MODE_STREAM, 143 AudioFormat.CHANNEL_OUT_MONO, AudioFormat.ENCODING_PCM_16BIT, 144 AudioTrack.STATE_INITIALIZED); 145 146 assertTrue("testConstructorMono16MusicStream: " + res.mResultLog, res.mResult); 147 } 148 149 150 //Test case 2: constructor for streaming AudioTrack, stereo, 16bit at misc valid sample rates 151 @LargeTest 152 public void testConstructorStereo16MusicStream() throws Exception { 153 154 TestResults res = constructorTestMultiSampleRate( 155 AudioManager.STREAM_MUSIC, AudioTrack.MODE_STREAM, 156 AudioFormat.CHANNEL_OUT_STEREO, AudioFormat.ENCODING_PCM_16BIT, 157 AudioTrack.STATE_INITIALIZED); 158 159 assertTrue("testConstructorStereo16MusicStream: " + res.mResultLog, res.mResult); 160 } 161 162 163 //Test case 3: constructor for static AudioTrack, mono, 16bit at misc valid sample rates 164 @LargeTest 165 public void testConstructorMono16MusicStatic() throws Exception { 166 167 TestResults res = constructorTestMultiSampleRate( 168 AudioManager.STREAM_MUSIC, AudioTrack.MODE_STATIC, 169 AudioFormat.CHANNEL_OUT_MONO, AudioFormat.ENCODING_PCM_16BIT, 170 AudioTrack.STATE_NO_STATIC_DATA); 171 172 assertTrue("testConstructorMono16MusicStatic: " + res.mResultLog, res.mResult); 173 } 174 175 176 //Test case 4: constructor for static AudioTrack, stereo, 16bit at misc valid sample rates 177 @LargeTest 178 public void testConstructorStereo16MusicStatic() throws Exception { 179 180 TestResults res = constructorTestMultiSampleRate( 181 AudioManager.STREAM_MUSIC, AudioTrack.MODE_STATIC, 182 AudioFormat.CHANNEL_OUT_STEREO, AudioFormat.ENCODING_PCM_16BIT, 183 AudioTrack.STATE_NO_STATIC_DATA); 184 185 assertTrue("testConstructorStereo16MusicStatic: " + res.mResultLog, res.mResult); 186 } 187 188 189 //----------------------------------------------------------------- 190 // AudioTrack constructor and AudioTrack.getMinBufferSize(...) for 8bit PCM 191 //---------------------------------- 192 193 //Test case 1: constructor for streaming AudioTrack, mono, 8bit at misc valid sample rates 194 @LargeTest 195 public void testConstructorMono8MusicStream() throws Exception { 196 197 TestResults res = constructorTestMultiSampleRate( 198 AudioManager.STREAM_MUSIC, AudioTrack.MODE_STREAM, 199 AudioFormat.CHANNEL_OUT_MONO, AudioFormat.ENCODING_PCM_8BIT, 200 AudioTrack.STATE_INITIALIZED); 201 202 assertTrue("testConstructorMono8MusicStream: " + res.mResultLog, res.mResult); 203 } 204 205 //Test case 2: constructor for streaming AudioTrack, stereo, 8bit at misc valid sample rates 206 @LargeTest 207 public void testConstructorStereo8MusicStream() throws Exception { 208 209 TestResults res = constructorTestMultiSampleRate( 210 AudioManager.STREAM_MUSIC, AudioTrack.MODE_STREAM, 211 AudioFormat.CHANNEL_OUT_STEREO, AudioFormat.ENCODING_PCM_8BIT, 212 AudioTrack.STATE_INITIALIZED); 213 214 assertTrue("testConstructorStereo8MusicStream: " + res.mResultLog, res.mResult); 215 } 216 217 //Test case 3: constructor for static AudioTrack, mono, 8bit at misc valid sample rates 218 @LargeTest 219 public void testConstructorMono8MusicStatic() throws Exception { 220 221 TestResults res = constructorTestMultiSampleRate( 222 AudioManager.STREAM_MUSIC, AudioTrack.MODE_STATIC, 223 AudioFormat.CHANNEL_OUT_MONO, AudioFormat.ENCODING_PCM_8BIT, 224 AudioTrack.STATE_NO_STATIC_DATA); 225 226 assertTrue("testConstructorMono8MusicStatic: " + res.mResultLog, res.mResult); 227 } 228 229 //Test case 4: constructor for static AudioTrack, stereo, 8bit at misc valid sample rates 230 @LargeTest 231 public void testConstructorStereo8MusicStatic() throws Exception { 232 233 TestResults res = constructorTestMultiSampleRate( 234 AudioManager.STREAM_MUSIC, AudioTrack.MODE_STATIC, 235 AudioFormat.CHANNEL_OUT_STEREO, AudioFormat.ENCODING_PCM_8BIT, 236 AudioTrack.STATE_NO_STATIC_DATA); 237 238 assertTrue("testConstructorStereo8MusicStatic: " + res.mResultLog, res.mResult); 239 } 240 241 242 //----------------------------------------------------------------- 243 // AudioTrack constructor for all stream types 244 //---------------------------------- 245 246 //Test case 1: constructor for all stream types 247 @LargeTest 248 public void testConstructorStreamType() throws Exception { 249 // constants for test 250 final int TYPE_TEST_SR = 22050; 251 final int TYPE_TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 252 final int TYPE_TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 253 final int TYPE_TEST_MODE = AudioTrack.MODE_STREAM; 254 final int[] STREAM_TYPES = { AudioManager.STREAM_ALARM, AudioManager.STREAM_BLUETOOTH_SCO, 255 AudioManager.STREAM_MUSIC, AudioManager.STREAM_NOTIFICATION, 256 AudioManager.STREAM_RING, AudioManager.STREAM_SYSTEM, 257 AudioManager.STREAM_VOICE_CALL, AudioManager.STREAM_DTMF, }; 258 final String[] STREAM_NAMES = { "STREAM_ALARM", "STREAM_BLUETOOTH_SCO", "STREAM_MUSIC", 259 "STREAM_NOTIFICATION", "STREAM_RING", "STREAM_SYSTEM", "STREAM_VOICE_CALL", "STREAM_DTMF" }; 260 261 boolean localTestRes = true; 262 AudioTrack track = null; 263 // test: loop constructor on all stream types 264 for (int i = 0 ; i < STREAM_TYPES.length ; i++) 265 { 266 try { 267 //-------- initialization -------------- 268 track = new AudioTrack(STREAM_TYPES[i], 269 TYPE_TEST_SR, TYPE_TEST_CONF, TYPE_TEST_FORMAT, 270 AudioTrack.getMinBufferSize(TYPE_TEST_SR, TYPE_TEST_CONF, TYPE_TEST_FORMAT), 271 TYPE_TEST_MODE); 272 } catch (IllegalArgumentException iae) { 273 loge("testConstructorStreamType", "exception for stream type " 274 + STREAM_NAMES[i] + ": "+ iae); 275 localTestRes = false; 276 } 277 //-------- test -------------- 278 if (track != null) { 279 if (track.getState() != AudioTrack.STATE_INITIALIZED) { 280 localTestRes = false; 281 Log.e("MediaAudioTrackTest", 282 "[ testConstructorStreamType ] failed for stream type "+STREAM_NAMES[i]); 283 } 284 //-------- tear down -------------- 285 track.release(); 286 } 287 else { 288 localTestRes = false; 289 } 290 } 291 292 assertTrue("testConstructorStreamType", localTestRes); 293 } 294 295 296 //----------------------------------------------------------------- 297 // Playback head position 298 //---------------------------------- 299 300 //Test case 1: getPlaybackHeadPosition() at 0 after initialization 301 @LargeTest 302 public void testPlaybackHeadPositionAfterInit() throws Exception { 303 // constants for test 304 final String TEST_NAME = "testPlaybackHeadPositionAfterInit"; 305 final int TEST_SR = 22050; 306 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 307 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 308 final int TEST_MODE = AudioTrack.MODE_STREAM; 309 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 310 311 //-------- initialization -------------- 312 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 313 AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT), TEST_MODE); 314 //-------- test -------------- 315 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 316 assertTrue(TEST_NAME, track.getPlaybackHeadPosition() == 0); 317 //-------- tear down -------------- 318 track.release(); 319 } 320 321 //Test case 2: getPlaybackHeadPosition() increases after play() 322 @LargeTest 323 public void testPlaybackHeadPositionIncrease() throws Exception { 324 // constants for test 325 final String TEST_NAME = "testPlaybackHeadPositionIncrease"; 326 final int TEST_SR = 22050; 327 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 328 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 329 final int TEST_MODE = AudioTrack.MODE_STREAM; 330 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 331 332 //-------- initialization -------------- 333 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 334 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 335 minBuffSize, TEST_MODE); 336 byte data[] = new byte[minBuffSize/2]; 337 //-------- test -------------- 338 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 339 track.write(data, 0, data.length); 340 track.write(data, 0, data.length); 341 track.play(); 342 Thread.sleep(100); 343 log(TEST_NAME, "position ="+ track.getPlaybackHeadPosition()); 344 assertTrue(TEST_NAME, track.getPlaybackHeadPosition() > 0); 345 //-------- tear down -------------- 346 track.release(); 347 } 348 349 //Test case 3: getPlaybackHeadPosition() is 0 after flush(); 350 @LargeTest 351 public void testPlaybackHeadPositionAfterFlush() throws Exception { 352 // constants for test 353 final String TEST_NAME = "testPlaybackHeadPositionAfterFlush"; 354 final int TEST_SR = 22050; 355 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 356 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 357 final int TEST_MODE = AudioTrack.MODE_STREAM; 358 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 359 360 //-------- initialization -------------- 361 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 362 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 363 minBuffSize, TEST_MODE); 364 byte data[] = new byte[minBuffSize/2]; 365 //-------- test -------------- 366 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 367 track.write(data, 0, data.length); 368 track.write(data, 0, data.length); 369 track.play(); 370 Thread.sleep(100); 371 track.stop(); 372 track.flush(); 373 log(TEST_NAME, "position ="+ track.getPlaybackHeadPosition()); 374 assertTrue(TEST_NAME, track.getPlaybackHeadPosition() == 0); 375 //-------- tear down -------------- 376 track.release(); 377 } 378 379 //Test case 3: getPlaybackHeadPosition() is 0 after stop(); 380 @LargeTest 381 public void testPlaybackHeadPositionAfterStop() throws Exception { 382 // constants for test 383 final String TEST_NAME = "testPlaybackHeadPositionAfterStop"; 384 final int TEST_SR = 22050; 385 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 386 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 387 final int TEST_MODE = AudioTrack.MODE_STREAM; 388 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 389 final int TEST_LOOP_CNT = 10; 390 391 //-------- initialization -------------- 392 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 393 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 394 minBuffSize, TEST_MODE); 395 byte data[] = new byte[minBuffSize/2]; 396 //-------- test -------------- 397 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 398 track.write(data, 0, data.length); 399 track.write(data, 0, data.length); 400 track.play(); 401 Thread.sleep(100); 402 track.stop(); 403 int count = 0; 404 int pos; 405 do { 406 Thread.sleep(200); 407 pos = track.getPlaybackHeadPosition(); 408 count++; 409 } while((pos != 0) && (count < TEST_LOOP_CNT)); 410 log(TEST_NAME, "position =" + pos + ", read count ="+count); 411 assertTrue(TEST_NAME, pos == 0); 412 //-------- tear down -------------- 413 track.release(); 414 } 415 416 //Test case 4: getPlaybackHeadPosition() is > 0 after play(); pause(); 417 @LargeTest 418 public void testPlaybackHeadPositionAfterPause() throws Exception { 419 // constants for test 420 final String TEST_NAME = "testPlaybackHeadPositionAfterPause"; 421 final int TEST_SR = 22050; 422 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 423 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 424 final int TEST_MODE = AudioTrack.MODE_STREAM; 425 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 426 427 //-------- initialization -------------- 428 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 429 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 430 minBuffSize, TEST_MODE); 431 byte data[] = new byte[minBuffSize/2]; 432 //-------- test -------------- 433 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 434 track.write(data, 0, data.length); 435 track.write(data, 0, data.length); 436 track.play(); 437 Thread.sleep(100); 438 track.pause(); 439 int pos = track.getPlaybackHeadPosition(); 440 log(TEST_NAME, "position ="+ pos); 441 assertTrue(TEST_NAME, pos > 0); 442 //-------- tear down -------------- 443 track.release(); 444 } 445 446 447 //----------------------------------------------------------------- 448 // Playback properties 449 //---------------------------------- 450 451 //Test case 1: setStereoVolume() with max volume returns SUCCESS 452 @LargeTest 453 public void testSetStereoVolumeMax() throws Exception { 454 // constants for test 455 final String TEST_NAME = "testSetStereoVolumeMax"; 456 final int TEST_SR = 22050; 457 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 458 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 459 final int TEST_MODE = AudioTrack.MODE_STREAM; 460 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 461 462 //-------- initialization -------------- 463 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 464 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 465 minBuffSize, TEST_MODE); 466 byte data[] = new byte[minBuffSize/2]; 467 //-------- test -------------- 468 track.write(data, 0, data.length); 469 track.write(data, 0, data.length); 470 track.play(); 471 float maxVol = AudioTrack.getMaxVolume(); 472 assertTrue(TEST_NAME, track.setStereoVolume(maxVol, maxVol) == AudioTrack.SUCCESS); 473 //-------- tear down -------------- 474 track.release(); 475 } 476 477 //Test case 2: setStereoVolume() with min volume returns SUCCESS 478 @LargeTest 479 public void testSetStereoVolumeMin() throws Exception { 480 // constants for test 481 final String TEST_NAME = "testSetStereoVolumeMin"; 482 final int TEST_SR = 22050; 483 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 484 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 485 final int TEST_MODE = AudioTrack.MODE_STREAM; 486 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 487 488 //-------- initialization -------------- 489 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 490 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 491 minBuffSize, TEST_MODE); 492 byte data[] = new byte[minBuffSize/2]; 493 //-------- test -------------- 494 track.write(data, 0, data.length); 495 track.write(data, 0, data.length); 496 track.play(); 497 float minVol = AudioTrack.getMinVolume(); 498 assertTrue(TEST_NAME, track.setStereoVolume(minVol, minVol) == AudioTrack.SUCCESS); 499 //-------- tear down -------------- 500 track.release(); 501 } 502 503 //Test case 3: setStereoVolume() with mid volume returns SUCCESS 504 @LargeTest 505 public void testSetStereoVolumeMid() throws Exception { 506 // constants for test 507 final String TEST_NAME = "testSetStereoVolumeMid"; 508 final int TEST_SR = 22050; 509 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 510 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 511 final int TEST_MODE = AudioTrack.MODE_STREAM; 512 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 513 514 //-------- initialization -------------- 515 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 516 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 517 minBuffSize, TEST_MODE); 518 byte data[] = new byte[minBuffSize/2]; 519 //-------- test -------------- 520 track.write(data, 0, data.length); 521 track.write(data, 0, data.length); 522 track.play(); 523 float midVol = (AudioTrack.getMaxVolume() - AudioTrack.getMinVolume()) / 2; 524 assertTrue(TEST_NAME, track.setStereoVolume(midVol, midVol) == AudioTrack.SUCCESS); 525 //-------- tear down -------------- 526 track.release(); 527 } 528 529 //Test case 4: setPlaybackRate() with half the content rate returns SUCCESS 530 @LargeTest 531 public void testSetPlaybackRate() throws Exception { 532 // constants for test 533 final String TEST_NAME = "testSetPlaybackRate"; 534 final int TEST_SR = 22050; 535 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 536 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 537 final int TEST_MODE = AudioTrack.MODE_STREAM; 538 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 539 540 //-------- initialization -------------- 541 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 542 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 543 minBuffSize, TEST_MODE); 544 byte data[] = new byte[minBuffSize/2]; 545 //-------- test -------------- 546 track.write(data, 0, data.length); 547 track.write(data, 0, data.length); 548 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 549 track.play(); 550 assertTrue(TEST_NAME, track.setPlaybackRate((int)(TEST_SR/2)) == AudioTrack.SUCCESS); 551 //-------- tear down -------------- 552 track.release(); 553 } 554 555 //Test case 5: setPlaybackRate(0) returns bad value error 556 @LargeTest 557 public void testSetPlaybackRateZero() throws Exception { 558 // constants for test 559 final String TEST_NAME = "testSetPlaybackRateZero"; 560 final int TEST_SR = 22050; 561 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 562 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 563 final int TEST_MODE = AudioTrack.MODE_STREAM; 564 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 565 566 //-------- initialization -------------- 567 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 568 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 569 minBuffSize, TEST_MODE); 570 //-------- test -------------- 571 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 572 assertTrue(TEST_NAME, track.setPlaybackRate(0) == AudioTrack.ERROR_BAD_VALUE); 573 //-------- tear down -------------- 574 track.release(); 575 } 576 577 //Test case 6: setPlaybackRate() accepts values twice the output sample rate 578 @LargeTest 579 public void testSetPlaybackRateTwiceOutputSR() throws Exception { 580 // constants for test 581 final String TEST_NAME = "testSetPlaybackRateTwiceOutputSR"; 582 final int TEST_SR = 22050; 583 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 584 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 585 final int TEST_MODE = AudioTrack.MODE_STREAM; 586 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 587 588 //-------- initialization -------------- 589 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 590 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 591 minBuffSize, TEST_MODE); 592 byte data[] = new byte[minBuffSize/2]; 593 int outputSR = AudioTrack.getNativeOutputSampleRate(TEST_STREAM_TYPE); 594 //-------- test -------------- 595 track.write(data, 0, data.length); 596 track.write(data, 0, data.length); 597 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 598 track.play(); 599 assertTrue(TEST_NAME, track.setPlaybackRate(2*outputSR) == AudioTrack.SUCCESS); 600 //-------- tear down -------------- 601 track.release(); 602 } 603 604 //Test case 7: setPlaybackRate() and retrieve value, should be the same for half the content SR 605 @LargeTest 606 public void testSetGetPlaybackRate() throws Exception { 607 // constants for test 608 final String TEST_NAME = "testSetGetPlaybackRate"; 609 final int TEST_SR = 22050; 610 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 611 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 612 final int TEST_MODE = AudioTrack.MODE_STREAM; 613 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 614 615 //-------- initialization -------------- 616 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 617 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 618 minBuffSize, TEST_MODE); 619 byte data[] = new byte[minBuffSize/2]; 620 //-------- test -------------- 621 track.write(data, 0, data.length); 622 track.write(data, 0, data.length); 623 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 624 track.play(); 625 track.setPlaybackRate((int)(TEST_SR/2)); 626 assertTrue(TEST_NAME, track.getPlaybackRate() == (int)(TEST_SR/2)); 627 //-------- tear down -------------- 628 track.release(); 629 } 630 631 //Test case 8: setPlaybackRate() invalid operation if track not initialized 632 @LargeTest 633 public void testSetPlaybackRateUninit() throws Exception { 634 // constants for test 635 final String TEST_NAME = "testSetPlaybackRateUninit"; 636 final int TEST_SR = 22050; 637 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 638 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 639 final int TEST_MODE = AudioTrack.MODE_STATIC; 640 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 641 642 //-------- initialization -------------- 643 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 644 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 645 minBuffSize, TEST_MODE); 646 //-------- test -------------- 647 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_NO_STATIC_DATA); 648 assertTrue(TEST_NAME, 649 track.setPlaybackRate(TEST_SR/2) == AudioTrack.ERROR_INVALID_OPERATION); 650 //-------- tear down -------------- 651 track.release(); 652 } 653 654 //----------------------------------------------------------------- 655 // Playback progress 656 //---------------------------------- 657 658 //Test case 1: setPlaybackHeadPosition() on playing track 659 @LargeTest 660 public void testSetPlaybackHeadPositionPlaying() throws Exception { 661 // constants for test 662 final String TEST_NAME = "testSetPlaybackHeadPositionPlaying"; 663 final int TEST_SR = 22050; 664 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 665 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 666 final int TEST_MODE = AudioTrack.MODE_STREAM; 667 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 668 669 //-------- initialization -------------- 670 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 671 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 672 2*minBuffSize, TEST_MODE); 673 byte data[] = new byte[minBuffSize]; 674 //-------- test -------------- 675 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 676 track.write(data, 0, data.length); 677 track.write(data, 0, data.length); 678 track.play(); 679 assertTrue(TEST_NAME, 680 track.setPlaybackHeadPosition(10) == AudioTrack.ERROR_INVALID_OPERATION); 681 //-------- tear down -------------- 682 track.release(); 683 } 684 685 //Test case 2: setPlaybackHeadPosition() on stopped track 686 @LargeTest 687 public void testSetPlaybackHeadPositionStopped() throws Exception { 688 // constants for test 689 final String TEST_NAME = "testSetPlaybackHeadPositionStopped"; 690 final int TEST_SR = 22050; 691 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 692 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 693 final int TEST_MODE = AudioTrack.MODE_STREAM; 694 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 695 696 //-------- initialization -------------- 697 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 698 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 699 2*minBuffSize, TEST_MODE); 700 byte data[] = new byte[minBuffSize]; 701 //-------- test -------------- 702 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 703 track.write(data, 0, data.length); 704 track.write(data, 0, data.length); 705 track.play(); 706 track.stop(); 707 assumeTrue(TEST_NAME, track.getPlayState() == AudioTrack.PLAYSTATE_STOPPED); 708 assertTrue(TEST_NAME, track.setPlaybackHeadPosition(10) == AudioTrack.SUCCESS); 709 //-------- tear down -------------- 710 track.release(); 711 } 712 713 //Test case 3: setPlaybackHeadPosition() on paused track 714 @LargeTest 715 public void testSetPlaybackHeadPositionPaused() throws Exception { 716 // constants for test 717 final String TEST_NAME = "testSetPlaybackHeadPositionPaused"; 718 final int TEST_SR = 22050; 719 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 720 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 721 final int TEST_MODE = AudioTrack.MODE_STREAM; 722 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 723 724 //-------- initialization -------------- 725 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 726 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 727 2*minBuffSize, TEST_MODE); 728 byte data[] = new byte[minBuffSize]; 729 //-------- test -------------- 730 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 731 track.write(data, 0, data.length); 732 track.write(data, 0, data.length); 733 track.play(); 734 track.pause(); 735 assumeTrue(TEST_NAME, track.getPlayState() == AudioTrack.PLAYSTATE_PAUSED); 736 assertTrue(TEST_NAME, track.setPlaybackHeadPosition(10) == AudioTrack.SUCCESS); 737 //-------- tear down -------------- 738 track.release(); 739 } 740 741 //Test case 4: setPlaybackHeadPosition() beyond what has been written 742 @LargeTest 743 public void testSetPlaybackHeadPositionTooFar() throws Exception { 744 // constants for test 745 final String TEST_NAME = "testSetPlaybackHeadPositionTooFar"; 746 final int TEST_SR = 22050; 747 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 748 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 749 final int TEST_MODE = AudioTrack.MODE_STREAM; 750 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 751 752 //-------- initialization -------------- 753 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 754 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 755 2*minBuffSize, TEST_MODE); 756 byte data[] = new byte[minBuffSize]; 757 // make up a frame index that's beyond what has been written: go from buffer size to frame 758 // count (given the audio track properties), and add 77. 759 int frameIndexTooFar = (2*minBuffSize/2) + 77; 760 //-------- test -------------- 761 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 762 track.write(data, 0, data.length); 763 track.write(data, 0, data.length); 764 track.play(); 765 track.stop(); 766 assumeTrue(TEST_NAME, track.getPlayState() == AudioTrack.PLAYSTATE_STOPPED); 767 assertTrue(TEST_NAME, track.setPlaybackHeadPosition(frameIndexTooFar) == AudioTrack.ERROR_BAD_VALUE); 768 //-------- tear down -------------- 769 track.release(); 770 } 771 772 773 //Test case 5: setLoopPoints() fails for MODE_STREAM 774 @LargeTest 775 public void testSetLoopPointsStream() throws Exception { 776 // constants for test 777 final String TEST_NAME = "testSetLoopPointsStream"; 778 final int TEST_SR = 22050; 779 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 780 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 781 final int TEST_MODE = AudioTrack.MODE_STREAM; 782 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 783 784 //-------- initialization -------------- 785 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 786 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 787 2*minBuffSize, TEST_MODE); 788 byte data[] = new byte[minBuffSize]; 789 //-------- test -------------- 790 track.write(data, 0, data.length); 791 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 792 assertTrue(TEST_NAME, track.setLoopPoints(2, 50, 2) == AudioTrack.ERROR_INVALID_OPERATION); 793 //-------- tear down -------------- 794 track.release(); 795 } 796 797 //Test case 6: setLoopPoints() fails start > end 798 @LargeTest 799 public void testSetLoopPointsStartAfterEnd() throws Exception { 800 // constants for test 801 final String TEST_NAME = "testSetLoopPointsStartAfterEnd"; 802 final int TEST_SR = 22050; 803 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 804 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 805 final int TEST_MODE = AudioTrack.MODE_STATIC; 806 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 807 808 //-------- initialization -------------- 809 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 810 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 811 minBuffSize, TEST_MODE); 812 byte data[] = new byte[minBuffSize]; 813 //-------- test -------------- 814 track.write(data, 0, data.length); 815 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 816 assertTrue(TEST_NAME, track.setLoopPoints(50, 0, 2) == AudioTrack.ERROR_BAD_VALUE); 817 //-------- tear down -------------- 818 track.release(); 819 } 820 821 //Test case 6: setLoopPoints() success 822 @LargeTest 823 public void testSetLoopPointsSuccess() throws Exception { 824 // constants for test 825 final String TEST_NAME = "testSetLoopPointsSuccess"; 826 final int TEST_SR = 22050; 827 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 828 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 829 final int TEST_MODE = AudioTrack.MODE_STATIC; 830 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 831 832 //-------- initialization -------------- 833 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 834 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 835 minBuffSize, TEST_MODE); 836 byte data[] = new byte[minBuffSize]; 837 //-------- test -------------- 838 track.write(data, 0, data.length); 839 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 840 assertTrue(TEST_NAME, track.setLoopPoints(0, 50, 2) == AudioTrack.SUCCESS); 841 //-------- tear down -------------- 842 track.release(); 843 } 844 845 //Test case 7: setLoopPoints() fails with loop length bigger than content 846 @LargeTest 847 public void testSetLoopPointsLoopTooLong() throws Exception { 848 // constants for test 849 final String TEST_NAME = "testSetLoopPointsLoopTooLong"; 850 final int TEST_SR = 22050; 851 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 852 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 853 final int TEST_MODE = AudioTrack.MODE_STATIC; 854 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 855 856 //-------- initialization -------------- 857 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 858 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 859 minBuffSize, TEST_MODE); 860 byte data[] = new byte[minBuffSize]; 861 int dataSizeInFrames = minBuffSize/2; 862 //-------- test -------------- 863 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_NO_STATIC_DATA); 864 track.write(data, 0, data.length); 865 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 866 assertTrue(TEST_NAME, 867 track.setLoopPoints(10, dataSizeInFrames+20, 2) == AudioTrack.ERROR_BAD_VALUE); 868 //-------- tear down -------------- 869 track.release(); 870 } 871 //Test case 8: setLoopPoints() fails with start beyond what can be written for the track 872 @LargeTest 873 public void testSetLoopPointsStartTooFar() throws Exception { 874 // constants for test 875 final String TEST_NAME = "testSetLoopPointsStartTooFar"; 876 final int TEST_SR = 22050; 877 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 878 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 879 final int TEST_MODE = AudioTrack.MODE_STATIC; 880 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 881 882 //-------- initialization -------------- 883 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 884 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 885 minBuffSize, TEST_MODE); 886 byte data[] = new byte[minBuffSize]; 887 int dataSizeInFrames = minBuffSize/2;//16bit data 888 //-------- test -------------- 889 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_NO_STATIC_DATA); 890 track.write(data, 0, data.length); 891 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 892 assertTrue(TEST_NAME, 893 track.setLoopPoints(dataSizeInFrames+20, dataSizeInFrames+50, 2) 894 == AudioTrack.ERROR_BAD_VALUE); 895 //-------- tear down -------------- 896 track.release(); 897 } 898 899 //Test case 9: setLoopPoints() fails with end beyond what can be written for the track 900 @LargeTest 901 public void testSetLoopPointsEndTooFar() throws Exception { 902 // constants for test 903 final String TEST_NAME = "testSetLoopPointsEndTooFar"; 904 final int TEST_SR = 22050; 905 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 906 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 907 final int TEST_MODE = AudioTrack.MODE_STATIC; 908 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 909 910 //-------- initialization -------------- 911 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 912 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 913 minBuffSize, TEST_MODE); 914 byte data[] = new byte[minBuffSize]; 915 int dataSizeInFrames = minBuffSize/2;//16bit data 916 //-------- test -------------- 917 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_NO_STATIC_DATA); 918 track.write(data, 0, data.length); 919 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 920 assertTrue(TEST_NAME, 921 track.setLoopPoints(dataSizeInFrames-10, dataSizeInFrames+50, 2) 922 == AudioTrack.ERROR_BAD_VALUE); 923 //-------- tear down -------------- 924 track.release(); 925 } 926 927 928 //----------------------------------------------------------------- 929 // Audio data supply 930 //---------------------------------- 931 932 //Test case 1: write() fails when supplying less data (bytes) than declared 933 @LargeTest 934 public void testWriteByteOffsetTooBig() throws Exception { 935 // constants for test 936 final String TEST_NAME = "testWriteByteOffsetTooBig"; 937 final int TEST_SR = 22050; 938 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 939 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 940 final int TEST_MODE = AudioTrack.MODE_STREAM; 941 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 942 943 //-------- initialization -------------- 944 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 945 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 946 2*minBuffSize, TEST_MODE); 947 byte data[] = new byte[minBuffSize]; 948 //-------- test -------------- 949 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 950 assertTrue(TEST_NAME, 951 track.write(data, 10, data.length) == AudioTrack.ERROR_BAD_VALUE); 952 //-------- tear down -------------- 953 track.release(); 954 } 955 956 //Test case 2: write() fails when supplying less data (shorts) than declared 957 @LargeTest 958 public void testWriteShortOffsetTooBig() throws Exception { 959 // constants for test 960 final String TEST_NAME = "testWriteShortOffsetTooBig"; 961 final int TEST_SR = 22050; 962 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 963 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 964 final int TEST_MODE = AudioTrack.MODE_STREAM; 965 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 966 967 //-------- initialization -------------- 968 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 969 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 970 2*minBuffSize, TEST_MODE); 971 short data[] = new short[minBuffSize/2]; 972 //-------- test -------------- 973 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 974 assertTrue(TEST_NAME, 975 track.write(data, 10, data.length) == AudioTrack.ERROR_BAD_VALUE); 976 //-------- tear down -------------- 977 track.release(); 978 } 979 980 //Test case 3: write() fails when supplying less data (bytes) than declared 981 @LargeTest 982 public void testWriteByteSizeTooBig() throws Exception { 983 // constants for test 984 final String TEST_NAME = "testWriteByteSizeTooBig"; 985 final int TEST_SR = 22050; 986 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 987 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 988 final int TEST_MODE = AudioTrack.MODE_STREAM; 989 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 990 991 //-------- initialization -------------- 992 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 993 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 994 2*minBuffSize, TEST_MODE); 995 byte data[] = new byte[minBuffSize]; 996 //-------- test -------------- 997 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 998 assertTrue(TEST_NAME, 999 track.write(data, 0, data.length + 10) == AudioTrack.ERROR_BAD_VALUE); 1000 //-------- tear down -------------- 1001 track.release(); 1002 } 1003 1004 //Test case 4: write() fails when supplying less data (shorts) than declared 1005 @LargeTest 1006 public void testWriteShortSizeTooBig() throws Exception { 1007 // constants for test 1008 final String TEST_NAME = "testWriteShortSizeTooBig"; 1009 final int TEST_SR = 22050; 1010 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1011 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 1012 final int TEST_MODE = AudioTrack.MODE_STREAM; 1013 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1014 1015 //-------- initialization -------------- 1016 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1017 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1018 2*minBuffSize, TEST_MODE); 1019 short data[] = new short[minBuffSize/2]; 1020 //-------- test -------------- 1021 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1022 assertTrue(TEST_NAME, 1023 track.write(data, 0, data.length + 10) == AudioTrack.ERROR_BAD_VALUE); 1024 //-------- tear down -------------- 1025 track.release(); 1026 } 1027 1028 //Test case 5: write() fails with negative offset 1029 @LargeTest 1030 public void testWriteByteNegativeOffset() throws Exception { 1031 // constants for test 1032 final String TEST_NAME = "testWriteByteNegativeOffset"; 1033 final int TEST_SR = 22050; 1034 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1035 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 1036 final int TEST_MODE = AudioTrack.MODE_STREAM; 1037 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1038 1039 //-------- initialization -------------- 1040 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1041 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1042 2*minBuffSize, TEST_MODE); 1043 byte data[] = new byte[minBuffSize]; 1044 //-------- test -------------- 1045 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1046 assertTrue(TEST_NAME, 1047 track.write(data, -10, data.length - 10) == AudioTrack.ERROR_BAD_VALUE); 1048 //-------- tear down -------------- 1049 track.release(); 1050 } 1051 1052 //Test case 6: write() fails with negative offset 1053 @LargeTest 1054 public void testWriteShortNegativeOffset() throws Exception { 1055 // constants for test 1056 final String TEST_NAME = "testWriteShortNegativeOffset"; 1057 final int TEST_SR = 22050; 1058 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1059 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 1060 final int TEST_MODE = AudioTrack.MODE_STREAM; 1061 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1062 1063 //-------- initialization -------------- 1064 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1065 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1066 2*minBuffSize, TEST_MODE); 1067 short data[] = new short[minBuffSize/2]; 1068 //-------- test -------------- 1069 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1070 assertTrue(TEST_NAME, 1071 track.write(data, -10, data.length - 10) == AudioTrack.ERROR_BAD_VALUE); 1072 //-------- tear down -------------- 1073 track.release(); 1074 } 1075 1076 //Test case 7: write() fails with negative size 1077 @LargeTest 1078 public void testWriteByteNegativeSize() throws Exception { 1079 // constants for test 1080 final String TEST_NAME = "testWriteByteNegativeSize"; 1081 final int TEST_SR = 22050; 1082 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1083 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 1084 final int TEST_MODE = AudioTrack.MODE_STREAM; 1085 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1086 1087 //-------- initialization -------------- 1088 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1089 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1090 2*minBuffSize, TEST_MODE); 1091 byte data[] = new byte[minBuffSize]; 1092 //-------- test -------------- 1093 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1094 assertTrue(TEST_NAME, 1095 track.write(data, 0, -10) == AudioTrack.ERROR_BAD_VALUE); 1096 //-------- tear down -------------- 1097 track.release(); 1098 } 1099 1100 //Test case 8: write() fails with negative size 1101 @LargeTest 1102 public void testWriteShortNegativeSize() throws Exception { 1103 // constants for test 1104 final String TEST_NAME = "testWriteShortNegativeSize"; 1105 final int TEST_SR = 22050; 1106 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1107 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 1108 final int TEST_MODE = AudioTrack.MODE_STREAM; 1109 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1110 1111 //-------- initialization -------------- 1112 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1113 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1114 2*minBuffSize, TEST_MODE); 1115 short data[] = new short[minBuffSize/2]; 1116 //-------- test -------------- 1117 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1118 assertTrue(TEST_NAME, 1119 track.write(data, 0, -10) == AudioTrack.ERROR_BAD_VALUE); 1120 //-------- tear down -------------- 1121 track.release(); 1122 } 1123 1124 //Test case 9: write() succeeds and returns the size that was written for 16bit 1125 @LargeTest 1126 public void testWriteByte() throws Exception { 1127 // constants for test 1128 final String TEST_NAME = "testWriteByte"; 1129 final int TEST_SR = 22050; 1130 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1131 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 1132 final int TEST_MODE = AudioTrack.MODE_STREAM; 1133 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1134 1135 //-------- initialization -------------- 1136 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1137 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1138 2*minBuffSize, TEST_MODE); 1139 byte data[] = new byte[minBuffSize]; 1140 //-------- test -------------- 1141 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1142 assertTrue(TEST_NAME, 1143 track.write(data, 0, data.length) == data.length); 1144 //-------- tear down -------------- 1145 track.release(); 1146 } 1147 1148 //Test case 10: write() succeeds and returns the size that was written for 16bit 1149 @LargeTest 1150 public void testWriteShort() throws Exception { 1151 // constants for test 1152 final String TEST_NAME = "testWriteShort"; 1153 final int TEST_SR = 22050; 1154 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1155 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 1156 final int TEST_MODE = AudioTrack.MODE_STREAM; 1157 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1158 1159 //-------- initialization -------------- 1160 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1161 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1162 2*minBuffSize, TEST_MODE); 1163 short data[] = new short[minBuffSize/2]; 1164 //-------- test -------------- 1165 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1166 assertTrue(TEST_NAME, 1167 track.write(data, 0, data.length) == data.length); 1168 //-------- tear down -------------- 1169 track.release(); 1170 } 1171 1172 //Test case 11: write() succeeds and returns the size that was written for 8bit 1173 @LargeTest 1174 public void testWriteByte8bit() throws Exception { 1175 // constants for test 1176 final String TEST_NAME = "testWriteByte8bit"; 1177 final int TEST_SR = 22050; 1178 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1179 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_8BIT; 1180 final int TEST_MODE = AudioTrack.MODE_STREAM; 1181 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1182 1183 //-------- initialization -------------- 1184 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1185 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1186 2*minBuffSize, TEST_MODE); 1187 byte data[] = new byte[minBuffSize]; 1188 //-------- test -------------- 1189 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1190 assertTrue(TEST_NAME, 1191 track.write(data, 0, data.length) == data.length); 1192 //-------- tear down -------------- 1193 track.release(); 1194 } 1195 1196 //Test case 12: write() succeeds and returns the size that was written for 8bit 1197 @LargeTest 1198 public void testWriteShort8bit() throws Exception { 1199 // constants for test 1200 final String TEST_NAME = "testWriteShort8bit"; 1201 final int TEST_SR = 22050; 1202 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1203 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_8BIT; 1204 final int TEST_MODE = AudioTrack.MODE_STREAM; 1205 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1206 1207 //-------- initialization -------------- 1208 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1209 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1210 2*minBuffSize, TEST_MODE); 1211 short data[] = new short[minBuffSize/2]; 1212 //-------- test -------------- 1213 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1214 assertTrue(TEST_NAME, 1215 track.write(data, 0, data.length) == data.length); 1216 //-------- tear down -------------- 1217 track.release(); 1218 } 1219 1220 //----------------------------------------------------------------- 1221 // Getters 1222 //---------------------------------- 1223 1224 //Test case 1: getMinBufferSize() return ERROR_BAD_VALUE if SR < 4000 1225 @LargeTest 1226 public void testGetMinBufferSizeTooLowSR() throws Exception { 1227 // constant for test 1228 final String TEST_NAME = "testGetMinBufferSizeTooLowSR"; 1229 final int TEST_SR = 3999; 1230 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1231 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_8BIT; 1232 final int TEST_MODE = AudioTrack.MODE_STREAM; 1233 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1234 1235 //-------- initialization & test -------------- 1236 assertTrue(TEST_NAME, 1237 AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT) 1238 == AudioTrack.ERROR_BAD_VALUE); 1239 } 1240 1241 //Test case 2: getMinBufferSize() return ERROR_BAD_VALUE if SR > 48000 1242 @LargeTest 1243 public void testGetMinBufferSizeTooHighSR() throws Exception { 1244 // constant for testg 1245 final String TEST_NAME = "testGetMinBufferSizeTooHighSR"; 1246 final int TEST_SR = 48001; 1247 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1248 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_8BIT; 1249 final int TEST_MODE = AudioTrack.MODE_STREAM; 1250 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1251 1252 //-------- initialization & test -------------- 1253 assertTrue(TEST_NAME, 1254 AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT) 1255 == AudioTrack.ERROR_BAD_VALUE); 1256 } 1257 1258} 1259