PVMFStatus PVFMVideoMIO::connect(PvmiMIOSession& aSession, PvmiMIOObserver* aObserver) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVFMVideoMIO::connect() called")); // Currently supports only one session OSCL_UNUSED_ARG(aSession); if (iObserver) { return PVMFFailure; } iObserver = aObserver; return PVMFSuccess; }
int32 AvcDecoder_OMX::ActivateSPS_OMX(void* aUserData, uint aSizeInMbs, uint aNumBuffers) { OSCL_UNUSED_ARG(aUserData); PVAVCDecGetSeqInfo(&(AvcHandle), &(SeqInfo)); if (pDpbBuffer) { oscl_free(pDpbBuffer); pDpbBuffer = NULL; } FrameSize = (aSizeInMbs << 7) * 3; pDpbBuffer = (uint8*) oscl_malloc(aNumBuffers * (FrameSize)); return 1; }
PVMFStatus PvmfJBJitterBufferDurationTimer::Stop() { PVMF_JBNODE_LOGINFO((0, "PvmfJBJitterBufferDurationTimer::Stop")); Cancel(); if (iStarted) { bool result = iRunClock.Stop(); OSCL_UNUSED_ARG(result); OSCL_ASSERT(result); } iStarted = false; iJitterBufferDurationInMS = 0; return PVMFSuccess; }
int32 CDecoderVideo::GetVideoHeader(int32 aLayer, uint8* aBuf, int32 aMaxSize) { OSCL_UNUSED_ARG(aLayer); int32 count = 0; char my_sc[4]; uint8 *tmp_bs = aBuf; oscl_memcpy(my_sc, tmp_bs, 4); my_sc[3] &= 0xf0; oscl_memcpy(VOSH_START_CODE1, aBuf, 4); return count ; if (aMaxSize >= 4) { /*__android_log_write(ANDROID_LOG_DEBUG, "CDecoderVideo::GetVideoHeader", "passo 1"); if (oscl_memcmp(my_sc, VOSH_START_CODE1, 4) && oscl_memcmp(my_sc, VO_START_CODE1, 4)) {__android_log_write(ANDROID_LOG_DEBUG, "CDecoderVideo::GetVideoHeader", "passo 2"); count = 0; } else {__android_log_write(ANDROID_LOG_DEBUG, "CDecoderVideo::GetVideoHeader", "passo 3");*/ count = 0; bool bShortHeader=false; while (oscl_memcmp(tmp_bs + count, VOP_START_CODE1, 4)) {__android_log_write(ANDROID_LOG_DEBUG, "CDecoderVideo::GetVideoHeader", "passo 4"); count++; if (count > 1000) {__android_log_write(ANDROID_LOG_DEBUG, "CDecoderVideo::GetVideoHeader", "passo 5"); bShortHeader = true; break; } } if (bShortHeader == true) {__android_log_write(ANDROID_LOG_DEBUG, "CDecoderVideo::GetVideoHeader", "passo 6"); count = 0; while (oscl_memcmp(tmp_bs + count, H263_START_CODE1, 3)) {__android_log_write(ANDROID_LOG_DEBUG, "CDecoderVideo::GetVideoHeader", "passo 7"); count++; } } //} } return count; }
PVMFStatus LipSyncDummyOutputMIO::connect(PvmiMIOSession& aSession, PvmiMIOObserver* aObserver) { OSCL_UNUSED_ARG(aSession); // Currently supports only one session if (iObserver) { LIPSYNCDUMMYOUTPUTMIO_LOGERROR((0, "LipSyncDummyOutputMIO::connect Session already exists. Can only support one session")); return PVMFErrAlreadyExists; } iObserver = aObserver; iParams = ShareParams::Instance(); iParams->iObserver = this; return PVMFSuccess; }
OSCL_EXPORT_REF void PVMp4FFComposerPort::setParametersSync(PvmiMIOSession session, PvmiKvp* parameters, int num_elements, PvmiKvp*& ret_kvp) { OSCL_UNUSED_ARG(session); ret_kvp = NULL; if (iFormat == PVMF_MIME_H264_VIDEO_MP4) { //this code is specific to H264 file format for (int32 i = 0; i < num_elements; i++)//assuming the memory is allocated for key { if (pv_mime_strcmp(parameters->key, VIDEO_AVC_OUTPUT_SPS_CUR_VALUE) == 0) { memfrag_sps = (OsclMemoryFragment *)(OSCL_MALLOC(sizeof(OsclMemoryFragment))); memfrag_sps->len = parameters->capacity; memfrag_sps->ptr = (uint8*)(OSCL_MALLOC(sizeof(uint8) * memfrag_sps->len)); oscl_memcpy((void*)memfrag_sps->ptr, (const void*)parameters->value.key_specific_value, memfrag_sps->len); iNode->memvector_sps.push_back(memfrag_sps); //storing SPS in the vector iNode->iNum_SPS_Set += 1; } if (pv_mime_strcmp(parameters->key, VIDEO_AVC_OUTPUT_PPS_CUR_VALUE) == 0) { memfrag_pps = (OsclMemoryFragment *)(OSCL_MALLOC(sizeof(OsclMemoryFragment))); memfrag_pps->len = parameters->capacity; memfrag_pps->ptr = (uint8*)(OSCL_MALLOC(sizeof(uint8) * memfrag_pps->len)); oscl_memcpy((void*)memfrag_pps->ptr, (const void*)parameters->value.key_specific_value, memfrag_pps->len); iNode->memvector_pps.push_back(memfrag_pps); //storing PPS in the vector iNode->iNum_PPS_Set += 1; } } } if (iFormat == PVMF_MIME_3GPP_TIMEDTEXT) { for (int32 i = 0; i < num_elements; i++)//assuming the memory is allocated for keys { if (pv_mime_strcmp(parameters->key, TIMED_TEXT_OUTPUT_CONFIG_INFO_CUR_VALUE) == 0) { PVA_FF_TextSampleDescInfo* ptempDecoderinfo = OSCL_STATIC_CAST(PVA_FF_TextSampleDescInfo*, parameters->value.key_specific_value); PVA_FF_TextSampleDescInfo* pDecoderinfo = OSCL_NEW(PVA_FF_TextSampleDescInfo, (*ptempDecoderinfo)); iNode->textdecodervector.push_back(pDecoderinfo); } } }
OSCL_EXPORT_REF void PVMFAvcEncPort::setParametersSync(PvmiMIOSession session, PvmiKvp* parameters, int num_elements, PvmiKvp*& ret_kvp) { OSCL_UNUSED_ARG(session); PVMFStatus status = PVMFSuccess; ret_kvp = NULL; for (int32 i = 0; i < num_elements; i++) { status = VerifyAndSetParameter(&(parameters[i]), true); if (status != PVMFSuccess) { LOG_ERR((0, "PVMFAvcEncPort::setParametersSync: Error - VerifiyAndSetParameter failed on parameter #%d", i)); ret_kvp = &(parameters[i]); OSCL_LEAVE(OsclErrArgument); } } }
PVMFStatus PVMFSocketPort::releaseParameters(PvmiMIOSession aSession, PvmiKvp* aParameters, int num_elements) { OSCL_UNUSED_ARG(aSession); PVLOGGER_LOGMSG(PVLOGMSG_INST_MLDBG, iLogger, PVLOGMSG_INFO, (0, "PVMFSocketPort::releaseParameters: aSession=0x%x, aParameters=0x%x, num_elements=%d", aSession, aParameters, num_elements)); if ((num_elements != 1) || (pv_mime_strcmp(aParameters->key, PVMI_PORT_CONFIG_INPLACE_DATA_PROCESSING_VALUE) != 0)) { PVLOGGER_LOGMSG(PVLOGMSG_INST_MLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFSocketPort::releaseParameters: Error - Not a PvmiKvp created by this port")); return PVMFFailure; } OsclMemAllocator alloc; alloc.deallocate((OsclAny*)(aParameters)); return PVMFSuccess; }
static void Get_lsp_pol( Word16 *lsp, Word32 *f, Flag *pOverflow) { Word16 i; Word16 j; Word16 hi; Word16 lo; Word32 t0; OSCL_UNUSED_ARG(pOverflow); /* f[0] = 1.0; */ *f++ = (Word32) 0x01000000; *f++ = (Word32) - *(lsp++) << 10; /* f[1] = -2.0 * lsp[0]; */ lsp++; /* Advance lsp pointer */ for (i = 2; i <= 5; i++) { *f = *(f - 2); for (j = 1; j < i; j++) { hi = (Word16)(*(f - 1) >> 16); lo = (Word16)((*(f - 1) >> 1) - ((Word32) hi << 15)); t0 = ((Word32)hi * *lsp); t0 += ((Word32)lo * *lsp) >> 15; *(f) += *(f - 2); /* *f += f[-2] */ *(f--) -= t0 << 2; /* *f -= t0 */ } *f -= (Word32)(*lsp++) << 10; f += i; lsp++; } return; }
int32 m4v_getVideoHeader(int32 layer, uint8 *buf, int32 max_size) { OSCL_UNUSED_ARG(layer); int32 count = 0; char my_sc[4]; uint8 *tmp_bs = buf; memcpy(my_sc, tmp_bs, 4); my_sc[3] &= 0xf0; if (max_size >= 4) { if (memcmp(my_sc, VOSH_START_CODE, 4) && memcmp(my_sc, VO_START_CODE, 4)) { count = 0; short_video_header = TRUE; } else { count = 0; short_video_header = FALSE; while (memcmp(tmp_bs + count, VOP_START_CODE, 4)) { count++; if (count > 1000) { short_video_header = TRUE; break; } } if (short_video_header == TRUE) { count = 0; while (memcmp(tmp_bs + count, H263_START_CODE, 3)) { count++; } } } } return count; }
OSCL_EXPORT_REF void TLSStorageOps::save_registry(TOsclTlsKey* key, OsclAny* ptr, int32 &aError) { aError = 0; #if (OSCL_TLS_IS_KEYED) OSCL_ASSERT(key); if (!OSCL_TLS_STORE_FUNC(*key, ptr)) { aError = EPVErrorBaseSystemCallFailed; return; } #else OSCL_UNUSED_ARG(key); if (!OSCL_TLS_STORE_FUNC(ptr)) { aError = EPVErrorBaseSystemCallFailed; return; } #endif }
int32 OsclSocketServI::Connect(uint32 aMessageSlots) { CONSTRUCT_STATS(this); //Connect to Oscl socket server OSCL_UNUSED_ARG(aMessageSlots); //should only connect once if (iServState == ESocketServ_Connected) { return OsclErrGeneral; } #ifdef OsclSocketStartup //startup the socket system. bool ok; OsclSocketStartup(ok); if (!ok) { return OsclErrGeneral; } #endif//OsclSocketStartup iServState = ESocketServ_Idle; //Start the server thread or AO int32 err = StartServImp(); if (err != OsclErrNone) { return err; } //check state. if (iServState != ESocketServ_Connected) { //cleanup after a failure. Close(false); return OsclErrGeneral; } return OsclErrNone; }
PVMFStatus PVAMRFFRecognizerPlugin::Recognize(PVMFDataStreamFactory& aSourceDataStreamFactory, PVMFRecognizerMIMEStringList* aFormatHint, Oscl_Vector<PVMFRecognizerResult, OsclMemAllocator>& aRecognizerResult) { OSCL_UNUSED_ARG(aFormatHint); OSCL_wHeapString<OsclMemAllocator> tmpfilename; Oscl_FileServer fileServ; PVFile pvfile; pvfile.SetCPM(&aSourceDataStreamFactory); if (!(pvfile.Open(tmpfilename.get_cstr(), Oscl_File::MODE_READ | Oscl_File::MODE_BINARY, fileServ))) { char* readData = NULL; readData = (char*)(oscl_malloc(sizeof(char) * AMRFF_MIN_DATA_SIZE_FOR_RECOGNITION)); if (readData != NULL) { int bytesRead = 0; bytesRead = pvfile.Read(readData, sizeof(char), AMRFF_MIN_DATA_SIZE_FOR_RECOGNITION); if (bytesRead != AMRFF_MIN_DATA_SIZE_FOR_RECOGNITION) { pvfile.Close(); oscl_free(readData); return PVMFFailure; } if (readData[0] == '#' && readData[1] == '!' && readData[2] == 'A' && readData[3] == 'M' && readData[4] == 'R') { PVMFRecognizerResult result; result.iRecognizedFormat = PVMF_MIME_AMRFF; result.iRecognitionConfidence = PVMFRecognizerConfidenceCertain; aRecognizerResult.push_back(result); } } pvfile.Close(); oscl_free(readData); return PVMFFailure; } else { return PVMFFailure; } return PVMFSuccess; }
PVA_FF_MediaDataAtom::PVA_FF_MediaDataAtom(MP4_AUTHOR_FF_FILE_HANDLE targetFileHandle, void *osclFileServerSession, uint32 aCacheSize) : PVA_FF_Atom(MEDIA_DATA_ATOM) { OSCL_UNUSED_ARG(aCacheSize); _type = MEDIA_DATA_ON_DISK; _osclFileServerSession = osclFileServerSession; _targetFileMediaStartOffset = 0; _totalDataRenderedToTargetFile = 0; _prenderables = NULL; _success = true; // _ptrackReferencePtrVec = new Oscl_Vector<PVA_FF_TrackAtom*,OsclMemAllocator>(); // _prenderables = new Oscl_Vector<PVA_FF_Renderable*,OsclMemAllocator>(); PV_MP4_FF_NEW(fp->auditCB, PVA_FF_RenderableVecType, (), _prenderables); PV_MP4_FF_NEW(fp->auditCB, PVA_FF_TrackAtomVecType, (), _ptrackReferencePtrVec); // ADDED TO CHECK FOR ANY FILE WRITE FAILURES _fileWriteError = false; _targetFileWriteError = false; _fileSize = 0; _fileOffsetForChunkStart = 0; _fileOffsetForAtomStart = 0; _oIsFileOpen = false; _directRender = true; _ptrackReferencePtr = NULL; recomputeSize(); _pofstream._filePtr = targetFileHandle; if (_pofstream._filePtr == NULL) { _fileWriteError = true; } }
// Constructor PVA_FF_MovieHeaderAtom::PVA_FF_MovieHeaderAtom(uint8 version, uint32 flags, uint32 fileAuthoringFlags) : PVA_FF_FullAtom(MOVIE_HEADER_ATOM, version, flags) { OSCL_UNUSED_ARG(fileAuthoringFlags); PVA_FF_AtomUtils::setTime(_creationTime); // Setting creating time (since 1/1/1904) PVA_FF_AtomUtils::setTime(_modificationTime); // Setting modification time _timeScale = DEFAULT_PRESENTATION_TIMESCALE; _duration = 0; _nextTrackID = INITIAL_TRACK_ID; /* * Variables added to ensure that the total track duration includes the duration of the * last sample as well, which in our case fp same as the last but one. */ _prevTS = 0; _deltaTS = 0; recomputeSize(); }
void PVMFSocketPort::setParametersSync(PvmiMIOSession aSession, PvmiKvp* aParameters, int num_elements, PvmiKvp * & aRet_kvp) { OSCL_UNUSED_ARG(aSession); PVLOGGER_LOGMSG(PVLOGMSG_INST_MLDBG, iLogger, PVLOGMSG_INFO, (0, "PVMFSocketPort::getParametersSync: aSession=0x%x, aParameters=0x%x, num_elements=%d, aRet_kvp=0x%x", aSession, aParameters, num_elements, aRet_kvp)); if (!aParameters || (num_elements != 1) || (pv_mime_strcmp(aParameters->key, PVMF_SOCKET_PORT_SPECIFIC_ALLOCATOR_VALTYPE) != 0)) { aRet_kvp = aParameters; OSCL_LEAVE(OsclErrArgument); } if (aParameters->value.key_specific_value == NULL) { aRet_kvp = aParameters; OSCL_LEAVE(OsclErrArgument); } }
Word16 GSMInitEncode(void **state_data, Flag dtx, Word8 *id) { Speech_Encode_FrameState* s; OSCL_UNUSED_ARG(id); if (state_data == NULL) { /* fprintf(stderr, "Speech_Encode_Frame_init: invalid parameter\n"); */ return -1; } *state_data = NULL; /* allocate memory */ if ((s = (Speech_Encode_FrameState *) oscl_malloc(sizeof(Speech_Encode_FrameState))) == NULL) { /* fprintf(stderr, "Speech_Encode_Frame_init: can not malloc state " "structure\n"); */ return -1; } s->pre_state = NULL; s->cod_amr_state = NULL; s->dtx = dtx; if (Pre_Process_init(&s->pre_state) || cod_amr_init(&s->cod_amr_state, s->dtx)) { Speech_Encode_FrameState** temp = &s; GSMEncodeFrameExit((void**)temp); return -1; } Speech_Encode_Frame_reset(s); *state_data = (void *)s; return 0; }
void Lsp_lsf( Word16 lsp[], /* (i) : lsp[m] (range: -1<=val<1) */ Word16 lsf[], /* (o) : lsf[m] normalized (range: 0.0<=val<=0.5) */ Word16 m, /* (i) : LPC order */ Flag *pOverflow /* (o) : Flag set when overflow occurs */ ) { Word16 i; Word16 ind; Word16 temp; Word32 L_tmp; Word16 *p_lsp = &lsp[m-1]; Word16 *p_lsf = &lsf[m-1]; OSCL_UNUSED_ARG(pOverflow); ind = 63; /* begin at end of table -1 */ for (i = m - 1; i >= 0; i--) { /* find value in table that is just greater than lsp[i] */ temp = *(p_lsp--); while (table[ind] < temp) { ind--; } /* acos(lsp[i])= ind*256 + ( ( lsp[i]-table[ind] ) * slope[ind] )/4096 */ L_tmp = (Word32)(temp - table[ind]) * slope[ind]; /*(lsp[i]-table[ind])*slope[ind])>>12*/ L_tmp = (L_tmp + 0x00000800) >> 12; *(p_lsf--) = (Word16)(L_tmp) + (ind << 8); } return; }
void pv_metadata_engine_test::HandleInformationalEvent(const PVAsyncInformationalEvent& aEvent) { OSCL_UNUSED_ARG(aEvent); }
void pv_metadata_engine_test::HandleErrorEvent(const PVAsyncErrorEvent& aEvent) { OSCL_UNUSED_ARG(aEvent); }
OMX_ERRORTYPE OmxDecTestBase::FillBufferDone(OMX_OUT OMX_HANDLETYPE aComponent, OMX_OUT OMX_PTR aAppData, OMX_OUT OMX_BUFFERHEADERTYPE* aBuffer) { OSCL_UNUSED_ARG(aComponent); OSCL_UNUSED_ARG(aAppData); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestBase::FillBufferDone() - IN")); //Check the validity of buffer if (NULL == aBuffer || OMX_DirOutput != aBuffer->nOutputPortIndex) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestBase::FillBufferDone() - ERROR, Invalid buffer found in callback, OUT")); iState = StateError; RunIfNotReady(); return OMX_ErrorBadParameter; } OMX_U8* pOutputBuffer; OMX_U32 ii = 0; pOutputBuffer = (OMX_U8*)(aBuffer->pBuffer); //Output buffer has been freed by component & can now be passed again in FillThisBuffer call if (NULL != aBuffer) { if (0 != aBuffer->nFilledLen) { if (WriteOutput(pOutputBuffer, aBuffer->nFilledLen)) { /* Clear the output buffer after writing to file, * so that there is no chance of getting it written again while flushing port */ aBuffer->nFilledLen = 0; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::FillBufferDone() - Frame %i processed Timestamp %d", iFramesWritten, aBuffer->nTimeStamp)); iFramesWritten++; } else { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestBase::FillBufferDone() - ERROR, Failed to write output to file")); } } } while (((OMX_U32) ipOutBuffer[ii] != (OMX_U32) aBuffer) && (ii < iOutBufferCount)) { ii++; } if (iOutBufferCount != ii) { //If the buffer is already returned and then a callback comes for same buffer //report an error and stop if (OMX_TRUE == ipOutReleased[ii]) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestBase::FillBufferDone() - ERROR, Same bufer with index %d returned twice", ii)); iState = StateError; RunIfNotReady(); } ipOutReleased[ii] = OMX_TRUE; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::FillBufferDone() - Output buffer with index %d marked free", ii)); } else { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestBase::FillBufferDone() - ERROR, Invalid buffer found in callback, cannot mark it free")); iState = StateError; RunIfNotReady(); } //To simulate output busy condition iCount++; if (0 == (iCount % 5)) { iStopOutput = OMX_TRUE; } if (0 >= iPendingCommands) { RunIfNotReady(); } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestBase::FillBufferDone() - OUT")); return OMX_ErrorNone; }
OMX_ERRORTYPE OmxDecTestBase::EmptyBufferDone(OMX_OUT OMX_HANDLETYPE aComponent, OMX_OUT OMX_PTR aAppData, OMX_OUT OMX_BUFFERHEADERTYPE* aBuffer) { OSCL_UNUSED_ARG(aComponent); OSCL_UNUSED_ARG(aAppData); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestBase::EmptyBufferDone() - IN")); //Check the validity of buffer if (NULL == aBuffer || OMX_DirInput != aBuffer->nInputPortIndex) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestBase::EmptyBufferDone() - ERROR, Invalid buffer found in callback, OUT")); iState = StateError; RunIfNotReady(); return OMX_ErrorBadParameter; } //ACTUAL PROCESSING OMX_U32 ii = 0; while ((OMX_U32)(ipInBuffer[ii]) != (OMX_U32) aBuffer && ii < iInBufferCount) { ii++; } if (iInBufferCount != ii) { //If the buffer is already returned and then a callback comes for same buffer //report an error and stop if (OMX_TRUE == ipInputAvail[ii]) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestBase::EmptyBufferDone() - ERROR, Same bufer with index %d returned twice", ii)); iState = StateError; RunIfNotReady(); } ipInputAvail[ii] = OMX_TRUE; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::EmptyBufferDone() - Input buffer with index %d returned in callback", ii)); } else { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestBase::EmptyBufferDone() - ERROR, Invalid buffer found in callback, cannot mark it free")); iState = StateError; RunIfNotReady(); } iInputReady = OMX_TRUE; //To simulate input busy condition iCount3++; if (0 == (iCount3 % 2)) { iStopInput = OMX_TRUE; } if (0 >= iPendingCommands) { RunIfNotReady(); } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestBase::EmptyBufferDone() - OUT")); return OMX_ErrorNone; }
OMX_ERRORTYPE OmxDecTestBase::EventHandler(OMX_OUT OMX_HANDLETYPE aComponent, OMX_OUT OMX_PTR aAppData, OMX_OUT OMX_EVENTTYPE aEvent, OMX_OUT OMX_U32 aData1, OMX_OUT OMX_U32 aData2, OMX_OUT OMX_PTR aEventData) { OSCL_UNUSED_ARG(aComponent); OSCL_UNUSED_ARG(aAppData); OSCL_UNUSED_ARG(aEventData); PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestBase::EventHandler() - IN")); if (OMX_EventCmdComplete == aEvent) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::EventHandler() - Command Complete callback arrived")); if (OMX_CommandStateSet == aData1) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::EventHandler() - State Changed callback has come under Command Complete")); switch ((OMX_S32) aData2) { //Falling through next case case OMX_StateInvalid: case OMX_StateWaitForResources: break; case OMX_StateLoaded: { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::EventHandler() - Callback, State Changed to OMX_StateLoaded")); if (StateCleanUp == iState) { iState = StateStop; if (0 == --iPendingCommands) { RunIfNotReady(); } } } break; case OMX_StateIdle: { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::EventHandler() - Callback, State Changed to OMX_StateIdle")); if (StateStopping == iState || StateDynamicReconfig == iState || StateDisablePort == iState || StateDecodeHeader == iState) { iState = StateCleanUp; if (0 == --iPendingCommands) { RunIfNotReady(); } } //this will be the case in EOS missing test case, go to a stopping state now else if (StateExecuting == iState) { iState = StateStopping; if (0 == --iPendingCommands) { RunIfNotReady(); } } else if (StateStop == iState || StateError == iState) { //Do not change the state because error has occured previously RunIfNotReady(); } else { iState = StateIdle; if (0 == --iPendingCommands) { RunIfNotReady(); } } } break; case OMX_StateExecuting: //Change the state on receiving callback { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::EventHandler() - Callback, State Changed to OMX_StateExecuting")); if (StateIdle == iState) //Chk whether some error condition has occured previously or not { iState = StateDecodeHeader; if (0 == --iPendingCommands) { RunIfNotReady(); } } else if (StatePause == iState) { iState = StateExecuting; if (0 == --iPendingCommands) { RunIfNotReady(); } } } break; case OMX_StatePause: //Change the state on receiving callback { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::EventHandler() - Callback, State Changed to OMX_StatePause")); if (StateExecuting == iState) { iState = StatePause; if (0 == --iPendingCommands) { RunIfNotReady(); } } } break; default: break; } } else if (OMX_CommandPortDisable == aData1) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::EventHandler() - Port Disable callback has come under Command Complete")); //Do the transition only if no error has occured previously if (StateStop != iState && StateError != iState) { iState = StateDynamicReconfig; if (0 == --iPendingCommands) { RunIfNotReady(); } } } else if (OMX_CommandPortEnable == aData1) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::EventHandler() - Port Enable callback has come under Command Complete")); //Change the state from Reconfig to Executing on receiving this callback if there is no error if (StateStop != iState && StateError != iState) { iState = StateExecuting; if (0 == --iPendingCommands) { RunIfNotReady(); } } } else if (OMX_CommandFlush == aData1) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::EventHandler() - Flush Port callback has come under Command Complete")); if (0 == --iPendingCommands) { //Move to a intermediate state for port/buffer verification iState = StateIntermediate; RunIfNotReady(); } } } else if (OMX_EventPortSettingsChanged == aEvent) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::EventHandler() - Port Settings Changed callback arrived")); if (StateDecodeHeader == iState || StateExecuting == iState) { iState = StateDisablePort; iDisableRun = OMX_FALSE; iFlagDisablePort = OMX_FALSE; RunIfNotReady(); } } else if (OMX_EventBufferFlag == aEvent) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "OmxDecTestBase::EventHandler() - End Of Stream callback arrived")); //callback for EOS //Change the state on receiving EOS callback iState = StateStopping; if (0 == --iPendingCommands) { RunIfNotReady(); } } else if (OMX_EventError == aEvent) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestBase::EventHandler() - Error returned in the callback")); if (OMX_ErrorSameState == (OMX_S32)aData1) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestBase::EventHandler() - Same State Error, trying to proceed")); if (StateCleanUp == iState) { iState = StateStop; if (0 == --iPendingCommands) { RunIfNotReady(); } } } else if (OMX_ErrorStreamCorrupt == (OMX_S32)aData1) { /* Don't do anything right now for the stream corrupt error, * just count the number of such callbacks and let the decoder to proceed */ iStreamCorruptCount++; PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "OmxDecTestBase::EventHandler() - Stream Corrupt Error, total as of now is %d", iStreamCorruptCount)); } else { // do nothing, just try to proceed normally } } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "OmxDecTestBase::EventHandler() - OUT")); return OMX_ErrorNone; }
void Deringing_Chroma( uint8 *Rec_C, int width, int height, int16 *QP_store, int Combined, uint8 *pp_mod ) { OSCL_UNUSED_ARG(Combined); /*---------------------------------------------------------------------------- ; Define all local variables ----------------------------------------------------------------------------*/ int thres; int v_blk, h_blk; int max_diff; int v_pel, h_pel; int max_blk, min_blk; int v0, h0; uint8 *ptr; int sum, sum1, incr; int32 addr_v; int sign_v[10], sum_v[10]; int *ptr2, *ptr3; uint8 pelu, pelc, pell; incr = width - BLKSIZE; /*---------------------------------------------------------------------------- ; Function body here ----------------------------------------------------------------------------*/ /* chrominance */ /* Do the first line (7 pixels at a time => Don't use MMX)*/ for (h_blk = 0;h_blk < width;h_blk += BLKSIZE) { max_diff = (QP_store[h_blk>>3] >> 2) + 4; ptr = &Rec_C[h_blk]; max_blk = min_blk = *ptr; FindMaxMin(ptr, &min_blk, &max_blk, width); h0 = ((h_blk - 1) >= 1) ? (h_blk - 1) : 1; if (max_blk - min_blk >= 4) { thres = (max_blk + min_blk + 1) >> 1; for (v_pel = 1;v_pel < BLKSIZE - 1;v_pel++) { addr_v = (int32)v_pel * width; ptr = &Rec_C[addr_v + h0 - 1]; ptr2 = &sum_v[0]; ptr3 = &sign_v[0]; pelu = *(ptr - width); pelc = *ptr; pell = *(ptr + width); ptr++; *ptr2++ = pelu + (pelc << 1) + pell; *ptr3++ = INDEX(pelu, thres) + INDEX(pelc, thres) + INDEX(pell, thres); pelu = *(ptr - width); pelc = *ptr; pell = *(ptr + width); ptr++; *ptr2++ = pelu + (pelc << 1) + pell; *ptr3++ = INDEX(pelu, thres) + INDEX(pelc, thres) + INDEX(pell, thres); for (h_pel = h0;h_pel < h_blk + BLKSIZE - 1;h_pel++) { pelu = *(ptr - width); pelc = *ptr; pell = *(ptr + width); *ptr2 = pelu + (pelc << 1) + pell; *ptr3 = INDEX(pelu, thres) + INDEX(pelc, thres) + INDEX(pell, thres); sum1 = *(ptr3 - 2) + *(ptr3 - 1) + *ptr3; if (sum1 == 0 || sum1 == 9) { sum = (*(ptr2 - 2) + (*(ptr2 - 1) << 1) + *ptr2 + 8) >> 4; ptr--; if (PV_ABS(*ptr - sum) > max_diff) { if (sum > *ptr) sum = *ptr + max_diff; else sum = *ptr - max_diff; } *ptr++ = (uint8) sum; } ptr++; ptr2++; ptr3++; } } }
int32 OsclNativeFile::SetSize(uint32 size) { OSCL_UNUSED_ARG(size); return -1; }
void subframePostProc( Word16 *speech, /* i : speech segment */ enum Mode mode, /* i : coder mode */ Word16 i_subfr, /* i : Subframe nr */ Word16 gain_pit, /* i : Pitch gain Q14 */ Word16 gain_code, /* i : Decoded innovation gain */ Word16 *Aq, /* i : A(z) quantized for the 4 subframes */ Word16 synth[], /* i : Local snthesis */ Word16 xn[], /* i : Target vector for pitch search */ Word16 code[], /* i : Fixed codebook exitation */ Word16 y1[], /* i : Filtered adaptive exitation */ Word16 y2[], /* i : Filtered fixed codebook excitation */ Word16 *mem_syn, /* i/o : memory of synthesis filter */ Word16 *mem_err, /* o : pointer to error signal */ Word16 *mem_w0, /* o : memory of weighting filter */ Word16 *exc, /* o : long term prediction residual */ Word16 *sharp, /* o : pitch sharpening value */ Flag *pOverflow /* o : overflow indicator */ ) { Word16 i; Word16 j; Word16 temp; Word32 L_temp; Word32 L_temp2; Word16 tempShift; Word16 kShift; Word16 pitch_fac; Word16 *p_exc; Word16 *p_code; OSCL_UNUSED_ARG(pOverflow); if (mode != MR122) { tempShift = 1; kShift = 16 - 2 - 1; pitch_fac = gain_pit; } else { tempShift = 2; kShift = 16 - 4 - 1; pitch_fac = gain_pit >> 1; } /*------------------------------------------------------------* * - Update pitch sharpening "sharp" with quantized gain_pit * *------------------------------------------------------------*/ if (gain_pit < SHARPMAX) { *sharp = gain_pit; } else { *sharp = SHARPMAX; } /*------------------------------------------------------* * - Find the total excitation * * - find synthesis speech corresponding to exc[] * * - update filters memories for finding the target * * vector in the next subframe * * (update error[-m..-1] and mem_w_err[]) * *------------------------------------------------------*/ p_exc = &exc[ i_subfr]; p_code = &code[0]; for (i = L_SUBFR >> 1; i != 0 ; i--) { /* exc[i] = gain_pit*exc[i] + gain_code*code[i]; */ /* * 12k2 others * --------------------------------- * exc Q0 Q0 * gain_pit Q14 Q14 * pitch_fac Q13 Q14 * product: Q14 Q15 * * code Q12 Q13 * gain_code Q1 Q1 * product Q14 Q15 * sum Q14 Q15 * * tempShift 2 1 * sum<<tempShift Q16 Q16 * result -> exc Q0 Q0 */ L_temp = ((Word32) * (p_exc++) * pitch_fac) << 1; L_temp2 = ((Word32) * (p_exc--) * pitch_fac) << 1; L_temp += ((Word32) * (p_code++) * gain_code) << 1; L_temp2 += ((Word32) * (p_code++) * gain_code) << 1; L_temp <<= tempShift; L_temp2 <<= tempShift; *(p_exc++) = (Word16)((L_temp + 0x08000L) >> 16); *(p_exc++) = (Word16)((L_temp2 + 0x08000L) >> 16); } Syn_filt( Aq, &exc[i_subfr], &synth[i_subfr], L_SUBFR, mem_syn, 1); for (i = L_SUBFR - M, j = 0; i < L_SUBFR; i++, j++) { mem_err[j] = speech[i_subfr + i] - synth[i_subfr + i]; /* * 12k2 others * --------------------------------- * y1 Q0 Q0 * gain_pit Q14 Q14 * product Q15 Q15 * shifted prod. Q16 Q16 * temp Q0 Q0 * * y2 Q10 Q12 * gain_code Q1 Q1 * product Q12 Q14 * kshift 4 2 * shifted prod. Q16 Q16 * k Q0 Q0 * mem_w0,xn,sum Q0 Q0 */ L_temp = ((Word32)y1[i] * gain_pit); temp = (Word16)(L_temp >> 14); L_temp = ((Word32)y2[i] * gain_code); temp += (Word16)(L_temp >> kShift); mem_w0[j] = xn[i] - temp; } return; }
PVMFStatus PVMFFileOutputNode::getParametersSync(PvmiMIOSession aSession, PvmiKeyType aIdentifier, PvmiKvp*& aParameters, int& aNumParamElements, PvmiCapabilityContext aContext) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVMFFileOutputNode::getParametersSync()")); OSCL_UNUSED_ARG(aSession); OSCL_UNUSED_ARG(aContext); // Initialize the output parameters aNumParamElements = 0; aParameters = NULL; // Count the number of components and parameters in the key int compcount = pv_mime_string_compcnt(aIdentifier); // Retrieve the first component from the key string char* compstr = NULL; pv_mime_string_extract_type(0, aIdentifier, compstr); if ((pv_mime_strcmp(compstr, _STRLIT_CHAR("x-pvmf/file/output")) < 0) || compcount < 4) { // First 4 components should be "x-pvmf/file/output" and there must // be at least 4 components PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFFileOutputNode::getParametersSync() Invalid key string")); return PVMFErrNotSupported; } // Retrieve the fourth component from the key string pv_mime_string_extract_type(3, aIdentifier, compstr); for (int32 fileoutput4ind = 0; fileoutput4ind < FILEOUTPUTNODECONFIG_BASE_NUMKEYS; ++fileoutput4ind) { // Go through each file output component string at 4th level if (pv_mime_strcmp(compstr, (char*)(FileOutputNodeConfig_BaseKeys[fileoutput4ind].iString)) >= 0) { if (4 == compcount) { // Determine what is requested PvmiKvpAttr reqattr = GetAttrTypeFromKeyString(aIdentifier); if (reqattr == PVMI_KVPATTR_UNKNOWN) { reqattr = PVMI_KVPATTR_CUR; } // Return the requested info PVMFStatus retval = GetConfigParameter(aParameters, aNumParamElements, fileoutput4ind, reqattr); if (retval != PVMFSuccess) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFFileOutputNode::getParametersSync() Retrieving file output node parameter failed")); return retval; } } else { // Right now file output node doesn't support more than 4 components // for this sub-key string so error out PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFFileOutputNode::getParametersSync() Unsupported key")); return PVMFErrNotSupported; } } } PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVMFFileOutputNode::getParametersSync() Out")); if (0 == aNumParamElements) { // If no one could get the parameter, return error PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFFileOutputNode::getParametersSync() Unsupported key")); return PVMFFailure; } else { return PVMFSuccess; } }
PVMFStatus PVMFFileOutputNode::releaseParameters(PvmiMIOSession aSession, PvmiKvp* aParameters, int aNumElements) { PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVMFFileOutputNode::releaseParameters()")); OSCL_UNUSED_ARG(aSession); if (aParameters == NULL || aNumElements < 1) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFFileOutputNode::releaseParameters() KVP list is NULL or number of elements is 0")); return PVMFErrArgument; } // Count the number of components and parameters in the key int compcount = pv_mime_string_compcnt(aParameters[0].key); // Retrieve the first component from the key string char* compstr = NULL; pv_mime_string_extract_type(0, aParameters[0].key, compstr); if ((pv_mime_strcmp(compstr, _STRLIT_CHAR("x-pvmf/file/output")) < 0) || compcount < 3) { // First 3 component should be "x-pvmf/file/output" and there must // be at least four components PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFFileOutputNode::releaseParameters() Unsupported key")); return PVMFErrNotSupported; } // Retrieve the third component from the key string pv_mime_string_extract_type(3, aParameters[0].key, compstr); // Go through each KVP and release memory for value if allocated from heap for (int32 ii = 0; ii < aNumElements; ++ii) { // Next check if it is a value type that allocated memory PvmiKvpType kvptype = GetTypeFromKeyString(aParameters[ii].key); if (kvptype == PVMI_KVPTYPE_VALUE || kvptype == PVMI_KVPTYPE_UNKNOWN) { PvmiKvpValueType keyvaltype = GetValTypeFromKeyString(aParameters[ii].key); if (PVMI_KVPVALTYPE_UNKNOWN == keyvaltype) { PVLOGGER_LOGMSG(PVLOGMSG_INST_HLDBG, iLogger, PVLOGMSG_ERR, (0, "PVMFFileOutputNode::releaseParameters() Valtype not specified in key string")); return PVMFErrNotSupported; } if (((PVMI_KVPVALTYPE_CHARPTR == keyvaltype) && NULL != (aParameters[ii].value.pChar_value))) { oscl_free(aParameters[ii].value.pChar_value); aParameters[ii].value.pChar_value = NULL; } else if (PVMI_KVPVALTYPE_KSV == keyvaltype && NULL != aParameters[ii].value.key_specific_value) { oscl_free(aParameters[ii].value.key_specific_value); aParameters[ii].value.key_specific_value = NULL; } else if (PVMI_KVPVALTYPE_RANGE_UINT32 == keyvaltype && NULL != aParameters[ii].value.key_specific_value) { range_uint32* rui32 = (range_uint32*)aParameters[ii].value.key_specific_value; aParameters[ii].value.key_specific_value = NULL; oscl_free(rui32); } // @TODO Add more types if file output node starts returning more types } } // file output node allocated its key strings in one chunk so just free the first key string ptr oscl_free(aParameters[0].key); // Free memory for the parameter list oscl_free(aParameters); aParameters = NULL; PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, (0, "PVMFFileOutputNode::releaseParameters() Out")); return PVMFSuccess; }
static Word16 Chebps(Word16 x, Word16 f[], /* (n) */ Word16 n, Flag *pOverflow) { Word16 i; Word16 cheb; Word16 b1_h; Word16 b1_l; Word32 t0; Word32 L_temp; Word16 *p_f = &f[1]; OSCL_UNUSED_ARG(pOverflow); /* L_temp = 1.0 */ L_temp = 0x01000000L; t0 = ((Word32) x << 10) + ((Word32) * (p_f++) << 14); /* b1 = t0 = 2*x + f[1] */ b1_h = (Word16)(t0 >> 16); b1_l = (Word16)((t0 >> 1) - (b1_h << 15)); for (i = 2; i < n; i++) { /* t0 = 2.0*x*b1 */ t0 = ((Word32) b1_h * x); t0 += ((Word32) b1_l * x) >> 15; t0 <<= 2; /* t0 = 2.0*x*b1 - b2 */ t0 -= L_temp; /* t0 = 2.0*x*b1 - b2 + f[i] */ t0 += (Word32) * (p_f++) << 14; L_temp = ((Word32) b1_h << 16) + ((Word32) b1_l << 1); /* b0 = 2.0*x*b1 - b2 + f[i]*/ b1_h = (Word16)(t0 >> 16); b1_l = (Word16)((t0 >> 1) - (b1_h << 15)); } /* t0 = x*b1; */ t0 = ((Word32) b1_h * x); t0 += ((Word32) b1_l * x) >> 15; t0 <<= 1; /* t0 = x*b1 - b2 */ t0 -= L_temp; /* t0 = x*b1 - b2 + f[i]/2 */ t0 += (Word32) * (p_f) << 13; if ((UWord32)(t0 - 0xfe000000L) < (UWord32)0x03ffffffL) { cheb = (Word16)(t0 >> 10); }
void UnbindBuffer_OMX(void* aUserData, int32 i) { OSCL_UNUSED_ARG(aUserData); OSCL_UNUSED_ARG(i); return; }