Ticket #872: symbian-mda-g711.patch

pjmedia/src/pjmedia-audiodev/symb_mda_dev.cpp

@@ -38 +38 @@
 #include <mdaaudiooutputstream.h>
 #include <mdaaudioinputstream.h>
 
+#include "s60_g729_bitstream.h"
 
 #define THIS_FILE                       "symb_mda_dev.c"
 #define BITS_PER_SAMPLE                 16
@@ -50 +51 @@
 #   define TRACE_(st)
 #endif
 
+/* Forward decl */
+class CPjSndUtility;
 
 /* MDA factory */
 struct mda_factory
@@ -57 +60 @@
     pjmedia_aud_dev_factory      base;
     pj_pool_t                   *pool;
     pj_pool_factory             *pf;
+    CPjSndUtility               *sndUtility;
     pjmedia_aud_dev_info         dev_info;
 };
 
@@ -74 +78 @@
     pj_pool_t           *pool;                  /**< Memory pool.       */
 
     // Common settings.
-    pjmedia_aud_param param;            /**< Stream param.      */
+    pjmedia_aud_param    param;                 /**< Stream param.      */
 
     // Audio engine
     CPjAudioInputEngine *in_engine;             /**< Record engine.     */
     CPjAudioOutputEngine *out_engine;           /**< Playback engine.   */
+    
+    // Detected G.711 frame size
+    unsigned             mda_g711_frame_len;
 };
 
 
@@ -176 +183 @@
 {
     PJ_LOG(1,(THIS_FILE, "%s: error code %d", title, rc));
 }
- 
+
+static TFourCC format_id_to_fourcc(const pjmedia_format *fmt)
+{
+    switch (fmt->id) {
+    case PJMEDIA_FORMAT_L16:
+    case PJMEDIA_FORMAT_PCMA:
+        return TFourCC('G', '7', '1', '1');
+    case PJMEDIA_FORMAT_AMR:
+        return TFourCC(' ', 'A', 'M', 'R');
+    case PJMEDIA_FORMAT_G729:
+        return TFourCC('G', '7', '2', '9');
+    case PJMEDIA_FORMAT_ILBC:
+        return TFourCC('i', 'L', 'B', 'C');
+    }
+    
+    pj_assert(!"Unsupported codec");
+    return TFourCC('G', '7', '1', '1');
+}
+
 //////////////////////////////////////////////////////////////////////////////
 //
 
@@ -240 +265 @@
 
     // cache variable
     // to avoid calculating frame length repeatedly
-    TInt                     frameLen_;
+    TInt                     pcmFrameLen_;
     
     // sometimes recorded size != requested framesize, so let's
     // provide a buffer to make sure the rec callback returning
@@ -248 +273 @@
     TUint8                  *frameRecBuf_;
     TInt                     frameRecBufLen_;
 
+    // is the device opened in g711 format?
+    bool                     fmt_g711_;
+    
+    // stuffs to process encoded frame
+    TBitStream               bitStream_;
+    
     CPjAudioInputEngine(struct mda_stream *parent_strm,
             pjmedia_aud_rec_cb rec_cb,
                         void *user_data);
     void ConstructL();
     TPtr8 & GetFrame();
     
+    void RecCbPcm(const TDesC8 &aBuffer);
+    void RecCbEncoded(const TDesC8 &aBuffer);
+    
 public:
     virtual void MaiscOpenComplete(TInt aError);
     virtual void MaiscBufferCopied(TInt aError, const TDesC8 &aBuffer);
@@ -269 +303 @@
       recCb_(rec_cb), userData_(user_data), 
       iInputStream_(NULL), iStreamBuffer_(NULL), iFramePtr_(0, 0),
       lastError_(KErrNone), timeStamp_(0),
-      frameLen_(parent_strm->param.samples_per_frame * 
-                BYTES_PER_SAMPLE),
-      frameRecBuf_(NULL), frameRecBufLen_(0)
+      pcmFrameLen_(parent_strm->param.samples_per_frame * 
+                   BYTES_PER_SAMPLE),
+      frameRecBuf_(NULL), frameRecBufLen_(0),
+      fmt_g711_(false)
 {
 }
 
@@ -289 +324 @@
 
 void CPjAudioInputEngine::ConstructL()
 {
-    iStreamBuffer_ = HBufC8::NewL(frameLen_);
+    iStreamBuffer_ = HBufC8::NewL(pcmFrameLen_);
     CleanupStack::PushL(iStreamBuffer_);
 
-    frameRecBuf_ = new TUint8[frameLen_*2];
+    frameRecBuf_ = new TUint8[pcmFrameLen_*2];
     CleanupStack::PushL(frameRecBuf_);
 }
 
@@ -362 +397 @@
     iInputStream_->Open(&iStreamSettings);
     
     // Success
-    PJ_LOG(4,(THIS_FILE, "Sound capture started."));
     return PJ_SUCCESS;
 }
 
@@ -390 +424 @@
 
 TPtr8 & CPjAudioInputEngine::GetFrame() 
 {
-    //iStreamBuffer_->Des().FillZ(frameLen_);
-    iFramePtr_.Set((TUint8*)(iStreamBuffer_->Ptr()), frameLen_, frameLen_);
+    //iStreamBuffer_->Des().FillZ(pcmFrameLen_);
+    iFramePtr_.Set((TUint8*)(iStreamBuffer_->Ptr()), pcmFrameLen_, pcmFrameLen_);
     return iFramePtr_;
 }
 
@@ -403 +437 @@
         return;
     }
 
