data.c revision c323fec2a2639c0cf7463016d592d0eb0539657c
1/* 2 * Copyright (C) 2010 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 17/** Data locator, data format, data source, and data sink support */ 18 19#include "sles_allinclusive.h" 20 21 22/** \brief Check a data locator and make local deep copy */ 23 24static SLresult checkDataLocator(const char *name, void *pLocator, DataLocator *pDataLocator, 25 SLuint32 allowedDataLocatorMask) 26{ 27 assert(NULL != name && NULL != pDataLocator); 28 SLresult result = SL_RESULT_SUCCESS; 29 30 SLuint32 locatorType; 31 if (NULL == pLocator) { 32 pDataLocator->mLocatorType = locatorType = SL_DATALOCATOR_NULL; 33 } else { 34 locatorType = *(SLuint32 *)pLocator; 35 switch (locatorType) { 36 37 case SL_DATALOCATOR_ADDRESS: 38 pDataLocator->mAddress = *(SLDataLocator_Address *)pLocator; 39 // if length is greater than zero, then the address must be non-NULL 40 if ((0 < pDataLocator->mAddress.length) && (NULL == pDataLocator->mAddress.pAddress)) { 41 SL_LOGE("%s: pAddress=NULL", name); 42 result = SL_RESULT_PARAMETER_INVALID; 43 } 44 break; 45 46 case SL_DATALOCATOR_BUFFERQUEUE: 47#ifdef ANDROID 48 // This is an alias that is _not_ converted; the rest of the code must check for both 49 // locator types. That's because it is only an alias for audio players, not audio recorder 50 // objects so we have to remember the distinction. 51 case SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE: 52#endif 53 pDataLocator->mBufferQueue = *(SLDataLocator_BufferQueue *)pLocator; 54 // number of buffers must be specified, there is no default value, and can't be too big 55 if (!((1 <= pDataLocator->mBufferQueue.numBuffers) && 56 (pDataLocator->mBufferQueue.numBuffers <= 255))) { 57 SL_LOGE("%s: numBuffers=%u", name, pDataLocator->mBufferQueue.numBuffers); 58 result = SL_RESULT_PARAMETER_INVALID; 59 } 60 break; 61 62 case SL_DATALOCATOR_IODEVICE: 63 { 64 pDataLocator->mIODevice = *(SLDataLocator_IODevice *)pLocator; 65 SLuint32 deviceType = pDataLocator->mIODevice.deviceType; 66 SLObjectItf device = pDataLocator->mIODevice.device; 67 if (NULL != device) { 68 pDataLocator->mIODevice.deviceID = 0; 69 SLuint32 expectedObjectID; 70 switch (deviceType) { 71 case SL_IODEVICE_LEDARRAY: 72 expectedObjectID = SL_OBJECTID_LEDDEVICE; 73 break; 74 case SL_IODEVICE_VIBRA: 75 expectedObjectID = SL_OBJECTID_VIBRADEVICE; 76 break; 77 case XA_IODEVICE_CAMERA: 78 expectedObjectID = XA_OBJECTID_CAMERADEVICE; 79 break; 80 case XA_IODEVICE_RADIO: 81 expectedObjectID = XA_OBJECTID_RADIODEVICE; 82 break; 83 // audio input and audio output cannot be specified via objects 84 case SL_IODEVICE_AUDIOINPUT: 85 // case SL_IODEVICE_AUDIOOUTPUT: // does not exist in 1.0.1, added in 1.1 86 default: 87 SL_LOGE("%s: deviceType=%u", name, deviceType); 88 pDataLocator->mIODevice.device = NULL; 89 expectedObjectID = 0; 90 result = SL_RESULT_PARAMETER_INVALID; 91 } 92 if (result == SL_RESULT_SUCCESS) { 93 // check that device has the correct object ID and is realized, 94 // and acquire a strong reference to it 95 result = AcquireStrongRef((IObject *) device, expectedObjectID); 96 if (SL_RESULT_SUCCESS != result) { 97 SL_LOGE("%s: locatorType=IODEVICE, but device field %p has wrong " \ 98 "object ID or is not realized", name, device); 99 pDataLocator->mIODevice.device = NULL; 100 } 101 } 102 } else { 103 SLuint32 deviceID = pDataLocator->mIODevice.deviceID; 104 switch (deviceType) { 105 case SL_IODEVICE_LEDARRAY: 106 if (SL_DEFAULTDEVICEID_LED != deviceID) { 107 SL_LOGE("%s: invalid LED deviceID=%u", name, deviceID); 108 result = SL_RESULT_PARAMETER_INVALID; 109 } 110 break; 111 case SL_IODEVICE_VIBRA: 112 if (SL_DEFAULTDEVICEID_VIBRA != deviceID) { 113 SL_LOGE("%s: invalid vibra deviceID=%u", name, deviceID); 114 result = SL_RESULT_PARAMETER_INVALID; 115 } 116 break; 117 case SL_IODEVICE_AUDIOINPUT: 118 if (SL_DEFAULTDEVICEID_AUDIOINPUT != deviceID) { 119 SL_LOGE("%s: invalid audio input deviceID=%u", name, deviceID); 120 result = SL_RESULT_PARAMETER_INVALID; 121 } 122 break; 123 case XA_IODEVICE_RADIO: 124 // no default device ID for radio; see Khronos bug XXXX 125 break; 126 case XA_IODEVICE_CAMERA: 127 if (XA_DEFAULTDEVICEID_CAMERA != deviceID) { 128 SL_LOGE("%s: invalid audio input deviceID=%u", name, deviceID); 129 result = XA_RESULT_PARAMETER_INVALID; 130 } 131 break; 132 // case SL_IODEVICE_AUDIOOUTPUT: 133 // does not exist in 1.0.1, added in 1.1 134 // break; 135 default: 136 SL_LOGE("%s: deviceType=%u is invalid", name, deviceType); 137 result = SL_RESULT_PARAMETER_INVALID; 138 } 139 } 140 } 141 break; 142 143 case SL_DATALOCATOR_MIDIBUFFERQUEUE: 144 pDataLocator->mMIDIBufferQueue = *(SLDataLocator_MIDIBufferQueue *)pLocator; 145 if (0 == pDataLocator->mMIDIBufferQueue.tpqn) { 146 pDataLocator->mMIDIBufferQueue.tpqn = 192; 147 } 148 // number of buffers must be specified, there is no default value, and can't be too big 149 if (!((1 <= pDataLocator->mMIDIBufferQueue.numBuffers) && 150 (pDataLocator->mMIDIBufferQueue.numBuffers <= 255))) { 151 SL_LOGE("%s: SLDataLocator_MIDIBufferQueue.numBuffers=%d", name, 152 pDataLocator->mMIDIBufferQueue.numBuffers); 153 result = SL_RESULT_PARAMETER_INVALID; 154 } 155 break; 156 157 case SL_DATALOCATOR_OUTPUTMIX: 158 pDataLocator->mOutputMix = *(SLDataLocator_OutputMix *)pLocator; 159 // check that output mix object has the correct object ID and is realized, 160 // and acquire a strong reference to it 161 result = AcquireStrongRef((IObject *) pDataLocator->mOutputMix.outputMix, 162 SL_OBJECTID_OUTPUTMIX); 163 if (SL_RESULT_SUCCESS != result) { 164 SL_LOGE("%s: locatorType=SL_DATALOCATOR_OUTPUTMIX, but outputMix field %p does " \ 165 "not refer to an SL_OBJECTID_OUTPUTMIX or the output mix is not realized", \ 166 name, pDataLocator->mOutputMix.outputMix); 167 pDataLocator->mOutputMix.outputMix = NULL; 168 } 169 break; 170 171 case XA_DATALOCATOR_NATIVEDISPLAY: 172 pDataLocator->mNativeDisplay = *(XADataLocator_NativeDisplay *)pLocator; 173 // hWindow is NDK C ANativeWindow * and hDisplay must be NULL 174 if (pDataLocator->mNativeDisplay.hWindow == NULL) { 175 SL_LOGE("%s: hWindow must be non-NULL ANativeWindow *", name); 176 result = SL_RESULT_PARAMETER_INVALID; 177 } 178 if (pDataLocator->mNativeDisplay.hDisplay != NULL) { 179 SL_LOGE("%s: hDisplay must be NULL, but is %p", name, 180 pDataLocator->mNativeDisplay.hDisplay); 181 result = SL_RESULT_PARAMETER_INVALID; 182 } 183 break; 184 185 case SL_DATALOCATOR_URI: 186 { 187 pDataLocator->mURI = *(SLDataLocator_URI *)pLocator; 188 if (NULL == pDataLocator->mURI.URI) { 189 SL_LOGE("%s: invalid URI=NULL", name); 190 result = SL_RESULT_PARAMETER_INVALID; 191 } else { 192 // NTH verify URI address for validity 193 size_t len = strlen((const char *) pDataLocator->mURI.URI); 194 SLchar *myURI = (SLchar *) malloc(len + 1); 195 if (NULL == myURI) { 196 result = SL_RESULT_MEMORY_FAILURE; 197 } else { 198 memcpy(myURI, pDataLocator->mURI.URI, len + 1); 199 // Verify that another thread didn't change the NUL-terminator after we used it 200 // to determine length of string to copy. It's OK if the string became shorter. 201 if ('\0' != myURI[len]) { 202 free(myURI); 203 myURI = NULL; 204 result = SL_RESULT_PARAMETER_INVALID; 205 } 206 } 207 pDataLocator->mURI.URI = myURI; 208 } 209 } 210 break; 211 212#ifdef ANDROID 213 case SL_DATALOCATOR_ANDROIDFD: 214 { 215 pDataLocator->mFD = *(SLDataLocator_AndroidFD *)pLocator; 216 SL_LOGV("%s: fd=%d offset=%lld length=%lld", name, pDataLocator->mFD.fd, 217 pDataLocator->mFD.offset, pDataLocator->mFD.length); 218 // NTH check against process fd limit 219 if (0 > pDataLocator->mFD.fd) { 220 SL_LOGE("%s: fd=%d\n", name, pDataLocator->mFD.fd); 221 result = SL_RESULT_PARAMETER_INVALID; 222 } 223 break; 224 } 225 case SL_DATALOCATOR_ANDROIDBUFFERQUEUE: 226 { 227 pDataLocator->mABQ = *(SLDataLocator_AndroidBufferQueue*)pLocator; 228 // number of buffers must be specified, there is no default value, and can't be too big 229 if (!((1 <= pDataLocator->mBufferQueue.numBuffers) && 230 (pDataLocator->mBufferQueue.numBuffers <= 255))) { 231 SL_LOGE("%s: numBuffers=%u", name, pDataLocator->mABQ.numBuffers); 232 result = SL_RESULT_PARAMETER_INVALID; 233 } 234 break; 235 } 236#endif 237 238 case SL_DATALOCATOR_NULL: // a NULL pointer is allowed, but not a pointer to NULL 239 default: 240 SL_LOGE("%s: locatorType=%u", name, locatorType); 241 result = SL_RESULT_PARAMETER_INVALID; 242 } 243 244 // Verify that another thread didn't change the locatorType field after we used it 245 // to determine sizeof struct to copy. 246 if ((SL_RESULT_SUCCESS == result) && (locatorType != pDataLocator->mLocatorType)) { 247 SL_LOGE("%s: locatorType changed from %u to %u", name, locatorType, 248 pDataLocator->mLocatorType); 249 result = SL_RESULT_PRECONDITIONS_VIOLATED; 250 } 251 252 } 253 254 // Verify that the data locator type is allowed in this context 255 if (SL_RESULT_SUCCESS == result) { 256 SLuint32 actualMask; 257 switch (locatorType) { 258 case SL_DATALOCATOR_NULL: 259 case SL_DATALOCATOR_URI: 260 case SL_DATALOCATOR_ADDRESS: 261 case SL_DATALOCATOR_IODEVICE: 262 case SL_DATALOCATOR_OUTPUTMIX: 263 case XA_DATALOCATOR_NATIVEDISPLAY: 264 case SL_DATALOCATOR_BUFFERQUEUE: 265 case SL_DATALOCATOR_MIDIBUFFERQUEUE: 266 actualMask = 1L << locatorType; 267 break; 268#ifdef ANDROID 269 case SL_DATALOCATOR_ANDROIDFD: 270 case SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE: 271 case SL_DATALOCATOR_ANDROIDBUFFERQUEUE: 272 actualMask = 0x100L << (locatorType - SL_DATALOCATOR_ANDROIDFD); 273 break; 274#endif 275 default: 276 assert(false); 277 actualMask = 0L; 278 break; 279 } 280 if (!(allowedDataLocatorMask & actualMask)) { 281 SL_LOGE("%s: data locator type 0x%x not allowed", name, locatorType); 282 result = SL_RESULT_CONTENT_UNSUPPORTED; 283 } 284 } 285 286 return result; 287} 288 289 290/** \brief Free the local deep copy of a data locator */ 291 292static void freeDataLocator(DataLocator *pDataLocator) 293{ 294 switch (pDataLocator->mLocatorType) { 295 case SL_DATALOCATOR_NULL: 296 case SL_DATALOCATOR_ADDRESS: 297 case SL_DATALOCATOR_BUFFERQUEUE: 298 case SL_DATALOCATOR_MIDIBUFFERQUEUE: 299 case XA_DATALOCATOR_NATIVEDISPLAY: 300 break; 301 case SL_DATALOCATOR_URI: 302 if (NULL != pDataLocator->mURI.URI) { 303 free(pDataLocator->mURI.URI); 304 pDataLocator->mURI.URI = NULL; 305 } 306 pDataLocator->mURI.URI = NULL; 307 break; 308 case SL_DATALOCATOR_IODEVICE: 309 if (NULL != pDataLocator->mIODevice.device) { 310 ReleaseStrongRef((IObject *) pDataLocator->mIODevice.device); 311 pDataLocator->mIODevice.device = NULL; 312 } 313 break; 314 case SL_DATALOCATOR_OUTPUTMIX: 315 if (NULL != pDataLocator->mOutputMix.outputMix) { 316 ReleaseStrongRef((IObject *) pDataLocator->mOutputMix.outputMix); 317 pDataLocator->mOutputMix.outputMix = NULL; 318 } 319 break; 320#ifdef ANDROID 321 case SL_DATALOCATOR_ANDROIDBUFFERQUEUE: 322 case SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE: 323 case SL_DATALOCATOR_ANDROIDFD: 324 break; 325#endif 326 default: 327 // an invalid data locator is caught earlier when making the copy 328 assert(false); 329 break; 330 } 331} 332 333 334/** \brief Check a data format and make local deep copy */ 335#define SL_ANDROID_SPEAKER_QUAD (SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT \ 336 | SL_SPEAKER_BACK_LEFT | SL_SPEAKER_BACK_RIGHT) 337 338#define SL_ANDROID_SPEAKER_5DOT1 (SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT \ 339 | SL_SPEAKER_FRONT_CENTER | SL_SPEAKER_LOW_FREQUENCY| SL_SPEAKER_BACK_LEFT \ 340 | SL_SPEAKER_BACK_RIGHT) 341 342#define SL_ANDROID_SPEAKER_7DOT1 (SL_ANDROID_SPEAKER_5DOT1 | SL_SPEAKER_SIDE_LEFT \ 343 |SL_SPEAKER_SIDE_RIGHT) 344 345static SLresult checkDataFormat(const char *name, void *pFormat, DataFormat *pDataFormat, 346 SLuint32 allowedDataFormatMask) 347{ 348 assert(NULL != name && NULL != pDataFormat); 349 SLresult result = SL_RESULT_SUCCESS; 350 351 SLuint32 formatType; 352 if (NULL == pFormat) { 353 pDataFormat->mFormatType = formatType = SL_DATAFORMAT_NULL; 354 } else { 355 formatType = *(SLuint32 *)pFormat; 356 switch (formatType) { 357 358 case SL_DATAFORMAT_PCM: 359 pDataFormat->mPCM = *(SLDataFormat_PCM *)pFormat; 360 do { 361 362 // check the channel count 363 switch (pDataFormat->mPCM.numChannels) { 364 case 1: // mono 365 case 2: // stereo 366 case 4: // QUAD 367 case 6: // 5.1 368 case 8: // 8.1 369 break; 370 case 0: // unknown 371 result = SL_RESULT_PARAMETER_INVALID; 372 break; 373 default: // multi-channel 374 result = SL_RESULT_CONTENT_UNSUPPORTED; 375 break; 376 } 377 if (SL_RESULT_SUCCESS != result) { 378 SL_LOGE("%s: numChannels=%u", name, (unsigned) pDataFormat->mPCM.numChannels); 379 break; 380 } 381 382 // check the sampling rate 383 switch (pDataFormat->mPCM.samplesPerSec) { 384 case SL_SAMPLINGRATE_8: 385 case SL_SAMPLINGRATE_11_025: 386 case SL_SAMPLINGRATE_12: 387 case SL_SAMPLINGRATE_16: 388 case SL_SAMPLINGRATE_22_05: 389 case SL_SAMPLINGRATE_24: 390 case SL_SAMPLINGRATE_32: 391 case SL_SAMPLINGRATE_44_1: 392 case SL_SAMPLINGRATE_48: 393 case SL_SAMPLINGRATE_64: 394 case SL_SAMPLINGRATE_88_2: 395 case SL_SAMPLINGRATE_96: 396 case SL_SAMPLINGRATE_192: 397 break; 398 case 0: 399 result = SL_RESULT_PARAMETER_INVALID; 400 break; 401 default: 402 result = SL_RESULT_CONTENT_UNSUPPORTED; 403 break; 404 } 405 if (SL_RESULT_SUCCESS != result) { 406 SL_LOGE("%s: samplesPerSec=%u", name, pDataFormat->mPCM.samplesPerSec); 407 break; 408 } 409 410 // check the sample bit depth 411 switch (pDataFormat->mPCM.bitsPerSample) { 412 case SL_PCMSAMPLEFORMAT_FIXED_8: 413 case SL_PCMSAMPLEFORMAT_FIXED_16: 414 case SL_PCMSAMPLEFORMAT_FIXED_24: 415 case SL_PCMSAMPLEFORMAT_FIXED_32: 416 break; 417 case SL_PCMSAMPLEFORMAT_FIXED_20: 418 case SL_PCMSAMPLEFORMAT_FIXED_28: 419 result = SL_RESULT_CONTENT_UNSUPPORTED; 420 break; 421 default: 422 result = SL_RESULT_PARAMETER_INVALID; 423 break; 424 } 425 if (SL_RESULT_SUCCESS != result) { 426 SL_LOGE("%s: bitsPerSample=%u", name, pDataFormat->mPCM.bitsPerSample); 427 break; 428 } 429 430 // check the container bit depth 431 if (pDataFormat->mPCM.containerSize < pDataFormat->mPCM.bitsPerSample) { 432 result = SL_RESULT_PARAMETER_INVALID; 433 } else if (pDataFormat->mPCM.containerSize != pDataFormat->mPCM.bitsPerSample) { 434 result = SL_RESULT_CONTENT_UNSUPPORTED; 435 } 436 if (SL_RESULT_SUCCESS != result) { 437 SL_LOGE("%s: containerSize=%u, bitsPerSample=%u", name, 438 (unsigned) pDataFormat->mPCM.containerSize, 439 (unsigned) pDataFormat->mPCM.bitsPerSample); 440 break; 441 } 442 443 // check the channel mask 444 switch (pDataFormat->mPCM.channelMask) { 445 case SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT: 446 if (2 != pDataFormat->mPCM.numChannels) { 447 result = SL_RESULT_PARAMETER_INVALID; 448 } 449 break; 450 case SL_SPEAKER_FRONT_LEFT: 451 case SL_SPEAKER_FRONT_RIGHT: 452 case SL_SPEAKER_FRONT_CENTER: 453 if (1 != pDataFormat->mPCM.numChannels) { 454 result = SL_RESULT_PARAMETER_INVALID; 455 } 456 break; 457 case SL_ANDROID_SPEAKER_QUAD: 458 if (4 != pDataFormat->mPCM.numChannels) { 459 result = SL_RESULT_PARAMETER_INVALID; 460 } 461 break; 462 case SL_ANDROID_SPEAKER_5DOT1: 463 if (6 != pDataFormat->mPCM.numChannels) { 464 result = SL_RESULT_PARAMETER_INVALID; 465 } 466 break; 467 case SL_ANDROID_SPEAKER_7DOT1: 468 if (8 != pDataFormat->mPCM.numChannels) { 469 result = SL_RESULT_PARAMETER_INVALID; 470 } 471 break; 472 case 0: 473 // The default of front left rather than center for mono may be non-intuitive, 474 // but the left channel is the first channel for stereo or multichannel content. 475 pDataFormat->mPCM.channelMask = pDataFormat->mPCM.numChannels == 2 ? 476 SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT : SL_SPEAKER_FRONT_LEFT; 477 break; 478 default: 479 result = SL_RESULT_PARAMETER_INVALID; 480 break; 481 } 482 if (SL_RESULT_SUCCESS != result) { 483 SL_LOGE("%s: channelMask=0x%x numChannels=%u", name, 484 pDataFormat->mPCM.channelMask, pDataFormat->mPCM.numChannels); 485 break; 486 } 487 488 // check the endianness / byte order 489 switch (pDataFormat->mPCM.endianness) { 490 case SL_BYTEORDER_LITTLEENDIAN: 491 case SL_BYTEORDER_BIGENDIAN: 492 break; 493 // native is proposed but not yet in spec 494 default: 495 result = SL_RESULT_PARAMETER_INVALID; 496 break; 497 } 498 if (SL_RESULT_SUCCESS != result) { 499 SL_LOGE("%s: endianness=%u", name, (unsigned) pDataFormat->mPCM.endianness); 500 break; 501 } 502 503 // here if all checks passed successfully 504 505 } while(0); 506 break; 507 508 case SL_DATAFORMAT_MIME: 509 pDataFormat->mMIME = *(SLDataFormat_MIME *)pFormat; 510 if (NULL != pDataFormat->mMIME.mimeType) { 511 // NTH check address for validity 512 size_t len = strlen((const char *) pDataFormat->mMIME.mimeType); 513 SLchar *myMIME = (SLchar *) malloc(len + 1); 514 if (NULL == myMIME) { 515 result = SL_RESULT_MEMORY_FAILURE; 516 } else { 517 memcpy(myMIME, pDataFormat->mMIME.mimeType, len + 1); 518 // make sure MIME string was not modified asynchronously 519 if ('\0' != myMIME[len]) { 520 free(myMIME); 521 myMIME = NULL; 522 result = SL_RESULT_PRECONDITIONS_VIOLATED; 523 } 524 } 525 pDataFormat->mMIME.mimeType = myMIME; 526 } 527 break; 528 529 case XA_DATAFORMAT_RAWIMAGE: 530 pDataFormat->mRawImage = *(XADataFormat_RawImage *)pFormat; 531 switch (pDataFormat->mRawImage.colorFormat) { 532 case XA_COLORFORMAT_MONOCHROME: 533 case XA_COLORFORMAT_8BITRGB332: 534 case XA_COLORFORMAT_12BITRGB444: 535 case XA_COLORFORMAT_16BITARGB4444: 536 case XA_COLORFORMAT_16BITARGB1555: 537 case XA_COLORFORMAT_16BITRGB565: 538 case XA_COLORFORMAT_16BITBGR565: 539 case XA_COLORFORMAT_18BITRGB666: 540 case XA_COLORFORMAT_18BITARGB1665: 541 case XA_COLORFORMAT_19BITARGB1666: 542 case XA_COLORFORMAT_24BITRGB888: 543 case XA_COLORFORMAT_24BITBGR888: 544 case XA_COLORFORMAT_24BITARGB1887: 545 case XA_COLORFORMAT_25BITARGB1888: 546 case XA_COLORFORMAT_32BITBGRA8888: 547 case XA_COLORFORMAT_32BITARGB8888: 548 case XA_COLORFORMAT_YUV411PLANAR: 549 case XA_COLORFORMAT_YUV420PLANAR: 550 case XA_COLORFORMAT_YUV420SEMIPLANAR: 551 case XA_COLORFORMAT_YUV422PLANAR: 552 case XA_COLORFORMAT_YUV422SEMIPLANAR: 553 case XA_COLORFORMAT_YCBYCR: 554 case XA_COLORFORMAT_YCRYCB: 555 case XA_COLORFORMAT_CBYCRY: 556 case XA_COLORFORMAT_CRYCBY: 557 case XA_COLORFORMAT_YUV444INTERLEAVED: 558 case XA_COLORFORMAT_RAWBAYER8BIT: 559 case XA_COLORFORMAT_RAWBAYER10BIT: 560 case XA_COLORFORMAT_RAWBAYER8BITCOMPRESSED: 561 case XA_COLORFORMAT_L2: 562 case XA_COLORFORMAT_L4: 563 case XA_COLORFORMAT_L8: 564 case XA_COLORFORMAT_L16: 565 case XA_COLORFORMAT_L24: 566 case XA_COLORFORMAT_L32: 567 case XA_COLORFORMAT_18BITBGR666: 568 case XA_COLORFORMAT_24BITARGB6666: 569 case XA_COLORFORMAT_24BITABGR6666: 570 break; 571 case XA_COLORFORMAT_UNUSED: 572 default: 573 result = XA_RESULT_PARAMETER_INVALID; 574 SL_LOGE("%s: unsupported color format %d", name, 575 pDataFormat->mRawImage.colorFormat); 576 break; 577 } 578 // no checks for height, width, or stride 579 break; 580 581 default: 582 result = SL_RESULT_PARAMETER_INVALID; 583 SL_LOGE("%s: formatType=%u", name, (unsigned) formatType); 584 break; 585 586 } 587 588 // make sure format type was not modified asynchronously 589 if ((SL_RESULT_SUCCESS == result) && (formatType != pDataFormat->mFormatType)) { 590 SL_LOGE("%s: formatType changed from %u to %u", name, formatType, 591 pDataFormat->mFormatType); 592 result = SL_RESULT_PRECONDITIONS_VIOLATED; 593 } 594 595 } 596 597 // Verify that the data format type is allowed in this context 598 if (SL_RESULT_SUCCESS == result) { 599 SLuint32 actualMask; 600 switch (formatType) { 601 case SL_DATAFORMAT_NULL: 602 case SL_DATAFORMAT_MIME: 603 case SL_DATAFORMAT_PCM: 604 case XA_DATAFORMAT_RAWIMAGE: 605 actualMask = 1L << formatType; 606 break; 607 default: 608 assert(false); 609 actualMask = 0L; 610 break; 611 } 612 if (!(allowedDataFormatMask & actualMask)) { 613 SL_LOGE("%s: data format %d not allowed", name, formatType); 614 result = SL_RESULT_CONTENT_UNSUPPORTED; 615 } 616 } 617 618 return result; 619} 620 621 622/** \brief Check interface ID compatibility with respect to a particular source 623 * and sink data locator format 624 */ 625 626SLresult checkSourceSinkVsInterfacesCompatibility(const DataLocatorFormat *pSrcDataLocatorFormat, 627 const DataLocatorFormat *pSinkDataLocatorFormat, 628 const ClassTable *clazz, unsigned requiredMask) { 629 int index; 630 switch (pSrcDataLocatorFormat->mLocator.mLocatorType) { 631 case SL_DATALOCATOR_URI: 632#ifdef ANDROID 633 case SL_DATALOCATOR_ANDROIDFD: 634#endif 635 // URIs and FD can be sources when "playing" to an OutputMix or a Buffer Queue for decode 636 // so we don't prevent the retrieval of the BufferQueue interfaces for those sources 637 switch (pSinkDataLocatorFormat->mLocator.mLocatorType) { 638 case SL_DATALOCATOR_BUFFERQUEUE: 639#ifdef ANDROID 640 case SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE: 641#endif 642 break; 643 default: 644 // can't require SLBufferQueueItf or its alias SLAndroidSimpleBufferQueueItf 645 // if the data sink is not a buffer queue 646 index = clazz->mMPH_to_index[MPH_BUFFERQUEUE]; 647#ifdef ANDROID 648 assert(index == clazz->mMPH_to_index[MPH_ANDROIDSIMPLEBUFFERQUEUE]); 649#endif 650 if (0 <= index) { 651 if (requiredMask & (1 << index)) { 652 SL_LOGE("can't require SL_IID_BUFFERQUEUE " 653#ifdef ANDROID 654 "or SL_IID_ANDROIDSIMPLEBUFFERQUEUE " 655#endif 656 "with a non-buffer queue data sink"); 657 return SL_RESULT_FEATURE_UNSUPPORTED; 658 } 659 } 660 break; 661 } 662 break; 663 664 case SL_DATALOCATOR_BUFFERQUEUE: 665#ifdef ANDROID 666 case SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE: 667#endif 668 // can't require SLSeekItf if data source is a buffer queue 669 index = clazz->mMPH_to_index[MPH_SEEK]; 670 if (0 <= index) { 671 if (requiredMask & (1 << index)) { 672 SL_LOGE("can't require SL_IID_SEEK with a buffer queue data source"); 673 return SL_RESULT_FEATURE_UNSUPPORTED; 674 } 675 } 676 // can't require SLMuteSoloItf if data source is a mono buffer queue 677 index = clazz->mMPH_to_index[MPH_MUTESOLO]; 678 if (0 <= index) { 679 if ((requiredMask & (1 << index)) && 680 (SL_DATAFORMAT_PCM == pSrcDataLocatorFormat->mFormat.mFormatType) && 681 (1 == pSrcDataLocatorFormat->mFormat.mPCM.numChannels)) { 682 SL_LOGE("can't require SL_IID_MUTESOLO with a mono buffer queue data source"); 683 return SL_RESULT_FEATURE_UNSUPPORTED; 684 } 685 } 686 break; 687 688#ifdef ANDROID 689 case SL_DATALOCATOR_ANDROIDBUFFERQUEUE: 690 // can't require SLSeekItf if data source is an Android buffer queue 691 index = clazz->mMPH_to_index[MPH_SEEK]; 692 if (0 <= index) { 693 if (requiredMask & (1 << index)) { 694 SL_LOGE("can't require SL_IID_SEEK with a SL_DATALOCATOR_ANDROIDBUFFERQUEUE "\ 695 "source"); 696 return SL_RESULT_FEATURE_UNSUPPORTED; 697 } 698 } 699 switch (pSinkDataLocatorFormat->mLocator.mLocatorType) { 700 // for use-case AAC decode from SLAndroidBufferQueueItf with AAC ADTS data 701 case SL_DATALOCATOR_BUFFERQUEUE: 702 case SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE: 703 break; 704 // for use-case audio playback from SLAndroidBufferQueueItf with MP2TS data 705 case SL_DATALOCATOR_OUTPUTMIX: 706 break; 707 default: 708 SL_LOGE("Invalid sink for SL_DATALOCATOR_ANDROIDBUFFERQUEUE source"); 709 return SL_RESULT_FEATURE_UNSUPPORTED; 710 break; 711 } 712 break; 713#endif 714 case SL_DATALOCATOR_ADDRESS: 715 case SL_DATALOCATOR_MIDIBUFFERQUEUE: 716 case XA_DATALOCATOR_NATIVEDISPLAY: 717 // any special checks here??? 718 default: 719 // can't require SLBufferQueueItf or its alias SLAndroidSimpleBufferQueueItf 720 // if the data source is not a buffer queue 721 index = clazz->mMPH_to_index[MPH_BUFFERQUEUE]; 722#ifdef ANDROID 723 assert(index == clazz->mMPH_to_index[MPH_ANDROIDSIMPLEBUFFERQUEUE]); 724#endif 725 if (0 <= index) { 726 if (requiredMask & (1 << index)) { 727 SL_LOGE("can't require SL_IID_BUFFERQUEUE " 728#ifdef ANDROID 729 "or SL_IID_ANDROIDSIMPLEBUFFERQUEUE " 730#endif 731 "with a non-buffer queue data source"); 732 return SL_RESULT_FEATURE_UNSUPPORTED; 733 } 734 } 735 break; 736 } 737 return SL_RESULT_SUCCESS; 738} 739 740 741/** \brief Free the local deep copy of a data format */ 742 743static void freeDataFormat(DataFormat *pDataFormat) 744{ 745 switch (pDataFormat->mFormatType) { 746 case SL_DATAFORMAT_MIME: 747 if (NULL != pDataFormat->mMIME.mimeType) { 748 free(pDataFormat->mMIME.mimeType); 749 pDataFormat->mMIME.mimeType = NULL; 750 } 751 break; 752 case SL_DATAFORMAT_PCM: 753 case XA_DATAFORMAT_RAWIMAGE: 754 case SL_DATAFORMAT_NULL: 755 break; 756 default: 757 // an invalid data format is caught earlier during the copy 758 assert(false); 759 break; 760 } 761} 762 763 764/** \brief Check a data source and make local deep copy */ 765 766SLresult checkDataSource(const char *name, const SLDataSource *pDataSrc, 767 DataLocatorFormat *pDataLocatorFormat, SLuint32 allowedDataLocatorMask, 768 SLuint32 allowedDataFormatMask) 769{ 770 assert(NULL != name && NULL != pDataLocatorFormat); 771 pDataLocatorFormat->u.mSource.pLocator = &pDataLocatorFormat->mLocator; 772 pDataLocatorFormat->u.mSource.pFormat = &pDataLocatorFormat->mFormat; 773 774 if (NULL == pDataSrc) { 775 pDataLocatorFormat->mLocator.mLocatorType = SL_DATALOCATOR_NULL; 776 pDataLocatorFormat->mFormat.mFormatType = SL_DATAFORMAT_NULL; 777 if ((allowedDataLocatorMask & DATALOCATOR_MASK_NULL) && 778 (allowedDataFormatMask & DATAFORMAT_MASK_NULL)) { 779 return SL_RESULT_SUCCESS; 780 } 781 SL_LOGE("%s: data source cannot be NULL", name); 782 return SL_RESULT_PARAMETER_INVALID; 783 } 784 SLDataSource myDataSrc = *pDataSrc; 785 SLresult result; 786 result = checkDataLocator(name, myDataSrc.pLocator, &pDataLocatorFormat->mLocator, 787 allowedDataLocatorMask); 788 if (SL_RESULT_SUCCESS != result) { 789 return result; 790 } 791 792 switch (pDataLocatorFormat->mLocator.mLocatorType) { 793 case SL_DATALOCATOR_URI: 794 allowedDataFormatMask &= DATAFORMAT_MASK_MIME; 795 break; 796 case SL_DATALOCATOR_ADDRESS: 797 case SL_DATALOCATOR_BUFFERQUEUE: 798 allowedDataFormatMask &= DATAFORMAT_MASK_PCM; 799 break; 800 // Per the spec, the pFormat field is ignored in some cases 801 case SL_DATALOCATOR_IODEVICE: 802 myDataSrc.pFormat = NULL; 803 // fall through 804 case SL_DATALOCATOR_NULL: 805 case SL_DATALOCATOR_MIDIBUFFERQUEUE: 806 allowedDataFormatMask &= DATAFORMAT_MASK_NULL; 807 break; 808 case SL_DATALOCATOR_OUTPUTMIX: 809 case XA_DATALOCATOR_NATIVEDISPLAY: 810 allowedDataFormatMask = DATAFORMAT_MASK_NONE; 811 break; 812#ifdef ANDROID 813 case SL_DATALOCATOR_ANDROIDFD: 814 allowedDataFormatMask &= DATAFORMAT_MASK_MIME; 815 break; 816 case SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE: 817 allowedDataFormatMask &= DATAFORMAT_MASK_PCM; 818 break; 819 case SL_DATALOCATOR_ANDROIDBUFFERQUEUE: 820 allowedDataFormatMask &= DATAFORMAT_MASK_MIME;; 821 break; 822#endif 823 default: 824 // invalid data locator type is caught earlier 825 assert(false); 826 allowedDataFormatMask = DATAFORMAT_MASK_NONE; 827 break; 828 } 829 830 result = checkDataFormat(name, myDataSrc.pFormat, &pDataLocatorFormat->mFormat, 831 allowedDataFormatMask); 832 if (SL_RESULT_SUCCESS != result) { 833 freeDataLocator(&pDataLocatorFormat->mLocator); 834 return result; 835 } 836 837 return SL_RESULT_SUCCESS; 838} 839 840 841/** \brief Check a data sink and make local deep copy */ 842 843SLresult checkDataSink(const char *name, const SLDataSink *pDataSink, 844 DataLocatorFormat *pDataLocatorFormat, SLuint32 allowedDataLocatorMask, 845 SLuint32 allowedDataFormatMask) 846{ 847 assert(NULL != name && NULL != pDataLocatorFormat); 848 pDataLocatorFormat->u.mSink.pLocator = &pDataLocatorFormat->mLocator; 849 pDataLocatorFormat->u.mSink.pFormat = &pDataLocatorFormat->mFormat; 850 851 if (NULL == pDataSink) { 852 pDataLocatorFormat->mLocator.mLocatorType = SL_DATALOCATOR_NULL; 853 pDataLocatorFormat->mFormat.mFormatType = SL_DATAFORMAT_NULL; 854 if ((allowedDataLocatorMask & DATALOCATOR_MASK_NULL) && 855 (allowedDataFormatMask & DATAFORMAT_MASK_NULL)) { 856 return SL_RESULT_SUCCESS; 857 } 858 SL_LOGE("%s: data sink cannot be NULL", name); 859 return SL_RESULT_PARAMETER_INVALID; 860 } 861 SLDataSink myDataSink = *pDataSink; 862 SLresult result; 863 result = checkDataLocator(name, myDataSink.pLocator, &pDataLocatorFormat->mLocator, 864 allowedDataLocatorMask); 865 if (SL_RESULT_SUCCESS != result) { 866 return result; 867 } 868 869 switch (pDataLocatorFormat->mLocator.mLocatorType) { 870 case SL_DATALOCATOR_URI: 871 allowedDataFormatMask &= DATAFORMAT_MASK_MIME; 872 break; 873 case SL_DATALOCATOR_ADDRESS: 874 case SL_DATALOCATOR_BUFFERQUEUE: 875 allowedDataFormatMask &= DATAFORMAT_MASK_PCM; 876 break; 877 // Per the spec, the pFormat field is ignored in some cases 878 case SL_DATALOCATOR_IODEVICE: 879 case SL_DATALOCATOR_OUTPUTMIX: 880 case XA_DATALOCATOR_NATIVEDISPLAY: 881 myDataSink.pFormat = NULL; 882 // fall through 883 case SL_DATALOCATOR_NULL: 884 case SL_DATALOCATOR_MIDIBUFFERQUEUE: 885 allowedDataFormatMask &= DATAFORMAT_MASK_NULL; 886 break; 887#ifdef ANDROID 888 case SL_DATALOCATOR_ANDROIDFD: 889 allowedDataFormatMask = DATAFORMAT_MASK_NONE; 890 break; 891 case SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE: 892 allowedDataFormatMask &= DATAFORMAT_MASK_PCM; 893 break; 894 case SL_DATALOCATOR_ANDROIDBUFFERQUEUE: 895 allowedDataFormatMask = DATAFORMAT_MASK_NONE; 896 break; 897#endif 898 default: 899 // invalid data locator type is caught earlier 900 assert(false); 901 allowedDataFormatMask = DATAFORMAT_MASK_NONE; 902 break; 903 } 904 905 result = checkDataFormat(name, myDataSink.pFormat, &pDataLocatorFormat->mFormat, 906 allowedDataFormatMask); 907 if (SL_RESULT_SUCCESS != result) { 908 freeDataLocator(&pDataLocatorFormat->mLocator); 909 return result; 910 } 911 912 return SL_RESULT_SUCCESS; 913} 914 915 916/** \brief Free the local deep copy of a data locator format */ 917 918void freeDataLocatorFormat(DataLocatorFormat *dlf) 919{ 920 assert(NULL != dlf); 921 freeDataLocator(&dlf->mLocator); 922 freeDataFormat(&dlf->mFormat); 923} 924