diff --git a/qahw_api/test/qap_wrapper_extn.c b/qahw_api/test/qap_wrapper_extn.c
index 28f34b7..36a12b0 100644
--- a/qahw_api/test/qap_wrapper_extn.c
+++ b/qahw_api/test/qap_wrapper_extn.c
@@ -1342,8 +1342,7 @@
             }
             ALOGV("%s %d feeding Input of size %d  and bytes_cosumed is %d",
                       __FUNCTION__, __LINE__,bytes_read, bytes_consumed);
-            if ((format == QAP_AUDIO_FORMAT_DTS) ||
-                 (format == QAP_AUDIO_FORMAT_DTS_HD)) {
+            if (stream_info->filetype == FILE_DTS) {
                   if (bytes_consumed < 0) {
                       while (!is_buffer_available) {
                           usleep(1000);
@@ -1428,7 +1427,10 @@
     input_config->channels = stream_info->channels;
     input_config->bit_width = stream_info->config.offload_info.bit_width;
 
-    stream_info->bytes_to_read = 1024;
+    if (stream_info->filetype == FILE_DTS)
+        stream_info->bytes_to_read = 10*1024;
+    else
+        stream_info->bytes_to_read = 1024;
     input_streams_count++;
     if (input_streams_count == 2) {
         if (stream_info->filetype == FILE_WAV) {
