diff --git a/configs/msm8937/msm8937.mk b/configs/msm8937/msm8937.mk
index b7a7a39..3d932b0 100644
--- a/configs/msm8937/msm8937.mk
+++ b/configs/msm8937/msm8937.mk
@@ -147,9 +147,9 @@
 PRODUCT_PROPERTY_OVERRIDES += \
 audio.deep_buffer.media=true
 
-#Default pcm audio sink buffer size in msec. This is used in calculating framecount
+#QC property used when calculating client heap size in audio flinger
 PRODUCT_PROPERTY_OVERRIDES += \
-media.stagefright.audio.sink=280
+audio.heap.size.multiplier=7
 
 #enable voice path for PCM VoIP by default
 PRODUCT_PROPERTY_OVERRIDES += \
diff --git a/configs/msm8953/msm8953.mk b/configs/msm8953/msm8953.mk
index 3106942..96c9a5d 100644
--- a/configs/msm8953/msm8953.mk
+++ b/configs/msm8953/msm8953.mk
@@ -148,9 +148,9 @@
 PRODUCT_PROPERTY_OVERRIDES += \
 audio.deep_buffer.media=true
 
-#Default pcm audio sink buffer size in msec. This is used in calculating framecount
+#QC property used when calculating client heap size in audio flinger
 PRODUCT_PROPERTY_OVERRIDES += \
-media.stagefright.audio.sink=280
+audio.heap.size.multiplier=7
 
 #enable voice path for PCM VoIP by default
 PRODUCT_PROPERTY_OVERRIDES += \
diff --git a/configs/msm8996/msm8996.mk b/configs/msm8996/msm8996.mk
index 5b240e9..6d3fa4b 100644
--- a/configs/msm8996/msm8996.mk
+++ b/configs/msm8996/msm8996.mk
@@ -143,9 +143,9 @@
 PRODUCT_PROPERTY_OVERRIDES += \
 audio.deep_buffer.media=true
 
-#Default pcm audio sink buffer size in msec. This is used in calculating framecount
+#QC property used when calculating client heap size in audio flinger
 PRODUCT_PROPERTY_OVERRIDES += \
-media.stagefright.audio.sink=280
+audio.heap.size.multiplier=7
 
 #enable voice path for PCM VoIP by default
 PRODUCT_PROPERTY_OVERRIDES += \
diff --git a/configs/msmcobalt/audio_platform_info.xml b/configs/msmcobalt/audio_platform_info.xml
index a1bd9a1..a8bce46 100644
--- a/configs/msmcobalt/audio_platform_info.xml
+++ b/configs/msmcobalt/audio_platform_info.xml
@@ -28,6 +28,9 @@
     <acdb_ids>
         <device name="SND_DEVICE_OUT_SPEAKER" acdb_id="15"/>
         <device name="SND_DEVICE_OUT_SPEAKER_PROTECTED" acdb_id="124"/>
+        <device name="SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE" acdb_id="131"/>
+        <device name="SND_DEVICE_IN_VOICE_REC_TMIC" acdb_id="131"/>
+        <device name="SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE" acdb_id="132"/>
     </acdb_ids>
     <bit_width_configs>
         <device name="SND_DEVICE_OUT_SPEAKER" bit_width="24"/>
diff --git a/configs/msmcobalt/msmcobalt.mk b/configs/msmcobalt/msmcobalt.mk
index b7684ed..bdc3bf2 100644
--- a/configs/msmcobalt/msmcobalt.mk
+++ b/configs/msmcobalt/msmcobalt.mk
@@ -152,9 +152,9 @@
 PRODUCT_PROPERTY_OVERRIDES += \
 audio.deep_buffer.media=true
 
-#Default pcm audio sink buffer size in msec. This is used in calculating framecount
+#QC property used when calculating client heap size in audio flinger
 PRODUCT_PROPERTY_OVERRIDES += \
-media.stagefright.audio.sink=280
+audio.heap.size.multiplier=7
 
 #enable voice path for PCM VoIP by default
 PRODUCT_PROPERTY_OVERRIDES += \
@@ -211,3 +211,6 @@
 PRODUCT_PROPERTY_OVERRIDES += \
 qcom.hw.aac.encoder=true
 
+#Disable FM a2dp concurrency
+PRODUCT_PROPERTY_OVERRIDES += \
+fm.a2dp.conc.disabled=true
diff --git a/configs/msmcobalt/sound_trigger_platform_info.xml b/configs/msmcobalt/sound_trigger_platform_info.xml
index 6c9f55e..15c8ef6 100644
--- a/configs/msmcobalt/sound_trigger_platform_info.xml
+++ b/configs/msmcobalt/sound_trigger_platform_info.xml
@@ -50,7 +50,13 @@
         <param max_cpe_users="3" />
         <param max_ape_phrases="10" />
         <param max_ape_users="10" />
+        <!-- Profile specific data which the algorithm can support -->
         <param sample_rate="16000" />
+        <param bit_width="16" />
+        <param channel_count="1"/>
+        <!-- adm_cfg_profile should match with the one defined under adm_config -->
+        <!-- Set it to NONE if LSM directly connects to AFE -->
+        <param adm_cfg_profile="NONE" />
         <gcs_usecase>
             <param uid="0x1" />
             <!-- module_id, instance_id, param_id -->
@@ -82,4 +88,13 @@
         <param capture_keyword="PCM_packet, RT, 2000" />
         <param client_capture_read_delay="2000" />
     </sound_model_config>
+
+    <!-- Multiple adm_config tags can be listed, each with unique profile name. -->
+    <!-- app_type to match corresponding value from ACDB -->
+    <adm_config>
+        <param adm_cfg_profile="DEFAULT" />
+        <param app_type="69938" />
+        <param sample_rate="16000" />
+        <param bit_width="16" />
+    </adm_config>
 </sound_trigger_platform_info>
diff --git a/configs/msmfalcon/msmfalcon.mk b/configs/msmfalcon/msmfalcon.mk
index 554f32b..509c159 100644
--- a/configs/msmfalcon/msmfalcon.mk
+++ b/configs/msmfalcon/msmfalcon.mk
@@ -137,9 +137,9 @@
 PRODUCT_PROPERTY_OVERRIDES += \
 audio.deep_buffer.media=true
 
-#Default pcm audio sink buffer size in msec. This is used in calculating framecount
+#QC property used when calculating client heap size in audio flinger
 PRODUCT_PROPERTY_OVERRIDES += \
-media.stagefright.audio.sink=280
+audio.heap.size.multiplier=7
 
 #enable voice path for PCM VoIP by default
 PRODUCT_PROPERTY_OVERRIDES += \
diff --git a/hal/audio_extn/a2dp.c b/hal/audio_extn/a2dp.c
index 28d0f75..d0959e8 100644
--- a/hal/audio_extn/a2dp.c
+++ b/hal/audio_extn/a2dp.c
@@ -751,6 +751,27 @@
                 if(a2dp.clear_a2dpsuspend_flag)
                     a2dp.clear_a2dpsuspend_flag();
                 a2dp.a2dp_suspended = false;
+                /*
+                 * It is possible that before suspend,a2dp sessions can be active
+                 * for example during music + voice activation concurrency
+                 * a2dp suspend will be called & BT will change to sco mode
+                 * though music is paused as a part of voice activation
+                 * compress session close happens only after pause timeout(10secs)
+                 * so if resume request comes before pause timeout as a2dp session
+                 * is already active IPC start will not be called from APM/audio_hw
+                 * Fix is to call a2dp start for IPC library post suspend
+                 * based on number of active session count
+                 */
+                if (a2dp.a2dp_total_active_session_request > 0) {
+                    ALOGD(" Calling IPC lib start post suspend state");
+                    if(a2dp.audio_start_stream) {
+                        ret =  a2dp.audio_start_stream();
+                        if (ret != 0) {
+                            ALOGE("BT controller start failed");
+                            a2dp.a2dp_started = false;
+                        }
+                    }
+                }
             }
         }
         goto param_handled;
diff --git a/hal/audio_extn/utils.c b/hal/audio_extn/utils.c
index 9542fbd..eb3213c 100644
--- a/hal/audio_extn/utils.c
+++ b/hal/audio_extn/utils.c
@@ -666,6 +666,18 @@
         if ((24 == usecase->stream.out->bit_width) &&
             (usecase->stream.out->devices & AUDIO_DEVICE_OUT_SPEAKER)) {
             usecase->stream.out->app_type_cfg.sample_rate = DEFAULT_OUTPUT_SAMPLING_RATE;
+        } else if ((snd_device == SND_DEVICE_OUT_HDMI ||
+                    snd_device == SND_DEVICE_OUT_USB_HEADSET ||
+                    snd_device == SND_DEVICE_OUT_DISPLAY_PORT) &&
+                   (usecase->stream.out->sample_rate >= OUTPUT_SAMPLING_RATE_44100)) {
+             /*
+              * To best utlize DSP, check if the stream sample rate is supported/multiple of
+              * configured device sample rate, if not update the COPP rate to be equal to the
+              * device sample rate, else open COPP at stream sample rate
+              */
+              platform_check_and_update_copp_sample_rate(adev->platform, snd_device,
+                                      usecase->stream.out->sample_rate,
+                                      &usecase->stream.out->app_type_cfg.sample_rate);
         } else if ((snd_device != SND_DEVICE_OUT_HEADPHONES_44_1 &&
             usecase->stream.out->sample_rate == OUTPUT_SAMPLING_RATE_44100) ||
             (usecase->stream.out->sample_rate < OUTPUT_SAMPLING_RATE_44100)) {
diff --git a/hal/audio_hw.c b/hal/audio_hw.c
index 3a12adf..bf2908f 100644
--- a/hal/audio_hw.c
+++ b/hal/audio_hw.c
@@ -796,8 +796,10 @@
             audio_extn_dev_arbi_release(snd_device);
             return -EINVAL;
         }
-    } else if (platform_can_split_snd_device(adev->platform, snd_device,
-            &num_devices, new_snd_devices)) {
+    } else if (platform_split_snd_device(adev->platform,
+                                         snd_device,
+                                         &num_devices,
+                                         new_snd_devices) == 0) {
         for (i = 0; i < num_devices; i++) {
             enable_snd_device(adev, new_snd_devices[i]);
         }
@@ -870,8 +872,10 @@
         if (platform_can_enable_spkr_prot_on_device(snd_device) &&
              audio_extn_spkr_prot_is_enabled()) {
             audio_extn_spkr_prot_stop_processing(snd_device);
-        } else if (platform_can_split_snd_device(adev->platform, snd_device,
-                    &num_devices, new_snd_devices)) {
+        } else if (platform_split_snd_device(adev->platform,
+                                             snd_device,
+                                             &num_devices,
+                                             new_snd_devices) == 0) {
             for (i = 0; i < num_devices; i++) {
                 disable_snd_device(adev, new_snd_devices[i]);
             }
@@ -908,6 +912,115 @@
     return 0;
 }
 
+/*
+  legend:
+  uc - existing usecase
+  new_uc - new usecase
+  d1, d11, d2 - SND_DEVICE enums
+  a1, a2 - corresponding ANDROID device enums
+  B1, B2 - backend strings
+
+case 1
+  uc->dev  d1 (a1)               B1
+  new_uc->dev d1 (a1), d2 (a2)   B1, B2
+
+  resolution: disable and enable uc->dev on d1
+
+case 2
+  uc->dev d1 (a1)        B1
+  new_uc->dev d11 (a1)   B1
+
+  resolution: need to switch uc since d1 and d11 are related
+  (e.g. speaker and voice-speaker)
+  use ANDROID_DEVICE_OUT enums to match devices since SND_DEVICE enums may vary
+
+case 3
+  uc->dev d1 (a1)        B1
+  new_uc->dev d2 (a2)    B2
+
+  resolution: no need to switch uc
+
+case 4
+  uc->dev d1 (a1)      B1
+  new_uc->dev d2 (a2)  B1
+
+  resolution: disable enable uc-dev on d2 since backends match
+  we cannot enable two streams on two different devices if they
+  share the same backend. e.g. if offload is on speaker device using
+  QUAD_MI2S backend and a low-latency stream is started on voice-handset
+  using the same backend, offload must also be switched to voice-handset.
+
+case 5
+  uc->dev  d1 (a1)                  B1
+  new_uc->dev d1 (a1), d2 (a2)      B1
+
+  resolution: disable enable uc-dev on d2 since backends match
+  we cannot enable two streams on two different devices if they
+  share the same backend.
+
+case 6
+  uc->dev  d1 (a1)    B1
+  new_uc->dev d2 (a1) B2
+
+  resolution: no need to switch
+
+case 7
+  uc->dev d1 (a1), d2 (a2)       B1, B2
+  new_uc->dev d1 (a1)            B1
+
+  resolution: no need to switch
+
+*/
+static snd_device_t derive_playback_snd_device(void * platform,
+                                               struct audio_usecase *uc,
+                                               struct audio_usecase *new_uc,
+                                               snd_device_t new_snd_device)
+{
+    audio_devices_t a1 = uc->stream.out->devices;
+    audio_devices_t a2 = new_uc->stream.out->devices;
+
+    snd_device_t d1 = uc->out_snd_device;
+    snd_device_t d2 = new_snd_device;
+
+    // Treat as a special case when a1 and a2 are not disjoint
+    if ((a1 != a2) && (a1 & a2)) {
+        snd_device_t d3[2];
+        int num_devices = 0;
+        int ret = platform_split_snd_device(platform,
+                                            popcount(a1) > 1 ? d1 : d2,
+                                            &num_devices,
+                                            d3);
+        if (ret < 0) {
+            if (ret != -ENOSYS) {
+                ALOGW("%s failed to split snd_device %d",
+                      __func__,
+                      popcount(a1) > 1 ? d1 : d2);
+            }
+            goto end;
+        }
+
+        // NB: case 7 is hypothetical and isn't a practical usecase yet.
+        // But if it does happen, we need to give priority to d2 if
+        // the combo devices active on the existing usecase share a backend.
+        // This is because we cannot have a usecase active on a combo device
+        // and a new usecase requests one device in this combo pair.
+        if (platform_check_backends_match(d3[0], d3[1])) {
+            return d2; // case 5
+        } else {
+            return d1; // case 1
+        }
+    } else {
+        if (platform_check_backends_match(d1, d2)) {
+            return d2; // case 2, 4
+        } else {
+            return d1; // case 6, 3
+        }
+    }
+
+end:
+    return d2; // return whatever was calculated before.
+}
+
 static void check_usecases_codec_backend(struct audio_device *adev,
                                               struct audio_usecase *uc_info,
                                               snd_device_t snd_device)
@@ -963,7 +1076,9 @@
               platform_check_backends_match(snd_device, usecase->out_snd_device));
         if (usecase->type != PCM_CAPTURE &&
             usecase != uc_info &&
-            (usecase->out_snd_device != snd_device || force_routing) &&
+            (derive_playback_snd_device(adev->platform,
+                                        usecase, uc_info,
+                                        snd_device) != usecase->out_snd_device || force_routing) &&
             ((usecase->devices & AUDIO_DEVICE_OUT_ALL_CODEC_BACKEND) ||
              (usecase->devices & AUDIO_DEVICE_OUT_AUX_DIGITAL) ||
              (usecase->devices & AUDIO_DEVICE_OUT_USB_DEVICE) ||
@@ -1303,7 +1418,7 @@
 
     // Force all a2dp output devices to reconfigure for proper AFE encode format
     if((usecase->stream.out) &&
-       (usecase->stream.out->devices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP) &&
+       (usecase->stream.out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
        audio_extn_a2dp_is_force_device_switch()) {
          ALOGD("Force a2dp device switch to update new encoder config");
          ret = true;
@@ -1334,6 +1449,10 @@
     if ((usecase->type == VOICE_CALL) ||
         (usecase->type == VOIP_CALL)  ||
         (usecase->type == PCM_HFP_CALL)) {
+        if(usecase->stream.out == NULL) {
+            ALOGE("%s: stream.out is NULL", __func__);
+            return -EINVAL;
+        }
         out_snd_device = platform_get_output_snd_device(adev->platform,
                                                         usecase->stream.out);
         in_snd_device = platform_get_input_snd_device(adev->platform, usecase->stream.out->devices);
@@ -1377,6 +1496,10 @@
             }
         }
         if (usecase->type == PCM_PLAYBACK) {
+            if (usecase->stream.out == NULL) {
+                ALOGE("%s: stream.out is NULL", __func__);
+                return -EINVAL;
+            }
             usecase->devices = usecase->stream.out->devices;
             in_snd_device = SND_DEVICE_NONE;
             if (out_snd_device == SND_DEVICE_NONE) {
@@ -1389,6 +1512,10 @@
                 }
             }
         } else if (usecase->type == PCM_CAPTURE) {
+            if (usecase->stream.in == NULL) {
+                ALOGE("%s: stream.in is NULL", __func__);
+                return -EINVAL;
+            }
             usecase->devices = usecase->stream.in->device;
             out_snd_device = SND_DEVICE_NONE;
             if (in_snd_device == SND_DEVICE_NONE) {
@@ -2469,14 +2596,14 @@
          * (3sec). As BT is turned off, the write gets blocked.
          * Avoid this by routing audio to speaker until standby.
          */
-        if ((out->devices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP) &&
+        if ((out->devices & AUDIO_DEVICE_OUT_ALL_A2DP) &&
                 (val == AUDIO_DEVICE_NONE)) {
                 val = AUDIO_DEVICE_OUT_SPEAKER;
         }
         /* To avoid a2dp to sco overlapping force route BT usecases
          * to speaker based on Phone state
          */
-        if ((val & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP) &&
+        if ((val & AUDIO_DEVICE_OUT_ALL_A2DP) &&
             ((adev->mode == AUDIO_MODE_RINGTONE) ||
             (adev->mode == AUDIO_MODE_IN_CALL))) {
             ALOGD("Forcing a2dp routing to speaker for ring/call mode");
@@ -4304,7 +4431,7 @@
         list_for_each(node, &adev->usecase_list) {
             usecase = node_to_item(node, struct audio_usecase, list);
             if ((usecase->type == PCM_PLAYBACK) &&
-                (usecase->devices & AUDIO_DEVICE_OUT_BLUETOOTH_A2DP)){
+                (usecase->devices & AUDIO_DEVICE_OUT_ALL_A2DP)){
                 ALOGD("reconfigure a2dp... forcing device switch");
                 lock_output_stream(usecase->stream.out);
                 audio_extn_a2dp_set_handoff_mode(true);
diff --git a/hal/msm8916/platform.c b/hal/msm8916/platform.c
index 9d13b94..7433e3a 100644
--- a/hal/msm8916/platform.c
+++ b/hal/msm8916/platform.c
@@ -444,6 +444,7 @@
     [SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS] = "quad-mic",
     [SND_DEVICE_IN_THREE_MIC] = "three-mic",
     [SND_DEVICE_IN_HANDSET_TMIC] = "three-mic",
+    [SND_DEVICE_IN_VOICE_REC_TMIC] = "three-mic",
     [SND_DEVICE_IN_UNPROCESSED_MIC] = "unprocessed-mic",
     [SND_DEVICE_IN_UNPROCESSED_STEREO_MIC] = "voice-rec-dmic-ef",
     [SND_DEVICE_IN_UNPROCESSED_THREE_MIC] = "three-mic",
@@ -573,6 +574,7 @@
     [SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS] = 129,
     [SND_DEVICE_IN_THREE_MIC] = 46, /* for APSS Surround Sound Recording */
     [SND_DEVICE_IN_HANDSET_TMIC] = 125, /* for 3mic recording with fluence */
+    [SND_DEVICE_IN_VOICE_REC_TMIC] = 125,
     [SND_DEVICE_IN_UNPROCESSED_MIC] = 143,
     [SND_DEVICE_IN_UNPROCESSED_STEREO_MIC] = 144,
     [SND_DEVICE_IN_UNPROCESSED_THREE_MIC] = 145,
@@ -704,6 +706,7 @@
     {TO_NAME_INDEX(SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS)},
     {TO_NAME_INDEX(SND_DEVICE_IN_THREE_MIC)},
     {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_TMIC)},
+    {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_TMIC)},
     {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_MIC)},
     {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_STEREO_MIC)},
     {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_THREE_MIC)},
@@ -2556,7 +2559,8 @@
         snd_device = usecase->in_snd_device;
     acdb_dev_id = acdb_device_table[platform_get_spkr_prot_snd_device(snd_device)];
 
-    if(!platform_can_split_snd_device(platform, snd_device, &num_devices, new_snd_device)) {
+    if (platform_split_snd_device(platform, snd_device, &num_devices,
+                                  new_snd_device) < 0) {
         new_snd_device[0] = snd_device;
     }
 
@@ -2858,22 +2862,21 @@
     return ret;
 }
 
-bool platform_can_split_snd_device(void *platform,
-                                   snd_device_t snd_device,
-                                   int *num_devices,
-                                   snd_device_t *new_snd_devices)
+int platform_split_snd_device(void *platform,
+                              snd_device_t snd_device,
+                              int *num_devices,
+                              snd_device_t *new_snd_devices)
 {
-    bool status = false;
+    int ret = -EINVAL;
     struct platform_data *my_data = (struct platform_data *)platform;
-
     if (NULL == num_devices || NULL == new_snd_devices) {
         ALOGE("%s: NULL pointer ..", __func__);
-        return false;
+        return -EINVAL;
     }
 
     /*
      * If wired headset/headphones/line devices share the same backend
-     * with speaker/earpiece this routine returns false.
+     * with speaker/earpiece this routine returns -EINVAL.
      */
     if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES &&
         !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_HEADPHONES)) {
@@ -2887,7 +2890,7 @@
              new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
 
         new_snd_devices[1] = SND_DEVICE_OUT_HEADPHONES;
-        status = true;
+        ret = 0;
     } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_HDMI &&
                !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_HDMI)) {
         *num_devices = 2;
@@ -2900,7 +2903,7 @@
             new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
 
         new_snd_devices[1] = SND_DEVICE_OUT_HDMI;
-        status = true;
+        ret = 0;
     } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT &&
                !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_DISPLAY_PORT)) {
         *num_devices = 2;
@@ -2913,24 +2916,24 @@
             new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
 
         new_snd_devices[1] = SND_DEVICE_OUT_DISPLAY_PORT;
-        status = true;
+        ret = 0;
     } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET &&
                !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_USB_HEADSET)) {
         *num_devices = 2;
         new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
         new_snd_devices[1] = SND_DEVICE_OUT_USB_HEADSET;
-        status = true;
+        ret = 0;
     } else if (SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP == snd_device) {
         *num_devices = 2;
         new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
         new_snd_devices[1] = SND_DEVICE_OUT_BT_A2DP;
-        status = true;
+        ret = 0;
     }
 
     ALOGD("%s: snd_device(%d) num devices(%d) new_snd_devices(%d)", __func__,
         snd_device, *num_devices, *new_snd_devices);
 
-    return status;
+    return ret;
 }
 
 int platform_get_ext_disp_type(void *platform)
@@ -3369,7 +3372,7 @@
                      snd_device = SND_DEVICE_IN_HANDSET_QMIC;
                 } else if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
                     (my_data->source_mic_type & SOURCE_THREE_MIC)) {
-                    snd_device = SND_DEVICE_IN_HANDSET_TMIC;
+                    snd_device = SND_DEVICE_IN_VOICE_REC_TMIC;
                 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
                     (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
                     snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE;
@@ -4757,8 +4760,8 @@
           backend_cfg.sample_rate,  backend_cfg.channels, backend_idx, usecase->id,
           platform_get_snd_device_name(snd_device));
 
-    if (!platform_can_split_snd_device(adev->platform, snd_device,
-            &num_devices, new_snd_devices))
+    if (platform_split_snd_device(adev->platform, snd_device,
+                                  &num_devices, new_snd_devices) < 0)
         new_snd_devices[0] = snd_device;
 
     for (i = 0; i < num_devices; i++) {
@@ -5020,6 +5023,29 @@
     return ret;
 }
 
+void platform_check_and_update_copp_sample_rate(void* platform, snd_device_t snd_device,
+                                                unsigned int stream_sr, int* sample_rate)
+{
+    struct platform_data* my_data = (struct platform_data *)platform;
+    int backend_idx = platform_get_backend_index(snd_device);
+    int device_sr = my_data->current_backend_cfg[backend_idx].sample_rate;
+    /*Check if device SR is multiple of 8K or 11.025 Khz
+     *check if the stream SR is multiple of same base, if not set
+     *copp sample rate equal to device sample rate.
+     */
+     if (!(((sample_rate_multiple(device_sr, SAMPLE_RATE_8000)) &&
+                 (sample_rate_multiple(stream_sr, SAMPLE_RATE_8000))) ||
+           ((sample_rate_multiple(device_sr, SAMPLE_RATE_11025)) &&
+                 (sample_rate_multiple(stream_sr, SAMPLE_RATE_11025))))) {
+         *sample_rate = device_sr;
+     } else
+         *sample_rate = stream_sr;
+
+     ALOGI("sn_device %d device sr %d stream sr %d copp sr %d", snd_device, device_sr, stream_sr
+, *sample_rate);
+
+}
+
 int platform_get_edid_info(void *platform)
 {
     struct platform_data *my_data = (struct platform_data *)platform;
diff --git a/hal/msm8916/platform.h b/hal/msm8916/platform.h
index cba9068..1f0d7c2 100644
--- a/hal/msm8916/platform.h
+++ b/hal/msm8916/platform.h
@@ -202,6 +202,7 @@
     SND_DEVICE_IN_SPEAKER_QMIC_AEC_NS,
     SND_DEVICE_IN_THREE_MIC,
     SND_DEVICE_IN_HANDSET_TMIC,
+    SND_DEVICE_IN_VOICE_REC_TMIC,
     SND_DEVICE_IN_UNPROCESSED_MIC,
     SND_DEVICE_IN_UNPROCESSED_STEREO_MIC,
     SND_DEVICE_IN_UNPROCESSED_THREE_MIC,
diff --git a/hal/msm8960/platform.c b/hal/msm8960/platform.c
index e025772..33bbc2f 100644
--- a/hal/msm8960/platform.c
+++ b/hal/msm8960/platform.c
@@ -1237,12 +1237,14 @@
 int platform_spkr_prot_is_wsa_analog_mode(void *adev __unused)
 {
     return 0;
-bool platform_can_split_snd_device(void *platform __unused,
-                                   snd_device_t in_snd_device __unused,
-                                   int *num_devices __unused,
-                                   snd_device_t *out_snd_devices __unused)
+
+}
+
+int platform_can_split_snd_device(snd_device_t in_snd_device __unused,
+                                  int *num_devices __unused,
+                                  snd_device_t *out_snd_devices __unused)
 {
-    return false;
+    return -ENOSYS;
 }
 
 bool platform_check_backends_match(snd_device_t snd_device1 __unused,
diff --git a/hal/msm8974/platform.c b/hal/msm8974/platform.c
index 0489fc9..3551006 100644
--- a/hal/msm8974/platform.c
+++ b/hal/msm8974/platform.c
@@ -446,6 +446,7 @@
     [SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE] = "quad-mic",
     [SND_DEVICE_IN_THREE_MIC] = "three-mic",
     [SND_DEVICE_IN_HANDSET_TMIC] = "three-mic",
+    [SND_DEVICE_IN_VOICE_REC_TMIC] = "three-mic",
     [SND_DEVICE_IN_UNPROCESSED_MIC] = "unprocessed-mic",
     [SND_DEVICE_IN_UNPROCESSED_STEREO_MIC] = "voice-rec-dmic-ef",
     [SND_DEVICE_IN_UNPROCESSED_THREE_MIC] = "three-mic",
@@ -570,6 +571,7 @@
     [SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE] = 125,
     [SND_DEVICE_IN_THREE_MIC] = 46, /* for APSS Surround Sound Recording */
     [SND_DEVICE_IN_HANDSET_TMIC] = 125, /* for 3mic recording with fluence */
+    [SND_DEVICE_IN_VOICE_REC_TMIC] = 125,
     [SND_DEVICE_IN_UNPROCESSED_MIC] = 143,
     [SND_DEVICE_IN_UNPROCESSED_STEREO_MIC] = 144,
     [SND_DEVICE_IN_UNPROCESSED_THREE_MIC] = 145,
@@ -693,6 +695,7 @@
     {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE)},
     {TO_NAME_INDEX(SND_DEVICE_IN_THREE_MIC)},
     {TO_NAME_INDEX(SND_DEVICE_IN_HANDSET_TMIC)},
+    {TO_NAME_INDEX(SND_DEVICE_IN_VOICE_REC_TMIC)},
     {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_MIC)},
     {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_STEREO_MIC)},
     {TO_NAME_INDEX(SND_DEVICE_IN_UNPROCESSED_THREE_MIC)},
@@ -2393,8 +2396,8 @@
         return -EINVAL;
     }
 
-    if(!platform_can_split_snd_device(my_data, snd_device,
-            &num_devices, new_snd_device)) {
+    if (platform_split_snd_device(my_data, snd_device,
+                                  &num_devices, new_snd_device) < 0) {
         new_snd_device[0] = snd_device;
     }
 
@@ -2697,58 +2700,58 @@
     return ret;
 }
 
-bool platform_can_split_snd_device(void *platform,
-                                   snd_device_t snd_device,
-                                   int *num_devices,
-                                   snd_device_t *new_snd_devices)
+int platform_split_snd_device(void *platform,
+                              snd_device_t snd_device,
+                              int *num_devices,
+                              snd_device_t *new_snd_devices)
 {
-    bool status = false;
+    int ret = -EINVAL;
     struct platform_data *my_data = (struct platform_data *)platform;
 
     if ( NULL == num_devices || NULL == new_snd_devices || NULL == my_data) {
         ALOGE("%s: NULL pointer ..", __func__);
-        return false;
+        return -EINVAL;
     }
 
     /*
      * If wired headset/headphones/line devices share the same backend
-     * with speaker/earpiece this routine returns false.
+     * with speaker/earpiece this routine returns -EINVAL.
      */
     if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_HEADPHONES &&
         !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_HEADPHONES)) {
         *num_devices = 2;
         new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
         new_snd_devices[1] = SND_DEVICE_OUT_HEADPHONES;
-        status = true;
+        ret = 0;
     } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_HDMI &&
                !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_HDMI)) {
         *num_devices = 2;
         new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
         new_snd_devices[1] = SND_DEVICE_OUT_HDMI;
-        status = true;
+        ret = 0;
     } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_DISPLAY_PORT &&
                !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_DISPLAY_PORT)) {
         *num_devices = 2;
         new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
         new_snd_devices[1] = SND_DEVICE_OUT_DISPLAY_PORT;
-        status = true;
+        ret = 0;
     } else if (snd_device == SND_DEVICE_OUT_SPEAKER_AND_USB_HEADSET &&
                !platform_check_backends_match(SND_DEVICE_OUT_SPEAKER, SND_DEVICE_OUT_USB_HEADSET)) {
         *num_devices = 2;
         new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
         new_snd_devices[1] = SND_DEVICE_OUT_USB_HEADSET;
-        status = true;
+        ret = 0;
     } else if (SND_DEVICE_OUT_SPEAKER_AND_BT_A2DP == snd_device) {
         *num_devices = 2;
         new_snd_devices[0] = SND_DEVICE_OUT_SPEAKER;
         new_snd_devices[1] = SND_DEVICE_OUT_BT_A2DP;
-        status = true;
+        ret = 0;
     }
 
     ALOGD("%s: snd_device(%d) num devices(%d) new_snd_devices(%d)", __func__,
         snd_device, *num_devices, *new_snd_devices);
 
-    return status;
+    return ret;
 }
 
 int platform_get_ext_disp_type(void *platform)
@@ -3138,7 +3141,7 @@
                      snd_device = SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE;
                 } else if ((my_data->fluence_type & FLUENCE_QUAD_MIC) &&
                     (my_data->source_mic_type & SOURCE_THREE_MIC)) {
-                    snd_device = SND_DEVICE_IN_HANDSET_TMIC;
+                    snd_device = SND_DEVICE_IN_VOICE_REC_TMIC;
                 } else if ((my_data->fluence_type & FLUENCE_DUAL_MIC) &&
                     (my_data->source_mic_type & SOURCE_DUAL_MIC)) {
                     snd_device = SND_DEVICE_IN_VOICE_REC_DMIC_FLUENCE;
@@ -4833,7 +4836,8 @@
           backend_cfg.sample_rate, backend_cfg.channels, backend_idx, usecase->id,
           platform_get_snd_device_name(snd_device));
 
-    if (!platform_can_split_snd_device(my_data, snd_device, &num_devices, new_snd_devices))
+    if (platform_split_snd_device(my_data, snd_device, &num_devices,
+                                  new_snd_devices) < 0)
         new_snd_devices[0] = snd_device;
 
     for (i = 0; i < num_devices; i++) {
@@ -5303,6 +5307,32 @@
     return fragment_size;
 }
 
+void platform_check_and_update_copp_sample_rate(void* platform, snd_device_t snd_device,
+                                                unsigned int stream_sr, int* sample_rate)
+{
+    struct platform_data* my_data = (struct platform_data *)platform;
+    int backend_idx = platform_get_backend_index(snd_device);
+    int device_sr = my_data->current_backend_cfg[backend_idx].sample_rate;
+    /*
+     *Check if device SR is multiple of 8K or 11.025 Khz
+     *check if the stream SR is multiple of same base, if yes
+     *then have copp SR equal to stream SR, this ensures that
+     *post processing happens at stream SR, else have
+     *copp SR equal to device SR.
+     */
+     if (!(((sample_rate_multiple(device_sr, SAMPLE_RATE_8000)) &&
+                 (sample_rate_multiple(stream_sr, SAMPLE_RATE_8000))) ||
+           ((sample_rate_multiple(device_sr, SAMPLE_RATE_11025)) &&
+                 (sample_rate_multiple(stream_sr, SAMPLE_RATE_11025))))) {
+         *sample_rate = device_sr;
+     } else
+         *sample_rate = stream_sr;
+
+     ALOGI("sn_device %d device sr %d stream sr %d copp sr %d", snd_device, device_sr, stream_sr
+, *sample_rate);
+
+}
+
 void platform_reset_edid_info(void *platform) {
 
     ALOGV("%s:", __func__);
@@ -5624,10 +5654,14 @@
 {
     int ret;
     if (out_snd_device == SND_DEVICE_OUT_USB_HEADSET) {
+        if (property_get_bool("audio.debug.usb.disable_sidetone", 0)) {
+            ALOGI("Debug: Disable sidetone");
+        } else {
             ret = audio_extn_usb_enable_sidetone(out_snd_device, enable);
             if (ret)
                 ALOGI("%s: usb device %d does not support device sidetone\n",
                   __func__, out_snd_device);
+        }
     } else {
         ALOGV("%s: sidetone out device(%d) mixer cmd = %s\n",
               __func__, out_snd_device, str);
diff --git a/hal/msm8974/platform.h b/hal/msm8974/platform.h
index c231843..fcfe4d1 100644
--- a/hal/msm8974/platform.h
+++ b/hal/msm8974/platform.h
@@ -197,6 +197,7 @@
     SND_DEVICE_IN_VOICE_REC_QMIC_FLUENCE,
     SND_DEVICE_IN_THREE_MIC,
     SND_DEVICE_IN_HANDSET_TMIC,
+    SND_DEVICE_IN_VOICE_REC_TMIC,
     SND_DEVICE_IN_UNPROCESSED_MIC,
     SND_DEVICE_IN_UNPROCESSED_STEREO_MIC,
     SND_DEVICE_IN_UNPROCESSED_THREE_MIC,
diff --git a/hal/platform_api.h b/hal/platform_api.h
index 61f42de..d3cb23f 100644
--- a/hal/platform_api.h
+++ b/hal/platform_api.h
@@ -25,7 +25,9 @@
 #define CODEC_BACKEND_DEFAULT_SAMPLE_RATE 48000
 #define CODEC_BACKEND_DEFAULT_CHANNELS 2
 #define CODEC_BACKEND_DEFAULT_TX_CHANNELS 1
-
+#define SAMPLE_RATE_8000 8000
+#define SAMPLE_RATE_11025 11025
+#define sample_rate_multiple(sr, base) ((sr % base)== 0?true:false)
 
 enum {
     NATIVE_AUDIO_MODE_SRC = 1,
@@ -147,10 +149,10 @@
 int platform_get_spkr_prot_snd_device(snd_device_t snd_device);
 int platform_get_vi_feedback_snd_device(snd_device_t snd_device);
 int platform_spkr_prot_is_wsa_analog_mode(void *adev);
-bool platform_can_split_snd_device(void *platform,
-                                   snd_device_t snd_device,
-                                   int *num_devices,
-                                   snd_device_t *new_snd_devices);
+int platform_split_snd_device(void *platform,
+                              snd_device_t snd_device,
+                              int *num_devices,
+                              snd_device_t *new_snd_devices);
 
 bool platform_check_backends_match(snd_device_t snd_device1, snd_device_t snd_device2);
 int platform_set_sidetone(struct audio_device *adev,
@@ -187,4 +189,6 @@
 
 unsigned char* platform_get_license(void* platform, int* size);
 int platform_get_max_mic_count(void *platform);
+void platform_check_and_update_copp_sample_rate(void *platform, snd_device_t snd_device,
+     unsigned int stream_sr,int *sample_rate);
 #endif // AUDIO_PLATFORM_API_H
diff --git a/mm-audio/Makefile.am b/mm-audio/Makefile.am
index e423acb..cd7d635 100644
--- a/mm-audio/Makefile.am
+++ b/mm-audio/Makefile.am
@@ -2,4 +2,4 @@
 #
 ACLOCAL_AMFLAGS = -I m4
 
-SUBDIRS = adec-aac adec-mp3 aenc-aac
+SUBDIRS = aenc-aac aenc-amrnb aenc-g711
diff --git a/mm-audio/aenc-aac/qdsp6/Makefile.am b/mm-audio/aenc-aac/qdsp6/Makefile.am
index 5af028a..d5103a4 100644
--- a/mm-audio/aenc-aac/qdsp6/Makefile.am
+++ b/mm-audio/aenc-aac/qdsp6/Makefile.am
@@ -15,16 +15,18 @@
 AM_CPPFLAGS += -DFEATURE_DSM_DUP_ITEMS
 AM_CPPFLAGS += -D_DEBUG
 AM_CPPFLAGS += -Iinc
+AM_CPPFLAGS += -I ${WORKSPACE}/hardware/qcom/media/mm-core/inc/
 
-c_sources  =src/omx_aac_aenc.cpp
+c_sources =src/omx_aac_aenc.cpp
 c_sources +=src/aenc_svr.c
 
 lib_LTLIBRARIES = libOmxAacEnc.la
 libOmxAacEnc_la_SOURCES = $(c_sources)
-libOmxAacEnc_la_CFLAGS = $(AM_CFLAGS) -fPIC
-libOmxAacEnc_la_LDLIBS = -lOmxCore -lstdc++ -lpthread
-libOmxAacEnc_la_LDFLAGS = -shared -version-info $(OMXAUDIO_LIBRARY_VERSION)
+libOmxAacEnc_la_CFLAGS = $(AM_CFLAGS) -fPIC $(GLIB_CFLAGS) -include glib.h -Dstrlcpy=g_strlcpy
+libOmxAacEnc_la_CPPFLAGS = $(AM_CPPFLAGS) -fPIC $(GLIB_CFLAGS) -include glib.h -Dstrlcpy=g_strlcpy
+libOmxAacEnc_la_LDLIBS = -lmm-omxcore -lstdc++ -lpthread $(GLIB_LIBS) -ldl -llog
+libOmxAacEnc_la_LDFLAGS = -shared $(GLIB_LIBS) -version-info $(OMXAUDIO_LIBRARY_VERSION)
 
 bin_PROGRAMS = mm-aenc-omxaac-test
-mm_aenc_omxaac_test_SOURCES = test/omx_aac_enc_test.c
-mm_aenc_omxaac_test_LDADD = -lOmxCore -ldl -lpthread libOmxAacEnc.la
+mm_aenc_omxaac_test_SOURCES = ./test/omx_aac_enc_test.c
+mm_aenc_omxaac_test_LDADD = -lmm-omxcore -ldl -lpthread -llog libOmxAacEnc.la
diff --git a/mm-audio/aenc-amrnb/Makefile.am b/mm-audio/aenc-amrnb/Makefile.am
new file mode 100644
index 0000000..24c1af2
--- /dev/null
+++ b/mm-audio/aenc-amrnb/Makefile.am
@@ -0,0 +1 @@
+SUBDIRS = qdsp6
diff --git a/mm-audio/aenc-amrnb/qdsp6/Makefile.am b/mm-audio/aenc-amrnb/qdsp6/Makefile.am
new file mode 100644
index 0000000..b63130c
--- /dev/null
+++ b/mm-audio/aenc-amrnb/qdsp6/Makefile.am
@@ -0,0 +1,42 @@
+AM_CFLAGS = -Wundef \
+        -Wstrict-prototypes \
+        -Wno-trigraphs \
+        -g  -O0 \
+        -fno-inline \
+        -fno-short-enums \
+        -fpic \
+        -I inc \
+        -I ${WORKSPACE}/hardware/qcom/media/mm-core/inc/
+
+# required pre-processor flags
+AM_CPPFLAGS = -D__packed__=
+AM_CPPFLAGS += -DIMAGE_APPS_PROC
+AM_CPPFLAGS += -DFEATURE_Q_SINGLE_LINK
+AM_CPPFLAGS += -DFEATURE_Q_NO_SELF_QPTR
+AM_CPPFLAGS += -DFEATURE_LINUX
+AM_CPPFLAGS += -DFEATURE_NATIVELINUX -Dstrlcpy=g_strlcpy
+AM_CPPFLAGS += -DFEATURE_DSM_DUP_ITEMS
+AM_CPPFLAGS += -I ${WORKSPACE}/hardware/qcom/media/mm-core/inc/
+
+AM_CPPFLAGS += -g
+AM_CPPFLAGS += -D_DEBUG
+AM_CPPFLAGS += -Iinc
+
+c_sources = src/omx_amr_aenc.cpp \
+            src/aenc_svr.c
+
+lib_LTLIBRARIES = libOmxAmrEnc.la
+libOmxAmrEnc_la_CC = @CC@
+libOmxAmrEnc_la_SOURCES = $(c_sources)
+libOmxAmrEnc_la_LIBADD  = -lcutils -llog
+libOmxAmrEnc_la_CFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) $(GLIB_CFLAGS) -include glib.h -Dstrlcpy=g_strlcpy
+libOmxAmrEnc_la_CPPFLAGS = $(AM_CFLAGS) $(AM_CPPFLAGS) $(GLIB_CFLAGS) -include glib.h -Dstrlcpy=g_strlcpy
+libOmxAmrEnc_la_LDFLAGS = $(GLIB_LIBS) -shared -version-info 1:0:0
+
+bin_PROGRAMS = mm_aenc_omxamr_test
+
+mm_aenc_omxamr_test_c_sources = test/omx_amr_enc_test.c
+mm_aenc_omxamr_test_CC = @CC@
+mm_aenc_omxamr_test_SOURCES = $(mm_aenc_omxamr_test_c_sources)
+mm_aenc_omxamr_test_LDADD = libOmxAmrEnc.la -lmm-omxcore
+mm_aenc_omxamr_test_CPPFLAGS = $(AM_CPPFLAGS) $(AM_CFLAGS)
diff --git a/mm-audio/aenc-amrnb/qdsp6/inc/omx_amr_aenc.h b/mm-audio/aenc-amrnb/qdsp6/inc/omx_amr_aenc.h
index 2d72eb2..f4fcf8e 100644
--- a/mm-audio/aenc-amrnb/qdsp6/inc/omx_amr_aenc.h
+++ b/mm-audio/aenc-amrnb/qdsp6/inc/omx_amr_aenc.h
@@ -60,6 +60,8 @@
 #include <semaphore.h>
 #include <linux/msm_audio.h>
 #include <linux/msm_audio_amrnb.h>
+#include <linux/msm_audio_amrwb.h>
+
 extern "C" {
     void * get_omx_component_factory_fn(void);
 }
@@ -144,6 +146,7 @@
 class omx_amr_aenc: public qc_omx_component
 {
 public:
+    int amrwb_enable;
     omx_amr_aenc();                             // constructor
     virtual ~omx_amr_aenc();                    // destructor
 
diff --git a/mm-audio/aenc-amrnb/qdsp6/src/omx_amr_aenc.cpp b/mm-audio/aenc-amrnb/qdsp6/src/omx_amr_aenc.cpp
index ba66d1b..5278671 100644
--- a/mm-audio/aenc-amrnb/qdsp6/src/omx_amr_aenc.cpp
+++ b/mm-audio/aenc-amrnb/qdsp6/src/omx_amr_aenc.cpp
@@ -1102,13 +1102,28 @@
     component_Role.nVersion.nVersion = OMX_SPEC_VERSION;
     if (!strcmp(role,"OMX.qcom.audio.encoder.amrnb"))
     {
+        amrwb_enable = 0;
         pcm_input = 1;
         component_Role.nSize = (OMX_U32)sizeof(role);
         strlcpy((char *)component_Role.cRole, (const char*)role,
 		sizeof(component_Role.cRole));
         DEBUG_PRINT("\ncomponent_init: Component %s LOADED \n", role);
-    } else if (!strcmp(role,"OMX.qcom.audio.encoder.tunneled.amrnb"))
-    {
+    } else if (!strcmp(role,"OMX.qcom.audio.encoder.tunneled.amrnb")) {
+        amrwb_enable = 0;
+        pcm_input = 0;
+        component_Role.nSize = (OMX_U32)sizeof(role);
+        strlcpy((char *)component_Role.cRole, (const char*)role,
+		sizeof(component_Role.cRole));
+        DEBUG_PRINT("\ncomponent_init: Component %s LOADED \n", role);
+    } else if (!strcmp(role,"OMX.qcom.audio.encoder.amrwb")) {
+        amrwb_enable = 1;
+        pcm_input = 1;
+        component_Role.nSize = (OMX_U32)sizeof(role);
+        strlcpy((char *)component_Role.cRole, (const char*)role,
+		sizeof(component_Role.cRole));
+        DEBUG_PRINT("\ncomponent_init: Component %s LOADED \n", role);
+    } else if (!strcmp(role,"OMX.qcom.audio.encoder.tunneled.amrwb")) {
+        amrwb_enable = 1;
         pcm_input = 0;
         component_Role.nSize = (OMX_U32)sizeof(role);
         strlcpy((char *)component_Role.cRole, (const char*)role,
@@ -1124,12 +1139,12 @@
     if(pcm_input)
     {
         m_tmp_meta_buf = (OMX_U8*) malloc(sizeof(OMX_U8) *
-                         (OMX_CORE_INPUT_BUFFER_SIZE + sizeof(META_IN)));
+                (OMX_CORE_INPUT_BUFFER_SIZE + sizeof(META_IN)));
 
         if (m_tmp_meta_buf == NULL){
             DEBUG_PRINT_ERROR("Mem alloc failed for tmp meta buf\n");
-                return OMX_ErrorInsufficientResources;
-	}
+            return OMX_ErrorInsufficientResources;
+        }
     }
     m_tmp_out_meta_buf =
 		(OMX_U8*)malloc(sizeof(OMX_U8)*OMX_AMR_OUTPUT_BUFFER_SIZE);
@@ -1138,16 +1153,29 @@
                 return OMX_ErrorInsufficientResources;
             }
 
-    if(0 == pcm_input)
-    {
-        m_drv_fd = open("/dev/msm_amrnb_in",O_RDONLY);
-    DEBUG_PRINT("Driver in Tunnel mode open\n");
-    }
-    else
-    {
-        m_drv_fd = open("/dev/msm_amrnb_in",O_RDWR);
-    DEBUG_PRINT("Driver in Non Tunnel mode open\n");
-    }
+    if(!amrwb_enable) {
+        if(0 == pcm_input)
+        {
+            m_drv_fd = open("/dev/msm_amrnb_in",O_RDONLY);
+            DEBUG_PRINT("Driver in Tunnel mode open\n");
+        }
+        else
+        {
+            m_drv_fd = open("/dev/msm_amrnb_in",O_RDWR);
+            DEBUG_PRINT("Driver in Non Tunnel mode open\n");
+        }
+    } else {
+        if(0 == pcm_input)
+        {
+            m_drv_fd = open("/dev/msm_amrwb_in",O_RDONLY);
+            DEBUG_PRINT("Driver in Tunnel mode open\n");
+        }
+        else
+        {
+            m_drv_fd = open("/dev/msm_amrwb_in",O_RDWR);
+            DEBUG_PRINT("Driver in Non Tunnel mode open\n");
+        }
+	}
     if (m_drv_fd < 0)
     {
         DEBUG_PRINT_ERROR("Component_init Open Failed[%d] errno[%d]",\
@@ -1417,6 +1445,7 @@
             {
 
                 struct msm_audio_amrnb_enc_config_v2 drv_amr_enc_config;
+                struct msm_audio_amrwb_enc_config drv_amrwb_enc_config;
                 struct msm_audio_stream_config drv_stream_config;
                 struct msm_audio_buf_cfg buf_cfg;
                 struct msm_audio_config pcm_cfg;
@@ -1433,22 +1462,49 @@
                     DEBUG_PRINT_ERROR("ioctl AUDIO_SET_STREAM_CONFIG failed, \
 					errno[%d]\n", errno);
                 }
+                if(!amrwb_enable)
+                {
+                    if(ioctl(m_drv_fd, AUDIO_GET_AMRNB_ENC_CONFIG_V2,
+                                &drv_amr_enc_config) == -1)
+                    {
+                        DEBUG_PRINT_ERROR("ioctl AUDIO_GET_AMRNB_ENC_CONFIG_V2 \
+                                failed, errno[%d]\n", errno);
+                    }
+                } else {
+                    if(ioctl(m_drv_fd, AUDIO_GET_AMRWB_ENC_CONFIG,
+                                &drv_amrwb_enc_config) == -1)
+                    {
+                        DEBUG_PRINT_ERROR("ioctl AUDIO_GET_AMRWB_ENC_CONFIG \
+                                failed, errno[%d]\n", errno);
+                    }
+                }
+                if(!amrwb_enable) {
+                    drv_amr_enc_config.band_mode = m_amr_param.eAMRBandMode;
+                    drv_amr_enc_config.dtx_enable = m_amr_param.eAMRDTXMode;
+                    drv_amr_enc_config.frame_format = m_amr_param.eAMRFrameFormat;
+                } else {
+                    drv_amrwb_enc_config.band_mode = m_amr_param.eAMRBandMode;
+                    drv_amrwb_enc_config.dtx_enable = m_amr_param.eAMRDTXMode;
+                    drv_amrwb_enc_config.frame_format = m_amr_param.eAMRFrameFormat;
+                }
 
-                if(ioctl(m_drv_fd, AUDIO_GET_AMRNB_ENC_CONFIG_V2,
-			&drv_amr_enc_config) == -1)
+                if(!amrwb_enable)
                 {
-                    DEBUG_PRINT_ERROR("ioctl AUDIO_GET_AMRNB_ENC_CONFIG_V2 \
-					failed, errno[%d]\n", errno);
+                    if(ioctl(m_drv_fd, AUDIO_SET_AMRNB_ENC_CONFIG_V2, &drv_amr_enc_config)
+                            == -1)
+                    {
+                        DEBUG_PRINT_ERROR("ioctl AUDIO_SET_AMRNB_ENC_CONFIG_V2 \
+                                failed, errno[%d]\n", errno);
+                    }
+                } else {
+                    if(ioctl(m_drv_fd, AUDIO_SET_AMRWB_ENC_CONFIG, &drv_amrwb_enc_config)
+                            == -1)
+                    {
+                        DEBUG_PRINT_ERROR("ioctl AUDIO_SET_AMRWB_ENC_CONFIG \
+                                failed, errno[%d]\n", errno);
+                    }
                 }
-        drv_amr_enc_config.band_mode = m_amr_param.eAMRBandMode;
-        drv_amr_enc_config.dtx_enable = m_amr_param.eAMRDTXMode;
-        drv_amr_enc_config.frame_format = m_amr_param.eAMRFrameFormat;
-        if(ioctl(m_drv_fd, AUDIO_SET_AMRNB_ENC_CONFIG_V2, &drv_amr_enc_config)
-		== -1)
-                {
-                    DEBUG_PRINT_ERROR("ioctl AUDIO_SET_AMRNB_ENC_CONFIG_V2 \
-					failed, errno[%d]\n", errno);
-                }
+
                 if (ioctl(m_drv_fd, AUDIO_GET_BUF_CFG, &buf_cfg) == -1)
                 {
                     DEBUG_PRINT_ERROR("ioctl AUDIO_GET_BUF_CFG, errno[%d]\n",
diff --git a/mm-audio/aenc-amrnb/qdsp6/test/omx_amr_enc_test.c b/mm-audio/aenc-amrnb/qdsp6/test/omx_amr_enc_test.c
index e509748..3448bff 100644
--- a/mm-audio/aenc-amrnb/qdsp6/test/omx_amr_enc_test.c
+++ b/mm-audio/aenc-amrnb/qdsp6/test/omx_amr_enc_test.c
@@ -89,6 +89,7 @@
 uint32_t pcmplayback = 0;
 uint32_t tunnel      = 0;
 uint32_t format = 1;
+uint32_t amrwb_enable=0;
 #define DEBUG_PRINT printf
 unsigned to_idle_transition = 0;
 unsigned long total_pcm_bytes;
@@ -110,6 +111,7 @@
 #define MIN_BITRATE 4 /* Bit rate 1 - 13.6 , 2 - 6.2 , 3 - 2.7 , 4 - 1.0 kbps*/
 #define MAX_BITRATE 4
 #define AMR_HEADER_SIZE 6
+#define AMRWB_HEADER_SIZE 9
 #define FAILED(result) (result != OMX_ErrorNone)
 
 #define SUCCEEDED(result) (result == OMX_ErrorNone)
@@ -499,6 +501,7 @@
 
     struct sigaction sa;
     char amr_header[6] = {0x23, 0x21, 0x41, 0x4D, 0x52, 0x0A};
+    char amrwb_header[9] = {0x23, 0x21, 0x41, 0x4D, 0x52,0x2D, 0x57, 0x42, 0x0A};
     memset(&sa, 0, sizeof(sa));
     sa.sa_handler = &signal_handler;
     sigaction(SIGABRT, &sa, NULL);
@@ -513,7 +516,7 @@
     pthread_mutex_init(&etb_lock, 0);
     pthread_mutex_init(&etb_lock1, 0);
 
-    if (argc >= 8) {
+    if (argc >= 9) {
         in_filename = argv[1];
           out_filename = argv[2];
     tunnel =  (uint32_t)atoi(argv[3]);
@@ -521,23 +524,35 @@
         dtxenable  = (uint32_t)atoi(argv[5]);
         recpath      = (uint32_t)atoi(argv[6]); // No configuration support yet..
         rectime      = (uint32_t)atoi(argv[7]);
+        amrwb_enable = (uint32_t)atoi(argv[8]);
 
     } else {
           DEBUG_PRINT(" invalid format: \n");
-          DEBUG_PRINT("ex: ./mm-aenc-omxamr-test INPUTFILE OUTPUTFILE Tunnel BANDMODE DTXENABLE RECORDPATH RECORDTIME\n");
+          DEBUG_PRINT("ex: ./mm-aenc-omxamr-test INPUTFILE OUTPUTFILE Tunnel BANDMODE DTXENABLE RECORDPATH RECORDTIME amrwb_enable \n");
           DEBUG_PRINT("Bandmode 1-7, dtxenable 0-1\n");
           DEBUG_PRINT("RECORDPATH 0(TX),1(RX),2(BOTH),3(MIC)\n");
           DEBUG_PRINT("RECORDTIME in seconds for AST Automation\n");
+	  DEBUG_PRINT("amrwb_enable:1-amrwb 0-amrnb\n");
           return 0;
     }
     if(recpath != 3) {
           DEBUG_PRINT("For RECORDPATH Only MIC supported\n");
           return 0;
     }
-    if(tunnel == 0)
-        aud_comp = "OMX.qcom.audio.encoder.amrnb";
-    else
-        aud_comp = "OMX.qcom.audio.encoder.tunneled.amrnb";
+    if(!amrwb_enable)
+    {
+        if(tunnel == 0)
+            aud_comp = "OMX.qcom.audio.encoder.amrnb";
+        else
+            aud_comp = "OMX.qcom.audio.encoder.tunneled.amrnb";
+    }
+    else {
+        if(tunnel == 0)
+            aud_comp = "OMX.qcom.audio.encoder.amrwb";
+        else
+            aud_comp = "OMX.qcom.audio.encoder.tunneled.amrwb";
+    }
+
     if(Init_Encoder(aud_comp)!= 0x00)
     {
         DEBUG_PRINT("Decoder Init failed\n");
@@ -589,7 +604,10 @@
             }
             wait_for_event();
             fseek(outputBufferFile, 0,SEEK_SET);
-            fwrite(amr_header,1,AMR_HEADER_SIZE,outputBufferFile);
+            if(!amrwb_enable)
+                fwrite(amr_header,1,AMR_HEADER_SIZE,outputBufferFile);
+            else
+                fwrite(amrwb_header,1,AMRWB_HEADER_SIZE,outputBufferFile);
 
             result = OMX_FreeHandle(amr_enc_handle);
             if (result != OMX_ErrorNone) {
@@ -1013,7 +1031,11 @@
     error_code = -1;
     return error_code;
     }
-    fseek(outputBufferFile, AMR_HEADER_SIZE, SEEK_SET);
+    if(!amrwb_enable) {
+        fseek(outputBufferFile, AMR_HEADER_SIZE, SEEK_SET);
+    } else {
+        fseek(outputBufferFile, AMRWB_HEADER_SIZE, SEEK_SET);
+    }
     return error_code;
 }
 
diff --git a/mm-audio/aenc-g711/Android.mk b/mm-audio/aenc-g711/Android.mk
new file mode 100644
index 0000000..4aff5c6
--- /dev/null
+++ b/mm-audio/aenc-g711/Android.mk
@@ -0,0 +1,7 @@
+ifneq ($(filter arm aarch64 arm64, $(TARGET_ARCH)),)
+
+AENC_G7111_PATH:= $(call my-dir)
+
+include $(AENC_G7111_PATH)/qdsp6/Android.mk
+
+endif
diff --git a/mm-audio/aenc-g711/Makefile b/mm-audio/aenc-g711/Makefile
new file mode 100644
index 0000000..83d822b
--- /dev/null
+++ b/mm-audio/aenc-g711/Makefile
@@ -0,0 +1,6 @@
+all:
+	@echo "invoking omxaudio make"
+	$(MAKE) -C qdsp6
+
+install:
+	$(MAKE) -C qdsp6 install
diff --git a/mm-audio/aenc-g711/Makefile.am b/mm-audio/aenc-g711/Makefile.am
new file mode 100644
index 0000000..24c1af2
--- /dev/null
+++ b/mm-audio/aenc-g711/Makefile.am
@@ -0,0 +1 @@
+SUBDIRS = qdsp6
diff --git a/mm-audio/aenc-g711/qdsp6/Android.mk b/mm-audio/aenc-g711/qdsp6/Android.mk
new file mode 100644
index 0000000..fd071eb
--- /dev/null
+++ b/mm-audio/aenc-g711/qdsp6/Android.mk
@@ -0,0 +1,72 @@
+ifneq ($(BUILD_TINY_ANDROID),true)
+
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+# ---------------------------------------------------------------------------------
+#                 Common definitons
+# ---------------------------------------------------------------------------------
+
+libOmxG711Enc-def := -g -O3
+libOmxG711Enc-def += -DQC_MODIFIED
+libOmxG711Enc-def += -D_ANDROID_
+libOmxG711Enc-def += -D_ENABLE_QC_MSG_LOG_
+libOmxG711Enc-def += -DVERBOSE
+libOmxG711Enc-def += -D_DEBUG
+libOmxG711Enc-def += -Wconversion
+libOmxG711Enc-def += -DAUDIOV2
+
+# ---------------------------------------------------------------------------------
+#             Make the Shared library (libOmxG711Enc)
+# ---------------------------------------------------------------------------------
+
+include $(CLEAR_VARS)
+
+libOmxG711Enc-inc       := $(LOCAL_PATH)/inc
+libOmxG711Enc-inc       += $(TARGET_OUT_HEADERS)/mm-core/omxcore
+
+LOCAL_MODULE            := libOmxG711Enc
+LOCAL_MODULE_TAGS       := optional
+LOCAL_CFLAGS            := $(libOmxG711Enc-def)
+LOCAL_C_INCLUDES        := $(libOmxG711Enc-inc)
+LOCAL_PRELINK_MODULE    := false
+LOCAL_SHARED_LIBRARIES  := libutils liblog libcutils
+
+LOCAL_SRC_FILES         := src/aenc_svr.c
+LOCAL_SRC_FILES         += src/omx_g711_aenc.cpp
+LOCAL_SRC_FILES         += src/omx_log.cpp
+
+LOCAL_C_INCLUDES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
+LOCAL_ADDITIONAL_DEPENDENCIES += $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr
+
+
+include $(BUILD_SHARED_LIBRARY)
+
+
+# ---------------------------------------------------------------------------------
+#             Make the apps-test (mm-aenc-omxg711-test)
+# ---------------------------------------------------------------------------------
+
+include $(CLEAR_VARS)
+
+mm-g711-enc-test-inc   := $(LOCAL_PATH)/inc
+mm-g711-enc-test-inc   += $(LOCAL_PATH)/test
+mm-g711-enc-test-inc   += $(TARGET_OUT_HEADERS)/mm-core/omxcore
+
+LOCAL_MODULE            := mm-aenc-omxg711-test
+LOCAL_MODULE_TAGS       := optional
+LOCAL_CFLAGS            := $(libOmxG711Enc-def)
+LOCAL_C_INCLUDES        := $(mm-g711-enc-test-inc)
+LOCAL_PRELINK_MODULE    := false
+LOCAL_SHARED_LIBRARIES  := libmm-omxcore
+LOCAL_SHARED_LIBRARIES  += libOmxG711Enc
+LOCAL_SRC_FILES         := test/omx_g711_enc_test.c
+
+include $(BUILD_EXECUTABLE)
+
+endif
+
+# ---------------------------------------------------------------------------------
+#                     END
+# ---------------------------------------------------------------------------------
+
diff --git a/mm-audio/aenc-g711/qdsp6/Makefile b/mm-audio/aenc-g711/qdsp6/Makefile
new file mode 100644
index 0000000..80dd4e5
--- /dev/null
+++ b/mm-audio/aenc-g711/qdsp6/Makefile
@@ -0,0 +1,81 @@
+# ---------------------------------------------------------------------------------
+#				MM-AUDIO-OSS-8K-AENC-G7111
+# ---------------------------------------------------------------------------------
+
+# cross-compiler flags
+CFLAGS += -Wall
+CFLAGS += -Wundef
+CFLAGS += -Wstrict-prototypes
+CFLAGS += -Wno-trigraphs
+
+# cross-compile flags specific to shared objects
+CFLAGS_SO += -fpic
+
+# required pre-processor flags
+CPPFLAGS := -D__packed__=
+CPPFLAGS += -DIMAGE_APPS_PROC
+CPPFLAGS += -DFEATURE_Q_SINGLE_LINK
+CPPFLAGS += -DFEATURE_Q_NO_SELF_QPTR
+CPPFLAGS += -DFEATURE_LINUX
+CPPFLAGS += -DFEATURE_NATIVELINUX
+CPPFLAGS += -DFEATURE_DSM_DUP_ITEMS
+
+CPPFLAGS += -g
+CPPFALGS += -D_DEBUG
+CPPFLAGS += -Iinc
+
+# linker flags
+LDFLAGS += -L$(SYSROOT)/usr/lib
+
+# linker flags for shared objects
+LDFLAGS_SO := -shared
+
+# defintions
+LIBMAJOR := $(basename $(basename $(LIBVER)))
+LIBINSTALLDIR := $(DESTDIR)usr/lib
+INCINSTALLDIR := $(DESTDIR)usr/include
+BININSTALLDIR := $(DESTDIR)usr/bin
+
+# ---------------------------------------------------------------------------------
+#					BUILD
+# ---------------------------------------------------------------------------------
+all: libOmxG711Enc.so.$(LIBVER) mm-aenc-omxg711-test
+
+install:
+	echo "intalling aenc-g711 in $(DESTDIR)"
+	if [ ! -d $(LIBINSTALLDIR) ]; then mkdir -p $(LIBINSTALLDIR); fi
+	if [ ! -d $(INCINSTALLDIR) ]; then mkdir -p $(INCINSTALLDIR); fi
+	if [ ! -d $(BININSTALLDIR) ]; then mkdir -p $(BININSTALLDIR); fi
+	install -m 555 libOmxG711Enc.so.$(LIBVER) $(LIBINSTALLDIR)
+	cd $(LIBINSTALLDIR) && ln -s libOmxG711Enc.so.$(LIBVER) libOmxG711Enc.so.$(LIBMAJOR)
+	cd $(LIBINSTALLDIR) && ln -s libOmxG711Enc.so.$(LIBMAJOR) libOmxG711Enc.so
+	install -m 555 mm-aenc-omxg711-test $(BININSTALLDIR)
+
+# ---------------------------------------------------------------------------------
+#				COMPILE LIBRARY
+# ---------------------------------------------------------------------------------
+LDLIBS := -lpthread
+LDLIBS += -lstdc++
+LDLIBS += -lOmxCore
+
+SRCS := src/omx_g711_aenc.cpp
+SRCS += src/aenc_svr.c
+
+libOmxG711Enc.so.$(LIBVER): $(SRCS)
+	$(CC) $(CPPFLAGS) $(CFLAGS_SO) $(LDFLAGS_SO) -Wl,-soname,libOmxG711Enc.so.$(LIBMAJOR) -o $@ $^ $(LDFLAGS) $(LDLIBS)
+
+# ---------------------------------------------------------------------------------
+#				COMPILE TEST APP
+# ---------------------------------------------------------------------------------
+TEST_LDLIBS := -lpthread
+TEST_LDLIBS += -ldl
+TEST_LDLIBS += -lOmxCore
+
+#TEST_SRCS := test/omx_g711_enc_test.c
+
+mm-aenc-omxg711-test: libOmxG711Enc.so.$(LIBVER) $(TEST_SRCS)
+	$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) -o $@ $^ $(TEST_LDLIBS)
+
+# ---------------------------------------------------------------------------------
+#					END
+# ---------------------------------------------------------------------------------
diff --git a/mm-audio/aenc-g711/qdsp6/Makefile.am b/mm-audio/aenc-g711/qdsp6/Makefile.am
new file mode 100644
index 0000000..572b87d
--- /dev/null
+++ b/mm-audio/aenc-g711/qdsp6/Makefile.am
@@ -0,0 +1,29 @@
+AM_CFLAGS = -Wall \
+            -Wundef \
+            -Wstrict-prototypes \
+            -Wno-trigraphs \
+            -fPIC \
+            -g -O3 \
+            -DQC_MODIFIED \
+            -D_ANDROID_ \
+            -D_ENABLE_QC_MSG_LOG_ \
+            -DVERBOSE \
+            -D_DEBUG \
+            -DAUDIOV2 \
+            -I inc \
+            -I ${WORKSPACE}/hardware/qcom/media/mm-core/inc/
+
+C_SOURCES = src/aenc_svr.c \
+            src/omx_g711_aenc.cpp \
+            src/omx_log.cpp
+
+lib_LTLIBRARIES = libOmxG711Enc.la
+libOmxG711Enc_la_SOURCES = $(C_SOURCES)
+libOmxG711Enc_la_CFLAGS = $(AM_CFLAGS) -Dstrlcpy=g_strlcpy $(GLIB_CFLAGS) -include glib.h
+libOmxG711Enc_la_CPPFLAGS = $(AM_CFLAGS) -Dstrlcpy=g_strlcpy $(GLIB_CFLAGS) -include glib.h
+libOmxG711Enc_la_LDFLAGS = $(GLIB_LIBS) -lcutils -llog -lstdc++
+
+bin_PROGRAMS = mm_aenc_omxg711_test
+mm_aenc_omxg711_test_SOURCES = ./test/omx_g711_enc_test.c
+mm_aenc_omxg711_test_CFLAGS = $(AM_CFLAGS) -Dstrlcpy=g_strlcpy $(GLIB_CFLAGS) -include glib.h
+mm_aenc_omxg711_test_LDADD = $(GLIB_LIBS) -lmm-omxcore -lpthread libOmxG711Enc.la
diff --git a/mm-audio/aenc-g711/qdsp6/inc/Map.h b/mm-audio/aenc-g711/qdsp6/inc/Map.h
new file mode 100644
index 0000000..22d3634
--- /dev/null
+++ b/mm-audio/aenc-g711/qdsp6/inc/Map.h
@@ -0,0 +1,245 @@
+/*--------------------------------------------------------------------------
+Copyright (c) 2010 The Linux Foundation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of The Linux Foundation nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--------------------------------------------------------------------------*/
+#ifndef _MAP_H_
+#define _MAP_H_
+
+#include <stdio.h>
+using namespace std;
+
+template <typename T,typename T2>
+class Map
+{
+    struct node
+    {
+        T    data;
+        T2   data2;
+        node* prev;
+        node* next;
+        node(T t, T2 t2,node* p, node* n) :
+             data(t), data2(t2), prev(p), next(n) {}
+    };
+    node* head;
+    node* tail;
+    node* tmp;
+    unsigned size_of_list;
+    static Map<T,T2> *m_self;
+public:
+    Map() : head( NULL ), tail ( NULL ),tmp(head),size_of_list(0) {}
+    bool empty() const { return ( !head || !tail ); }
+    operator bool() const { return !empty(); }
+    void insert(T,T2);
+    void show();
+    int  size();
+    T2 find(T); // Return VALUE
+    T find_ele(T);// Check if the KEY is present or not
+    T2 begin(); //give the first ele
+    bool erase(T);
+    bool eraseall();
+    bool isempty();
+    ~Map()
+    {
+        while(head)
+        {
+            node* temp(head);
+            head=head->next;
+            size_of_list--;
+            delete temp;
+        }
+    }
+};
+
+template <typename T,typename T2>
+T2 Map<T,T2>::find(T d1)
+{
+    tmp = head;
+    while(tmp)
+    {
+        if(tmp->data == d1)
+        {
+            return tmp->data2;
+        }
+        tmp = tmp->next;
+    }
+    return 0;
+}
+
+template <typename T,typename T2>
+T Map<T,T2>::find_ele(T d1)
+{
+    tmp = head;
+    while(tmp)
+    {
+        if(tmp->data == d1)
+        {
+            return tmp->data;
+        }
+        tmp = tmp->next;
+    }
+    return 0;
+}
+
+template <typename T,typename T2>
+T2 Map<T,T2>::begin()
+{
+    tmp = head;
+    if(tmp)
+    {
+        return (tmp->data2);
+    }
+    return 0;
+}
+
+template <typename T,typename T2>
+void Map<T,T2>::show()
+{
+    tmp = head;
+    while(tmp)
+    {
+        printf("%d-->%d\n",tmp->data,tmp->data2);
+        tmp = tmp->next;
+    }
+}
+
+template <typename T,typename T2>
+int Map<T,T2>::size()
+{
+    int count =0;
+    tmp = head;
+    while(tmp)
+    {
+        tmp = tmp->next;
+        count++;
+    }
+    return count;
+}
+
+template <typename T,typename T2>
+void Map<T,T2>::insert(T data, T2 data2)
+{
+    tail = new node(data, data2,tail, NULL);
+    if( tail->prev )
+        tail->prev->next = tail;
+
+    if( empty() )
+    {
+        head = tail;
+        tmp=head;
+    }
+    tmp = head;
+    size_of_list++;
+}
+
+template <typename T,typename T2>
+bool Map<T,T2>::erase(T d)
+{
+    bool found = false;
+    tmp = head;
+    node* prevnode = tmp;
+    node *tempnode;
+
+    while(tmp)
+    {
+        if((head == tail) && (head->data == d))
+        {
+           found = true;
+           tempnode = head;
+           head = tail = NULL;
+           delete tempnode;
+           break;
+        }
+        if((tmp ==head) && (tmp->data ==d))
+        {
+            found = true;
+            tempnode = tmp;
+            tmp = tmp->next;
+            tmp->prev = NULL;
+            head = tmp;
+            tempnode->next = NULL;
+            delete tempnode;
+            break;
+        }
+        if((tmp == tail) && (tmp->data ==d))
+        {
+            found = true;
+            tempnode = tmp;
+            prevnode->next = NULL;
+            tmp->prev = NULL;
+            tail = prevnode;
+            delete tempnode;
+            break;
+        }
+        if(tmp->data == d)
+        {
+            found = true;
+            prevnode->next = tmp->next;
+            tmp->next->prev = prevnode->next;
+            tempnode = tmp;
+            //tmp = tmp->next;
+            delete tempnode;
+            break;
+        }
+        prevnode = tmp;
+        tmp = tmp->next;
+    }
+    if(found)size_of_list--;
+    return found;
+}
+
+template <typename T,typename T2>
+bool Map<T,T2>::eraseall()
+{
+    // Be careful while using this method
+    // it not only removes the node but FREES(not delete) the allocated
+    // memory.
+    node *tempnode;
+    tmp = head;
+    while(head)
+    {
+       tempnode = head;
+       head = head->next;
+       tempnode->next = NULL;
+       if(tempnode->data)
+           free(tempnode->data);
+       if(tempnode->data2)
+           free(tempnode->data2);
+           delete tempnode;
+    }
+    tail = head = NULL;
+    return true;
+}
+
+
+template <typename T,typename T2>
+bool Map<T,T2>::isempty()
+{
+    if(!size_of_list) return true;
+    else return false;
+}
+
+#endif // _MAP_H_
diff --git a/mm-audio/aenc-g711/qdsp6/inc/aenc_svr.h b/mm-audio/aenc-g711/qdsp6/inc/aenc_svr.h
new file mode 100644
index 0000000..24132e1
--- /dev/null
+++ b/mm-audio/aenc-g711/qdsp6/inc/aenc_svr.h
@@ -0,0 +1,121 @@
+/*--------------------------------------------------------------------------
+Copyright (c) 2010, 2016, The Linux Foundation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of The Linux Foundation nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--------------------------------------------------------------------------*/
+#ifndef AENC_SVR_H
+#define AENC_SVR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <pthread.h>
+#include <sched.h>
+#include <utils/Log.h>
+
+#ifdef _ANDROID_
+#define LOG_TAG "QC_G711ENC"
+#endif
+
+#ifndef LOGE
+#define LOGE ALOGE
+#endif
+
+#ifndef LOGW
+#define LOGW ALOGW
+#endif
+
+#ifndef LOGD
+#define LOGD ALOGD
+#endif
+
+#ifndef LOGV
+#define LOGV ALOGV
+#endif
+
+#ifndef LOGI
+#define LOGI ALOGI
+#endif
+
+#define DEBUG_PRINT_ERROR LOGE
+#define DEBUG_PRINT       LOGI
+#define DEBUG_DETAIL      LOGV
+
+typedef void (*message_func)(void* client_data, unsigned char id);
+
+/**
+ @brief audio encoder ipc info structure
+
+ */
+struct g711_ipc_info
+{
+    pthread_t thr;
+    int pipe_in;
+    int pipe_out;
+    int dead;
+    message_func process_msg_cb;
+    void         *client_data;
+    char         thread_name[128];
+};
+
+/**
+ @brief This function starts command server
+
+ @param cb pointer to callback function from the client
+ @param client_data reference client wants to get back
+  through callback
+ @return handle to command server
+ */
+struct g711_ipc_info *omx_g711_thread_create(message_func cb,
+    void* client_data,
+    char *th_name);
+
+struct g711_ipc_info *omx_g711_event_thread_create(message_func cb,
+    void* client_data,
+    char *th_name);
+/**
+ @brief This function stop command server
+
+ @param svr handle to command server
+ @return none
+ */
+void omx_g711_thread_stop(struct g711_ipc_info *g711_ipc);
+
+
+/**
+ @brief This function post message in the command server
+
+ @param svr handle to command server
+ @return none
+ */
+void omx_g711_post_msg(struct g711_ipc_info *g711_ipc,
+                          unsigned char id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* AENC_SVR */
diff --git a/mm-audio/aenc-g711/qdsp6/inc/omx_g711_aenc.h b/mm-audio/aenc-g711/qdsp6/inc/omx_g711_aenc.h
new file mode 100644
index 0000000..9f91299
--- /dev/null
+++ b/mm-audio/aenc-g711/qdsp6/inc/omx_g711_aenc.h
@@ -0,0 +1,539 @@
+/*--------------------------------------------------------------------------
+Copyright (c) 2010, 2014, 2016 The Linux Foundation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of The Linux Foundation nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--------------------------------------------------------------------------*/
+#ifndef _G711_ENC_H_
+#define _G711_ENC_H_
+/*============================================================================
+                    Audio Encoder
+
+@file omx_g711_aenc.h
+This module contains the class definition for openMAX encoder component.
+
+
+
+============================================================================*/
+
+//////////////////////////////////////////////////////////////////////////////
+//                             Include Files
+//////////////////////////////////////////////////////////////////////////////
+
+/* Uncomment out below line #define LOG_NDEBUG 0 if we want to see
+ *  all DEBUG_PRINT or LOGV messaging */
+#include<stdlib.h>
+#include <stdio.h>
+#include <pthread.h>
+#include <time.h>
+#include <inttypes.h>
+#include <unistd.h>
+#include "QOMX_AudioExtensions.h"
+#include "QOMX_AudioIndexExtensions.h"
+#include "OMX_Core.h"
+#include "OMX_Audio.h"
+#include "aenc_svr.h"
+#include "qc_omx_component.h"
+#include "Map.h"
+#include <semaphore.h>
+#include <linux/msm_audio.h>
+#include <linux/msm_audio_g711.h>
+extern "C" {
+    void * get_omx_component_factory_fn(void);
+}
+
+
+//////////////////////////////////////////////////////////////////////////////
+//                       Module specific globals
+//////////////////////////////////////////////////////////////////////////////
+
+
+
+#define OMX_SPEC_VERSION  0x00000101
+#define MIN(x,y) (((x) < (y)) ? (x) : (y))
+#define MAX(x,y) (x >= y?x:y)
+
+//////////////////////////////////////////////////////////////////////////////
+//               Macros
+//////////////////////////////////////////////////////////////////////////////
+//
+
+
+#define PrintFrameHdr(i,bufHdr) \
+                           DEBUG_PRINT("i=%d OMX bufHdr[%p]buf[%p]size[%d]TS[%lld]nFlags[0x%x]\n",\
+                           i,\
+                           bufHdr,                                     \
+                           ((OMX_BUFFERHEADERTYPE *)bufHdr)->pBuffer,   \
+                           (unsigned)((OMX_BUFFERHEADERTYPE *)bufHdr)->nFilledLen,\
+                           ((OMX_BUFFERHEADERTYPE *)bufHdr)->nTimeStamp, \
+                           (unsigned)((OMX_BUFFERHEADERTYPE *)bufHdr)->nFlags)
+
+
+// BitMask Management logic
+#define BITS_PER_BYTE 8
+#define BITMASK_SIZE(mIndex) \
+            (((mIndex) + BITS_PER_BYTE - 1)/BITS_PER_BYTE)
+#define BITMASK_OFFSET(mIndex)\
+            ((mIndex)/BITS_PER_BYTE)
+#define BITMASK_FLAG(mIndex) \
+            (1 << ((mIndex) % BITS_PER_BYTE))
+#define BITMASK_CLEAR(mArray,mIndex)\
+            (mArray)[BITMASK_OFFSET(mIndex)] &=  ~(BITMASK_FLAG(mIndex))
+#define BITMASK_SET(mArray,mIndex)\
+            (mArray)[BITMASK_OFFSET(mIndex)] |=  BITMASK_FLAG(mIndex)
+#define BITMASK_PRESENT(mArray,mIndex)\
+            ((mArray)[BITMASK_OFFSET(mIndex)] & BITMASK_FLAG(mIndex))
+#define BITMASK_ABSENT(mArray,mIndex)\
+            (((mArray)[BITMASK_OFFSET(mIndex)] & \
+            BITMASK_FLAG(mIndex)) == 0x0)
+
+#define OMX_CORE_NUM_INPUT_BUFFERS    4
+#define OMX_CORE_NUM_OUTPUT_BUFFERS   8
+
+#define OMX_CORE_INPUT_BUFFER_SIZE    4096 // Multiple of 160
+#define OMX_CORE_CONTROL_CMDQ_SIZE   100
+#define OMX_AENC_VOLUME_STEP         0x147
+#define OMX_AENC_MIN                 0
+#define OMX_AENC_MAX                 100
+#define NON_TUNNEL                   1
+#define TUNNEL                       0
+#define IP_PORT_BITMASK                 0x02
+#define OP_PORT_BITMASK                 0x01
+#define IP_OP_PORT_BITMASK              0x03
+
+#define OMX_G711_DEFAULT_SF            8000
+#define OMX_G711_DEFAULT_CH_CFG        1
+#define OMX_G711_DEFAULT_VOL         25
+// 14 bytes for input meta data
+#define OMX_AENC_SIZEOF_META_BUF     (OMX_CORE_INPUT_BUFFER_SIZE+14)
+
+#define TRUE 1
+#define FALSE 0
+
+#define NUMOFFRAMES                   1
+#define MAXFRAMELENGTH                360
+#define OMX_G711_OUTPUT_BUFFER_SIZE    ((NUMOFFRAMES * (sizeof(ENC_META_OUT) + MAXFRAMELENGTH) \
+                        + 1))
+
+
+class omx_g711_aenc;
+
+// OMX mo3 audio encoder class
+class omx_g711_aenc: public qc_omx_component
+{
+public:
+    omx_g711_aenc();                             // constructor
+    virtual ~omx_g711_aenc();                    // destructor
+
+    OMX_ERRORTYPE allocate_buffer(OMX_HANDLETYPE             hComp,
+                                  OMX_BUFFERHEADERTYPE **bufferHdr,
+                                  OMX_U32                     port,
+                                  OMX_PTR                  appData,
+                                  OMX_U32                    bytes);
+
+
+    OMX_ERRORTYPE component_deinit(OMX_HANDLETYPE hComp);
+
+    OMX_ERRORTYPE component_init(OMX_STRING role);
+
+    OMX_ERRORTYPE component_role_enum(OMX_HANDLETYPE hComp,
+                                      OMX_U8         *role,
+                                      OMX_U32        index);
+
+    OMX_ERRORTYPE component_tunnel_request(OMX_HANDLETYPE             hComp,
+                                           OMX_U32                     port,
+                                           OMX_HANDLETYPE     peerComponent,
+                                           OMX_U32                 peerPort,
+                                           OMX_TUNNELSETUPTYPE *tunnelSetup);
+
+    OMX_ERRORTYPE empty_this_buffer(OMX_HANDLETYPE         hComp,
+                                    OMX_BUFFERHEADERTYPE *buffer);
+
+
+    OMX_ERRORTYPE empty_this_buffer_proxy(OMX_HANDLETYPE         hComp,
+                                          OMX_BUFFERHEADERTYPE *buffer);
+
+
+    OMX_ERRORTYPE fill_this_buffer(OMX_HANDLETYPE         hComp,
+                                   OMX_BUFFERHEADERTYPE *buffer);
+
+
+    OMX_ERRORTYPE free_buffer(OMX_HANDLETYPE         hComp,
+                              OMX_U32                 port,
+                              OMX_BUFFERHEADERTYPE *buffer);
+
+    OMX_ERRORTYPE get_component_version(OMX_HANDLETYPE              hComp,
+                                        OMX_STRING          componentName,
+                                        OMX_VERSIONTYPE *componentVersion,
+                                        OMX_VERSIONTYPE *     specVersion,
+                                        OMX_UUIDTYPE       *componentUUID);
+
+    OMX_ERRORTYPE get_config(OMX_HANDLETYPE      hComp,
+                             OMX_INDEXTYPE configIndex,
+                             OMX_PTR        configData);
+
+    OMX_ERRORTYPE get_extension_index(OMX_HANDLETYPE     hComp,
+                                      OMX_STRING     paramName,
+                                      OMX_INDEXTYPE *indexType);
+
+    OMX_ERRORTYPE get_parameter(OMX_HANDLETYPE hComp,
+                                OMX_INDEXTYPE paramIndex,
+                                OMX_PTR paramData);
+
+    OMX_ERRORTYPE get_state(OMX_HANDLETYPE hComp,
+                            OMX_STATETYPE *state);
+
+    static void process_in_port_msg(void          *client_data,
+                                    unsigned char id);
+
+    static void process_out_port_msg(void          *client_data,
+                                     unsigned char id);
+
+    static void process_command_msg(void          *client_data,
+                                    unsigned char id);
+
+    static void process_event_cb(void          *client_data,
+                                   unsigned char id);
+
+
+    OMX_ERRORTYPE set_callbacks(OMX_HANDLETYPE hComp,
+                                OMX_CALLBACKTYPE *callbacks,
+                                OMX_PTR appData);
+
+    OMX_ERRORTYPE set_config(OMX_HANDLETYPE hComp,
+                             OMX_INDEXTYPE configIndex,
+                             OMX_PTR configData);
+
+    OMX_ERRORTYPE set_parameter(OMX_HANDLETYPE hComp,
+                                OMX_INDEXTYPE paramIndex,
+                                OMX_PTR paramData);
+
+    OMX_ERRORTYPE use_buffer(OMX_HANDLETYPE             hComp,
+                             OMX_BUFFERHEADERTYPE **bufferHdr,
+                             OMX_U32                     port,
+                             OMX_PTR                  appData,
+                             OMX_U32                    bytes,
+                             OMX_U8                  *buffer);
+
+    OMX_ERRORTYPE use_EGL_image(OMX_HANDLETYPE             hComp,
+                                OMX_BUFFERHEADERTYPE **bufferHdr,
+                                OMX_U32                     port,
+                                OMX_PTR                  appData,
+                                void *                  eglImage);
+
+    bool post_command(unsigned int p1, unsigned int p2,
+        unsigned char id);
+
+    // Deferred callback identifiers
+    enum
+    {
+        //Event Callbacks from the component thread context
+        OMX_COMPONENT_GENERATE_EVENT       = 0x1,
+        //Buffer Done callbacks from component thread context
+        OMX_COMPONENT_GENERATE_BUFFER_DONE = 0x2,
+        OMX_COMPONENT_GENERATE_ETB         = 0x3,
+        //Command
+        OMX_COMPONENT_GENERATE_COMMAND     = 0x4,
+        OMX_COMPONENT_GENERATE_FRAME_DONE  = 0x05,
+        OMX_COMPONENT_GENERATE_FTB         = 0x06,
+        OMX_COMPONENT_GENERATE_EOS         = 0x07,
+        OMX_COMPONENT_PORTSETTINGS_CHANGED = 0x08,
+        OMX_COMPONENT_SUSPEND              = 0x09,
+        OMX_COMPONENT_RESUME               = 0x0a
+    };
+private:
+
+    ///////////////////////////////////////////////////////////
+    // Type definitions
+    ///////////////////////////////////////////////////////////
+    // Bit Positions
+    enum flags_bit_positions
+    {
+        // Defer transition to IDLE
+        OMX_COMPONENT_IDLE_PENDING            =0x1,
+        // Defer transition to LOADING
+        OMX_COMPONENT_LOADING_PENDING         =0x2,
+
+        OMX_COMPONENT_MUTED                   =0x3,
+
+        // Defer transition to Enable
+        OMX_COMPONENT_INPUT_ENABLE_PENDING    =0x4,
+        // Defer transition to Enable
+        OMX_COMPONENT_OUTPUT_ENABLE_PENDING   =0x5,
+        // Defer transition to Disable
+        OMX_COMPONENT_INPUT_DISABLE_PENDING   =0x6,
+        // Defer transition to Disable
+        OMX_COMPONENT_OUTPUT_DISABLE_PENDING  =0x7
+    };
+
+
+    typedef Map<OMX_BUFFERHEADERTYPE*, OMX_BUFFERHEADERTYPE*>
+    input_buffer_map;
+
+    typedef Map<OMX_BUFFERHEADERTYPE*, OMX_BUFFERHEADERTYPE*>
+    output_buffer_map;
+
+    enum port_indexes
+    {
+        OMX_CORE_INPUT_PORT_INDEX        =0,
+        OMX_CORE_OUTPUT_PORT_INDEX       =1
+    };
+
+    struct omx_event
+    {
+        unsigned long param1;
+        unsigned long param2;
+        unsigned char id;
+    };
+
+    struct omx_cmd_queue
+    {
+        omx_event m_q[OMX_CORE_CONTROL_CMDQ_SIZE];
+        unsigned m_read;
+        unsigned m_write;
+        unsigned m_size;
+
+        omx_cmd_queue();
+        ~omx_cmd_queue();
+        bool insert_entry(unsigned long p1, unsigned long p2, unsigned char id);
+        bool pop_entry(unsigned long *p1,unsigned long *p2, unsigned char *id);
+        bool get_msg_id(unsigned char *id);
+        bool get_msg_with_id(unsigned *p1,unsigned *p2, unsigned id);
+    };
+
+    typedef struct TIMESTAMP
+    {
+        unsigned int LowPart;
+        unsigned int HighPart;
+    }__attribute__((packed)) TIMESTAMP;
+
+    typedef struct metadata_input
+    {
+        unsigned short offsetVal;
+        TIMESTAMP      nTimeStamp;
+        unsigned int   nFlags;
+    }__attribute__((packed)) META_IN;
+
+    typedef struct enc_meta_out
+    {
+        unsigned int offset_to_frame;
+        unsigned int frame_size;
+        unsigned int encoded_pcm_samples;
+        unsigned int lsw_ts;
+        unsigned int msw_ts;
+        unsigned int nflags;
+    } __attribute__ ((packed))ENC_META_OUT;
+
+    typedef struct
+    {
+        OMX_U32 tot_in_buf_len;
+        OMX_U32 tot_out_buf_len;
+        OMX_TICKS tot_pb_time;
+        OMX_U32 fbd_cnt;
+        OMX_U32 ftb_cnt;
+        OMX_U32 etb_cnt;
+        OMX_U32 ebd_cnt;
+    }G711_PB_STATS;
+
+    ///////////////////////////////////////////////////////////
+    // Member variables
+    ///////////////////////////////////////////////////////////
+    OMX_U8                         *m_tmp_meta_buf;
+    OMX_U8                         *m_tmp_out_meta_buf;
+    OMX_U8                         m_flush_cnt ;
+    OMX_U8                         m_comp_deinit;
+
+    // the below var doesnt hold good if combo of use and alloc bufs are used
+    OMX_S32                        m_volume;//Unit to be determined
+    OMX_PTR                        m_app_data;// Application data
+    int                            nNumInputBuf;
+    int                            nNumOutputBuf;
+    int                            m_drv_fd;   // Kernel device node file handle
+    bool                           bFlushinprogress;
+    bool                           is_in_th_sleep;
+    bool                           is_out_th_sleep;
+    unsigned int                   m_flags;      //encapsulate the waiting states.
+    OMX_TICKS                      nTimestamp;
+    unsigned int                   pcm_input; //tunnel or non-tunnel
+    unsigned int                   m_inp_act_buf_count;    // Num of Input Buffers
+    unsigned int                   m_out_act_buf_count;    // Numb of Output Buffers
+    unsigned int                   m_inp_current_buf_count;    // Num of Input Buffers
+    unsigned int                   m_out_current_buf_count;    // Numb of Output Buffers
+    unsigned int                   output_buffer_size;
+    unsigned int                   input_buffer_size;
+    unsigned short                 m_session_id;
+	bool                           is_mlaw;
+    // store I/P PORT state
+    OMX_BOOL                       m_inp_bEnabled;
+    // store O/P PORT state
+    OMX_BOOL                       m_out_bEnabled;
+    //Input port Populated
+    OMX_BOOL                       m_inp_bPopulated;
+    //Output port Populated
+    OMX_BOOL                       m_out_bPopulated;
+    sem_t                          sem_States;
+    sem_t                          sem_read_msg;
+    sem_t                          sem_write_msg;
+
+    volatile int                   m_is_event_done;
+    volatile int                   m_is_in_th_sleep;
+    volatile int                   m_is_out_th_sleep;
+    input_buffer_map               m_input_buf_hdrs;
+    output_buffer_map              m_output_buf_hdrs;
+    omx_cmd_queue                  m_input_q;
+    omx_cmd_queue                  m_input_ctrl_cmd_q;
+    omx_cmd_queue                  m_input_ctrl_ebd_q;
+    omx_cmd_queue                  m_command_q;
+    omx_cmd_queue                  m_output_q;
+    omx_cmd_queue                  m_output_ctrl_cmd_q;
+    omx_cmd_queue                  m_output_ctrl_fbd_q;
+    pthread_mutexattr_t            m_outputlock_attr;
+    pthread_mutexattr_t            m_commandlock_attr;
+    pthread_mutexattr_t            m_lock_attr;
+    pthread_mutexattr_t            m_state_attr;
+    pthread_mutexattr_t            m_flush_attr;
+    pthread_mutexattr_t            m_in_th_attr_1;
+    pthread_mutexattr_t            m_out_th_attr_1;
+    pthread_mutexattr_t            m_event_attr;
+    pthread_mutexattr_t            m_in_th_attr;
+    pthread_mutexattr_t            m_out_th_attr;
+    pthread_mutexattr_t            out_buf_count_lock_attr;
+    pthread_mutexattr_t            in_buf_count_lock_attr;
+    pthread_cond_t                 cond;
+    pthread_cond_t                 in_cond;
+    pthread_cond_t                 out_cond;
+    pthread_mutex_t                m_lock;
+    pthread_mutex_t                m_commandlock;
+    pthread_mutex_t                m_outputlock;
+    // Mutexes for state change
+    pthread_mutex_t                m_state_lock;
+    // Mutexes for  flush acks from input and output threads
+    pthread_mutex_t                m_flush_lock;
+    pthread_mutex_t                m_event_lock;
+    pthread_mutex_t                m_in_th_lock;
+    pthread_mutex_t                m_out_th_lock;
+    pthread_mutex_t                m_in_th_lock_1;
+    pthread_mutex_t                m_out_th_lock_1;
+    pthread_mutex_t                out_buf_count_lock;
+    pthread_mutex_t                in_buf_count_lock;
+
+    OMX_STATETYPE                  m_state;      // OMX State
+    OMX_STATETYPE                  nState;
+    OMX_CALLBACKTYPE               m_cb;         // Application callbacks
+    G711_PB_STATS                  m_g711_pb_stats;
+    struct g711_ipc_info           *m_ipc_to_in_th;    // for input thread
+    struct g711_ipc_info           *m_ipc_to_out_th;    // for output thread
+    struct g711_ipc_info           *m_ipc_to_cmd_th;    // for command thread
+    struct g711_ipc_info          *m_ipc_to_event_th;    //for txco event thread
+    OMX_PRIORITYMGMTTYPE           m_priority_mgm ;
+    OMX_AUDIO_PARAM_PCMMODETYPE    m_g711_param; // Cache G711 encoder parameter
+    OMX_AUDIO_PARAM_PCMMODETYPE    m_pcm_param;  // Cache pcm  parameter
+    OMX_PARAM_COMPONENTROLETYPE    component_Role;
+    OMX_PARAM_BUFFERSUPPLIERTYPE   m_buffer_supplier;
+
+    ///////////////////////////////////////////////////////////
+    // Private methods
+    ///////////////////////////////////////////////////////////
+    OMX_ERRORTYPE allocate_output_buffer(OMX_HANDLETYPE       hComp,
+                                         OMX_BUFFERHEADERTYPE **bufferHdr,
+                                         OMX_U32 port,OMX_PTR appData,
+                                         OMX_U32              bytes);
+
+    OMX_ERRORTYPE allocate_input_buffer(OMX_HANDLETYPE       hComp,
+                                        OMX_BUFFERHEADERTYPE **bufferHdr,
+                                        OMX_U32              port,
+                                        OMX_PTR              appData,
+                                        OMX_U32              bytes);
+
+    OMX_ERRORTYPE use_input_buffer(OMX_IN OMX_HANDLETYPE          hComp,
+                                   OMX_INOUT OMX_BUFFERHEADERTYPE **bufHdr,
+                                   OMX_IN OMX_U32                 port,
+                                   OMX_IN OMX_PTR                 appData,
+                                   OMX_IN OMX_U32                 bytes,
+                                   OMX_IN OMX_U8*                 buffer);
+
+    OMX_ERRORTYPE use_output_buffer(OMX_IN OMX_HANDLETYPE          hComp,
+                                    OMX_INOUT OMX_BUFFERHEADERTYPE **bufHdr,
+                                    OMX_IN OMX_U32                 port,
+                                    OMX_IN OMX_PTR                 appData,
+                                    OMX_IN OMX_U32                 bytes,
+                                    OMX_IN OMX_U8*                 buffer);
+
+    OMX_ERRORTYPE fill_this_buffer_proxy(OMX_HANDLETYPE       hComp,
+                                         OMX_BUFFERHEADERTYPE *buffer);
+
+    OMX_ERRORTYPE send_command_proxy(OMX_HANDLETYPE  hComp,
+                                     OMX_COMMANDTYPE cmd,
+                                     OMX_U32         param1,
+                                     OMX_PTR         cmdData);
+
+    OMX_ERRORTYPE send_command(OMX_HANDLETYPE hComp,
+                               OMX_COMMANDTYPE  cmd,
+                               OMX_U32       param1,
+                               OMX_PTR      cmdData);
+
+    bool allocate_done(void);
+
+    bool release_done(OMX_U32         param1);
+
+    bool execute_omx_flush(OMX_IN OMX_U32 param1, bool cmd_cmpl=true);
+
+    bool execute_input_omx_flush(void);
+
+    bool execute_output_omx_flush(void);
+
+    bool search_input_bufhdr(OMX_BUFFERHEADERTYPE *buffer);
+
+    bool search_output_bufhdr(OMX_BUFFERHEADERTYPE *buffer);
+
+    bool post_input(unsigned long p1, unsigned long p2,
+                    unsigned char id);
+
+    bool post_output(unsigned long p1, unsigned long p2,
+                     unsigned char id);
+
+    void process_events(omx_g711_aenc *client_data);
+
+    void buffer_done_cb(OMX_BUFFERHEADERTYPE *bufHdr);
+
+    void frame_done_cb(OMX_BUFFERHEADERTYPE *bufHdr);
+
+    void wait_for_event();
+
+    void event_complete();
+
+    void in_th_goto_sleep();
+
+    void in_th_wakeup();
+
+    void out_th_goto_sleep();
+
+    void out_th_wakeup();
+
+    void flush_ack();
+    void deinit_encoder();
+
+};
+#endif
diff --git a/mm-audio/aenc-g711/qdsp6/inc/omx_log.h b/mm-audio/aenc-g711/qdsp6/inc/omx_log.h
new file mode 100644
index 0000000..0080ccc
--- /dev/null
+++ b/mm-audio/aenc-g711/qdsp6/inc/omx_log.h
@@ -0,0 +1,61 @@
+/*--------------------------------------------------------------------------
+Copyright (c) 2016, The Linux Foundation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of The Linux Foundation nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--------------------------------------------------------------------------*/
+
+#ifndef OMX_LOGS_H
+#define OMX_LOGS_H
+
+#include <inttypes.h>
+
+using namespace std;
+
+/*
+ * Change logging-level at runtime with "persist.debug.omx.logs.level"
+ *
+ * level     OMX_LOGV        OMX_LOGD
+ * ----------------------------------
+ * 0         silent          silent
+ * 1         silent          printed
+ * 2         printed         printed
+ *
+ * AVLOGI/W/E are printed always
+ */
+
+extern uint32_t gOmxLogLevel;
+
+#define OMX_LOGV(format, args...) ALOGD_IF((gOmxLogLevel > 1), format, ##args)
+#define OMX_LOGD(format, args...) ALOGD_IF((gOmxLogLevel > 0), format, ##args)
+#define OMX_LOGI(format, args...) ALOGI(format, ##args)
+#define OMX_LOGW(format, args...) ALOGW(format, ##args)
+#define OMX_LOGE(format, args...) ALOGE(format, ##args)
+
+void updateLogLevel();
+
+
+#endif // OMX_LOGS_H
+
diff --git a/mm-audio/aenc-g711/qdsp6/src/aenc_svr.c b/mm-audio/aenc-g711/qdsp6/src/aenc_svr.c
new file mode 100644
index 0000000..fa44632
--- /dev/null
+++ b/mm-audio/aenc-g711/qdsp6/src/aenc_svr.c
@@ -0,0 +1,206 @@
+/*--------------------------------------------------------------------------
+Copyright (c) 2010, 2016 The Linux Foundation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of The Linux Foundation nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--------------------------------------------------------------------------*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <fcntl.h>
+#include <errno.h>
+
+#include <aenc_svr.h>
+
+/**
+ @brief This function processes posted messages
+
+ Once thread is being spawned, this function is run to
+ start processing commands posted by client
+
+ @param info pointer to context
+
+ */
+void *omx_g711_msg(void *info)
+{
+    struct g711_ipc_info *g711_info = (struct g711_ipc_info*)info;
+    unsigned char id;
+    ssize_t n;
+
+    DEBUG_DETAIL("\n%s: message thread start\n", __FUNCTION__);
+    while (!g711_info->dead)
+    {
+        n = read(g711_info->pipe_in, &id, 1);
+        if (0 == n) break;
+        if (1 == n)
+        {
+          DEBUG_DETAIL("\n%s-->pipe_in=%d pipe_out=%d\n",
+                                               g711_info->thread_name,
+                                               g711_info->pipe_in,
+                                               g711_info->pipe_out);
+
+            g711_info->process_msg_cb(g711_info->client_data, id);
+        }
+        if ((n < 0) && (errno != EINTR)) break;
+    }
+    DEBUG_DETAIL("%s: message thread stop\n", __FUNCTION__);
+
+    return 0;
+}
+
+void *omx_g711_events(void *info)
+{
+    struct g711_ipc_info *g711_info = (struct g711_ipc_info*)info;
+    unsigned char id = 0;
+
+    DEBUG_DETAIL("%s: message thread start\n", g711_info->thread_name);
+    g711_info->process_msg_cb(g711_info->client_data, id);
+    DEBUG_DETAIL("%s: message thread stop\n", g711_info->thread_name);
+    return 0;
+}
+
+/**
+ @brief This function starts command server
+
+ @param cb pointer to callback function from the client
+ @param client_data reference client wants to get back
+  through callback
+ @return handle to msging thread
+ */
+struct g711_ipc_info *omx_g711_thread_create(
+                                    message_func cb,
+                                    void* client_data,
+                                    char* th_name)
+{
+    int r;
+    int fds[2];
+    struct g711_ipc_info *g711_info;
+
+    g711_info = calloc(1, sizeof(struct g711_ipc_info));
+    if (!g711_info)
+    {
+        return 0;
+    }
+
+    g711_info->client_data = client_data;
+    g711_info->process_msg_cb = cb;
+    strlcpy(g711_info->thread_name, th_name, sizeof(g711_info->thread_name));
+
+    if (pipe(fds))
+    {
+        DEBUG_PRINT_ERROR("\n%s: pipe creation failed\n", __FUNCTION__);
+        goto fail_pipe;
+    }
+
+    g711_info->pipe_in = fds[0];
+    g711_info->pipe_out = fds[1];
+
+    r = pthread_create(&g711_info->thr, 0, omx_g711_msg, g711_info);
+    if (r < 0) goto fail_thread;
+
+    DEBUG_DETAIL("Created thread for %s \n", g711_info->thread_name);
+    return g711_info;
+
+
+fail_thread:
+    close(g711_info->pipe_in);
+    close(g711_info->pipe_out);
+
+fail_pipe:
+    free(g711_info);
+
+    return 0;
+}
+
+/**
+ *  @brief This function starts command server
+ *
+ *   @param cb pointer to callback function from the client
+ *    @param client_data reference client wants to get back
+ *      through callback
+ *       @return handle to msging thread
+ *        */
+struct g711_ipc_info *omx_g711_event_thread_create(
+                                    message_func cb,
+                                    void* client_data,
+                                    char* th_name)
+{
+    int r;
+    int fds[2];
+    struct g711_ipc_info *g711_info;
+
+    g711_info = calloc(1, sizeof(struct g711_ipc_info));
+    if (!g711_info)
+    {
+        return 0;
+    }
+
+    g711_info->client_data = client_data;
+    g711_info->process_msg_cb = cb;
+    strlcpy(g711_info->thread_name, th_name, sizeof(g711_info->thread_name));
+
+    if (pipe(fds))
+    {
+        DEBUG_PRINT("\n%s: pipe creation failed\n", __FUNCTION__);
+        goto fail_pipe;
+    }
+
+    g711_info->pipe_in = fds[0];
+    g711_info->pipe_out = fds[1];
+
+    r = pthread_create(&g711_info->thr, 0, omx_g711_events, g711_info);
+    if (r < 0) goto fail_thread;
+
+    DEBUG_DETAIL("Created thread for %s \n", g711_info->thread_name);
+    return g711_info;
+
+
+fail_thread:
+    close(g711_info->pipe_in);
+    close(g711_info->pipe_out);
+
+fail_pipe:
+    free(g711_info);
+
+    return 0;
+}
+
+void omx_g711_thread_stop(struct g711_ipc_info *g711_info) {
+    DEBUG_DETAIL("%s stop server\n", __FUNCTION__);
+    close(g711_info->pipe_in);
+    close(g711_info->pipe_out);
+    pthread_join(g711_info->thr,NULL);
+    g711_info->pipe_out = -1;
+    g711_info->pipe_in = -1;
+    DEBUG_DETAIL("%s: message thread close fds%d %d\n", g711_info->thread_name,
+        g711_info->pipe_in,g711_info->pipe_out);
+    free(g711_info);
+}
+
+void omx_g711_post_msg(struct g711_ipc_info *g711_info, unsigned char id) {
+    DEBUG_DETAIL("\n%s id=%d\n", __FUNCTION__,id);
+    write(g711_info->pipe_out, &id, 1);
+}
diff --git a/mm-audio/aenc-g711/qdsp6/src/omx_g711_aenc.cpp b/mm-audio/aenc-g711/qdsp6/src/omx_g711_aenc.cpp
new file mode 100644
index 0000000..23fe28a
--- /dev/null
+++ b/mm-audio/aenc-g711/qdsp6/src/omx_g711_aenc.cpp
@@ -0,0 +1,4572 @@
+/*--------------------------------------------------------------------------
+Copyright (c) 2010, 2014, 2016 The Linux Foundation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of The Linux Foundation nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--------------------------------------------------------------------------*/
+/*============================================================================
+@file omx_aenc_g711.c
+  This module contains the implementation of the OpenMAX core & component.
+
+*//*========================================================================*/
+//////////////////////////////////////////////////////////////////////////////
+//                             Include Files
+//////////////////////////////////////////////////////////////////////////////
+
+
+#include<string.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include "omx_g711_aenc.h"
+#include "omx_log.h"
+#include <errno.h>
+
+using namespace std;
+#define SLEEP_MS 100
+
+// omx_cmd_queue destructor
+omx_g711_aenc::omx_cmd_queue::~omx_cmd_queue()
+{
+    // Nothing to do
+}
+
+// omx cmd queue constructor
+omx_g711_aenc::omx_cmd_queue::omx_cmd_queue(): m_read(0),m_write(0),m_size(0)
+{
+    memset(m_q,      0,sizeof(omx_event)*OMX_CORE_CONTROL_CMDQ_SIZE);
+}
+
+// omx cmd queue insert
+bool omx_g711_aenc::omx_cmd_queue::insert_entry(unsigned long p1,
+                                                unsigned long p2,
+                                                unsigned char id)
+{
+    bool ret = true;
+    if (m_size < OMX_CORE_CONTROL_CMDQ_SIZE)
+    {
+        m_q[m_write].id       = id;
+        m_q[m_write].param1   = p1;
+        m_q[m_write].param2   = p2;
+        m_write++;
+        m_size ++;
+        if (m_write >= OMX_CORE_CONTROL_CMDQ_SIZE)
+        {
+            m_write = 0;
+        }
+    } else
+    {
+        ret = false;
+        OMX_LOGE("ERROR!!! Command Queue Full");
+    }
+    return ret;
+}
+
+bool omx_g711_aenc::omx_cmd_queue::pop_entry(unsigned long *p1,
+                                        unsigned long *p2, unsigned char *id)
+{
+    bool ret = true;
+    if (m_size > 0)
+    {
+        *id = m_q[m_read].id;
+        *p1 = m_q[m_read].param1;
+        *p2 = m_q[m_read].param2;
+        // Move the read pointer ahead
+        ++m_read;
+        --m_size;
+        if (m_read >= OMX_CORE_CONTROL_CMDQ_SIZE)
+        {
+            m_read = 0;
+
+        }
+    } else
+    {
+        ret = false;
+        OMX_LOGE("ERROR Delete!!! Command Queue Empty");
+    }
+    return ret;
+}
+
+// factory function executed by the core to create instances
+void *get_omx_component_factory_fn(void)
+{
+    return(new omx_g711_aenc);
+}
+bool omx_g711_aenc::omx_cmd_queue::get_msg_id(unsigned char *id)
+{
+   if(m_size > 0)
+   {
+       *id = m_q[m_read].id;
+       OMX_LOGV("get_msg_id=%d\n",*id);
+   }
+   else{
+       return false;
+   }
+   return true;
+}
+/*=============================================================================
+FUNCTION:
+  wait_for_event
+
+DESCRIPTION:
+  waits for a particular event
+
+INPUT/OUTPUT PARAMETERS:
+  None
+
+RETURN VALUE:
+  None
+
+Dependency:
+  None
+
+SIDE EFFECTS:
+   None
+=============================================================================*/
+void omx_g711_aenc::wait_for_event()
+{
+    int               rc;
+    struct timespec   ts;
+    pthread_mutex_lock(&m_event_lock);
+    while (0 == m_is_event_done)
+    {
+       clock_gettime(CLOCK_REALTIME, &ts);
+       ts.tv_sec += (SLEEP_MS/1000);
+       ts.tv_nsec += ((SLEEP_MS%1000) * 1000000);
+       rc = pthread_cond_timedwait(&cond, &m_event_lock, &ts);
+       if (rc == ETIMEDOUT && !m_is_event_done) {
+            OMX_LOGV("Timed out waiting for flush");
+            if (ioctl(m_drv_fd, AUDIO_FLUSH, 0) < 0)
+            {
+                OMX_LOGE("Flush:Input port, ioctl failed error: rc:%d, %s, no:%d \n",
+                        rc, strerror(errno), errno);
+                if (m_cb.EventHandler)
+                    m_cb.EventHandler(&this->m_cmp, this->m_app_data,
+                            OMX_EventError, OMX_ErrorInvalidState,
+                            OMX_COMPONENT_GENERATE_EVENT, NULL);
+                break;
+            }
+       }
+    }
+    m_is_event_done = 0;
+    pthread_mutex_unlock(&m_event_lock);
+}
+
+/*=============================================================================
+FUNCTION:
+  event_complete
+
+DESCRIPTION:
+  informs about the occurance of an event
+
+INPUT/OUTPUT PARAMETERS:
+  None
+
+RETURN VALUE:
+  None
+
+Dependency:
+  None
+
+SIDE EFFECTS:
+   None
+=============================================================================*/
+void omx_g711_aenc::event_complete()
+{
+    pthread_mutex_lock(&m_event_lock);
+    if (0 == m_is_event_done)
+    {
+        m_is_event_done = 1;
+        pthread_cond_signal(&cond);
+    }
+    pthread_mutex_unlock(&m_event_lock);
+}
+
+// All this non-sense because of a single g711 object
+void omx_g711_aenc::in_th_goto_sleep()
+{
+    pthread_mutex_lock(&m_in_th_lock);
+    while (0 == m_is_in_th_sleep)
+    {
+        pthread_cond_wait(&in_cond, &m_in_th_lock);
+    }
+    m_is_in_th_sleep = 0;
+    pthread_mutex_unlock(&m_in_th_lock);
+}
+
+void omx_g711_aenc::in_th_wakeup()
+{
+    pthread_mutex_lock(&m_in_th_lock);
+    if (0 == m_is_in_th_sleep)
+    {
+        m_is_in_th_sleep = 1;
+        pthread_cond_signal(&in_cond);
+    }
+    pthread_mutex_unlock(&m_in_th_lock);
+}
+
+void omx_g711_aenc::out_th_goto_sleep()
+{
+
+    pthread_mutex_lock(&m_out_th_lock);
+    while (0 == m_is_out_th_sleep)
+    {
+        pthread_cond_wait(&out_cond, &m_out_th_lock);
+    }
+    m_is_out_th_sleep = 0;
+    pthread_mutex_unlock(&m_out_th_lock);
+}
+
+void omx_g711_aenc::out_th_wakeup()
+{
+    pthread_mutex_lock(&m_out_th_lock);
+    if (0 == m_is_out_th_sleep)
+    {
+        m_is_out_th_sleep = 1;
+        pthread_cond_signal(&out_cond);
+    }
+    pthread_mutex_unlock(&m_out_th_lock);
+}
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::omx_g711_aenc
+
+DESCRIPTION
+  Constructor
+
+PARAMETERS
+  None
+
+RETURN VALUE
+  None.
+========================================================================== */
+omx_g711_aenc::omx_g711_aenc(): m_tmp_meta_buf(NULL),
+        m_tmp_out_meta_buf(NULL),
+        m_flush_cnt(255),
+        m_comp_deinit(0),
+        m_volume(25),
+        m_app_data(NULL),
+        nNumInputBuf(0),
+        nNumOutputBuf(0),
+        m_drv_fd(-1),
+        bFlushinprogress(0),
+        is_in_th_sleep(false),
+        is_out_th_sleep(false),
+        m_flags(0),
+        nTimestamp(0),
+        pcm_input(0),
+        m_inp_act_buf_count (OMX_CORE_NUM_INPUT_BUFFERS),
+        m_out_act_buf_count (OMX_CORE_NUM_OUTPUT_BUFFERS),
+        m_inp_current_buf_count(0),
+        m_out_current_buf_count(0),
+        output_buffer_size((OMX_U32)OMX_G711_OUTPUT_BUFFER_SIZE),
+        input_buffer_size(OMX_CORE_INPUT_BUFFER_SIZE),
+        m_session_id(0),
+        is_mlaw(false),
+        m_inp_bEnabled(OMX_TRUE),
+        m_out_bEnabled(OMX_TRUE),
+        m_inp_bPopulated(OMX_FALSE),
+        m_out_bPopulated(OMX_FALSE),
+        m_is_event_done(0),
+        m_state(OMX_StateInvalid),
+        m_ipc_to_in_th(NULL),
+        m_ipc_to_out_th(NULL),
+        m_ipc_to_cmd_th(NULL),
+        m_ipc_to_event_th(NULL)
+{
+    int cond_ret = 0;
+    component_Role.nSize = 0;
+    memset(&m_cmp, 0, sizeof(m_cmp));
+    memset(&m_cb, 0, sizeof(m_cb));
+    memset(&m_g711_pb_stats, 0, sizeof(m_g711_pb_stats));
+    memset(&m_g711_param, 0, sizeof(m_g711_param));
+    memset(&m_pcm_param, 0, sizeof(m_pcm_param));
+    memset(&m_buffer_supplier, 0, sizeof(m_buffer_supplier));
+    memset(&m_priority_mgm, 0, sizeof(m_priority_mgm));
+
+    pthread_mutexattr_init(&m_lock_attr);
+    pthread_mutex_init(&m_lock, &m_lock_attr);
+    pthread_mutexattr_init(&m_commandlock_attr);
+    pthread_mutex_init(&m_commandlock, &m_commandlock_attr);
+
+    pthread_mutexattr_init(&m_outputlock_attr);
+    pthread_mutex_init(&m_outputlock, &m_outputlock_attr);
+
+    pthread_mutexattr_init(&m_state_attr);
+    pthread_mutex_init(&m_state_lock, &m_state_attr);
+
+    pthread_mutexattr_init(&m_event_attr);
+    pthread_mutex_init(&m_event_lock, &m_event_attr);
+
+    pthread_mutexattr_init(&m_flush_attr);
+    pthread_mutex_init(&m_flush_lock, &m_flush_attr);
+
+    pthread_mutexattr_init(&m_event_attr);
+    pthread_mutex_init(&m_event_lock, &m_event_attr);
+
+    pthread_mutexattr_init(&m_in_th_attr);
+    pthread_mutex_init(&m_in_th_lock, &m_in_th_attr);
+
+    pthread_mutexattr_init(&m_out_th_attr);
+    pthread_mutex_init(&m_out_th_lock, &m_out_th_attr);
+
+    pthread_mutexattr_init(&m_in_th_attr_1);
+    pthread_mutex_init(&m_in_th_lock_1, &m_in_th_attr_1);
+
+    pthread_mutexattr_init(&m_out_th_attr_1);
+    pthread_mutex_init(&m_out_th_lock_1, &m_out_th_attr_1);
+
+    pthread_mutexattr_init(&out_buf_count_lock_attr);
+    pthread_mutex_init(&out_buf_count_lock, &out_buf_count_lock_attr);
+
+    pthread_mutexattr_init(&in_buf_count_lock_attr);
+    pthread_mutex_init(&in_buf_count_lock, &in_buf_count_lock_attr);
+    updateLogLevel();
+
+    if ((cond_ret = pthread_cond_init (&cond, NULL)) != 0)
+    {
+       OMX_LOGE("pthread_cond_init returns non zero for cond\n");
+       if (cond_ret == EAGAIN)
+         OMX_LOGE("The system lacked necessary \
+                resources(other than mem)\n");
+       else if (cond_ret == ENOMEM)
+          OMX_LOGE("Insufficient memory to initialise \
+                condition variable\n");
+    }
+    if ((cond_ret = pthread_cond_init (&in_cond, NULL)) != 0)
+    {
+       OMX_LOGE("pthread_cond_init returns non zero for in_cond\n");
+       if (cond_ret == EAGAIN)
+         OMX_LOGE("The system lacked necessary \
+                resources(other than mem)\n");
+       else if (cond_ret == ENOMEM)
+          OMX_LOGE("Insufficient memory to initialise \
+                condition variable\n");
+    }
+    if ((cond_ret = pthread_cond_init (&out_cond, NULL)) != 0)
+    {
+       OMX_LOGE("pthread_cond_init returns non zero for out_cond\n");
+       if (cond_ret == EAGAIN)
+         OMX_LOGE("The system lacked necessary \
+                resources(other than mem)\n");
+       else if (cond_ret == ENOMEM)
+          OMX_LOGE("Insufficient memory to initialise \
+                condition variable\n");
+    }
+
+    sem_init(&sem_read_msg,0, 0);
+    sem_init(&sem_write_msg,0, 0);
+    sem_init(&sem_States,0, 0);
+    return;
+}
+
+
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::~omx_g711_aenc
+
+DESCRIPTION
+  Destructor
+
+PARAMETERS
+  None
+
+RETURN VALUE
+  None.
+========================================================================== */
+omx_g711_aenc::~omx_g711_aenc()
+{
+    OMX_LOGE("G711 Object getting destroyed comp-deinit=%d\n",
+            m_comp_deinit);
+    if ( !m_comp_deinit )
+    {
+        deinit_encoder();
+    }
+    pthread_mutexattr_destroy(&m_lock_attr);
+    pthread_mutex_destroy(&m_lock);
+
+    pthread_mutexattr_destroy(&m_commandlock_attr);
+    pthread_mutex_destroy(&m_commandlock);
+
+    pthread_mutexattr_destroy(&m_outputlock_attr);
+    pthread_mutex_destroy(&m_outputlock);
+
+    pthread_mutexattr_destroy(&m_state_attr);
+    pthread_mutex_destroy(&m_state_lock);
+
+    pthread_mutexattr_destroy(&m_event_attr);
+    pthread_mutex_destroy(&m_event_lock);
+
+    pthread_mutexattr_destroy(&m_flush_attr);
+    pthread_mutex_destroy(&m_flush_lock);
+
+    pthread_mutexattr_destroy(&m_in_th_attr);
+    pthread_mutex_destroy(&m_in_th_lock);
+
+    pthread_mutexattr_destroy(&m_out_th_attr);
+    pthread_mutex_destroy(&m_out_th_lock);
+
+    pthread_mutexattr_destroy(&out_buf_count_lock_attr);
+    pthread_mutex_destroy(&out_buf_count_lock);
+
+    pthread_mutexattr_destroy(&in_buf_count_lock_attr);
+    pthread_mutex_destroy(&in_buf_count_lock);
+
+    pthread_mutexattr_destroy(&m_in_th_attr_1);
+    pthread_mutex_destroy(&m_in_th_lock_1);
+
+    pthread_mutexattr_destroy(&m_out_th_attr_1);
+    pthread_mutex_destroy(&m_out_th_lock_1);
+    pthread_cond_destroy(&cond);
+    pthread_cond_destroy(&in_cond);
+    pthread_cond_destroy(&out_cond);
+    sem_destroy (&sem_read_msg);
+    sem_destroy (&sem_write_msg);
+    sem_destroy (&sem_States);
+    OMX_LOGE("OMX G711 component destroyed\n");
+    return;
+}
+
+/**
+  @brief memory function for sending EmptyBufferDone event
+   back to IL client
+
+  @param bufHdr OMX buffer header to be passed back to IL client
+  @return none
+ */
+void omx_g711_aenc::buffer_done_cb(OMX_BUFFERHEADERTYPE *bufHdr)
+{
+    if (m_cb.EmptyBufferDone)
+    {
+        PrintFrameHdr(OMX_COMPONENT_GENERATE_BUFFER_DONE,bufHdr);
+        bufHdr->nFilledLen = 0;
+
+        m_cb.EmptyBufferDone(&m_cmp, m_app_data, bufHdr);
+        pthread_mutex_lock(&in_buf_count_lock);
+        m_g711_pb_stats.ebd_cnt++;
+        nNumInputBuf--;
+        DEBUG_DETAIL("EBD CB:: in_buf_len=%d nNumInputBuf=%d\n ebd_cnt=%d",\
+                     m_g711_pb_stats.tot_in_buf_len,
+                     nNumInputBuf, m_g711_pb_stats.ebd_cnt);
+        pthread_mutex_unlock(&in_buf_count_lock);
+    }
+
+    return;
+}
+
+/*=============================================================================
+FUNCTION:
+  flush_ack
+
+DESCRIPTION:
+
+
+INPUT/OUTPUT PARAMETERS:
+  None
+
+RETURN VALUE:
+  None
+
+Dependency:
+  None
+
+SIDE EFFECTS:
+  None
+=============================================================================*/
+void omx_g711_aenc::flush_ack()
+{
+    // Decrement the FLUSH ACK count and notify the waiting recepients
+    pthread_mutex_lock(&m_flush_lock);
+    --m_flush_cnt;
+    if (0 == m_flush_cnt)
+    {
+        event_complete();
+    }
+    OMX_LOGV("Rxed FLUSH ACK cnt=%d\n",m_flush_cnt);
+    pthread_mutex_unlock(&m_flush_lock);
+}
+void omx_g711_aenc::frame_done_cb(OMX_BUFFERHEADERTYPE *bufHdr)
+{
+    if (m_cb.FillBufferDone)
+    {
+        PrintFrameHdr(OMX_COMPONENT_GENERATE_FRAME_DONE,bufHdr);
+        m_g711_pb_stats.fbd_cnt++;
+        pthread_mutex_lock(&out_buf_count_lock);
+        nNumOutputBuf--;
+        OMX_LOGV("FBD CB:: nNumOutputBuf=%d out_buf_len=%u fbd_cnt=%u\n",\
+                    nNumOutputBuf,
+                    m_g711_pb_stats.tot_out_buf_len,
+                    m_g711_pb_stats.fbd_cnt);
+        m_g711_pb_stats.tot_out_buf_len += bufHdr->nFilledLen;
+        m_g711_pb_stats.tot_pb_time  = bufHdr->nTimeStamp;
+        OMX_LOGV("FBD:in_buf_len=%u out_buf_len=%u\n",
+                    m_g711_pb_stats.tot_in_buf_len,
+                    m_g711_pb_stats.tot_out_buf_len);
+
+        pthread_mutex_unlock(&out_buf_count_lock);
+        m_cb.FillBufferDone(&m_cmp, m_app_data, bufHdr);
+    }
+    return;
+}
+
+/*=============================================================================
+FUNCTION:
+  process_out_port_msg
+
+DESCRIPTION:
+  Function for handling all commands from IL client
+IL client commands are processed and callbacks are generated through
+this routine  Audio Command Server provides the thread context for this routine
+
+INPUT/OUTPUT PARAMETERS:
+  [INOUT] client_data
+  [IN] id
+
+RETURN VALUE:
+  None
+
+Dependency:
+  None
+
+SIDE EFFECTS:
+  None
+=============================================================================*/
+void omx_g711_aenc::process_out_port_msg(void *client_data, unsigned char id)
+{
+    unsigned long p1 = 0;                            // Parameter - 1
+    unsigned long p2 = 0;                            // Parameter - 2
+    unsigned char ident = 0;
+    unsigned      qsize     = 0;                 // qsize
+    unsigned      tot_qsize = 0;
+    omx_g711_aenc  *pThis    = (omx_g711_aenc *) client_data;
+    OMX_STATETYPE state;
+
+loopback_out:
+    pthread_mutex_lock(&pThis->m_state_lock);
+    pThis->get_state(&pThis->m_cmp, &state);
+    pthread_mutex_unlock(&pThis->m_state_lock);
+    if ( state == OMX_StateLoaded )
+    {
+        OMX_LOGV(" OUT: IN LOADED STATE RETURN\n");
+        return;
+    }
+    pthread_mutex_lock(&pThis->m_outputlock);
+
+    qsize = pThis->m_output_ctrl_cmd_q.m_size;
+    tot_qsize = pThis->m_output_ctrl_cmd_q.m_size;
+    tot_qsize += pThis->m_output_ctrl_fbd_q.m_size;
+    tot_qsize += pThis->m_output_q.m_size;
+
+    if ( 0 == tot_qsize )
+    {
+        pthread_mutex_unlock(&pThis->m_outputlock);
+        DEBUG_DETAIL("OUT-->BREAK FROM LOOP...%d\n",tot_qsize);
+        return;
+    }
+    if ( (state != OMX_StateExecuting) && !qsize )
+    {
+        pthread_mutex_unlock(&pThis->m_outputlock);
+        pthread_mutex_lock(&pThis->m_state_lock);
+        pThis->get_state(&pThis->m_cmp, &state);
+        pthread_mutex_unlock(&pThis->m_state_lock);
+        if ( state == OMX_StateLoaded )
+            return;
+
+        DEBUG_DETAIL("OUT:1.SLEEPING OUT THREAD\n");
+        pthread_mutex_lock(&pThis->m_out_th_lock_1);
+        pThis->is_out_th_sleep = true;
+        pthread_mutex_unlock(&pThis->m_out_th_lock_1);
+        pThis->out_th_goto_sleep();
+
+        /* Get the updated state */
+        pthread_mutex_lock(&pThis->m_state_lock);
+        pThis->get_state(&pThis->m_cmp, &state);
+        pthread_mutex_unlock(&pThis->m_state_lock);
+    }
+
+    if ( ((!pThis->m_output_ctrl_cmd_q.m_size) && !pThis->m_out_bEnabled) )
+    {
+        // case where no port reconfig and nothing in the flush q
+        DEBUG_DETAIL("No flush/port reconfig qsize=%d tot_qsize=%d",\
+            qsize,tot_qsize);
+        pthread_mutex_unlock(&pThis->m_outputlock);
+        pthread_mutex_lock(&pThis->m_state_lock);
+        pThis->get_state(&pThis->m_cmp, &state);
+        pthread_mutex_unlock(&pThis->m_state_lock);
+        if ( state == OMX_StateLoaded )
+            return;
+
+        if(pThis->m_output_ctrl_cmd_q.m_size || !(pThis->bFlushinprogress))
+        {
+            OMX_LOGV("OUT:2. SLEEPING OUT THREAD \n");
+            pthread_mutex_lock(&pThis->m_out_th_lock_1);
+            pThis->is_out_th_sleep = true;
+            pthread_mutex_unlock(&pThis->m_out_th_lock_1);
+            pThis->out_th_goto_sleep();
+        }
+        /* Get the updated state */
+        pthread_mutex_lock(&pThis->m_state_lock);
+        pThis->get_state(&pThis->m_cmp, &state);
+        pthread_mutex_unlock(&pThis->m_state_lock);
+    }
+    qsize = pThis->m_output_ctrl_cmd_q.m_size;
+    tot_qsize = pThis->m_output_ctrl_cmd_q.m_size;
+    tot_qsize += pThis->m_output_ctrl_fbd_q.m_size;
+    tot_qsize += pThis->m_output_q.m_size;
+    pthread_mutex_lock(&pThis->m_state_lock);
+    pThis->get_state(&pThis->m_cmp, &state);
+    pthread_mutex_unlock(&pThis->m_state_lock);
+    DEBUG_DETAIL("OUT-->QSIZE-flush=%d,fbd=%d QSIZE=%d state=%d\n",\
+        pThis->m_output_ctrl_cmd_q.m_size,
+        pThis->m_output_ctrl_fbd_q.m_size,
+        pThis->m_output_q.m_size,state);
+
+
+    if (qsize)
+    {
+        // process FLUSH message
+        pThis->m_output_ctrl_cmd_q.pop_entry(&p1,&p2,&ident);
+    } else if ( (qsize = pThis->m_output_ctrl_fbd_q.m_size) &&
+        (pThis->m_out_bEnabled) && (state == OMX_StateExecuting) )
+    {
+        // then process EBD's
+        pThis->m_output_ctrl_fbd_q.pop_entry(&p1,&p2,&ident);
+    } else if ( (qsize = pThis->m_output_q.m_size) &&
+        (pThis->m_out_bEnabled) && (state == OMX_StateExecuting) )
+    {
+        // if no FLUSH and FBD's then process FTB's
+        pThis->m_output_q.pop_entry(&p1,&p2,&ident);
+    } else if ( state == OMX_StateLoaded )
+    {
+        pthread_mutex_unlock(&pThis->m_outputlock);
+        OMX_LOGV("IN: ***in OMX_StateLoaded so exiting\n");
+        return ;
+    } else
+    {
+        qsize = 0;
+        OMX_LOGV("OUT--> Empty Queue state=%d %d %d %d\n",state,
+                     pThis->m_output_ctrl_cmd_q.m_size,
+                     pThis->m_output_ctrl_fbd_q.m_size,
+                     pThis->m_output_q.m_size);
+
+        if(state == OMX_StatePause)
+        {
+            DEBUG_DETAIL("OUT: SLEEPING AGAIN OUT THREAD\n");
+            pthread_mutex_lock(&pThis->m_out_th_lock_1);
+            pThis->is_out_th_sleep = true;
+            pthread_mutex_unlock(&pThis->m_out_th_lock_1);
+            pthread_mutex_unlock(&pThis->m_outputlock);
+            pThis->out_th_goto_sleep();
+            goto loopback_out;
+        }
+    }
+    pthread_mutex_unlock(&pThis->m_outputlock);
+
+    if ( qsize > 0 )
+    {
+        id = ident;
+        ident = 0;
+        DEBUG_DETAIL("OUT->state[%d]ident[%d]flushq[%d]fbd[%d]dataq[%d]\n",\
+            pThis->m_state,
+            ident,
+            pThis->m_output_ctrl_cmd_q.m_size,
+            pThis->m_output_ctrl_fbd_q.m_size,
+            pThis->m_output_q.m_size);
+
+        if ( OMX_COMPONENT_GENERATE_FRAME_DONE == id )
+        {
+            pThis->frame_done_cb((OMX_BUFFERHEADERTYPE *)p2);
+        } else if ( OMX_COMPONENT_GENERATE_FTB == id )
+        {
+            pThis->fill_this_buffer_proxy((OMX_HANDLETYPE)p1,
+                (OMX_BUFFERHEADERTYPE *)p2);
+        } else if ( OMX_COMPONENT_GENERATE_EOS == id )
+        {
+            pThis->m_cb.EventHandler(&pThis->m_cmp,
+                pThis->m_app_data,
+                OMX_EventBufferFlag,
+                1, 1, NULL );
+
+        }
+        else if(id == OMX_COMPONENT_RESUME)
+        {
+             OMX_LOGV("RESUMED...\n");
+        }
+        else if(id == OMX_COMPONENT_GENERATE_COMMAND)
+        {
+            // Execute FLUSH command
+            if ( OMX_CommandFlush == p1 )
+            {
+                DEBUG_DETAIL("Executing FLUSH command on Output port\n");
+                pThis->execute_output_omx_flush();
+            } else
+            {
+                DEBUG_DETAIL("Invalid command[%lu]\n",p1);
+            }
+        } else
+        {
+            OMX_LOGE("ERROR:OUT-->Invalid Id[%d]\n",id);
+        }
+    } else
+    {
+        DEBUG_DETAIL("ERROR: OUT--> Empty OUTPUTQ\n");
+    }
+
+    return;
+}
+
+/*=============================================================================
+FUNCTION:
+  process_command_msg
+
+DESCRIPTION:
+
+
+INPUT/OUTPUT PARAMETERS:
+  [INOUT] client_data
+  [IN] id
+
+RETURN VALUE:
+  None
+
+Dependency:
+  None
+
+SIDE EFFECTS:
+  None
+=============================================================================*/
+void omx_g711_aenc::process_command_msg(void *client_data, unsigned char id)
+{
+    unsigned long p1 = 0;                             // Parameter - 1
+    unsigned long p2 = 0;                             // Parameter - 2
+    unsigned char ident = 0;
+    unsigned     qsize  = 0;
+    omx_g711_aenc *pThis = (omx_g711_aenc*)client_data;
+    pthread_mutex_lock(&pThis->m_commandlock);
+
+    qsize = pThis->m_command_q.m_size;
+    DEBUG_DETAIL("CMD-->QSIZE=%d state=%d\n",pThis->m_command_q.m_size,
+                 pThis->m_state);
+
+    if (!qsize)
+    {
+        DEBUG_DETAIL("CMD-->BREAKING FROM LOOP\n");
+        pthread_mutex_unlock(&pThis->m_commandlock);
+        return;
+    } else
+    {
+        pThis->m_command_q.pop_entry(&p1,&p2,&ident);
+    }
+    pthread_mutex_unlock(&pThis->m_commandlock);
+
+    id = ident;
+    DEBUG_DETAIL("CMD->state[%d]id[%d]cmdq[%d]n",\
+                 pThis->m_state,ident, \
+                 pThis->m_command_q.m_size);
+
+    if (OMX_COMPONENT_GENERATE_EVENT == id)
+    {
+        if (pThis->m_cb.EventHandler)
+        {
+            if (OMX_CommandStateSet == p1)
+            {
+                pthread_mutex_lock(&pThis->m_state_lock);
+                pThis->m_state = (OMX_STATETYPE) p2;
+                pthread_mutex_unlock(&pThis->m_state_lock);
+                OMX_LOGV("CMD:Process->state set to %d \n", \
+                            pThis->m_state);
+
+                if (pThis->m_state == OMX_StateExecuting ||
+                    pThis->m_state == OMX_StateLoaded)
+                {
+
+                    pthread_mutex_lock(&pThis->m_in_th_lock_1);
+                    if (pThis->is_in_th_sleep)
+                    {
+                        pThis->is_in_th_sleep = false;
+                        DEBUG_DETAIL("CMD:WAKING UP IN THREADS\n");
+                        pThis->in_th_wakeup();
+                    }
+                    pthread_mutex_unlock(&pThis->m_in_th_lock_1);
+
+                    pthread_mutex_lock(&pThis->m_out_th_lock_1);
+                    if (pThis->is_out_th_sleep)
+                    {
+                        DEBUG_DETAIL("CMD:WAKING UP OUT THREADS\n");
+                        pThis->is_out_th_sleep = false;
+                        pThis->out_th_wakeup();
+                    }
+                    pthread_mutex_unlock(&pThis->m_out_th_lock_1);
+                }
+            }
+            if (OMX_StateInvalid == pThis->m_state)
+            {
+                pThis->m_cb.EventHandler(&pThis->m_cmp,
+                                         pThis->m_app_data,
+                                         OMX_EventError,
+                                         OMX_ErrorInvalidState,
+                                         0, NULL );
+            } else if ((signed)p2 == OMX_ErrorPortUnpopulated)
+            {
+                pThis->m_cb.EventHandler(&pThis->m_cmp,
+                                         pThis->m_app_data,
+                                         OMX_EventError,
+                                         (OMX_U32)p2,
+                                         0,
+                                         0 );
+            } else
+            {
+                pThis->m_cb.EventHandler(&pThis->m_cmp,
+                                         pThis->m_app_data,
+                                         OMX_EventCmdComplete,
+                                         (OMX_U32)p1, (OMX_U32)p2, NULL );
+            }
+        } else
+        {
+            OMX_LOGE("ERROR:CMD-->EventHandler NULL \n");
+        }
+    } else if (OMX_COMPONENT_GENERATE_COMMAND == id)
+    {
+        pThis->send_command_proxy(&pThis->m_cmp,
+                                  (OMX_COMMANDTYPE)p1,
+                                  (OMX_U32)p2,(OMX_PTR)NULL);
+    } else if (OMX_COMPONENT_PORTSETTINGS_CHANGED == id)
+    {
+        DEBUG_DETAIL("CMD-->RXED PORTSETTINGS_CHANGED");
+        pThis->m_cb.EventHandler(&pThis->m_cmp,
+                                 pThis->m_app_data,
+                                 OMX_EventPortSettingsChanged,
+                                 1, 1, NULL );
+    }
+    else
+    {
+       OMX_LOGE("CMD->state[%d]id[%d]\n",pThis->m_state,ident);
+    }
+    return;
+}
+
+/*=============================================================================
+FUNCTION:
+  process_in_port_msg
+
+DESCRIPTION:
+
+
+INPUT/OUTPUT PARAMETERS:
+  [INOUT] client_data
+  [IN] id
+
+RETURN VALUE:
+  None
+
+Dependency:
+  None
+
+SIDE EFFECTS:
+  None
+=============================================================================*/
+void omx_g711_aenc::process_in_port_msg(void *client_data, unsigned char id)
+{
+    unsigned long p1 = 0;                            // Parameter - 1
+    unsigned long p2 = 0;                            // Parameter - 2
+    unsigned char ident = 0;
+    unsigned      qsize     = 0;
+    unsigned      tot_qsize = 0;
+    omx_g711_aenc  *pThis    = (omx_g711_aenc *) client_data;
+    OMX_STATETYPE state;
+
+    if (!pThis)
+    {
+        OMX_LOGE("ERROR:IN--> Invalid Obj \n");
+        return;
+    }
+loopback_in:
+    pthread_mutex_lock(&pThis->m_state_lock);
+    pThis->get_state(&pThis->m_cmp, &state);
+    pthread_mutex_unlock(&pThis->m_state_lock);
+    if ( state == OMX_StateLoaded )
+    {
+        OMX_LOGV(" IN: IN LOADED STATE RETURN\n");
+        return;
+    }
+    // Protect the shared queue data structure
+    pthread_mutex_lock(&pThis->m_lock);
+
+    qsize = pThis->m_input_ctrl_cmd_q.m_size;
+    tot_qsize = qsize;
+    tot_qsize += pThis->m_input_ctrl_ebd_q.m_size;
+    tot_qsize += pThis->m_input_q.m_size;
+
+    if ( 0 == tot_qsize )
+    {
+        DEBUG_DETAIL("IN-->BREAKING FROM IN LOOP");
+        pthread_mutex_unlock(&pThis->m_lock);
+        return;
+    }
+
+    if ( (state != OMX_StateExecuting) && ! (pThis->m_input_ctrl_cmd_q.m_size))
+    {
+        pthread_mutex_unlock(&pThis->m_lock);
+        DEBUG_DETAIL("SLEEPING IN THREAD\n");
+        pthread_mutex_lock(&pThis->m_in_th_lock_1);
+        pThis->is_in_th_sleep = true;
+        pthread_mutex_unlock(&pThis->m_in_th_lock_1);
+        pThis->in_th_goto_sleep();
+
+        /* Get the updated state */
+        pthread_mutex_lock(&pThis->m_state_lock);
+        pThis->get_state(&pThis->m_cmp, &state);
+        pthread_mutex_unlock(&pThis->m_state_lock);
+    }
+    else if ((state == OMX_StatePause))
+    {
+        if(!(pThis->m_input_ctrl_cmd_q.m_size))
+        {
+           pthread_mutex_unlock(&pThis->m_lock);
+
+           DEBUG_DETAIL("IN: SLEEPING IN THREAD\n");
+           pthread_mutex_lock(&pThis->m_in_th_lock_1);
+           pThis->is_in_th_sleep = true;
+           pthread_mutex_unlock(&pThis->m_in_th_lock_1);
+           pThis->in_th_goto_sleep();
+
+           pthread_mutex_lock(&pThis->m_state_lock);
+           pThis->get_state(&pThis->m_cmp, &state);
+           pthread_mutex_unlock(&pThis->m_state_lock);
+        }
+    }
+
+    qsize = pThis->m_input_ctrl_cmd_q.m_size;
+    tot_qsize = qsize;
+    tot_qsize += pThis->m_input_ctrl_ebd_q.m_size;
+    tot_qsize += pThis->m_input_q.m_size;
+
+    DEBUG_DETAIL("Input-->QSIZE-flush=%d,ebd=%d QSIZE=%d state=%d\n",\
+        pThis->m_input_ctrl_cmd_q.m_size,
+        pThis->m_input_ctrl_ebd_q.m_size,
+        pThis->m_input_q.m_size, state);
+
+
+    if ( qsize )
+    {
+        // process FLUSH message
+        pThis->m_input_ctrl_cmd_q.pop_entry(&p1,&p2,&ident);
+    } else if ( (qsize = pThis->m_input_ctrl_ebd_q.m_size) &&
+        (state == OMX_StateExecuting) )
+    {
+        // then process EBD's
+        pThis->m_input_ctrl_ebd_q.pop_entry(&p1,&p2,&ident);
+    } else if ((qsize = pThis->m_input_q.m_size) &&
+               (state == OMX_StateExecuting))
+    {
+        // if no FLUSH and EBD's then process ETB's
+        pThis->m_input_q.pop_entry(&p1, &p2, &ident);
+    } else if ( state == OMX_StateLoaded )
+    {
+        pthread_mutex_unlock(&pThis->m_lock);
+        OMX_LOGV("IN: ***in OMX_StateLoaded so exiting\n");
+        return ;
+    } else
+    {
+        qsize = 0;
+        OMX_LOGV("IN-->state[%d]cmdq[%d]ebdq[%d]in[%d]\n",\
+                             state,pThis->m_input_ctrl_cmd_q.m_size,
+                             pThis->m_input_ctrl_ebd_q.m_size,
+                             pThis->m_input_q.m_size);
+
+        if(state == OMX_StatePause)
+        {
+            DEBUG_DETAIL("IN: SLEEPING AGAIN IN THREAD\n");
+            pthread_mutex_lock(&pThis->m_in_th_lock_1);
+            pThis->is_in_th_sleep = true;
+            pthread_mutex_unlock(&pThis->m_in_th_lock_1);
+            pthread_mutex_unlock(&pThis->m_lock);
+            pThis->in_th_goto_sleep();
+            goto loopback_in;
+        }
+    }
+    pthread_mutex_unlock(&pThis->m_lock);
+
+    if ( qsize > 0 )
+    {
+        id = ident;
+        DEBUG_DETAIL("Input->state[%d]id[%d]flushq[%d]ebdq[%d]dataq[%d]\n",\
+            pThis->m_state,
+            ident,
+            pThis->m_input_ctrl_cmd_q.m_size,
+            pThis->m_input_ctrl_ebd_q.m_size,
+            pThis->m_input_q.m_size);
+        if ( OMX_COMPONENT_GENERATE_BUFFER_DONE == id )
+        {
+            pThis->buffer_done_cb((OMX_BUFFERHEADERTYPE *)p2);
+        }
+        else if(id == OMX_COMPONENT_GENERATE_EOS)
+        {
+            pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
+                OMX_EventBufferFlag, 0, 1, NULL );
+        } else if ( OMX_COMPONENT_GENERATE_ETB == id )
+        {
+            pThis->empty_this_buffer_proxy((OMX_HANDLETYPE)p1,
+                (OMX_BUFFERHEADERTYPE *)p2);
+        } else if ( OMX_COMPONENT_GENERATE_COMMAND == id )
+        {
+            // Execute FLUSH command
+            if ( OMX_CommandFlush == p1 )
+            {
+                DEBUG_DETAIL(" Executing FLUSH command on Input port\n");
+                pThis->execute_input_omx_flush();
+            } else
+            {
+                DEBUG_DETAIL("Invalid command[%lu]\n",p1);
+            }
+        }
+        else
+        {
+            OMX_LOGE("ERROR:IN-->Invalid Id[%d]\n",id);
+        }
+    } else
+    {
+        DEBUG_DETAIL("ERROR:IN-->Empty INPUT Q\n");
+    }
+    return;
+}
+
+/**
+ @brief member function for performing component initialization
+
+ @param role C string mandating role of this component
+ @return Error status
+ */
+OMX_ERRORTYPE omx_g711_aenc::component_init(OMX_STRING role)
+{
+
+    OMX_ERRORTYPE eRet = OMX_ErrorNone;
+    m_state                   = OMX_StateLoaded;
+
+    /* DSP does not give information about the bitstream
+    randomly assign the value right now. Query will result in
+    incorrect param */
+    memset(&m_g711_param, 0, sizeof(m_g711_param));
+    m_g711_param.nSize = (OMX_U32)sizeof(m_g711_param);
+    m_g711_param.nChannels = OMX_G711_DEFAULT_CH_CFG;
+    m_g711_param.nSamplingRate = OMX_G711_DEFAULT_SF;
+    m_volume = OMX_G711_DEFAULT_VOL; /* Close to unity gain */
+    memset(&m_g711_pb_stats,0,sizeof(G711_PB_STATS));
+    memset(&m_pcm_param, 0, sizeof(m_pcm_param));
+    m_pcm_param.nSize = (OMX_U32)sizeof(m_pcm_param);
+    m_pcm_param.nChannels = OMX_G711_DEFAULT_CH_CFG;
+    m_pcm_param.nSamplingRate = OMX_G711_DEFAULT_SF;
+    nTimestamp = 0;
+
+
+    nNumInputBuf = 0;
+    nNumOutputBuf = 0;
+    m_ipc_to_in_th = NULL;  // Command server instance
+    m_ipc_to_out_th = NULL;  // Client server instance
+    m_ipc_to_cmd_th = NULL;  // command instance
+    m_is_out_th_sleep = 0;
+    m_is_in_th_sleep = 0;
+    is_out_th_sleep= false;
+
+    is_in_th_sleep=false;
+
+    memset(&m_priority_mgm, 0, sizeof(m_priority_mgm));
+    m_priority_mgm.nGroupID =0;
+    m_priority_mgm.nGroupPriority=0;
+
+    memset(&m_buffer_supplier, 0, sizeof(m_buffer_supplier));
+    m_buffer_supplier.nPortIndex=OMX_BufferSupplyUnspecified;
+
+    OMX_LOGE(" component init: role = %s\n",role);
+
+    OMX_LOGV(" component init: role = %s\n",role);
+    component_Role.nVersion.nVersion = OMX_SPEC_VERSION;
+    if (!strcmp(role,"OMX.qcom.audio.encoder.g711mlaw"))
+    {
+        pcm_input = 1;
+        component_Role.nSize = (OMX_U32)sizeof(role);
+        strlcpy((char *)component_Role.cRole, (const char*)role,
+                sizeof(component_Role.cRole));
+        OMX_LOGV("\ncomponent_init: Component %s LOADED \n", role);
+        is_mlaw = true;
+    } else if (!strcmp(role,"OMX.qcom.audio.encoder.tunneled.g711mlaw"))
+    {
+        pcm_input = 0;
+        component_Role.nSize = (OMX_U32)sizeof(role);
+        strlcpy((char *)component_Role.cRole, (const char*)role,
+                sizeof(component_Role.cRole));
+        OMX_LOGV("\ncomponent_init: Component %s LOADED \n", role);
+        is_mlaw = true;
+    } else if (!strcmp(role,"OMX.qcom.audio.encoder.g711alaw"))
+    {
+        pcm_input = 1;
+        component_Role.nSize = (OMX_U32)sizeof(role);
+        strlcpy((char *)component_Role.cRole, (const char*)role,
+                sizeof(component_Role.cRole));
+        OMX_LOGV("\ncomponent_init: Component %s LOADED \n", role);
+    } else if (!strcmp(role,"OMX.qcom.audio.encoder.tunneled.g711alaw"))
+    {
+        pcm_input = 0;
+        component_Role.nSize = (OMX_U32)sizeof(role);
+        strlcpy((char *)component_Role.cRole, (const char*)role,
+                sizeof(component_Role.cRole));
+        OMX_LOGV("\ncomponent_init: Component %s LOADED \n", role);
+    } else
+    {
+        component_Role.nSize = (OMX_U32)sizeof("\0");
+        strlcpy((char *)component_Role.cRole, (const char*)"\0",
+                sizeof(component_Role.cRole));
+        OMX_LOGV("\ncomponent_init: Component %s LOADED is invalid\n", role);
+    }
+    if(pcm_input)
+    {
+
+
+        m_tmp_meta_buf = (OMX_U8*) malloc(sizeof(OMX_U8) *
+                         (OMX_CORE_INPUT_BUFFER_SIZE + sizeof(META_IN)));
+
+        if (m_tmp_meta_buf == NULL){
+            OMX_LOGV("Mem alloc failed for in meta buf\n");
+                return OMX_ErrorInsufficientResources;
+            }
+    }
+    m_tmp_out_meta_buf =
+        (OMX_U8*)malloc(sizeof(OMX_U8)*OMX_G711_OUTPUT_BUFFER_SIZE);
+        if ( m_tmp_out_meta_buf == NULL ) {
+            OMX_LOGV("Mem alloc failed for out meta buf\n");
+            return OMX_ErrorInsufficientResources;
+        }
+
+    if(0 == pcm_input)
+    {
+        if (is_mlaw)
+        {
+            m_drv_fd = open("/dev/msm_g711mlaw_in",O_RDONLY);
+            OMX_LOGV("Driver msm_g711mlaw_in in Tunnel mode open\n");
+        }
+        else
+        {
+            m_drv_fd = open("/dev/msm_g711alaw_in",O_RDONLY);
+            OMX_LOGV("Driver msm_g711alaw_in in Tunnel mode open\n");
+        }
+    }
+    else
+    {
+        if (is_mlaw)
+        {
+            m_drv_fd = open("/dev/msm_g711mlaw_in",O_RDWR);
+            OMX_LOGV("Driver msm_g711mlaw_in in Non Tunnel mode open\n");
+        }
+        else
+        {
+            m_drv_fd = open("/dev/msm_g711alaw_in",O_RDWR);
+            OMX_LOGV("Driver msm_g711alaw_in in Non Tunnel mode open\n");
+        }
+    }
+    if (m_drv_fd < 0)
+    {
+        OMX_LOGE("Component_init Open Failed[%d] errno[%d]",\
+                m_drv_fd,errno);
+
+        return OMX_ErrorInsufficientResources;
+    }
+    if(ioctl(m_drv_fd, AUDIO_GET_SESSION_ID,&m_session_id) == -1)
+    {
+        OMX_LOGE("AUDIO_GET_SESSION_ID FAILED\n");
+    }
+    if(pcm_input)
+    {
+        if (!m_ipc_to_in_th)
+        {
+            m_ipc_to_in_th = omx_g711_thread_create(process_in_port_msg,
+                this, (char *)"INPUT_THREAD");
+            if (!m_ipc_to_in_th)
+            {
+                OMX_LOGE("ERROR!!! Failed to start \
+                    Input port thread\n");
+                return OMX_ErrorInsufficientResources;
+            }
+        }
+    }
+
+    if (!m_ipc_to_cmd_th)
+    {
+        m_ipc_to_cmd_th = omx_g711_thread_create(process_command_msg,
+            this, (char *)"CMD_THREAD");
+        if (!m_ipc_to_cmd_th)
+        {
+            OMX_LOGE("ERROR!!!Failed to start "
+                              "command message thread\n");
+            return OMX_ErrorInsufficientResources;
+        }
+    }
+
+        if (!m_ipc_to_out_th)
+        {
+            m_ipc_to_out_th = omx_g711_thread_create(process_out_port_msg,
+                this, (char *)"OUTPUT_THREAD");
+            if (!m_ipc_to_out_th)
+            {
+                OMX_LOGE("ERROR!!! Failed to start output "
+                                  "port thread\n");
+                return OMX_ErrorInsufficientResources;
+            }
+        }
+    return eRet;
+}
+
+/**
+
+ @brief member function to retrieve version of component
+
+
+
+ @param hComp handle to this component instance
+ @param componentName name of component
+ @param componentVersion  pointer to memory space which stores the
+       version number
+ @param specVersion pointer to memory sapce which stores version of
+        openMax specification
+ @param componentUUID
+ @return Error status
+ */
+OMX_ERRORTYPE  omx_g711_aenc::get_component_version
+(
+    OMX_IN OMX_HANDLETYPE               hComp,
+    OMX_OUT OMX_STRING          componentName,
+    OMX_OUT OMX_VERSIONTYPE* componentVersion,
+    OMX_OUT OMX_VERSIONTYPE*      specVersion,
+    OMX_OUT OMX_UUIDTYPE*       componentUUID)
+{
+    if((hComp == NULL) || (componentName == NULL) ||
+        (specVersion == NULL) || (componentUUID == NULL))
+    {
+        componentVersion = NULL;
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    if (m_state == OMX_StateInvalid)
+    {
+        OMX_LOGE("Get Comp Version in Invalid State\n");
+        return OMX_ErrorInvalidState;
+    }
+    componentVersion->nVersion = OMX_SPEC_VERSION;
+    specVersion->nVersion = OMX_SPEC_VERSION;
+    return OMX_ErrorNone;
+}
+/**
+  @brief member function handles command from IL client
+
+  This function simply queue up commands from IL client.
+  Commands will be processed in command server thread context later
+
+  @param hComp handle to component instance
+  @param cmd type of command
+  @param param1 parameters associated with the command type
+  @param cmdData
+  @return Error status
+*/
+OMX_ERRORTYPE  omx_g711_aenc::send_command(OMX_IN OMX_HANDLETYPE hComp,
+                                           OMX_IN OMX_COMMANDTYPE  cmd,
+                                           OMX_IN OMX_U32       param1,
+                                           OMX_IN OMX_PTR      cmdData)
+{
+    int portIndex = (int)param1;
+
+    if(hComp == NULL)
+    {
+        cmdData = cmdData;
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    if (OMX_StateInvalid == m_state)
+    {
+        return OMX_ErrorInvalidState;
+    }
+    if ( (cmd == OMX_CommandFlush) && (portIndex > 1) )
+    {
+        return OMX_ErrorBadPortIndex;
+    }
+    post_command((unsigned)cmd,(unsigned)param1,OMX_COMPONENT_GENERATE_COMMAND);
+    OMX_LOGV("Send Command : returns with OMX_ErrorNone \n");
+    OMX_LOGV("send_command : recieved state before semwait= %u\n",param1);
+    sem_wait (&sem_States);
+    OMX_LOGV("send_command : recieved state after semwait\n");
+    return OMX_ErrorNone;
+}
+
+/**
+ @brief member function performs actual processing of commands excluding
+  empty buffer call
+
+ @param hComp handle to component
+ @param cmd command type
+ @param param1 parameter associated with the command
+ @param cmdData
+
+ @return error status
+*/
+OMX_ERRORTYPE  omx_g711_aenc::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
+                                                 OMX_IN OMX_COMMANDTYPE  cmd,
+                                                 OMX_IN OMX_U32       param1,
+                                                 OMX_IN OMX_PTR      cmdData)
+{
+    OMX_ERRORTYPE eRet = OMX_ErrorNone;
+    //   Handle only IDLE and executing
+    OMX_STATETYPE eState = (OMX_STATETYPE) param1;
+    int bFlag = 1;
+    nState = eState;
+
+    if(hComp == NULL)
+    {
+        cmdData = cmdData;
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    if (OMX_CommandStateSet == cmd)
+    {
+        /***************************/
+        /* Current State is Loaded */
+        /***************************/
+        if (OMX_StateLoaded == m_state)
+        {
+            if (OMX_StateIdle == eState)
+            {
+
+                 if (allocate_done() ||
+                        (m_inp_bEnabled == OMX_FALSE
+                         && m_out_bEnabled == OMX_FALSE))
+                 {
+                       OMX_LOGV("SCP-->Allocate Done Complete\n");
+                 }
+                 else
+                 {
+                        OMX_LOGV("SCP-->Loaded to Idle-Pending\n");
+                        BITMASK_SET(&m_flags, OMX_COMPONENT_IDLE_PENDING);
+                        bFlag = 0;
+                 }
+
+            } else if (eState == OMX_StateLoaded)
+            {
+                OMX_LOGV("OMXCORE-SM: Loaded-->Loaded\n");
+                m_cb.EventHandler(&this->m_cmp,
+                                  this->m_app_data,
+                                  OMX_EventError,
+                                  OMX_ErrorSameState,
+                                  0, NULL );
+                eRet = OMX_ErrorSameState;
+            }
+
+            else if (eState == OMX_StateWaitForResources)
+            {
+                OMX_LOGV("OMXCORE-SM: Loaded-->WaitForResources\n");
+                eRet = OMX_ErrorNone;
+            }
+
+            else if (eState == OMX_StateExecuting)
+            {
+                OMX_LOGV("OMXCORE-SM: Loaded-->Executing\n");
+                m_cb.EventHandler(&this->m_cmp,
+                                  this->m_app_data,
+                                  OMX_EventError,
+                                  OMX_ErrorIncorrectStateTransition,
+                                  0, NULL );
+                eRet = OMX_ErrorIncorrectStateTransition;
+            }
+
+            else if (eState == OMX_StatePause)
+            {
+                OMX_LOGV("OMXCORE-SM: Loaded-->Pause\n");
+                m_cb.EventHandler(&this->m_cmp,
+                                  this->m_app_data,
+                                  OMX_EventError,
+                                  OMX_ErrorIncorrectStateTransition,
+                                  0, NULL );
+                eRet = OMX_ErrorIncorrectStateTransition;
+            }
+
+            else if (eState == OMX_StateInvalid)
+            {
+                OMX_LOGV("OMXCORE-SM: Loaded-->Invalid\n");
+                m_cb.EventHandler(&this->m_cmp,
+                                  this->m_app_data,
+                                  OMX_EventError,
+                                  OMX_ErrorInvalidState,
+                                  0, NULL );
+                m_state = OMX_StateInvalid;
+                eRet = OMX_ErrorInvalidState;
+            } else
+            {
+                OMX_LOGE("SCP-->Loaded to Invalid(%d))\n",eState);
+                eRet = OMX_ErrorBadParameter;
+            }
+        }
+
+        /***************************/
+        /* Current State is IDLE */
+        /***************************/
+        else if (OMX_StateIdle == m_state)
+        {
+            if (OMX_StateLoaded == eState)
+            {
+                if (release_done(-1))
+                {
+                    if (ioctl(m_drv_fd, AUDIO_STOP, 0) == -1)
+                    {
+                        OMX_LOGE("SCP:Idle->Loaded,\
+                                ioctl stop failed %d\n", errno);
+                    }
+
+                    nTimestamp=0;
+
+                    OMX_LOGV("SCP-->Idle to Loaded\n");
+                } else
+                {
+                    OMX_LOGV("SCP--> Idle to Loaded-Pending\n");
+                    BITMASK_SET(&m_flags, OMX_COMPONENT_LOADING_PENDING);
+                    // Skip the event notification
+                    bFlag = 0;
+                }
+            }
+            else if (OMX_StateExecuting == eState)
+            {
+
+                struct msm_audio_g711_enc_config drv_g711_enc_config;
+                struct msm_audio_stream_config drv_stream_config;
+                struct msm_audio_buf_cfg buf_cfg;
+                struct msm_audio_config pcm_cfg;
+
+                if(ioctl(m_drv_fd, AUDIO_GET_STREAM_CONFIG, &drv_stream_config)
+                    == -1)
+                {
+                    OMX_LOGE("ioctl AUDIO_GET_STREAM_CONFIG failed, \
+                            errno[%d]\n", errno);
+                }
+                if(ioctl(m_drv_fd, AUDIO_SET_STREAM_CONFIG, &drv_stream_config)
+                    == -1)
+                {
+                    OMX_LOGE("ioctl AUDIO_SET_STREAM_CONFIG failed, \
+                            errno[%d]\n", errno);
+                }
+
+                if(ioctl(m_drv_fd, AUDIO_GET_G711_ENC_CONFIG,
+                    &drv_g711_enc_config) == -1)
+                {
+                    OMX_LOGE("ioctl AUDIO_GET_G711_ENC_CONFIG failed,\
+                            errno[%d]\n", errno);
+                }
+                if( drv_g711_enc_config.sample_rate != m_g711_param.nSamplingRate)
+                {
+                    drv_g711_enc_config.sample_rate = m_g711_param.nSamplingRate;
+                }
+                OMX_LOGV("sampling rate %d", drv_g711_enc_config.sample_rate);
+                if(ioctl(m_drv_fd, AUDIO_SET_G711_ENC_CONFIG, &drv_g711_enc_config)
+                    == -1)
+                {
+                    OMX_LOGE("ioctl AUDIO_SET_G711_ENC_CONFIG \
+                            failed, errno[%d]\n", errno);
+                }
+                if (ioctl(m_drv_fd, AUDIO_GET_BUF_CFG, &buf_cfg) == -1)
+                {
+                    OMX_LOGE("ioctl AUDIO_GET_BUF_CFG, errno[%d]\n",
+                            errno);
+                }
+                buf_cfg.meta_info_enable = 1;
+                buf_cfg.frames_per_buf = NUMOFFRAMES;
+                if (ioctl(m_drv_fd, AUDIO_SET_BUF_CFG, &buf_cfg) == -1)
+                {
+                    OMX_LOGE("ioctl AUDIO_SET_BUF_CFG, errno[%d]\n",
+                            errno);
+                }
+                if(pcm_input)
+                {
+                    if (ioctl(m_drv_fd, AUDIO_GET_CONFIG, &pcm_cfg) == -1)
+                    {
+                        OMX_LOGE("ioctl AUDIO_GET_CONFIG, errno[%d]\n",
+                                errno);
+                    }
+                    pcm_cfg.channel_count = m_pcm_param.nChannels;
+                    pcm_cfg.sample_rate  =  m_pcm_param.nSamplingRate;
+                    OMX_LOGV("pcm config %u %u\n",m_pcm_param.nChannels,
+                            m_pcm_param.nSamplingRate);
+
+                    if (ioctl(m_drv_fd, AUDIO_SET_CONFIG, &pcm_cfg) == -1)
+                    {
+                        OMX_LOGE("ioctl AUDIO_SET_CONFIG, errno[%d]\n",
+                                errno);
+                    }
+                }
+                if(ioctl(m_drv_fd, AUDIO_START, 0) == -1)
+                {
+                    OMX_LOGE("ioctl AUDIO_START failed, errno[%d]\n",
+                            errno);
+                }
+                OMX_LOGV("SCP-->Idle to Executing\n");
+                nState = eState;
+            } else if (eState == OMX_StateIdle)
+            {
+                OMX_LOGV("OMXCORE-SM: Idle-->Idle\n");
+                m_cb.EventHandler(&this->m_cmp,
+                                  this->m_app_data,
+                                  OMX_EventError,
+                                  OMX_ErrorSameState,
+                                  0, NULL );
+                eRet = OMX_ErrorSameState;
+            } else if (eState == OMX_StateWaitForResources)
+            {
+                OMX_LOGV("OMXCORE-SM: Idle-->WaitForResources\n");
+                this->m_cb.EventHandler(&this->m_cmp, this->m_app_data,
+                                        OMX_EventError,
+                                        OMX_ErrorIncorrectStateTransition,
+                                        0, NULL );
+                eRet = OMX_ErrorIncorrectStateTransition;
+            }
+
+            else if (eState == OMX_StatePause)
+            {
+                OMX_LOGV("OMXCORE-SM: Idle-->Pause\n");
+            }
+
+            else if (eState == OMX_StateInvalid)
+            {
+                OMX_LOGV("OMXCORE-SM: Idle-->Invalid\n");
+                m_state = OMX_StateInvalid;
+                this->m_cb.EventHandler(&this->m_cmp,
+                                        this->m_app_data,
+                                        OMX_EventError,
+                                        OMX_ErrorInvalidState,
+                                        0, NULL );
+                eRet = OMX_ErrorInvalidState;
+            } else
+            {
+                OMX_LOGE("SCP--> Idle to %d Not Handled\n",eState);
+                eRet = OMX_ErrorBadParameter;
+            }
+        }
+
+        /******************************/
+        /* Current State is Executing */
+        /******************************/
+        else if (OMX_StateExecuting == m_state)
+        {
+            if (OMX_StateIdle == eState)
+            {
+                OMX_LOGV("SCP-->Executing to Idle \n");
+                if(pcm_input)
+                    execute_omx_flush(-1,false);
+                else
+                    execute_omx_flush(1,false);
+
+
+            } else if (OMX_StatePause == eState)
+            {
+                DEBUG_DETAIL("*************************\n");
+                OMX_LOGV("SCP-->RXED PAUSE STATE\n");
+                DEBUG_DETAIL("*************************\n");
+                //ioctl(m_drv_fd, AUDIO_PAUSE, 0);
+            } else if (eState == OMX_StateLoaded)
+            {
+                OMX_LOGV("\n OMXCORE-SM: Executing --> Loaded \n");
+                this->m_cb.EventHandler(&this->m_cmp, this->m_app_data,
+                                        OMX_EventError,
+                                        OMX_ErrorIncorrectStateTransition,
+                                        0, NULL );
+                eRet = OMX_ErrorIncorrectStateTransition;
+            } else if (eState == OMX_StateWaitForResources)
+            {
+                OMX_LOGV("\n OMXCORE-SM: Executing --> WaitForResources \n");
+                this->m_cb.EventHandler(&this->m_cmp, this->m_app_data,
+                                        OMX_EventError,
+                                        OMX_ErrorIncorrectStateTransition,
+                                        0, NULL );
+                eRet = OMX_ErrorIncorrectStateTransition;
+            } else if (eState == OMX_StateExecuting)
+            {
+                OMX_LOGV("\n OMXCORE-SM: Executing --> Executing \n");
+                this->m_cb.EventHandler(&this->m_cmp, this->m_app_data,
+                                        OMX_EventError, OMX_ErrorSameState,
+                                        0, NULL );
+                eRet = OMX_ErrorSameState;
+            } else if (eState == OMX_StateInvalid)
+            {
+                OMX_LOGV("\n OMXCORE-SM: Executing --> Invalid \n");
+                m_state = OMX_StateInvalid;
+                this->m_cb.EventHandler(&this->m_cmp, this->m_app_data,
+                                        OMX_EventError, OMX_ErrorInvalidState,
+                                        0, NULL );
+                eRet = OMX_ErrorInvalidState;
+            } else
+            {
+                OMX_LOGE("SCP--> Executing to %d Not Handled\n",
+                        eState);
+                eRet = OMX_ErrorBadParameter;
+            }
+        }
+        /***************************/
+        /* Current State is Pause  */
+        /***************************/
+        else if (OMX_StatePause == m_state)
+        {
+            if( (eState == OMX_StateExecuting || eState == OMX_StateIdle) )
+            {
+                pthread_mutex_lock(&m_out_th_lock_1);
+                if(is_out_th_sleep)
+                {
+                    DEBUG_DETAIL("PE: WAKING UP OUT THREAD\n");
+                    is_out_th_sleep = false;
+                    out_th_wakeup();
+                }
+                pthread_mutex_unlock(&m_out_th_lock_1);
+            }
+            if ( OMX_StateExecuting == eState )
+            {
+                nState = eState;
+            } else if ( OMX_StateIdle == eState )
+            {
+                OMX_LOGV("SCP-->Paused to Idle \n");
+                OMX_LOGV ("\n Internal flush issued");
+                pthread_mutex_lock(&m_flush_lock);
+                m_flush_cnt = 2;
+                pthread_mutex_unlock(&m_flush_lock);
+                if(pcm_input)
+                    execute_omx_flush(-1,false);
+                else
+                    execute_omx_flush(1,false);
+
+            } else if ( eState == OMX_StateLoaded )
+            {
+                OMX_LOGV("\n Pause --> loaded \n");
+                this->m_cb.EventHandler(&this->m_cmp, this->m_app_data,
+                                        OMX_EventError,
+                                        OMX_ErrorIncorrectStateTransition,
+                                        0, NULL );
+                eRet = OMX_ErrorIncorrectStateTransition;
+            } else if (eState == OMX_StateWaitForResources)
+            {
+                OMX_LOGV("\n Pause --> WaitForResources \n");
+                this->m_cb.EventHandler(&this->m_cmp, this->m_app_data,
+                                        OMX_EventError,
+                                        OMX_ErrorIncorrectStateTransition,
+                                        0, NULL );
+                eRet = OMX_ErrorIncorrectStateTransition;
+            } else if (eState == OMX_StatePause)
+            {
+                OMX_LOGV("\n Pause --> Pause \n");
+                this->m_cb.EventHandler(&this->m_cmp, this->m_app_data,
+                                        OMX_EventError, OMX_ErrorSameState,
+                                        0, NULL );
+                eRet = OMX_ErrorSameState;
+            } else if (eState == OMX_StateInvalid)
+            {
+                OMX_LOGV("\n Pause --> Invalid \n");
+                m_state = OMX_StateInvalid;
+                this->m_cb.EventHandler(&this->m_cmp, this->m_app_data,
+                                        OMX_EventError, OMX_ErrorInvalidState,
+                                        0, NULL );
+                eRet = OMX_ErrorInvalidState;
+            } else
+            {
+                OMX_LOGV("SCP-->Paused to %d Not Handled\n",eState);
+                eRet = OMX_ErrorBadParameter;
+            }
+        }
+        /**************************************/
+        /* Current State is WaitForResources  */
+        /**************************************/
+        else if (m_state == OMX_StateWaitForResources)
+        {
+            if (eState == OMX_StateLoaded)
+            {
+                OMX_LOGV("OMXCORE-SM: WaitForResources-->Loaded\n");
+            } else if (eState == OMX_StateWaitForResources)
+            {
+                OMX_LOGV("OMXCORE-SM: waitForResources-->WaitForResources\n");
+                this->m_cb.EventHandler(&this->m_cmp, this->m_app_data,
+                                        OMX_EventError, OMX_ErrorSameState,
+                                        0, NULL );
+                eRet = OMX_ErrorSameState;
+            } else if (eState == OMX_StateExecuting)
+            {
+                OMX_LOGV("OMXCORE-SM: WaitForResources-->Executing\n");
+                this->m_cb.EventHandler(&this->m_cmp, this->m_app_data,
+                                        OMX_EventError,
+                                        OMX_ErrorIncorrectStateTransition,
+                                        0, NULL );
+                eRet = OMX_ErrorIncorrectStateTransition;
+            } else if (eState == OMX_StatePause)
+            {
+                OMX_LOGV("OMXCORE-SM: WaitForResources-->Pause\n");
+                this->m_cb.EventHandler(&this->m_cmp, this->m_app_data,
+                                        OMX_EventError,
+                                        OMX_ErrorIncorrectStateTransition,
+                                        0, NULL );
+                eRet = OMX_ErrorIncorrectStateTransition;
+            } else if (eState == OMX_StateInvalid)
+            {
+                OMX_LOGV("OMXCORE-SM: WaitForResources-->Invalid\n");
+                m_state = OMX_StateInvalid;
+                this->m_cb.EventHandler(&this->m_cmp, this->m_app_data,
+                                        OMX_EventError,
+                                        OMX_ErrorInvalidState,
+                                        0, NULL );
+                eRet = OMX_ErrorInvalidState;
+            } else
+            {
+                OMX_LOGE("SCP--> %d to %d(Not Handled)\n",
+                    m_state,eState);
+                eRet = OMX_ErrorBadParameter;
+            }
+        }
+        /****************************/
+        /* Current State is Invalid */
+        /****************************/
+        else if (m_state == OMX_StateInvalid)
+        {
+            if (OMX_StateLoaded == eState || OMX_StateWaitForResources == eState
+                || OMX_StateIdle == eState || OMX_StateExecuting == eState
+                || OMX_StatePause == eState || OMX_StateInvalid == eState)
+            {
+                OMX_LOGV("OMXCORE-SM: Invalid-->Loaded/Idle/Executing"
+                            "/Pause/Invalid/WaitForResources\n");
+                m_state = OMX_StateInvalid;
+                this->m_cb.EventHandler(&this->m_cmp, this->m_app_data,
+                                        OMX_EventError, OMX_ErrorInvalidState,
+                                        0, NULL );
+                eRet = OMX_ErrorInvalidState;
+            }
+        } else
+        {
+            OMX_LOGE("OMXCORE-SM: %d --> %d(Not Handled)\n",\
+                              m_state,eState);
+            eRet = OMX_ErrorBadParameter;
+        }
+    } else if (OMX_CommandFlush == cmd)
+    {
+        DEBUG_DETAIL("*************************\n");
+        OMX_LOGV("SCP-->RXED FLUSH COMMAND port=%u\n",param1);
+        DEBUG_DETAIL("*************************\n");
+        bFlag = 0;
+        if ( param1 == OMX_CORE_INPUT_PORT_INDEX ||
+             param1 == OMX_CORE_OUTPUT_PORT_INDEX ||
+            (signed)param1 == -1 )
+        {
+            execute_omx_flush(param1);
+        } else
+        {
+            eRet = OMX_ErrorBadPortIndex;
+            m_cb.EventHandler(&m_cmp, m_app_data, OMX_EventError,
+                OMX_CommandFlush, OMX_ErrorBadPortIndex, NULL );
+        }
+    } else if ( cmd == OMX_CommandPortDisable )
+    {
+    bFlag = 0;
+        if ( param1 == OMX_CORE_INPUT_PORT_INDEX || param1 == OMX_ALL )
+        {
+            OMX_LOGV("SCP: Disabling Input port Indx\n");
+            m_inp_bEnabled = OMX_FALSE;
+            if ( (m_state == OMX_StateLoaded || m_state == OMX_StateIdle)
+                && release_done(0) )
+            {
+                OMX_LOGV("send_command_proxy:OMX_CommandPortDisable:\
+                            OMX_CORE_INPUT_PORT_INDEX:release_done \n");
+                OMX_LOGV("************* OMX_CommandPortDisable:\
+                            m_inp_bEnabled=%d********\n",m_inp_bEnabled);
+
+                post_command(OMX_CommandPortDisable,
+                             OMX_CORE_INPUT_PORT_INDEX,
+                             OMX_COMPONENT_GENERATE_EVENT);
+            }
+
+            else
+            {
+                if (m_state == OMX_StatePause ||m_state == OMX_StateExecuting)
+                {
+                    OMX_LOGV("SCP: execute_omx_flush in Disable in "\
+                                " param1=%u m_state=%d \n",param1, m_state);
+                    execute_omx_flush(param1);
+                }
+                OMX_LOGV("send_command_proxy:OMX_CommandPortDisable:\
+                            OMX_CORE_INPUT_PORT_INDEX \n");
+                BITMASK_SET(&m_flags, OMX_COMPONENT_INPUT_DISABLE_PENDING);
+                // Skip the event notification
+
+            }
+
+        }
+        if (param1 == OMX_CORE_OUTPUT_PORT_INDEX || param1 == OMX_ALL)
+        {
+
+            OMX_LOGV("SCP: Disabling Output port Indx\n");
+            m_out_bEnabled = OMX_FALSE;
+            if ((m_state == OMX_StateLoaded || m_state == OMX_StateIdle)
+                && release_done(1))
+            {
+                OMX_LOGV("send_command_proxy:OMX_CommandPortDisable:\
+                            OMX_CORE_OUTPUT_PORT_INDEX:release_done \n");
+                OMX_LOGV("************* OMX_CommandPortDisable:\
+                            m_out_bEnabled=%d********\n",m_inp_bEnabled);
+
+                post_command(OMX_CommandPortDisable,
+                             OMX_CORE_OUTPUT_PORT_INDEX,
+                             OMX_COMPONENT_GENERATE_EVENT);
+            } else
+            {
+                if (m_state == OMX_StatePause ||m_state == OMX_StateExecuting)
+                {
+                    OMX_LOGV("SCP: execute_omx_flush in Disable out "\
+                                "param1=%u m_state=%d \n",param1, m_state);
+                    execute_omx_flush(param1);
+                }
+                BITMASK_SET(&m_flags, OMX_COMPONENT_OUTPUT_DISABLE_PENDING);
+                // Skip the event notification
+
+            }
+        } else
+        {
+            OMX_LOGE("OMX_CommandPortDisable: disable wrong port ID");
+        }
+
+    } else if (cmd == OMX_CommandPortEnable)
+    {
+    bFlag = 0;
+        if (param1 == OMX_CORE_INPUT_PORT_INDEX  || param1 == OMX_ALL)
+        {
+            m_inp_bEnabled = OMX_TRUE;
+            OMX_LOGV("SCP: Enabling Input port Indx\n");
+            if ((m_state == OMX_StateLoaded
+                 && !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
+                || (m_state == OMX_StateWaitForResources)
+                || (m_inp_bPopulated == OMX_TRUE))
+            {
+                post_command(OMX_CommandPortEnable,
+                             OMX_CORE_INPUT_PORT_INDEX,
+                             OMX_COMPONENT_GENERATE_EVENT);
+
+
+            } else
+            {
+                BITMASK_SET(&m_flags, OMX_COMPONENT_INPUT_ENABLE_PENDING);
+                // Skip the event notification
+
+            }
+        }
+
+        if (param1 == OMX_CORE_OUTPUT_PORT_INDEX || param1 == OMX_ALL)
+        {
+            OMX_LOGV("SCP: Enabling Output port Indx\n");
+            m_out_bEnabled = OMX_TRUE;
+            if ((m_state == OMX_StateLoaded
+                 && !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
+                || (m_state == OMX_StateWaitForResources)
+                || (m_out_bPopulated == OMX_TRUE))
+            {
+                post_command(OMX_CommandPortEnable,
+                             OMX_CORE_OUTPUT_PORT_INDEX,
+                             OMX_COMPONENT_GENERATE_EVENT);
+            } else
+            {
+                OMX_LOGV("send_command_proxy:OMX_CommandPortEnable:\
+                            OMX_CORE_OUTPUT_PORT_INDEX:release_done \n");
+                BITMASK_SET(&m_flags, OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
+                // Skip the event notification
+
+            }
+            pthread_mutex_lock(&m_in_th_lock_1);
+            if(is_in_th_sleep)
+            {
+                    is_in_th_sleep = false;
+                    DEBUG_DETAIL("SCP:WAKING UP IN THREADS\n");
+                    in_th_wakeup();
+            }
+            pthread_mutex_unlock(&m_in_th_lock_1);
+            pthread_mutex_lock(&m_out_th_lock_1);
+            if (is_out_th_sleep)
+            {
+                is_out_th_sleep = false;
+                OMX_LOGV("SCP:WAKING OUT THR, OMX_CommandPortEnable\n");
+                out_th_wakeup();
+            }
+            pthread_mutex_unlock(&m_out_th_lock_1);
+        } else
+        {
+            OMX_LOGE("OMX_CommandPortEnable: disable wrong port ID");
+        }
+
+    } else
+    {
+        OMX_LOGE("SCP-->ERROR: Invali Command [%d]\n",cmd);
+        eRet = OMX_ErrorNotImplemented;
+    }
+    OMX_LOGV("posting sem_States\n");
+    sem_post (&sem_States);
+    if (eRet == OMX_ErrorNone && bFlag)
+    {
+        post_command(cmd,eState,OMX_COMPONENT_GENERATE_EVENT);
+    }
+    return eRet;
+}
+
+/*=============================================================================
+FUNCTION:
+  execute_omx_flush
+
+DESCRIPTION:
+  Function that flushes buffers that are pending to be written to driver
+
+INPUT/OUTPUT PARAMETERS:
+  [IN] param1
+  [IN] cmd_cmpl
+
+RETURN VALUE:
+  true
+  false
+
+Dependency:
+  None
+
+SIDE EFFECTS:
+  None
+=============================================================================*/
+bool omx_g711_aenc::execute_omx_flush(OMX_IN OMX_U32 param1, bool cmd_cmpl)
+{
+    bool bRet = true;
+
+    OMX_LOGV("Execute_omx_flush Port[%u]", param1);
+    struct timespec abs_timeout;
+    abs_timeout.tv_sec = 1;
+    abs_timeout.tv_nsec = 0;
+
+    if ((signed)param1 == -1)
+    {
+        bFlushinprogress = true;
+        OMX_LOGV("Execute flush for both I/p O/p port\n");
+        pthread_mutex_lock(&m_flush_lock);
+        m_flush_cnt = 2;
+        pthread_mutex_unlock(&m_flush_lock);
+
+        // Send Flush commands to input and output threads
+        post_input(OMX_CommandFlush,
+                   OMX_CORE_INPUT_PORT_INDEX,OMX_COMPONENT_GENERATE_COMMAND);
+        post_output(OMX_CommandFlush,
+                    OMX_CORE_OUTPUT_PORT_INDEX,OMX_COMPONENT_GENERATE_COMMAND);
+        // Send Flush to the kernel so that the in and out buffers are released
+        if (ioctl( m_drv_fd, AUDIO_FLUSH, 0) == -1)
+            OMX_LOGE("FLush:ioctl flush failed errno=%d\n",errno);
+        DEBUG_DETAIL("****************************************");
+        DEBUG_DETAIL("is_in_th_sleep=%d is_out_th_sleep=%d\n",\
+                     is_in_th_sleep,is_out_th_sleep);
+        DEBUG_DETAIL("****************************************");
+
+        pthread_mutex_lock(&m_in_th_lock_1);
+        if (is_in_th_sleep)
+        {
+            is_in_th_sleep = false;
+            DEBUG_DETAIL("For FLUSH-->WAKING UP IN THREADS\n");
+            in_th_wakeup();
+        }
+        pthread_mutex_unlock(&m_in_th_lock_1);
+
+        pthread_mutex_lock(&m_out_th_lock_1);
+        if (is_out_th_sleep)
+        {
+            is_out_th_sleep = false;
+            DEBUG_DETAIL("For FLUSH-->WAKING UP OUT THREADS\n");
+            out_th_wakeup();
+        }
+        pthread_mutex_unlock(&m_out_th_lock_1);
+
+
+        // sleep till the FLUSH ACK are done by both the input and
+        // output threads
+        DEBUG_DETAIL("WAITING FOR FLUSH ACK's param1=%d",param1);
+        wait_for_event();
+
+        OMX_LOGV("RECIEVED BOTH FLUSH ACK's param1=%u cmd_cmpl=%d",\
+                    param1,cmd_cmpl);
+
+        // If not going to idle state, Send FLUSH complete message
+        // to the Client, now that FLUSH ACK's have been recieved.
+        if (cmd_cmpl)
+        {
+            m_cb.EventHandler(&m_cmp, m_app_data, OMX_EventCmdComplete,
+                              OMX_CommandFlush, OMX_CORE_INPUT_PORT_INDEX,
+                              NULL );
+            m_cb.EventHandler(&m_cmp, m_app_data, OMX_EventCmdComplete,
+                              OMX_CommandFlush, OMX_CORE_OUTPUT_PORT_INDEX,
+                              NULL );
+            OMX_LOGV("Inside FLUSH.. sending FLUSH CMPL\n");
+        }
+        bFlushinprogress = false;
+    }
+    else if (param1 == OMX_CORE_INPUT_PORT_INDEX)
+    {
+        OMX_LOGV("Execute FLUSH for I/p port\n");
+        pthread_mutex_lock(&m_flush_lock);
+        m_flush_cnt = 1;
+        pthread_mutex_unlock(&m_flush_lock);
+        post_input(OMX_CommandFlush,
+                   OMX_CORE_INPUT_PORT_INDEX,OMX_COMPONENT_GENERATE_COMMAND);
+        if (ioctl( m_drv_fd, AUDIO_FLUSH, 0) == -1)
+            OMX_LOGE("Flush:Input port, ioctl flush failed %d\n",
+                errno);
+        DEBUG_DETAIL("****************************************");
+        DEBUG_DETAIL("is_in_th_sleep=%d is_out_th_sleep=%d\n",\
+                     is_in_th_sleep,is_out_th_sleep);
+        DEBUG_DETAIL("****************************************");
+
+        if (is_in_th_sleep)
+        {
+            pthread_mutex_lock(&m_in_th_lock_1);
+            is_in_th_sleep = false;
+            pthread_mutex_unlock(&m_in_th_lock_1);
+            DEBUG_DETAIL("For FLUSH-->WAKING UP IN THREADS\n");
+            in_th_wakeup();
+        }
+
+        if (is_out_th_sleep)
+        {
+            pthread_mutex_lock(&m_out_th_lock_1);
+            is_out_th_sleep = false;
+            pthread_mutex_unlock(&m_out_th_lock_1);
+            DEBUG_DETAIL("For FLUSH-->WAKING UP OUT THREADS\n");
+            out_th_wakeup();
+        }
+
+        //sleep till the FLUSH ACK are done by both the input and output threads
+        DEBUG_DETAIL("Executing FLUSH for I/p port\n");
+        DEBUG_DETAIL("WAITING FOR FLUSH ACK's param1=%d",param1);
+        wait_for_event();
+        DEBUG_DETAIL(" RECIEVED FLUSH ACK FOR I/P PORT param1=%d",param1);
+
+        // Send FLUSH complete message to the Client,
+        // now that FLUSH ACK's have been recieved.
+        if (cmd_cmpl)
+        {
+            m_cb.EventHandler(&m_cmp, m_app_data, OMX_EventCmdComplete,
+                              OMX_CommandFlush, OMX_CORE_INPUT_PORT_INDEX,
+                              NULL );
+        }
+    } else if (OMX_CORE_OUTPUT_PORT_INDEX == param1)
+    {
+        OMX_LOGV("Executing FLUSH for O/p port\n");
+        pthread_mutex_lock(&m_flush_lock);
+        m_flush_cnt = 1;
+        pthread_mutex_unlock(&m_flush_lock);
+        DEBUG_DETAIL("Executing FLUSH for O/p port\n");
+        DEBUG_DETAIL("WAITING FOR FLUSH ACK's param1=%d",param1);
+        post_output(OMX_CommandFlush,
+                    OMX_CORE_OUTPUT_PORT_INDEX,OMX_COMPONENT_GENERATE_COMMAND);
+        if (ioctl( m_drv_fd, AUDIO_FLUSH, 0) ==-1)
+            OMX_LOGE("Flush:Output port, ioctl flush failed %d\n",
+                errno);
+        DEBUG_DETAIL("****************************************");
+        DEBUG_DETAIL("is_in_th_sleep=%d is_out_th_sleep=%d\n",\
+                     is_in_th_sleep,is_out_th_sleep);
+        DEBUG_DETAIL("****************************************");
+        if (is_in_th_sleep)
+        {
+            pthread_mutex_lock(&m_in_th_lock_1);
+            is_in_th_sleep = false;
+            pthread_mutex_unlock(&m_in_th_lock_1);
+            DEBUG_DETAIL("For FLUSH-->WAKING UP IN THREADS\n");
+            in_th_wakeup();
+        }
+
+        if (is_out_th_sleep)
+        {
+            pthread_mutex_lock(&m_out_th_lock_1);
+            is_out_th_sleep = false;
+            pthread_mutex_unlock(&m_out_th_lock_1);
+            DEBUG_DETAIL("For FLUSH-->WAKING UP OUT THREADS\n");
+            out_th_wakeup();
+        }
+
+        // sleep till the FLUSH ACK are done by both the input and
+        // output threads
+        wait_for_event();
+        // Send FLUSH complete message to the Client,
+        // now that FLUSH ACK's have been recieved.
+        if (cmd_cmpl)
+        {
+            m_cb.EventHandler(&m_cmp, m_app_data, OMX_EventCmdComplete,
+                              OMX_CommandFlush, OMX_CORE_OUTPUT_PORT_INDEX,
+                              NULL );
+        }
+        DEBUG_DETAIL("RECIEVED FLUSH ACK FOR O/P PORT param1=%d",param1);
+    } else
+    {
+        OMX_LOGV("Invalid Port ID[%u]",param1);
+    }
+    return bRet;
+}
+
+/*=============================================================================
+FUNCTION:
+  execute_input_omx_flush
+
+DESCRIPTION:
+  Function that flushes buffers that are pending to be written to driver
+
+INPUT/OUTPUT PARAMETERS:
+  None
+
+RETURN VALUE:
+  true
+  false
+
+Dependency:
+  None
+
+SIDE EFFECTS:
+  None
+=============================================================================*/
+bool omx_g711_aenc::execute_input_omx_flush()
+{
+    OMX_BUFFERHEADERTYPE *omx_buf;
+    unsigned long p1 = 0;                            // Parameter - 1
+    unsigned long p2 = 0;                            // Parameter - 2
+    unsigned char ident = 0;
+    unsigned      qsize=0;                       // qsize
+    unsigned      tot_qsize=0;                   // qsize
+
+    OMX_LOGV("Execute_omx_flush on input port");
+
+    pthread_mutex_lock(&m_lock);
+    do
+    {
+        qsize = m_input_q.m_size;
+        tot_qsize = qsize;
+        tot_qsize += m_input_ctrl_ebd_q.m_size;
+
+        DEBUG_DETAIL("Input FLUSH-->flushq[%d] ebd[%d]dataq[%d]",\
+                     m_input_ctrl_cmd_q.m_size,
+                     m_input_ctrl_ebd_q.m_size,qsize);
+        if (!tot_qsize)
+        {
+            DEBUG_DETAIL("Input-->BREAKING FROM execute_input_flush LOOP");
+            pthread_mutex_unlock(&m_lock);
+            break;
+        }
+        if (qsize)
+        {
+            m_input_q.pop_entry(&p1, &p2, &ident);
+            if ((ident == OMX_COMPONENT_GENERATE_ETB) ||
+                (ident == OMX_COMPONENT_GENERATE_BUFFER_DONE))
+            {
+                omx_buf = (OMX_BUFFERHEADERTYPE *) p2;
+                DEBUG_DETAIL("Flush:Input dataq=%p \n", omx_buf);
+                omx_buf->nFilledLen = 0;
+                buffer_done_cb((OMX_BUFFERHEADERTYPE *)omx_buf);
+            }
+        } else if (m_input_ctrl_ebd_q.m_size)
+        {
+            m_input_ctrl_ebd_q.pop_entry(&p1, &p2, &ident);
+            if (ident == OMX_COMPONENT_GENERATE_BUFFER_DONE)
+            {
+                omx_buf = (OMX_BUFFERHEADERTYPE *) p2;
+                omx_buf->nFilledLen = 0;
+                DEBUG_DETAIL("Flush:ctrl dataq=%p \n", omx_buf);
+                buffer_done_cb((OMX_BUFFERHEADERTYPE *)omx_buf);
+            }
+        } else
+        {
+        }
+    }while (tot_qsize>0);
+    DEBUG_DETAIL("*************************\n");
+    DEBUG_DETAIL("IN-->FLUSHING DONE\n");
+    DEBUG_DETAIL("*************************\n");
+    flush_ack();
+    pthread_mutex_unlock(&m_lock);
+    return true;
+}
+
+/*=============================================================================
+FUNCTION:
+  execute_output_omx_flush
+
+DESCRIPTION:
+  Function that flushes buffers that are pending to be written to driver
+
+INPUT/OUTPUT PARAMETERS:
+  None
+
+RETURN VALUE:
+  true
+  false
+
+Dependency:
+  None
+
+SIDE EFFECTS:
+  None
+=============================================================================*/
+bool omx_g711_aenc::execute_output_omx_flush()
+{
+    OMX_BUFFERHEADERTYPE *omx_buf;
+    unsigned long p1 = 0;                            // Parameter - 1
+    unsigned long p2 = 0;                            // Parameter - 2
+    unsigned char ident = 0;
+    unsigned      qsize=0;                       // qsize
+    unsigned      tot_qsize=0;                   // qsize
+
+    OMX_LOGV("Execute_omx_flush on output port");
+
+    pthread_mutex_lock(&m_outputlock);
+    do
+    {
+        qsize = m_output_q.m_size;
+        DEBUG_DETAIL("OUT FLUSH-->flushq[%d] fbd[%d]dataq[%d]",\
+                     m_output_ctrl_cmd_q.m_size,
+                     m_output_ctrl_fbd_q.m_size,qsize);
+        tot_qsize = qsize;
+        tot_qsize += m_output_ctrl_fbd_q.m_size;
+        if (!tot_qsize)
+        {
+            DEBUG_DETAIL("OUT-->BREAKING FROM execute_input_flush LOOP");
+            pthread_mutex_unlock(&m_outputlock);
+            break;
+        }
+        if (qsize)
+        {
+            m_output_q.pop_entry(&p1,&p2,&ident);
+            if ( (OMX_COMPONENT_GENERATE_FTB == ident) ||
+                 (OMX_COMPONENT_GENERATE_FRAME_DONE == ident))
+            {
+                omx_buf = (OMX_BUFFERHEADERTYPE *) p2;
+                DEBUG_DETAIL("Ouput Buf_Addr=%p TS[0x%x] \n",\
+                             omx_buf,nTimestamp);
+                omx_buf->nTimeStamp = nTimestamp;
+                omx_buf->nFilledLen = 0;
+                frame_done_cb((OMX_BUFFERHEADERTYPE *)omx_buf);
+                DEBUG_DETAIL("CALLING FBD FROM FLUSH");
+            }
+        } else if ((qsize = m_output_ctrl_fbd_q.m_size))
+        {
+            m_output_ctrl_fbd_q.pop_entry(&p1, &p2, &ident);
+            if (OMX_COMPONENT_GENERATE_FRAME_DONE == ident)
+            {
+                omx_buf = (OMX_BUFFERHEADERTYPE *) p2;
+                DEBUG_DETAIL("Ouput Buf_Addr=%p TS[0x%x] \n", \
+                             omx_buf,nTimestamp);
+                omx_buf->nTimeStamp = nTimestamp;
+                omx_buf->nFilledLen = 0;
+                frame_done_cb((OMX_BUFFERHEADERTYPE *)omx_buf);
+                DEBUG_DETAIL("CALLING FROM CTRL-FBDQ FROM FLUSH");
+            }
+        }
+    }while (qsize>0);
+    DEBUG_DETAIL("*************************\n");
+    DEBUG_DETAIL("OUT-->FLUSHING DONE\n");
+    DEBUG_DETAIL("*************************\n");
+    flush_ack();
+    pthread_mutex_unlock(&m_outputlock);
+    return true;
+}
+
+/*=============================================================================
+FUNCTION:
+  post_input
+
+DESCRIPTION:
+  Function that posts command in the command queue
+
+INPUT/OUTPUT PARAMETERS:
+  [IN] p1
+  [IN] p2
+  [IN] id - command ID
+  [IN] lock - self-locking mode
+
+RETURN VALUE:
+  true
+  false
+
+Dependency:
+  None
+
+SIDE EFFECTS:
+  None
+=============================================================================*/
+bool omx_g711_aenc::post_input(unsigned long p1,
+                               unsigned long p2,
+                               unsigned char id)
+{
+    bool bRet = false;
+    pthread_mutex_lock(&m_lock);
+
+    if((OMX_COMPONENT_GENERATE_COMMAND == id) || (id == OMX_COMPONENT_SUSPEND))
+    {
+        // insert flush message and ebd
+        m_input_ctrl_cmd_q.insert_entry(p1,p2,id);
+    } else if ((OMX_COMPONENT_GENERATE_BUFFER_DONE == id))
+    {
+        // insert ebd
+        m_input_ctrl_ebd_q.insert_entry(p1,p2,id);
+    } else
+    {
+        // ETBS in this queue
+        m_input_q.insert_entry(p1,p2,id);
+    }
+
+    if (m_ipc_to_in_th)
+    {
+        bRet = true;
+        omx_g711_post_msg(m_ipc_to_in_th, id);
+    }
+
+    DEBUG_DETAIL("PostInput-->state[%d]id[%d]flushq[%d]ebdq[%d]dataq[%d] \n",\
+                 m_state,
+                 id,
+                 m_input_ctrl_cmd_q.m_size,
+                 m_input_ctrl_ebd_q.m_size,
+                 m_input_q.m_size);
+
+    pthread_mutex_unlock(&m_lock);
+    return bRet;
+}
+
+/*=============================================================================
+FUNCTION:
+  post_command
+
+DESCRIPTION:
+  Function that posts command in the command queue
+
+INPUT/OUTPUT PARAMETERS:
+  [IN] p1
+  [IN] p2
+  [IN] id - command ID
+  [IN] lock - self-locking mode
+
+RETURN VALUE:
+  true
+  false
+
+Dependency:
+  None
+
+SIDE EFFECTS:
+  None
+=============================================================================*/
+bool omx_g711_aenc::post_command(unsigned int p1,
+                                 unsigned int p2,
+                                 unsigned char id)
+{
+    bool bRet  = false;
+
+    pthread_mutex_lock(&m_commandlock);
+
+    m_command_q.insert_entry(p1,p2,id);
+
+    if (m_ipc_to_cmd_th)
+    {
+        bRet = true;
+        omx_g711_post_msg(m_ipc_to_cmd_th, id);
+    }
+
+    DEBUG_DETAIL("PostCmd-->state[%d]id[%d]cmdq[%d]flags[%x]\n",\
+                 m_state,
+                 id,
+                 m_command_q.m_size,
+                 m_flags >> 3);
+
+    pthread_mutex_unlock(&m_commandlock);
+    return bRet;
+}
+
+/*=============================================================================
+FUNCTION:
+  post_output
+
+DESCRIPTION:
+  Function that posts command in the command queue
+
+INPUT/OUTPUT PARAMETERS:
+  [IN] p1
+  [IN] p2
+  [IN] id - command ID
+  [IN] lock - self-locking mode
+
+RETURN VALUE:
+  true
+  false
+
+Dependency:
+  None
+
+SIDE EFFECTS:
+  None
+=============================================================================*/
+bool omx_g711_aenc::post_output(unsigned long p1,
+                                unsigned long p2,
+                                unsigned char id)
+{
+    bool bRet = false;
+
+    pthread_mutex_lock(&m_outputlock);
+    if((OMX_COMPONENT_GENERATE_COMMAND == id) || (id == OMX_COMPONENT_SUSPEND)
+        || (id == OMX_COMPONENT_RESUME))
+    {
+        // insert flush message and fbd
+        m_output_ctrl_cmd_q.insert_entry(p1,p2,id);
+    } else if ( (OMX_COMPONENT_GENERATE_FRAME_DONE == id) )
+    {
+        // insert flush message and fbd
+        m_output_ctrl_fbd_q.insert_entry(p1,p2,id);
+    } else
+    {
+        m_output_q.insert_entry(p1,p2,id);
+    }
+    if ( m_ipc_to_out_th )
+    {
+        bRet = true;
+        omx_g711_post_msg(m_ipc_to_out_th, id);
+    }
+    DEBUG_DETAIL("PostOutput-->state[%d]id[%d]flushq[%d]ebdq[%d]dataq[%d]\n",\
+                 m_state,
+                 id,
+                 m_output_ctrl_cmd_q.m_size,
+                 m_output_ctrl_fbd_q.m_size,
+                 m_output_q.m_size);
+
+    pthread_mutex_unlock(&m_outputlock);
+    return bRet;
+}
+/**
+  @brief member function that return parameters to IL client
+
+  @param hComp handle to component instance
+  @param paramIndex Parameter type
+  @param paramData pointer to memory space which would hold the
+        paramter
+  @return error status
+*/
+OMX_ERRORTYPE  omx_g711_aenc::get_parameter(OMX_IN OMX_HANDLETYPE     hComp,
+                                            OMX_IN OMX_INDEXTYPE paramIndex,
+                                            OMX_INOUT OMX_PTR     paramData)
+{
+    OMX_ERRORTYPE eRet = OMX_ErrorNone;
+
+    if(hComp == NULL)
+    {
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    if (m_state == OMX_StateInvalid)
+    {
+        OMX_LOGE("Get Param in Invalid State\n");
+        return OMX_ErrorInvalidState;
+    }
+    if (paramData == NULL)
+    {
+        OMX_LOGV("get_parameter: paramData is NULL\n");
+        return OMX_ErrorBadParameter;
+    }
+
+    switch ((int)paramIndex)
+    {
+        case OMX_IndexParamPortDefinition:
+            {
+                OMX_PARAM_PORTDEFINITIONTYPE *portDefn;
+                portDefn = (OMX_PARAM_PORTDEFINITIONTYPE *) paramData;
+
+                OMX_LOGV("OMX_IndexParamPortDefinition " \
+                            "portDefn->nPortIndex = %u\n",
+                            portDefn->nPortIndex);
+
+                portDefn->nVersion.nVersion = OMX_SPEC_VERSION;
+                portDefn->nSize = (OMX_U32)sizeof(portDefn);
+                portDefn->eDomain    = OMX_PortDomainAudio;
+
+                if (0 == portDefn->nPortIndex)
+                {
+                    portDefn->eDir       = OMX_DirInput;
+                    portDefn->bEnabled   = m_inp_bEnabled;
+                    portDefn->bPopulated = m_inp_bPopulated;
+                    portDefn->nBufferCountActual = m_inp_act_buf_count;
+                    portDefn->nBufferCountMin    = OMX_CORE_NUM_INPUT_BUFFERS;
+                    portDefn->nBufferSize        = input_buffer_size;
+                    portDefn->format.audio.bFlagErrorConcealment = OMX_TRUE;
+                    portDefn->format.audio.eEncoding = OMX_AUDIO_CodingPCM;
+                    portDefn->format.audio.pNativeRender = 0;
+                } else if (1 == portDefn->nPortIndex)
+                {
+                    portDefn->eDir =  OMX_DirOutput;
+                    portDefn->bEnabled   = m_out_bEnabled;
+                    portDefn->bPopulated = m_out_bPopulated;
+                    portDefn->nBufferCountActual = m_out_act_buf_count;
+                    portDefn->nBufferCountMin    = OMX_CORE_NUM_OUTPUT_BUFFERS;
+                    portDefn->nBufferSize        = output_buffer_size;
+                    portDefn->format.audio.bFlagErrorConcealment = OMX_TRUE;
+                    portDefn->format.audio.eEncoding = OMX_AUDIO_CodingG711;
+                    portDefn->format.audio.pNativeRender = 0;
+                } else
+                {
+                    portDefn->eDir =  OMX_DirMax;
+                    OMX_LOGE("Bad Port idx %d\n",\
+                                       (int)portDefn->nPortIndex);
+                    eRet = OMX_ErrorBadPortIndex;
+                }
+                break;
+            }
+
+        case OMX_IndexParamAudioInit:
+            {
+                OMX_PORT_PARAM_TYPE *portParamType =
+                (OMX_PORT_PARAM_TYPE *) paramData;
+                OMX_LOGV("OMX_IndexParamAudioInit\n");
+
+                portParamType->nVersion.nVersion = OMX_SPEC_VERSION;
+                portParamType->nSize = (OMX_U32)sizeof(portParamType);
+                portParamType->nPorts           = 2;
+                portParamType->nStartPortNumber = 0;
+                break;
+            }
+
+        case OMX_IndexParamAudioPortFormat:
+            {
+                OMX_AUDIO_PARAM_PORTFORMATTYPE *portFormatType =
+                (OMX_AUDIO_PARAM_PORTFORMATTYPE *) paramData;
+                OMX_LOGV("OMX_IndexParamAudioPortFormat\n");
+                portFormatType->nVersion.nVersion = OMX_SPEC_VERSION;
+                portFormatType->nSize = (OMX_U32)sizeof(portFormatType);
+
+                if (OMX_CORE_INPUT_PORT_INDEX == portFormatType->nPortIndex)
+                {
+
+                    portFormatType->eEncoding = OMX_AUDIO_CodingPCM;
+                } else if (OMX_CORE_OUTPUT_PORT_INDEX == portFormatType->nPortIndex)
+                {
+                    OMX_LOGV("get_parameter: OMX_IndexParamAudioFormat: "\
+                                "%u\n", portFormatType->nIndex);
+
+                    portFormatType->eEncoding = OMX_AUDIO_CodingG711;
+                } else
+                {
+                    OMX_LOGE("get_parameter: Bad port index %d\n",
+                                      (int)portFormatType->nPortIndex);
+                    eRet = OMX_ErrorBadPortIndex;
+                }
+                break;
+            }
+        case QOMX_IndexParamAudioSessionId:
+            {
+                QOMX_AUDIO_STREAM_INFO_DATA *streaminfoparam =
+                   (QOMX_AUDIO_STREAM_INFO_DATA *) paramData;
+                streaminfoparam->sessionId = (OMX_U8)m_session_id;
+                break;
+            }
+
+        case OMX_IndexParamAudioPcm:
+            {
+                OMX_AUDIO_PARAM_PCMMODETYPE *pcmparam =
+                (OMX_AUDIO_PARAM_PCMMODETYPE *) paramData;
+
+                if (OMX_CORE_INPUT_PORT_INDEX== pcmparam->nPortIndex ||
+                        OMX_CORE_OUTPUT_PORT_INDEX== pcmparam->nPortIndex)
+                {
+                    memcpy(pcmparam,&m_pcm_param,\
+                        sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
+                    OMX_LOGV("get_parameter: Sampling rate %u",\
+                                 pcmparam->nSamplingRate);
+                    OMX_LOGV("get_parameter: Number of channels %u",\
+                                 pcmparam->nChannels);
+                } else
+                {
+                    OMX_LOGE("get_parameter:OMX_IndexParamAudioPcm "\
+                                      "OMX_ErrorBadPortIndex %d\n", \
+                                      (int)pcmparam->nPortIndex);
+                     eRet = OMX_ErrorBadPortIndex;
+                }
+                break;
+         }
+        case OMX_IndexParamComponentSuspended:
+        {
+            OMX_PARAM_SUSPENSIONTYPE *suspend =
+                (OMX_PARAM_SUSPENSIONTYPE *) paramData;
+            OMX_LOGV("get_parameter: OMX_IndexParamComponentSuspended %p\n",
+                    suspend);
+            break;
+        }
+        case OMX_IndexParamVideoInit:
+            {
+                OMX_PORT_PARAM_TYPE *portParamType =
+                    (OMX_PORT_PARAM_TYPE *) paramData;
+                OMX_LOGV("get_parameter: OMX_IndexParamVideoInit\n");
+                portParamType->nVersion.nVersion = OMX_SPEC_VERSION;
+                portParamType->nSize = (OMX_U32)sizeof(portParamType);
+                portParamType->nPorts           = 0;
+                portParamType->nStartPortNumber = 0;
+                break;
+            }
+        case OMX_IndexParamPriorityMgmt:
+            {
+                OMX_PRIORITYMGMTTYPE *priorityMgmtType =
+                        (OMX_PRIORITYMGMTTYPE*)paramData;
+                OMX_LOGV("get_parameter: OMX_IndexParamPriorityMgmt\n");
+                priorityMgmtType->nSize = (OMX_U32)sizeof(priorityMgmtType);
+                priorityMgmtType->nVersion.nVersion = OMX_SPEC_VERSION;
+                priorityMgmtType->nGroupID = m_priority_mgm.nGroupID;
+                priorityMgmtType->nGroupPriority =
+                    m_priority_mgm.nGroupPriority;
+                break;
+            }
+        case OMX_IndexParamImageInit:
+            {
+                OMX_PORT_PARAM_TYPE *portParamType =
+                (OMX_PORT_PARAM_TYPE *) paramData;
+                OMX_LOGV("get_parameter: OMX_IndexParamImageInit\n");
+                portParamType->nVersion.nVersion = OMX_SPEC_VERSION;
+                portParamType->nSize = (OMX_U32)sizeof(portParamType);
+                portParamType->nPorts           = 0;
+                portParamType->nStartPortNumber = 0;
+                break;
+            }
+
+        case OMX_IndexParamCompBufferSupplier:
+            {
+                OMX_LOGV("get_parameter: \
+                        OMX_IndexParamCompBufferSupplier\n");
+                OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplierType
+                        = (OMX_PARAM_BUFFERSUPPLIERTYPE*) paramData;
+                OMX_LOGV("get_parameter: \
+                        OMX_IndexParamCompBufferSupplier\n");
+
+                bufferSupplierType->nSize = (OMX_U32)sizeof(bufferSupplierType);
+                bufferSupplierType->nVersion.nVersion = OMX_SPEC_VERSION;
+                if (OMX_CORE_INPUT_PORT_INDEX   ==
+                        bufferSupplierType->nPortIndex)
+                {
+                    bufferSupplierType->nPortIndex =
+                            OMX_BufferSupplyUnspecified;
+                } else if (OMX_CORE_OUTPUT_PORT_INDEX ==
+                        bufferSupplierType->nPortIndex)
+                {
+                    bufferSupplierType->nPortIndex =
+                            OMX_BufferSupplyUnspecified;
+                } else
+                {
+                    OMX_LOGE("get_parameter:"\
+                                      "OMX_IndexParamCompBufferSupplier eRet"\
+                                      "%08x\n", eRet);
+                    eRet = OMX_ErrorBadPortIndex;
+                }
+                 break;
+            }
+
+            /*Component should support this port definition*/
+        case OMX_IndexParamOtherInit:
+            {
+                OMX_PORT_PARAM_TYPE *portParamType =
+                    (OMX_PORT_PARAM_TYPE *) paramData;
+                OMX_LOGV("get_parameter: OMX_IndexParamOtherInit\n");
+                portParamType->nVersion.nVersion = OMX_SPEC_VERSION;
+                portParamType->nSize = (OMX_U32)sizeof(portParamType);
+                portParamType->nPorts           = 0;
+                portParamType->nStartPortNumber = 0;
+                break;
+            }
+    case OMX_IndexParamStandardComponentRole:
+            {
+                OMX_PARAM_COMPONENTROLETYPE *componentRole;
+                componentRole = (OMX_PARAM_COMPONENTROLETYPE*)paramData;
+                componentRole->nSize = component_Role.nSize;
+                componentRole->nVersion = component_Role.nVersion;
+                strlcpy((char *)componentRole->cRole,
+                        (const char*)component_Role.cRole,
+                        sizeof(componentRole->cRole));
+                OMX_LOGE("nSize = %d , nVersion = %d, cRole = %s\n",
+                component_Role.nSize,
+                component_Role.nVersion,
+                component_Role.cRole);
+                break;
+
+            }
+        default:
+            {
+                OMX_LOGE("unknown param %08x\n", paramIndex);
+                eRet = OMX_ErrorUnsupportedIndex;
+            }
+    }
+    return eRet;
+
+}
+
+/**
+ @brief member function that set paramter from IL client
+
+ @param hComp handle to component instance
+ @param paramIndex parameter type
+ @param paramData pointer to memory space which holds the paramter
+ @return error status
+ */
+OMX_ERRORTYPE  omx_g711_aenc::set_parameter(OMX_IN OMX_HANDLETYPE     hComp,
+                                            OMX_IN OMX_INDEXTYPE paramIndex,
+                                            OMX_IN OMX_PTR        paramData)
+{
+    OMX_ERRORTYPE eRet = OMX_ErrorNone;
+
+    if(hComp == NULL)
+    {
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    if (m_state != OMX_StateLoaded)
+    {
+        OMX_LOGE("set_parameter is not in proper state\n");
+        return OMX_ErrorIncorrectStateOperation;
+    }
+    if (paramData == NULL)
+    {
+        OMX_LOGV("param data is NULL");
+        return OMX_ErrorBadParameter;
+    }
+
+    switch (paramIndex)
+    {
+        case OMX_IndexParamPortDefinition:
+            {
+                OMX_PARAM_PORTDEFINITIONTYPE *portDefn;
+                portDefn = (OMX_PARAM_PORTDEFINITIONTYPE *) paramData;
+
+                if (((m_state == OMX_StateLoaded)&&
+                     !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
+                    || (m_state == OMX_StateWaitForResources &&
+                        ((OMX_DirInput == portDefn->eDir &&
+                         m_inp_bEnabled == true)||
+                         (OMX_DirInput == portDefn->eDir &&
+                         m_out_bEnabled == true)))
+                    ||(((OMX_DirInput == portDefn->eDir &&
+                         m_inp_bEnabled == false)||
+                         (OMX_DirInput == portDefn->eDir &&
+                         m_out_bEnabled == false)) &&
+                         (m_state != OMX_StateWaitForResources)))
+                {
+                    OMX_LOGV("Set Parameter called in valid state\n");
+                } else
+                {
+                    OMX_LOGE("Set Parameter called in \
+                        Invalid State\n");
+                    return OMX_ErrorIncorrectStateOperation;
+                }
+                OMX_LOGV("OMX_IndexParamPortDefinition portDefn->nPortIndex "
+                            "= %u\n",portDefn->nPortIndex);
+                if (OMX_CORE_INPUT_PORT_INDEX == portDefn->nPortIndex)
+                {
+                    if ( portDefn->nBufferCountActual >
+                            OMX_CORE_NUM_INPUT_BUFFERS )
+                    {
+                        m_inp_act_buf_count = portDefn->nBufferCountActual;
+                    } else
+                    {
+                        m_inp_act_buf_count =OMX_CORE_NUM_INPUT_BUFFERS;
+                    }
+                    input_buffer_size = portDefn->nBufferSize;
+
+                } else if (OMX_CORE_OUTPUT_PORT_INDEX == portDefn->nPortIndex)
+                {
+                    if ( portDefn->nBufferCountActual >
+                            OMX_CORE_NUM_OUTPUT_BUFFERS )
+                    {
+                        m_out_act_buf_count = portDefn->nBufferCountActual;
+                    } else
+                    {
+                        m_out_act_buf_count =OMX_CORE_NUM_OUTPUT_BUFFERS;
+                    }
+                    output_buffer_size = portDefn->nBufferSize;
+                } else
+                {
+                    OMX_LOGV(" set_parameter: Bad Port idx %d",\
+                                  (int)portDefn->nPortIndex);
+                    eRet = OMX_ErrorBadPortIndex;
+                }
+                break;
+            }
+        case OMX_IndexParamPriorityMgmt:
+            {
+                OMX_LOGV("set_parameter: OMX_IndexParamPriorityMgmt\n");
+
+                if (m_state != OMX_StateLoaded)
+                {
+                    OMX_LOGE("Set Parameter called in \
+                        Invalid State\n");
+                    return OMX_ErrorIncorrectStateOperation;
+                }
+                OMX_PRIORITYMGMTTYPE *priorityMgmtype
+                        = (OMX_PRIORITYMGMTTYPE*) paramData;
+                OMX_LOGV("set_parameter: OMX_IndexParamPriorityMgmt %u\n",
+                        priorityMgmtype->nGroupID);
+
+                OMX_LOGV("set_parameter: priorityMgmtype %u\n",
+                        priorityMgmtype->nGroupPriority);
+
+                m_priority_mgm.nGroupID = priorityMgmtype->nGroupID;
+                m_priority_mgm.nGroupPriority = priorityMgmtype->nGroupPriority;
+
+                break;
+            }
+        case  OMX_IndexParamAudioPortFormat:
+            {
+
+                OMX_AUDIO_PARAM_PORTFORMATTYPE *portFormatType =
+                         (OMX_AUDIO_PARAM_PORTFORMATTYPE *) paramData;
+                OMX_LOGV("set_parameter: OMX_IndexParamAudioPortFormat\n");
+
+                if (OMX_CORE_INPUT_PORT_INDEX== portFormatType->nPortIndex)
+                {
+                    portFormatType->eEncoding = OMX_AUDIO_CodingPCM;
+                } else if (OMX_CORE_OUTPUT_PORT_INDEX ==
+                     portFormatType->nPortIndex)
+                {
+                    OMX_LOGV("set_parameter: OMX_IndexParamAudioFormat:"\
+                                " %u\n", portFormatType->nIndex);
+                    portFormatType->eEncoding = OMX_AUDIO_CodingG711;
+                } else
+                {
+                    OMX_LOGE("set_parameter: Bad port index %d\n", \
+                                      (int)portFormatType->nPortIndex);
+                    eRet = OMX_ErrorBadPortIndex;
+                }
+                break;
+            }
+
+
+        case OMX_IndexParamCompBufferSupplier:
+            {
+                OMX_LOGV("set_parameter: \
+                OMX_IndexParamCompBufferSupplier\n");
+                OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplierType
+                        = (OMX_PARAM_BUFFERSUPPLIERTYPE*) paramData;
+                OMX_LOGV("set_param: OMX_IndexParamCompBufferSupplier %d",\
+                            bufferSupplierType->eBufferSupplier);
+
+                if (bufferSupplierType->nPortIndex == OMX_CORE_INPUT_PORT_INDEX
+                    || bufferSupplierType->nPortIndex ==
+                    OMX_CORE_OUTPUT_PORT_INDEX)
+                {
+                    OMX_LOGV("set_parameter:\
+                            OMX_IndexParamCompBufferSupplier\n");
+                    m_buffer_supplier.eBufferSupplier =
+                            bufferSupplierType->eBufferSupplier;
+                } else
+                {
+                    OMX_LOGE("set_param:\
+                            IndexParamCompBufferSup %08x\n", eRet);
+                    eRet = OMX_ErrorBadPortIndex;
+                }
+
+                break;
+            }
+        case OMX_IndexParamAudioPcm:
+            {
+                OMX_LOGV("set_parameter: OMX_IndexParamAudioPcm\n");
+                OMX_AUDIO_PARAM_PCMMODETYPE *pcmparam
+                        = (OMX_AUDIO_PARAM_PCMMODETYPE *) paramData;
+
+                if (OMX_CORE_INPUT_PORT_INDEX== pcmparam->nPortIndex ||
+                        OMX_CORE_OUTPUT_PORT_INDEX== pcmparam->nPortIndex)
+                {
+                    memcpy(&m_pcm_param,pcmparam,\
+                        sizeof(OMX_AUDIO_PARAM_PCMMODETYPE));
+                    OMX_LOGV("set_pcm_parameter: %u %u",\
+                                 m_pcm_param.nChannels,
+                                 m_pcm_param.nSamplingRate);
+                } else
+                {
+                    OMX_LOGE("Set_parameter:OMX_IndexParamAudioPcm "
+                                      "OMX_ErrorBadPortIndex %d\n",
+                                      (int)pcmparam->nPortIndex);
+                    eRet = OMX_ErrorBadPortIndex;
+                }
+                m_g711_param = m_pcm_param;
+                break;
+            }
+        case OMX_IndexParamSuspensionPolicy:
+            {
+                eRet = OMX_ErrorNotImplemented;
+                break;
+            }
+        case OMX_IndexParamStandardComponentRole:
+            {
+                OMX_PARAM_COMPONENTROLETYPE *componentRole;
+                componentRole = (OMX_PARAM_COMPONENTROLETYPE*)paramData;
+                component_Role.nSize = componentRole->nSize;
+                component_Role.nVersion = componentRole->nVersion;
+                strlcpy((char *)component_Role.cRole,
+                       (const char*)componentRole->cRole,
+                        sizeof(component_Role.cRole));
+                break;
+            }
+
+        default:
+            {
+                OMX_LOGE("unknown param %d\n", paramIndex);
+                eRet = OMX_ErrorUnsupportedIndex;
+            }
+    }
+    return eRet;
+}
+
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::GetConfig
+
+DESCRIPTION
+  OMX Get Config Method implementation.
+
+PARAMETERS
+  <TBD>.
+
+RETURN VALUE
+  OMX Error None if successful.
+
+========================================================================== */
+OMX_ERRORTYPE  omx_g711_aenc::get_config(OMX_IN OMX_HANDLETYPE      hComp,
+                                         OMX_IN OMX_INDEXTYPE configIndex,
+                                         OMX_INOUT OMX_PTR     configData)
+{
+    OMX_ERRORTYPE eRet = OMX_ErrorNone;
+
+    if(hComp == NULL)
+    {
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    if (m_state == OMX_StateInvalid)
+    {
+        OMX_LOGE("Get Config in Invalid State\n");
+        return OMX_ErrorInvalidState;
+    }
+
+    switch (configIndex)
+    {
+        case OMX_IndexConfigAudioVolume:
+            {
+                OMX_AUDIO_CONFIG_VOLUMETYPE *volume =
+                        (OMX_AUDIO_CONFIG_VOLUMETYPE*) configData;
+
+                if (OMX_CORE_INPUT_PORT_INDEX == volume->nPortIndex)
+                {
+                    volume->nSize = (OMX_U32)sizeof(volume);
+                    volume->nVersion.nVersion = OMX_SPEC_VERSION;
+                    volume->bLinear = OMX_TRUE;
+                    volume->sVolume.nValue = m_volume;
+                    volume->sVolume.nMax   = OMX_AENC_MAX;
+                    volume->sVolume.nMin   = OMX_AENC_MIN;
+                } else
+                {
+                    eRet = OMX_ErrorBadPortIndex;
+                }
+            }
+            break;
+
+        case OMX_IndexConfigAudioMute:
+            {
+                OMX_AUDIO_CONFIG_MUTETYPE *mute =
+                        (OMX_AUDIO_CONFIG_MUTETYPE*) configData;
+
+                if (OMX_CORE_INPUT_PORT_INDEX == mute->nPortIndex)
+                {
+                    mute->nSize = (OMX_U32)sizeof(mute);
+                    mute->nVersion.nVersion = OMX_SPEC_VERSION;
+                    mute->bMute = (BITMASK_PRESENT(&m_flags,
+                                      OMX_COMPONENT_MUTED)?OMX_TRUE:OMX_FALSE);
+                } else
+                {
+                    eRet = OMX_ErrorBadPortIndex;
+                }
+            }
+            break;
+
+        default:
+            eRet = OMX_ErrorUnsupportedIndex;
+            break;
+    }
+    return eRet;
+}
+
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::SetConfig
+
+DESCRIPTION
+  OMX Set Config method implementation
+
+PARAMETERS
+  <TBD>.
+
+RETURN VALUE
+  OMX Error None if successful.
+========================================================================== */
+OMX_ERRORTYPE  omx_g711_aenc::set_config(OMX_IN OMX_HANDLETYPE      hComp,
+                                         OMX_IN OMX_INDEXTYPE configIndex,
+                                         OMX_IN OMX_PTR        configData)
+{
+    OMX_ERRORTYPE eRet = OMX_ErrorNone;
+
+    if(hComp == NULL)
+    {
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    if (m_state == OMX_StateInvalid)
+    {
+        OMX_LOGE("Set Config in Invalid State\n");
+        return OMX_ErrorInvalidState;
+    }
+    if ( m_state == OMX_StateExecuting)
+    {
+        OMX_LOGE("set_config:Ignore in Exe state\n");
+        return OMX_ErrorInvalidState;
+    }
+
+    switch (configIndex)
+    {
+        case OMX_IndexConfigAudioVolume:
+            {
+                OMX_AUDIO_CONFIG_VOLUMETYPE *vol =
+                        (OMX_AUDIO_CONFIG_VOLUMETYPE*)configData;
+                if (vol->nPortIndex == OMX_CORE_INPUT_PORT_INDEX)
+                {
+                    if ((vol->sVolume.nValue <= OMX_AENC_MAX) &&
+                        (vol->sVolume.nValue >= OMX_AENC_MIN))
+                    {
+                        m_volume = vol->sVolume.nValue;
+                        if (BITMASK_ABSENT(&m_flags, OMX_COMPONENT_MUTED))
+                        {
+                            /* ioctl(m_drv_fd, AUDIO_VOLUME,
+                            m_volume * OMX_AENC_VOLUME_STEP); */
+                        }
+
+                    } else
+                    {
+                        eRet = OMX_ErrorBadParameter;
+                    }
+                } else
+                {
+                    eRet = OMX_ErrorBadPortIndex;
+                }
+            }
+            break;
+
+        case OMX_IndexConfigAudioMute:
+            {
+                OMX_AUDIO_CONFIG_MUTETYPE *mute = (OMX_AUDIO_CONFIG_MUTETYPE*)
+                                                  configData;
+                if (mute->nPortIndex == OMX_CORE_INPUT_PORT_INDEX)
+                {
+                    if (mute->bMute == OMX_TRUE)
+                    {
+                        BITMASK_SET(&m_flags, OMX_COMPONENT_MUTED);
+                        /* ioctl(m_drv_fd, AUDIO_VOLUME, 0); */
+                    } else
+                    {
+                        BITMASK_CLEAR(&m_flags, OMX_COMPONENT_MUTED);
+                        /* ioctl(m_drv_fd, AUDIO_VOLUME,
+                        m_volume * OMX_AENC_VOLUME_STEP); */
+                    }
+                } else
+                {
+                    eRet = OMX_ErrorBadPortIndex;
+                }
+            }
+            break;
+
+        default:
+            eRet = OMX_ErrorUnsupportedIndex;
+            break;
+    }
+    return eRet;
+}
+
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::GetExtensionIndex
+
+DESCRIPTION
+  OMX GetExtensionIndex method implementaion.  <TBD>
+
+PARAMETERS
+  <TBD>.
+
+RETURN VALUE
+  OMX Error None if everything successful.
+
+========================================================================== */
+OMX_ERRORTYPE  omx_g711_aenc::get_extension_index(
+                OMX_IN OMX_HANDLETYPE      hComp,
+                OMX_IN OMX_STRING      paramName,
+                OMX_OUT OMX_INDEXTYPE* indexType)
+{
+    if((hComp == NULL) || (paramName == NULL) || (indexType == NULL))
+    {
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    if (m_state == OMX_StateInvalid)
+    {
+        OMX_LOGE("Get Extension Index in Invalid State\n");
+        return OMX_ErrorInvalidState;
+    }
+  if(strncmp(paramName,"OMX.Qualcomm.index.audio.sessionId",
+        strlen("OMX.Qualcomm.index.audio.sessionId")) == 0)
+  {
+      *indexType =(OMX_INDEXTYPE)QOMX_IndexParamAudioSessionId;
+      OMX_LOGV("Extension index type - %d\n", *indexType);
+
+  }
+  else
+  {
+      return OMX_ErrorBadParameter;
+
+  }
+  return OMX_ErrorNone;
+}
+
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::GetState
+
+DESCRIPTION
+  Returns the state information back to the caller.<TBD>
+
+PARAMETERS
+  <TBD>.
+
+RETURN VALUE
+  Error None if everything is successful.
+========================================================================== */
+OMX_ERRORTYPE  omx_g711_aenc::get_state(OMX_IN OMX_HANDLETYPE  hComp,
+                                        OMX_OUT OMX_STATETYPE* state)
+{
+    if(hComp == NULL)
+    {
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    *state = m_state;
+    OMX_LOGV("Returning the state %d\n",*state);
+    return OMX_ErrorNone;
+}
+
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::ComponentTunnelRequest
+
+DESCRIPTION
+  OMX Component Tunnel Request method implementation. <TBD>
+
+PARAMETERS
+  None.
+
+RETURN VALUE
+  OMX Error None if everything successful.
+
+========================================================================== */
+OMX_ERRORTYPE  omx_g711_aenc::component_tunnel_request
+(
+    OMX_IN OMX_HANDLETYPE                hComp,
+    OMX_IN OMX_U32                        port,
+    OMX_IN OMX_HANDLETYPE        peerComponent,
+    OMX_IN OMX_U32                    peerPort,
+    OMX_INOUT OMX_TUNNELSETUPTYPE* tunnelSetup)
+{
+    OMX_LOGE("Error: component_tunnel_request Not Implemented\n");
+
+    if((hComp == NULL) || (peerComponent == NULL) || (tunnelSetup == NULL))
+    {
+        port = port;
+        peerPort = peerPort;
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    return OMX_ErrorNotImplemented;
+}
+
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::AllocateInputBuffer
+
+DESCRIPTION
+  Helper function for allocate buffer in the input pin
+
+PARAMETERS
+  None.
+
+RETURN VALUE
+  true/false
+
+========================================================================== */
+OMX_ERRORTYPE  omx_g711_aenc::allocate_input_buffer
+(
+    OMX_IN OMX_HANDLETYPE                hComp,
+    OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
+    OMX_IN OMX_U32                        port,
+    OMX_IN OMX_PTR                     appData,
+    OMX_IN OMX_U32                       bytes)
+{
+    OMX_ERRORTYPE         eRet = OMX_ErrorNone;
+    OMX_BUFFERHEADERTYPE  *bufHdr;
+    unsigned              nBufSize = MAX(bytes, input_buffer_size);
+    char                  *buf_ptr;
+  if(m_inp_current_buf_count < m_inp_act_buf_count)
+  {
+    buf_ptr = (char *) calloc((nBufSize + \
+        sizeof(OMX_BUFFERHEADERTYPE)+sizeof(META_IN)) , 1);
+
+    if(hComp == NULL)
+    {
+        port = port;
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        free(buf_ptr);
+        return OMX_ErrorBadParameter;
+    }
+    if (buf_ptr != NULL)
+    {
+        bufHdr = (OMX_BUFFERHEADERTYPE *) buf_ptr;
+        *bufferHdr = bufHdr;
+        memset(bufHdr,0,sizeof(OMX_BUFFERHEADERTYPE));
+
+        bufHdr->pBuffer           = (OMX_U8 *)((buf_ptr) + sizeof(META_IN)+
+                                               sizeof(OMX_BUFFERHEADERTYPE));
+        bufHdr->nSize             = (OMX_U32)sizeof(OMX_BUFFERHEADERTYPE);
+        bufHdr->nVersion.nVersion = OMX_SPEC_VERSION;
+        bufHdr->nAllocLen         = nBufSize;
+        bufHdr->pAppPrivate       = appData;
+        bufHdr->nInputPortIndex   = OMX_CORE_INPUT_PORT_INDEX;
+        m_input_buf_hdrs.insert(bufHdr, NULL);
+
+        m_inp_current_buf_count++;
+        OMX_LOGV("AIB:bufHdr %p bufHdr->pBuffer %p m_inp_buf_cnt=%d \
+                bytes=%u", bufHdr, bufHdr->pBuffer,m_inp_current_buf_count,
+                bytes);
+
+    } else
+    {
+        OMX_LOGV("Input buffer memory allocation failed 1 \n");
+        eRet =  OMX_ErrorInsufficientResources;
+    }
+  }
+  else
+  {
+    OMX_LOGV("Input buffer memory allocation failed 2\n");
+    eRet =  OMX_ErrorInsufficientResources;
+  }
+    return eRet;
+}
+
+OMX_ERRORTYPE  omx_g711_aenc::allocate_output_buffer
+(
+    OMX_IN OMX_HANDLETYPE                hComp,
+    OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
+    OMX_IN OMX_U32                        port,
+    OMX_IN OMX_PTR                     appData,
+    OMX_IN OMX_U32                       bytes)
+{
+    OMX_ERRORTYPE         eRet = OMX_ErrorNone;
+    OMX_BUFFERHEADERTYPE  *bufHdr;
+    unsigned                   nBufSize = MAX(bytes,output_buffer_size);
+    char                  *buf_ptr;
+
+    if(hComp == NULL)
+    {
+        port = port;
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    if (m_out_current_buf_count < m_out_act_buf_count)
+    {
+        buf_ptr = (char *) calloc( (nBufSize + sizeof(OMX_BUFFERHEADERTYPE)),1);
+
+        if (buf_ptr != NULL)
+        {
+            bufHdr = (OMX_BUFFERHEADERTYPE *) buf_ptr;
+            *bufferHdr = bufHdr;
+            memset(bufHdr,0,sizeof(OMX_BUFFERHEADERTYPE));
+
+            bufHdr->pBuffer           = (OMX_U8 *)((buf_ptr) +
+                    sizeof(OMX_BUFFERHEADERTYPE));
+            bufHdr->nSize             = (OMX_U32)sizeof(OMX_BUFFERHEADERTYPE);
+            bufHdr->nVersion.nVersion = OMX_SPEC_VERSION;
+            bufHdr->nAllocLen         = nBufSize;
+            bufHdr->pAppPrivate       = appData;
+            bufHdr->nOutputPortIndex   = OMX_CORE_OUTPUT_PORT_INDEX;
+            m_output_buf_hdrs.insert(bufHdr, NULL);
+            m_out_current_buf_count++;
+            OMX_LOGV("AOB::bufHdr %p bufHdr->pBuffer %p m_out_buf_cnt=%d "\
+                        "bytes=%u",bufHdr, bufHdr->pBuffer,\
+                        m_out_current_buf_count, bytes);
+        } else
+        {
+            OMX_LOGV("Output buffer memory allocation failed 1 \n");
+            eRet =  OMX_ErrorInsufficientResources;
+        }
+    } else
+    {
+        OMX_LOGV("Output buffer memory allocation failed\n");
+        eRet =  OMX_ErrorInsufficientResources;
+    }
+    return eRet;
+}
+
+
+// AllocateBuffer  -- API Call
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::AllocateBuffer
+
+DESCRIPTION
+  Returns zero if all the buffers released..
+
+PARAMETERS
+  None.
+
+RETURN VALUE
+  true/false
+
+========================================================================== */
+OMX_ERRORTYPE  omx_g711_aenc::allocate_buffer
+(
+    OMX_IN OMX_HANDLETYPE                hComp,
+    OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
+    OMX_IN OMX_U32                        port,
+    OMX_IN OMX_PTR                     appData,
+    OMX_IN OMX_U32                       bytes)
+{
+
+    OMX_ERRORTYPE eRet = OMX_ErrorNone;          // OMX return type
+
+    if (m_state == OMX_StateInvalid)
+    {
+        OMX_LOGE("Allocate Buf in Invalid State\n");
+        return OMX_ErrorInvalidState;
+    }
+    // What if the client calls again.
+    if (OMX_CORE_INPUT_PORT_INDEX == port)
+    {
+        eRet = allocate_input_buffer(hComp,bufferHdr,port,appData,bytes);
+    } else if (OMX_CORE_OUTPUT_PORT_INDEX == port)
+    {
+        eRet = allocate_output_buffer(hComp,bufferHdr,port,appData,bytes);
+    } else
+    {
+        OMX_LOGE("Error: Invalid Port Index received %d\n",
+                          (int)port);
+        eRet = OMX_ErrorBadPortIndex;
+    }
+
+    if (eRet == OMX_ErrorNone)
+    {
+        OMX_LOGV("allocate_buffer:  before allocate_done \n");
+        if (allocate_done())
+        {
+            OMX_LOGV("allocate_buffer:  after allocate_done \n");
+            if (BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
+            {
+                BITMASK_CLEAR(&m_flags, OMX_COMPONENT_IDLE_PENDING);
+                post_command(OMX_CommandStateSet,OMX_StateIdle,
+                             OMX_COMPONENT_GENERATE_EVENT);
+                OMX_LOGV("allocate_buffer:  post idle transition event \n");
+            }
+            OMX_LOGV("allocate_buffer:  complete \n");
+        }
+        if (port == OMX_CORE_INPUT_PORT_INDEX && m_inp_bPopulated)
+        {
+            if (BITMASK_PRESENT(&m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING))
+            {
+                BITMASK_CLEAR((&m_flags),OMX_COMPONENT_INPUT_ENABLE_PENDING);
+                post_command(OMX_CommandPortEnable, OMX_CORE_INPUT_PORT_INDEX,
+                             OMX_COMPONENT_GENERATE_EVENT);
+            }
+        }
+        if (port == OMX_CORE_OUTPUT_PORT_INDEX && m_out_bPopulated)
+        {
+            if (BITMASK_PRESENT(&m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING))
+            {
+                BITMASK_CLEAR((&m_flags),OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
+                m_out_bEnabled = OMX_TRUE;
+
+                OMX_LOGV("AllocBuf-->is_out_th_sleep=%d\n",is_out_th_sleep);
+                pthread_mutex_lock(&m_out_th_lock_1);
+                if (is_out_th_sleep)
+                {
+                    is_out_th_sleep = false;
+                    DEBUG_DETAIL("AllocBuf:WAKING UP OUT THREADS\n");
+                    out_th_wakeup();
+                }
+                pthread_mutex_unlock(&m_out_th_lock_1);
+                pthread_mutex_lock(&m_in_th_lock_1);
+                if(is_in_th_sleep)
+                {
+                   is_in_th_sleep = false;
+                   DEBUG_DETAIL("AB:WAKING UP IN THREADS\n");
+                   in_th_wakeup();
+                }
+                pthread_mutex_unlock(&m_in_th_lock_1);
+                post_command(OMX_CommandPortEnable, OMX_CORE_OUTPUT_PORT_INDEX,
+                             OMX_COMPONENT_GENERATE_EVENT);
+            }
+        }
+    }
+    OMX_LOGV("Allocate Buffer exit with ret Code %d\n", eRet);
+    return eRet;
+}
+
+/*=============================================================================
+FUNCTION:
+  use_buffer
+
+DESCRIPTION:
+  OMX Use Buffer method implementation.
+
+INPUT/OUTPUT PARAMETERS:
+  [INOUT] bufferHdr
+  [IN] hComp
+  [IN] port
+  [IN] appData
+  [IN] bytes
+  [IN] buffer
+
+RETURN VALUE:
+  OMX_ERRORTYPE
+
+Dependency:
+  None
+
+SIDE EFFECTS:
+  None
+=============================================================================*/
+OMX_ERRORTYPE  omx_g711_aenc::use_buffer
+(
+    OMX_IN OMX_HANDLETYPE            hComp,
+    OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
+    OMX_IN OMX_U32                   port,
+    OMX_IN OMX_PTR                   appData,
+    OMX_IN OMX_U32                   bytes,
+    OMX_IN OMX_U8*                   buffer)
+{
+    OMX_ERRORTYPE eRet = OMX_ErrorNone;
+
+    if (OMX_CORE_INPUT_PORT_INDEX == port)
+    {
+        eRet = use_input_buffer(hComp,bufferHdr,port,appData,bytes,buffer);
+
+    } else if (OMX_CORE_OUTPUT_PORT_INDEX == port)
+    {
+        eRet = use_output_buffer(hComp,bufferHdr,port,appData,bytes,buffer);
+    } else
+    {
+        OMX_LOGE("Error: Invalid Port Index received %d\n",(int)port);
+        eRet = OMX_ErrorBadPortIndex;
+    }
+
+    if (eRet == OMX_ErrorNone)
+    {
+        OMX_LOGV("Checking for Output Allocate buffer Done");
+        if (allocate_done())
+        {
+            if (BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
+            {
+                BITMASK_CLEAR(&m_flags, OMX_COMPONENT_IDLE_PENDING);
+                post_command(OMX_CommandStateSet,OMX_StateIdle,
+                             OMX_COMPONENT_GENERATE_EVENT);
+            }
+        }
+        if (port == OMX_CORE_INPUT_PORT_INDEX && m_inp_bPopulated)
+        {
+            if (BITMASK_PRESENT(&m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING))
+            {
+                BITMASK_CLEAR((&m_flags),OMX_COMPONENT_INPUT_ENABLE_PENDING);
+                post_command(OMX_CommandPortEnable, OMX_CORE_INPUT_PORT_INDEX,
+                             OMX_COMPONENT_GENERATE_EVENT);
+
+            }
+        }
+        if (port == OMX_CORE_OUTPUT_PORT_INDEX && m_out_bPopulated)
+        {
+            if (BITMASK_PRESENT(&m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING))
+            {
+                BITMASK_CLEAR((&m_flags),OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
+                post_command(OMX_CommandPortEnable, OMX_CORE_OUTPUT_PORT_INDEX,
+                             OMX_COMPONENT_GENERATE_EVENT);
+                pthread_mutex_lock(&m_out_th_lock_1);
+                if (is_out_th_sleep)
+                {
+                    is_out_th_sleep = false;
+                    DEBUG_DETAIL("UseBuf:WAKING UP OUT THREADS\n");
+                    out_th_wakeup();
+                }
+                pthread_mutex_unlock(&m_out_th_lock_1);
+                pthread_mutex_lock(&m_in_th_lock_1);
+                if(is_in_th_sleep)
+                {
+                   is_in_th_sleep = false;
+                   DEBUG_DETAIL("UB:WAKING UP IN THREADS\n");
+                   in_th_wakeup();
+                }
+                pthread_mutex_unlock(&m_in_th_lock_1);
+        }
+    }
+  }
+    OMX_LOGV("Use Buffer for port[%u] eRet[%d]\n", port,eRet);
+    return eRet;
+}
+/*=============================================================================
+FUNCTION:
+  use_input_buffer
+
+DESCRIPTION:
+  Helper function for Use buffer in the input pin
+
+INPUT/OUTPUT PARAMETERS:
+  [INOUT] bufferHdr
+  [IN] hComp
+  [IN] port
+  [IN] appData
+  [IN] bytes
+  [IN] buffer
+
+RETURN VALUE:
+  OMX_ERRORTYPE
+
+Dependency:
+  None
+
+SIDE EFFECTS:
+  None
+=============================================================================*/
+OMX_ERRORTYPE  omx_g711_aenc::use_input_buffer
+(
+    OMX_IN OMX_HANDLETYPE            hComp,
+    OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
+    OMX_IN OMX_U32                   port,
+    OMX_IN OMX_PTR                   appData,
+    OMX_IN OMX_U32                   bytes,
+    OMX_IN OMX_U8*                   buffer)
+{
+    OMX_ERRORTYPE         eRet = OMX_ErrorNone;
+    OMX_BUFFERHEADERTYPE  *bufHdr;
+    unsigned              nBufSize = MAX(bytes, input_buffer_size);
+    char                  *buf_ptr;
+
+    if(hComp == NULL)
+    {
+        port = port;
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    if(bytes < input_buffer_size)
+    {
+      /* return if i\p buffer size provided by client
+       is less than min i\p buffer size supported by omx component*/
+      return OMX_ErrorInsufficientResources;
+    }
+    if (m_inp_current_buf_count < m_inp_act_buf_count)
+    {
+        buf_ptr = (char *) calloc(sizeof(OMX_BUFFERHEADERTYPE), 1);
+
+        if (buf_ptr != NULL)
+        {
+            bufHdr = (OMX_BUFFERHEADERTYPE *) buf_ptr;
+            *bufferHdr = bufHdr;
+            memset(bufHdr,0,sizeof(OMX_BUFFERHEADERTYPE));
+
+            bufHdr->pBuffer           = (OMX_U8 *)(buffer);
+            OMX_LOGV("use_input_buffer:bufHdr %p bufHdr->pBuffer %p \
+            bytes=%u", bufHdr, bufHdr->pBuffer,bytes);
+            bufHdr->nSize             = (OMX_U32)sizeof(OMX_BUFFERHEADERTYPE);
+            bufHdr->nVersion.nVersion = OMX_SPEC_VERSION;
+            bufHdr->nAllocLen         = nBufSize;
+            input_buffer_size         = nBufSize;
+            bufHdr->pAppPrivate       = appData;
+            bufHdr->nInputPortIndex   = OMX_CORE_INPUT_PORT_INDEX;
+            bufHdr->nOffset           = 0;
+            m_input_buf_hdrs.insert(bufHdr, NULL);
+            m_inp_current_buf_count++;
+        } else
+        {
+            OMX_LOGV("Input buffer memory allocation failed 1 \n");
+            eRet =  OMX_ErrorInsufficientResources;
+        }
+    } else
+    {
+        OMX_LOGV("Input buffer memory allocation failed\n");
+        eRet =  OMX_ErrorInsufficientResources;
+    }
+    return eRet;
+}
+
+/*=============================================================================
+FUNCTION:
+  use_output_buffer
+
+DESCRIPTION:
+  Helper function for Use buffer in the output pin
+
+INPUT/OUTPUT PARAMETERS:
+  [INOUT] bufferHdr
+  [IN] hComp
+  [IN] port
+  [IN] appData
+  [IN] bytes
+  [IN] buffer
+
+RETURN VALUE:
+  OMX_ERRORTYPE
+
+Dependency:
+  None
+
+SIDE EFFECTS:
+  None
+=============================================================================*/
+OMX_ERRORTYPE  omx_g711_aenc::use_output_buffer
+(
+    OMX_IN OMX_HANDLETYPE            hComp,
+    OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
+    OMX_IN OMX_U32                   port,
+    OMX_IN OMX_PTR                   appData,
+    OMX_IN OMX_U32                   bytes,
+    OMX_IN OMX_U8*                   buffer)
+{
+    OMX_ERRORTYPE         eRet = OMX_ErrorNone;
+    OMX_BUFFERHEADERTYPE  *bufHdr;
+    unsigned              nBufSize = MAX(bytes,output_buffer_size);
+    char                  *buf_ptr;
+
+    if(hComp == NULL)
+    {
+        port = port;
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    if (bytes < output_buffer_size)
+    {
+        /* return if o\p buffer size provided by client
+        is less than min o\p buffer size supported by omx component*/
+        return OMX_ErrorInsufficientResources;
+    }
+
+    OMX_LOGV("Inside omx_g711_aenc::use_output_buffer");
+    if (m_out_current_buf_count < m_out_act_buf_count)
+    {
+
+        buf_ptr = (char *) calloc(sizeof(OMX_BUFFERHEADERTYPE), 1);
+
+        if (buf_ptr != NULL)
+        {
+            bufHdr = (OMX_BUFFERHEADERTYPE *) buf_ptr;
+            OMX_LOGV("BufHdr=%p buffer=%p\n",bufHdr,buffer);
+            *bufferHdr = bufHdr;
+            memset(bufHdr,0,sizeof(OMX_BUFFERHEADERTYPE));
+
+            bufHdr->pBuffer           = (OMX_U8 *)(buffer);
+            OMX_LOGV("use_output_buffer:bufHdr %p bufHdr->pBuffer %p \
+            len=%u\n", bufHdr, bufHdr->pBuffer,bytes);
+            bufHdr->nSize             = (OMX_U32)sizeof(OMX_BUFFERHEADERTYPE);
+            bufHdr->nVersion.nVersion = OMX_SPEC_VERSION;
+            bufHdr->nAllocLen         = nBufSize;
+            output_buffer_size        = nBufSize;
+            bufHdr->pAppPrivate       = appData;
+            bufHdr->nOutputPortIndex   = OMX_CORE_OUTPUT_PORT_INDEX;
+            bufHdr->nOffset           = 0;
+            m_output_buf_hdrs.insert(bufHdr, NULL);
+            m_out_current_buf_count++;
+
+        } else
+        {
+            OMX_LOGV("Output buffer memory allocation failed\n");
+            eRet =  OMX_ErrorInsufficientResources;
+        }
+    } else
+    {
+        OMX_LOGV("Output buffer memory allocation failed 2\n");
+        eRet =  OMX_ErrorInsufficientResources;
+    }
+    return eRet;
+}
+/**
+ @brief member function that searches for caller buffer
+
+ @param buffer pointer to buffer header
+ @return bool value indicating whether buffer is found
+ */
+bool omx_g711_aenc::search_input_bufhdr(OMX_BUFFERHEADERTYPE *buffer)
+{
+
+    bool eRet = false;
+    OMX_BUFFERHEADERTYPE *temp = NULL;
+
+    //access only in IL client context
+    temp = m_input_buf_hdrs.find_ele(buffer);
+    if (buffer && temp)
+    {
+        DEBUG_DETAIL("search_input_bufhdr %p \n", buffer);
+        eRet = true;
+    }
+    return eRet;
+}
+
+/**
+ @brief member function that searches for caller buffer
+
+ @param buffer pointer to buffer header
+ @return bool value indicating whether buffer is found
+ */
+bool omx_g711_aenc::search_output_bufhdr(OMX_BUFFERHEADERTYPE *buffer)
+{
+
+    bool eRet = false;
+    OMX_BUFFERHEADERTYPE *temp = NULL;
+
+    //access only in IL client context
+    temp = m_output_buf_hdrs.find_ele(buffer);
+    if (buffer && temp)
+    {
+        DEBUG_DETAIL("search_output_bufhdr %p \n", buffer);
+        eRet = true;
+    }
+    return eRet;
+}
+
+// Free Buffer - API call
+/**
+  @brief member function that handles free buffer command from IL client
+
+  This function is a block-call function that handles IL client request to
+  freeing the buffer
+
+  @param hComp handle to component instance
+  @param port id of port which holds the buffer
+  @param buffer buffer header
+  @return Error status
+*/
+OMX_ERRORTYPE  omx_g711_aenc::free_buffer(
+                OMX_IN OMX_HANDLETYPE         hComp,
+                OMX_IN OMX_U32                 port,
+                OMX_IN OMX_BUFFERHEADERTYPE* buffer)
+{
+    OMX_ERRORTYPE eRet = OMX_ErrorNone;
+
+    OMX_LOGV("Free_Buffer buf %p\n", buffer);
+    if(hComp == NULL)
+    {
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    if (m_state == OMX_StateIdle &&
+        (BITMASK_PRESENT(&m_flags ,OMX_COMPONENT_LOADING_PENDING)))
+    {
+        OMX_LOGV(" free buffer while Component in Loading pending\n");
+    } else if ((m_inp_bEnabled == OMX_FALSE &&
+        port == OMX_CORE_INPUT_PORT_INDEX)||
+               (m_out_bEnabled == OMX_FALSE &&
+        port == OMX_CORE_OUTPUT_PORT_INDEX))
+    {
+        OMX_LOGV("Free Buffer while port %u disabled\n", port);
+    } else if (m_state == OMX_StateExecuting || m_state == OMX_StatePause)
+    {
+        OMX_LOGV("Invalid state to free buffer,ports need to be disabled:\
+                    OMX_ErrorPortUnpopulated\n");
+        post_command(OMX_EventError,
+                     OMX_ErrorPortUnpopulated,
+                     OMX_COMPONENT_GENERATE_EVENT);
+
+        return eRet;
+    } else
+    {
+        OMX_LOGV("free_buffer: Invalid state to free buffer,ports need to be\
+                    disabled:OMX_ErrorPortUnpopulated\n");
+        post_command(OMX_EventError,
+                     OMX_ErrorPortUnpopulated,
+                     OMX_COMPONENT_GENERATE_EVENT);
+    }
+    if (OMX_CORE_INPUT_PORT_INDEX == port)
+    {
+        if (m_inp_current_buf_count != 0)
+        {
+            m_inp_bPopulated = OMX_FALSE;
+            if (true == search_input_bufhdr(buffer))
+            {
+                /* Buffer exist */
+                //access only in IL client context
+                OMX_LOGV("Free_Buf:in_buffer[%p]\n",buffer);
+                m_input_buf_hdrs.erase(buffer);
+                free(buffer);
+                m_inp_current_buf_count--;
+            } else
+            {
+                OMX_LOGE("Free_Buf:Error-->free_buffer, \
+                                  Invalid Input buffer header\n");
+                eRet = OMX_ErrorBadParameter;
+            }
+        } else
+        {
+            OMX_LOGE("Error: free_buffer,Port Index calculation \
+                              came out Invalid\n");
+            eRet = OMX_ErrorBadPortIndex;
+        }
+        if (BITMASK_PRESENT((&m_flags),OMX_COMPONENT_INPUT_DISABLE_PENDING)
+            && release_done(0))
+        {
+            OMX_LOGV("INPUT PORT MOVING TO DISABLED STATE \n");
+            BITMASK_CLEAR((&m_flags),OMX_COMPONENT_INPUT_DISABLE_PENDING);
+            post_command(OMX_CommandPortDisable,
+                         OMX_CORE_INPUT_PORT_INDEX,
+                         OMX_COMPONENT_GENERATE_EVENT);
+        }
+    } else if (OMX_CORE_OUTPUT_PORT_INDEX == port)
+    {
+        if (m_out_current_buf_count != 0)
+        {
+            m_out_bPopulated = OMX_FALSE;
+            if (true == search_output_bufhdr(buffer))
+            {
+                /* Buffer exist */
+                //access only in IL client context
+                OMX_LOGV("Free_Buf:out_buffer[%p]\n",buffer);
+                m_output_buf_hdrs.erase(buffer);
+                free(buffer);
+                m_out_current_buf_count--;
+            } else
+            {
+                OMX_LOGV("Free_Buf:Error-->free_buffer , \
+                            Invalid Output buffer header\n");
+                eRet = OMX_ErrorBadParameter;
+            }
+        } else
+        {
+            eRet = OMX_ErrorBadPortIndex;
+        }
+
+        if (BITMASK_PRESENT((&m_flags),OMX_COMPONENT_OUTPUT_DISABLE_PENDING)
+            && release_done(1))
+        {
+            OMX_LOGV("OUTPUT PORT MOVING TO DISABLED STATE \n");
+            BITMASK_CLEAR((&m_flags),OMX_COMPONENT_OUTPUT_DISABLE_PENDING);
+            post_command(OMX_CommandPortDisable,
+                         OMX_CORE_OUTPUT_PORT_INDEX,
+                         OMX_COMPONENT_GENERATE_EVENT);
+
+        }
+    } else
+    {
+        eRet = OMX_ErrorBadPortIndex;
+    }
+    if ((OMX_ErrorNone == eRet) &&
+        (BITMASK_PRESENT(&m_flags ,OMX_COMPONENT_LOADING_PENDING)))
+    {
+        if (release_done(-1))
+        {
+            if(ioctl(m_drv_fd, AUDIO_STOP, 0) < 0)
+               OMX_LOGE("AUDIO STOP in free buffer failed\n");
+            else
+               OMX_LOGV("AUDIO STOP in free buffer passed\n");
+
+
+            OMX_LOGV("Free_Buf: Free buffer\n");
+
+
+            // Send the callback now
+            BITMASK_CLEAR((&m_flags),OMX_COMPONENT_LOADING_PENDING);
+            OMX_LOGV("Before OMX_StateLoaded \
+                OMX_COMPONENT_GENERATE_EVENT\n");
+            post_command(OMX_CommandStateSet,
+                         OMX_StateLoaded,OMX_COMPONENT_GENERATE_EVENT);
+            OMX_LOGV("After OMX_StateLoaded OMX_COMPONENT_GENERATE_EVENT\n");
+
+        }
+    }
+    return eRet;
+}
+
+
+/**
+ @brief member function that that handles empty this buffer command
+
+ This function meremly queue up the command and data would be consumed
+ in command server thread context
+
+ @param hComp handle to component instance
+ @param buffer pointer to buffer header
+ @return error status
+ */
+OMX_ERRORTYPE  omx_g711_aenc::empty_this_buffer(
+                OMX_IN OMX_HANDLETYPE         hComp,
+                OMX_IN OMX_BUFFERHEADERTYPE* buffer)
+{
+    OMX_ERRORTYPE eRet = OMX_ErrorNone;
+
+    OMX_LOGV("ETB:Buf:%p Len %u TS %lld numInBuf=%d\n", \
+                buffer, buffer->nFilledLen, buffer->nTimeStamp, (nNumInputBuf));
+    if (m_state == OMX_StateInvalid)
+    {
+        OMX_LOGV("Empty this buffer in Invalid State\n");
+        return OMX_ErrorInvalidState;
+    }
+    if (!m_inp_bEnabled)
+    {
+        OMX_LOGV("empty_this_buffer OMX_ErrorIncorrectStateOperation "\
+                    "Port Status %d \n", m_inp_bEnabled);
+        return OMX_ErrorIncorrectStateOperation;
+    }
+    if (buffer->nSize != sizeof(OMX_BUFFERHEADERTYPE))
+    {
+        OMX_LOGV("omx_g711_aenc::etb--> Buffer Size Invalid\n");
+        return OMX_ErrorBadParameter;
+    }
+    if (buffer->nVersion.nVersion != OMX_SPEC_VERSION)
+    {
+        OMX_LOGV("omx_g711_aenc::etb--> OMX Version Invalid\n");
+        return OMX_ErrorVersionMismatch;
+    }
+
+    if (buffer->nInputPortIndex != OMX_CORE_INPUT_PORT_INDEX)
+    {
+        return OMX_ErrorBadPortIndex;
+    }
+    if ((m_state != OMX_StateExecuting) &&
+        (m_state != OMX_StatePause))
+    {
+        OMX_LOGE("Invalid state\n");
+        eRet = OMX_ErrorInvalidState;
+    }
+    if (OMX_ErrorNone == eRet)
+    {
+        if (search_input_bufhdr(buffer) == true)
+        {
+            post_input((unsigned long)hComp,
+                       (unsigned long) buffer,OMX_COMPONENT_GENERATE_ETB);
+        } else
+        {
+            OMX_LOGE("Bad header %p \n", buffer);
+            eRet = OMX_ErrorBadParameter;
+        }
+    }
+    pthread_mutex_lock(&in_buf_count_lock);
+    nNumInputBuf++;
+    m_g711_pb_stats.etb_cnt++;
+    pthread_mutex_unlock(&in_buf_count_lock);
+    return eRet;
+}
+/**
+  @brief member function that writes data to kernel driver
+
+  @param hComp handle to component instance
+  @param buffer pointer to buffer header
+  @return error status
+ */
+OMX_ERRORTYPE  omx_g711_aenc::empty_this_buffer_proxy
+(
+    OMX_IN OMX_HANDLETYPE         hComp,
+    OMX_BUFFERHEADERTYPE* buffer)
+{
+    OMX_STATETYPE state;
+    META_IN meta_in;
+    //Pointer to the starting location of the data to be transcoded
+    OMX_U8 *srcStart;
+    //The total length of the data to be transcoded
+    srcStart = buffer->pBuffer;
+    OMX_U8 *data = NULL;
+    ssize_t bytes = 0;
+
+    PrintFrameHdr(OMX_COMPONENT_GENERATE_ETB,buffer);
+    memset(&meta_in,0,sizeof(meta_in));
+    if ( search_input_bufhdr(buffer) == false )
+    {
+        OMX_LOGV("ETBP: INVALID BUF HDR\n");
+        buffer_done_cb((OMX_BUFFERHEADERTYPE *)buffer);
+        return OMX_ErrorBadParameter;
+    }
+    if (m_tmp_meta_buf)
+    {
+        data = m_tmp_meta_buf;
+
+        // copy the metadata info from the BufHdr and insert to payload
+        meta_in.offsetVal  = (OMX_U16)sizeof(META_IN);
+        meta_in.nTimeStamp.LowPart =
+           (unsigned int)((((OMX_BUFFERHEADERTYPE*)buffer)->nTimeStamp) & 0xFFFFFFFF);
+        meta_in.nTimeStamp.HighPart =
+           (unsigned int)(((((OMX_BUFFERHEADERTYPE*)buffer)->nTimeStamp) >> 32) & 0xFFFFFFFF);
+        meta_in.nFlags &= ~OMX_BUFFERFLAG_EOS;
+        if(buffer->nFlags & OMX_BUFFERFLAG_EOS)
+        {
+            OMX_LOGV("EOS OCCURED \n");
+            meta_in.nFlags  |= OMX_BUFFERFLAG_EOS;
+        }
+        memcpy(data,&meta_in, meta_in.offsetVal);
+        OMX_LOGV("meta_in.nFlags = 0x%8x\n",meta_in.nFlags);
+    }
+
+    memcpy(&data[sizeof(META_IN)],buffer->pBuffer,buffer->nFilledLen);
+    bytes = write(m_drv_fd, data, buffer->nFilledLen+sizeof(META_IN));
+    if (bytes <= 0) {
+        frame_done_cb((OMX_BUFFERHEADERTYPE *)buffer);
+
+        if (errno == ENETRESET)
+        {
+            ALOGE("In SSR, return error to close the session");
+            m_cb.EventHandler(&m_cmp,
+                  m_app_data,
+                  OMX_EventError,
+                  OMX_ErrorHardware,
+                  0, NULL );
+        }
+        return OMX_ErrorNone;
+    }
+
+    pthread_mutex_lock(&m_state_lock);
+    get_state(&m_cmp, &state);
+    pthread_mutex_unlock(&m_state_lock);
+
+    if (OMX_StateExecuting == state)
+    {
+        DEBUG_DETAIL("In Exe state, EBD CB");
+        buffer_done_cb((OMX_BUFFERHEADERTYPE *)buffer);
+    } else
+    {
+        /* Assume empty this buffer function has already checked
+        validity of buffer */
+        OMX_LOGV("Empty buffer %p to kernel driver\n", buffer);
+        post_input((unsigned long) & hComp,(unsigned long) buffer,
+                   OMX_COMPONENT_GENERATE_BUFFER_DONE);
+    }
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE  omx_g711_aenc::fill_this_buffer_proxy
+(
+    OMX_IN OMX_HANDLETYPE         hComp,
+    OMX_BUFFERHEADERTYPE* buffer)
+{
+    OMX_STATETYPE state;
+    ENC_META_OUT *meta_out = NULL;
+    ssize_t nReadbytes = 0;
+
+    pthread_mutex_lock(&m_state_lock);
+    get_state(&m_cmp, &state);
+    pthread_mutex_unlock(&m_state_lock);
+
+    if (true == search_output_bufhdr(buffer))
+    {
+          OMX_LOGV("\nBefore Read..m_drv_fd = %d,\n",m_drv_fd);
+          nReadbytes = read(m_drv_fd,buffer->pBuffer,output_buffer_size );
+          DEBUG_DETAIL("FTBP->Al_len[%lu]buf[%p]size[%d]numOutBuf[%d]\n",\
+                         buffer->nAllocLen,buffer->pBuffer,
+                         nReadbytes,nNumOutputBuf);
+      if (nReadbytes <= 0) {
+            buffer->nFilledLen = 0;
+            buffer->nOffset = 0;
+            buffer->nTimeStamp = nTimestamp;
+            frame_done_cb((OMX_BUFFERHEADERTYPE *)buffer);
+
+            if (errno == ENETRESET)
+            {
+                ALOGE("In SSR, return error to close the session");
+                m_cb.EventHandler(&m_cmp,
+                   m_app_data,
+                   OMX_EventError,
+                   OMX_ErrorHardware,
+                   0, NULL );
+            }
+            return OMX_ErrorNone;
+      } else
+              OMX_LOGV("Read bytes %d\n",nReadbytes);
+
+      // Buffer from Driver will have
+      // 1 byte => Nr of frame field
+      // (sizeof(ENC_META_OUT) * Nr of frame) bytes => meta_out->offset_to_frame
+      // Frame Size * Nr of frame =>
+
+      meta_out = (ENC_META_OUT *)(buffer->pBuffer + sizeof(unsigned char));
+          buffer->nTimeStamp = (((OMX_TICKS)meta_out->msw_ts << 32)+
+                meta_out->lsw_ts);
+          buffer->nFlags |= meta_out->nflags;
+          buffer->nOffset = (OMX_U32) (meta_out->offset_to_frame +
+                              sizeof(unsigned char));
+          buffer->nFilledLen = (OMX_U32)(nReadbytes - buffer->nOffset);
+          nTimestamp = buffer->nTimeStamp;
+          OMX_LOGV("nflags %d frame_size %d offset_to_frame %d \
+            timestamp %lld\n", meta_out->nflags,
+            meta_out->frame_size, meta_out->offset_to_frame,
+            buffer->nTimeStamp);
+
+          if ((buffer->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS )
+          {
+              buffer->nFilledLen = 0;
+              buffer->nOffset = 0;
+              buffer->nTimeStamp = nTimestamp;
+              frame_done_cb((OMX_BUFFERHEADERTYPE *)buffer);
+              if ((buffer->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS )
+              {
+                  OMX_LOGV("FTBP: Now, Send EOS flag to Client \n");
+                  m_cb.EventHandler(&m_cmp,
+                                  m_app_data,
+                                  OMX_EventBufferFlag,
+                                  1, 1, NULL );
+              }
+
+              return OMX_ErrorNone;
+          }
+          OMX_LOGV("nState %d \n",nState );
+
+          pthread_mutex_lock(&m_state_lock);
+          get_state(&m_cmp, &state);
+          pthread_mutex_unlock(&m_state_lock);
+
+          if (state == OMX_StatePause)
+          {
+              OMX_LOGV("FTBP:Post the FBD to event thread currstate=%d\n",\
+                            state);
+              post_output((unsigned long) & hComp,(unsigned long) buffer,
+                            OMX_COMPONENT_GENERATE_FRAME_DONE);
+          }
+          else
+          {
+              frame_done_cb((OMX_BUFFERHEADERTYPE *)buffer);
+
+          }
+
+    }
+    else
+        OMX_LOGV("\n FTBP-->Invalid buffer in FTB \n");
+
+
+    return OMX_ErrorNone;
+}
+
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::FillThisBuffer
+
+DESCRIPTION
+  IL client uses this method to release the frame buffer
+  after displaying them.
+
+
+
+PARAMETERS
+
+  None.
+
+RETURN VALUE
+  true/false
+
+========================================================================== */
+OMX_ERRORTYPE  omx_g711_aenc::fill_this_buffer
+(
+    OMX_IN OMX_HANDLETYPE         hComp,
+    OMX_IN OMX_BUFFERHEADERTYPE* buffer)
+{
+    OMX_ERRORTYPE eRet = OMX_ErrorNone;
+    if (buffer->nSize != sizeof(OMX_BUFFERHEADERTYPE))
+    {
+        OMX_LOGV("omx_g711_aenc::ftb--> Buffer Size Invalid\n");
+        return OMX_ErrorBadParameter;
+    }
+    if (m_out_bEnabled == OMX_FALSE)
+    {
+        return OMX_ErrorIncorrectStateOperation;
+    }
+
+    if (buffer->nVersion.nVersion != OMX_SPEC_VERSION)
+    {
+        OMX_LOGV("omx_g711_aenc::ftb--> OMX Version Invalid\n");
+        return OMX_ErrorVersionMismatch;
+    }
+    if (buffer->nOutputPortIndex != OMX_CORE_OUTPUT_PORT_INDEX)
+    {
+        return OMX_ErrorBadPortIndex;
+    }
+    pthread_mutex_lock(&out_buf_count_lock);
+    nNumOutputBuf++;
+    m_g711_pb_stats.ftb_cnt++;
+    DEBUG_DETAIL("FTB:nNumOutputBuf is %d", nNumOutputBuf);
+    pthread_mutex_unlock(&out_buf_count_lock);
+    post_output((unsigned long)hComp,
+                (unsigned long) buffer,OMX_COMPONENT_GENERATE_FTB);
+    return eRet;
+}
+
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::SetCallbacks
+
+DESCRIPTION
+  Set the callbacks.
+
+PARAMETERS
+  None.
+
+RETURN VALUE
+  OMX Error None if everything successful.
+
+========================================================================== */
+OMX_ERRORTYPE  omx_g711_aenc::set_callbacks(
+                OMX_IN OMX_HANDLETYPE        hComp,
+                OMX_IN OMX_CALLBACKTYPE* callbacks,
+                OMX_IN OMX_PTR             appData)
+{
+    if(hComp == NULL)
+    {
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    m_cb       = *callbacks;
+    m_app_data =    appData;
+
+    return OMX_ErrorNone;
+}
+
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::ComponentDeInit
+
+DESCRIPTION
+  Destroys the component and release memory allocated to the heap.
+
+PARAMETERS
+  <TBD>.
+
+RETURN VALUE
+  OMX Error None if everything successful.
+
+========================================================================== */
+OMX_ERRORTYPE  omx_g711_aenc::component_deinit(OMX_IN OMX_HANDLETYPE hComp)
+{
+    if(hComp == NULL)
+    {
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    if (OMX_StateLoaded != m_state && OMX_StateInvalid != m_state)
+    {
+        OMX_LOGE("Warning: Rxed DeInit when not in LOADED state %d\n",
+            m_state);
+    }
+  deinit_encoder();
+
+OMX_LOGE("%s:COMPONENT DEINIT...\n", __FUNCTION__);
+  return OMX_ErrorNone;
+}
+
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::deinit_encoder
+
+DESCRIPTION
+  Closes all the threads and release memory allocated to the heap.
+
+PARAMETERS
+  None.
+
+RETURN VALUE
+  None.
+
+========================================================================== */
+void  omx_g711_aenc::deinit_encoder()
+{
+    OMX_LOGV("Component-deinit being processed\n");
+    OMX_LOGV("********************************\n");
+    OMX_LOGV("STATS: in-buf-len[%u]out-buf-len[%u] tot-pb-time[%lld]",\
+                m_g711_pb_stats.tot_in_buf_len,
+                m_g711_pb_stats.tot_out_buf_len,
+                m_g711_pb_stats.tot_pb_time);
+    OMX_LOGV("STATS: fbd-cnt[%u]ftb-cnt[%u]etb-cnt[%u]ebd-cnt[%u]",\
+                m_g711_pb_stats.fbd_cnt,m_g711_pb_stats.ftb_cnt,
+                m_g711_pb_stats.etb_cnt,
+                m_g711_pb_stats.ebd_cnt);
+   memset(&m_g711_pb_stats,0,sizeof(G711_PB_STATS));
+
+    if((OMX_StateLoaded != m_state) && (OMX_StateInvalid != m_state))
+    {
+        OMX_LOGE("%s,Deinit called in state[%d]\n",__FUNCTION__,\
+                                                                m_state);
+        // Get back any buffers from driver
+        if(pcm_input)
+            execute_omx_flush(-1,false);
+        else
+            execute_omx_flush(1,false);
+        // force state change to loaded so that all threads can be exited
+        pthread_mutex_lock(&m_state_lock);
+        m_state = OMX_StateLoaded;
+        pthread_mutex_unlock(&m_state_lock);
+        OMX_LOGE("Freeing Buf:inp_current_buf_count[%d][%d]\n",\
+        m_inp_current_buf_count,
+        m_input_buf_hdrs.size());
+        m_input_buf_hdrs.eraseall();
+        OMX_LOGE("Freeing Buf:out_current_buf_count[%d][%d]\n",\
+        m_out_current_buf_count,
+        m_output_buf_hdrs.size());
+        m_output_buf_hdrs.eraseall();
+
+    }
+    if(pcm_input)
+    {
+        pthread_mutex_lock(&m_in_th_lock_1);
+        if (is_in_th_sleep)
+        {
+            is_in_th_sleep = false;
+            DEBUG_DETAIL("Deinit:WAKING UP IN THREADS\n");
+            in_th_wakeup();
+        }
+        pthread_mutex_unlock(&m_in_th_lock_1);
+    }
+    pthread_mutex_lock(&m_out_th_lock_1);
+    if (is_out_th_sleep)
+    {
+        is_out_th_sleep = false;
+        DEBUG_DETAIL("SCP:WAKING UP OUT THREADS\n");
+        out_th_wakeup();
+    }
+    pthread_mutex_unlock(&m_out_th_lock_1);
+    if(pcm_input)
+    {
+        if (m_ipc_to_in_th != NULL)
+        {
+            omx_g711_thread_stop(m_ipc_to_in_th);
+            m_ipc_to_in_th = NULL;
+        }
+    }
+
+    if (m_ipc_to_cmd_th != NULL)
+    {
+        omx_g711_thread_stop(m_ipc_to_cmd_th);
+        m_ipc_to_cmd_th = NULL;
+    }
+    if (m_ipc_to_out_th != NULL)
+    {
+         DEBUG_DETAIL("Inside omx_g711_thread_stop\n");
+        omx_g711_thread_stop(m_ipc_to_out_th);
+        m_ipc_to_out_th = NULL;
+     }
+
+
+    if(ioctl(m_drv_fd, AUDIO_STOP, 0) <0)
+          OMX_LOGE("De-init: AUDIO_STOP FAILED\n");
+
+    if(pcm_input && m_tmp_meta_buf )
+    {
+        free(m_tmp_meta_buf);
+    }
+
+    if(m_tmp_out_meta_buf)
+    {
+        free(m_tmp_out_meta_buf);
+    }
+    nNumInputBuf = 0;
+    nNumOutputBuf = 0;
+    bFlushinprogress = 0;
+
+    m_inp_current_buf_count=0;
+    m_out_current_buf_count=0;
+    m_out_act_buf_count = 0;
+    m_inp_act_buf_count = 0;
+    m_inp_bEnabled = OMX_FALSE;
+    m_out_bEnabled = OMX_FALSE;
+    m_inp_bPopulated = OMX_FALSE;
+    m_out_bPopulated = OMX_FALSE;
+
+    if ( m_drv_fd >= 0 )
+    {
+        if(close(m_drv_fd) < 0)
+        OMX_LOGV("De-init: Driver Close Failed \n");
+        m_drv_fd = -1;
+    }
+    else
+    {
+        OMX_LOGE(" G711 device already closed\n");
+    }
+    m_comp_deinit=1;
+    m_is_out_th_sleep = 1;
+    m_is_in_th_sleep = 1;
+    OMX_LOGV("************************************\n");
+    OMX_LOGV(" DEINIT COMPLETED");
+    OMX_LOGV("************************************\n");
+
+}
+
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::UseEGLImage
+
+DESCRIPTION
+  OMX Use EGL Image method implementation <TBD>.
+
+PARAMETERS
+  <TBD>.
+
+RETURN VALUE
+  Not Implemented error.
+
+========================================================================== */
+OMX_ERRORTYPE  omx_g711_aenc::use_EGL_image
+(
+    OMX_IN OMX_HANDLETYPE                hComp,
+    OMX_INOUT OMX_BUFFERHEADERTYPE** bufferHdr,
+    OMX_IN OMX_U32                        port,
+    OMX_IN OMX_PTR                     appData,
+    OMX_IN void*                      eglImage)
+{
+    OMX_LOGE("Error : use_EGL_image:  Not Implemented \n");
+
+    if((hComp == NULL) || (appData == NULL) || (eglImage == NULL))
+    {
+        bufferHdr = bufferHdr;
+        port = port;
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    return OMX_ErrorNotImplemented;
+}
+
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::ComponentRoleEnum
+
+DESCRIPTION
+  OMX Component Role Enum method implementation.
+
+PARAMETERS
+  <TBD>.
+
+RETURN VALUE
+  OMX Error None if everything is successful.
+========================================================================== */
+OMX_ERRORTYPE  omx_g711_aenc::component_role_enum(
+                OMX_IN OMX_HANDLETYPE hComp,
+                OMX_OUT OMX_U8*        role,
+                OMX_IN OMX_U32        index)
+{
+    OMX_ERRORTYPE eRet = OMX_ErrorNone;
+    const char *cmp_role = "audio_encoder.g711";
+
+    if(hComp == NULL)
+    {
+        OMX_LOGE("Returning OMX_ErrorBadParameter\n");
+        return OMX_ErrorBadParameter;
+    }
+    if (index == 0 && role)
+    {
+        memcpy(role, cmp_role, strlen(cmp_role));
+        *(((char *) role) + strlen(cmp_role) + 1) = '\0';
+    } else
+    {
+        eRet = OMX_ErrorNoMore;
+    }
+    return eRet;
+}
+
+
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::AllocateDone
+
+DESCRIPTION
+  Checks if entire buffer pool is allocated by IL Client or not.
+  Need this to move to IDLE state.
+
+PARAMETERS
+  None.
+
+RETURN VALUE
+  true/false.
+
+========================================================================== */
+bool omx_g711_aenc::allocate_done(void)
+{
+    OMX_BOOL bRet = OMX_FALSE;
+    if (pcm_input==1)
+    {
+        if ((m_inp_act_buf_count == m_inp_current_buf_count)
+            &&(m_out_act_buf_count == m_out_current_buf_count))
+        {
+            bRet=OMX_TRUE;
+
+        }
+        if ((m_inp_act_buf_count == m_inp_current_buf_count) && m_inp_bEnabled )
+        {
+            m_inp_bPopulated = OMX_TRUE;
+        }
+
+        if ((m_out_act_buf_count == m_out_current_buf_count) && m_out_bEnabled )
+        {
+            m_out_bPopulated = OMX_TRUE;
+        }
+    } else if (pcm_input==0)
+    {
+        if (m_out_act_buf_count == m_out_current_buf_count)
+        {
+            bRet=OMX_TRUE;
+
+        }
+        if ((m_out_act_buf_count == m_out_current_buf_count) && m_out_bEnabled )
+        {
+            m_out_bPopulated = OMX_TRUE;
+        }
+
+    }
+    return bRet;
+}
+
+
+/* ======================================================================
+FUNCTION
+  omx_g711_aenc::ReleaseDone
+
+DESCRIPTION
+  Checks if IL client has released all the buffers.
+
+PARAMETERS
+  None.
+
+RETURN VALUE
+  true/false
+
+========================================================================== */
+bool omx_g711_aenc::release_done(OMX_U32 param1)
+{
+    OMX_LOGV("Inside omx_g711_aenc::release_done");
+    OMX_BOOL bRet = OMX_FALSE;
+
+    if (param1 == OMX_ALL)
+    {
+        if ((0 == m_inp_current_buf_count)&&(0 == m_out_current_buf_count))
+        {
+            bRet=OMX_TRUE;
+        }
+    } else if (param1 == OMX_CORE_INPUT_PORT_INDEX )
+    {
+        if ((0 == m_inp_current_buf_count))
+        {
+            bRet=OMX_TRUE;
+        }
+    } else if (param1 == OMX_CORE_OUTPUT_PORT_INDEX)
+    {
+        if ((0 == m_out_current_buf_count))
+        {
+            bRet=OMX_TRUE;
+        }
+    }
+    return bRet;
+}
diff --git a/mm-audio/aenc-g711/qdsp6/src/omx_log.cpp b/mm-audio/aenc-g711/qdsp6/src/omx_log.cpp
new file mode 100644
index 0000000..39498be
--- /dev/null
+++ b/mm-audio/aenc-g711/qdsp6/src/omx_log.cpp
@@ -0,0 +1,50 @@
+/*--------------------------------------------------------------------------
+Copyright (c) 2016 The Linux Foundation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of The Linux Foundation nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--------------------------------------------------------------------------*/
+
+#include <stdlib.h>
+#include <utils/Log.h>
+#include <cutils/properties.h>
+
+#include "omx_log.h"
+
+using namespace std;
+
+uint32_t gOmxLogLevel;
+
+void updateLogLevel() {
+    char level[PROPERTY_VALUE_MAX];
+#ifdef ANDROID
+    property_get("persist.debug.omx.logs.level", level, "0");
+    gOmxLogLevel = atoi(level);
+#else
+    gOmxLogLevel = atoi("0");
+#endif
+}
+
+
diff --git a/mm-audio/aenc-g711/qdsp6/test/omx_g711_enc_test.c b/mm-audio/aenc-g711/qdsp6/test/omx_g711_enc_test.c
new file mode 100644
index 0000000..54e80ea
--- /dev/null
+++ b/mm-audio/aenc-g711/qdsp6/test/omx_g711_enc_test.c
@@ -0,0 +1,1026 @@
+/*--------------------------------------------------------------------------
+Copyright (c) 2010, 2014, 2016, The Linux Foundation. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+    * Neither the name of The Linux Foundation nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+--------------------------------------------------------------------------*/
+
+
+/*
+    An Open max test application ....
+*/
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <time.h>
+#include <sys/ioctl.h>
+#include "OMX_Core.h"
+#include "OMX_Component.h"
+#include "pthread.h"
+#include <signal.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include<unistd.h>
+#include<string.h>
+#include <pthread.h>
+#include "QOMX_AudioExtensions.h"
+#include "QOMX_AudioIndexExtensions.h"
+#include <linux/ioctl.h>
+
+typedef unsigned char uint8;
+typedef unsigned char byte;
+typedef unsigned int  uint32;
+typedef unsigned int  uint16;
+
+QOMX_AUDIO_STREAM_INFO_DATA streaminfoparam;
+
+void Release_Encoder();
+
+#ifdef AUDIOV2
+unsigned short session_id;
+int device_id;
+int control = 0;
+const char *device="handset_tx";
+#define DIR_TX 2
+#endif
+
+#define MIN(A,B)    (((A) < (B))?(A):(B))
+
+FILE *F1 = NULL;
+
+uint32_t channels    = 1;
+uint32_t samplerate  = 8000;
+uint32_t pcmplayback = 0;
+uint32_t tunnel      = 0;
+uint32_t rectime     = 0;
+uint32_t encode_format        = 0;
+#define DEBUG_PRINT printf
+unsigned to_idle_transition = 0;
+
+
+/************************************************************************/
+/*                #DEFINES                            */
+/************************************************************************/
+#define false 0
+#define true 1
+
+#define CONFIG_VERSION_SIZE(param) \
+    param.nVersion.nVersion = CURRENT_OMX_SPEC_VERSION;\
+    param.nSize = sizeof(param);
+
+#define FAILED(result) (result != OMX_ErrorNone)
+
+#define SUCCEEDED(result) (result == OMX_ErrorNone)
+
+/************************************************************************/
+/*                GLOBAL DECLARATIONS                     */
+/************************************************************************/
+
+pthread_mutex_t lock;
+pthread_cond_t cond;
+pthread_mutex_t elock;
+pthread_cond_t econd;
+pthread_cond_t fcond;
+pthread_mutex_t etb_lock;
+pthread_mutex_t etb_lock1;
+pthread_cond_t etb_cond;
+FILE * inputBufferFile;
+FILE * outputBufferFile;
+OMX_PARAM_PORTDEFINITIONTYPE inputportFmt;
+OMX_PARAM_PORTDEFINITIONTYPE outputportFmt;
+OMX_AUDIO_PARAM_PCMMODETYPE pcmParams;
+OMX_PORT_PARAM_TYPE portParam;
+OMX_ERRORTYPE error;
+
+
+
+
+#define ID_RIFF 0x46464952
+#define ID_WAVE 0x45564157
+#define ID_FMT  0x20746d66
+#define ID_DATA 0x61746164
+#define ID_FACT 0x74636166
+
+#define FORMAT_PCM   0x0001
+#define FORMAT_ALAW  0x0006
+#define FORMAT_MULAW 0x0007
+
+struct wav_header {
+  uint32_t riff_id;
+  uint32_t riff_sz;
+  uint32_t riff_fmt;
+  uint32_t fmt_id;
+  uint32_t fmt_sz;
+  uint16_t audio_format;
+  uint16_t num_channels;
+  uint32_t sample_rate;
+  uint32_t byte_rate;       /* sample_rate * num_channels * bps / 8 */
+  uint16_t block_align;     /* num_channels * bps / 8 */
+  uint16_t bits_per_sample;
+  uint32_t data_id;
+  uint32_t data_sz;
+};
+
+struct __attribute__((__packed__)) g711_header {
+  uint32_t riff_id;
+  uint32_t riff_sz;
+  uint32_t riff_fmt;
+  uint32_t fmt_id;
+  uint32_t fmt_sz;
+  uint16_t audio_format;
+  uint16_t num_channels;
+  uint32_t sample_rate;
+  uint32_t byte_rate;       /* sample_rate * num_channels * bps / 8 */
+  uint16_t block_align;     /* num_channels * bps / 8 */
+  uint16_t bits_per_sample;
+  uint16_t extension_size;
+  uint32_t fact_id;
+  uint32_t fact_sz;
+  uint32_t sample_length;
+  uint32_t data_id;
+  uint32_t data_sz;
+};
+
+struct enc_meta_out{
+        unsigned int offset_to_frame;
+        unsigned int frame_size;
+        unsigned int encoded_pcm_samples;
+        unsigned int msw_ts;
+        unsigned int lsw_ts;
+        unsigned int nflags;
+} __attribute__ ((packed));
+
+static int totaldatalen = 0;
+
+static struct wav_header hdr;
+static struct g711_header g711hdr;
+/************************************************************************/
+/*                GLOBAL INIT                    */
+/************************************************************************/
+
+unsigned int input_buf_cnt = 0;
+unsigned int output_buf_cnt = 0;
+int used_ip_buf_cnt = 0;
+volatile int event_is_done = 0;
+volatile int ebd_event_is_done = 0;
+volatile int fbd_event_is_done = 0;
+volatile int etb_event_is_done = 0;
+int ebd_cnt;
+int bInputEosReached = 0;
+int bOutputEosReached = 0;
+int bInputEosReached_tunnel = 0;
+static int etb_done = 0;
+int bFlushing = false;
+int bPause    = false;
+const char *in_filename;
+const char *out_filename;
+
+int timeStampLfile = 0;
+int timestampInterval = 100;
+
+//* OMX Spec Version supported by the wrappers. Version = 1.1 */
+const OMX_U32 CURRENT_OMX_SPEC_VERSION = 0x00000101;
+OMX_COMPONENTTYPE* g711_enc_handle = 0;
+
+OMX_BUFFERHEADERTYPE  **pInputBufHdrs = NULL;
+OMX_BUFFERHEADERTYPE  **pOutputBufHdrs = NULL;
+
+/************************************************************************/
+/*                GLOBAL FUNC DECL                        */
+/************************************************************************/
+int Init_Encoder(char*);
+int Play_Encoder();
+OMX_STRING aud_comp;
+/**************************************************************************/
+/*                STATIC DECLARATIONS                       */
+/**************************************************************************/
+
+static int open_audio_file ();
+static int Read_Buffer(OMX_BUFFERHEADERTYPE  *pBufHdr );
+static OMX_ERRORTYPE Allocate_Buffer ( OMX_COMPONENTTYPE *g711_enc_handle,
+                                       OMX_BUFFERHEADERTYPE  ***pBufHdrs,
+                                       OMX_U32 nPortIndex,
+                                       unsigned int bufCntMin, unsigned int bufSize);
+
+
+static OMX_ERRORTYPE EventHandler(OMX_IN OMX_HANDLETYPE hComponent,
+                                  OMX_IN OMX_PTR pAppData,
+                                  OMX_IN OMX_EVENTTYPE eEvent,
+                                  OMX_IN OMX_U32 nData1, OMX_IN OMX_U32 nData2,
+                                  OMX_IN OMX_PTR pEventData);
+static OMX_ERRORTYPE EmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
+                                     OMX_IN OMX_PTR pAppData,
+                                     OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
+
+static OMX_ERRORTYPE FillBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
+                                     OMX_IN OMX_PTR pAppData,
+                                     OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
+static OMX_ERRORTYPE  parse_pcm_header();
+static OMX_ERRORTYPE  attach_g711_header();
+void wait_for_event(void)
+{
+    pthread_mutex_lock(&lock);
+    DEBUG_PRINT("%s: event_is_done=%d", __FUNCTION__, event_is_done);
+    while (event_is_done == 0) {
+        pthread_cond_wait(&cond, &lock);
+    }
+    event_is_done = 0;
+    pthread_mutex_unlock(&lock);
+}
+
+void event_complete(void )
+{
+    pthread_mutex_lock(&lock);
+    if (event_is_done == 0) {
+        event_is_done = 1;
+        pthread_cond_broadcast(&cond);
+    }
+    pthread_mutex_unlock(&lock);
+}
+
+void etb_wait_for_event(void)
+{
+    pthread_mutex_lock(&etb_lock1);
+    DEBUG_PRINT("%s: etb_event_is_done=%d", __FUNCTION__, etb_event_is_done);
+    while (etb_event_is_done == 0) {
+        pthread_cond_wait(&etb_cond, &etb_lock1);
+    }
+    etb_event_is_done = 0;
+    pthread_mutex_unlock(&etb_lock1);
+}
+
+void etb_event_complete(void )
+{
+    pthread_mutex_lock(&etb_lock1);
+    if (etb_event_is_done == 0) {
+        etb_event_is_done = 1;
+        pthread_cond_broadcast(&etb_cond);
+    }
+    pthread_mutex_unlock(&etb_lock1);
+}
+
+
+OMX_ERRORTYPE EventHandler(OMX_IN OMX_HANDLETYPE hComponent,
+                           OMX_IN OMX_PTR pAppData,
+                           OMX_IN OMX_EVENTTYPE eEvent,
+                           OMX_IN OMX_U32 nData1, OMX_IN OMX_U32 nData2,
+                           OMX_IN OMX_PTR pEventData)
+{
+    DEBUG_PRINT("Function %s \n", __FUNCTION__);
+    /* To remove warning for unused variable to keep prototype same */
+    (void)hComponent;
+    (void)pAppData;
+    (void)pEventData;
+
+    switch(eEvent) {
+        case OMX_EventCmdComplete:
+        DEBUG_PRINT("\n OMX_EventCmdComplete event=%d data1=%u data2=%u\n",(OMX_EVENTTYPE)eEvent,
+                                                                               nData1,nData2);
+            event_complete();
+        break;
+        case OMX_EventError:
+        DEBUG_PRINT("\n OMX_EventError \n");
+        break;
+         case OMX_EventBufferFlag:
+             DEBUG_PRINT("\n OMX_EventBufferFlag \n");
+             bOutputEosReached = true;
+             event_complete();
+             break;
+        case OMX_EventPortSettingsChanged:
+        DEBUG_PRINT("\n OMX_EventPortSettingsChanged \n");
+        break;
+        default:
+        DEBUG_PRINT("\n Unknown Event \n");
+        break;
+    }
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE FillBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
+                              OMX_IN OMX_PTR pAppData,
+                              OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
+{
+    size_t bytes_writen = 0;
+    size_t total_bytes_writen = 0;
+    size_t len = 0;
+    struct enc_meta_out *meta = NULL;
+    OMX_U8 *src = pBuffer->pBuffer;
+    unsigned int num_of_frames = 1;
+
+    /* To remove warning for unused variable to keep prototype same */
+    (void)pAppData;
+
+        if(((pBuffer->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
+            DEBUG_PRINT("FBD::EOS on output port totaldatalen %d\n ", totaldatalen);
+            bOutputEosReached = true;
+            g711hdr.data_sz = (uint32_t)totaldatalen;
+            g711hdr.sample_length = (uint32_t)totaldatalen;
+            g711hdr.riff_sz = g711hdr.data_sz + sizeof(g711hdr) - 8;
+            fseek(outputBufferFile, 0, SEEK_SET);
+            fwrite(&g711hdr,1, sizeof(g711hdr), outputBufferFile);
+            fseek(outputBufferFile, 0, SEEK_END);
+            return OMX_ErrorNone;
+        }
+        if(bInputEosReached_tunnel || bOutputEosReached)
+        {
+            DEBUG_PRINT("EOS REACHED NO MORE PROCESSING OF BUFFERS\n");
+            return OMX_ErrorNone;
+        }
+        if(num_of_frames != src[0]){
+
+            printf("Data corrupt\n");
+            return OMX_ErrorNone;
+        }
+        /* Skip the first bytes */
+
+
+
+        src += sizeof(unsigned char);
+        meta = (struct enc_meta_out *)src;
+        while (num_of_frames > 0) {
+            meta = (struct enc_meta_out *)src;
+            len = meta->frame_size;
+            bytes_writen = fwrite(pBuffer->pBuffer + sizeof(unsigned char) + meta->offset_to_frame,1,len,outputBufferFile);
+            if(bytes_writen < len)
+            {
+                DEBUG_PRINT("error: invalid g711 encoded data \n");
+                return OMX_ErrorNone;
+            }
+            src += sizeof(struct enc_meta_out);
+            num_of_frames--;
+            total_bytes_writen += len;
+        }
+        DEBUG_PRINT(" FillBufferDone size writen to file  %zu\n",total_bytes_writen);
+        totaldatalen = totaldatalen + (int)total_bytes_writen;
+
+        DEBUG_PRINT(" FBD calling FTB\n");
+        OMX_FillThisBuffer(hComponent,pBuffer);
+        return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE EmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
+                              OMX_IN OMX_PTR pAppData,
+                              OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
+{
+    int readBytes =0;
+
+    /* To remove warning for unused variable to keep prototype same */
+    (void)pAppData;
+
+    ebd_cnt++;
+    used_ip_buf_cnt--;
+    pthread_mutex_lock(&etb_lock);
+    if(!etb_done)
+    {
+        DEBUG_PRINT("\n*********************************************\n");
+        DEBUG_PRINT("Wait till first set of buffers are given to component\n");
+        DEBUG_PRINT("\n*********************************************\n");
+        etb_done++;
+        pthread_mutex_unlock(&etb_lock);
+        etb_wait_for_event();
+    }
+    else
+    {
+        pthread_mutex_unlock(&etb_lock);
+    }
+
+
+    if(bInputEosReached)
+    {
+        DEBUG_PRINT("\n*********************************************\n");
+        DEBUG_PRINT("   EBD::EOS on input port\n ");
+        DEBUG_PRINT("*********************************************\n");
+        return OMX_ErrorNone;
+    }else if (bFlushing == true) {
+      DEBUG_PRINT("omx_g711_aenc_test: bFlushing is set to TRUE used_ip_buf_cnt=%d\n",used_ip_buf_cnt);
+      if (used_ip_buf_cnt == 0) {
+        bFlushing = false;
+      } else {
+        DEBUG_PRINT("omx_g711_aenc_test: more buffer to come back used_ip_buf_cnt=%d\n",used_ip_buf_cnt);
+        return OMX_ErrorNone;
+      }
+    }
+
+    if((readBytes = Read_Buffer(pBuffer)) > 0) {
+        pBuffer->nFilledLen = (OMX_U32)readBytes;
+        used_ip_buf_cnt++;
+        OMX_EmptyThisBuffer(hComponent,pBuffer);
+    }
+    else{
+        pBuffer->nFlags |= OMX_BUFFERFLAG_EOS;
+        used_ip_buf_cnt++;
+        bInputEosReached = true;
+        pBuffer->nFilledLen = 0;
+        OMX_EmptyThisBuffer(hComponent,pBuffer);
+        DEBUG_PRINT("EBD..Either EOS or Some Error while reading file\n");
+    }
+    return OMX_ErrorNone;
+}
+
+void signal_handler(int sig_id) {
+
+  /* Flush */
+  if (sig_id == SIGUSR1) {
+    DEBUG_PRINT("%s Initiate flushing\n", __FUNCTION__);
+    bFlushing = true;
+    OMX_SendCommand(g711_enc_handle, OMX_CommandFlush, OMX_ALL, NULL);
+  } else if (sig_id == SIGUSR2) {
+    if (bPause == true) {
+      DEBUG_PRINT("%s resume playback\n", __FUNCTION__);
+      bPause = false;
+      OMX_SendCommand(g711_enc_handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
+    } else {
+      DEBUG_PRINT("%s pause playback\n", __FUNCTION__);
+      bPause = true;
+      OMX_SendCommand(g711_enc_handle, OMX_CommandStateSet, OMX_StatePause, NULL);
+    }
+  }
+}
+
+int main(int argc, char **argv)
+{
+    unsigned int bufCnt=0;
+    OMX_ERRORTYPE result;
+
+    struct sigaction sa;
+
+    memset(&sa, 0, sizeof(sa));
+    sa.sa_handler = &signal_handler;
+    sigaction(SIGABRT, &sa, NULL);
+    sigaction(SIGUSR1, &sa, NULL);
+    sigaction(SIGUSR2, &sa, NULL);
+
+   (void) signal(SIGINT, Release_Encoder);
+
+    pthread_cond_init(&cond, 0);
+    pthread_mutex_init(&lock, 0);
+    pthread_cond_init(&etb_cond, 0);
+    pthread_mutex_init(&etb_lock, 0);
+    pthread_mutex_init(&etb_lock1, 0);
+
+    if (argc >= 5) {
+      in_filename = argv[1];
+      out_filename = argv[2];
+      encode_format = (uint32_t)atoi(argv[3]);
+      tunnel  = (uint32_t)atoi(argv[4]);
+      rectime = (uint32_t)atoi(argv[5]);
+
+
+      DEBUG_PRINT("Input parameters: enocder format= %d, tunnel %d, rectime = %d\n",
+                encode_format, tunnel, rectime);
+
+    } else {
+        DEBUG_PRINT(" invalid format: \n");
+        DEBUG_PRINT("ex: ./mm-aenc-omxg711 INPUTFILE G711_OUTPUTFILE   ENCODE_FORMAT TUNNEL RECORDTIME \n");
+        DEBUG_PRINT("ENCODE formats are : G711MLAW :0 , G711ALAW: 1");
+        DEBUG_PRINT("FOR TUNNEL MOD PASS INPUT FILE AS ZERO\n");
+        DEBUG_PRINT("RECORDTIME in seconds for AST Automation ...TUNNEL MODE ONLY\n");
+        return 0;
+    }
+    if(tunnel == 0) {
+        if(encode_format == 0) {
+            aud_comp = "OMX.qcom.audio.encoder.g711mlaw";
+        }
+        else {
+            aud_comp = "OMX.qcom.audio.encoder.g711alaw";
+        }
+    } else {
+        if(encode_format == 0) {
+            aud_comp = "OMX.qcom.audio.encoder.tunneled.g711mlaw";
+        }
+        else {
+            aud_comp = "OMX.qcom.audio.encoder.tunneled.g711alaw";
+        }
+    }
+    if(Init_Encoder(aud_comp)!= 0x00)
+    {
+        DEBUG_PRINT("Decoder Init failed\n");
+        return -1;
+    }
+
+    fcntl(0, F_SETFL, O_NONBLOCK);
+
+    if(Play_Encoder() != 0x00)
+    {
+        DEBUG_PRINT("Play_Decoder failed\n");
+        return -1;
+    }
+
+    // Wait till EOS is reached...
+        if(rectime && tunnel)
+        {
+            sleep(rectime);
+            rectime = 0;
+            bInputEosReached_tunnel = 1;
+            DEBUG_PRINT("\EOS ON INPUT PORT\n");
+        }
+        else
+        {
+            wait_for_event();
+        }
+
+        if((bInputEosReached_tunnel) || ((bOutputEosReached) && !tunnel))
+        {
+
+            DEBUG_PRINT("\nMoving the decoder to idle state \n");
+            OMX_SendCommand(g711_enc_handle, OMX_CommandStateSet, OMX_StateIdle,0);
+            wait_for_event();
+            DEBUG_PRINT("\nMoving the encoder to loaded state \n");
+            OMX_SendCommand(g711_enc_handle, OMX_CommandStateSet, OMX_StateLoaded,0);
+            sleep(1);
+            if (!tunnel)
+            {
+                DEBUG_PRINT("\nFillBufferDone: Deallocating i/p buffers \n");
+                for(bufCnt=0; bufCnt < input_buf_cnt; ++bufCnt) {
+                    OMX_FreeBuffer(g711_enc_handle, 0, pInputBufHdrs[bufCnt]);
+                }
+            }
+
+            DEBUG_PRINT ("\nFillBufferDone: Deallocating o/p buffers \n");
+            for(bufCnt=0; bufCnt < output_buf_cnt; ++bufCnt) {
+                OMX_FreeBuffer(g711_enc_handle, 1, pOutputBufHdrs[bufCnt]);
+            }
+            wait_for_event();
+
+            result = OMX_FreeHandle(g711_enc_handle);
+            if (result != OMX_ErrorNone) {
+                DEBUG_PRINT ("\nOMX_FreeHandle error. Error code: %d\n", result);
+            }
+            OMX_Deinit();
+            ebd_cnt=0;
+            bOutputEosReached = false;
+            bInputEosReached_tunnel = false;
+            bInputEosReached = 0;
+            g711_enc_handle = NULL;
+            pthread_cond_destroy(&cond);
+            pthread_mutex_destroy(&lock);
+            fclose(outputBufferFile);
+            DEBUG_PRINT("*****************************************\n");
+            DEBUG_PRINT("******...G711 ENC TEST COMPLETED...***************\n");
+            DEBUG_PRINT("*****************************************\n");
+        }
+        return 0;
+}
+
+void Release_Encoder()
+{
+    static int cnt=0;
+    OMX_ERRORTYPE result;
+
+    DEBUG_PRINT("END OF G711 ENCODING: EXITING PLEASE WAIT\n");
+    bInputEosReached_tunnel = 1;
+    event_complete();
+    cnt++;
+    if(cnt > 1)
+    {
+        /* FORCE RESET  */
+        g711_enc_handle = NULL;
+        ebd_cnt=0;
+        bInputEosReached_tunnel = false;
+
+        result = OMX_FreeHandle(g711_enc_handle);
+        if (result != OMX_ErrorNone) {
+            DEBUG_PRINT ("\nOMX_FreeHandle error. Error code: %d\n", result);
+        }
+
+        /* Deinit OpenMAX */
+
+        OMX_Deinit();
+
+        pthread_cond_destroy(&cond);
+        pthread_mutex_destroy(&lock);
+            DEBUG_PRINT("*****************************************\n");
+            DEBUG_PRINT("******...G711 ENC TEST COMPLETED...***************\n");
+            DEBUG_PRINT("*****************************************\n");
+        exit(0);
+    }
+}
+
+int Init_Encoder(OMX_STRING audio_component)
+{
+    DEBUG_PRINT("Inside %s \n", __FUNCTION__);
+    OMX_ERRORTYPE omxresult;
+    OMX_U32 total = 0;
+    typedef OMX_U8* OMX_U8_PTR;
+    char *role ="audio_encoder";
+
+    static OMX_CALLBACKTYPE call_back = {
+        &EventHandler,&EmptyBufferDone,&FillBufferDone
+    };
+
+    /* Init. the OpenMAX Core */
+    DEBUG_PRINT("\nInitializing OpenMAX Core....\n");
+    omxresult = OMX_Init();
+
+    if(OMX_ErrorNone != omxresult) {
+        DEBUG_PRINT("\n Failed to Init OpenMAX core");
+          return -1;
+    }
+    else {
+        DEBUG_PRINT("\nOpenMAX Core Init Done\n");
+    }
+
+    /* Query for audio decoders*/
+    DEBUG_PRINT("G711_test: Before entering OMX_GetComponentOfRole");
+    OMX_GetComponentsOfRole(role, &total, 0);
+    DEBUG_PRINT ("\nTotal components of role=%s :%u", role, total);
+
+
+    omxresult = OMX_GetHandle((OMX_HANDLETYPE*)(&g711_enc_handle),
+                        (OMX_STRING)audio_component, NULL, &call_back);
+    if (FAILED(omxresult)) {
+        DEBUG_PRINT("\nFailed to Load the component:%s\n", audio_component);
+    return -1;
+    }
+    else
+    {
+        DEBUG_PRINT("\nComponent %s is in LOADED state\n", audio_component);
+    }
+
+    /* Get the port information */
+    CONFIG_VERSION_SIZE(portParam);
+    omxresult = OMX_GetParameter(g711_enc_handle, OMX_IndexParamAudioInit,
+                                (OMX_PTR)&portParam);
+
+    if(FAILED(omxresult)) {
+        DEBUG_PRINT("\nFailed to get Port Param\n");
+    return -1;
+    }
+    else
+    {
+        DEBUG_PRINT("\nportParam.nPorts:%u\n", portParam.nPorts);
+    DEBUG_PRINT("\nportParam.nStartPortNumber:%u\n",
+                                             portParam.nStartPortNumber);
+    }
+    return 0;
+}
+
+int Play_Encoder()
+{
+    unsigned int i;
+    int Size=0;
+    DEBUG_PRINT("Inside %s \n", __FUNCTION__);
+    OMX_ERRORTYPE ret;
+    OMX_INDEXTYPE index;
+#ifdef __LP64__
+    DEBUG_PRINT("sizeof[%ld]\n", sizeof(OMX_BUFFERHEADERTYPE));
+#else
+    DEBUG_PRINT("sizeof[%d]\n", sizeof(OMX_BUFFERHEADERTYPE));
+#endif
+
+    /* open the i/p and o/p files based on the video file format passed */
+    if(open_audio_file()) {
+        DEBUG_PRINT("\n Returning -1");
+        return -1;
+    }
+
+    /* Query the encoder input min buf requirements */
+    CONFIG_VERSION_SIZE(inputportFmt);
+
+    /* Port for which the Client needs to obtain info */
+    inputportFmt.nPortIndex = portParam.nStartPortNumber;
+
+    OMX_GetParameter(g711_enc_handle,OMX_IndexParamPortDefinition,&inputportFmt);
+    DEBUG_PRINT ("\nEnc Input Buffer Count %u\n", inputportFmt.nBufferCountMin);
+    DEBUG_PRINT ("\nEnc: Input Buffer Size %u\n", inputportFmt.nBufferSize);
+
+    if(OMX_DirInput != inputportFmt.eDir) {
+        DEBUG_PRINT ("\nEnc: Expect Input Port\n");
+        return -1;
+    }
+
+    pcmParams.nPortIndex   = 0;
+    pcmParams.nChannels    =  channels;
+    pcmParams.bInterleaved = OMX_TRUE;
+    pcmParams.nSamplingRate = samplerate;
+    OMX_SetParameter(g711_enc_handle,OMX_IndexParamAudioPcm,&pcmParams);
+
+
+    /* Query the encoder outport's min buf requirements */
+    CONFIG_VERSION_SIZE(outputportFmt);
+    /* Port for which the Client needs to obtain info */
+    outputportFmt.nPortIndex = portParam.nStartPortNumber + 1;
+
+    OMX_GetParameter(g711_enc_handle,OMX_IndexParamPortDefinition,&outputportFmt);
+    DEBUG_PRINT ("\nEnc: Output Buffer Count %u\n", outputportFmt.nBufferCountMin);
+    DEBUG_PRINT ("\nEnc: Output Buffer Size %u\n", outputportFmt.nBufferSize);
+
+    if(OMX_DirOutput != outputportFmt.eDir) {
+        DEBUG_PRINT ("\nEnc: Expect Output Port\n");
+        return -1;
+    }
+
+
+    CONFIG_VERSION_SIZE(pcmParams);
+
+
+    pcmParams.nPortIndex   =  1;
+    pcmParams.nChannels    =  channels; //Only mono is supported
+    pcmParams.nSamplingRate  =  samplerate;
+    OMX_SetParameter(g711_enc_handle,OMX_IndexParamAudioPcm,&pcmParams);
+    OMX_GetExtensionIndex(g711_enc_handle,"OMX.Qualcomm.index.audio.sessionId",&index);
+    OMX_GetParameter(g711_enc_handle,index,&streaminfoparam);
+    DEBUG_PRINT ("\nOMX_SendCommand Encoder -> IDLE\n");
+    OMX_SendCommand(g711_enc_handle, OMX_CommandStateSet, OMX_StateIdle,0);
+    /* wait_for_event(); should not wait here event complete status will
+       not come until enough buffer are allocated */
+    if (tunnel == 0)
+    {
+        input_buf_cnt = inputportFmt.nBufferCountActual; //  inputportFmt.nBufferCountMin + 5;
+        DEBUG_PRINT("Transition to Idle State succesful...\n");
+        /* Allocate buffer on decoder's i/p port */
+        error = Allocate_Buffer(g711_enc_handle, &pInputBufHdrs, inputportFmt.nPortIndex,
+                            input_buf_cnt, inputportFmt.nBufferSize);
+        if (error != OMX_ErrorNone || pInputBufHdrs == NULL) {
+            DEBUG_PRINT ("\nOMX_AllocateBuffer Input buffer error\n");
+            return -1;
+        }
+        else {
+            DEBUG_PRINT ("\nOMX_AllocateBuffer Input buffer success\n");
+        }
+    }
+    output_buf_cnt = outputportFmt.nBufferCountMin ;
+
+    /* Allocate buffer on encoder's O/Pp port */
+    error = Allocate_Buffer(g711_enc_handle, &pOutputBufHdrs, outputportFmt.nPortIndex,
+                            output_buf_cnt, outputportFmt.nBufferSize);
+    if (error != OMX_ErrorNone || pOutputBufHdrs == NULL) {
+        DEBUG_PRINT ("\nOMX_AllocateBuffer Output buffer error\n");
+        return -1;
+    }
+    else {
+        DEBUG_PRINT ("\nOMX_AllocateBuffer Output buffer success\n");
+    }
+
+    wait_for_event();
+
+    if (tunnel == 1)
+    {
+        DEBUG_PRINT ("\nOMX_SendCommand to enable TUNNEL MODE during IDLE\n");
+        OMX_SendCommand(g711_enc_handle, OMX_CommandPortDisable,0,0); // disable input port
+        wait_for_event();
+    }
+
+    DEBUG_PRINT ("\nOMX_SendCommand encoder -> Executing\n");
+    OMX_SendCommand(g711_enc_handle, OMX_CommandStateSet, OMX_StateExecuting,0);
+    wait_for_event();
+
+    DEBUG_PRINT(" Start sending OMX_FILLthisbuffer\n");
+
+    attach_g711_header();
+
+    for(i=0; i < output_buf_cnt; i++) {
+        DEBUG_PRINT ("\nOMX_FillThisBuffer on output buf no.%d\n",i);
+        pOutputBufHdrs[i]->nOutputPortIndex = 1;
+        pOutputBufHdrs[i]->nFlags = pOutputBufHdrs[i]->nFlags & (unsigned)~OMX_BUFFERFLAG_EOS;
+        ret = OMX_FillThisBuffer(g711_enc_handle, pOutputBufHdrs[i]);
+        if (OMX_ErrorNone != ret) {
+            DEBUG_PRINT("OMX_FillThisBuffer failed with result %d\n", ret);
+        }
+        else {
+            DEBUG_PRINT("OMX_FillThisBuffer success!\n");
+        }
+    }
+
+    if(tunnel == 0)
+    {
+        DEBUG_PRINT(" Start sending OMX_emptythisbuffer\n");
+        for (i = 0;i < input_buf_cnt;i++) {
+            DEBUG_PRINT ("\nOMX_EmptyThisBuffer on Input buf no.%d\n",i);
+            pInputBufHdrs[i]->nInputPortIndex = 0;
+            Size = Read_Buffer(pInputBufHdrs[i]);
+            if(Size <=0 ){
+              DEBUG_PRINT("NO DATA READ\n");
+              bInputEosReached = true;
+              pInputBufHdrs[i]->nFlags= OMX_BUFFERFLAG_EOS;
+            }
+            pInputBufHdrs[i]->nFilledLen = (OMX_U32)Size;
+            pInputBufHdrs[i]->nInputPortIndex = 0;
+            used_ip_buf_cnt++;
+            ret = OMX_EmptyThisBuffer(g711_enc_handle, pInputBufHdrs[i]);
+            if (OMX_ErrorNone != ret) {
+                DEBUG_PRINT("OMX_EmptyThisBuffer failed with result %d\n", ret);
+            }
+            else {
+                DEBUG_PRINT("OMX_EmptyThisBuffer success!\n");
+            }
+            if(Size <=0 ){
+                break;//eos reached
+            }
+        }
+        pthread_mutex_lock(&etb_lock);
+        if(etb_done)
+        {
+            DEBUG_PRINT("Component is waiting for EBD to be released.\n");
+            etb_event_complete();
+        }
+        else
+        {
+            DEBUG_PRINT("\n****************************\n");
+            DEBUG_PRINT("EBD not yet happened ...\n");
+            DEBUG_PRINT("\n****************************\n");
+            etb_done++;
+        }
+        pthread_mutex_unlock(&etb_lock);
+    }
+    return 0;
+}
+
+
+
+static OMX_ERRORTYPE Allocate_Buffer ( OMX_COMPONENTTYPE *avc_enc_handle,
+                                       OMX_BUFFERHEADERTYPE  ***pBufHdrs,
+                                       OMX_U32 nPortIndex,
+                                       unsigned int bufCntMin, unsigned int bufSize)
+{
+    DEBUG_PRINT("Inside %s \n", __FUNCTION__);
+    OMX_ERRORTYPE error=OMX_ErrorNone;
+    unsigned int bufCnt=0;
+    /* To remove warning for unused variable to keep prototype same */
+    (void)avc_enc_handle;
+
+    *pBufHdrs= (OMX_BUFFERHEADERTYPE **)
+                   malloc(sizeof(OMX_BUFFERHEADERTYPE*)*bufCntMin);
+
+    for(bufCnt=0; bufCnt < bufCntMin; ++bufCnt) {
+        DEBUG_PRINT("\n OMX_AllocateBuffer No %d \n", bufCnt);
+        error = OMX_AllocateBuffer(g711_enc_handle, &((*pBufHdrs)[bufCnt]),
+                                   nPortIndex, NULL, bufSize);
+    }
+    return error;
+}
+
+
+
+
+static int Read_Buffer (OMX_BUFFERHEADERTYPE  *pBufHdr )
+{
+    size_t bytes_read=0;
+    pBufHdr->nFilledLen = 0;
+    pBufHdr->nFlags |= OMX_BUFFERFLAG_EOS;
+
+     bytes_read = fread(pBufHdr->pBuffer, 1, pBufHdr->nAllocLen , inputBufferFile);
+
+      pBufHdr->nFilledLen = (OMX_U32)bytes_read;
+        if(bytes_read == 0)
+        {
+
+          pBufHdr->nFlags |= OMX_BUFFERFLAG_EOS;
+          DEBUG_PRINT ("\nBytes read zero\n");
+        }
+        else
+        {
+            pBufHdr->nFlags = pBufHdr->nFlags & (unsigned)~OMX_BUFFERFLAG_EOS;
+        }
+
+    return (int)bytes_read;
+}
+
+
+
+//In Encoder this Should Open a PCM or WAV file for input.
+
+static int open_audio_file ()
+{
+    int error_code = 0;
+
+    if (!tunnel)
+    {
+        DEBUG_PRINT("Inside %s filename=%s\n", __FUNCTION__, in_filename);
+        inputBufferFile = fopen (in_filename, "rb");
+        if (inputBufferFile == NULL) {
+            DEBUG_PRINT("\ni/p file %s could NOT be opened\n",
+                                         in_filename);
+        error_code = -1;
+        }
+        if(parse_pcm_header() != 0x00)
+        {
+            DEBUG_PRINT("PCM parser failed \n");
+            return -1;
+        }
+    }
+
+    DEBUG_PRINT("Inside %s filename=%s\n", __FUNCTION__, out_filename);
+    outputBufferFile = fopen (out_filename, "wb");
+    if (outputBufferFile == NULL) {
+        DEBUG_PRINT("\ni/p file %s could NOT be opened\n",
+                                         out_filename);
+        error_code = -1;
+    }
+    return error_code;
+}
+
+static OMX_ERRORTYPE attach_g711_header()
+{
+
+    memset(&g711hdr, 0, sizeof(struct g711_header));
+
+    g711hdr.riff_id = ID_RIFF;
+    g711hdr.riff_fmt = ID_WAVE;
+    g711hdr.fmt_id = ID_FMT;
+    g711hdr.fmt_sz = 18;
+
+    //change format type from wav to g711
+    if(encode_format == 0) {
+        g711hdr.audio_format = FORMAT_MULAW;
+    }
+    else {
+        g711hdr.audio_format = FORMAT_ALAW;
+    }
+
+    g711hdr.num_channels = hdr.num_channels;
+    g711hdr.sample_rate = hdr.sample_rate;
+    g711hdr.bits_per_sample = 8;
+    g711hdr.byte_rate = g711hdr.sample_rate * g711hdr.num_channels * (g711hdr.bits_per_sample / 8);
+    g711hdr.block_align = (uint16_t)((g711hdr.bits_per_sample / 8) * g711hdr.num_channels);
+    g711hdr.extension_size = 0;
+    g711hdr.fact_id = ID_FACT;
+    g711hdr.fact_sz = 4;
+    g711hdr.data_id = ID_DATA;
+    g711hdr.data_sz = 0;
+    g711hdr.riff_sz = g711hdr.data_sz + sizeof(g711hdr) - 8;
+
+    fwrite(&g711hdr,1, sizeof(g711hdr), outputBufferFile);
+
+    /*To Do : Attach Fact chunk for Non -PCM format */
+    return OMX_ErrorNone;
+}
+
+static OMX_ERRORTYPE parse_pcm_header()
+{
+
+    DEBUG_PRINT("\n***************************************************************\n");
+    if(fread(&hdr, 1, sizeof(hdr),inputBufferFile)!=sizeof(hdr))
+    {
+        DEBUG_PRINT("Wav file cannot read header\n");
+        return -1;
+    }
+
+    if ((hdr.riff_id != ID_RIFF) ||
+        (hdr.riff_fmt != ID_WAVE)||
+        (hdr.fmt_id != ID_FMT))
+    {
+        DEBUG_PRINT("Wav file is not a riff/wave file\n");
+        return -1;
+    }
+
+    if (hdr.audio_format != FORMAT_PCM)
+    {
+        DEBUG_PRINT("Wav file is not pcm format %d and fmt size is %d\n",
+                      hdr.audio_format, hdr.fmt_sz);
+        return -1;
+    }
+
+    if ((hdr.sample_rate != 8000) && (hdr.sample_rate != 16000)) {
+          DEBUG_PRINT("samplerate = %d, not supported, Supported "
+                      "samplerates are 8000, 16000", samplerate);
+        return -1;
+    }
+
+    if (hdr.num_channels != 1) {
+          DEBUG_PRINT("stereo and multi channel are not supported, channels %d"
+                      , hdr.num_channels);
+        return -1;
+    }
+
+    DEBUG_PRINT("Samplerate is %d\n", hdr.sample_rate);
+    DEBUG_PRINT("Channel Count is %d\n", hdr.num_channels);
+    DEBUG_PRINT("\n***************************************************************\n");
+
+    samplerate = hdr.sample_rate;
+    channels = hdr.num_channels;
+
+    return OMX_ErrorNone;
+}
diff --git a/mm-audio/configure.ac b/mm-audio/configure.ac
index b75d2ed..6eabd87 100644
--- a/mm-audio/configure.ac
+++ b/mm-audio/configure.ac
@@ -1,14 +1,14 @@
 #                                               -*- Autoconf -*-
 
-# configure.ac -- Autoconf script for mm-omxaudio
+# configure.ac -- Autoconf script for encoders
 #
 
 # Process this file with autoconf to produce a configure script.
 
 AC_PREREQ(2.61)
-AC_INIT([omxaudio],
+AC_INIT([encoders],
 	1.0.0)
-AM_INIT_AUTOMAKE([-Wall -Werror gnu foreign])
+AM_INIT_AUTOMAKE([foreign])
 AM_MAINTAINER_MODE
 AC_CONFIG_HEADER([config.h])
 AC_CONFIG_MACRO_DIR([m4])
@@ -21,6 +21,30 @@
 OMXAUDIO_LIBRARY_VERSION=$OMXAUDIO_MAJOR_VERSION:$OMXAUDIO_MINOR_VERSION:$OMXAUDIO_MICRO_VERSION
 AC_SUBST(OMXAUDIO_LIBRARY_VERSION)
 
+AC_ARG_WITH(sanitized-headers,
+        AS_HELP_STRING([--with-sanitized-headers=DIR],
+                [Specify the location of the sanitized Linux headers]),
+        [CPPFLAGS="$CPPFLAGS -idirafter $withval"])
+
+AC_ARG_WITH([glib],
+      AC_HELP_STRING([--with-glib],
+         [enable glib, Build against glib. Use this when building for HLOS systems which use glib]))
+
+if (test "x${with_glib}" = "xyes"); then
+        PKG_CHECK_MODULES(GTHREAD, gthread-2.0 >= 2.16, dummy=yes,
+                                AC_MSG_ERROR(GThread >= 2.16 is required))
+        PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.16, dummy=yes,
+                                AC_MSG_ERROR(GLib >= 2.16 is required))
+        GLIB_CFLAGS="$GLIB_CFLAGS $GTHREAD_CFLAGS"
+        GLIB_LIBS="$GLIB_LIBS $GTHREAD_LIBS"
+
+        AC_SUBST(GLIB_CFLAGS)
+        AC_SUBST(GLIB_LIBS)
+fi
+
+AM_CONDITIONAL(USE_GLIB, test "x${with_glib}" = "xyes")
+
+
 # Checks for programs.
 AC_PROG_CC
 AC_PROG_CPP
@@ -34,11 +58,11 @@
 
 AC_CONFIG_FILES([     \
 	Makefile \
-	adec-aac/Makefile \
-	adec-mp3/Makefile \
 	aenc-aac/Makefile \
-	adec-aac/qdsp6/Makefile \
-	adec-mp3/qdsp6/Makefile \
 	aenc-aac/qdsp6/Makefile \
+	aenc-amrnb/Makefile \
+	aenc-amrnb/qdsp6/Makefile \
+	aenc-g711/Makefile \
+	aenc-g711/qdsp6/Makefile
 	])
 AC_OUTPUT
diff --git a/policy_hal/AudioPolicyManager.cpp b/policy_hal/AudioPolicyManager.cpp
index 8bfea9a..089efc5 100644
--- a/policy_hal/AudioPolicyManager.cpp
+++ b/policy_hal/AudioPolicyManager.cpp
@@ -1405,17 +1405,34 @@
     return false;
 }
 
-bool static isDirectPCMEnabled(int bitWidth)
+bool static tryForDirectPCM(int bitWidth, audio_output_flags_t *flags)
 {
-    bool directPCMEnabled = false;
-    if (bitWidth == 24 || bitWidth == 32)
-        directPCMEnabled =
-             property_get_bool("audio.offload.pcm.24bit.enable", false);
-    else
-        directPCMEnabled =
-             property_get_bool("audio.offload.pcm.16bit.enable", false);
+    bool playerDirectPCM = false; // Output request for Track created by mediaplayer
+    bool trackDirectPCM = false;  // Output request for track created by other apps
 
-    return directPCMEnabled;
+    // Direct PCM is allowed only if
+    // In case of mediaPlayer playback
+    // 16 bit direct pcm or 24bit direct PCM property is set and
+    // the FLAG requested is DIRECT_PCM ( NuPlayer case) or
+    // In case of AudioTracks created by apps
+    // track offload is enabled and FLAG requested is FLAG_NONE.
+
+    if (*flags == AUDIO_OUTPUT_FLAG_DIRECT_PCM) {
+       if (bitWidth == 24 || bitWidth == 32)
+           playerDirectPCM =
+                property_get_bool("audio.offload.pcm.24bit.enable", false);
+       else
+           playerDirectPCM =
+                property_get_bool("audio.offload.pcm.16bit.enable", false);
+       // Reset flag to NONE so that we can still reuse direct pcm criteria check
+       // in getOutputforDevice
+       *flags = AUDIO_OUTPUT_FLAG_NONE;
+    } else if ( *flags == AUDIO_OUTPUT_FLAG_NONE) {
+        trackDirectPCM = property_get_bool("audio.offload.track.enable", true);
+    }
+
+    ALOGI("%s for Direct PCM",trackDirectPCM || playerDirectPCM?"Check":"Dont check");
+    return trackDirectPCM || playerDirectPCM;
 }
 
 status_t AudioPolicyManagerCustom::getOutputForAttr(const audio_attributes_t *attr,
@@ -1440,8 +1457,7 @@
     }
 
     if (!offloadDisabled && (offloadInfo == NULL) &&
-        isDirectPCMEnabled(bitWidth) &&
-        (flags == AUDIO_OUTPUT_FLAG_NONE)) {
+        tryForDirectPCM(bitWidth, &flags)) {
 
         tOffloadInfo.sample_rate  = samplingRate;
         tOffloadInfo.channel_mask = channelMask;
diff --git a/visualizer/offload_visualizer.c b/visualizer/offload_visualizer.c
index f49c434..ef2835a 100644
--- a/visualizer/offload_visualizer.c
+++ b/visualizer/offload_visualizer.c
@@ -896,6 +896,14 @@
         break;
 
     case VISUALIZER_CMD_MEASURE: {
+        if (pReplyData == NULL || replySize == NULL ||
+                *replySize < (sizeof(int32_t) * MEASUREMENT_COUNT)) {
+            ALOGV("%s VISUALIZER_CMD_MEASURE error *replySize %d <"
+                    "(sizeof(int32_t) * MEASUREMENT_COUNT) %d",
+                    __func__, *replySize, sizeof(int32_t) * MEASUREMENT_COUNT);
+            android_errorWriteLog(0x534e4554, "30229821");
+            return -EINVAL;
+        }
         uint16_t peak_u16 = 0;
         float sum_rms_squared = 0.0f;
         uint8_t nb_valid_meas = 0;