TB10.1 Example Applications: examples/Multimedia/MmfExFormatPlugin/mmfrawformat.cpp Source File

00001 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
-00002 // All rights reserved.
-00003 // This component and the accompanying materials are made available
-00004 // under the terms of "Eclipse Public License v1.0"
-00005 // which accompanies this distribution, and is available
-00006 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
-00007 //
-00008 // Initial Contributors:
-00009 // Nokia Corporation - initial contribution.
-00010 //
-00011 // Contributors:
-00012 //
-00013 // Description:
-00014 //
-00015 
-00016 // MMF framework headers
-00017 #include <mmffile.h>
-00018 #include <ecom.h>
-00019 #include <mmfformatimplementationuids.hrh>
-00020 #include <mmffourcc.h>
-00021 
-00022 #include "mmfrawformat.h"
-00023 #include "UIDs.hrh"
-00024 
-00025 const TUint KFormatDefaultFrameSize(0x1000); //Set default frame size to 4 K
-00026 const TUint KDefineIOBufferSize(0x0200); //easy to read clip buffer size
-00027 const TUint KOneSecondInMicroSeconds(1000000); //1 Second
-00028 const TUint KMono(1);
-00029 const TUint KStereo(2);
-00030 //this defines the valid sample rates for RAW
-00031 const TUint KRawSampleRates[] = { 8000, 11025, 22050, 44100 };
-00032 
-00033 
-00034 //
-00035 // CMMFRawFormatRead
-00036 //
-00037 
-00038 // Factory function
-00039 CMMFFormatDecode* CMMFRawFormatRead::NewL(MDataSource* aSource)
-00040         {
-00041         if ((aSource->DataSourceType()==KUidMmfDescriptorSource)||
-00042                         (aSource->DataSourceType()==KUidMmfFileSource))
-00043                 {//currently only files and descriptor MDataSources are supported
-00044                 CMMFRawFormatRead* self = new(ELeave)CMMFRawFormatRead;
-00045                 CleanupStack::PushL(self);
-00046                 self->ConstructL(aSource);
-00047                 CleanupStack::Pop();
-00048                 return self;
-00049                 }
-00050         else return NULL;
-00051         }
-00052 
-00053 // Destructor
-00054 CMMFRawFormatRead::~CMMFRawFormatRead()
-00055         {
-00056         delete iBuffer;
-00057         }
-00058         
-00059 // Second-phase constructor
-00060 void CMMFRawFormatRead::ConstructL(MDataSource* aSource)
-00061         {
-00062         // tell clip we're using it
-00063         iClip = aSource;
-00064         User::LeaveIfError(iClip->SourceThreadLogon(*this));
-00065         iClip->SourcePrimeL();
-00066         iFrameSize = KFormatDefaultFrameSize;
-00067         iClipLength = (static_cast<CMMFClip*>(iClip))->Size();
-00068         }
-00069 
-00070 // Implementing MDataSource
-00071 
-00072 // Handle request to fill buffer with data from clip
-00073 void CMMFRawFormatRead::FillBufferL(CMMFBuffer* aBuffer, MDataSink* aConsumer, TMediaId aMediaId )
-00074         {       
-00075         // check media id & pass onto the clip
-00076         if (aMediaId.iMediaType != KUidMediaTypeAudio) User::Leave(KErrNotSupported); 
-00077         iDataPath = aConsumer;
-00078         //assumes first frame is frame 1
-00079         TUint position = ((aBuffer->FrameNumber()-1)*iFrameSize)+iStartPosition;
-00080         (static_cast<CMMFClip*>(iClip))->ReadBufferL(aBuffer, position, this);
-00081         // notified of when buffer is full by BufferFilledL
-00082         }
-00083 
-00084 // creates the buffer for the source
-00085 // This overload supplies the sink buffer, as optimal source buffer size creation may depend on this
-00086 CMMFBuffer* CMMFRawFormatRead::CreateSourceBufferL(TMediaId aMediaId, CMMFBuffer& aSinkBuffer, TBool &aReference)
-00087         {
-00088         if (aMediaId.iMediaType == KUidMediaTypeAudio) 
-00089                 {
-00090                 NegotiateSourceBufferL(aSinkBuffer); //sets frame size to match sink buffer
-00091                 return CreateSourceBufferL(aMediaId, aReference);
-00092                 }
-00093         else User::Leave(KErrNotSupported);
-00094         return NULL;
-00095         }
-00096 
-00097 // creates the buffer for the source
-00098 CMMFBuffer* CMMFRawFormatRead::CreateSourceBufferL(TMediaId aMediaId, TBool &aReference)
-00099         {
-00100         if (aMediaId.iMediaType == KUidMediaTypeAudio) 
-00101                 {
-00102                 // assume default frame size if haven't determined a better one
-00103                 if (!iFrameSize) iFrameSize = KFormatDefaultFrameSize;
-00104                 // sets aReference to false if a new CMMFBuffer is returned
-00105                 aReference = EFalse;
-00106                 return CreateSourceBufferOfSizeL(iFrameSize);
-00107                 }
-00108         else User::Leave(KErrNotSupported);
-00109         return NULL;
-00110         }
-00111 
-00112 // Helper function to create and zero fill a buffer of specified size
-00113 CMMFDataBuffer* CMMFRawFormatRead::CreateSourceBufferOfSizeL(TUint aSize)
-00114         {
-00115         //needs to create source buffer
-00116         CMMFDataBuffer* buffer = CMMFDataBuffer::NewL(aSize);
-00117         buffer->Data().FillZ(aSize);
-00118         return buffer;
-00119         }
-00120 
-00121 // Helper function to determine best source buffer size
-00122 void CMMFRawFormatRead::NegotiateSourceBufferL(CMMFBuffer& aSinkBuffer)
-00123         {
-00124         // if sink buffer has a fixed size use this to determine source buffer size
-00125         if (aSinkBuffer.Type() == KUidMmfDataBuffer)
-00126                 {
-00127                 // RAW is linear data, so can set target buffer to sink buffer size
-00128                 TUint sinkBufferLength = (static_cast<CMMFDataBuffer&>(aSinkBuffer)).Data().MaxLength();
-00129                 if (sinkBufferLength == 0) sinkBufferLength = KFormatDefaultFrameSize;
-00130                 iFrameSize = sinkBufferLength; 
-00131                 CalculateFrameTimeInterval();
-00132                 }
-00133         else 
-00134                 User::Leave(KErrNotSupported);
-00135         }
-00136 
-00137 // returns the codec FourCC code for the mediaId
-00138 TFourCC CMMFRawFormatRead::SourceDataTypeCode(TMediaId aMediaId)
-00139         {
-00140         if (aMediaId.iMediaType == KUidMediaTypeAudio) return iFourCC;
-00141         else return TFourCC(); //defaults to 'NULL' fourCC
-00142         }
-00143 
-00144 // sets the codec FourCC code for the mediaId
-00145 TInt CMMFRawFormatRead::SetSourceDataTypeCode(TFourCC aSinkFourCC, TMediaId aMediaId)
-00146         {
-00147         if (aMediaId.iMediaType != KUidMediaTypeAudio) return KErrNotSupported;
-00148         else iFourCC = aSinkFourCC;
-00149         
-00150         if ((iFourCC == KMMFFourCCCodePCM16) || 
-00151                 (iFourCC == KMMFFourCCCodePCM16B) || 
-00152                 (iFourCC == KMMFFourCCCodePCMU16)) 
-00153                         iBitsPerSample = 16;
-00154         else if ((iFourCC == KMMFFourCCCodeIMAD) || 
-00155                 (iFourCC == KMMFFourCCCodeIMAS)) 
-00156                         iBitsPerSample = 4;
-00157         else 
-00158                         iBitsPerSample = 8; //default to 8
-00159         return KErrNone;
-00160         }
-00161 
-00162 // Initiate use of the interface 
-00163 TInt CMMFRawFormatRead::SourceThreadLogon(MAsyncEventHandler& aEventHandler)
-00164         {//pass through to source clip
-00165         return(iClip->SourceThreadLogon(aEventHandler));
-00166         }
-00167 
-00168 // Prepare clip
-00169 void CMMFRawFormatRead::SourcePrimeL()
-00170         {
-00171         iClip->SourcePrimeL();
-00172         CalculateFrameTimeInterval();
-00173         }
-00174 
-00175 // Play clip
-00176 void CMMFRawFormatRead::SourcePlayL()
-00177         {
-00178         iClip->SourcePlayL();
-00179         }
-00180 
-00181 // Pause clip
-00182 void CMMFRawFormatRead::SourcePauseL()
-00183         {
-00184         iClip->SourcePauseL(); //propagate state change down to clip
-00185         }
-00186 
-00187 // Stop clip
-00188 void CMMFRawFormatRead::SourceStopL()
-00189         {
-00190         iClip->SourceStopL();
-00191         }
-00192 
-00193 // End use of the interface
-00194 void CMMFRawFormatRead::SourceThreadLogoff()
-00195         {
-00196         iClip->SourceThreadLogoff();
-00197         }
-00198 
-00199 // from MDataSink
-00200 
-00201 // called by MDataSource to pass back full buffer to the sink
-00202 void CMMFRawFormatRead::BufferFilledL(CMMFBuffer* aBuffer)
-00203         {
-00204         //set position
-00205         TTimeIntervalMicroSeconds position = //assumes frame numbers begin at frame 1
-00206                 TTimeIntervalMicroSeconds(TInt64(aBuffer->FrameNumber()-1)*iFrameTimeInterval.Int64());
-00207         aBuffer->SetTimeToPlay(position);
-00208         iDataPath->BufferFilledL(aBuffer);      
-00209         }
-00210 
-00211 
-00212 // from CMMFFormatDecode
-00213 
-00214 // returns number of streams
-00215 TUint CMMFRawFormatRead::Streams(TUid aMediaType) const
-00216         {
-00217         //need to check aMediaType for audio
-00218         if (aMediaType == KUidMediaTypeAudio) return 1; //raw files can only have 1 audio stream
-00219         else return 0;
-00220         }
-00221 
-00222 // returns the time interval for one frame
-00223 TTimeIntervalMicroSeconds CMMFRawFormatRead::FrameTimeInterval(TMediaId aMediaId) const
-00224         {
-00225         if (aMediaId.iMediaType == KUidMediaTypeAudio) return iFrameTimeInterval;
-00226         else return TTimeIntervalMicroSeconds(0);
-00227         }
-00228 
-00229 // returns the duration of the source clip
-00230 TTimeIntervalMicroSeconds CMMFRawFormatRead::Duration(TMediaId aMediaId) const
-00231         {
-00232         if ((aMediaId.iMediaType == KUidMediaTypeAudio) && 
-00233                 (iClipLength) && (iSampleRate) && (iBitsPerSample) && (iChannels))
-00234                 {//we have enough values to calculate the duration
-00235                 TInt64 clipLength(iClipLength);
-00236                 clipLength*=KOneSecondInMicroSeconds;
-00237                 TTimeIntervalMicroSeconds duration = TTimeIntervalMicroSeconds(clipLength/iSampleRate);
-00238                 duration = TTimeIntervalMicroSeconds(duration.Int64()/(iBitsPerSample*iChannels));
-00239                 duration = TTimeIntervalMicroSeconds(duration.Int64()*8);
-00240                 return duration;
-00241                 }
-00242         else return TTimeIntervalMicroSeconds(0);
-00243         }
-00244 
-00245 // helper function: calculates time between frames
-00246 void CMMFRawFormatRead::CalculateFrameTimeInterval()
-00247         {
-00248         if ((iFrameSize) && (iSampleRate) && (iBitsPerSample) && (iChannels))
-00249                 {
-00250                 iFrameTimeInterval = TTimeIntervalMicroSeconds((iFrameSize*KOneSecondInMicroSeconds)/iSampleRate);
-00251                 iFrameTimeInterval = 
-00252                         TTimeIntervalMicroSeconds(iFrameTimeInterval.Int64()/(iBitsPerSample*iChannels));
-00253                 iFrameTimeInterval = TTimeIntervalMicroSeconds(iFrameTimeInterval.Int64()*8);
-00254                 }
-00255         }
-00256 
-00257 // called by sink to suggest a source buffer size
-00258 void CMMFRawFormatRead::SuggestSourceBufferSize(TUint aSuggestedBufferSize)
-00259         {
-00260         iFrameSize = aSuggestedBufferSize; //set source format frame size to buffer size suggested by sink
-00261         CalculateFrameTimeInterval();
-00262         }
-00263 
-00264 // set the number of channels
-00265 TInt CMMFRawFormatRead::SetNumChannels(TUint aChannels)
-00266         {
-00267         TInt error = KErrNone;
-00268         if ((aChannels ==  KMono)||(aChannels == KStereo)) iChannels = aChannels;
-00269         else error = KErrNotSupported; //only alow one or two channels
-00270         return error;
-00271         }
-00272 
-00273 // set the sample rate
-00274 TInt CMMFRawFormatRead::SetSampleRate(TUint aSampleRate)
-00275         {
-00276         TInt status = KErrNotSupported;
-00277         //we'll iterate through the valid sample table
-00278         TInt i = sizeof(KRawSampleRates) / sizeof(TUint);
-00279                 
-00280         while ((i--) && (status != KErrNone))
-00281                 {
-00282                 if (aSampleRate == KRawSampleRates[i])
-00283                         {
-00284                         iSampleRate = aSampleRate;
-00285                         status = KErrNone;
-00286                         }
-00287                 }
-00288         return status;
-00289         }
-00290 
-00291 // helper function to read from clip
-00292 void CMMFRawFormatRead::DoReadL(TInt aReadPosition)
-00293         {
-00294         STATIC_CAST(CMMFClip*,iClip)->ReadBufferL(iBuffer,aReadPosition);
-00295         }
-00296 
-00297 // get the supported sample rates
-00298 void CMMFRawFormatRead::GetSupportedSampleRatesL(RArray<TUint>& aSampleRates)
-00299         {
-00300         aSampleRates.Reset();
-00301 
-00302         // Iterate through the valid sample table and append each value to aSampleRates
-00303         TInt i = sizeof(KRawSampleRates) / sizeof(TUint);
-00304         
-00305         while (i--)
-00306                 {
-00307                 User::LeaveIfError(aSampleRates.Append(KRawSampleRates[i]));
-00308                 }
-00309         }
-00310 
-00311 // get the supported channel number options
-00312 void CMMFRawFormatRead::GetSupportedNumChannelsL(RArray<TUint>& aNumChannels)
-00313         {
-00314         aNumChannels.Reset();
-00315         User::LeaveIfError(aNumChannels.Append(KMono));
-00316         User::LeaveIfError(aNumChannels.Append(KStereo));
-00317         }
-00318 
-00319 // get the supported codecs
-00320 void CMMFRawFormatRead::GetSupportedDataTypesL(TMediaId aMediaId, RArray<TFourCC>& aDataTypes)
-00321         {
-00322         if (aMediaId.iMediaType != KUidMediaTypeAudio)
-00323                 User::Leave(KErrNotSupported);
-00324         aDataTypes.Reset();
-00325         User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodePCM16));
-00326         User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodePCM16B));
-00327         User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodePCMU16));
-00328         User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodeIMAD));
-00329         User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodeIMAS));
-00330         }
-00331 
-00332 
-00333 //
-00334 // CMMFRawFormatWrite
-00335 //
-00336 
-00337 // Factory function
-00338 CMMFFormatEncode* CMMFRawFormatWrite::NewL(MDataSink* aSink)
-00339         {
-00340         if ((aSink->DataSinkType()==KUidMmfDescriptorSink)||
-00341                         (aSink->DataSinkType()==KUidMmfFileSink))
-00342                 {//currently only files and descriptor MDataSources are supported
-00343                 CMMFRawFormatWrite* self = new(ELeave)CMMFRawFormatWrite;
-00344                 CleanupStack::PushL(self);
-00345                 self->ConstructL(aSink);
-00346                 CleanupStack::Pop();
-00347                 return STATIC_CAST(CMMFFormatEncode*, self);
-00348                 }
-00349         else return NULL;
-00350         }
-00351 
-00352 // destructor
-00353 CMMFRawFormatWrite::~CMMFRawFormatWrite()
-00354         {
-00355         delete iBuffer;
-00356         delete iConvertBuffer;
-00357         delete iChannelAndSampleRateConverterFactory;
-00358         }
-00359         
-00360 // second-phase construction    
-00361 void CMMFRawFormatWrite::ConstructL(MDataSink* aSink)
-00362         {
-00363         iClip = aSink;
-00364         //first need to check if sink clip already exists to get settings.
-00365         User::LeaveIfError(iClip->SinkThreadLogon(*this));
-00366         iClip->SinkPrimeL();
-00367         iBuffer = CreateSinkBufferOfSizeL(KDefineIOBufferSize); //512 easiest file size to read
-00368         DoReadL(0);//read from beginning of clip
-00369         if (iBuffer->Data().Size()> 0)
-00370                 {
-00371                 iClipAlreadyExists = ETrue;
-00372                 //There is no header, so data size is the same as the clip size in this case.
-00373                 iDataSize = iClipLength = STATIC_CAST(CMMFClip*,iClip)->Size();
-00374                 }
-00375         iFrameSize = KFormatDefaultFrameSize;
-00376         }
-00377 
-00378 // from MDataSink
-00379 
-00380 // sink thread attaches
-00381 TInt CMMFRawFormatWrite::SinkThreadLogon(MAsyncEventHandler& aEventHandler)
-00382         {//pass through to sink clip
-00383         return(iClip->SinkThreadLogon(aEventHandler));
-00384         }
-00385 
-00386 // helper function: calculates time between frames
-00387 void CMMFRawFormatWrite::CalculateFrameTimeInterval()
-00388         {
-00389         if ((iFrameSize) && (iSampleRate) && (iBitsPerSample) && (iChannels))
-00390                 {
-00391                 iFrameTimeInterval = TTimeIntervalMicroSeconds((iFrameSize*KOneSecondInMicroSeconds)/iSampleRate);
-00392                 iFrameTimeInterval = 
-00393                         TTimeIntervalMicroSeconds((iFrameTimeInterval.Int64())/(iBitsPerSample*iChannels));
-00394                 iFrameTimeInterval = TTimeIntervalMicroSeconds(iFrameTimeInterval.Int64()*8);
-00395                 }
-00396         }
-00397 
-00398 // called if sink setup depends on source
-00399 void CMMFRawFormatWrite::Negotiate(MDataSource& aSource)
-00400         {
-00401         if (aSource.DataSourceType() == KUidMmfAudioInput)
-00402                 {
-00403                 // could query the audio capabilities from DevSound for the settings below
-00404                 iSourceSampleRate = 8000; // assume 8KHz for now
-00405                 iSourceChannels = 1; //assume mono
-00406                 iSourceFourCC.Set(KMMFFourCCCodePCM16); //16 bit PCM
-00407                 }
-00408         else if (aSource.DataSourceType() == KUidMmfFormatDecode)
-00409                 {//source is a clip so for now set sink settings to match source
-00410                 iSourceSampleRate = ((CMMFFormatDecode&)aSource).SampleRate();
-00411                 iSourceChannels = ((CMMFFormatDecode&)aSource).NumChannels();
-00412                 iSourceFourCC.Set(aSource.SourceDataTypeCode(TMediaId(KUidMediaTypeAudio)));
-00413                 iSourceWillSampleConvert = STATIC_CAST(CMMFFormatDecode&, aSource).SourceSampleConvert();
-00414                 ((CMMFFormatDecode&)aSource).SuggestSourceBufferSize(iFrameSize); //for now suggest format src takes same buf size as sink??
-00415                 //make the start position the end of the clip
-00416                 }
-00417         else return;
-00418         //set default sink parameters to be the same as the source
-00419         if (iClipAlreadyExists) iStartPosition = iClipLength;
-00420         if (!iSampleRate) iSampleRate = iSourceSampleRate; //might have already been set by custom command
-00421         if (!iChannels) iChannels = iSourceChannels;
-00422         if (!iBitsPerSample)
-00423                 {
-00424                 iFourCC.Set(iSourceFourCC);
-00425                 if ((iFourCC == KMMFFourCCCodePCM16) ||
-00426                         (iFourCC == KMMFFourCCCodePCM16B) ||
-00427                         (iFourCC == KMMFFourCCCodePCMU16))
-00428                                 iBitsPerSample = 16;            
-00429                 else if ((iFourCC == KMMFFourCCCodeIMAD) || 
-00430                         (iFourCC == KMMFFourCCCodeIMAS))
-00431                                 iBitsPerSample = 4;     
-00432                 else 
-00433                                 iBitsPerSample = 8; //default to 8
-00434                 }
-00435         CalculateFrameTimeInterval();
-00436         }
-00437 
-00438 // Prime the sink to be accessed
-00439 void CMMFRawFormatWrite::SinkPrimeL()
-00440         {
-00441         iClip->SinkPrimeL(); //propagate state change down to clip
-00442         CalculateFrameTimeInterval();
-00443         }
-00444 
-00445 // Play the sink
-00446 void CMMFRawFormatWrite::SinkPlayL()
-00447         {
-00448         iClip->SinkPlayL(); //propagate state change down to clip
-00449         if ((iChannels != iSourceChannels) || (iSampleRate != iSourceSampleRate) && (!iSourceWillSampleConvert))
-00450                 {//the source channels & sample rate don't match the formats - therefore need to do a conversion 
-00451                 //currently only pcm16 is supported so return with an error if format not pcm16
-00452                 if (iFourCC != KMMFFourCCCodePCM16) User::Leave(KErrNotSupported);
-00453                 iChannelAndSampleRateConverterFactory 
-00454                         = new(ELeave)CMMFChannelAndSampleRateConverterFactory;
-00455                 iChannelAndSampleRateConverter = 
-00456                         iChannelAndSampleRateConverterFactory->CreateConverterL( iSourceSampleRate, iSourceChannels, 
-00457                                                                                                                                         iSampleRate, iChannels);
-00458                 //need to create an intermediate buffer in which to place the converted data
-00459                 TUint convertedBufferFrameSize = (iFrameSize*iChannels)/iSourceChannels;
-00460                 iConvertBuffer = CreateSinkBufferOfSizeL(convertedBufferFrameSize);
-00461                 }
-00462         iFileHasChanged = ETrue; //file will change if we start playing to it
-00463         }
-00464 
-00465 // Pause the sink
-00466 void CMMFRawFormatWrite::SinkPauseL()
-00467         {
-00468         iClip->SinkPauseL(); //propagate state change down to clip
-00469         }
-00470 
-00471 // Stop the sink
-00472 void CMMFRawFormatWrite::SinkStopL()
-00473         {
-00474         iClip->SinkStopL(); //propagate state change down to clip
-00475         }
-00476 
-00477 // Detach from the sink
-00478 void CMMFRawFormatWrite::SinkThreadLogoff()
-00479         {
-00480         iClip->SinkThreadLogoff(); //propagate down to clip
-00481         }
-00482 
-00483 // Called by the CMMFDataPath to add a buffer to a clip
-00484 void CMMFRawFormatWrite::EmptyBufferL(CMMFBuffer* aBuffer, MDataSource* aSupplier, TMediaId aMediaId)
-00485         {
-00486         //since raw always contains linear audio the sink buffer size can set the source buffer size
-00487 
-00488         //check media id &pass onto clip
-00489         if (aMediaId.iMediaType!=KUidMediaTypeAudio) User::Leave(KErrNotSupported); 
-00490         iDataPath = aSupplier;
-00491 
-00492         // Check we haven't exceeded any set maximum on our clip length
-00493         if (iMaximumClipSize > 0)
-00494                 {
-00495                 // Find the current clip size
-00496                 TInt currentClipLength = STATIC_CAST(CMMFClip*, iClip)->Size();
-00497                 TInt bufferSize = aBuffer->BufferSize();
-00498                 if ((currentClipLength + bufferSize) >= iMaximumClipSize)
-00499                         User::Leave(KErrEof);
-00500                 }
-00501 
-00502         //assumes first frame is frame 1
-00503         iBufferToEmpty = aBuffer; //save this so it can be returned to datapath
-00504         TInt position = ((aBuffer->FrameNumber()-1)*iFrameSize)+iStartPosition;
-00505         if (position < (TInt)iStartPosition) position = iStartPosition; //can't write before start of header
-00506         if ((iChannelAndSampleRateConverter) && (!iSourceWillSampleConvert))
-00507                 {//need to perform channel & sample rate conversion before writing to clip
-00508                 iFrameSize = iChannelAndSampleRateConverter->Convert(*(CMMFDataBuffer*)aBuffer,*iConvertBuffer);
-00509                 STATIC_CAST(CMMFClip*,iClip)->WriteBufferL(iConvertBuffer, position, this);
-00510                 }
-00511         else
-00512                 {//no need to convert the data
-00513                 STATIC_CAST(CMMFClip*,iClip)->WriteBufferL(aBuffer, position, this);
-00514                 }
-00515         iPos = position; //save current write position
-00516         }
-00517 
-00518 // helper function to create buffer of specficed size
-00519 CMMFDataBuffer* CMMFRawFormatWrite::CreateSinkBufferOfSizeL(TUint aSize)
-00520         {
-00521         //needs to create source buffer
-00522         CMMFDataBuffer* buffer = CMMFDataBuffer::NewL(aSize);
-00523         buffer->Data().FillZ(aSize);
-00524         iBufferCreated = ETrue;
-00525         return buffer;
-00526         }
-00527 
-00528 // create buffer to receive data
-00529 CMMFBuffer* CMMFRawFormatWrite::CreateSinkBufferL(TMediaId aMediaId, TBool &aReference)
-00530         {
-00531         if (aMediaId.iMediaType == KUidMediaTypeAudio) 
-00532                 {
-00533                 if (!iFrameSize) iFrameSize = KFormatDefaultFrameSize;
-00534                 aReference = EFalse;
-00535                 return CreateSinkBufferOfSizeL(iFrameSize);
-00536                 }
-00537         else User::Leave(KErrNotSupported);
-00538         return NULL;
-00539         }
-00540 
-00541 // gets the codec type
-00542 TFourCC CMMFRawFormatWrite::SinkDataTypeCode(TMediaId aMediaId)
-00543         {
-00544         if (aMediaId.iMediaType == KUidMediaTypeAudio) return iFourCC;
-00545         else return TFourCC(); //defaults to 'NULL' fourCC
-00546         }
-00547 
-00548 // sets the codec type
-00549 TInt CMMFRawFormatWrite::SetSinkDataTypeCode(TFourCC aSinkFourCC, TMediaId aMediaId)
-00550         {
-00551         if (aMediaId.iMediaType != KUidMediaTypeAudio) return KErrNotSupported;
-00552         else iFourCC = aSinkFourCC;
-00553         
-00554         if ((iFourCC == KMMFFourCCCodePCM16) || 
-00555                 (iFourCC == KMMFFourCCCodePCM16B) ||
-00556                 (iFourCC == KMMFFourCCCodePCMU16)) 
-00557                         iBitsPerSample = 16;
-00558         else if ((iFourCC == KMMFFourCCCodeIMAD) ||
-00559                 (iFourCC == KMMFFourCCCodeIMAS)) 
-00560                         iBitsPerSample = 4;
-00561         else 
-00562                         iBitsPerSample = 8; //default to 8
-00563 
-00564         return KErrNone;
-00565         }
-00566 
-00567 // helper function to read data from clip
-00568 void CMMFRawFormatWrite::DoReadL(TInt aReadPosition)
-00569         {
-00570         STATIC_CAST(CMMFClip*,iClip)->ReadBufferL(iBuffer,aReadPosition);
-00571         }
-00572 
-00573 // helper function to write data to clip
-00574 void CMMFRawFormatWrite::DoWriteL(TInt aWritePosition)
-00575         {
-00576         STATIC_CAST(CMMFClip*,iClip)->WriteBufferL(iBuffer,aWritePosition);
-00577         }
-00578 
-00579 
-00580 // from MDataSource
-00581 
-00582 // called by MDataSink to pass back emptied buffer to the source
-00583 void CMMFRawFormatWrite::BufferEmptiedL(CMMFBuffer* aBuffer)
-00584         {
-00585         iDataSize+=aBuffer->BufferSize(); //total bytes written
-00586         iPos += aBuffer->BufferSize(); //total bytes written so far - iPos is not always = iDataSize due to repositions
-00587         if (iMaxPos < iPos) iMaxPos = iPos; //need iMaxPos incase we write data then repos to an earlier pos in the clip
-00588         if (iBufferToEmpty != aBuffer) iDataPath->BufferEmptiedL(iBufferToEmpty); //need to return same buffer
-00589         else iDataPath->BufferEmptiedL(aBuffer);
-00590         }
-00591 
-00592 
-00593 // from CMMFFormatEncode
-00594 
-00595 // set the number of channels 
-00596 TInt CMMFRawFormatWrite::SetNumChannels(TUint aChannels)
-00597         {
-00598         TInt error = KErrNone;
-00599         if ((aChannels ==  KMono)||(aChannels == KStereo)) iChannels = aChannels;
-00600         else error = KErrNotSupported; //only alow one or two channels
-00601         return error;
-00602         }
-00603 
-00604 // set the sample rate
-00605 TInt CMMFRawFormatWrite::SetSampleRate(TUint aSampleRate)
-00606         {
-00607         TInt status = KErrNotSupported;
-00608         //we'll iterate through the valid sample table
-00609         TInt i = sizeof(KRawSampleRates) / sizeof(TUint);
-00610                 
-00611         while ((i--) && (status != KErrNone))
-00612                 {
-00613                 if (aSampleRate == KRawSampleRates[i])
-00614                         {
-00615                         iSampleRate = aSampleRate;
-00616                         status = KErrNone;
-00617                         }
-00618                 }
-00619         return status;
-00620         }
-00621 
-00622 // get the frame interval
-00623 TTimeIntervalMicroSeconds CMMFRawFormatWrite::FrameTimeInterval(TMediaId aMediaId) const
-00624         {
-00625         if (aMediaId.iMediaType == KUidMediaTypeAudio) return iFrameTimeInterval;
-00626         else return TTimeIntervalMicroSeconds(0);
-00627         }
-00628 
-00629 // returns the duration of the source clip
-00630 TTimeIntervalMicroSeconds CMMFRawFormatWrite::Duration(TMediaId aMediaId) const
-00631         {
-00632         if ((aMediaId.iMediaType == KUidMediaTypeAudio) 
-00633                 && (iDataSize) && (iSampleRate) && (iBitsPerSample) && (iChannels))
-00634                 {
-00635                 TInt64 clipLength(iDataSize);
-00636                 clipLength*=KOneSecondInMicroSeconds;
-00637                 TTimeIntervalMicroSeconds duration = TTimeIntervalMicroSeconds(clipLength/iSampleRate);
-00638                 duration = 
-00639                         TTimeIntervalMicroSeconds(duration.Int64()/(iBitsPerSample*iChannels));
-00640                 duration = TTimeIntervalMicroSeconds(duration.Int64()*8);
-00641                 return duration;
-00642                 }
-00643         else return TTimeIntervalMicroSeconds(0);
-00644         }
-00645 
-00646 // Calculate and return the number of bytes used for on second of audio.
-00647 TInt64 CMMFRawFormatWrite::BytesPerSecond() 
-00648         {
-00649         TInt64 bitsPerSecond = iSampleRate * iBitsPerSample * iChannels ;
-00650         TInt64 bytesPerSecond = bitsPerSecond/8;
-00651         return bytesPerSecond ;
-00652         }
-00653 
-00654 // Shortens the clip from the position specified to the end specified.
-00655 void CMMFRawFormatWrite::CropL(TTimeIntervalMicroSeconds aPosition, TBool aToEnd )
-00656         {
-00657         // Does clip have any size to crop
-00658         if (!(STATIC_CAST(CMMFClip*,iClip)->Size())) User::Leave(KErrNotFound); //no clip to crop or clip is 0 bytes.
-00659 
-00660 
-00661         // Is aPosition between the start and the end?
-00662         if ( ( aPosition < TTimeIntervalMicroSeconds(0) ) || ( aPosition >= Duration( KUidMediaTypeAudio) ) ) 
-00663                 User::Leave( KErrArgument ) ;
-00664 
-00665         // Convert aPostion to cropPosition in bytes
-00666 
-00667         TInt64 cropPosition64 = 
-00668                 TInt64( ( aPosition.Int64() * iSampleRate * (iBitsPerSample/8) * iChannels ) /KOneSecondInMicroSeconds);
-00669         TUint cropPosition = I64INT(cropPosition64);
-00670 
-00671         // Does cropPosition need adjustment to retain integrity?  (assume not)
-00672 
-00673         TUint dataSize ;  // This will be the size of the data left after cropping.
-00674 
-00675         if ( !aToEnd )
-00676                 {
-00677                 // Shift the data physically
-00678                 // move the data in blocks
-00679                 // Create a CMMFDataBuffer and use CMMFClip to shift the data
-00680                 dataSize = iMaxPos - cropPosition ;
-00681                 if (( dataSize > 0 ) && (aPosition != TTimeIntervalMicroSeconds(0)))
-00682                         {
-00683                         TUint bufSize = ( dataSize < KDefineIOBufferSize ? dataSize : KDefineIOBufferSize ) ; //max bufSize 512
-00684                         CMMFDataBuffer* buffer = CMMFDataBuffer::NewL(bufSize) ;
-00685                         CleanupStack::PushL( buffer ) ;
-00686 
-00687                         TUint rPos = cropPosition ; // read position
-00688                         TUint wPos = 0;
-00689                         TInt dataToShift = ETrue ;
-00690                         while ( dataToShift )
-00691                                 {
-00692                                 STATIC_CAST( CMMFClip*, iClip )->ReadBufferL( buffer, rPos ) ;  // synchronous calls
-00693                                 STATIC_CAST( CMMFClip*, iClip )->WriteBufferL( buffer, wPos ) ;
-00694                                 if ( rPos > iMaxPos ) 
-00695                                         dataToShift = EFalse ;  // past the end:  Done
-00696                                 else
-00697                                         { // shift the pointers
-00698                                         rPos += bufSize ;
-00699                                         wPos += bufSize ;
-00700                                         }
-00701                                 }// while data to shift
-00702                         CleanupStack::PopAndDestroy( ) ; // buffer
-00703                         }// if data to shift
-00704                 }// crop to start
-00705         else // crop to end
-00706                 dataSize = cropPosition ;
-00707 
-00708         iDataSize = dataSize ;
-00709         iMaxPos = dataSize ;
-00710 
-00711         // Do the physical chop
-00712         if ( iClip->DataSinkType() == KUidMmfFileSink )
-00713                 {
-00714                 STATIC_CAST( CMMFFile*, iClip )->FileL().SetSize( iMaxPos ) ;
-00715                 iClipLength = iMaxPos; 
-00716                 }
-00717         }
-00718 
-00719 // get the supported sample rates
-00720 void CMMFRawFormatWrite::GetSupportedSampleRatesL(RArray<TUint>& aSampleRates)
-00721         {
-00722         aSampleRates.Reset();
-00723 
-00724         // Iterate through the valid sample table and append each value to aSampleRates
-00725         TInt i = sizeof(KRawSampleRates) / sizeof(TUint);
-00726         
-00727         while (i--)
-00728                 {
-00729                 User::LeaveIfError(aSampleRates.Append(KRawSampleRates[i]));
-00730                 }
-00731         }
-00732 
-00733 // get the supported channel number options
-00734 void CMMFRawFormatWrite::GetSupportedNumChannelsL(RArray<TUint>& aNumChannels)
-00735         {
-00736         aNumChannels.Reset();
-00737         User::LeaveIfError(aNumChannels.Append(KMono));
-00738         User::LeaveIfError(aNumChannels.Append(KStereo));
-00739         }
-00740 
-00741 // set maximum clip size
-00742 void CMMFRawFormatWrite::SetMaximumClipSize(TInt aBytes)
-00743         {
-00744         iMaximumClipSize = aBytes;
-00745         }
-00746 
-00747 // get the supported codecs
-00748 void CMMFRawFormatWrite::GetSupportedDataTypesL(TMediaId aMediaId, RArray<TFourCC>& aDataTypes)
-00749         {
-00750         if (aMediaId.iMediaType != KUidMediaTypeAudio)
-00751                 User::Leave(KErrNotSupported);
-00752         aDataTypes.Reset();
-00753         User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodePCM16));
-00754         User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodePCM16B));
-00755         User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodePCMU16));
-00756         User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodeIMAD));
-00757         User::LeaveIfError(aDataTypes.Append(KMMFFourCCCodeIMAS));
-00758         }
-00759 
-00760 
-00761 // __________________________________________________________________________
-00762 // Exported proxy for instantiation method resolution
-00763 // Define the interface UIDs
-00764 
-00765 const TImplementationProxy ImplementationTable[] = 
-00766         {
-00767                 IMPLEMENTATION_PROXY_ENTRY(KRawDecoder, CMMFRawFormatRead::NewL),
-00768                 IMPLEMENTATION_PROXY_ENTRY(KRawEncoder, CMMFRawFormatWrite::NewL)
-00769         };
-00770 
-00771 EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
-00772         {
-00773         aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);
-00774 
-00775         return ImplementationTable;
-00776         }
-