| /* |
| * Copyright (C) 2010 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* AndroidBufferQueue implementation */ |
| |
| //#define USE_LOG SLAndroidLogLevel_Verbose |
| |
| #include "sles_allinclusive.h" |
| // for AAC ADTS verification on enqueue: |
| #include "android/include/AacBqToPcmCbRenderer.h" |
| |
| /** |
| * 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). |
| */ |
| |
| static SLuint32 getAssociatedState(IAndroidBufferQueue *thiz) |
| { |
| SLuint32 state; |
| switch (InterfaceToObjectID(thiz)) { |
| case XA_OBJECTID_MEDIAPLAYER: |
| state = ((CMediaPlayer *) thiz->mThis)->mPlay.mState; |
| break; |
| case SL_OBJECTID_AUDIOPLAYER: |
| state = ((CAudioPlayer *) thiz->mThis)->mPlay.mState; |
| break; |
| default: |
| // unreachable, but just in case we will assume it is stopped |
| assert(SL_BOOLEAN_FALSE); |
| state = SL_PLAYSTATE_STOPPED; |
| break; |
| } |
| return state; |
| } |
| |
| |
| /** |
| * 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 SLresult setItems(SLuint32 dataLength, |
| const SLAndroidBufferItem *pItems, SLuint32 itemsLength, |
| SLuint16 bufferType, AdvancedBufferHeader *pBuff, bool *pEOS) |
| { |
| // reset item structure based on type |
| switch (bufferType) { |
| case kAndroidBufferTypeMpeg2Ts: |
| pBuff->mItems.mTsCmdData.mTsCmdCode = ANDROID_MP2TSEVENT_NONE; |
| pBuff->mItems.mTsCmdData.mPts = 0; |
| break; |
| case kAndroidBufferTypeAacadts: |
| pBuff->mItems.mAdtsCmdData.mAdtsCmdCode = ANDROID_ADTSEVENT_NONE; |
| break; |
| case kAndroidBufferTypeInvalid: |
| default: |
| // shouldn't happen, but just in case clear out the item structure |
| memset(&pBuff->mItems, 0, sizeof(AdvancedBufferItems)); |
| return SL_RESULT_INTERNAL_ERROR; |
| } |
| |
| // process all items in the array; if no items then we break out of loop immediately |
| while (itemsLength > 0) { |
| |
| // 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"); |
| 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"); |
| return SL_RESULT_PARAMETER_INVALID; |
| } |
| itemsLength -= itemDataSizeWithAlignmentPadding; |
| |
| // parse item data based on type |
| switch (bufferType) { |
| |
| case kAndroidBufferTypeMpeg2Ts: { |
| switch (pItems->itemKey) { |
| |
| case SL_ANDROID_ITEMKEY_EOS: |
| 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", pItems->itemSize); |
| return SL_RESULT_PARAMETER_INVALID; |
| } |
| break; |
| |
| case SL_ANDROID_ITEMKEY_DISCONTINUITY: |
| if (pItems->itemSize == 0) { |
| pBuff->mItems.mTsCmdData.mTsCmdCode |= ANDROID_MP2TSEVENT_DISCONTINUITY; |
| //SL_LOGD("Found DISCONTINUITYevent=%d", pBuff->mItems.mTsCmdData.mTsCmdCode); |
| } else if (pItems->itemSize == sizeof(SLAuint64)) { |
| pBuff->mItems.mTsCmdData.mTsCmdCode |= ANDROID_MP2TSEVENT_DISCON_NEWPTS; |
| 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", pItems->itemSize); |
| return SL_RESULT_PARAMETER_INVALID; |
| } |
| break; |
| |
| case SL_ANDROID_ITEMKEY_FORMAT_CHANGE: |
| // distinguish between a "full" format change and one where it says what changed |
| if (pItems->itemSize == 0) { |
| SL_LOGV("Received format change with no data == full format change"); |
| pBuff->mItems.mTsCmdData.mTsCmdCode |= ANDROID_MP2TSEVENT_FORMAT_CHANGE_FULL; |
| } else if (pItems->itemSize == sizeof(SLuint32)) { |
| XAuint32 formatData = *((XAuint32*)pItems->itemData); |
| // intentionally only supporting video change when reading which specific |
| // stream has changed, interpret other changes as full change |
| if (formatData == XA_ANDROID_FORMATCHANGE_ITEMDATA_VIDEO) { |
| pBuff->mItems.mTsCmdData.mTsCmdCode |= |
| ANDROID_MP2TSEVENT_FORMAT_CHANGE_VIDEO; |
| SL_LOGV("Received video format change"); |
| } else { |
| // note that we don't support specifying |
| // ANDROID_MP2TSEVENT_FORMAT_CHANGE_FULL by having all bits of |
| // the data mask set, we default to it with unsupported masks |
| SL_LOGE("Received format change with unsupported data, ignoring data"); |
| pBuff->mItems.mTsCmdData.mTsCmdCode |= |
| ANDROID_MP2TSEVENT_FORMAT_CHANGE_FULL; |
| } |
| } else { |
| SL_LOGE("Received format change with invalid data size, ignoring data"); |
| pBuff->mItems.mTsCmdData.mTsCmdCode |= ANDROID_MP2TSEVENT_FORMAT_CHANGE_FULL; |
| } |
| break; |
| |
| default: |
| // unknown item key |
| SL_LOGE("Unknown item key %u with size %u", pItems->itemKey, pItems->itemSize); |
| return SL_RESULT_PARAMETER_INVALID; |
| |
| }// switch (pItems->itemKey) |
| } break; |
| |
| case kAndroidBufferTypeAacadts: { |
| switch (pItems->itemKey) { |
| |
| 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", pItems->itemSize); |
| return SL_RESULT_PARAMETER_INVALID; |
| } |
| break; |
| |
| default: |
| // unknown item key |
| 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 SL_RESULT_INTERNAL_ERROR; |
| |
| }// switch (bufferType) |
| |
| // skip past this item, including data with alignment padding |
| pItems = (SLAndroidBufferItem *) ((char *) pItems + |
| sizeof(SLAndroidBufferItem) + itemDataSizeWithAlignmentPadding); |
| } |
| |
| // now check for invalid combinations of items |
| switch (bufferType) { |
| |
| case kAndroidBufferTypeMpeg2Ts: { |
| // supported Mpeg2Ts commands are mutually exclusive |
| switch (pBuff->mItems.mTsCmdData.mTsCmdCode) { |
| // single items are allowed |
| 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_FULL: |
| case ANDROID_MP2TSEVENT_FORMAT_CHANGE_VIDEO: |
| break; |
| // no combinations are allowed |
| default: |
| 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 SL_RESULT_INTERNAL_ERROR; |
| } |
| |
| return SL_RESULT_SUCCESS; |
| } |
| |
| |
| static SLresult IAndroidBufferQueue_RegisterCallback(SLAndroidBufferQueueItf self, |
| slAndroidBufferQueueCallback callback, void *pContext) |
| { |
| SL_ENTER_INTERFACE |
| |
| IAndroidBufferQueue *thiz = (IAndroidBufferQueue *) self; |
| |
| interface_lock_exclusive(thiz); |
| |
| // verify pre-condition that media object is in the SL_PLAYSTATE_STOPPED state |
| if (SL_PLAYSTATE_STOPPED == getAssociatedState(thiz)) { |
| thiz->mCallback = callback; |
| thiz->mContext = pContext; |
| result = SL_RESULT_SUCCESS; |
| |
| } else { |
| result = SL_RESULT_PRECONDITIONS_VIOLATED; |
| } |
| |
| interface_unlock_exclusive(thiz); |
| |
| SL_LEAVE_INTERFACE |
| } |
| |
| |
| static SLresult IAndroidBufferQueue_Clear(SLAndroidBufferQueueItf self) |
| { |
| SL_ENTER_INTERFACE |
| result = SL_RESULT_SUCCESS; |
| |
| IAndroidBufferQueue *thiz = (IAndroidBufferQueue *) self; |
| |
| interface_lock_exclusive(thiz); |
| |
| // reset the queue pointers |
| thiz->mFront = &thiz->mBufferArray[0]; |
| thiz->mRear = &thiz->mBufferArray[0]; |
| // reset the queue state |
| thiz->mState.count = 0; |
| thiz->mState.index = 0; |
| |
| // 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); |
| |
| SL_LEAVE_INTERFACE |
| } |
| |
| |
| static SLresult IAndroidBufferQueue_Enqueue(SLAndroidBufferQueueItf self, |
| void *pBufferContext, |
| void *pData, |
| SLuint32 dataLength, |
| const SLAndroidBufferItem *pItems, |
| SLuint32 itemsLength) |
| { |
| SL_ENTER_INTERFACE |
| SL_LOGD("IAndroidBufferQueue_Enqueue pData=%p dataLength=%d", pData, dataLength); |
| |
| if ((dataLength > 0) && (NULL == pData)) { |
| SL_LOGE("Enqueue failure: non-zero data length %u but NULL data pointer", dataLength); |
| result = SL_RESULT_PARAMETER_INVALID; |
| } else if ((itemsLength > 0) && (NULL == pItems)) { |
| SL_LOGE("Enqueue failure: non-zero items length %u but NULL items pointer", itemsLength); |
| result = SL_RESULT_PARAMETER_INVALID; |
| } else if ((0 == dataLength) && (0 == itemsLength)) { |
| // no data and no msg |
| SL_LOGE("Enqueue failure: trying to enqueue buffer with no data and no items."); |
| result = SL_RESULT_PARAMETER_INVALID; |
| // Note that a non-NULL data pointer with zero data length is allowed. |
| // We track that data pointer as it moves through the queue |
| // to assist the application in accounting for data buffers. |
| // A non-NULL items pointer with zero items length is also allowed, but has no value. |
| } else { |
| IAndroidBufferQueue *thiz = (IAndroidBufferQueue *) self; |
| |
| // buffer size check, can be done outside of lock because buffer type can't change |
| switch (thiz->mBufferType) { |
| case kAndroidBufferTypeMpeg2Ts: |
| 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 (packet size)", |
| MPEG2_TS_PACKET_SIZE); |
| result = SL_RESULT_PARAMETER_INVALID; |
| SL_LEAVE_INTERFACE |
| break; |
| case kAndroidBufferTypeAacadts: |
| // zero dataLength is permitted in case of EOS command only |
| if (dataLength > 0) { |
| result = android::AacBqToPcmCbRenderer::validateBufferStartEndOnFrameBoundaries( |
| pData, dataLength); |
| if (SL_RESULT_SUCCESS != result) { |
| SL_LOGE("Error enqueueing ADTS data: data must start and end on frame " |
| "boundaries"); |
| SL_LEAVE_INTERFACE |
| } |
| } |
| break; |
| case kAndroidBufferTypeInvalid: |
| default: |
| result = SL_RESULT_PARAMETER_INVALID; |
| SL_LEAVE_INTERFACE |
| } |
| |
| interface_lock_exclusive(thiz); |
| |
| AdvancedBufferHeader *oldRear = thiz->mRear, *newRear; |
| if ((newRear = oldRear + 1) == &thiz->mBufferArray[thiz->mNumBuffers + 1]) { |
| newRear = thiz->mBufferArray; |
| } |
| 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 { |
| // set oldRear->mItems based on items |
| 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) && |
| (1 == thiz->mState.count) && (SL_PLAYSTATE_PLAYING == getAssociatedState(thiz))) ? |
| ATTR_ABQ_ENQUEUE : ATTR_NONE); |
| } |
| |
| SL_LEAVE_INTERFACE |
| } |
| |
| |
| static SLresult IAndroidBufferQueue_GetState(SLAndroidBufferQueueItf self, |
| SLAndroidBufferQueueState *pState) |
| { |
| SL_ENTER_INTERFACE |
| |
| // Note that GetState while a Clear is pending is equivalent to GetState before the Clear |
| |
| if (NULL == pState) { |
| result = SL_RESULT_PARAMETER_INVALID; |
| } else { |
| IAndroidBufferQueue *thiz = (IAndroidBufferQueue *) self; |
| |
| interface_lock_shared(thiz); |
| |
| pState->count = thiz->mState.count; |
| pState->index = thiz->mState.index; |
| |
| interface_unlock_shared(thiz); |
| |
| result = SL_RESULT_SUCCESS; |
| } |
| |
| SL_LEAVE_INTERFACE |
| } |
| |
| |
| static SLresult IAndroidBufferQueue_SetCallbackEventsMask(SLAndroidBufferQueueItf self, |
| SLuint32 eventFlags) |
| { |
| SL_ENTER_INTERFACE |
| |
| IAndroidBufferQueue *thiz = (IAndroidBufferQueue *) self; |
| interface_lock_exclusive(thiz); |
| // FIXME only supporting SL_ANDROIDBUFFERQUEUEEVENT_PROCESSED in this implementation |
| if (!(~(SL_ANDROIDBUFFERQUEUEEVENT_PROCESSED /* | others TBD */ ) & eventFlags)) { |
| thiz->mCallbackEventsMask = eventFlags; |
| result = SL_RESULT_SUCCESS; |
| } else { |
| result = SL_RESULT_FEATURE_UNSUPPORTED; |
| } |
| interface_unlock_exclusive(thiz); |
| |
| SL_LEAVE_INTERFACE |
| } |
| |
| |
| static SLresult IAndroidBufferQueue_GetCallbackEventsMask(SLAndroidBufferQueueItf self, |
| SLuint32 *pEventFlags) |
| { |
| SL_ENTER_INTERFACE |
| |
| if (NULL == pEventFlags) { |
| result = SL_RESULT_PARAMETER_INVALID; |
| } else { |
| IAndroidBufferQueue *thiz = (IAndroidBufferQueue *) self; |
| interface_lock_shared(thiz); |
| SLuint32 callbackEventsMask = thiz->mCallbackEventsMask; |
| interface_unlock_shared(thiz); |
| *pEventFlags = callbackEventsMask; |
| result = SL_RESULT_SUCCESS; |
| } |
| |
| SL_LEAVE_INTERFACE |
| } |
| |
| |
| static const struct SLAndroidBufferQueueItf_ IAndroidBufferQueue_Itf = { |
| IAndroidBufferQueue_RegisterCallback, |
| IAndroidBufferQueue_Clear, |
| IAndroidBufferQueue_Enqueue, |
| IAndroidBufferQueue_GetState, |
| IAndroidBufferQueue_SetCallbackEventsMask, |
| IAndroidBufferQueue_GetCallbackEventsMask |
| }; |
| |
| |
| void IAndroidBufferQueue_init(void *self) |
| { |
| IAndroidBufferQueue *thiz = (IAndroidBufferQueue *) self; |
| thiz->mItf = &IAndroidBufferQueue_Itf; |
| |
| thiz->mState.count = 0; |
| thiz->mState.index = 0; |
| |
| thiz->mCallback = NULL; |
| thiz->mContext = NULL; |
| thiz->mCallbackEventsMask = SL_ANDROIDBUFFERQUEUEEVENT_PROCESSED; |
| |
| thiz->mBufferType = kAndroidBufferTypeInvalid; |
| thiz->mBufferArray = NULL; |
| thiz->mFront = NULL; |
| thiz->mRear = NULL; |
| thiz->mEOS = false; |
| } |
| |
| |
| void IAndroidBufferQueue_deinit(void *self) |
| { |
| IAndroidBufferQueue *thiz = (IAndroidBufferQueue *) self; |
| if (NULL != thiz->mBufferArray) { |
| free(thiz->mBufferArray); |
| 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 |