+    PJ_LOG(4,(THIS_FILE, "Sound capture started."));
+    
     // set stream priority to normal and time sensitive
     iInputStream_->SetPriority(EPriorityNormal, 
-                               EMdaPriorityPreferenceTime);                             
-
+                               EMdaPriorityPreferenceTime);
+    
+    // set the stream format
+    TFourCC aFmt = format_id_to_fourcc(&parentStrm_->param.ext_fmt);
+    TRAPD(fmterr, iInputStream_->SetDataTypeL(aFmt));
+    if (fmterr) {
+        if (parentStrm_->param.ext_fmt.id != 0) {
+            // This is error since we can't open codec as requested
+            snd_perror("Unable to set capture format", aError);
+            return;
+        } else {
+            // This is fine. The stream is opened in PCM but we couldn't
+            // set G.711 codec, so just revert back to use PCM.
+            fmt_g711_ = false;
+        }
+    } else {
+        if (parentStrm_->param.ext_fmt.id == 0)
+            fmt_g711_ = true;
+    }
+    
     // Read the first frame.
     TPtr8 & frm = GetFrame();
     TRAPD(err2, iInputStream_->ReadL(frm));
@@ -415 +469 @@
     }
 }
 
-void CPjAudioInputEngine::MaiscBufferCopied(TInt aError, 
-                                            const TDesC8 &aBuffer)
+// Record callback for PCM format.
+void CPjAudioInputEngine::RecCbPcm(const TDesC8 &aBuffer)
 {
-    lastError_ = aError;
-    if (aError != KErrNone) {
-        snd_perror("Error in MaiscBufferCopied()", aError);
-        return;
-    }
-
-    if (frameRecBufLen_ || aBuffer.Length() < frameLen_) {
-        pj_memcpy(frameRecBuf_ + frameRecBufLen_, (void*) aBuffer.Ptr(), aBuffer.Length());
+    if (fmt_g711_) {
+        pj_assert(aBuffer.Length() >= 2);
+        if (aBuffer[0]==1 && aBuffer[1]==0) {
+            /* Normal voice */
+            pjmedia_alaw_decode((short*)(frameRecBuf_ + frameRecBufLen_), 
+                                ((const pj_uint8_t*)aBuffer.Ptr())+2, 
+                                aBuffer.Length()-2);
+            frameRecBufLen_ += ((aBuffer.Length()-2) << 1);
+        } else {
+            /* Zeroes or SID */
+            pj_bzero(frameRecBuf_ + frameRecBufLen_, ((aBuffer.Length()-2) << 1));
+            frameRecBufLen_ += ((aBuffer.Length()-2) << 1);
+        }
+    } else {
+        pj_memcpy(frameRecBuf_ + frameRecBufLen_, (void*) aBuffer.Ptr(), 
+                  aBuffer.Length());
         frameRecBufLen_ += aBuffer.Length();
     }
-
+        
     if (frameRecBufLen_) {
-        while (frameRecBufLen_ >= frameLen_) {
+        while (frameRecBufLen_ >= pcmFrameLen_) {
             pjmedia_frame f;
             
             f.type = PJMEDIA_FRAME_TYPE_AUDIO;
             f.buf = frameRecBuf_;
-            f.size = frameLen_;
+            f.size = pcmFrameLen_;
             f.timestamp.u32.lo = timeStamp_;
             f.bit_info = 0;
             
@@ -444 +506 @@
             // Increment timestamp.
             timeStamp_ += parentStrm_->param.samples_per_frame;
 
-            frameRecBufLen_ -= frameLen_;
-            pj_memmove(frameRecBuf_, frameRecBuf_+frameLen_, frameRecBufLen_);
+            frameRecBufLen_ -= pcmFrameLen_;
+            pj_memmove(frameRecBuf_, frameRecBuf_+pcmFrameLen_, frameRecBufLen_);
         }
-    } else {
-        pjmedia_frame f;
-        
-        f.type = PJMEDIA_FRAME_TYPE_AUDIO;
-        f.buf = (void*)aBuffer.Ptr();
-        f.size = aBuffer.Length();
-        f.timestamp.u32.lo = timeStamp_;
-        f.bit_info = 0;
-        
-        // Call the callback.
-        recCb_(userData_, &f);
-        
-        // Increment timestamp.
-        timeStamp_ += parentStrm_->param.samples_per_frame;
     }
-
+    
     // Record next frame
     TPtr8 & frm = GetFrame();
     TRAPD(err2, iInputStream_->ReadL(frm));
@@ -471 +519 @@
     }
 }
 
+// Record callback for encoded format.
+void CPjAudioInputEngine::RecCbEncoded(const TDesC8 &aBuffer)
+{
+    pjmedia_frame_ext *frame = (pjmedia_frame_ext*) frameRecBuf_;
+    
+    switch(parentStrm_->param.ext_fmt.id) {
+    case PJMEDIA_FORMAT_AMR:
+        {
+            const pj_uint8_t *p = (const pj_uint8_t*)aBuffer.Ptr() + 1;
+            unsigned len = aBuffer.Length() - 1;
+            
+            pjmedia_frame_ext_append_subframe(frame, p, len << 3, 160);
+            if (frame->samples_cnt >= parentStrm_->param.samples_per_frame) {
+                frame->base.type = PJMEDIA_FRAME_TYPE_EXTENDED;
+                recCb_(userData_, (pjmedia_frame*)frame);
+                frame->samples_cnt = 0;
+                frame->subframe_cnt = 0;
+            }
+        }
+        break;
+        
+    case PJMEDIA_FORMAT_G729:
+        {
+            /* Check if we got a normal or SID frame. */
+            if (aBuffer[0] != 0 || aBuffer[1] != 0) {
+                enum { NORMAL_LEN = 22, SID_LEN = 8 };
+                unsigned src_len = aBuffer.Length()- 2;
+                
+                pj_assert(src_len == NORMAL_LEN || src_len == SID_LEN);
 
+                const TDesC8& p = bitStream_.CompressG729Frame(
+                                            aBuffer.Right(src_len), 
+                                            src_len == SID_LEN);
+                
+                pjmedia_frame_ext_append_subframe(frame, p.Ptr(), 
+                                                  p.Length() << 3, 80);
+            } else { /* We got null frame. */
+                pjmedia_frame_ext_append_subframe(frame, NULL, 0, 80);
+            }
+            
+            if (frame->samples_cnt >= parentStrm_->param.samples_per_frame) {
+                frame->base.type = PJMEDIA_FRAME_TYPE_EXTENDED;
+                recCb_(userData_, (pjmedia_frame*)frame);
+                frame->samples_cnt = 0;
+                frame->subframe_cnt = 0;
+            }
+        }
+        break;
+
+    case PJMEDIA_FORMAT_ILBC:
+        {
+            unsigned samples_got;
+            
+            samples_got = (parentStrm_->param.ext_fmt.bitrate) == 15200? 
+                                160 : 240;
+            
+            /* Check if we got a normal frame. */
+            if (aBuffer[0] == 1 && aBuffer[1] == 0) {
+                const pj_uint8_t *p = (const pj_uint8_t*)aBuffer.Ptr() + 2;
+                unsigned len = aBuffer.Length() - 2;
+                
+                pjmedia_frame_ext_append_subframe(frame, p, len << 3,
+                                                  samples_got);
+            } else { /* We got null frame. */
+                pjmedia_frame_ext_append_subframe(frame, NULL, 0, samples_got);
+            }
+            
+            if (frame->samples_cnt >= parentStrm_->param.samples_per_frame) {
+                frame->base.type = PJMEDIA_FRAME_TYPE_EXTENDED;
+                recCb_(userData_, (pjmedia_frame*)frame);
+                frame->samples_cnt = 0;
+                frame->subframe_cnt = 0;
+            }
+        }
+        break;
+        
+    case PJMEDIA_FORMAT_PCMU:
+    case PJMEDIA_FORMAT_PCMA:
+        {
+            unsigned samples_processed = 0;
+            
+            /* Make sure it is normal frame. */
+            pj_assert(aBuffer[0] == 1 && aBuffer[1] == 0);
+
+            /* Detect the recorder G.711 frame size, player frame size will 
+             * follow this recorder frame size.
+             */
+            if (parentStrm_->mda_g711_frame_len == 0) {
+                parentStrm_->mda_g711_frame_len = aBuffer.Length()-2;
+                TRACE_((THIS_FILE, "Detected MDA G.711 frame size = %u samples",
+                        parentStrm_->mda_g711_frame_len));
+            }
+            
+            /* Convert APS buffer format into pjmedia_frame_ext. Whenever 
+             * samples count in the frame is equal to stream's samples per 
+             * frame, call parent stream callback.
+             */
+            while (samples_processed < parentStrm_->mda_g711_frame_len) {
+                unsigned tmp;
+                const pj_uint8_t *pb = (const pj_uint8_t*)aBuffer.Ptr() +
+                                       2 + samples_processed;
+    
+                tmp = PJ_MIN(parentStrm_->param.samples_per_frame - frame->samples_cnt,
+                             parentStrm_->mda_g711_frame_len - samples_processed);
+                
+                pjmedia_frame_ext_append_subframe(frame, pb, tmp << 3, tmp);
+                samples_processed += tmp;
+    
+                if (frame->samples_cnt >= parentStrm_->param.samples_per_frame) {
+                    frame->base.type = PJMEDIA_FRAME_TYPE_EXTENDED;
+                    recCb_(userData_, (pjmedia_frame*)frame);
+                    frame->samples_cnt = 0;
+                    frame->subframe_cnt = 0;
+                }
+            }
+        }
+        break;
+        
+    default:
+        break;
+    }
+
+}
+
+void CPjAudioInputEngine::MaiscBufferCopied(TInt aError, 
+                                            const TDesC8 &aBuffer)
+{
+    lastError_ = aError;
+    if (aError != KErrNone) {
+        snd_perror("Error in MaiscBufferCopied()", aError);
+        return;
+    }
+    
+    if (this->parentStrm_->param.ext_fmt.id == 0)
+        RecCbPcm(aBuffer);
+    else
+        RecCbEncoded(aBuffer);
+}
+
+
 void CPjAudioInputEngine::MaiscRecordComplete(TInt aError)
 {
     lastError_ = aError;
@@ -540 +727 @@
     pjmedia_aud_play_cb      playCb_;
     void                    *userData_;
     CMdaAudioOutputStream   *iOutputStream_;
-    TUint8                  *frameBuf_;
-    unsigned                 frameBufSize_;
+    TUint8                  *frameBuf_;         // buffer for playCb_
+    unsigned                 frameBufSize_;     // left over samples in frameBuf_
+    unsigned                 frameBufCapacity_; // frameBuf_ capacity
     TPtrC8                   frame_;
     TInt                     lastError_;
     unsigned                 timestamp_;
-
+    bool                     fmt_g711_;
+    pj_uint8_t              *tmpEncodedFrame_;
+    
     CPjAudioOutputEngine(struct mda_stream *parent_strm,
                          pjmedia_aud_play_cb play_cb,
                          void *user_data);
@@ -554 +744 @@
     virtual void MaoscOpenComplete(TInt aError);
     virtual void MaoscBufferCopied(TInt aError, const TDesC8& aBuffer);
     virtual void MaoscPlayComplete(TInt aError);
+    
+    bool GetFramePcm();
+    bool PlayFramePcm();
+    bool PlayFrameEncoded();
 };
 
 
@@ -561 +755 @@
                                            pjmedia_aud_play_cb play_cb,
                                            void *user_data) 
 : state_(STATE_INACTIVE), parentStrm_(parent_strm), playCb_(play_cb), 
