static int bio_method_free(BIO *bio)
{
if (!bio) {
LOG_LOG(NULL, "BIO free called with null bio");
return 0;
}
LOG_LOG(ER_DTLS_CONNECTION(bio->ptr), "BIO free");
return 0;
}
static void openssl_poll(ErDtlsConnection *self)
{
int ret;
char buf[512];
int error;
log_state(self, "poll: before handshake");
ret = SSL_do_handshake(self->priv->ssl);
log_state(self, "poll: after handshake");
if (ret == 1) {
if (!self->priv->keys_exported) {
LOG_INFO(self, "handshake just completed successfully, exporting keys");
export_srtp_keys(self);
} else {
LOG_INFO(self, "handshake is completed");
}
return;
} else {
if (ret == 0) {
LOG_DEBUG(self, "do_handshake encountered EOF");
} else if (ret == -1) {
LOG_WARNING(self, "do_handshake encountered BIO error");
} else {
LOG_DEBUG(self, "do_handshake returned %d", ret);
}
}
error = SSL_get_error(self->priv->ssl, ret);
switch (error) {
case SSL_ERROR_NONE:
LOG_WARNING(self, "no error, handshake should be done");
break;
case SSL_ERROR_SSL:
LOG_LOG(self, "SSL error %d: %s", error, ERR_error_string(ERR_get_error(), buf));
break;
case SSL_ERROR_WANT_READ:
LOG_LOG(self, "SSL wants read");
break;
case SSL_ERROR_WANT_WRITE:
LOG_LOG(self, "SSL wants write");
break;
case SSL_ERROR_SYSCALL: {
LOG_LOG(self, "SSL syscall (error) : %lu", ERR_get_error());
break;
}
default:
LOG_WARNING(self, "Unknown SSL error: %d, ret: %d", error, ret);
}
}
AUDIO_FILTERRETURNTYPE WmaDec::AudioFilterFrame()
{
AUDIO_FILTERRETURNTYPE ret = AUDIO_FILTER_SUCCESS;
tWMAFileStatus WmaRet;
WmaRet = pWMADecodeFrame(pWmaDecConfig, pWmaDecParams, (WMAD_INT16 *)(pOutBufferHdr->pBuffer), pWmaDecParams->us32OutputBufSize);
LOG_LOG("WmaRet = %d\n", WmaRet);
if (WmaRet == cWMA_NoErr)
{
sWfx.Format.wBitsPerSample = pWmaDecParams->us32ValidBitsPerSample;
LOG_DEBUG("Wma channels: %d sample rate: %d bispersample: %d\n", sWfx.Format.nChannels, sWfx.Format.nSamplesPerSec, sWfx.Format.wBitsPerSample);
if (sWfx.Format.nChannels != PcmMode.nChannels
|| sWfx.Format.nSamplesPerSec != PcmMode.nSamplingRate
|| sWfx.Format.wBitsPerSample != PcmMode.nBitPerSample)
{
PcmMode.nChannels = sWfx.Format.nChannels;
PcmMode.nSamplingRate = sWfx.Format.nSamplesPerSec;
PcmMode.nBitPerSample = sWfx.Format.wBitsPerSample;
SendEvent(OMX_EventPortSettingsChanged, AUDIO_FILTER_OUTPUT_PORT, 0, NULL);
}
pOutBufferHdr->nOffset = 0;
pOutBufferHdr->nFilledLen = pWmaDecParams->us16NumSamples * \
sWfx.Format.nChannels * sWfx.Format.wBitsPerSample/8;
TS_PerFrame = (OMX_U64)pWmaDecParams->us16NumSamples*OMX_TICKS_PER_SECOND/sWfx.Format.nSamplesPerSec;
LOG_LOG("Decoder output sample: %d\t Sample Rate = %d\t TS per Frame = %lld\n", \
pWmaDecParams->us16NumSamples, sWfx.Format.nSamplesPerSec, TS_PerFrame);
TS_Manager.TS_SetIncrease(TS_PerFrame);
}
else if (WmaRet == cWMA_NoMoreFrames)
{
pOutBufferHdr->nOffset = 0;
pOutBufferHdr->nFilledLen = 0;
ret = AUDIO_FILTER_EOS;
}
else
{
ret = AUDIO_FILTER_FAILURE;
}
LOG_LOG("Decoder nTimeStamp = %lld\n", pOutBufferHdr->nTimeStamp);
return ret;
}
RINGBUFFER_ERRORTYPE RingBuffer::BufferGet(fsl_osal_u8 **ppBuffer, fsl_osal_u32 BufferLen, fsl_osal_u32 *pActualLen)
{
RINGBUFFER_ERRORTYPE ret = RINGBUFFER_SUCCESS;
fsl_osal_s32 DataLen = AudioDataLen();
if (DataLen < (fsl_osal_s32)BufferLen)
{
*pActualLen = DataLen;
}
else
{
*pActualLen = BufferLen;
}
if (ReservedLen < *pActualLen)
{
LOG_WARNING("Reserved buffer is too short.\n");
*pActualLen = ReservedLen;
}
if (End + *pActualLen > RingBufferPtr + nRingBufferLen)
{
fsl_osal_u32 FirstSegmentLen = nRingBufferLen - (End - RingBufferPtr);
fsl_osal_memcpy(Reserved, End, FirstSegmentLen);
fsl_osal_memcpy(Reserved + FirstSegmentLen, RingBufferPtr, *pActualLen - FirstSegmentLen);
*ppBuffer = Reserved;
}
else
{
*ppBuffer = End;
}
LOG_LOG("nRingBufferLen = %d\t DataLen = %d\n", nRingBufferLen, DataLen);
return ret;
}
RINGBUFFER_ERRORTYPE RingBuffer::BufferAddZeros(fsl_osal_u32 BufferLen, fsl_osal_u32 *pActualLen)
{
RINGBUFFER_ERRORTYPE ret = RINGBUFFER_SUCCESS;
fsl_osal_u32 DataLen = AudioDataLen();
fsl_osal_u32 FreeBufferLen = nRingBufferLen - DataLen - 1;
if (FreeBufferLen < BufferLen)
{
*pActualLen = FreeBufferLen;
}
else
{
*pActualLen = BufferLen;
}
if (Begin + *pActualLen > RingBufferPtr + nRingBufferLen)
{
fsl_osal_u32 FirstSegmentLen = nRingBufferLen - (Begin - RingBufferPtr);
fsl_osal_memset(Begin, 0, FirstSegmentLen);
fsl_osal_memset(RingBufferPtr, 0, *pActualLen - FirstSegmentLen);
Begin = RingBufferPtr + *pActualLen - FirstSegmentLen;
}
else
{
fsl_osal_memset(Begin, 0, *pActualLen);
Begin += *pActualLen;
}
LOG_LOG("nRingBufferLen = %d\t DataLen = %d\n", nRingBufferLen, DataLen);
return ret;
}
OMX_ERRORTYPE Ac3Dec::AudioFilterCheckFrameHeader()
{
OMX_ERRORTYPE ret = OMX_ErrorUndefined;
OMX_U8 *pBuffer;
OMX_U8 *pHeader;
OMX_U32 nActuralLen;
OMX_U32 nOffset=0;
OMX_BOOL bFounded = OMX_FALSE;
AUDIO_FRAME_INFO FrameInfo;
fsl_osal_memset(&FrameInfo, 0, sizeof(AUDIO_FRAME_INFO));
LOG_DEBUG("Ac3Dec AudioFilterCheckFrameHeader");
do{
AudioRingBuffer.BufferGet(&pBuffer, AC3_PUSH_MODE_LEN, &nActuralLen);
LOG_LOG("Get stream length: %d\n", nActuralLen);
if (nActuralLen < AC3_PUSH_MODE_LEN){
ret = OMX_ErrorNone;
break;
}
if(AFP_SUCCESS != Ac3CheckFrame(&FrameInfo, pBuffer, nActuralLen)){
break;
}
if(FrameInfo.bGotOneFrame){
bFounded = OMX_TRUE;
}
nOffset = FrameInfo.nConsumedOffset;
if(nOffset < nActuralLen)
LOG_LOG("buffer=%02x%02x%02x%02x",pBuffer[nOffset],pBuffer[nOffset+1],pBuffer[nOffset+2],pBuffer[nOffset+1]);
LOG_LOG("Ac3 decoder skip %d bytes.\n", nOffset);
AudioRingBuffer.BufferConsumered(nOffset);
TS_Manager.Consumered(nOffset);
if (bFounded == OMX_TRUE){
ret = OMX_ErrorNone;
break;
}
}while(0);
return ret;
}
bool FS_UpdateFiles(const FS_UpdateFileList& files) {
LOG_LOG("开始执行文件更新操作 ");
FS_UpdateFileList::const_iterator it, it_end;
// 检查原始文件正确性
LOG_LOG("正在检查已下载的更新文件包...");
for( it = files.begin(), it_end = files.end(); it != it_end; ++it ) {
if( !PathFileExists(it->source_file.c_str()) ) {
LOG_LOG("错误：临时文件["+it->source_file+"]不存在 ");
return false;
}
}
// 备份待更新的文件（更改文件名字）
LOG_LOG("正在备份要被更新的文件...");
for( it = files.begin(), it_end = files.end(); it != it_end; ++it ) {
if( PathFileExists(it->target_file.c_str()) ) {
// 备份目标文件
std::string backup_file = it->target_file + GS_UPDATE_BACKUP_POSTFIX;
if( ::PathFileExists(backup_file.c_str()) ) {
::remove(backup_file.c_str());
}
if( 0 != rename(it->target_file.c_str(), backup_file.c_str()) ) {
UpdateFiles_RollbackBackupFiles(files);
return false;
}
}
}
// 执行文件更新操作
LOG_LOG("正在执行文件更新...");
for( it = files.begin(), it_end = files.end(); it != it_end; ++it ) {
LOG_LOG("正在更新文件["+it->target_file+"]");
// 首先复制文件到目标路径
FS_ForceCreateDir(it->target_file.c_str());
if( 0 == ::MoveFile(it->source_file.c_str(), it->target_file.c_str()) ) {
LOG_LOG("错误：文件["+it->target_file+"]更新失败");
UpdateFiles_RollbackBackupFiles(files);
return false;
}
}
// 删除备份的文件
LOG_LOG("正在删除备份的文件...");
UpdateFiles_DeleteBackupFiles(files);
LOG_LOG("文件更新成功完成");
return true;
}
OMX_ERRORTYPE WbAmrEncWrapper::encodeFrame(
OMX_U8 *pOutBuffer,
OMX_U32 *pOutputDataSize,
OMX_U8 *pInputBuffer,
OMX_U32 *pInputDataSize)
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
wbamre_encode_frame(pAmrEncConfig, (WBAMR_S16*)pInputBuffer, (WBAMR_S16*)pOutBuffer);
LOG_LOG("Input size: %d\n", *pInputDataSize);
LOG_LOG("Output size: %d\n", *(pAmrEncConfig->wbamre_output_size));
*pOutputDataSize = *(pAmrEncConfig->wbamre_output_size);
*pInputDataSize = (WBAMR_L_FRAME * sizeof(WBAMR_S16));
return ret;
}
static int bio_method_new(BIO *bio)
{
LOG_LOG(NULL, "BIO: new");
bio->shutdown = 0;
bio->init = 1;
return 1;
}
fsl_osal_u32 RingBuffer::GetFrameLen()
{
TS_QUEUE TS_Item;
fsl_osal_u32 nFrameLen = 0;
BufferConsumered(0);
if (TS_Queue->Access(&TS_Item, 1) != QUEUE_SUCCESS)
{
LOG_WARNING("Can't get audio TS item.\n");
return AudioDataLen();
}
nFrameLen = TS_Item.RingBufferBegin - TotalConsumeLen;
LOG_LOG("TS_Item.RingBufferBegin: %lld\n", TS_Item.RingBufferBegin);
LOG_LOG("TotalConsumeLen: %lld\n", TotalConsumeLen);
LOG_LOG("Frame Len: %d\n", nFrameLen);
return nFrameLen;
}
OMX_ERRORTYPE UniaDecoder::AudioFilterReset()
{
OMX_S32 ret = ACODEC_SUCCESS;
if(IDecoder == NULL || uniaHandle == NULL)
return OMX_ErrorUndefined;
ret = IDecoder->ResetDecoder(uniaHandle);
LOG_LOG("UniaDec::AudioDecoderBaseReset ret=%d",ret);
return OMX_ErrorNone;
}
//add this function to check whether input data is raw data.
OMX_ERRORTYPE AacDec::AudioFilterCheckFrameHeader()
{
OMX_U8 *pBuffer;
OMX_U32 nActuralLen = 0;
OMX_U32 nVal = 0;
AUDIO_FRAME_INFO FrameInfo;
fsl_osal_memset(&FrameInfo, 0, sizeof(AUDIO_FRAME_INFO));
LOG_DEBUG("AacDec AudioFilterCheckFrameHeader");
if(bFrameCheck){
return OMX_ErrorNone;
}
do{
AudioRingBuffer.BufferGet(&pBuffer, AAC_PUSH_MODE_LEN, &nActuralLen);
LOG_LOG("Get stream length: %d\n", nActuralLen);
if (nActuralLen < AAC_PUSH_MODE_LEN && ePlayMode == DEC_FILE_MODE)
break;
nVal = *pBuffer<<24|*(pBuffer+1)<<16|*(pBuffer+2)<<8|*(pBuffer+3);
if(nVal == ADIF_FILE){
LOG_DEBUG("ADIF_FILE");
frameInput = OMX_FALSE;
bFrameCheck = OMX_TRUE;
AacType.eAACStreamFormat = OMX_AUDIO_AACStreamFormatADIF;
break;
}
if(AFP_SUCCESS != AacCheckFrame(&FrameInfo, pBuffer, nActuralLen)){
LOG_DEBUG("CHECK FAILED");
break;
}
if(FrameInfo.bGotOneFrame){
LOG_DEBUG("ADTS_FILE");
AacType.eAACStreamFormat = OMX_AUDIO_AACStreamFormatMP2ADTS;
frameInput = OMX_FALSE;
bFrameCheck = OMX_TRUE;
break;
}
AacType.eAACStreamFormat = OMX_AUDIO_AACStreamFormatRAW;
frameInput = OMX_TRUE;
bFrameCheck = OMX_TRUE;
LOG_DEBUG("FrameInfo.nHeaderCount");
}while(0);
return OMX_ErrorNone;
}
static void UpdateFiles_DeleteBackupFiles(const FS_UpdateFileList& files) {
FS_UpdateFileList::const_iterator it, it_end;
// 去掉文件后缀名
for( it = files.begin(), it_end = files.end(); it != it_end; ++it ) {
const std::string backup_file = it->target_file + GS_UPDATE_BACKUP_POSTFIX;
if( PathFileExists(backup_file.c_str()) ) {
LOG_LOG("正在删除临时文件["+backup_file+"]");
int ret = remove(backup_file.c_str());
assert( 0 == ret );// 即便这个时候失败，也应该继续循环。
}
}
}
static void UpdateFiles_RollbackBackupFiles(const FS_UpdateFileList& files) {
LOG_LOG("正在 Rollback 文件更新操作");
FS_UpdateFileList::const_iterator it, it_end;
// 去掉文件后缀名
for( it = files.begin(), it_end = files.end(); it != it_end; ++it ) {
// 原始文件不存在且目标文件存在，说明已经进行了更新操作，恢复源文件。
if( PathFileExists(it->target_file.c_str()) && !PathFileExists(it->source_file.c_str()) ) {
LOG_LOG("正在 Rollback 文件["+it->source_file+"]");
int ret = rename( it->target_file.c_str(), it->source_file.c_str() );
assert( 0 == ret );// 即便这个时候失败，也应该继续循环。
}
// 备份文件存在且目标文件不存在，需要恢复目标文件。
const std::string backup_file = it->target_file + GS_UPDATE_BACKUP_POSTFIX;
if( PathFileExists(backup_file.c_str()) && !PathFileExists(it->target_file.c_str()) ) {
LOG_LOG("正在 Rollback 文件["+it->target_file+"]");
int ret = rename( backup_file.c_str(), it->target_file.c_str() );
assert( 0 == ret );// 即便这个时候失败，也应该继续循环。
}
}
}
OMX_ERRORTYPE AudioFilter::ProcessOutputDataBuffer()
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
AudioRingBuffer.TS_Get(&pOutBufferHdr->nTimeStamp);
AUDIO_FILTERRETURNTYPE DecodeRet;
if (bDecoderInitFail == OMX_TRUE)
{
AudioRingBuffer.BufferReset();
bReceivedEOS = OMX_TRUE;
DecodeRet = AUDIO_FILTER_EOS;
}
else
{
DecodeRet = AudioFilterFrame();
if (DecodeRet == AUDIO_FILTER_FAILURE)
{
LOG_WARNING("Decode frame fail.\n");
fsl_osal_sleep(4000);
return OMX_ErrorNone;
}
}
if (DecodeRet == AUDIO_FILTER_EOS && bReceivedEOS == OMX_TRUE && AudioRingBuffer.AudioDataLen() == 0)
{
LOG_DEBUG("Audio Filter %s send EOS, len %d\n", role[0], pOutBufferHdr->nFilledLen);
pOutBufferHdr->nFlags |= OMX_BUFFERFLAG_EOS;
bDecoderEOS = OMX_TRUE;
SendEvent(OMX_EventBufferFlag, AUDIO_FILTER_OUTPUT_PORT, OMX_BUFFERFLAG_EOS, NULL);
}
if (bFirstFrame == OMX_TRUE)
{
bFirstFrame = OMX_FALSE;
pOutBufferHdr->nFlags |= OMX_BUFFERFLAG_STARTTIME;
}
pOutBufferHdr->nFlags |= OMX_BUFFERFLAG_ENDOFFRAME;
pOutBufferHdr->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
LOG_LOG("audio filter pOutBufferHdr->nTimeStamp = %lld, \n", pOutBufferHdr->nTimeStamp);
ports[AUDIO_FILTER_OUTPUT_PORT]->SendBuffer(pOutBufferHdr);
pOutBufferHdr = NULL;
return OMX_ErrorNone;
}
OMX_ERRORTYPE AudioSource::ProcessOutputBufferData()
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_U8 *pBuffer;
OMX_U32 nActuralLen;
OMX_U32 nSendDataLen = pOutBufferHdr->nAllocLen;
if (nSendDataLen > AudioRenderRingBuffer.AudioDataLen() - nFadeInFadeOutProcessLen)
nSendDataLen = AudioRenderRingBuffer.AudioDataLen() - nFadeInFadeOutProcessLen;
AudioRenderRingBuffer.BufferGet(&pBuffer, nSendDataLen, &nActuralLen);
fsl_osal_memcpy(pOutBufferHdr->pBuffer, pBuffer, nActuralLen);
pOutBufferHdr->nFilledLen = nActuralLen;
LOG_LOG("pOutBufferHdr->nAllocLen = %d\t pOutBufferHdr->nFilledLen = %d\n", pOutBufferHdr->nAllocLen, pOutBufferHdr->nFilledLen);
AudioRenderRingBuffer.BufferConsumered(nActuralLen);
return ret;
}
static long bio_method_ctrl(BIO *bio, int cmd, long arg1, void *arg2)
{
ErDtlsConnection *self = ER_DTLS_CONNECTION(bio->ptr);
ErDtlsConnectionPrivate *priv = self->priv;
switch (cmd) {
case BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT:
case BIO_CTRL_DGRAM_SET_RECV_TIMEOUT:
LOG_LOG(self, "BIO: Timeout set");
priv->timeout_set = TRUE;
g_cond_signal(&priv->condition);
return 1;
case BIO_CTRL_RESET:
priv->bio_buffer = NULL;
priv->bio_buffer_len = 0;
priv->bio_buffer_offset = 0;
LOG_LOG(self, "BIO: EOF reset");
return 1;
case BIO_CTRL_EOF: {
gint eof = !(priv->bio_buffer_len - priv->bio_buffer_offset);
LOG_LOG(self, "BIO: EOF query returned %d", eof);
return eof;
}
case BIO_CTRL_WPENDING:
LOG_LOG(self, "BIO: pending write");
return 1;
case BIO_CTRL_PENDING: {
gint pending = priv->bio_buffer_len - priv->bio_buffer_offset;
LOG_LOG(self, "BIO: %d bytes pending", pending);
return pending;
}
case BIO_CTRL_FLUSH:
LOG_LOG(self, "BIO: flushing");
return 1;
case BIO_CTRL_DGRAM_QUERY_MTU:
LOG_DEBUG(self, "BIO: MTU query, returning 0...");
return 0;
case BIO_CTRL_DGRAM_MTU_EXCEEDED:
LOG_WARNING(self, "BIO: MTU exceeded");
return 0;
default:
LOG_LOG(self, "BIO: unhandled ctrl, %d", cmd);
return 0;
}
}
static int bio_method_read(BIO *bio, char *out_buffer, int size)
{
ErDtlsConnection *self = ER_DTLS_CONNECTION(bio->ptr);
ErDtlsConnectionPrivate *priv = self->priv;
guint internal_size;
gint copy_size;
internal_size = priv->bio_buffer_len - priv->bio_buffer_offset;
if (!priv->bio_buffer) {
LOG_LOG(self, "BIO: EOF");
return 0;
}
if (!out_buffer || size <= 0) {
LOG_WARNING(self, "BIO: read got invalid arguments");
if (internal_size) {
BIO_set_retry_read(bio);
}
return internal_size;
}
if (size > internal_size) {
copy_size = internal_size;
} else {
copy_size = size;
}
LOG_DEBUG(self, "reading %d/%d bytes %d at offset %d, output buff size is %d",
copy_size, priv->bio_buffer_len, internal_size, priv->bio_buffer_offset, size);
memcpy(out_buffer, priv->bio_buffer + priv->bio_buffer_offset, copy_size);
priv->bio_buffer_offset += copy_size;
if (priv->bio_buffer_len == priv->bio_buffer_offset) {
priv->bio_buffer = NULL;
}
return copy_size;
}
RINGBUFFER_ERRORTYPE RingBuffer::TS_Add(fsl_osal_s64 ts)
{
RINGBUFFER_ERRORTYPE ret = RINGBUFFER_SUCCESS;
TS_QUEUE TS_Item;
if (TS_Queue->Size() > 0)
{
if (TS_Queue->Access(&TS_Item, TS_Queue->Size()) != QUEUE_SUCCESS)
{
LOG_ERROR("Can't get audio TS item.\n");
return RINGBUFFER_FAILURE;
}
if (TS_Item.ts == ts)
{
LOG_DEBUG("The same TS.\n");
return ret;
}
}
fsl_osal_s32 DataLen = AudioDataLen();
TS_Item.ts = ts;
/** Should add TS first after received buffer from input port */
TS_Item.RingBufferBegin = TotalConsumeLen + DataLen;
LOG_LOG("TS: %lld\t RingBufferBegin: %lld\n", TS_Item.ts, TS_Item.RingBufferBegin);
/* Update current time stamp at the first frame */
if (TotalConsumeLen == 0 && AudioDataLen() == 0 && ts >= 0)
{
CurrentTS = ts;
}
if (TS_Queue->Add(&TS_Item) != QUEUE_SUCCESS)
{
LOG_ERROR("Can't add TS item to audio ts queue. Queue size: %d, max queue size: %d \n", TS_Queue->Size(), TS_QUEUE_SIZE);
return RINGBUFFER_FAILURE;
}
return ret;
}
tWMAFileStatus WMA10FileCBGetNewPayload(OMX_PTR *state, OMX_U64 offset, OMX_U32 *pnum_bytes, \
OMX_U8 **ppData, OMX_PTR pAppContext, OMX_U32 *pbIsCompressedPayload)
{
tWMAFileStatus ret = cWMA_NoErr;
WmaDec *pWmaDec = (WmaDec *)pAppContext;
RingBuffer *pAudioRingBuffer = (RingBuffer *)&(pWmaDec->AudioRingBuffer);
AudioTSManager *pAudioTSManager = (AudioTSManager *)&(pWmaDec->TS_Manager);
*ppData = NULL;
LOG_LOG("Wma need bytes: %d RingBuffer audio data len: %d\n", *pnum_bytes, pAudioRingBuffer->AudioDataLen());
if(pAudioRingBuffer->AudioDataLen()<=0 && pWmaDec->bReceivedEOS == OMX_TRUE)
{
return cWMA_NoMoreFrames;
}
if((pAudioRingBuffer->AudioDataLen() - pAudioRingBuffer->nPrevOffset)<*pnum_bytes && pWmaDec->bReceivedEOS == OMX_FALSE)
{
*ppData = NULL;
*pnum_bytes=0;
return cWMA_NoMoreDataThisTime;
}
pAudioRingBuffer->BufferConsumered(pAudioRingBuffer->nPrevOffset);
pAudioTSManager->Consumered(pAudioRingBuffer->nPrevOffset);
OMX_U32 nActuralLen;
pAudioRingBuffer->BufferGet(ppData, *pnum_bytes, &nActuralLen);
LOG_DEBUG("Get stream length: %d\n", nActuralLen);
if(nActuralLen==0 && pWmaDec->bReceivedEOS == OMX_TRUE)
{
return cWMA_NoMoreFrames;
}
pAudioRingBuffer->nPrevOffset = nActuralLen;
return ret;
}
static int bio_method_write(BIO *bio, const char *data, int size)
{
ErDtlsConnection *self = ER_DTLS_CONNECTION(bio->ptr);
LOG_LOG(self, "BIO: writing %d", size);
if (self->priv->send_closure) {
GValue values[3] = { G_VALUE_INIT };
g_value_init(&values[0], ER_TYPE_DTLS_CONNECTION);
g_value_set_object(&values[0], self);
g_value_init(&values[1], G_TYPE_POINTER);
g_value_set_pointer(&values[1], (gpointer) data);
g_value_init(&values[2], G_TYPE_INT);
g_value_set_int(&values[2], size);
g_closure_invoke(self->priv->send_closure, NULL, 3, values, NULL);
}
return size;
}
static void log_state(ErDtlsConnection *self, const gchar *str)
{
ErDtlsConnectionPrivate *priv = self->priv;
guint states = 0;
states |= (!!SSL_is_init_finished(priv->ssl) << 0);
states |= (!!SSL_in_init(priv->ssl) << 4);
states |= (!!SSL_in_before(priv->ssl) << 8);
states |= (!!SSL_in_connect_init(priv->ssl) << 12);
states |= (!!SSL_in_accept_init(priv->ssl) << 16);
states |= (!!SSL_want_write(priv->ssl) << 20);
states |= (!!SSL_want_read(priv->ssl) << 24);
LOG_LOG(self, "%s: role=%s buf=(%d,%p:%d/%d) %x|%x %s",
str,
priv->is_client ? "client" : "server",
pqueue_size(priv->ssl->d1->sent_messages),
priv->bio_buffer,
priv->bio_buffer_offset,
priv->bio_buffer_len,
states, SSL_get_state(priv->ssl),
SSL_state_string_long(priv->ssl));
}
OMX_ERRORTYPE AudioSource::ProcessDataBuffer()
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
OMX_U32 nActuralLen;
if (bSendEOS == OMX_TRUE)
return OMX_ErrorNoMore;
if (AudioRenderRingBuffer.AudioDataLen() <= nFadeInFadeOutProcessLen) {
if (nDeviceReadLen == 0) {
LOG_DEBUG("Ringbuffer data len: %d\n", AudioRenderRingBuffer.AudioDataLen());
ret = GetOneFrameFromDevice();
if (ret == OMX_ErrorUndefined) {
OMX_U8 *pBuffer;
AudioRenderRingBuffer.BufferGet(&pBuffer, nFadeInFadeOutProcessLen, &nActuralLen);
AudioRenderFadeInFadeOut.SetMode(FADEOUT);
AudioRenderFadeInFadeOut.Process(pBuffer, nActuralLen);
AudioRenderRingBuffer.BufferConsumered(nActuralLen);
AudioRenderRingBuffer.BufferAdd(pBuffer, nFadeInFadeOutProcessLen, &nActuralLen);
nDeviceReadOffset = 0;
AudioRenderRingBuffer.BufferAddZeros(nDeviceReadLen, &nActuralLen);
LOG_LOG("Ringbuffer add len: %d\n", nActuralLen);
nDeviceReadLen -= nActuralLen;
nDeviceReadOffset += nActuralLen;
bAddZeros = OMX_TRUE;
if (nDeviceReadLen == 0)
AudioRenderFadeInFadeOut.SetMode(FADEIN);
} else {
if (ret != OMX_ErrorNone)
return ret;
bAddZeros = OMX_FALSE;
nDeviceReadOffset = 0;
AudioRenderFadeInFadeOut.Process(pDeviceReadBuffer, nDeviceReadLen);
AudioRenderRingBuffer.BufferAdd(pDeviceReadBuffer, nDeviceReadLen, &nActuralLen);
LOG_LOG("Ringbuffer add len: %d\n", nActuralLen);
nDeviceReadLen -= nActuralLen;
nDeviceReadOffset += nActuralLen;
}
} else {
if (bAddZeros == OMX_TRUE) {
AudioRenderRingBuffer.BufferAddZeros(nDeviceReadLen, &nActuralLen);
nDeviceReadLen -= nActuralLen;
nDeviceReadOffset += nActuralLen;
if (nDeviceReadLen == 0)
AudioRenderFadeInFadeOut.SetMode(FADEIN);
} else {
AudioRenderFadeInFadeOut.Process(pDeviceReadBuffer + nDeviceReadOffset, nDeviceReadLen);
AudioRenderRingBuffer.BufferAdd(pDeviceReadBuffer + nDeviceReadOffset, nDeviceReadLen, &nActuralLen);
nDeviceReadLen -= nActuralLen;
nDeviceReadOffset += nActuralLen;
}
}
}
LOG_LOG("Ringbuffer data len: %d\n", AudioRenderRingBuffer.AudioDataLen());
while(AudioRenderRingBuffer.AudioDataLen() > nFadeInFadeOutProcessLen) {
if (ports[OUTPUT_PORT]->BufferNum() == 0 && pOutBufferHdr == NULL ) {
fsl_osal_sleep(5000);
continue;
}
if (ports[OUTPUT_PORT]->BufferNum() > 0 && pOutBufferHdr == NULL) {
ports[OUTPUT_PORT]->GetBuffer(&pOutBufferHdr);
}
ret = ProcessOutputBufferData();
if (ret != OMX_ErrorNone)
return ret;
ret = ProcessOutputBufferFlag();
if (ret != OMX_ErrorNone)
return ret;
ret = SendOutputBuffer();
if (ret != OMX_ErrorNone)
return ret;
}
return OMX_ErrorNone;
}
RINGBUFFER_ERRORTYPE RingBuffer::BufferConsumered(fsl_osal_u32 ConsumeredLen)
{
RINGBUFFER_ERRORTYPE ret = RINGBUFFER_SUCCESS;
fsl_osal_s32 DataLen = AudioDataLen();
if (DataLen < (fsl_osal_s32)ConsumeredLen)
{
LOG_ERROR("Ring buffer consumer point set error.\n");
return RINGBUFFER_FAILURE;
}
if (End + ConsumeredLen > RingBufferPtr + nRingBufferLen)
{
End += ConsumeredLen - nRingBufferLen;
}
else
{
End += ConsumeredLen;
}
TotalConsumeLen += ConsumeredLen;
if (TS_Queue->Size() < 1)
{
return ret;
}
/** Adjust current TS */
TS_QUEUE TS_Item;
while (1)
{
if (TS_Queue->Access(&TS_Item, 1) != QUEUE_SUCCESS)
{
LOG_ERROR("Can't get audio TS item.\n");
return RINGBUFFER_FAILURE;
}
if (TotalConsumeLen >= TS_Item.RingBufferBegin)
{
if(TS_Item.ts >= 0 && RingBufferBeginPre != TS_Item.RingBufferBegin)
{
RingBufferBeginPre = TS_Item.RingBufferBegin;
CurrentTS = TS_Item.ts;
bHaveTS = E_FSL_OSAL_TRUE;
LOG_DEBUG_INS("Reset CurrentTS = %lld\n", CurrentTS);
}
if (TS_Queue->Size() > 1)
{
if (TS_Queue->Get(&TS_Item) != QUEUE_SUCCESS)
{
LOG_ERROR("Can't get audio TS item.\n");
return RINGBUFFER_FAILURE;
}
LOG_LOG("Remove TS: %lld\t RingBufferBegin: %lld\n", TS_Item.ts, TS_Item.RingBufferBegin);
}
else
{
break;
}
}
else
{
break;
}
}
LOG_LOG("nRingBufferLen = %d\t DataLen = %d\n", nRingBufferLen, DataLen);
return ret;
}
AUDIO_FILTERRETURNTYPE UniaDecoder::AudioFilterFrame()
{
AUDIO_FILTERRETURNTYPE ret = AUDIO_FILTER_SUCCESS;
OMX_S32 decoderRet = ACODEC_SUCCESS;
OMX_U32 nActuralLen = 0;
//OMX_U32 InputOffsetBegin = 0;
OMX_U32 consumeLen = 0;
OMX_U32 InputLen = 0;;
OMX_U32 InputOffset = 0;
OMX_U8* pBuffer = NULL;
AudioRingBuffer.BufferGet(&pBuffer, nPushModeInputLen, &InputLen);
if(frameInput && InputLen != 0){
OMX_U32 nFrameLen;
nFrameLen = TS_Manager.GetFrameLen();
if (nFrameLen == 0)
nFrameLen = nActuralLen;
AudioRingBuffer.BufferGet(&pBuffer, nFrameLen, &InputLen);
}
//InputOffsetBegin = InputOffset;
if(pBuffer && InputLen > 0){
decoderRet = IDecoder->DecodeFrame(uniaHandle,pBuffer,InputLen,
&InputOffset,&pOutBufferHdr->pBuffer,&nActuralLen);
if(!frameInput){
AudioRingBuffer.BufferConsumered(InputOffset);
}
inputFrameCount += InputOffset;
}else{
decoderRet = IDecoder->DecodeFrame(uniaHandle,NULL,0,&InputOffset,&pOutBufferHdr->pBuffer,&nActuralLen);
}
LOG_LOG("decoderRet=%d,InputLen=%d,InputOffset=%d,nActuralLen=%d",decoderRet,InputLen,InputOffset,nActuralLen);
if(decoderRet == ACODEC_SUCCESS || decoderRet == ACODEC_CAPIBILITY_CHANGE){
if(decoderRet & ACODEC_CAPIBILITY_CHANGE && OMX_ErrorNone == ResetParameterWhenOutputChange()){
if(nActuralLen != 0){
TS_PerFrame = (OMX_S64)nActuralLen*8*OMX_TICKS_PER_SECOND/PcmMode.nChannels \
/PcmMode.nSamplingRate/PcmMode.nBitPerSample;
}
LOG_DEBUG("send output port changed event");
SendEvent(OMX_EventPortSettingsChanged, AUDIO_FILTER_OUTPUT_PORT, 0, NULL);
}
pOutBufferHdr->nOffset = 0;
pOutBufferHdr->nFilledLen = nActuralLen;
TS_PerFrame = (OMX_S64)pOutBufferHdr->nFilledLen*8*OMX_TICKS_PER_SECOND/PcmMode.nChannels \
/PcmMode.nSamplingRate/PcmMode.nBitPerSample;
IDecoder->GetParameter(uniaHandle,UNIA_CONSUMED_LENGTH,(UniACodecParameter*)&consumeLen);
TS_Manager.Consumered(consumeLen);
LOG_LOG("AudioTime.TS_Increase TS_PerFrame=%lld,consumeLen=%d",TS_PerFrame,consumeLen);
TS_Manager.TS_SetIncrease(TS_PerFrame);
consumeFrameCount += consumeLen;
if(frameInput){
//more than one frames could be in a frame buffer, so consume one frame's length.
AudioRingBuffer.BufferConsumered(consumeLen);
}
if(nActuralLen == 0){
ret = AUDIO_FILTER_NEEDMORE;
}
LOG_LOG("Decoder outputLength=%d,pOutBufferHdr->nTimeStamp=%lld",\
pOutBufferHdr->nFilledLen,pOutBufferHdr->nTimeStamp);
LOG_LOG("OUTPUT = %x%x%x%x",pOutBufferHdr->pBuffer[0],pOutBufferHdr->pBuffer[1],pOutBufferHdr->pBuffer[2],pOutBufferHdr->pBuffer[3]);
#if 0
FILE * pfile;
pfile = fopen("/data/data/pcm","ab");
if(pfile){
fwrite(pOutBufferHdr->pBuffer,1,pOutBufferHdr->nFilledLen,pfile);
fclose(pfile);
}
#endif
if(nActuralLen != 0){
profileErrorCount = 0;
}
}else if(decoderRet == ACODEC_END_OF_STREAM){
pOutBufferHdr->nOffset = 0;
pOutBufferHdr->nFilledLen = 0;
LOG_DEBUG("ACODEC_END_OF_STREAM");
ret = AUDIO_FILTER_EOS;
}else if(decoderRet == ACODEC_NOT_ENOUGH_DATA){
ret = AUDIO_FILTER_NEEDMORE;
}else if((decoderRet == ACODEC_ERROR_STREAM || decoderRet == ACODEC_ERR_UNKNOWN) && pBuffer){
IDecoder->GetParameter(uniaHandle,UNIA_CONSUMED_LENGTH,(UniACodecParameter*)&consumeLen);
IDecoder->ResetDecoder(uniaHandle);
if(frameInput){
AudioRingBuffer.BufferConsumered(InputOffset);
}
TS_Manager.Consumered(InputOffset);
consumeFrameCount += InputOffset;
LOG_DEBUG("ERROR CONSUME LEN=%d,getlen=%d",consumeLen,InputOffset);
ret = AUDIO_FILTER_FAILURE;
errorCount ++;
LOG_DEBUG("ACODEC_ERROR_STREAM no more data");
}else if((decoderRet == ACODEC_ERROR_STREAM || decoderRet == ACODEC_ERR_UNKNOWN) && !pBuffer){
pOutBufferHdr->nOffset = 0;
pOutBufferHdr->nFilledLen = 0;
LOG_DEBUG("SET TO EOS");
ret = AUDIO_FILTER_EOS;
}else if(decoderRet == ACODEC_PROFILE_NOT_SUPPORT){
pOutBufferHdr->nOffset = 0;
pOutBufferHdr->nFilledLen = 0;
LOG_DEBUG("ACODEC_PROFILE_NOT_SUPPORT");
ret = AUDIO_FILTER_EOS;
profileErrorCount++;
}else if(decoderRet == ACODEC_INIT_ERR){
pOutBufferHdr->nOffset = 0;
pOutBufferHdr->nFilledLen = 0;
LOG_DEBUG("ACODEC RESULT ACODEC_INIT_ERR!");
ret = AUDIO_FILTER_FATAL_ERROR;
}else{
pOutBufferHdr->nOffset = 0;
pOutBufferHdr->nFilledLen = 0;
LOG_LOG("error decoderRet=%d",decoderRet);
ret = AUDIO_FILTER_FAILURE;
errorCount ++;
}
//for test usage
if(errorCount > 500){
LOG_DEBUG("Unia Decoder error count > 500 ***!!!");
errorCount = 0;
}
//check if count of profile error reaches the limited.
if(profileErrorCount > MAX_PROFILE_ERROR_COUNT){
ret = AUDIO_FILTER_FATAL_ERROR;
profileErrorCount = 0;
LOG_DEBUG("return AUDIO_FILTER_FATAL_ERROR instead of ACODEC_PROFILE_NOT_SUPPORT");
}
return ret;
}
OMX_ERRORTYPE AudioFilter::ProcessDataBuffer()
{
OMX_ERRORTYPE ret = OMX_ErrorNone;
LOG_LOG("Audio filter In: %d, Out: %d\n", ports[AUDIO_FILTER_INPUT_PORT]->BufferNum(), ports[AUDIO_FILTER_OUTPUT_PORT]->BufferNum());
if(((ports[AUDIO_FILTER_INPUT_PORT]->BufferNum() == 0 && pInBufferHdr == NULL )
|| pInBufferHdr != NULL) /**< Ring buffer full */
&& (ports[AUDIO_FILTER_OUTPUT_PORT]->BufferNum() == 0 && pOutBufferHdr == NULL))
return OMX_ErrorNoMore;
if(pOutBufferHdr == NULL && ports[AUDIO_FILTER_OUTPUT_PORT]->BufferNum() > 0)
{
ports[AUDIO_FILTER_OUTPUT_PORT]->GetBuffer(&pOutBufferHdr);
pOutBufferHdr->nFlags = 0;
}
if(pInBufferHdr == NULL && ports[AUDIO_FILTER_INPUT_PORT]->BufferNum() > 0)
{
ports[AUDIO_FILTER_INPUT_PORT]->GetBuffer(&pInBufferHdr);
if(pInBufferHdr != NULL)
{
ret = ProcessInputBufferFlag();
if (ret != OMX_ErrorNone)
{
LOG_ERROR("Process input buffer flag fail.\n");
return ret;
}
}
}
if(pInBufferHdr != NULL)
{
ret = ProcessInputDataBuffer();
if (ret != OMX_ErrorNone)
{
LOG_ERROR("Process input data buffer fail.\n");
return ret;
}
}
if (bInstanceReset == OMX_TRUE)
{
bInstanceReset = OMX_FALSE;
ret = AudioFilterInstanceReset();
if (ret != OMX_ErrorNone)
{
LOG_ERROR("Audio filter instance reset fail.\n");
bDecoderEOS = OMX_TRUE;
SendEvent(OMX_EventError, ret, 0, NULL);
return ret;
}
}
if (bFirstFrame == OMX_TRUE)
{
ret = AudioFilterCheckFrameHeader();
if (ret != OMX_ErrorNone)
{
LOG_ERROR("AudioFilterCheckFrameHeader fail.\n");
}
}
LOG_LOG("Audio Filter Ringbuffer data len: %d\n", AudioRingBuffer.AudioDataLen());
if ((AudioRingBuffer.AudioDataLen() < nPushModeInputLen && bReceivedEOS == OMX_FALSE)
|| bDecoderEOS == OMX_TRUE)
{
LOG_DEBUG("Input buffer is not enough for filter.\n");
if(ports[AUDIO_FILTER_INPUT_PORT]->BufferNum() > 0)
return OMX_ErrorNone;
else
return OMX_ErrorNoMore;
}
if (bCodecInit == OMX_FALSE)
{
bCodecInit = OMX_TRUE;
ret = AudioFilterCodecInit();
if (ret != OMX_ErrorNone)
{
LOG_ERROR("Audio decoder codec init fail.\n");
bDecoderInitFail = OMX_TRUE;
}
}
if(pOutBufferHdr != NULL)
{
ret = ProcessOutputDataBuffer();
if (ret != OMX_ErrorNone)
LOG_ERROR("Process Output data buffer fail.\n");
}
return OMX_ErrorNone;
}
int evt_run(){
LOG_LOG("event_dispatch begin");
aeMain(loop);
LOG_LOG("event_dispatch end");
return 1;
}
