00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016 #include "CMediaClientEngine.h"
00017
00018
00019 void ChangeExtension(const TFileName& aFile, const TDesC& aTargetType,
00020 TFileName& aTargetFile);
00021
00022
00023
00024
00025 CMediaClientEngine::CMediaClientEngine(RFs& aFs)
00026 : iFs(aFs),
00027 iState(CMediaClientEngine::EIdle),
00028 iVolume(CMediaClientEngine::EMedium)
00029 {
00030 }
00031
00032 CMediaClientEngine::~CMediaClientEngine()
00033 {
00034 iEngineObserver = 0;
00035 Stop();
00036 }
00037
00038
00039
00040
00041
00042 void CMediaClientEngine::SetObserver(MExEngineObserver& aObserver)
00043 {
00044 iEngineObserver = &aObserver;
00045 }
00046
00047
00048
00049 void CMediaClientEngine::Stop()
00050 {
00051
00052 switch (iState)
00053 {
00054 case ETonePrepare:
00055 iAudioToneUtility->CancelPrepare();
00056 ToneCleanup();
00057 break;
00058 case ETonePlaying:
00059 iAudioToneUtility->CancelPlay();
00060 ToneCleanup();
00061 break;
00062 case EPlayFilePrepare:
00063 PlayCleanup();
00064 break;
00065 case EPlayFilePlaying:
00066 iAudioPlayUtility->Stop();
00067 PlayCleanup();
00068 break;
00069 case ERecordPrepare:
00070 RecordCleanup();
00071 break;
00072 case ERecording:
00073 iAudioRecorderUtility -> Stop();
00074 RecordCleanup();
00075 break;
00076 case EConvert:
00077 ConvertCleanup();
00078 break;
00079 case EStreamPrepare:
00080 StreamCleanup();
00081 break;
00082 case EStreamStarted:
00083 case ENextStreamBuf:
00084 iAudioStreamPlayer -> Stop();
00085 iState = EStreamStopping;
00086 break;
00087 default:
00088 break;
00089 };
00090
00091 if (iEngineObserver)
00092 iEngineObserver -> HandleEngineState(iState,KErrNone);
00093 }
00094
00095
00096 CMediaClientEngine::TExVolume CMediaClientEngine::Volume() const
00097 {
00098 return iVolume;
00099 }
00100
00101
00102 void CMediaClientEngine::SetVolume(CMediaClientEngine::TExVolume aVolume)
00103 {
00104 iVolume = aVolume;
00105 if (iAudioStreamPlayer)
00106 {
00107 iAudioStreamPlayer -> SetVolume(iAudioStreamPlayer -> MaxVolume()/iVolume);
00108 }
00109 }
00110
00111
00112 CMediaClientEngine::TState CMediaClientEngine::Status() const
00113 {
00114 return iState;
00115 }
00116
00117
00118 void CMediaClientEngine::Panic(CMediaClientEngine::TPanics aPanic)
00119 {
00120 _LIT(KPanic,"MEDIA_AUDIO_EX");
00121 User::Panic(KPanic,aPanic);
00122 }
00123
00124
00125
00126
00127
00128
00129
00130 void CMediaClientEngine::PlayL(TInt aFrequency,
00131 const TTimeIntervalMicroSeconds& aDuration)
00132 {
00133 __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00134
00135 iAudioToneUtility = CMdaAudioToneUtility::NewL(*this);
00136 iState = ETonePrepare;
00137 iAudioToneUtility -> PrepareToPlayTone(aFrequency, aDuration);
00138
00139 }
00140
00141
00142
00143 void CMediaClientEngine::MatoPrepareComplete(TInt aError)
00144 {
00145 __ASSERT_DEBUG(iEngineObserver, Panic(CMediaClientEngine::ENullObserver));
00146 __ASSERT_DEBUG(iAudioToneUtility, Panic(CMediaClientEngine::ENullTonePlayer));
00147 __ASSERT_DEBUG(iState == ETonePrepare, Panic(CMediaClientEngine::EWrongState));
00148
00149
00150 if (aError)
00151 ToneCleanup();
00152 else
00153 {
00154 iState = ETonePlaying;
00155 iAudioToneUtility -> SetVolume(iAudioToneUtility -> MaxVolume()/iVolume);
00156 iAudioToneUtility -> Play();
00157 }
00158 iEngineObserver -> HandleEngineState(iState,aError);
00159 }
00160
00161
00162
00163 void CMediaClientEngine::MatoPlayComplete(TInt aError)
00164 {
00165 __ASSERT_DEBUG(iState == ETonePlaying, Panic(CMediaClientEngine::ENotReady));
00166 __ASSERT_DEBUG(iEngineObserver, Panic(CMediaClientEngine::ENullObserver));
00167
00168
00169 ToneCleanup();
00170 iEngineObserver -> HandleEngineState(iState,aError);
00171 }
00172
00173
00174 void CMediaClientEngine::ToneCleanup()
00175 {
00176 iState = EIdle;
00177 delete iAudioToneUtility;
00178 iAudioToneUtility = NULL;
00179 }
00180
00181
00182
00183
00184
00185
00186
00187 void CMediaClientEngine::PlayL(const TDesC &aFile)
00188 {
00189 __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00190
00191 iAudioPlayUtility = CMdaAudioPlayerUtility::NewFilePlayerL(aFile, *this);
00192 iState = EPlayFilePrepare;
00193
00194 }
00195
00196
00197
00198 void CMediaClientEngine::MapcInitComplete(TInt aError,
00199 const TTimeIntervalMicroSeconds& )
00200 {
00201 __ASSERT_DEBUG(iEngineObserver, Panic(CMediaClientEngine::ENullObserver));
00202 __ASSERT_DEBUG(iAudioPlayUtility, Panic(CMediaClientEngine::ENullPlayerUtility));
00203 __ASSERT_DEBUG(iState == EPlayFilePrepare || iState == EGetMetaData1, Panic(CMediaClientEngine::EWrongState));
00204
00205
00206 if (aError)
00207 {
00208 PlayCleanup();
00209 iEngineObserver -> HandleEngineState(iState,aError);
00210 return;
00211 }
00212 if (iState == EPlayFilePrepare)
00213 {
00214 iState = EPlayFilePlaying;
00215 iAudioPlayUtility -> SetVolume(iAudioPlayUtility -> MaxVolume()/iVolume);
00216 iAudioPlayUtility->Play();
00217 iEngineObserver -> HandleEngineState(iState,aError);
00218 return;
00219 }
00220 if (iState == EGetMetaData1)
00221 {
00222 TInt numEntries = 0;
00223 iAudioPlayUtility -> GetNumberOfMetaDataEntries(numEntries);
00224 for (TInt i=0; i<numEntries; i++)
00225 {
00226 CMMFMetaDataEntry *dataEntry=CMMFMetaDataEntry::NewL();
00227 TRAPD(err,dataEntry = iAudioPlayUtility->GetMetaDataEntryL(i));
00228 if(err)
00229 {
00230 return;
00231 }
00232 iMetaData->Append(dataEntry);
00233 }
00234 PlayCleanup();
00235 iEngineObserver -> HandleEngineState(EGetMetaData2,aError);
00236 iState = EIdle;
00237 return;
00238 }
00239 }
00240
00241
00242
00243 void CMediaClientEngine::MapcPlayComplete(TInt aError)
00244 {
00245 __ASSERT_DEBUG(iState == EPlayFilePlaying, Panic(CMediaClientEngine::ENotReady));
00246 __ASSERT_DEBUG(iEngineObserver, Panic(CMediaClientEngine::ENullObserver));
00247
00248
00249 PlayCleanup();
00250 iEngineObserver -> HandleEngineState(iState,aError);
00251 }
00252
00253
00254 void CMediaClientEngine::PlayCleanup()
00255 {
00256 iState = EIdle;
00257 delete iAudioPlayUtility;
00258 iAudioPlayUtility = NULL;
00259 }
00260
00261
00262
00263
00264
00265
00266
00267 void CMediaClientEngine::RecordTypesL(CDesCArray& aTypeArray)
00268 {
00269
00270 RMMFControllerImplInfoArray controllers;
00271 CleanupResetAndDestroyPushL(controllers);
00272
00273 CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();
00274 CMMFFormatSelectionParameters* fSelectRead = CMMFFormatSelectionParameters::NewLC();
00275 CMMFFormatSelectionParameters* fSelectWrite = CMMFFormatSelectionParameters::NewLC();
00276
00277 RArray<TUid> mediaIds;
00278 mediaIds.Append(KUidMediaTypeAudio);
00279 CleanupClosePushL(mediaIds);
00280 cSelect->SetMediaIdsL(mediaIds, CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds);
00281 cSelect->SetRequiredPlayFormatSupportL(*fSelectRead);
00282 cSelect->SetRequiredRecordFormatSupportL(*fSelectWrite);
00283 cSelect->ListImplementationsL(controllers);
00284
00285 TBuf<10> buf;
00286
00287 for (TInt i=0; i<controllers.Count(); i++)
00288 {
00289 const RMMFFormatImplInfoArray& recordInfo = controllers[i]->RecordFormats();
00290
00291 for (TInt j=0; j<recordInfo.Count(); j++)
00292 {
00293 const CDesC8Array& extensions = recordInfo[j]->SupportedFileExtensions();
00294
00295 for (TInt k=0; k<extensions.Count(); k++)
00296 {
00297 buf.Copy(extensions[k]);
00298 aTypeArray.AppendL(buf);
00299 }
00300 }
00301 }
00302 CleanupStack::PopAndDestroy(5);
00303 }
00304
00305
00306
00307 void CMediaClientEngine::RecordL(const TDesC &aFile, const TRecordFormatOptions& aRecordFormatOptions)
00308 {
00309 __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00310
00311 iRecordFormatOptions = &aRecordFormatOptions;
00312
00313 iAudioRecorderUtility = CMdaAudioRecorderUtility::NewL(*this);
00314 iAudioRecorderUtility -> OpenFileL(aFile);
00315 iState = ERecordPrepare;
00316 iEngineObserver -> HandleEngineState(iState,KErrNone);
00317
00318 }
00319
00320
00321 void CMediaClientEngine::Record2L()
00322 {
00323
00324 iAudioRecorderUtility -> SetAudioDeviceMode(CMdaAudioRecorderUtility::EDefault);
00325 if (iRecordFormatOptions->iGainSet)
00326 iAudioRecorderUtility -> SetGain(iRecordFormatOptions->iGain);
00327 if (iRecordFormatOptions->iBalanceSet)
00328 iAudioRecorderUtility -> SetPlaybackBalance(iRecordFormatOptions->iBalance);
00329 if (iRecordFormatOptions->i4CCSet)
00330 iAudioRecorderUtility -> SetDestinationDataTypeL(iRecordFormatOptions->i4CC);
00331 if (iRecordFormatOptions->iBitRateSet)
00332 iAudioRecorderUtility -> SetDestinationBitRateL(iRecordFormatOptions->iBitRate);
00333 if (iRecordFormatOptions->iSampleRateSet)
00334 iAudioRecorderUtility -> SetDestinationSampleRateL(iRecordFormatOptions->iSampleRate);
00335 if (iRecordFormatOptions->iChannelSet)
00336 iAudioRecorderUtility -> SetDestinationNumberOfChannelsL(iRecordFormatOptions->iChannel);
00337
00338
00339 iAudioRecorderUtility -> RecordL();
00340 iState = ERecording;
00341 }
00342
00343
00344 void CMediaClientEngine::RecordCleanup()
00345 {
00346 iState = EIdle;
00347 delete iAudioRecorderUtility;
00348 iAudioRecorderUtility = NULL;
00349 }
00350
00351
00352 CMdaAudioRecorderUtility* CMediaClientEngine::NewRecorderL(const TDesC& aTargetType)
00353 {
00354 __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00355
00356 return CRecorderCreator::NewRecorderL(aTargetType);
00357 }
00358
00359
00360
00361
00362 CRecorderCreator::CRecorderCreator()
00363 :CActive(EPriorityStandard)
00364 {}
00365
00366 CMdaAudioRecorderUtility* CRecorderCreator::NewRecorderL(const TDesC& aTargetType)
00367 {
00368 CRecorderCreator* creator = new (ELeave) CRecorderCreator();
00369 CleanupStack::PushL(creator);
00370 CMdaAudioRecorderUtility* record = creator->ConstructL(aTargetType);
00371 CleanupStack::PopAndDestroy(creator);
00372 return record;
00373 }
00374
00375 CMdaAudioRecorderUtility* CRecorderCreator::ConstructL(const TDesC& aTargetType)
00376 {
00377 _LIT(KDummyName, "\\dummy");
00378 TFileName name(KDummyName);
00379 name.Append(aTargetType);
00380
00381
00382 iRecorderUtility = CMdaAudioRecorderUtility::NewL(*this);
00383 iRecorderUtility->OpenFileL(name);
00384 CActiveScheduler::Add(this);
00385 SetActive();
00386 CActiveScheduler::Start();
00387 return iRecorderUtility;
00388 }
00389
00390 void CRecorderCreator::RunL()
00391 {
00392 if (iStatus != KErrNone)
00393 {
00394 delete iRecorderUtility;
00395 iRecorderUtility = NULL;
00396 }
00397 CActiveScheduler::Stop();
00398 }
00399
00400 void CRecorderCreator::DoCancel()
00401 {
00402 delete iRecorderUtility;
00403 iRecorderUtility = NULL;
00404 CActiveScheduler::Stop();
00405 }
00406
00407 void CRecorderCreator::MoscoStateChangeEvent(CBase* , TInt ,
00408 TInt , TInt aErrorCode)
00409 {
00410 TRequestStatus* status = &iStatus;
00411 User::RequestComplete(status, aErrorCode);
00412 }
00413
00414
00415
00416 void CMediaClientEngine::MoscoStateChangeEvent(CBase* aObject,
00417 TInt , TInt aCurrentState, TInt aErrorCode)
00418 {
00419 __ASSERT_ALWAYS(aObject == iAudioRecorderUtility || aObject == iConvertUtility, Panic(CMediaClientEngine::EWrongState));
00420 if (aObject == iAudioRecorderUtility)
00421 {
00422 __ASSERT_DEBUG(iState == CMediaClientEngine::ERecordPrepare || iState == CMediaClientEngine::ERecording,
00423 Panic(CMediaClientEngine::EWrongState));
00424
00425 if (aErrorCode)
00426 RecordCleanup();
00427 else if (aCurrentState == CMdaAudioClipUtility::EOpen)
00428 {
00429 TRAPD(err,Record2L());
00430 if(err)
00431 {
00432 return;
00433 }
00434 }
00435 iEngineObserver -> HandleEngineState(iState,aErrorCode);
00436 }
00437
00438 if (aObject == iConvertUtility)
00439 {
00440 __ASSERT_DEBUG(iState == CMediaClientEngine::EConvert || iState == CMediaClientEngine::EConvertComplete,
00441 Panic(CMediaClientEngine::EWrongState));
00442
00443 if (aErrorCode || iState == CMediaClientEngine::EConvertComplete)
00444 ConvertCleanup();
00445 else
00446 {
00447 TRAPD(err,Convert2L());
00448 if(err)
00449 {
00450 return;
00451 }
00452 }
00453 iEngineObserver -> HandleEngineState(iState,aErrorCode);
00454 }
00455 }
00456
00457
00458 void CMediaClientEngine::DestinationTypesL(const TFileName& aFile, CDesCArray& aTypeArray)
00459 {
00460
00461 RMMFControllerImplInfoArray controllers;
00462 CleanupResetAndDestroyPushL(controllers);
00463 CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();
00464 CMMFFormatSelectionParameters* fSelectRead = CMMFFormatSelectionParameters::NewLC();
00465 CMMFFormatSelectionParameters* fSelectWrite = CMMFFormatSelectionParameters::NewLC();
00466 fSelectRead->SetMatchToFileNameL(aFile);
00467 cSelect->SetRequiredPlayFormatSupportL(*fSelectRead);
00468 cSelect->SetRequiredRecordFormatSupportL(*fSelectWrite);
00469 cSelect->ListImplementationsL(controllers);
00470
00471 TBuf<10> buf;
00472 TParsePtrC parse(aFile);
00473 TPtrC ext = parse.Ext();
00474
00475
00476 for (TInt i=0; i<controllers.Count(); i++)
00477 {
00478 const RMMFFormatImplInfoArray& recordInfo = controllers[i]->RecordFormats();
00479
00480 for (TInt j=0; j<recordInfo.Count(); j++)
00481 {
00482 const CDesC8Array& extensions = recordInfo[j]->SupportedFileExtensions();
00483
00484 for (TInt k=0; k<extensions.Count(); k++)
00485 {
00486 buf.Copy(extensions[k]);
00487 if (buf != ext)
00488 aTypeArray.AppendL(buf);
00489 }
00490 }
00491 }
00492 CleanupStack::PopAndDestroy(4);
00493 }
00494
00495
00496 void CMediaClientEngine::ConvertL(const TFileName& aFile, const TDesC& aTargetType, const TFormatOptions& aOptions)
00497 {
00498 __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00499
00500 iOptions = &aOptions;
00501 ChangeExtension(aFile, aTargetType, iTargetFile);
00502
00503 iConvertUtility = CMdaAudioConvertUtility::NewL(*this);
00504 iConvertUtility->OpenL(aFile, iTargetFile);
00505 iState = EConvert;
00506
00507 }
00508
00509
00510 void CMediaClientEngine::Convert2L()
00511 {
00512 if (iOptions->i4CCSet) iConvertUtility->SetDestinationDataTypeL(iOptions->i4CC);
00513 if (iOptions->iBitRateSet) iConvertUtility->SetDestinationBitRateL(iOptions->iBitRate);
00514 if (iOptions->iSampleRateSet) iConvertUtility->SetDestinationSampleRateL(iOptions->iSampleRate);
00515 if (iOptions->iChannelSet) iConvertUtility->SetDestinationNumberOfChannelsL(iOptions->iChannel);
00516 iConvertUtility->ConvertL();
00517 iState = EConvertComplete;
00518
00519 }
00520
00521
00522 void CMediaClientEngine::ConvertCleanup()
00523 {
00524 iState = EIdle;
00525 delete iConvertUtility;
00526 iConvertUtility = NULL;
00527 }
00528
00529
00530
00531
00532
00533
00534 void CMediaClientEngine::PlayL()
00535 {
00536 __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00537 iAudioStreamPlayer = CMdaAudioOutputStream::NewL(*this);
00538 iSettings.iVolume = iAudioStreamPlayer -> MaxVolume()/iVolume;
00539 iSettings.iChannels = TMdaAudioDataSettings::EChannelsMono;
00540 iSettings.iSampleRate = TMdaAudioDataSettings::ESampleRate8000Hz;
00541
00542 iAudioStreamPlayer -> Open(&iSettings);
00543
00544 iState = EStreamPrepare;
00545 iEngineObserver -> HandleEngineState(iState,KErrNone);
00546
00547 }
00548
00549
00550 void CMediaClientEngine::MaoscOpenComplete(TInt aError)
00551 {
00552 if (aError)
00553 StreamCleanup();
00554 else
00555 iState = EStreamStarted;
00556
00557 iEngineObserver -> HandleEngineState(iState,aError);
00558 }
00559
00560
00561
00562 void CMediaClientEngine::MaoscBufferCopied(TInt aError, const TDesC8& )
00563 {
00564
00565 if (aError)
00566 iState = EStreamError;
00567 else
00568 iState = ENextStreamBuf;
00569
00570 iEngineObserver -> HandleEngineState(iState,aError);
00571 }
00572
00573
00574 void CMediaClientEngine::MaoscPlayComplete(TInt aError)
00575 {
00576 if (aError == KErrUnderflow) aError=KErrNone;
00577 StreamCleanup();
00578 iEngineObserver -> HandleEngineState(iState,aError);
00579 }
00580
00581
00582 void CMediaClientEngine::WriteToStreamL(const TDesC8& aData)
00583 {
00584 if (iState == CMediaClientEngine::EStreamStarted
00585 || iState == CMediaClientEngine::ENextStreamBuf)
00586 iAudioStreamPlayer -> WriteL(aData);
00587
00588 }
00589
00590
00591
00592 void CMediaClientEngine::StreamCleanup()
00593 {
00594 iState = EIdle;
00595 delete iAudioStreamPlayer;
00596 iAudioStreamPlayer = NULL;
00597 }
00598
00599
00600
00601
00602
00603
00604 void CMediaClientEngine::GetMetaDataL(const TFileName& aFile, RMetaDataArray& aMetaData)
00605 {
00606 __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00607
00608 iAudioPlayUtility = CMdaAudioPlayerUtility::NewFilePlayerL(aFile, *this);
00609 iMetaData = &aMetaData;
00610 iState = EGetMetaData1;
00611
00612 }
00613
00614
00615
00616
00617
00618
00619
00620
00621 CMdaAudioConvertUtility* CMediaClientEngine::NewConverterL(const TFileName& aFile, const TDesC& aTargetType,
00622 TFileName& aTargetFile)
00623 {
00624 __ASSERT_DEBUG(iState == CMediaClientEngine::EIdle, Panic(CMediaClientEngine::EInProgress));
00625
00626 return CConverterCreator::NewConverterL(aFile, aTargetType, aTargetFile);
00627 }
00628
00629 CConverterCreator::CConverterCreator()
00630 :CActive(EPriorityStandard)
00631 {}
00632
00633 CMdaAudioConvertUtility* CConverterCreator::NewConverterL(const TFileName& aFile, const TDesC& aTargetType,
00634 TFileName& aTargetFile)
00635 {
00636 CConverterCreator* creator = new (ELeave) CConverterCreator();
00637 CleanupStack::PushL(creator);
00638 CMdaAudioConvertUtility* convert = creator->ConstructL(aFile, aTargetType, aTargetFile);
00639 CleanupStack::PopAndDestroy(creator);
00640 return convert;
00641 }
00642
00643 CMdaAudioConvertUtility* CConverterCreator::ConstructL(const TFileName& aFile, const TDesC& aTargetType,
00644 TFileName& aTargetFile)
00645 {
00646 ChangeExtension(aFile, aTargetType, aTargetFile);
00647
00648 iConvertUtility = CMdaAudioConvertUtility::NewL(*this);
00649 iConvertUtility->OpenL(aFile, aTargetFile);
00650 CActiveScheduler::Add(this);
00651 SetActive();
00652 CActiveScheduler::Start();
00653 return iConvertUtility;
00654 }
00655
00656 void CConverterCreator::MoscoStateChangeEvent(CBase* , TInt , TInt , TInt aErrorCode)
00657 {
00658 TRequestStatus* status = &iStatus;
00659 User::RequestComplete(status, aErrorCode);
00660 }
00661
00662 void CConverterCreator::RunL()
00663 {
00664 if (iStatus != KErrNone)
00665 {
00666 delete iConvertUtility;
00667 iConvertUtility = NULL;
00668 }
00669 CActiveScheduler::Stop();
00670 }
00671
00672 void CConverterCreator::DoCancel()
00673 {
00674 delete iConvertUtility;
00675 iConvertUtility = NULL;
00676 CActiveScheduler::Stop();
00677 }
00678
00679
00680
00681
00682
00683 void ChangeExtension(const TFileName& aFile, const TDesC& aTargetType,
00684 TFileName& aTargetFile)
00685 {
00686
00687 aTargetFile = aFile;
00688 TParsePtr parse(aTargetFile);
00689 TPtrC ext = parse.Ext();
00690 aTargetFile.Replace(aTargetFile.Length()-ext.Length(),ext.Length(),aTargetType);
00691 }