-  userData_(user_data), iOutputStream_(NULL), frameBuf_(NULL),
-  lastError_(KErrNone), timestamp_(0)
+  userData_(user_data), iOutputStream_(NULL), frameBuf_(NULL), frameBufSize_(0),
+  lastError_(KErrNone), timestamp_(0), fmt_g711_(false), tmpEncodedFrame_(NULL)
 {
 }
 
 
 void CPjAudioOutputEngine::ConstructL()
 {
-    frameBufSize_ = parentStrm_->param.samples_per_frame *
-                    BYTES_PER_SAMPLE;
-    frameBuf_ = new TUint8[frameBufSize_];
+    frameBufCapacity_ = parentStrm_->param.samples_per_frame * 2 *
+                        BYTES_PER_SAMPLE;
+    frameBuf_ = new TUint8[frameBufCapacity_];
+    tmpEncodedFrame_ = new TUint8[parentStrm_->param.samples_per_frame+2];
 }
 
 CPjAudioOutputEngine::~CPjAudioOutputEngine()
 {
     Stop();
-    delete [] frameBuf_;        
+    delete [] frameBuf_;
+    delete [] tmpEncodedFrame_;
 }
 
 CPjAudioOutputEngine *
@@ -663 +859 @@
     state_ = STATE_INACTIVE;
 }
 
