C++ OSCL_UNUSED_ARG函数代码示例

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;
    }
}

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;
}