PVMFStatus PVOMA1KMJRecognizerPlugin::Recognize( PVMFDataStreamFactory& aSourceDataStreamFactory,
                                                 PVMFRecognizerMIMEStringList* aFormatHint,
                                                 Oscl_Vector<PVMFRecognizerResult,OsclMemAllocator>& aRecognizerResult
                                                )
{
  Oscl_FileServer fileServ;
    PVFile pvfile;

    // set data stream
    pvfile.SetCPM(&aSourceDataStreamFactory);

    // open data stream
    int32 ret = pvfile.Open( NULL,Oscl_File::MODE_READ | Oscl_File::MODE_BINARY,fileServ);
    if(ret)  // open data stream failed
    {
        LOGD("PVOMA1KMJRecognizerPlugin:Recognize pvfile.Open failed");
        return PVMFFailure;
    }

    DrmPluginDataAccess dataAccess(&pvfile);

    T_DRM_Input_Data drmInputData =
    {
        (int32_t)&dataAccess,
        TYPE_DRM_UNKNOWN,
        DrmPluginGetDataLen,
        DrmPluginReadData,
        DrmPluginSeekData
    };

    int32_t session = SVC_drm_openSession(drmInputData);

    if((DRM_MEDIA_DATA_INVALID == session) || (DRM_FAILURE == session))
    {
        LOGD("PVOMA1KMJRecognizerPlugin:Recognize SVC_drm_openSession failed");
    pvfile.Close();
        return PVMFFailure;
    }

    char mediaType[CONTENT_TYPE_LEN] = {0};
    ret = SVC_drm_getContentType(session,(uint8_t*)mediaType);

    SVC_drm_closeSession(session);
    pvfile.Close();

    if(DRM_SUCCESS != ret)  // get DRM content type failed
    {
        LOGD("PVOMA1KMJRecognizerPlugin:Recognize SVC_drm_getTypeDirectly failed");
        return PVMFFailure;
    }

    // save content type for use by outer
    PVMFRecognizerResult result;

    RecognizeContentType(mediaType,result.iRecognizedFormat);
    result.iRecognitionConfidence = PVMFRecognizerConfidenceCertain;
    aRecognizerResult.push_back(result);

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