+bool CPjAudioOutputEngine::GetFramePcm()
+{
+    pjmedia_frame f;
+    unsigned pcm_size = parentStrm_->param.samples_per_frame * BYTES_PER_SAMPLE;
+    pj_status_t status;
+    
+    f.type = PJMEDIA_FRAME_TYPE_AUDIO;
+    f.buf = frameBuf_+frameBufSize_;
+    f.size = pcm_size;
+    f.timestamp.u32.lo = timestamp_;
+    f.bit_info = 0;
+    
+    status = playCb_(this->userData_, &f);
+    if (status != PJ_SUCCESS) {
+        this->Stop();
+        return false;
+    }
+
+    if (f.type != PJMEDIA_FRAME_TYPE_AUDIO || f.size == 0) {
+        pj_bzero(frameBuf_, pcm_size);
+        f.size = pcm_size;
+    }
+    
+    frameBufSize_ += pcm_size;
+    
+    // Increment timestamp.
+    timestamp_ += (pcm_size / BYTES_PER_SAMPLE);
+
+    return true;
+}
+
+bool CPjAudioOutputEngine::PlayFramePcm()
+{
+    if (fmt_g711_) {
+        // Here we open MDA in G.711 mode although user asked PCM
+        unsigned frame_size = parentStrm_->mda_g711_frame_len;
+        
+        if (frame_size==0)
+            frame_size = 320;
+        
+        // If we don't have enough samples in the buffer to fill in one frame,
+        // ask user.
+        if (frameBufSize_ < frame_size) {
+            if (!GetFramePcm())
+                return false;
+        }
+        
+        pj_assert(frameBufSize_ >= frame_size);
+        
+        pjmedia_alaw_encode((pj_uint8_t*)tmpEncodedFrame_+2, 
+                            (const pj_int16_t*)frameBuf_, 
+                            frame_size >> 1);
+        tmpEncodedFrame_[0] = 1;
+        tmpEncodedFrame_[1] = 0;
+        frame_.Set(tmpEncodedFrame_, (frame_size >> 1) + 2);
+        iOutputStream_->WriteL(frame_);
+        
+        frameBufSize_ -= frame_size;
+        pj_memmove(frameBuf_, frameBuf_ + frame_size, frameBufSize_);
+    } else {
+        // Here we open MDA in PCM mode, so just return the frame
+        pj_assert(frameBufSize_ == 0);
+        
+        if (!GetFramePcm())
+            return false;
+        
+        frame_.Set(frameBuf_, frameBufSize_);
+        iOutputStream_->WriteL(frame_);
+        
+        frameBufSize_ = 0;
+    }
+    
+    return true;
+}
+
+bool CPjAudioOutputEngine::PlayFrameEncoded()
+{
+    pjmedia_frame_ext *frame = (pjmedia_frame_ext*) frameBuf_;
+
+    switch(parentStrm_->param.ext_fmt.id) {
+    case PJMEDIA_FORMAT_AMR:
+        {
+            if (frame->samples_cnt == 0) {
+                frame->base.type = PJMEDIA_FRAME_TYPE_EXTENDED;
+                strm->play_cb(strm->user_data, (pjmedia_frame*)frame);
+                pj_assert(frame->base.type==PJMEDIA_FRAME_TYPE_EXTENDED ||
+                          frame->base.type==PJMEDIA_FRAME_TYPE_NONE);
+            }
+
+            if (frame->base.type == PJMEDIA_FRAME_TYPE_EXTENDED) { 
+                pjmedia_frame_ext_subframe *sf;
+                unsigned samples_cnt;
+                
+                sf = pjmedia_frame_ext_get_subframe(frame, 0);
+                samples_cnt = frame->samples_cnt / frame->subframe_cnt;
+                
+                if (sf->data && sf->bitlen) {
+                    /* AMR header for APS is one byte, the format (may be!):
+                     * 0xxxxy00, where xxxx:frame type, y:not sure. 
+                     */
+                    unsigned len = (sf->bitlen+7)>>3;
+                    enum {SID_FT = 8 };
+                    pj_uint8_t amr_header = 4, ft = SID_FT;
+
+                    if (len >= pjmedia_codec_amrnb_framelen[0])
+                        ft = pjmedia_codec_amr_get_mode2(PJ_TRUE, len);
+                    
+                    amr_header |= ft << 3;
+                    buf.iBuffer.Append(amr_header);
+                    
+                    buf.iBuffer.Append((TUint8*)sf->data, len);
+                } else {
+                    buf.iBuffer.Append(0);
+                }
+
+                pjmedia_frame_ext_pop_subframes(frame, 1);
+            
+            } else { /* PJMEDIA_FRAME_TYPE_NONE */
+                buf.iBuffer.Append(0);
+                
+                frame->samples_cnt = 0;
+                frame->subframe_cnt = 0;
+            }
+        }
+        break;
+        
+    case PJMEDIA_FORMAT_G729:
+        {
+            if (frame->samples_cnt == 0) {
+                frame->base.type = PJMEDIA_FRAME_TYPE_EXTENDED;
+                strm->play_cb(strm->user_data, (pjmedia_frame*)frame);
+                pj_assert(frame->base.type==PJMEDIA_FRAME_TYPE_EXTENDED ||
+                          frame->base.type==PJMEDIA_FRAME_TYPE_NONE);
+            }
+
+            if (frame->base.type == PJMEDIA_FRAME_TYPE_EXTENDED) { 
+                pjmedia_frame_ext_subframe *sf;
+                unsigned samples_cnt;
+                
+                sf = pjmedia_frame_ext_get_subframe(frame, 0);
+                samples_cnt = frame->samples_cnt / frame->subframe_cnt;
+                
+                if (sf->data && sf->bitlen) {
+                    enum { NORMAL_LEN = 10, SID_LEN = 2 };
+                    pj_bool_t sid_frame = ((sf->bitlen >> 3) == SID_LEN);
+                    TBitStream *bitstream = (TBitStream*)strm->strm_data;
+                    const TPtrC8 src(sf->data, sf->bitlen>>3);
+                    const TDesC8 &dst = bitstream->ExpandG729Frame(src,
+                                                                   sid_frame); 
+                    if (sid_frame) {
+                        buf.iBuffer.Append(0);
+                        buf.iBuffer.Append(1);
+                    } else {
+                        buf.iBuffer.Append(1);
+                        buf.iBuffer.Append(0);
+                    }
+                    buf.iBuffer.Append(dst);
+                } else {
+                    buf.iBuffer.Append(0);
+                    buf.iBuffer.Append(0);
+                }
+
+                pjmedia_frame_ext_pop_subframes(frame, 1);
+            
+            } else { /* PJMEDIA_FRAME_TYPE_NONE */
+                buf.iBuffer.Append(0);
+                buf.iBuffer.Append(0);
+                
+                frame->samples_cnt = 0;
+                frame->subframe_cnt = 0;
+            }
+        }
+        break;
+        
+    case PJMEDIA_FORMAT_ILBC:
+        {
+            if (frame->samples_cnt == 0) {
+                frame->base.type = PJMEDIA_FRAME_TYPE_EXTENDED;
+                strm->play_cb(strm->user_data, (pjmedia_frame*)frame);
+                pj_assert(frame->base.type==PJMEDIA_FRAME_TYPE_EXTENDED ||
+                          frame->base.type==PJMEDIA_FRAME_TYPE_NONE);
+            }
+
+            if (frame->base.type == PJMEDIA_FRAME_TYPE_EXTENDED) { 
+                pjmedia_frame_ext_subframe *sf;
+                unsigned samples_cnt;
+                
+                sf = pjmedia_frame_ext_get_subframe(frame, 0);
+                samples_cnt = frame->samples_cnt / frame->subframe_cnt;
+                
+                pj_assert((strm->param.ext_fmt.bitrate == 15200 && 
+                           samples_cnt == 160) ||
+                          (strm->param.ext_fmt.bitrate != 15200 &&
+                           samples_cnt == 240));
+                
+                if (sf->data && sf->bitlen) {
+                    buf.iBuffer.Append(1);
+                    buf.iBuffer.Append(0);
+                    buf.iBuffer.Append((TUint8*)sf->data, sf->bitlen>>3);
+                } else {
+                    buf.iBuffer.Append(0);
+                    buf.iBuffer.Append(0);
+                }
+
+                pjmedia_frame_ext_pop_subframes(frame, 1);
+            
+            } else { /* PJMEDIA_FRAME_TYPE_NONE */
+                buf.iBuffer.Append(0);
+                buf.iBuffer.Append(0);
+                
+                frame->samples_cnt = 0;
+                frame->subframe_cnt = 0;
+            }
+        }
+        break;
+        
+    case PJMEDIA_FORMAT_PCMU:
+    case PJMEDIA_FORMAT_PCMA:
+        {
+            unsigned samples_ready = 0;
+            unsigned samples_req = aps_g711_frame_len;
+            
+            /* Assume frame size is 10ms if frame size hasn't been known. */
+            if (samples_req == 0)
+                samples_req = 80;
+            
+            buf.iBuffer.Append(1);
+            buf.iBuffer.Append(0);
+            
+            /* Call parent stream callback to get samples to play. */
+            while (samples_ready < samples_req) {
+                if (frame->samples_cnt == 0) {
+                    frame->base.type = PJMEDIA_FRAME_TYPE_EXTENDED;
+                    strm->play_cb(strm->user_data, (pjmedia_frame*)frame);
+                    pj_assert(frame->base.type==PJMEDIA_FRAME_TYPE_EXTENDED ||
+                              frame->base.type==PJMEDIA_FRAME_TYPE_NONE);
+                }
+    
+                if (frame->base.type == PJMEDIA_FRAME_TYPE_EXTENDED) { 
+                    pjmedia_frame_ext_subframe *sf;
+                    unsigned samples_cnt;
+                    
+                    sf = pjmedia_frame_ext_get_subframe(frame, 0);
+                    samples_cnt = frame->samples_cnt / frame->subframe_cnt;
+                    if (sf->data && sf->bitlen) {
+                        buf.iBuffer.Append((TUint8*)sf->data, sf->bitlen>>3);
+                    } else {
+                        pj_uint8_t silc;
+                        silc = (strm->param.ext_fmt.id==PJMEDIA_FORMAT_PCMU)?
+                                pjmedia_linear2ulaw(0) : pjmedia_linear2alaw(0);
+                        buf.iBuffer.AppendFill(silc, samples_cnt);
+                    }
+                    samples_ready += samples_cnt;
+                    
+                    pjmedia_frame_ext_pop_subframes(frame, 1);
+                
+                } else { /* PJMEDIA_FRAME_TYPE_NONE */
+                    pj_uint8_t silc;
+                    
+                    silc = (strm->param.ext_fmt.id==PJMEDIA_FORMAT_PCMU)?
+                            pjmedia_linear2ulaw(0) : pjmedia_linear2alaw(0);
+                    buf.iBuffer.AppendFill(silc, samples_req - samples_ready);
+
+                    samples_ready = samples_req;
+                    frame->samples_cnt = 0;
+                    frame->subframe_cnt = 0;
+                }
+            }
+        }
+        break;
+        
+    default:
+        break;
+    }
+}
+
 void CPjAudioOutputEngine::MaoscOpenComplete(TInt aError)
 {
     lastError_ = aError;
@@ -688 +1160 @@
         iOutputStream_->SetPriority(EPriorityNormal, 
                                     EMdaPriorityPreferenceTime);                                
 
-        // Call callback to retrieve frame from upstream.
-        pjmedia_frame f;
-        pj_status_t status;
-        
-        f.type = PJMEDIA_FRAME_TYPE_AUDIO;
-        f.buf = frameBuf_;
-        f.size = frameBufSize_;
-        f.timestamp.u32.lo = timestamp_;
-        f.bit_info = 0;
-
-        status = playCb_(this->userData_, &f);
-        if (status != PJ_SUCCESS) {
-            this->Stop();
-            return;
+        // set format
+        TFourCC aFmt = format_id_to_fourcc(&parentStrm_->param.ext_fmt);
+        TRAPD(ferr, iOutputStream_->SetDataTypeL(aFmt));
+        if (ferr) {
+            if (parentStrm_->param.ext_fmt.id != 0) {
+                // This is error since we can't open codec as requested
+                snd_perror("Unable to set playback format", aError);
+                return;
+            } else {
+                // This is fine. The stream is opened in PCM but we couldn't
+                // set G.711 codec, so just revert back to use PCM.
+                fmt_g711_ = false;
+            }
+        } else {
+            if (parentStrm_->param.ext_fmt.id == 0)
+                fmt_g711_ = true;
         }
 
-        if (f.type != PJMEDIA_FRAME_TYPE_AUDIO)
-            pj_bzero(frameBuf_, frameBufSize_);
+        // Kick start the first Write
+        TPtrC8 dummy;
+        MaoscBufferCopied(KErrNone, dummy);
         
-        // Increment timestamp.
-        timestamp_ += (frameBufSize_ / BYTES_PER_SAMPLE);
-
-        // issue WriteL() to write the first audio data block, 
-        // subsequent calls to WriteL() will be issued in 
-        // MMdaAudioOutputStreamCallback::MaoscBufferCopied() 
-        // until whole data buffer is written.
-        frame_.Set(frameBuf_, frameBufSize_);
-        iOutputStream_->WriteL(frame_);
     } else {
         snd_perror("Error in MaoscOpenComplete()", aError);
     }
@@ -728 +1194 @@
 
     if (aError==KErrNone) {
         // Buffer successfully written, feed another one.
+        if (parentStrm_->param.ext_fmt.id == 0)
+            PlayFramePcm();
+        else
+            PlayFrameEncoded();
 
-        // Call callback to retrieve frame from upstream.
-        pjmedia_frame f;
-        pj_status_t status;
-        
-        f.type = PJMEDIA_FRAME_TYPE_AUDIO;
-        f.buf = frameBuf_;
-        f.size = frameBufSize_;
-        f.timestamp.u32.lo = timestamp_;
-        f.bit_info = 0;
-
-        status = playCb_(this->userData_, &f);
-        if (status != PJ_SUCCESS) {
-            this->Stop();
-            return;
-        }
-
-        if (f.type != PJMEDIA_FRAME_TYPE_AUDIO)
-            pj_bzero(frameBuf_, frameBufSize_);
-        
-        // Increment timestamp.
-        timestamp_ += (frameBufSize_ / BYTES_PER_SAMPLE);
-
-        // Write to playback stream.
-        frame_.Set(frameBuf_, frameBufSize_);
-        iOutputStream_->WriteL(frame_);
-
     } else if (aError==KErrAbort) {
         // playing was aborted, due to call to CMdaAudioOutputStream::Stop()
         state_ = STATE_INACTIVE;
@@ -776 +1220 @@
 }
 
 /****************************************************************************
+ * MDA format enumerator
+ */
+class CPjSndUtility : public CBase, MMdaAudioInputStreamCallback
+{
+public:
+    CPjSndUtility();
+    ~CPjSndUtility();
+    
+    bool Busy() const;
+    pj_status_t EnumFormats(pjmedia_format fmt[], unsigned *count);
+    
+private:
+    CMdaAudioInputStream  *iInputStream_;
+    bool done_;
+    bool stopped_;
+    pjmedia_format *fmt_;
+    unsigned max_fmt_;
+    unsigned *pcount_;
+    TInt lastError_;
+    
+    virtual void MaiscOpenComplete(TInt aError);
+    virtual void MaiscBufferCopied(TInt aError, const TDesC8 &aBuffer);
+    virtual void MaiscRecordComplete(TInt aError);
+};
+
+CPjSndUtility::CPjSndUtility()
+: iInputStream_(NULL)
+{
+    
+}
+
+CPjSndUtility::~CPjSndUtility()
+{
+    delete iInputStream_;
+}
+
+bool CPjSndUtility::Busy() const
+{
+    return iInputStream_ != NULL;
+}
+
+pj_status_t CPjSndUtility::EnumFormats(pjmedia_format fmt[], unsigned *count)
+{
+    unsigned i;
+    
+    if (Busy()) {
+        // Already running
+        return PJ_EINVALIDOP;
+    }
+
+    fmt_ = fmt;
+    pcount_ = count;
+    max_fmt_ = *count;
+    done_ = false;
+    
+    // Create the stream.
+    TRAPD(err, iInputStream_ = CMdaAudioInputStream::NewL(*this));
+    if (err != KErrNone)
+        return PJ_RETURN_OS_ERROR(err);
+
+    // Initialize settings.
+    TMdaAudioDataSettings iStreamSettings;
+    iStreamSettings.iChannels = get_channel_cap(1);
+    iStreamSettings.iSampleRate = get_clock_rate_cap(8000);
+
+    pj_assert(iStreamSettings.iChannels != 0 && 
+              iStreamSettings.iSampleRate != 0);
+
+    // Open stream.
+    lastError_ = KRequestPending;
+    iInputStream_->Open(&iStreamSettings);
+    
+    for (i=0; i<100 && !done_; ++i)
+        pj_symbianos_poll(-1, 50);
+
+    stopped_ = false;
+    iInputStream_->Stop();
+    for (i=0; i<10 && !stopped_; ++i)
+        pj_symbianos_poll(-1, 50);
+ 
+    if (stopped_) {
+        delete iInputStream_;
+        iInputStream_ = NULL;
+    }
+
+    if (!done_)
+        return PJ_RETURN_OS_ERROR(KRequestPending);
+    
+    return PJ_RETURN_OS_ERROR(lastError_);
+}
+
+void CPjSndUtility::MaiscOpenComplete(TInt aError)
+{
+    struct fmt_info
+    {
+        TFourCC          fourcc;
+        const char      *name;
+        pjmedia_format   fmt;
+    } fmt[8];
+    unsigned i, cnt = 0;
+    
+    lastError_ = aError;
+    if (aError != KErrNone) {
+        snd_perror("Error in MaiscOpenComplete()", aError);
+        done_ = true;
+        return;
+    }
+
+    pj_bzero(fmt, sizeof(fmt));
+    
+    // G.711 Alaw
+    fmt[cnt].fourcc = TFourCC('G', '7', '1', '1');
+    fmt[cnt].fmt.id = PJMEDIA_FORMAT_ALAW;
+    fmt[cnt].fmt.bitrate = 64000;
+    fmt[cnt].fmt.vad = PJ_TRUE;
+    cnt++;
+    
+    // AMR-NB
+    fmt[cnt].fourcc = TFourCC(' ', 'A', 'M', 'R');
+    fmt[cnt].fmt.id = PJMEDIA_FORMAT_AMR;
+    fmt[cnt].fmt.bitrate = 7400;
+    fmt[cnt].fmt.vad = PJ_TRUE;
+    cnt++;
+    
+    // G.729
+    fmt[cnt].fourcc = TFourCC('G', '7', '2', '9');
+    fmt[cnt].fmt.id = PJMEDIA_FORMAT_G729;
+    fmt[cnt].fmt.bitrate = 8000;
+    fmt[cnt].fmt.vad = PJ_TRUE;
+    cnt++;
+
+    // iLBC
+    fmt[cnt].fourcc = TFourCC('i', 'L', 'B', 'C');
+    fmt[cnt].fmt.id = PJMEDIA_FORMAT_ILBC;
+    fmt[cnt].fmt.bitrate = 13333;
+    fmt[cnt].fmt.vad = PJ_TRUE;
+    cnt++;
+    
+    // set stream priority to normal and time sensitive
+    iInputStream_->SetPriority(EPriorityNormal, 
+                               EMdaPriorityPreferenceTime);
+    
+    // Test each formats
+    for (i=0; i<cnt; ++i) {
+        TRAPD(fmterr, iInputStream_->SetDataTypeL(fmt[i].fourcc));
+        if (!fmterr && *pcount_ < max_fmt_) {
+            fmt_[*pcount_] = fmt[i].fmt;
+            (*pcount_)++;
+        }
+        PJ_LOG(4,(THIS_FILE, "Format %s is %s",
+                  fmt[i].name, (fmterr? "not supported" : "supported")));
+    }
+    
+    done_ = true;
+}
+
+void CPjSndUtility::MaiscBufferCopied(TInt aError, const TDesC8 &aBuffer)
+{
+    // Should not happen
+    pj_assert(!"Should not be called");
+}
+
+void CPjSndUtility::MaiscRecordComplete(TInt aError)
+{
+        stopped_ = true;
+}
+
+/****************************************************************************
  * Factory operations
  */
 
@@ -807 +1419 @@
 static pj_status_t factory_init(pjmedia_aud_dev_factory *f)
 {
     struct mda_factory *af = (struct mda_factory*)f;
-
+    unsigned i;
+    pj_status_t status;
+    
+    PJ_LOG(4, (THIS_FILE, "Initializing Symbian MDA sound subsystem.."));
+    
     pj_ansi_strcpy(af->dev_info.name, "Symbian Audio");
     af->dev_info.default_samples_per_sec = 8000;
     af->dev_info.caps = PJMEDIA_AUD_DEV_CAP_INPUT_VOLUME_SETTING |
@@ -815 +1431 @@
     af->dev_info.input_count = 1;
     af->dev_info.output_count = 1;
 
-    PJ_LOG(4, (THIS_FILE, "Symb Mda initialized"));
-
+    // Enum supported formats
+    af->sndUtility = new CPjSndUtility;
+    af->dev_info.ext_fmt_cnt = PJ_ARRAY_SIZE(af->dev_info.ext_fmt);
+    status = af->sndUtility->EnumFormats(af->dev_info.ext_fmt, 
+                                         &af->dev_info.ext_fmt_cnt);
+    if (status != PJ_SUCCESS) {
+        af->dev_info.ext_fmt_cnt = 0;
+    } else {
+        af->dev_info.caps |= PJMEDIA_AUD_DEV_CAP_EXT_FORMAT;
+    }
+    
+    if (!af->sndUtility->Busy()) {
+        delete af->sndUtility;
+        af->sndUtility = NULL;
+    }
+    
+    // If G.711 is supported, that should indicate that EC and VAD is being 
+    // used. It cannot be turned off by this API though.
+    for (i=0; i<af->dev_info.ext_fmt_cnt; ++i) {
+        if (af->dev_info.ext_fmt[i].id == PJMEDIA_FORMAT_PCMA)
+            break;
+    }
+    if (i != af->dev_info.ext_fmt_cnt) {
+        af->dev_info.caps |= (PJMEDIA_AUD_DEV_CAP_EC | PJMEDIA_AUD_DEV_CAP_VAD);
+    }
+    
+    PJ_LOG(4, (THIS_FILE, "Symbian MDA sound initialized"));
     return PJ_SUCCESS;
 }
 
@@ -826 +1467 @@
     struct mda_factory *af = (struct mda_factory*)f;
     pj_pool_t *pool = af->pool;
 
+    delete af->sndUtility;
+    af->sndUtility = NULL;
+        
     af->pool = NULL;
     pj_pool_release(pool);
 
@@ -874 +1518 @@
     param->bits_per_sample = BITS_PER_SAMPLE;
     param->flags = af->dev_info.caps;
 
+    /* Clear volume settings */
+    param->flags &= ~(PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING | 
+                      PJMEDIA_AUD_DEV_CAP_INPUT_VOLUME_SETTING);
+    
     return PJ_SUCCESS;
 }
 
