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 390 //-------- initialization -------------- 391 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 392 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 393 minBuffSize, TEST_MODE); 394 byte data[] = new byte[minBuffSize/2]; 395 //-------- test -------------- 396 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 397 track.write(data, 0, data.length); 398 track.write(data, 0, data.length); 399 track.play(); 400 Thread.sleep(100); 401 track.stop(); 402 Thread.sleep(100); // TODO: what is a sensible value? 403 int pos = track.getPlaybackHeadPosition(); 404 log(TEST_NAME, "position ="+ pos); 405 assertTrue(TEST_NAME, pos == 0); 406 //-------- tear down -------------- 407 track.release(); 408 } 409 410 //Test case 4: getPlaybackHeadPosition() is > 0 after play(); pause(); 411 @LargeTest 412 public void testPlaybackHeadPositionAfterPause() throws Exception { 413 // constants for test 414 final String TEST_NAME = "testPlaybackHeadPositionAfterPause"; 415 final int TEST_SR = 22050; 416 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 417 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 418 final int TEST_MODE = AudioTrack.MODE_STREAM; 419 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 420 421 //-------- initialization -------------- 422 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 423 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 424 minBuffSize, TEST_MODE); 425 byte data[] = new byte[minBuffSize/2]; 426 //-------- test -------------- 427 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 428 track.write(data, 0, data.length); 429 track.write(data, 0, data.length); 430 track.play(); 431 Thread.sleep(100); 432 track.pause(); 433 int pos = track.getPlaybackHeadPosition(); 434 log(TEST_NAME, "position ="+ pos); 435 assertTrue(TEST_NAME, pos > 0); 436 //-------- tear down -------------- 437 track.release(); 438 } 439 440 441 //----------------------------------------------------------------- 442 // Playback properties 443 //---------------------------------- 444 445 //Test case 1: setStereoVolume() with max volume returns SUCCESS 446 @LargeTest 447 public void testSetStereoVolumeMax() throws Exception { 448 // constants for test 449 final String TEST_NAME = "testSetStereoVolumeMax"; 450 final int TEST_SR = 22050; 451 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 452 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 453 final int TEST_MODE = AudioTrack.MODE_STREAM; 454 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 455 456 //-------- initialization -------------- 457 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 458 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 459 minBuffSize, TEST_MODE); 460 byte data[] = new byte[minBuffSize/2]; 461 //-------- test -------------- 462 track.write(data, 0, data.length); 463 track.write(data, 0, data.length); 464 track.play(); 465 float maxVol = AudioTrack.getMaxVolume(); 466 assertTrue(TEST_NAME, track.setStereoVolume(maxVol, maxVol) == AudioTrack.SUCCESS); 467 //-------- tear down -------------- 468 track.release(); 469 } 470 471 //Test case 2: setStereoVolume() with min volume returns SUCCESS 472 @LargeTest 473 public void testSetStereoVolumeMin() throws Exception { 474 // constants for test 475 final String TEST_NAME = "testSetStereoVolumeMin"; 476 final int TEST_SR = 22050; 477 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 478 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 479 final int TEST_MODE = AudioTrack.MODE_STREAM; 480 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 481 482 //-------- initialization -------------- 483 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 484 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 485 minBuffSize, TEST_MODE); 486 byte data[] = new byte[minBuffSize/2]; 487 //-------- test -------------- 488 track.write(data, 0, data.length); 489 track.write(data, 0, data.length); 490 track.play(); 491 float minVol = AudioTrack.getMinVolume(); 492 assertTrue(TEST_NAME, track.setStereoVolume(minVol, minVol) == AudioTrack.SUCCESS); 493 //-------- tear down -------------- 494 track.release(); 495 } 496 497 //Test case 3: setStereoVolume() with mid volume returns SUCCESS 498 @LargeTest 499 public void testSetStereoVolumeMid() throws Exception { 500 // constants for test 501 final String TEST_NAME = "testSetStereoVolumeMid"; 502 final int TEST_SR = 22050; 503 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 504 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 505 final int TEST_MODE = AudioTrack.MODE_STREAM; 506 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 507 508 //-------- initialization -------------- 509 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 510 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 511 minBuffSize, TEST_MODE); 512 byte data[] = new byte[minBuffSize/2]; 513 //-------- test -------------- 514 track.write(data, 0, data.length); 515 track.write(data, 0, data.length); 516 track.play(); 517 float midVol = (AudioTrack.getMaxVolume() - AudioTrack.getMinVolume()) / 2; 518 assertTrue(TEST_NAME, track.setStereoVolume(midVol, midVol) == AudioTrack.SUCCESS); 519 //-------- tear down -------------- 520 track.release(); 521 } 522 523 //Test case 4: setPlaybackRate() with half the content rate returns SUCCESS 524 @LargeTest 525 public void testSetPlaybackRate() throws Exception { 526 // constants for test 527 final String TEST_NAME = "testSetPlaybackRate"; 528 final int TEST_SR = 22050; 529 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 530 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 531 final int TEST_MODE = AudioTrack.MODE_STREAM; 532 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 533 534 //-------- initialization -------------- 535 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 536 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 537 minBuffSize, TEST_MODE); 538 byte data[] = new byte[minBuffSize/2]; 539 //-------- test -------------- 540 track.write(data, 0, data.length); 541 track.write(data, 0, data.length); 542 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 543 track.play(); 544 assertTrue(TEST_NAME, track.setPlaybackRate((int)(TEST_SR/2)) == AudioTrack.SUCCESS); 545 //-------- tear down -------------- 546 track.release(); 547 } 548 549 //Test case 5: setPlaybackRate(0) returns bad value error 550 @LargeTest 551 public void testSetPlaybackRateZero() throws Exception { 552 // constants for test 553 final String TEST_NAME = "testSetPlaybackRateZero"; 554 final int TEST_SR = 22050; 555 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 556 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 557 final int TEST_MODE = AudioTrack.MODE_STREAM; 558 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 559 560 //-------- initialization -------------- 561 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 562 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 563 minBuffSize, TEST_MODE); 564 //-------- test -------------- 565 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 566 assertTrue(TEST_NAME, track.setPlaybackRate(0) == AudioTrack.ERROR_BAD_VALUE); 567 //-------- tear down -------------- 568 track.release(); 569 } 570 571 //Test case 6: setPlaybackRate() accepts values twice the output sample rate 572 @LargeTest 573 public void testSetPlaybackRateTwiceOutputSR() throws Exception { 574 // constants for test 575 final String TEST_NAME = "testSetPlaybackRateTwiceOutputSR"; 576 final int TEST_SR = 22050; 577 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 578 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 579 final int TEST_MODE = AudioTrack.MODE_STREAM; 580 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 581 582 //-------- initialization -------------- 583 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 584 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 585 minBuffSize, TEST_MODE); 586 byte data[] = new byte[minBuffSize/2]; 587 int outputSR = AudioTrack.getNativeOutputSampleRate(TEST_STREAM_TYPE); 588 //-------- test -------------- 589 track.write(data, 0, data.length); 590 track.write(data, 0, data.length); 591 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 592 track.play(); 593 assertTrue(TEST_NAME, track.setPlaybackRate(2*outputSR) == AudioTrack.SUCCESS); 594 //-------- tear down -------------- 595 track.release(); 596 } 597 598 //Test case 7: setPlaybackRate() and retrieve value, should be the same for half the content SR 599 @LargeTest 600 public void testSetGetPlaybackRate() throws Exception { 601 // constants for test 602 final String TEST_NAME = "testSetGetPlaybackRate"; 603 final int TEST_SR = 22050; 604 final int TEST_CONF = AudioFormat.CHANNEL_OUT_STEREO; 605 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 606 final int TEST_MODE = AudioTrack.MODE_STREAM; 607 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 608 609 //-------- initialization -------------- 610 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 611 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 612 minBuffSize, TEST_MODE); 613 byte data[] = new byte[minBuffSize/2]; 614 //-------- test -------------- 615 track.write(data, 0, data.length); 616 track.write(data, 0, data.length); 617 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 618 track.play(); 619 track.setPlaybackRate((int)(TEST_SR/2)); 620 assertTrue(TEST_NAME, track.getPlaybackRate() == (int)(TEST_SR/2)); 621 //-------- tear down -------------- 622 track.release(); 623 } 624 625 //Test case 8: setPlaybackRate() invalid operation if track not initialized 626 @LargeTest 627 public void testSetPlaybackRateUninit() throws Exception { 628 // constants for test 629 final String TEST_NAME = "testSetPlaybackRateUninit"; 630 final int TEST_SR = 22050; 631 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 632 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 633 final int TEST_MODE = AudioTrack.MODE_STATIC; 634 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 635 636 //-------- initialization -------------- 637 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 638 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 639 minBuffSize, TEST_MODE); 640 //-------- test -------------- 641 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_NO_STATIC_DATA); 642 assertTrue(TEST_NAME, 643 track.setPlaybackRate(TEST_SR/2) == AudioTrack.ERROR_INVALID_OPERATION); 644 //-------- tear down -------------- 645 track.release(); 646 } 647 648 //----------------------------------------------------------------- 649 // Playback progress 650 //---------------------------------- 651 652 //Test case 1: setPlaybackHeadPosition() on playing track 653 @LargeTest 654 public void testSetPlaybackHeadPositionPlaying() throws Exception { 655 // constants for test 656 final String TEST_NAME = "testSetPlaybackHeadPositionPlaying"; 657 final int TEST_SR = 22050; 658 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 659 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 660 final int TEST_MODE = AudioTrack.MODE_STREAM; 661 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 662 663 //-------- initialization -------------- 664 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 665 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 666 2*minBuffSize, TEST_MODE); 667 byte data[] = new byte[minBuffSize]; 668 //-------- test -------------- 669 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 670 track.write(data, 0, data.length); 671 track.write(data, 0, data.length); 672 track.play(); 673 assertTrue(TEST_NAME, 674 track.setPlaybackHeadPosition(10) == AudioTrack.ERROR_INVALID_OPERATION); 675 //-------- tear down -------------- 676 track.release(); 677 } 678 679 //Test case 2: setPlaybackHeadPosition() on stopped track 680 @LargeTest 681 public void testSetPlaybackHeadPositionStopped() throws Exception { 682 // constants for test 683 final String TEST_NAME = "testSetPlaybackHeadPositionStopped"; 684 final int TEST_SR = 22050; 685 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 686 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 687 final int TEST_MODE = AudioTrack.MODE_STREAM; 688 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 689 690 //-------- initialization -------------- 691 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 692 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 693 2*minBuffSize, TEST_MODE); 694 byte data[] = new byte[minBuffSize]; 695 //-------- test -------------- 696 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 697 track.write(data, 0, data.length); 698 track.write(data, 0, data.length); 699 track.play(); 700 track.stop(); 701 assumeTrue(TEST_NAME, track.getPlayState() == AudioTrack.PLAYSTATE_STOPPED); 702 assertTrue(TEST_NAME, track.setPlaybackHeadPosition(10) == AudioTrack.SUCCESS); 703 //-------- tear down -------------- 704 track.release(); 705 } 706 707 //Test case 3: setPlaybackHeadPosition() on paused track 708 @LargeTest 709 public void testSetPlaybackHeadPositionPaused() throws Exception { 710 // constants for test 711 final String TEST_NAME = "testSetPlaybackHeadPositionPaused"; 712 final int TEST_SR = 22050; 713 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 714 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 715 final int TEST_MODE = AudioTrack.MODE_STREAM; 716 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 717 718 //-------- initialization -------------- 719 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 720 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 721 2*minBuffSize, TEST_MODE); 722 byte data[] = new byte[minBuffSize]; 723 //-------- test -------------- 724 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 725 track.write(data, 0, data.length); 726 track.write(data, 0, data.length); 727 track.play(); 728 track.pause(); 729 assumeTrue(TEST_NAME, track.getPlayState() == AudioTrack.PLAYSTATE_PAUSED); 730 assertTrue(TEST_NAME, track.setPlaybackHeadPosition(10) == AudioTrack.SUCCESS); 731 //-------- tear down -------------- 732 track.release(); 733 } 734 735 //Test case 4: setPlaybackHeadPosition() beyond what has been written 736 @LargeTest 737 public void testSetPlaybackHeadPositionTooFar() throws Exception { 738 // constants for test 739 final String TEST_NAME = "testSetPlaybackHeadPositionTooFar"; 740 final int TEST_SR = 22050; 741 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 742 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 743 final int TEST_MODE = AudioTrack.MODE_STREAM; 744 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 745 746 //-------- initialization -------------- 747 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 748 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 749 2*minBuffSize, TEST_MODE); 750 byte data[] = new byte[minBuffSize]; 751 // make up a frame index that's beyond what has been written: go from buffer size to frame 752 // count (given the audio track properties), and add 77. 753 int frameIndexTooFar = (2*minBuffSize/2) + 77; 754 //-------- test -------------- 755 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 756 track.write(data, 0, data.length); 757 track.write(data, 0, data.length); 758 track.play(); 759 track.stop(); 760 assumeTrue(TEST_NAME, track.getPlayState() == AudioTrack.PLAYSTATE_STOPPED); 761 assertTrue(TEST_NAME, track.setPlaybackHeadPosition(frameIndexTooFar) == AudioTrack.ERROR_BAD_VALUE); 762 //-------- tear down -------------- 763 track.release(); 764 } 765 766 767 //Test case 5: setLoopPoints() fails for MODE_STREAM 768 @LargeTest 769 public void testSetLoopPointsStream() throws Exception { 770 // constants for test 771 final String TEST_NAME = "testSetLoopPointsStream"; 772 final int TEST_SR = 22050; 773 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 774 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 775 final int TEST_MODE = AudioTrack.MODE_STREAM; 776 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 777 778 //-------- initialization -------------- 779 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 780 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 781 2*minBuffSize, TEST_MODE); 782 byte data[] = new byte[minBuffSize]; 783 //-------- test -------------- 784 track.write(data, 0, data.length); 785 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 786 assertTrue(TEST_NAME, track.setLoopPoints(2, 50, 2) == AudioTrack.ERROR_INVALID_OPERATION); 787 //-------- tear down -------------- 788 track.release(); 789 } 790 791 //Test case 6: setLoopPoints() fails start > end 792 @LargeTest 793 public void testSetLoopPointsStartAfterEnd() throws Exception { 794 // constants for test 795 final String TEST_NAME = "testSetLoopPointsStartAfterEnd"; 796 final int TEST_SR = 22050; 797 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 798 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 799 final int TEST_MODE = AudioTrack.MODE_STATIC; 800 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 801 802 //-------- initialization -------------- 803 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 804 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 805 minBuffSize, TEST_MODE); 806 byte data[] = new byte[minBuffSize]; 807 //-------- test -------------- 808 track.write(data, 0, data.length); 809 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 810 assertTrue(TEST_NAME, track.setLoopPoints(50, 0, 2) == AudioTrack.ERROR_BAD_VALUE); 811 //-------- tear down -------------- 812 track.release(); 813 } 814 815 //Test case 6: setLoopPoints() success 816 @LargeTest 817 public void testSetLoopPointsSuccess() throws Exception { 818 // constants for test 819 final String TEST_NAME = "testSetLoopPointsSuccess"; 820 final int TEST_SR = 22050; 821 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 822 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 823 final int TEST_MODE = AudioTrack.MODE_STATIC; 824 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 825 826 //-------- initialization -------------- 827 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 828 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 829 minBuffSize, TEST_MODE); 830 byte data[] = new byte[minBuffSize]; 831 //-------- test -------------- 832 track.write(data, 0, data.length); 833 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 834 assertTrue(TEST_NAME, track.setLoopPoints(0, 50, 2) == AudioTrack.SUCCESS); 835 //-------- tear down -------------- 836 track.release(); 837 } 838 839 //Test case 7: setLoopPoints() fails with loop length bigger than content 840 @LargeTest 841 public void testSetLoopPointsLoopTooLong() throws Exception { 842 // constants for test 843 final String TEST_NAME = "testSetLoopPointsLoopTooLong"; 844 final int TEST_SR = 22050; 845 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 846 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 847 final int TEST_MODE = AudioTrack.MODE_STATIC; 848 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 849 850 //-------- initialization -------------- 851 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 852 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 853 minBuffSize, TEST_MODE); 854 byte data[] = new byte[minBuffSize]; 855 int dataSizeInFrames = minBuffSize/2; 856 //-------- test -------------- 857 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_NO_STATIC_DATA); 858 track.write(data, 0, data.length); 859 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 860 assertTrue(TEST_NAME, 861 track.setLoopPoints(10, dataSizeInFrames+20, 2) == AudioTrack.ERROR_BAD_VALUE); 862 //-------- tear down -------------- 863 track.release(); 864 } 865 //Test case 8: setLoopPoints() fails with start beyond what can be written for the track 866 @LargeTest 867 public void testSetLoopPointsStartTooFar() throws Exception { 868 // constants for test 869 final String TEST_NAME = "testSetLoopPointsStartTooFar"; 870 final int TEST_SR = 22050; 871 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 872 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 873 final int TEST_MODE = AudioTrack.MODE_STATIC; 874 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 875 876 //-------- initialization -------------- 877 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 878 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 879 minBuffSize, TEST_MODE); 880 byte data[] = new byte[minBuffSize]; 881 int dataSizeInFrames = minBuffSize/2;//16bit data 882 //-------- test -------------- 883 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_NO_STATIC_DATA); 884 track.write(data, 0, data.length); 885 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 886 assertTrue(TEST_NAME, 887 track.setLoopPoints(dataSizeInFrames+20, dataSizeInFrames+50, 2) 888 == AudioTrack.ERROR_BAD_VALUE); 889 //-------- tear down -------------- 890 track.release(); 891 } 892 893 //Test case 9: setLoopPoints() fails with end beyond what can be written for the track 894 @LargeTest 895 public void testSetLoopPointsEndTooFar() throws Exception { 896 // constants for test 897 final String TEST_NAME = "testSetLoopPointsEndTooFar"; 898 final int TEST_SR = 22050; 899 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 900 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 901 final int TEST_MODE = AudioTrack.MODE_STATIC; 902 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 903 904 //-------- initialization -------------- 905 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 906 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 907 minBuffSize, TEST_MODE); 908 byte data[] = new byte[minBuffSize]; 909 int dataSizeInFrames = minBuffSize/2;//16bit data 910 //-------- test -------------- 911 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_NO_STATIC_DATA); 912 track.write(data, 0, data.length); 913 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 914 assertTrue(TEST_NAME, 915 track.setLoopPoints(dataSizeInFrames-10, dataSizeInFrames+50, 2) 916 == AudioTrack.ERROR_BAD_VALUE); 917 //-------- tear down -------------- 918 track.release(); 919 } 920 921 922 //----------------------------------------------------------------- 923 // Audio data supply 924 //---------------------------------- 925 926 //Test case 1: write() fails when supplying less data (bytes) than declared 927 @LargeTest 928 public void testWriteByteOffsetTooBig() throws Exception { 929 // constants for test 930 final String TEST_NAME = "testWriteByteOffsetTooBig"; 931 final int TEST_SR = 22050; 932 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 933 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 934 final int TEST_MODE = AudioTrack.MODE_STREAM; 935 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 936 937 //-------- initialization -------------- 938 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 939 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 940 2*minBuffSize, TEST_MODE); 941 byte data[] = new byte[minBuffSize]; 942 //-------- test -------------- 943 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 944 assertTrue(TEST_NAME, 945 track.write(data, 10, data.length) == AudioTrack.ERROR_BAD_VALUE); 946 //-------- tear down -------------- 947 track.release(); 948 } 949 950 //Test case 2: write() fails when supplying less data (shorts) than declared 951 @LargeTest 952 public void testWriteShortOffsetTooBig() throws Exception { 953 // constants for test 954 final String TEST_NAME = "testWriteShortOffsetTooBig"; 955 final int TEST_SR = 22050; 956 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 957 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 958 final int TEST_MODE = AudioTrack.MODE_STREAM; 959 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 960 961 //-------- initialization -------------- 962 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 963 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 964 2*minBuffSize, TEST_MODE); 965 short data[] = new short[minBuffSize/2]; 966 //-------- test -------------- 967 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 968 assertTrue(TEST_NAME, 969 track.write(data, 10, data.length) == AudioTrack.ERROR_BAD_VALUE); 970 //-------- tear down -------------- 971 track.release(); 972 } 973 974 //Test case 3: write() fails when supplying less data (bytes) than declared 975 @LargeTest 976 public void testWriteByteSizeTooBig() throws Exception { 977 // constants for test 978 final String TEST_NAME = "testWriteByteSizeTooBig"; 979 final int TEST_SR = 22050; 980 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 981 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 982 final int TEST_MODE = AudioTrack.MODE_STREAM; 983 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 984 985 //-------- initialization -------------- 986 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 987 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 988 2*minBuffSize, TEST_MODE); 989 byte data[] = new byte[minBuffSize]; 990 //-------- test -------------- 991 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 992 assertTrue(TEST_NAME, 993 track.write(data, 0, data.length + 10) == AudioTrack.ERROR_BAD_VALUE); 994 //-------- tear down -------------- 995 track.release(); 996 } 997 998 //Test case 4: write() fails when supplying less data (shorts) than declared 999 @LargeTest 1000 public void testWriteShortSizeTooBig() throws Exception { 1001 // constants for test 1002 final String TEST_NAME = "testWriteShortSizeTooBig"; 1003 final int TEST_SR = 22050; 1004 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1005 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 1006 final int TEST_MODE = AudioTrack.MODE_STREAM; 1007 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1008 1009 //-------- initialization -------------- 1010 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1011 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1012 2*minBuffSize, TEST_MODE); 1013 short data[] = new short[minBuffSize/2]; 1014 //-------- test -------------- 1015 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1016 assertTrue(TEST_NAME, 1017 track.write(data, 0, data.length + 10) == AudioTrack.ERROR_BAD_VALUE); 1018 //-------- tear down -------------- 1019 track.release(); 1020 } 1021 1022 //Test case 5: write() fails with negative offset 1023 @LargeTest 1024 public void testWriteByteNegativeOffset() throws Exception { 1025 // constants for test 1026 final String TEST_NAME = "testWriteByteNegativeOffset"; 1027 final int TEST_SR = 22050; 1028 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1029 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 1030 final int TEST_MODE = AudioTrack.MODE_STREAM; 1031 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1032 1033 //-------- initialization -------------- 1034 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1035 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1036 2*minBuffSize, TEST_MODE); 1037 byte data[] = new byte[minBuffSize]; 1038 //-------- test -------------- 1039 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1040 assertTrue(TEST_NAME, 1041 track.write(data, -10, data.length - 10) == AudioTrack.ERROR_BAD_VALUE); 1042 //-------- tear down -------------- 1043 track.release(); 1044 } 1045 1046 //Test case 6: write() fails with negative offset 1047 @LargeTest 1048 public void testWriteShortNegativeOffset() throws Exception { 1049 // constants for test 1050 final String TEST_NAME = "testWriteShortNegativeOffset"; 1051 final int TEST_SR = 22050; 1052 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1053 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 1054 final int TEST_MODE = AudioTrack.MODE_STREAM; 1055 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1056 1057 //-------- initialization -------------- 1058 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1059 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1060 2*minBuffSize, TEST_MODE); 1061 short data[] = new short[minBuffSize/2]; 1062 //-------- test -------------- 1063 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1064 assertTrue(TEST_NAME, 1065 track.write(data, -10, data.length - 10) == AudioTrack.ERROR_BAD_VALUE); 1066 //-------- tear down -------------- 1067 track.release(); 1068 } 1069 1070 //Test case 7: write() fails with negative size 1071 @LargeTest 1072 public void testWriteByteNegativeSize() throws Exception { 1073 // constants for test 1074 final String TEST_NAME = "testWriteByteNegativeSize"; 1075 final int TEST_SR = 22050; 1076 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1077 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 1078 final int TEST_MODE = AudioTrack.MODE_STREAM; 1079 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1080 1081 //-------- initialization -------------- 1082 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1083 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1084 2*minBuffSize, TEST_MODE); 1085 byte data[] = new byte[minBuffSize]; 1086 //-------- test -------------- 1087 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1088 assertTrue(TEST_NAME, 1089 track.write(data, 0, -10) == AudioTrack.ERROR_BAD_VALUE); 1090 //-------- tear down -------------- 1091 track.release(); 1092 } 1093 1094 //Test case 8: write() fails with negative size 1095 @LargeTest 1096 public void testWriteShortNegativeSize() throws Exception { 1097 // constants for test 1098 final String TEST_NAME = "testWriteShortNegativeSize"; 1099 final int TEST_SR = 22050; 1100 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1101 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 1102 final int TEST_MODE = AudioTrack.MODE_STREAM; 1103 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1104 1105 //-------- initialization -------------- 1106 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1107 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1108 2*minBuffSize, TEST_MODE); 1109 short data[] = new short[minBuffSize/2]; 1110 //-------- test -------------- 1111 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1112 assertTrue(TEST_NAME, 1113 track.write(data, 0, -10) == AudioTrack.ERROR_BAD_VALUE); 1114 //-------- tear down -------------- 1115 track.release(); 1116 } 1117 1118 //Test case 9: write() succeeds and returns the size that was written for 16bit 1119 @LargeTest 1120 public void testWriteByte() throws Exception { 1121 // constants for test 1122 final String TEST_NAME = "testWriteByte"; 1123 final int TEST_SR = 22050; 1124 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1125 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 1126 final int TEST_MODE = AudioTrack.MODE_STREAM; 1127 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1128 1129 //-------- initialization -------------- 1130 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1131 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1132 2*minBuffSize, TEST_MODE); 1133 byte data[] = new byte[minBuffSize]; 1134 //-------- test -------------- 1135 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1136 assertTrue(TEST_NAME, 1137 track.write(data, 0, data.length) == data.length); 1138 //-------- tear down -------------- 1139 track.release(); 1140 } 1141 1142 //Test case 10: write() succeeds and returns the size that was written for 16bit 1143 @LargeTest 1144 public void testWriteShort() throws Exception { 1145 // constants for test 1146 final String TEST_NAME = "testWriteShort"; 1147 final int TEST_SR = 22050; 1148 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1149 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_16BIT; 1150 final int TEST_MODE = AudioTrack.MODE_STREAM; 1151 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1152 1153 //-------- initialization -------------- 1154 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1155 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1156 2*minBuffSize, TEST_MODE); 1157 short data[] = new short[minBuffSize/2]; 1158 //-------- test -------------- 1159 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1160 assertTrue(TEST_NAME, 1161 track.write(data, 0, data.length) == data.length); 1162 //-------- tear down -------------- 1163 track.release(); 1164 } 1165 1166 //Test case 11: write() succeeds and returns the size that was written for 8bit 1167 @LargeTest 1168 public void testWriteByte8bit() throws Exception { 1169 // constants for test 1170 final String TEST_NAME = "testWriteByte8bit"; 1171 final int TEST_SR = 22050; 1172 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1173 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_8BIT; 1174 final int TEST_MODE = AudioTrack.MODE_STREAM; 1175 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1176 1177 //-------- initialization -------------- 1178 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1179 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1180 2*minBuffSize, TEST_MODE); 1181 byte data[] = new byte[minBuffSize]; 1182 //-------- test -------------- 1183 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1184 assertTrue(TEST_NAME, 1185 track.write(data, 0, data.length) == data.length); 1186 //-------- tear down -------------- 1187 track.release(); 1188 } 1189 1190 //Test case 12: write() succeeds and returns the size that was written for 8bit 1191 @LargeTest 1192 public void testWriteShort8bit() throws Exception { 1193 // constants for test 1194 final String TEST_NAME = "testWriteShort8bit"; 1195 final int TEST_SR = 22050; 1196 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1197 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_8BIT; 1198 final int TEST_MODE = AudioTrack.MODE_STREAM; 1199 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1200 1201 //-------- initialization -------------- 1202 int minBuffSize = AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT); 1203 AudioTrack track = new AudioTrack(TEST_STREAM_TYPE, TEST_SR, TEST_CONF, TEST_FORMAT, 1204 2*minBuffSize, TEST_MODE); 1205 short data[] = new short[minBuffSize/2]; 1206 //-------- test -------------- 1207 assumeTrue(TEST_NAME, track.getState() == AudioTrack.STATE_INITIALIZED); 1208 assertTrue(TEST_NAME, 1209 track.write(data, 0, data.length) == data.length); 1210 //-------- tear down -------------- 1211 track.release(); 1212 } 1213 1214 //----------------------------------------------------------------- 1215 // Getters 1216 //---------------------------------- 1217 1218 //Test case 1: getMinBufferSize() return ERROR_BAD_VALUE if SR < 4000 1219 @LargeTest 1220 public void testGetMinBufferSizeTooLowSR() throws Exception { 1221 // constant for test 1222 final String TEST_NAME = "testGetMinBufferSizeTooLowSR"; 1223 final int TEST_SR = 3999; 1224 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1225 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_8BIT; 1226 final int TEST_MODE = AudioTrack.MODE_STREAM; 1227 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1228 1229 //-------- initialization & test -------------- 1230 assertTrue(TEST_NAME, 1231 AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT) 1232 == AudioTrack.ERROR_BAD_VALUE); 1233 } 1234 1235 //Test case 2: getMinBufferSize() return ERROR_BAD_VALUE if SR > 48000 1236 @LargeTest 1237 public void testGetMinBufferSizeTooHighSR() throws Exception { 1238 // constant for testg 1239 final String TEST_NAME = "testGetMinBufferSizeTooHighSR"; 1240 final int TEST_SR = 48001; 1241 final int TEST_CONF = AudioFormat.CHANNEL_OUT_MONO; 1242 final int TEST_FORMAT = AudioFormat.ENCODING_PCM_8BIT; 1243 final int TEST_MODE = AudioTrack.MODE_STREAM; 1244 final int TEST_STREAM_TYPE = AudioManager.STREAM_MUSIC; 1245 1246 //-------- initialization & test -------------- 1247 assertTrue(TEST_NAME, 1248 AudioTrack.getMinBufferSize(TEST_SR, TEST_CONF, TEST_FORMAT) 1249 == AudioTrack.ERROR_BAD_VALUE); 1250 } 1251 1252} 1253