| /* ------------------------------------------------------------------ |
| * Copyright (C) 1998-2009 PacketVideo |
| * |
| * 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. |
| * ------------------------------------------------------------------- |
| */ |
| #ifndef TEST_PV_AUTHOR_ENGINE_TESTSET5_H_INCLUDED |
| #include "test_pv_author_engine_testset5.h" |
| #endif |
| |
| #ifndef PVMF_COMPOSER_SIZE_AND_DURATION_H_INCLUDED |
| #include "pvmf_composer_size_and_duration.h" |
| #endif |
| |
| #ifndef PVMF_FILEOUTPUT_CONFIG_H_INCLUDED |
| #include "pvmf_fileoutput_config.h" |
| #endif |
| |
| #ifndef PVMP4FFCN_CLIPCONFIG_H_INCLUDED |
| #include "pvmp4ffcn_clipconfig.h" |
| #endif |
| |
| #ifndef PV_MP4_H263_ENC_EXTENSION_H_INCLUDED |
| #include "pvmp4h263encextension.h" |
| #endif |
| |
| #ifndef PVAETEST_NODE_CONFIG_H_INCLUDED |
| #include "pvaetest_node_config.h" |
| #endif |
| |
| #ifndef PVMI_KVP_H_INCLUDED |
| #include "pvmi_kvp.h" |
| #endif |
| void pv_mediainput_async_test_opencomposestop::StartTest() |
| { |
| AddToScheduler(); |
| iState = PVAE_CMD_CREATE; |
| RunIfNotReady(); |
| } |
| |
| |
| /*@todo add error handling here */ |
| //////////////////////////////////////////////////////////////////////////// |
| void pv_mediainput_async_test_opencomposestop::HandleErrorEvent(const PVAsyncErrorEvent& aEvent) |
| { |
| OSCL_UNUSED_ARG(aEvent); |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, (0, "pv_mediainput_async_test_opencomposestop::HandleErrorEvent")); |
| iState = PVAE_CMD_RESET; |
| Cancel();//added to cancel previous running AO |
| RunIfNotReady(); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| void pv_mediainput_async_test_opencomposestop::HandleInformationalEvent(const PVAsyncInformationalEvent& aEvent) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_STACK_TRACE, |
| (0, "pv_mediainput_async_test_opencomposestop::HandleInformationalEvent")); |
| |
| OsclAny* eventData = NULL; |
| switch (aEvent.GetEventType()) |
| { |
| case PVMF_COMPOSER_MAXFILESIZE_REACHED: |
| case PVMF_COMPOSER_MAXDURATION_REACHED: |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, |
| (0, "pv_mediainput_async_test_opencomposestop::HandleNodeInformationalEvent: Max file size reached")); |
| iState = PVAE_CMD_RESET; |
| |
| Cancel(); |
| PVPATB_TEST_IS_TRUE(true); |
| RunIfNotReady(); |
| |
| fprintf(iFile, "Recording finished, Closing file please wait *******\n"); |
| break; |
| |
| case PVMF_COMPOSER_DURATION_PROGRESS: |
| aEvent.GetEventData(eventData); |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, |
| (0, "pv_mediainput_async_test_opencomposestop::HandleNodeInformationalEvent: Duration progress: %d ms", |
| (int32)eventData)); |
| fprintf(iStdOut, "Duration: %d ms\n", (int32)eventData); |
| break; |
| |
| case PVMF_COMPOSER_FILESIZE_PROGRESS: |
| aEvent.GetEventData(eventData); |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, |
| (0, "pv_mediainput_async_test_opencomposestop::HandleNodeInformationalEvent: File size progress: %d bytes", |
| (int32)eventData)); |
| fprintf(iStdOut, "File size: %d bytes\n", (int32)eventData); |
| break; |
| |
| case PVMF_COMPOSER_EOS_REACHED: |
| //Engine already stopped at EOS so send reset command. |
| iState = PVAE_CMD_RESET; |
| //cancel recording timeout scheduled for timer object. |
| Cancel(); |
| RunIfNotReady(); |
| |
| fprintf(iFile, "Recording finished, Closing file please wait *******\n"); |
| |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| bool pv_mediainput_async_test_opencomposestop::CreateTestInputs() |
| { |
| int32 status = 0; |
| int32 error = 0; |
| iFileParser = NULL; |
| |
| iFileServer.Connect(); |
| |
| if (iMediaInputType == PVMF_MIME_AVIFF) |
| { |
| |
| OSCL_TRY(error, iFileParser = PVAviFile::CreateAviFileParser(iInputFileName, error, &iFileServer);); |
| |
| if (error || (NULL == iFileParser)) |
| { |
| if (iFileParser) |
| { |
| goto ERROR_CODE; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| |
| //set recording duration to TEST_TIMEOUT_FACTOR times the file duration in order to time out |
| //if EOS is not received by this time. |
| iTestDuration = (TEST_TIMEOUT_FACTOR * ((PVAviFile*)iFileParser)->GetFileDuration()); |
| |
| if (iTestDuration > KAuthoringSessionUnit) |
| { |
| //if test duration, in microsec, is too large, the uint32 |
| //variable will rollover. Hence the test run is divided |
| //in small sessions of KAuthoringSessionUnit duration |
| iAuthoringCount = iTestDuration / KAuthoringSessionUnit; |
| iTestDuration = KAuthoringSessionUnit * 1000 * 1000; //in microsec |
| } |
| else |
| { |
| iTestDuration = iTestDuration * 1000 * 1000; |
| } |
| uint32 numStreams = ((PVAviFile*)iFileParser)->GetNumStreams(); |
| |
| iAddAudioMediaTrack = false; |
| iAddVideoMediaTrack = false; |
| |
| for (uint32 ii = 0; ii < numStreams; ii++) |
| { |
| if (oscl_strstr(((PVAviFile*)iFileParser)->GetStreamMimeType(ii).get_cstr(), "audio")) |
| { |
| iAddAudioMediaTrack = true; |
| } |
| |
| if (oscl_strstr(((PVAviFile*)iFileParser)->GetStreamMimeType(ii).get_cstr(), "video")) |
| { |
| iAddVideoMediaTrack = true; |
| } |
| |
| } |
| |
| } |
| else if (iMediaInputType == PVMF_MIME_WAVFF) |
| { |
| OSCL_TRY(error, iFileParser = OSCL_NEW(PV_Wav_Parser, ());); |
| if (error || (NULL == iFileParser)) |
| { |
| return false; |
| } |
| if (((PV_Wav_Parser*)iFileParser)->InitWavParser(iInputFileName, &iFileServer) != PVWAVPARSER_OK) |
| { |
| |
| goto ERROR_CODE; |
| } |
| |
| iAddAudioMediaTrack = true; |
| iAddVideoMediaTrack = false; |
| |
| PVWAVFileInfo fileInfo; |
| |
| ((PV_Wav_Parser*)iFileParser)->RetrieveFileInfo(fileInfo); |
| |
| //set recording duration to TEST_TIMEOUT_FACTOR times the file duration in order to time out |
| //if EOS is not received by this time. |
| iTestDuration = (TEST_TIMEOUT_FACTOR * ((fileInfo.NumSamples * fileInfo.BytesPerSample) / fileInfo.SampleRate)) ; // in sec |
| |
| if (iTestDuration > KAuthoringSessionUnit) |
| { |
| //if test duration, in microsec, is too large, the uint32 |
| //variable will rollover. Hence the test run is divided |
| //in small sessions of KAuthoringSessionUnit duration |
| iAuthoringCount = iTestDuration / KAuthoringSessionUnit; |
| iTestDuration = KAuthoringSessionUnit * 1000 * 1000; //in microsec |
| } |
| else |
| { |
| iTestDuration = iTestDuration * 1000 * 1000; |
| } |
| |
| } |
| |
| { |
| |
| PVMIOControlComp MIOComp(iMediaInputType, (OsclAny*)iFileParser, iLoopTime); |
| |
| if (iLoopTime) |
| { |
| |
| iTestDuration = TEST_TIMEOUT_FACTOR * iLoopTime ; //timeout duration in microsec |
| if (iTestDuration > KAuthoringSessionUnit) |
| { |
| //if test duration, in microsec, is too large, the uint32 |
| //variable will rollover. Hence the test run is divided |
| //in small sessions of KAuthoringSessionUnit duration |
| iAuthoringCount = iTestDuration / KAuthoringSessionUnit; |
| iTestDuration = KAuthoringSessionUnit * 1000 * 1000; //in microsec |
| } |
| else |
| { |
| iTestDuration = iTestDuration * 1000 * 1000; |
| } |
| |
| } |
| |
| status = MIOComp.CreateMIOInputNode(iRealTimeAuthoring, iMediaInputType, iInputFileName); |
| if (status != PVMFSuccess) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, |
| (0, "pv_mediainput_async_test_opencomposestop::CreateTestInputs: Error - CreateMIOInputNode failed")); |
| |
| goto ERROR_CODE; |
| |
| } |
| |
| iMIOComponent = MIOComp; |
| if (!AddDataSource()) |
| { |
| |
| //delete any MIO Comp created. |
| MIOComp.DeleteInputNode(); |
| goto ERROR_CODE; |
| |
| } |
| |
| return true; |
| |
| } |
| |
| |
| ERROR_CODE: |
| { |
| //remove file parser |
| if (iMediaInputType == PVMF_MIME_AVIFF) |
| { |
| PVAviFile* fileparser = OSCL_STATIC_CAST(PVAviFile*, iFileParser); |
| PVAviFile::DeleteAviFileParser(fileparser); |
| fileparser = NULL; |
| iFileParser = NULL; |
| } |
| else if (iMediaInputType == PVMF_MIME_WAVFF) |
| { |
| PV_Wav_Parser* fileparser = OSCL_STATIC_CAST(PV_Wav_Parser*, iFileParser); |
| delete(fileparser); |
| fileparser = NULL; |
| iFileParser = NULL; |
| } |
| |
| return false; |
| } |
| |
| |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| bool pv_mediainput_async_test_opencomposestop::AddDataSource() |
| { |
| int32 err = 0; |
| uint32 noOfNodes = iMIOComponent.iMIONode.size(); |
| |
| OSCL_TRY(err, |
| for (uint32 ii = 0; ii < noOfNodes; ii++) |
| { |
| AddEngineCommand(); |
| |
| iAuthor->AddDataSource(*(iMIOComponent.iMIONode[ii]), (OsclAny*)iAuthor); |
| } |
| ); |
| |
| if (err != OSCL_ERR_NONE) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, |
| (0, "pvauthor_async_test_miscellaneous::AddDataSource: Error - iAuthor->AddDataSource failed. err=0x%x", err)); |
| |
| iMIOComponent.DeleteInputNode(); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| bool pv_mediainput_async_test_opencomposestop::ConfigComposer() |
| { |
| if (!ConfigOutputFile()) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_ERR, |
| (0, "pv_mediainput_async_test_opencomposestop::ConfigComposer: Error - ConfigOutputFile failed")); |
| |
| return false; |
| } |
| |
| if ((oscl_strstr(iComposerMimeType.get_str(), "mp4")) || (oscl_strstr(iComposerMimeType.get_str(), "3gp"))) |
| { |
| if (!ConfigMp43gpComposer()) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_ERR, |
| (0, "pv_mediainput_async_test_opencomposestop::ConfigComposer: Error - ConfigMp43gpComposer failed")); |
| |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| bool pv_mediainput_async_test_opencomposestop::ConfigOutputFile() |
| { |
| |
| PvmfFileOutputNodeConfigInterface* clipConfig = OSCL_STATIC_CAST(PvmfFileOutputNodeConfigInterface*, iComposerConfig); |
| if (!clipConfig) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_ERR, |
| (0, "pv_mediainput_async_test_opencomposestop::ConfigAmrComposer: Error - Invalid iComposerConfig")); |
| |
| return false; |
| } |
| |
| if (!iUseExtrnFileDesc) |
| { |
| if (clipConfig->SetOutputFileName(iOutputFileName) != PVMFSuccess) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_ERR, |
| (0, "pv_mediainput_async_test_opencomposestop::ConfigAmrComposer: Error - SetOutputFileName failed")); |
| |
| return false; |
| } |
| } |
| else |
| { |
| char* fname[ARRAY_SIZE]; |
| oscl_UnicodeToUTF8(iOutputFileName.get_str(), iOutputFileName.get_size(), (char*)fname, ARRAY_SIZE); |
| |
| FILE *fp = fopen((char*)fname, "w+b"); |
| if (fp) |
| { |
| iFileHandle = OSCL_NEW(OsclFileHandle, (fp)); |
| if (clipConfig->SetOutputFileDescriptor(iFileHandle) != PVMFSuccess) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_ERR, |
| (0, "pv_mediainput_async_test_opencomposestop::ConfigAmrComposer: Error - SetOutputFileName failed")); |
| |
| return false; |
| } |
| } |
| |
| } |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| bool pv_mediainput_async_test_opencomposestop::ConfigMp43gpComposer() |
| { |
| |
| PVMp4FFCNClipConfigInterface* clipConfig; |
| clipConfig = OSCL_STATIC_CAST(PVMp4FFCNClipConfigInterface*, iComposerConfig); |
| if (!clipConfig) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_ERR, |
| (0, "pv_mediainput_async_test_opencomposestop::ConfigMp43gpComposer: Error - iComposerConfig==NULL")); |
| |
| return false; |
| } |
| PvmfAssetInfo3GPPLocationStruct aLocation_info; |
| |
| OSCL_wHeapString<OsclMemAllocator> versionString = _STRLIT("Latest Version"); |
| OSCL_wHeapString<OsclMemAllocator> titleString = _STRLIT("This is the test title"); |
| OSCL_wHeapString<OsclMemAllocator> authorString = _STRLIT("Unknown"); |
| OSCL_wHeapString<OsclMemAllocator> copyrightString = _STRLIT("PV Copyright"); |
| OSCL_wHeapString<OsclMemAllocator> descriptionString = _STRLIT("New Song"); |
| OSCL_wHeapString<OsclMemAllocator> ratingString = _STRLIT("Five"); |
| OSCL_wHeapString<OsclMemAllocator> performerString = _STRLIT("Performer"); |
| OSCL_wHeapString<OsclMemAllocator> genreString = _STRLIT("Rock"); |
| OSCL_wHeapString<OsclMemAllocator> classificationInfoString = _STRLIT("Rock Music"); |
| OSCL_wHeapString<OsclMemAllocator> keyWordInfoString1 = _STRLIT("One"); |
| OSCL_wHeapString<OsclMemAllocator> keyWordInfoString2 = _STRLIT("Two"); |
| OSCL_wHeapString<OsclMemAllocator> keyWordInfoString3 = _STRLIT("Three"); |
| OSCL_wHeapString<OsclMemAllocator> location_name = _STRLIT("PV"); |
| OSCL_wHeapString<OsclMemAllocator> astronomical_body = _STRLIT("PV"); |
| OSCL_wHeapString<OsclMemAllocator> additional_notes = _STRLIT("PV"); |
| OSCL_wHeapString<OsclMemAllocator> iAlbumTitle = _STRLIT("albumtitle"); |
| uint16 iRecordingYear = 2008; |
| |
| OSCL_HeapString<OsclMemAllocator> lang_code = "eng"; |
| |
| aLocation_info._location_name = NULL; |
| uint32 size = location_name.get_size(); |
| aLocation_info._location_name = (oscl_wchar *)oscl_malloc(sizeof(oscl_wchar) * size + 10); |
| oscl_strncpy(aLocation_info._location_name, location_name.get_cstr(), size); |
| aLocation_info._location_name[size+1] = 0; |
| |
| size = astronomical_body.get_size(); |
| aLocation_info._astronomical_body = NULL; |
| aLocation_info._astronomical_body = (oscl_wchar *)oscl_malloc(sizeof(oscl_wchar) * size + 10); |
| oscl_strncpy(aLocation_info._astronomical_body, astronomical_body.get_cstr(), size); |
| aLocation_info._astronomical_body[size+1] = 0; |
| |
| |
| size = additional_notes.get_size(); |
| aLocation_info._additional_notes = NULL; |
| aLocation_info._additional_notes = (oscl_wchar *)oscl_malloc(sizeof(oscl_wchar) * size + 10); |
| oscl_strncpy(aLocation_info._additional_notes, additional_notes.get_cstr(), size); |
| aLocation_info._additional_notes[size+1] = 0; |
| |
| aLocation_info._role = 2; |
| aLocation_info._longitude = 0; |
| aLocation_info._latitude = 0; |
| aLocation_info._altitude = 0; |
| aLocation_info.Lang_code = lang_code; |
| |
| |
| uint32 classificationEntity = 0; |
| uint16 classificationTable = 0; |
| |
| clipConfig->SetOutputFileName(iOutputFileName); |
| clipConfig->SetPresentationTimescale(1000); |
| clipConfig->SetVersion(versionString, lang_code); |
| clipConfig->SetTitle(titleString, lang_code); |
| clipConfig->SetAuthor(authorString, lang_code); |
| clipConfig->SetCopyright(copyrightString, lang_code); |
| clipConfig->SetDescription(descriptionString, lang_code); |
| clipConfig->SetRating(ratingString, lang_code); |
| clipConfig->SetPerformer(performerString, lang_code); |
| clipConfig->SetGenre(genreString, lang_code); |
| clipConfig->SetClassification(classificationInfoString, classificationEntity, classificationTable, lang_code); |
| clipConfig->SetKeyWord(keyWordInfoString1, lang_code); |
| clipConfig->SetKeyWord(keyWordInfoString2, lang_code); |
| clipConfig->SetKeyWord(keyWordInfoString3, lang_code); |
| |
| |
| clipConfig->SetLocationInfo(aLocation_info); |
| |
| |
| clipConfig->SetAlbumInfo(iAlbumTitle, lang_code); |
| |
| |
| clipConfig->SetRecordingYear(iRecordingYear); |
| |
| if (iTestCaseNum == K3GPPDownloadModeTest || iTestCaseNum == K3GPPDownloadModeLongetivityTest) |
| { |
| clipConfig->SetAuthoringMode(PVMP4FFCN_3GPP_DOWNLOAD_MODE); |
| } |
| else if (iTestCaseNum == K3GPPProgressiveDownloadModeTest || iTestCaseNum == K3GPPProgressiveDownloadModeLongetivityTest) |
| { |
| clipConfig->SetAuthoringMode(PVMP4FFCN_3GPP_PROGRESSIVE_DOWNLOAD_MODE); |
| } |
| else if (iTestCaseNum == KMovieFragmentModeTest || iTestCaseNum == KMovieFragmentModeLongetivityTest) |
| { |
| clipConfig->SetAuthoringMode(PVMP4FFCN_MOVIE_FRAGMENT_MODE); |
| } |
| |
| |
| |
| |
| if (aLocation_info._location_name != NULL) |
| OSCL_FREE(aLocation_info._location_name); |
| |
| if (aLocation_info._astronomical_body != NULL) |
| OSCL_FREE(aLocation_info._astronomical_body); |
| |
| if (aLocation_info._additional_notes != NULL) |
| OSCL_FREE(aLocation_info._additional_notes); |
| |
| |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| bool pv_mediainput_async_test_opencomposestop::AddMediaTrack() |
| { |
| PVMIOControlComp MIOComp; |
| |
| if (iAddAudioMediaTrack) |
| { |
| if (iMediaInputType == PVMF_MIME_AVIFF) |
| { |
| Oscl_Vector<uint32, OsclMemAllocator> audioStrNum; |
| |
| audioStrNum = (iMIOComponent.iPVAviFile)->GetAudioStreamCountList(); |
| |
| if (audioStrNum.size() == 0) |
| { |
| return false; |
| } |
| |
| iAuthor->AddMediaTrack(*(iMIOComponent.iMIONode[audioStrNum[0]]), iAudioEncoderMimeType, |
| iComposer, iAudioEncoderConfig, (OsclAny*)iAuthor); |
| |
| AddEngineCommand(); |
| |
| } |
| else if (iMediaInputType == PVMF_MIME_WAVFF) |
| { |
| PVWAVFileInfo wavFileInfo; |
| (iMIOComponent.iPVWavFile)->RetrieveFileInfo(wavFileInfo); |
| |
| |
| iAuthor->AddMediaTrack(*(iMIOComponent.iMIONode[0]), iAudioEncoderMimeType, |
| iComposer, iAudioEncoderConfig, (OsclAny*)iAuthor); |
| |
| AddEngineCommand(); |
| |
| |
| } |
| |
| |
| } |
| |
| if (iAddVideoMediaTrack) |
| { |
| if (iMediaInputType == PVMF_MIME_AVIFF) |
| { |
| Oscl_Vector<uint32, OsclMemAllocator> vidStrNum; |
| vidStrNum = (iMIOComponent.iPVAviFile)->GetVideoStreamCountList(); |
| |
| if (vidStrNum.size() == 0) |
| { |
| return false; |
| } |
| |
| iAuthor->AddMediaTrack(*(iMIOComponent.iMIONode[vidStrNum[0]]), iVideoEncoderMimeType, |
| iComposer, iVideoEncoderConfig, (OsclAny*)iAuthor); |
| |
| AddEngineCommand(); |
| |
| } |
| else if (iMediaInputType == PVMF_MIME_WAVFF) |
| { |
| return false; |
| } |
| |
| } |
| |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| bool pv_mediainput_async_test_opencomposestop::ConfigureVideoEncoder() |
| { |
| |
| PVMp4H263EncExtensionInterface* config; |
| config = OSCL_STATIC_CAST(PVMp4H263EncExtensionInterface*, iVideoEncoderConfig); |
| if (!config) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, |
| (0, "pv_mediainput_async_test_opencomposestop::ConfigureVideoEncoder: No configuration needed")); |
| |
| return true; |
| } |
| |
| uint32 width = 0; |
| uint32 height = 0; |
| OsclFloat frameRate = 0.0; |
| uint32 frameInterval = 0; |
| |
| if (iMediaInputType == PVMF_MIME_AVIFF) |
| { |
| Oscl_Vector<uint32, OsclMemAllocator> vidStrNum = |
| (iMIOComponent.iPVAviFile)->GetVideoStreamCountList(); |
| |
| width = (iMIOComponent.iPVAviFile)->GetWidth(vidStrNum[0]); |
| bool orient = false; |
| height = (iMIOComponent.iPVAviFile)->GetHeight(orient, vidStrNum[0]); |
| frameRate = (iMIOComponent.iPVAviFile)->GetFrameRate(vidStrNum[0]); |
| frameInterval = (iMIOComponent.iPVAviFile)->GetFrameDuration(); |
| } |
| |
| //setting the width and height |
| config->SetOutputFrameSize(0, width , height); |
| |
| //setting video bitrate |
| if (0 == iVideoBitrate) |
| { |
| config->SetOutputBitRate(0, KVideoBitrate); |
| } |
| else |
| { |
| config->SetOutputBitRate(0, iVideoBitrate);//values from config file |
| } |
| |
| config->SetOutputFrameRate(0, frameRate); |
| config->SetNumLayers(KNumLayers); |
| config->SetIFrameInterval(KVideoIFrameInterval); |
| config->SetSceneDetection(true); |
| |
| return true; |
| } |
| |
| bool pv_mediainput_async_test_opencomposestop::ConfigureAudioEncoder() |
| { |
| |
| PVAudioEncExtensionInterface* config; |
| config = OSCL_STATIC_CAST(PVAudioEncExtensionInterface*, iAudioEncoderConfig); |
| if (!config) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, |
| (0, "pv_mediainput_async_test_opencomposestop::Encoder: No configuration needed")); |
| |
| return true; |
| } |
| |
| if (!PVAETestNodeConfig::ConfigureAudioEncoder(iAudioEncoderConfig, iAudioEncoderMimeType, iAudioBitrate)) |
| { |
| return false; |
| } |
| return true; |
| } |
| //////////////////////////////////////////////////////////////////////////// |
| void pv_mediainput_async_test_opencomposestop::ResetAuthorConfig() |
| { |
| if (iComposerConfig) |
| { |
| iComposerConfig->removeRef(); |
| iComposerConfig = NULL; |
| } |
| if (iAudioEncoderConfig) |
| { |
| iAudioEncoderConfig->removeRef(); |
| iAudioEncoderConfig = NULL; |
| } |
| if (iVideoEncoderConfig) |
| { |
| iVideoEncoderConfig->removeRef(); |
| iVideoEncoderConfig = NULL; |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| void pv_mediainput_async_test_opencomposestop::Cleanup() |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, (0, "pv_mediainput_async_test_opencomposestop::Cleanup")); |
| |
| iComposer = NULL; |
| |
| ResetAuthorConfig(); |
| if (iAuthor) |
| { |
| PVAuthorEngineFactory::DeleteAuthor(iAuthor); |
| iAuthor = NULL; |
| } |
| |
| // iMIOComponent.DeleteInputNode(); |
| iOutputFileName = NULL; |
| iFileServer.Close(); |
| if (iFileHandle) |
| { |
| OSCL_DELETE(iFileHandle); |
| iFileHandle = NULL; |
| } |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////// |
| void pv_mediainput_async_test_opencomposestop::Run() |
| { |
| if (IsEngineCmdPending()) |
| { |
| return; |
| } |
| |
| switch (iState) |
| { |
| case PVAE_CMD_CREATE: |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_DEBUG, |
| (0, "******pv_mediainput_async_test_opencomposestop::iTestCaseNum:%d******", iTestCaseNum)); |
| fprintf(iFile, "Creating Author Engine \n"); |
| |
| iAuthor = PVAuthorEngineFactory::CreateAuthor(this, this, this); |
| if (!iAuthor) |
| { |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_CLEANUPANDCOMPLETE; |
| RunIfNotReady(); |
| |
| } |
| else |
| { |
| iState = PVAE_CMD_OPEN; |
| RunIfNotReady(); |
| } |
| } |
| break; |
| |
| case PVAE_CMD_OPEN: |
| { |
| fprintf(iFile, "Opening Author Engine\n"); |
| iAuthor->Open((OsclAny*)iAuthor); |
| } |
| break; |
| |
| case PVAE_CMD_ADD_DATA_SOURCE: |
| { |
| fprintf(iFile, "Add Data Source\n"); |
| bool aStatus = CreateTestInputs(); |
| if (aStatus == 0) //Failed while creating test input |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, |
| (0, "pv_mediainput_async_test_opencomposestop::CreateTestInputs: Error - failed")); |
| |
| PVPATB_TEST_IS_TRUE(false); |
| |
| iState = PVAE_CMD_CLEANUPANDCOMPLETE; |
| |
| RunIfNotReady(); |
| } |
| |
| } |
| break; |
| |
| case PVAE_CMD_SELECT_COMPOSER: |
| { |
| fprintf(iFile, "Select Composer\n"); |
| iAuthor->SelectComposer(iComposerMimeType, iComposerConfig, |
| (OsclAny*)iAuthor); |
| } |
| break; |
| |
| case PVAE_CMD_QUERY_INTERFACE: |
| |
| fprintf(iFile, "Query Interface\n"); |
| |
| if (!QueryComposerOutputInterface()) |
| { |
| iState = PVAE_CMD_ADD_MEDIA_TRACK; |
| RunIfNotReady(); |
| } |
| break; |
| |
| case PVAE_CMD_ADD_MEDIA_TRACK: |
| { |
| fprintf(iFile, "Add Media Track\n"); |
| if (!AddMediaTrack()) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, |
| (0, "pv_mediainput_async_test_opencomposestop::AddMediaTrack Error - No track added")); |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_REMOVE_DATA_SOURCE; |
| RunIfNotReady(); |
| } |
| } |
| break; |
| |
| case PVAE_CMD_INIT: |
| { |
| fprintf(iFile, "Initializing Author Engine\n"); |
| iAuthor->Init((OsclAny*)iAuthor); |
| } |
| break; |
| |
| case PVAE_CMD_START: |
| { |
| fprintf(iFile, "Starting Author Engine\n"); |
| iAuthor->Start(); |
| } |
| break; |
| |
| case PVAE_CMD_STOP: |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, |
| (0, "pv_mediainput_async_test_opencomposestop::Run: Command Stop")); |
| |
| fprintf(iFile, "Error: Recording timeout, stop engine please wait *******\n"); |
| iAuthor->Stop((OsclAny*)iAuthor); |
| |
| //flag error as no EOS was found and recording timedout |
| PVPATB_TEST_IS_TRUE(false); |
| |
| } |
| break; |
| |
| case PVAE_CMD_RESET: |
| { |
| ResetAuthorConfig(); |
| if (iAuthor->GetPVAuthorState() != PVAE_STATE_IDLE) |
| { |
| iAuthor->Reset((OsclAny*)iAuthor); |
| } |
| } |
| break; |
| |
| case PVAE_CMD_REMOVE_DATA_SOURCE: |
| { |
| for (uint32 ii = 0; ii < iMIOComponent.iMIONode.size(); ii++) |
| { |
| iAuthor->RemoveDataSource(*(iMIOComponent.iMIONode[ii]), (OsclAny*)iAuthor); |
| AddEngineCommand(); |
| } |
| } |
| break; |
| |
| case PVAE_CMD_CLOSE: |
| { |
| iAuthor->Close((OsclAny*)iAuthor); |
| } |
| break; |
| |
| case PVAE_CMD_PAUSE: |
| { |
| fprintf(iFile, "Pause Initiated ********\n"); |
| iAuthor->Pause((OsclAny*)iAuthor); |
| } |
| break; |
| |
| case PVAE_CMD_RESUME: |
| { |
| fprintf(iFile, "Resume Athoring *******\n"); |
| iAuthor->Resume((OsclAny*)iAuthor); |
| } |
| break; |
| |
| case PVAE_CMD_QUERY_INTERFACE2: |
| fprintf(iFile, "Query Interface2\n"); |
| iAuthor->QueryInterface(PVMI_CAPABILITY_AND_CONFIG_PVUUID, (PVInterface*&)iAuthorCapConfigIF, (OsclAny*)iAuthor); |
| break; |
| case PVAE_CMD_CAPCONFIG_ASYNC: |
| { |
| fprintf(iFile, "Cap Config ASync\n"); |
| CapConfigAsync(); |
| |
| } |
| break; |
| |
| case PVAE_CMD_CAPCONFIG_SYNC: |
| // set configuration MIME strings Synchronously |
| { |
| fprintf(iFile, "Cap Config Sync\n"); |
| |
| if (!CapConfigSync()) //CapConfig failed |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, |
| (0, "pv_mediainput_async_test_opencomposestop::Run: Error - CapConfigSync failed")); |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_CLEANUPANDCOMPLETE; |
| RunIfNotReady(); |
| } |
| else |
| { |
| iState = PVAE_CMD_START; |
| RunIfNotReady(); |
| } |
| } |
| break; |
| |
| case PVAE_CMD_CLEANUPANDCOMPLETE: |
| { |
| Cleanup(); |
| iObserver->CompleteTest(*iTestCase); |
| } |
| break; |
| |
| case PVAE_CMD_ADD_DATA_SINK: |
| case PVAE_CMD_REMOVE_DATA_SINK: |
| break; |
| |
| case PVAE_CMD_RECORDING: |
| { |
| fprintf(iFile, "Recording Please Wait*******\n"); |
| if (!iAuthoringCount) |
| { |
| iState = PVAE_CMD_STOP; |
| RunIfNotReady(iTestDuration); |
| } |
| else |
| { |
| iState = PVAE_CMD_RECORDING; |
| RunIfNotReady(iTestDuration); |
| iAuthoringCount--; |
| } |
| } |
| break; |
| |
| default: |
| break; |
| } //end switch |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| void pv_mediainput_async_test_opencomposestop::CommandCompleted(const PVCmdResponse& aResponse) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, |
| (0, "pv_mediainput_async_test_opencomposestop::CommandCompleted iState:%d", iState)); |
| |
| |
| if (aResponse.GetCmdStatus() != PVMFSuccess) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_LLDBG, iLogger, PVLOGMSG_STACK_TRACE, |
| (0, "pv_mediainput_async_test_opencomposestop::CommandCompleted iState:%d FAILED", iState)); |
| } |
| |
| switch (iState) |
| { |
| case PVAE_CMD_OPEN: |
| { |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| iState = PVAE_CMD_ADD_DATA_SOURCE; |
| RunIfNotReady(); |
| } |
| else |
| { |
| // Open failed |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_RESET; |
| RunIfNotReady(); |
| } |
| } |
| break; |
| |
| case PVAE_CMD_ADD_DATA_SOURCE: |
| { |
| if (EngineCmdComplete()) |
| { |
| iState = PVAE_CMD_SELECT_COMPOSER; |
| } |
| |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| RunIfNotReady(); |
| } |
| else |
| { |
| // AddDataSource failed |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_RESET; |
| RunIfNotReady(); |
| } |
| } |
| break; |
| |
| case PVAE_CMD_SELECT_COMPOSER: |
| { |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| iComposer = aResponse.GetResponseData(); |
| if (!ConfigComposer()) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, |
| (0, "pv_mediainput_async_test_opencomposestop::CommandCompleted: Error - ConfigComposer failed")); |
| |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_RESET; |
| RunIfNotReady(); |
| return; |
| } |
| else |
| { |
| iState = PVAE_CMD_QUERY_INTERFACE; |
| RunIfNotReady(); |
| } |
| } |
| else |
| { |
| // SelectComposer failed |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_RESET; |
| RunIfNotReady(); |
| } |
| |
| } |
| break; |
| case PVAE_CMD_QUERY_INTERFACE: |
| { |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| ConfigComposerOutput(); |
| iState = PVAE_CMD_ADD_MEDIA_TRACK; |
| RunIfNotReady(); |
| } |
| else |
| { |
| // QueryInterface failed |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_RESET; |
| RunIfNotReady(); |
| } |
| } |
| break; |
| case PVAE_CMD_ADD_MEDIA_TRACK: |
| { |
| if (EngineCmdComplete()) |
| { |
| if (iAddVideoMediaTrack) |
| { |
| ConfigureVideoEncoder(); |
| } |
| |
| if (iAddAudioMediaTrack) |
| { |
| ConfigureAudioEncoder(); |
| } |
| |
| iState = PVAE_CMD_QUERY_INTERFACE2; |
| } |
| |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| RunIfNotReady(); |
| } |
| else |
| { |
| // AddMediaTrack failed |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_RESET; |
| RunIfNotReady(); |
| } |
| } |
| break; |
| case PVAE_CMD_QUERY_INTERFACE2: |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| iState = PVAE_CMD_INIT; |
| RunIfNotReady(); |
| } |
| else |
| { |
| // QueryInterface2 failed |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_RESET; |
| RunIfNotReady(); |
| } |
| break; |
| |
| case PVAE_CMD_INIT: |
| { |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| if (iTestCaseNum == CapConfigTest) |
| { |
| iState = PVAE_CMD_CAPCONFIG_ASYNC; |
| } |
| else |
| { |
| iState = PVAE_CMD_START; |
| } |
| RunIfNotReady(); |
| } |
| else |
| { |
| // Init failed |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_RESET; |
| RunIfNotReady(); |
| } |
| } |
| break; |
| case PVAE_CMD_CAPCONFIG_ASYNC: |
| { |
| |
| if (aResponse.GetCmdStatus() != PVMFSuccess) |
| { |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, |
| (0, "pv_mediainput_async_test_opencomposestop::Run: Error - CapConfigAsync failed")); |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_CLEANUPANDCOMPLETE; |
| RunIfNotReady(); |
| } |
| else |
| { |
| PVPATB_TEST_IS_TRUE(true); |
| iState = PVAE_CMD_START; |
| RunIfNotReady(); |
| } |
| } |
| break; |
| |
| case PVAE_CMD_START: |
| { |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| if (iPauseResumeEnable) |
| { |
| iState = PVAE_CMD_PAUSE; |
| RunIfNotReady(KPauseDuration); //Pause after 5 sec |
| } |
| else |
| { |
| iState = PVAE_CMD_RECORDING; |
| RunIfNotReady(); |
| } |
| } |
| else |
| { |
| // Start failed |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_RESET; |
| RunIfNotReady(); |
| } |
| } |
| break; |
| |
| case PVAE_CMD_PAUSE: |
| { |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| fprintf(iFile, "PAUSED: Resume after 10 seconds*******\n"); |
| iState = PVAE_CMD_RESUME; |
| /* Stay paused for 10 seconds */ |
| RunIfNotReady(10*1000*1000); |
| } |
| else |
| { |
| //Pause failed |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_RESET; |
| RunIfNotReady(); |
| } |
| } |
| break; |
| |
| case PVAE_CMD_RESUME: |
| { |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| iState = PVAE_CMD_RECORDING; |
| |
| //Start Authoring again |
| RunIfNotReady(); |
| } |
| else |
| { |
| //Resume failed |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_RESET; |
| RunIfNotReady(); |
| } |
| } |
| break; |
| |
| case PVAE_CMD_STOP: |
| { |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| iOutputFileName = NULL; |
| iState = PVAE_CMD_RESET; |
| RunIfNotReady(); |
| } |
| else |
| { |
| // Stop failed |
| PVPATB_TEST_IS_TRUE(false); |
| iState = PVAE_CMD_RESET; |
| RunIfNotReady(); |
| } |
| } |
| break; |
| |
| case PVAE_CMD_RESET: |
| { |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| if ((iMIOComponent.iMediaInput.size() == 0) || (iMIOComponent.iMIONode.size() == 0)) |
| { |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| PVPATB_TEST_IS_TRUE(true); |
| } |
| else |
| { |
| PVPATB_TEST_IS_TRUE(false); |
| } |
| //Since there are no MIO Components/Nodes, we end here |
| //No need to call RemoveDataSource |
| iObserver->CompleteTest(*iTestCase); |
| break; |
| } |
| |
| iState = PVAE_CMD_REMOVE_DATA_SOURCE; |
| RunIfNotReady(); |
| } |
| else |
| { |
| // Reset failed |
| PVPATB_TEST_IS_TRUE(false); |
| OSCL_ASSERT("ERROR -- Response failure for CMD_RESET"); |
| iObserver->CompleteTest(*iTestCase); |
| } |
| } |
| break; |
| |
| case PVAE_CMD_REMOVE_DATA_SOURCE: |
| { |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| if (EngineCmdComplete()) |
| { |
| iOutputFileName = NULL; |
| iMIOComponent.DeleteInputNode(); |
| if (iMediaInputType == PVMF_MIME_AVIFF) |
| { |
| PVAviFile* fileparser = OSCL_STATIC_CAST(PVAviFile*, iFileParser); |
| PVAviFile::DeleteAviFileParser(fileparser); |
| fileparser = NULL; |
| iFileParser = NULL; |
| } |
| else if (iMediaInputType == PVMF_MIME_WAVFF) |
| { |
| PV_Wav_Parser* fileparser = OSCL_STATIC_CAST(PV_Wav_Parser*, iFileParser); |
| delete(fileparser); |
| fileparser = NULL; |
| iFileParser = NULL; |
| } |
| |
| iFileParser = NULL; |
| iState = PVAE_CMD_CLOSE; |
| RunIfNotReady(); |
| |
| } |
| else |
| { |
| return; //wait for completion of all RemoveDataSource calls. |
| } |
| } |
| else |
| { |
| // RemoveDataSource failed |
| PVPATB_TEST_IS_TRUE(false); |
| iObserver->CompleteTest(*iTestCase); |
| } |
| } |
| break; |
| |
| case PVAE_CMD_CLOSE: |
| { |
| if (aResponse.GetCmdStatus() == PVMFSuccess) |
| { |
| PVPATB_TEST_IS_TRUE(true); |
| } |
| else |
| { |
| PVPATB_TEST_IS_TRUE(false); |
| } |
| iObserver->CompleteTest(*iTestCase); |
| } |
| break; |
| |
| default: |
| { |
| // Testing error if this is reached |
| PVPATB_TEST_IS_TRUE(false); |
| iObserver->CompleteTest(*iTestCase); |
| } |
| break; |
| } //end switch |
| } |
| |
| bool pv_mediainput_async_test_opencomposestop::ConfigComposerOutput() |
| { |
| PvmfComposerSizeAndDurationInterface* config = |
| OSCL_REINTERPRET_CAST(PvmfComposerSizeAndDurationInterface*, iOutputSizeAndDurationConfig); |
| if (!config) |
| { |
| return false; |
| } |
| bool enabled = false; |
| uint32 configData = 0; |
| switch (iTestCaseNum) |
| { |
| case KMaxFileSizeTest: |
| case KMaxFileSizeLongetivityTest: |
| { |
| if (config->SetMaxFileSize(true, KMaxFileSize) != PVMFSuccess) |
| { |
| return false; |
| } |
| config->GetMaxFileSizeConfig(enabled, configData); |
| if (!enabled || configData != KMaxFileSize) |
| { |
| return false; |
| } |
| } |
| break; |
| |
| case PVMediaInput_Open_Compose_Stop_Test: |
| case PVMediaInput_Open_Compose_Stop_Test_UsingExternalFileHandle: |
| { |
| if (config->SetFileSizeProgressReport(true, KFileSizeProgressFreq) != PVMFSuccess) |
| { |
| return false; |
| } |
| config->GetFileSizeProgressReportConfig(enabled, configData); |
| if (!enabled || configData != KFileSizeProgressFreq) |
| { |
| return false; |
| } |
| if (config->SetDurationProgressReport(true, KDurationProgressFreq) != PVMFSuccess) |
| { |
| return false; |
| } |
| config->GetDurationProgressReportConfig(enabled, configData); |
| if (!enabled || configData != KDurationProgressFreq) |
| { |
| return false; |
| } |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| return true; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| bool pv_mediainput_async_test_opencomposestop::QueryComposerOutputInterface() |
| { |
| switch (iTestCaseNum) |
| { |
| case PVMediaInput_Open_Compose_Stop_Test: |
| case PVMediaInput_Open_Compose_Stop_Test_UsingExternalFileHandle: |
| case KMaxFileSizeTest: |
| { |
| //iPendingCmds.push_back(PVAE_CMD_QUERY_INTERFACE); |
| iAuthor->QueryInterface(PvmfComposerSizeAndDurationUuid, |
| iOutputSizeAndDurationConfig, (OsclAny*)iAuthor); |
| return true; |
| } |
| break; |
| default: |
| return false; |
| } |
| |
| return false; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // function for setting configuration MIME strings Asynchronously |
| |
| bool pv_mediainput_async_test_opencomposestop::CapConfigAsync() |
| { |
| if (iTestCaseNum == CapConfigTest) |
| { |
| // Set the observer |
| iAuthorCapConfigIF->setObserver(this); |
| |
| iKeyStringSetAsync = _STRLIT_CHAR("x-pvmf/author/productinfo/dummyprod1;valtype=int32"); |
| iKVPSetAsync.key = iKeyStringSetAsync.get_str(); |
| iKVPSetAsync.value.int32_value = 2; |
| |
| // set the parameter |
| iErrorKVP = NULL; |
| iAuthorCapConfigIF->setParametersAsync(NULL, &iKVPSetAsync, 1, iErrorKVP); |
| |
| return true; |
| } |
| else |
| { |
| return false; |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // function for setting configuration MIME strings Synchronously |
| |
| bool pv_mediainput_async_test_opencomposestop::CapConfigSync() |
| { |
| if (iTestCaseNum == CapConfigTest) |
| { |
| // set the mime strings here |
| // capabilty and configuration feature implemented here |
| // set the config parameters using MIME strings here |
| |
| // set the KVP array |
| PvmiKvp paramkvp1; |
| // set cache size for composer node |
| // PVMI_FILEIO_PV_CACHE_SIZE (MACRO defined in "pvmi_fileio_kvp.h") |
| OSCL_StackString<64> paramkey1(_STRLIT_CHAR(PVMI_FILEIO_PV_CACHE_SIZE)); |
| paramkey1 += _STRLIT_CHAR(";valtype=uint32"); |
| // set KVP values |
| // for composer node |
| paramkvp1.key = paramkey1.get_str(); |
| paramkvp1.value.uint32_value = 1024; |
| |
| iErrorKVP = NULL; |
| |
| // verifyParametersSync will give Failure for test cases not using MP4 composer("fileio") node so commented |
| // Verify the new settings |
| //if (iAuthorCapConfigIF->verifyParametersSync(NULL, ¶mkvp1, 1) == PVMFSuccess) |
| { |
| // set the parameter |
| iAuthorCapConfigIF->setParametersSync(NULL, ¶mkvp1, 1, iErrorKVP); |
| if (iErrorKVP == NULL) |
| { |
| // Check by calling get |
| PvmiKvp* retparam = NULL; |
| int retnumparam = 0; |
| paramkey1 += _STRLIT_CHAR(";attr=cur"); |
| // pass the string |
| // retrieve a MIME string back |
| iAuthorCapConfigIF->getParametersSync(NULL, paramkey1.get_str(), retparam, retnumparam, NULL); |
| |
| if ((retparam != NULL) && (retnumparam == 1)) |
| { |
| // release the parameters |
| if (iAuthorCapConfigIF->releaseParameters(NULL, retparam, retnumparam) != PVMFSuccess) |
| { |
| return false; |
| } |
| } |
| } |
| } |
| /* |
| else |
| { |
| return false; |
| }*/ |
| |
| //MIME for file output node |
| // set here any parameter here |
| OSCL_StackString<64> paramkey2(_STRLIT_CHAR("x-pvmf/file/output/parameter1;valtype=uint32")); |
| |
| // for file output node |
| paramkvp1.key = paramkey2.get_str(); |
| paramkvp1.value.int32_value = 144; |
| |
| // set the value in node using SetParameterSync f(n) here |
| iAuthorCapConfigIF->setParametersSync(NULL, ¶mkvp1, 1, iErrorKVP); |
| |
| // MIME for media io node |
| // set parameters here |
| OSCL_StackString<64> paramkey3(_STRLIT_CHAR("x-pvmf/media-io/parameter1;valtype=uint32")); |
| |
| // for media io node |
| paramkvp1.key = paramkey3.get_str(); |
| paramkvp1.value.int32_value = 144; |
| |
| // set the value in node using SetParameterSync f(n) here |
| iAuthorCapConfigIF->setParametersSync(NULL, ¶mkvp1, 1, iErrorKVP); |
| |
| if (iErrorKVP == NULL) |
| { |
| // Check by calling get |
| PvmiKvp* retparam = NULL; |
| int retnumparam = 0; |
| paramkey3 += _STRLIT_CHAR(";attr=cur"); |
| // pass the string |
| // retrieve a MIME string back |
| iAuthorCapConfigIF->getParametersSync(NULL, paramkey3.get_str(), retparam, retnumparam, NULL); |
| if ((retparam != NULL) && (retnumparam == 1)) |
| { |
| // release the parameters |
| if (iAuthorCapConfigIF->releaseParameters(NULL, retparam, retnumparam) != PVMFSuccess) |
| { |
| return false; |
| } |
| } |
| } |
| |
| // MIME for amr encoder |
| // set the parameter here |
| |
| // MIME string here "x-pvmf/encoder/audio/sampling_rate;valtype=uint32" |
| OSCL_StackString<64> paramkey4(_STRLIT_CHAR(MOUT_AUDIO_SAMPLING_RATE_KEY)); |
| // MOUT_AUDIO_SAMPLING_RATE_KEY (MACRO defined in "pvmi_kvp.h") |
| // for amr encoder node |
| paramkvp1.key = paramkey4.get_str(); |
| paramkvp1.value.int32_value = 8000; |
| |
| // set the value in node using SetParameterSync f(n) here |
| iAuthorCapConfigIF->setParametersSync(NULL, ¶mkvp1, 1, iErrorKVP); |
| |
| if (iErrorKVP == NULL) |
| { |
| // Check by calling get |
| PvmiKvp* retparam = NULL; |
| int retnumparam = 0; |
| paramkey1 += _STRLIT_CHAR(";attr=cur"); |
| // pass the string |
| // retrieve a MIME string back |
| iAuthorCapConfigIF->getParametersSync(NULL, paramkey4.get_str(), retparam, retnumparam, NULL); |
| if ((retparam != NULL) && (retnumparam == 1)) |
| { |
| // release the parameters |
| if (iAuthorCapConfigIF->releaseParameters(NULL, retparam, retnumparam) != PVMFSuccess) |
| { |
| return false; |
| } |
| } |
| } |
| |
| |
| // MIME for video encoder |
| // set the parameter frame width in the node (use combinations for width n height default is 176 by 144) |
| |
| // MIME string here "x-pvmf/video/render/output_width;valtype=uint32" |
| OSCL_StackString<64> paramkey5(_STRLIT_CHAR(MOUT_VIDEO_OUTPUT_WIDTH_KEY)); |
| // MACRO "MOUT_VIDEO_OUTPUT_WIDTH_KEY" been defined in "pvmi_kvp.h" |
| // for video encoder node |
| paramkvp1.key = paramkey5.get_str(); |
| paramkvp1.value.uint32_value = 128; |
| // set the value in node using SetParameterSync f(n) here |
| iAuthorCapConfigIF->setParametersSync(NULL, ¶mkvp1, 1, iErrorKVP); |
| |
| if (iErrorKVP == NULL) |
| { |
| // Check by calling get |
| PvmiKvp* retparam = NULL; |
| int retnumparam = 0; |
| paramkey1 += _STRLIT_CHAR(";attr=cur"); |
| // pass the string |
| // retrieve a MIME string back |
| iAuthorCapConfigIF->getParametersSync(NULL, paramkey5.get_str(), retparam, retnumparam, NULL); |
| if ((retparam != NULL) && (retnumparam == 1)) |
| { |
| // release the parameters |
| if (iAuthorCapConfigIF->releaseParameters(NULL, retparam, retnumparam) != PVMFSuccess) |
| { |
| return false; |
| } |
| } |
| } |
| |
| // MIME for AVC Encoder |
| // set the parameter encoding mode |
| |
| // MIME string here "x-pvmf/avc/encoder/encoding_mode;valtype=uint32" |
| OSCL_StackString<64> paramkey6(_STRLIT_CHAR(PVMF_AVC_ENCODER_ENCODINGMODE_KEY)); |
| // MACRO "PVMF_AVC_ENCODER_ENCODINGMODE_KEY" been defined in "pvmi_kvp.h" |
| // for AVC Encoder node |
| paramkvp1.key = paramkey6.get_str(); |
| paramkvp1.value.uint32_value = 3;//EAVCEI_ENCMODE_TWOWAY; |
| // set the value in node using SetParameterSync f(n) here |
| iAuthorCapConfigIF->setParametersSync(NULL, ¶mkvp1, 1, iErrorKVP); |
| |
| if (iErrorKVP == NULL) |
| { |
| // Check by calling get |
| PvmiKvp* retparam = NULL; |
| int retnumparam = 0; |
| paramkey1 += _STRLIT_CHAR(";attr=cur"); |
| // pass the string |
| // retrieve a MIME string back |
| iAuthorCapConfigIF->getParametersSync(NULL, paramkey6.get_str(), retparam, retnumparam, NULL); |
| if ((retparam != NULL) && (retnumparam == 1)) |
| { |
| // release the parameters |
| if (iAuthorCapConfigIF->releaseParameters(NULL, retparam, retnumparam) != PVMFSuccess) |
| { |
| return false; |
| } |
| } |
| } |
| |
| return true; |
| } |
| else |
| { |
| return true; |
| } |
| |
| } |
| |
| void pv_mediainput_async_test_opencomposestop::SignalEvent(int32 aReq_Id) |
| { |
| if (aReq_Id == 0) //For PVAE_CMD_CAPCONFIG_SET_PARAMETERS |
| { |
| if (iErrorKVP != NULL) |
| { |
| // There was an error in setParameterAsync() |
| PVLOGGER_LOGMSG(PVLOGMSG_INST_REL, iLogger, PVLOGMSG_ERR, |
| (0, "pv_mediainput_async_test_opencomposestop::SignalEvent: setParametersAsync failed")); |
| PVPATB_TEST_IS_TRUE(false); |
| iObserver->CompleteTest(*iTestCase); |
| } |
| else |
| { |
| iState = PVAE_CMD_CAPCONFIG_SYNC; |
| RunIfNotReady(); |
| } |
| } |
| } |
| |