@@ -900 +1548 @@
     PJ_ASSERT_RETURN(param->channel_count == 1, PJ_EINVAL);
 
     /* Create and Initialize stream descriptor */
-    pool = pj_pool_create(mf->pf, "symb_aud_dev", 1000, 1000, NULL);
+    pool = pj_pool_create(mf->pf, "symb_aud_dev", 512, 512, NULL);
     PJ_ASSERT_RETURN(pool, PJ_ENOMEM);
 
     strm = PJ_POOL_ZALLOC_T(pool, struct mda_stream);
@@ -934 +1582 @@
     strm->base.op = &stream_op;
     *p_aud_strm = &strm->base;
 
+    /* Apply output volume setting if specified */
+    if (param->flags & PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING) {
+        stream_set_cap(&strm->base, PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING, 
+                       &param->output_vol);
+    }
+
+    /* Apply input volume setting if specified */
+    if (param->flags & PJMEDIA_AUD_DEV_CAP_INPUT_VOLUME_SETTING) {
+        stream_set_cap(&strm->base, PJMEDIA_AUD_DEV_CAP_INPUT_VOLUME_SETTING, 
+                       &param->input_vol);
+    }
+    
     return PJ_SUCCESS;
 }
 
@@ -947 +1607 @@
 
     pj_memcpy(pi, &strm->param, sizeof(*pi));
     
+    /* Update the output volume setting */
+    if (stream_get_cap(s, PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING,
+                       &pi->output_vol) == PJ_SUCCESS)
+    {
+        pi->flags |= PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING;
+    } else {
+        pi->flags &= (~PJMEDIA_AUD_DEV_CAP_OUTPUT_VOLUME_SETTING);
+    }
+
+    /* Update the input volume setting */
+    if (stream_get_cap(s, PJMEDIA_AUD_DEV_CAP_INPUT_VOLUME_SETTING,
+                       &pi->input_vol) == PJ_SUCCESS)
+    {
+        pi->flags |= PJMEDIA_AUD_DEV_CAP_INPUT_VOLUME_SETTING;
+    } else {
+        pi->flags &= (~PJMEDIA_AUD_DEV_CAP_INPUT_VOLUME_SETTING);
+    }
+    
     return PJ_SUCCESS;
 }