diff -r 000000000000 -r 951a5db380a0 videoeditorengine/audioeditorengine/src/ProcProcessAO.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/videoeditorengine/audioeditorengine/src/ProcProcessAO.cpp	Fri Jan 29 14:08:33 2010 +0200
@@ -0,0 +1,332 @@
+/*
+* Copyright (c) 2010 Ixonos Plc.
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - Initial contribution
+*
+* Contributors:
+* Ixonos Plc
+*
+* Description:  
+*
+*/
+
+
+
+#include "ProcProcessAO.h"
+#include "AudCommon.h"
+#include "AudPanic.h"
+#include "audconstants.h"
+
+
+
+
+TBool CProcProcess::StartSyncProcessingL(const CAudSong* aSong, TBool aGetTimeEstimation)
+    {
+
+    iSong = aSong;
+    
+    if (iEncoder != 0)
+        {
+        delete iEncoder;
+        iEncoder = 0;
+        }
+    iEncoder = CProcEncoder::NewL();
+    iEncoder->InitL(iSong->OutputFileProperties().iAudioType, 
+                    iSong->OutputFileProperties().iSamplingRate,
+                    iSong->OutputFileProperties().iChannelMode, 
+                    iSong->OutputFileProperties().iBitrate );
+                    
+    
+    if (iAMRBuf)
+        {
+        delete iAMRBuf;
+        iAMRBuf = 0;
+        
+        }
+    // buffer for extra AMR-frames
+    iAMRBuf = HBufC8::NewL(KAedMaxAMRFrameLength);
+    
+    if (iDecBuffer)
+        {
+        delete iDecBuffer;   
+        iDecBuffer = 0;
+        
+        }
+        
+    iDecBuffer = HBufC8::NewL(KAedMaxFeedBufferSize);
+    
+    TInt rawFrameSize = KAedSizeAMRBuffer;
+    if (aSong->OutputFileProperties().iSamplingRate == KAedSampleRate8kHz)
+        {
+        rawFrameSize = KAedSizeAMRBuffer;
+        }
+    else 
+        {
+        rawFrameSize = KAedSizeAACBuffer;
+        if ( aSong->OutputFileProperties().iChannelMode == EAudStereo )
+            {
+            rawFrameSize *= 2;
+            }
+        }
+    
+
+    CAudProcessorImpl* processorImpl = CAudProcessorImpl::NewLC();
+
+    processorImpl->ProcessSongL(aSong, rawFrameSize, aGetTimeEstimation);
+
+    CleanupStack::Pop(processorImpl);
+    iProcessorImpl = processorImpl;
+
+
+    return ETrue;
+
+    }
+
+TBool CProcProcess::ProcessSyncPieceL(HBufC8*& aFrame, TInt& aProgress,
+                                       TTimeIntervalMicroSeconds& aDuration)
+    {
+    
+    // first check if we have frames left from the previous encoding
+    
+    if (iAMRBuf->Length() > 0)
+        {
+        // we do have some frames left
+        
+        TInt frLen = ProcTools::GetNextAMRFrameLength(iAMRBuf, 0);
+        
+        if (frLen > iAMRBuf->Length())
+            {
+            // something has gone wrong, we don't have a proper AMR frame in the buffer
+            User::Leave(KErrGeneral);
+            }
+        
+        aFrame = HBufC8::NewL(frLen);
+        aFrame->Des().Append(iAMRBuf->Left(frLen));
+        iAMRBuf->Des().Delete(0, frLen);
+        
+        aDuration = KAedAMRFrameDuration;
+        iProgress = aProgress;
+        
+        return EFalse;
+        }
+    
+    iDecBuffer->Des().Delete(0, iDecBuffer->Size());
+    
+    HBufC8* frame = 0;
+        
+    TBool rawFrame = EFalse;
+    
+    TInt outDurationMilli = 0;
+    
+    TBool ret = iProcessorImpl->ProcessSyncPieceL(frame, aProgress, aDuration, rawFrame);
+    iProgress = aProgress;
+    
+    if (!rawFrame)
+        {
+        
+        // frame already in compressed domain, no need for encoding
+        if (ret || frame == 0) 
+            {
+            
+            iTimeEstimate = iProcessorImpl->GetFinalTimeEstimate();
+            
+            aFrame = frame;
+            // no more frames left -> processing ready
+            delete iProcessorImpl;
+            iProcessorImpl = 0;
+            delete iDecBuffer;
+            iDecBuffer = 0;
+            return ETrue;
+            }
+        else 
+            {
+            aFrame = frame;
+            return EFalse;
+            }
+    
+        }
+    else
+        {
+        // frame needs to be encoded
+        if (ret || frame == 0) 
+            {
+            
+            iTimeEstimate = iProcessorImpl->GetFinalTimeEstimate();
+            // no more frames left -> processing ready
+            delete iProcessorImpl;
+            iProcessorImpl = 0;
+            delete iDecBuffer;
+            iDecBuffer = 0;
+            return ETrue;
+            }    
+        
+        
+        // feed encoder until we have something in the output buffer
+
+        
+        iEncoder->FillEncBufferL(*frame, iDecBuffer, outDurationMilli);
+ 
+        delete frame;
+        frame = 0;
+   
+        while (iDecBuffer->Size() == 0)
+            {
+            
+            // we need more input for encoder
+            
+            TTimeIntervalMicroSeconds dur;
+                       ret = iProcessorImpl->ProcessSyncPieceL(frame, aProgress, dur, rawFrame);
+                
+            if (!ret)
+                {
+                
+                }
+            else
+                {
+                
+                // no more frames left -> processing ready
+                
+                
+                iTimeEstimate = iProcessorImpl->GetFinalTimeEstimate();
+                delete iProcessorImpl;
+                iProcessorImpl = 0;
+                delete iDecBuffer;
+                iDecBuffer = 0;
+                return ETrue;
+                }
+                
+  
+            
+            iProgress = aProgress;
+            
+            if (ret) 
+                {
+                
+                // no more frames left -> processing ready
+                
+                iTimeEstimate = iProcessorImpl->GetFinalTimeEstimate();
+                delete iProcessorImpl;
+                iProcessorImpl = 0;
+                delete iDecBuffer;
+                iDecBuffer = 0;
+                return ETrue;
+                }
+            
+            if (!rawFrame)
+                {
+          
+                // we got encoded frame -> return it
+                aFrame = frame;
+                return EFalse;
+                }
+            
+            // we should now have a raw frame in aFrame -> feed the encoder
+            
+            aDuration = aDuration.Int64() + dur.Int64();
+
+            iEncoder->FillEncBufferL(*frame, iDecBuffer, outDurationMilli);
+            delete frame;
+            frame = 0;
+          
+            }
+        
+        }
+        
+    // read the encoded frame to aFrame
+    
+    TInt frameLen = 0;
+    if (iEncoder->DestAudType() == EAudAMR)
+        {
+        frameLen = ProcTools::GetNextAMRFrameLength(iDecBuffer, 0);
+        }
+    
+    if (frameLen < iDecBuffer->Length() && iEncoder->DestAudType() == EAudAMR)
+        {
+        
+        // we got more than one AMR frame, return the first now
+        // and the second when this function is called next time
+        aFrame = HBufC8::NewL(frameLen);
+        aFrame->Des().Append(iDecBuffer->Des().Left(frameLen));
+        
+        if ( (iDecBuffer->Length() + iAMRBuf->Length() - frameLen) > iAMRBuf->Des().MaxLength())
+            {
+            // if the temporary storage is too small, we need more space for it
+            iAMRBuf = iAMRBuf->ReAlloc(iDecBuffer->Length() + iAMRBuf->Length() - frameLen);
+            }
+            
+        iAMRBuf->Des().Append(iDecBuffer->Right(iDecBuffer->Length() - frameLen));
+        
+        }
+    else
+        {
+        
+        aFrame = HBufC8::NewL(iDecBuffer->Size());
+        aFrame->Des().Append(iDecBuffer->Des());
+        
+        }
+        
+    iDecBuffer->Des().Delete(0, iDecBuffer->Size());
+           
+    aDuration = outDurationMilli*1000;
+    
+    return EFalse;
+    
+    }
+
+TInt64 CProcProcess::GetFinalTimeEstimate() const
+    {
+    
+    return iTimeEstimate;
+    
+    }
+
+
+CProcProcess* CProcProcess::NewL() 
+    {
+
+
+    CProcProcess* self = new (ELeave) CProcProcess();
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+CProcProcess::~CProcProcess() 
+    {
+
+    if (iProcessorImpl != 0)
+        {
+        delete iProcessorImpl;
+        iProcessorImpl = 0;
+        }
+        
+    delete iEncoder;
+    
+    delete iDecBuffer;
+    iDecBuffer = 0;
+    
+    delete iAMRBuf;
+    
+    
+    }
+    
+
+void CProcProcess::ConstructL() 
+    {
+    
+    
+    }
+
+CProcProcess::CProcProcess() : iProcessorImpl(0), iSong(0)
+    {
+
+    }
+    
+