#include "android/include/AacBqToPcmCbRenderer.h"
/**
- * Determine the state of the audio player or audio recorder associated with a buffer queue.
+ * Determine the state of the audio player or media player associated with a buffer queue.
* Note that PLAYSTATE and RECORDSTATE values are equivalent (where PLAYING == RECORDING).
*/
* parse and set the items associated with the given buffer, based on the buffer type,
* which determines the set of authorized items and format
*/
-static void setItems(const SLAndroidBufferItem *pItems, SLuint32 itemsLength,
- SLuint16 bufferType, AdvancedBufferHeader *pBuff)
+static SLresult setItems(SLuint32 dataLength,
+ const SLAndroidBufferItem *pItems, SLuint32 itemsLength,
+ SLuint16 bufferType, AdvancedBufferHeader *pBuff, bool *pEOS)
{
// reset item structure based on type
switch (bufferType) {
default:
// shouldn't happen, but just in case clear out the item structure
memset(&pBuff->mItems, 0, sizeof(AdvancedBufferItems));
- return;
+ return SL_RESULT_INTERNAL_ERROR;
}
// process all items in the array; if no items then we break out of loop immediately
// remaining length must be large enough for one full item without any associated data
if (itemsLength < sizeof(SLAndroidBufferItem)) {
- SL_LOGE("Partial item at end of array ignored");
- break;
+ SL_LOGE("Partial item at end of array");
+ return SL_RESULT_PARAMETER_INVALID;
}
itemsLength -= sizeof(SLAndroidBufferItem);
// remaining length must be large enough for data with current item and alignment padding
SLuint32 itemDataSizeWithAlignmentPadding = (pItems->itemSize + 3) & ~3;
if (itemsLength < itemDataSizeWithAlignmentPadding) {
- SL_LOGE("Partial item data at end of array ignored");
- break;
+ SL_LOGE("Partial item data at end of array");
+ return SL_RESULT_PARAMETER_INVALID;
}
itemsLength -= itemDataSizeWithAlignmentPadding;
pBuff->mItems.mTsCmdData.mTsCmdCode |= ANDROID_MP2TSEVENT_EOS;
//SL_LOGD("Found EOS event=%d", pBuff->mItems.mTsCmdData.mTsCmdCode);
if (pItems->itemSize != 0) {
- SL_LOGE("Invalid item parameter size %u for EOS, ignoring value",
- pItems->itemSize);
+ SL_LOGE("Invalid item parameter size %u for EOS", pItems->itemSize);
+ return SL_RESULT_PARAMETER_INVALID;
}
break;
pBuff->mItems.mTsCmdData.mPts = *((SLAuint64*)pItems->itemData);
//SL_LOGD("Found PTS=%lld", pBuff->mItems.mTsCmdData.mPts);
} else {
- SL_LOGE("Invalid item parameter size %u for MPEG-2 PTS, ignoring value",
- pItems->itemSize);
- pBuff->mItems.mTsCmdData.mTsCmdCode |= ANDROID_MP2TSEVENT_DISCONTINUITY;
+ SL_LOGE("Invalid item parameter size %u for MPEG-2 PTS", pItems->itemSize);
+ return SL_RESULT_PARAMETER_INVALID;
}
break;
case SL_ANDROID_ITEMKEY_FORMAT_CHANGE:
pBuff->mItems.mTsCmdData.mTsCmdCode |= ANDROID_MP2TSEVENT_FORMAT_CHANGE;
if (pItems->itemSize != 0) {
- SL_LOGE("Invalid item parameter size %u for format change, ignoring value",
- pItems->itemSize);
+ SL_LOGE("Invalid item parameter size %u for format change", pItems->itemSize);
+ return SL_RESULT_PARAMETER_INVALID;
}
break;
default:
// unknown item key
- SL_LOGE("Unknown item key %u with size %u ignored", pItems->itemKey,
- pItems->itemSize);
- break;
+ SL_LOGE("Unknown item key %u with size %u", pItems->itemKey, pItems->itemSize);
+ return SL_RESULT_PARAMETER_INVALID;
}// switch (pItems->itemKey)
} break;
case SL_ANDROID_ITEMKEY_EOS:
pBuff->mItems.mAdtsCmdData.mAdtsCmdCode |= ANDROID_ADTSEVENT_EOS;
if (pItems->itemSize != 0) {
- SL_LOGE("Invalid item parameter size %u for EOS, ignoring value",
- pItems->itemSize);
+ SL_LOGE("Invalid item parameter size %u for EOS", pItems->itemSize);
+ return SL_RESULT_PARAMETER_INVALID;
}
break;
default:
// unknown item key
- SL_LOGE("Unknown item key %u with size %u ignored", pItems->itemKey,
- pItems->itemSize);
- break;
+ SL_LOGE("Unknown item key %u with size %u", pItems->itemKey, pItems->itemSize);
+ return SL_RESULT_PARAMETER_INVALID;
}// switch (pItems->itemKey)
} break;
case kAndroidBufferTypeInvalid:
default:
// not reachable as we checked this earlier
- return;
+ return SL_RESULT_INTERNAL_ERROR;
}// switch (bufferType)
// supported Mpeg2Ts commands are mutually exclusive
switch (pBuff->mItems.mTsCmdData.mTsCmdCode) {
// single items are allowed
- case ANDROID_MP2TSEVENT_NONE:
case ANDROID_MP2TSEVENT_EOS:
+ if (dataLength > 0) {
+ SL_LOGE("Can't enqueue non-zero data with EOS");
+ return SL_RESULT_PRECONDITIONS_VIOLATED;
+ }
+ *pEOS = true;
+ break;
+ case ANDROID_MP2TSEVENT_NONE:
case ANDROID_MP2TSEVENT_DISCONTINUITY:
case ANDROID_MP2TSEVENT_DISCON_NEWPTS:
case ANDROID_MP2TSEVENT_FORMAT_CHANGE:
break;
// no combinations are allowed
default:
- SL_LOGE("Invalid combination of items; all ignored");
- pBuff->mItems.mTsCmdData.mTsCmdCode = ANDROID_MP2TSEVENT_NONE;
- break;
+ SL_LOGE("Invalid combination of items");
+ return SL_RESULT_PARAMETER_INVALID;
}
} break;
case kAndroidBufferTypeAacadts: {
// only one item supported, and thus no combination check needed
+ if (pBuff->mItems.mAdtsCmdData.mAdtsCmdCode == ANDROID_ADTSEVENT_EOS) {
+ if (dataLength > 0) {
+ SL_LOGE("Can't enqueue non-zero data with EOS");
+ return SL_RESULT_PRECONDITIONS_VIOLATED;
+ }
+ *pEOS = true;
+ }
} break;
case kAndroidBufferTypeInvalid:
default:
// not reachable as we checked this earlier
- return;
+ return SL_RESULT_INTERNAL_ERROR;
}
+ return SL_RESULT_SUCCESS;
}
// reset the queue state
thiz->mState.count = 0;
thiz->mState.index = 0;
- // reset the individual buffers
- for (XAuint16 i=0 ; i<(thiz->mNumBuffers + 1) ; i++) {
- thiz->mBufferArray[i].mDataBuffer = NULL;
- thiz->mBufferArray[i].mDataSize = 0;
- thiz->mBufferArray[i].mDataSizeConsumed = 0;
- thiz->mBufferArray[i].mBufferContext = NULL;
- thiz->mBufferArray[i].mBufferState = SL_ANDROIDBUFFERQUEUEEVENT_NONE;
- switch (thiz->mBufferType) {
- case kAndroidBufferTypeMpeg2Ts:
- thiz->mBufferArray[i].mItems.mTsCmdData.mTsCmdCode = ANDROID_MP2TSEVENT_NONE;
- thiz->mBufferArray[i].mItems.mTsCmdData.mPts = 0;
- break;
- case kAndroidBufferTypeAacadts:
- thiz->mBufferArray[i].mItems.mAdtsCmdData.mAdtsCmdCode = ANDROID_ADTSEVENT_NONE;
- break;
- default:
- result = SL_RESULT_CONTENT_UNSUPPORTED;
- }
- }
- if (SL_RESULT_SUCCESS == result) {
- // object-specific behavior for a clear
- switch (InterfaceToObjectID(thiz)) {
- case SL_OBJECTID_AUDIOPLAYER:
- result = SL_RESULT_SUCCESS;
- android_audioPlayer_androidBufferQueue_clear_l((CAudioPlayer*) thiz->mThis);
- break;
- case XA_OBJECTID_MEDIAPLAYER:
- result = SL_RESULT_SUCCESS;
- android_Player_androidBufferQueue_clear_l((CMediaPlayer*) thiz->mThis);
- break;
- default:
- result = SL_RESULT_PARAMETER_INVALID;
- }
+ // object-specific behavior for a clear
+ switch (InterfaceToObjectID(thiz)) {
+ case SL_OBJECTID_AUDIOPLAYER:
+ android_audioPlayer_androidBufferQueue_clear_l((CAudioPlayer*) thiz->mThis);
+ break;
+ case XA_OBJECTID_MEDIAPLAYER:
+ android_Player_androidBufferQueue_clear_l((CMediaPlayer*) thiz->mThis);
+ break;
+ default:
+ result = SL_RESULT_PARAMETER_INVALID;
}
interface_unlock_exclusive(thiz);
// buffer size check, can be done outside of lock because buffer type can't change
switch (thiz->mBufferType) {
case kAndroidBufferTypeMpeg2Ts:
- if (dataLength % MPEG2_TS_BLOCK_SIZE == 0) {
+ if (dataLength % MPEG2_TS_PACKET_SIZE == 0) {
+ // The downstream Stagefright MPEG-2 TS parser is sensitive to format errors,
+ // so do a quick sanity check beforehand on the first packet of the buffer.
+ // We don't check all the packets to avoid thrashing the data cache.
+ if ((dataLength > 0) && (*(SLuint8 *)pData != MPEG2_TS_PACKET_SYNC)) {
+ SL_LOGE("Error enqueueing MPEG-2 TS data: incorrect packet sync");
+ result = SL_RESULT_CONTENT_CORRUPTED;
+ SL_LEAVE_INTERFACE
+ }
break;
}
- SL_LOGE("Error enqueueing MPEG-2 TS data: size must be a multiple of %d (block size)",
- MPEG2_TS_BLOCK_SIZE);
+ SL_LOGE("Error enqueueing MPEG-2 TS data: size must be a multiple of %d (packet size)",
+ MPEG2_TS_PACKET_SIZE);
result = SL_RESULT_PARAMETER_INVALID;
SL_LEAVE_INTERFACE
break;
case kAndroidBufferTypeAacadts:
- // non-zero dataLength is permitted in case of EOS command only
+ // zero dataLength is permitted in case of EOS command only
if (dataLength > 0) {
result = android::AacBqToPcmCbRenderer::validateBufferStartEndOnFrameBoundaries(
pData, dataLength);
if ((newRear = oldRear + 1) == &thiz->mBufferArray[thiz->mNumBuffers + 1]) {
newRear = thiz->mBufferArray;
}
- if (newRear == thiz->mFront) {
+ if (thiz->mEOS) {
+ SL_LOGE("Can't enqueue after EOS");
+ result = SL_RESULT_PRECONDITIONS_VIOLATED;
+ } else if (newRear == thiz->mFront) {
result = SL_RESULT_BUFFER_INSUFFICIENT;
} else {
- oldRear->mDataBuffer = pData;
- oldRear->mDataSize = dataLength;
- oldRear->mDataSizeConsumed = 0;
- oldRear->mBufferContext = pBufferContext;
- oldRear->mBufferState = SL_ANDROIDBUFFERQUEUEEVENT_NONE;
- thiz->mRear = newRear;
- ++thiz->mState.count;
// set oldRear->mItems based on items
- setItems(pItems, itemsLength, thiz->mBufferType, oldRear);
- result = SL_RESULT_SUCCESS;
+ result = setItems(dataLength, pItems, itemsLength, thiz->mBufferType, oldRear,
+ &thiz->mEOS);
+ if (SL_RESULT_SUCCESS == result) {
+ oldRear->mDataBuffer = pData;
+ oldRear->mDataSize = dataLength;
+ oldRear->mDataSizeConsumed = 0;
+ oldRear->mBufferContext = pBufferContext;
+ //oldRear->mBufferState = TBD;
+ thiz->mRear = newRear;
+ ++thiz->mState.count;
+ }
}
// set enqueue attribute if state is PLAYING and the first buffer is enqueued
interface_unlock_exclusive_attributes(thiz, ((SL_RESULT_SUCCESS == result) &&
IAndroidBufferQueue *thiz = (IAndroidBufferQueue *) self;
interface_lock_exclusive(thiz);
// FIXME only supporting SL_ANDROIDBUFFERQUEUEEVENT_PROCESSED in this implementation
- if ((SL_ANDROIDBUFFERQUEUEEVENT_PROCESSED == eventFlags) ||
- (SL_ANDROIDBUFFERQUEUEEVENT_NONE == eventFlags)) {
+ if (!(~(SL_ANDROIDBUFFERQUEUEEVENT_PROCESSED /* | others TBD */ ) & eventFlags)) {
thiz->mCallbackEventsMask = eventFlags;
result = SL_RESULT_SUCCESS;
} else {
thiz->mBufferArray = NULL;
thiz->mFront = NULL;
thiz->mRear = NULL;
+ thiz->mEOS = false;
}
thiz->mBufferArray = NULL;
}
}
+
+
+#if 0
+// Dump the contents of an IAndroidBufferQueue to the log. This is for debugging only,
+// and is not a documented API. The associated object is locked throughout for atomicity,
+// but the log entries may be interspersed with unrelated logs.
+
+void IAndroidBufferQueue_log(IAndroidBufferQueue *thiz)
+{
+ interface_lock_shared(thiz);
+ SL_LOGI("IAndroidBufferQueue %p:", thiz);
+ SL_LOGI(" mState.count=%u mState.index=%u mCallback=%p mContext=%p",
+ thiz->mState.count, thiz->mState.index, thiz->mCallback, thiz->mContext);
+ const char *bufferTypeString;
+ switch (thiz->mBufferType) {
+ case kAndroidBufferTypeInvalid:
+ bufferTypeString = "kAndroidBufferTypeInvalid";
+ break;
+ case kAndroidBufferTypeMpeg2Ts:
+ bufferTypeString = "kAndroidBufferTypeMpeg2Ts";
+ break;
+ case kAndroidBufferTypeAacadts:
+ bufferTypeString = "kAndroidBufferTypeAacadts";
+ break;
+ default:
+ bufferTypeString = "unknown";
+ break;
+ }
+ SL_LOGI(" mCallbackEventsMask=0x%x, mBufferType=0x%x (%s), mEOS=%s",
+ thiz->mCallbackEventsMask,
+ thiz->mBufferType, bufferTypeString,
+ thiz->mEOS ? "true" : "false");
+ SL_LOGI(" mBufferArray=%p, mFront=%p (%u), mRear=%p (%u)",
+ thiz->mBufferArray,
+ thiz->mFront, thiz->mFront - thiz->mBufferArray,
+ thiz->mRear, thiz->mRear - thiz->mBufferArray);
+ SL_LOGI(" index mDataBuffer mDataSize mDataSizeConsumed mBufferContext mItems");
+ const AdvancedBufferHeader *hdr;
+ for (hdr = thiz->mFront; hdr != thiz->mRear; ) {
+ SLuint32 i = hdr - thiz->mBufferArray;
+ char itemString[32];
+ switch (thiz->mBufferType) {
+ case kAndroidBufferTypeMpeg2Ts:
+ switch (hdr->mItems.mTsCmdData.mTsCmdCode) {
+ case ANDROID_MP2TSEVENT_NONE:
+ strcpy(itemString, "NONE");
+ break;
+ case ANDROID_MP2TSEVENT_EOS:
+ strcpy(itemString, "EOS");
+ break;
+ case ANDROID_MP2TSEVENT_DISCONTINUITY:
+ strcpy(itemString, "DISCONTINUITY");
+ break;
+ case ANDROID_MP2TSEVENT_DISCON_NEWPTS:
+ snprintf(itemString, sizeof(itemString), "NEWPTS %llu",
+ hdr->mItems.mTsCmdData.mPts);
+ break;
+ case ANDROID_MP2TSEVENT_FORMAT_CHANGE:
+ strcpy(itemString, "FORMAT_CHANGE");
+ break;
+ default:
+ snprintf(itemString, sizeof(itemString), "0x%x", hdr->mItems.mTsCmdData.mTsCmdCode);
+ break;
+ }
+ break;
+ case kAndroidBufferTypeAacadts:
+ switch (hdr->mItems.mAdtsCmdData.mAdtsCmdCode) {
+ case ANDROID_ADTSEVENT_NONE:
+ strcpy(itemString, "NONE");
+ break;
+ case ANDROID_ADTSEVENT_EOS:
+ strcpy(itemString, "EOS");
+ break;
+ default:
+ snprintf(itemString, sizeof(itemString), "0x%x",
+ hdr->mItems.mAdtsCmdData.mAdtsCmdCode);
+ break;
+ }
+ break;
+ default:
+ strcpy(itemString, "");
+ break;
+ }
+ SL_LOGI(" %5u %11p %9u %17u %14p %s",
+ i, hdr->mDataBuffer, hdr->mDataSize, hdr->mDataSizeConsumed,
+ hdr->mBufferContext, itemString);
+ // mBufferState
+ if (++hdr == &thiz->mBufferArray[thiz->mNumBuffers + 1]) {
+ hdr = thiz->mBufferArray;
+ }
+ }
+ interface_unlock_shared(thiz);
+}
+
+#endif