tests/tunnel_test.c - platform/hardware/knowles/athletico/sound_trigger_hal - Git at Google

 /*
  * Copyright (C) 2018 Knowles Electronics
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <signal.h>
 #include <stdbool.h>
 #include <time.h>
 #include <errno.h>
 #include <unistd.h>

 #define LOG_TAG "ia_tunneling_hal_test"

 #include <log/log.h>
 #include "tunnel.h"
 #include "conversion_routines.h"
 #include <linux/mfd/adnc/iaxxx-system-identifiers.h>
 #include <linux/mfd/adnc/iaxxx-tunnel-intf.h>


 #define MAX_TUNNELS 32
 #define BUF_SIZE 32768
 #define MAX_FILE_PATH 256

 #define DEFAULT_PATH                "/data/data"
 #define FILE_PREFIX                 "/tnl_op"
 #define UNPARSED_OUTPUT_FILE        "/unparsed_output"

 struct raf_format_type {
     uint16_t frameSizeInBytes; /*!< Frame length in bytes */
     uint8_t encoding;   /*!< Encoding */
     uint8_t sampleRate; /*!< Sample rate */
 };

 struct raf_frame_type {
     uint64_t timeStamp; /*!< Timestamp of the frame */
     uint32_t seqNo;     /*!< Optional sequence number of the frame */

     struct raf_format_type format; /*!< Format information for the frame */
     uint32_t data[0];   /*!< Start of the variable size payload.
                            It must start at 128 bit aligned address for all the frames */
 };

 volatile int capturing = 1;

 void sigint_handler(int sig __unused) {
     ALOGE("Interrupted, setting the exit condition");
     capturing = 0;
 }


 void parse_audio_tunnel_data(FILE *out_fp, unsigned char *buf_itr, int frame_sz_in_bytes) {
     char q16_buf[BUF_SIZE]; // This can be smaller but by how much?
     int frameSizeInWords = (frame_sz_in_bytes + 3) >> 2;

     if (NULL == buf_itr || NULL == out_fp) {
         ALOGE("%s: Buffer or file pointer is NULL", __func__);
         return;
     }

     kst_float_to_q15_vector(q16_buf, buf_itr, frameSizeInWords);

     fwrite(q16_buf, (frameSizeInWords * 2), 1, out_fp);
     fflush(out_fp);
 }

 int main(int argc, char *argv[]) {
     struct ia_tunneling_hal *thdl = NULL;
     int err = 0;
     FILE *out_fp[MAX_TUNNELS] = { NULL };
     FILE *unp_out_fp = NULL;
     int bytes_avail = 0, bytes_rem = 0;
     int bytes_read = 0;
     void *buf = NULL;
     // The magic number is ROME in ASCII reversed. So we are looking for EMOR in the byte stream
     const unsigned char magic_num[4]  = {0x45, 0x4D, 0x4F, 0x52};
     int i = 0;
     bool valid_frame = true;
     char filepath[MAX_FILE_PATH];
     char filename[MAX_FILE_PATH];
     int num_of_tunnels = 0;
     int num_tunnel_params;
     float timer_signal = 0;
     timer_t timer_id;
     int tunnel_src[MAX_TUNNELS] = { 0 };
     int tunnel_mode[MAX_TUNNELS] = { 0 };
     int tunnel_encode[MAX_TUNNELS];
     int lastSeqNum[MAX_TUNNELS] = { 0 };
     int notFirstFrame[MAX_TUNNELS] = { 0 };
     int frameDropCount[MAX_TUNNELS] = { 0 };
     uint64_t tunnel_time_stamps[MAX_TUNNELS] = { 0 };
     unsigned char *frame_start, *buf_itr;
     // Minimum bytes required is the magic number + tunnel id + reserved and crc + raf struct
     int min_bytes_req = 4 + 2 + 6 + sizeof(struct raf_frame_type);
     int instance;

     if (argc < 5) {
         ALOGE("USAGE: %s <instance number> <Number of tunnels> <Time in seconds> <Source End pt 1> <tnl mode> <encode fmt> <Source End pt 2> <tnl mode> <encode fmt>... <output path>", argv[0]);
         return -EINVAL;
     }

     instance = strtol(argv[1], NULL, 0);
     ALOGD("instance %d", instance);

     num_of_tunnels = strtol(argv[2], NULL, 0);
     ALOGD("Number of tunnels %d", num_of_tunnels);

     timer_signal = strtof(argv[3], NULL);
     ALOGD("tunnel out timer based req %f", timer_signal);
     err = timer_create(CLOCK_MONOTONIC, NULL, &timer_id);
     if (err != 0) {
         ALOGE("Couldn't create timer: %s", strerror(errno));
         return -EINVAL;
     }

     num_tunnel_params = num_of_tunnels * 3 + 4;
 #ifdef FILENAME_ASSIGN
     char filename_str_format[256] = {0};
     bool is_specified_name = false;
     bool is_specified_path= false;
     for (int i = 0; i < argc ; i++) {
         if (strncmp(argv[i], "-f", sizeof(char)*2) == 0) {
             if ((i+1) < argc) {
                 snprintf(filename_str_format, sizeof(filename_str_format), "%s", argv[i+1]);
                 ALOGE("specify a output file name %s, argc i = %d, argv[%d] = %s", filename_str_format, i, i+1, argv[i+1]);
                 is_specified_name = true;
             }
         }
         if (strncmp(argv[i], "-p", sizeof(char)*2) == 0) {
             if ((i+1) < argc) {
                 snprintf(filepath, sizeof(filepath), "%s", argv[i+1]);
                 ALOGE("specify a output file path %s, argc i = %d, argv[%d] = %s", filepath, i, i+1, argv[i+1]);
                 is_specified_path = true;
             }
         }
     }

     if (is_specified_name || is_specified_path) {
         int spec_number = 2 * ((int) is_specified_name + (int) is_specified_path);

         if (argc != (num_tunnel_params + spec_number)) {
             ALOGE("USAGE: %s <instance number> <Number of tunnels> <Sync Tunnel req> <Source End pt 1> <tnl mode> <encode fmt> <Source End pt 2> <tnl mode> <encode fmt>... [-f filename] [-p filepath]", argv[0]);
             return -EINVAL;
         }
         else {
             ALOGE("is_specified_name = TRUE");
         }
     } else {
         if (argc != num_tunnel_params && argc != num_tunnel_params + 1) {
             ALOGE("USAGE: %s <instance number> <Number of tunnels> <Sync Tunnel req> <Source End pt 1> <tnl mode> <encode fmt> <Source End pt 2> <tnl mode> <encode fmt>...", argv[0]);
             return -EINVAL;
         }
     }
 #else
     if (argc != num_tunnel_params && argc != num_tunnel_params + 1) {
         ALOGE("USAGE: %s <instance number> <Number of tunnels> <Sync Tunnel req> <Source End pt 1> <tnl mode> <encode fmt> <Source End pt 2> <tnl mode> <encode fmt>...", argv[0]);
         return -EINVAL;
     }
 #endif /* FILENAME_ASSIGN */


     for (i = 0; i < num_of_tunnels; i++) {
         tunnel_src[i] = strtol(argv[i*3+4], NULL, 0);
         tunnel_mode[i] = strtol(argv[i*3+5], NULL, 0);
         tunnel_encode[i] = strtol(argv[i*3+6], NULL, 0);
         ALOGD("Tunnel source 0x%x Tunnel mode %d Tunnel encode %d", tunnel_src[i], tunnel_mode[i], tunnel_encode[i]);
     }

 #ifdef FILENAME_ASSIGN
     if (!is_specified_path) {
         strcpy(filepath, DEFAULT_PATH);
     }
 #else
     if (argc == num_tunnel_params) {
         strcpy(filepath, DEFAULT_PATH);
     } else {
         strcpy(filepath, argv[argc-1]);
     }
 #endif
     ALOGE("Output path %s", filepath);

     thdl = ia_start_tunneling(0);
     if (NULL == thdl) {
         ALOGE("Failed to start tunneling");
         goto exit;
     }

     for (i = 0; i < num_of_tunnels; i++) {
         err = ia_enable_tunneling_source(thdl, tunnel_src[i], tunnel_mode[i], tunnel_encode[i]);
         if (0 != err) {
             ALOGE("Failed to enable tunneling for src_id %u mode %u encode %u", tunnel_src[i], tunnel_mode[i], tunnel_encode[i]);
             goto exit;
         }
     }

     buf = malloc(BUF_SIZE * 2);
     if (NULL == buf) {
         ALOGE("Failed to allocate memory to read buffer");
         goto exit;
     }

     snprintf(filename, MAX_FILE_PATH, "%s%s", filepath, UNPARSED_OUTPUT_FILE);
     unp_out_fp = fopen(filename, "wb");
     if (NULL == unp_out_fp) {
         ALOGE("Failed to open the file %s", filename);
         goto exit;
     }

     signal(SIGINT, sigint_handler);

     if (num_of_tunnels && timer_signal) {
         struct itimerspec timer_spec;
         uint64_t timer_ns = timer_signal * NS_PER_SEC;

         signal(SIGALRM, sigint_handler);

         memset(&timer_spec, 0, sizeof(timer_spec));
         timer_spec.it_value.tv_sec = timer_ns / NS_PER_SEC;
         timer_spec.it_value.tv_nsec = timer_ns % NS_PER_SEC;
         timer_settime(timer_id, 0, &timer_spec, NULL);
         ALOGD("timer_settime %ld %ld",
               timer_spec.it_value.tv_sec,
               timer_spec.it_value.tv_nsec);
     }

     unsigned short int tunnel_id;
     unsigned short int tunl_src;
     while (1) {
 read_again:
         if (0 == capturing) {
             ALOGE("Time to bail from here");
             break;
         }

         if (0 != bytes_avail) {
             if (bytes_avail < 0) {
                 bytes_rem = 0;
             } else {
                 bytes_rem = bytes_avail;
                 ALOGD("bytes_avail is %d", bytes_rem);
                 memcpy(buf, buf_itr, bytes_rem);
             }
         } else {
             bytes_rem = 0;
         }

         // Ensure that we read BUF_SIZE always otherwise the kernel read will hang
         bytes_avail = ia_read_tunnel_data (thdl,
                                            (void *)((unsigned char *)buf + bytes_rem),
                                            BUF_SIZE);
         if (bytes_avail <= 0) {
             ALOGE("Failed to read data from the tunnel :%d", bytes_avail);
             break;
         }

         fwrite((void *)((unsigned char *)buf + bytes_rem), bytes_avail, 1, unp_out_fp);
         fflush(unp_out_fp);

         bytes_avail += bytes_rem; // update the available bytes with the previous reminder if any
         ALOGD("bytes_avail is after read %d", bytes_avail);
         buf_itr = (unsigned char *)buf;

         do {
             // Check for MagicNumber 0x454D4F52
             if (buf_itr[0] != magic_num[0] || buf_itr[1] != magic_num[1] ||
                     buf_itr[2] != magic_num[2] || buf_itr[3] != magic_num[3]) {
                   ALOGE("Could not find the magic number, reading again");
                   ALOGE("buf_itr[0] %x buf_itr[1] %x buf_itr[2] %x buf_itr[3] %x ",
                             buf_itr[0], buf_itr[1], buf_itr[2], buf_itr[3]);
                   goto exit;
             }
             ALOGD("bytes_avail is after magic %d: prev :%d", bytes_avail, bytes_avail + 540);
             // Bookmark the start of the frame
             frame_start = buf_itr;

             // Skip the magic number
             buf_itr += 4;
             bytes_avail -= 4;

             // Read the tunnelID
             tunnel_id = ((unsigned char) (buf_itr[0]) |
                          (unsigned char) (buf_itr[1]) << 8);

             // Skip tunnelID
             buf_itr += 2;
             bytes_avail -= 2;

             tunl_src = ((unsigned char) (buf_itr[0]) |
                          (unsigned char) (buf_itr[1]) << 8);

             // Skip src id field and CRC - 6 bytes in total
             buf_itr += 6;
             bytes_avail -= 6;

             valid_frame = true;
             if (tunnel_id > MAX_TUNNELS) {
                 ALOGE("Invalid tunnel id %d", tunnel_id);
                 valid_frame = false;
             }

             struct raf_frame_type rft;
             memcpy(&rft, buf_itr, sizeof(struct raf_frame_type));
             if (true == valid_frame) {
                 if (NULL == out_fp[tunnel_id]) {
 #ifdef FILENAME_ASSIGN
                     if (is_specified_name) {
                         snprintf(filename, 256, "%s/%s", filepath, filename_str_format);
                     } else if (TNL_ENC_OPAQUE == rft.format.encoding) {
 #else
                     if (TNL_ENC_OPAQUE == rft.format.encoding) {
 #endif /* FILENAME_ASSIGN */
                         snprintf(filename, MAX_FILE_PATH, "%s%sid%d-src0x%x-enc0x%x_client%d.raw", filepath, FILE_PREFIX, tunnel_id, tunl_src, rft.format.encoding, instance);
                     } else {
                         snprintf(filename, MAX_FILE_PATH, "%s%sid%d-src0x%x-enc0x%x_client%d.pcm", filepath, FILE_PREFIX, tunnel_id, tunl_src, rft.format.encoding, instance);
                     }
                     // Open the file to dump
                     out_fp[tunnel_id] = fopen(filename, "wb");
                     if (NULL == out_fp[tunnel_id]) {
                         ALOGE("ERROR: Failed to open the file %s", filename);
                         goto exit;
                     }
                 }
             }

             ALOGD("Tunnel id %d timestamp %llu", tunnel_id, rft.timeStamp);
             tunnel_time_stamps[tunnel_id] = rft.timeStamp;

             // Skip the raf_frame_type
             buf_itr += sizeof(struct raf_frame_type);
             bytes_avail -= sizeof(struct raf_frame_type);

             if (bytes_avail < rft.format.frameSizeInBytes) {
                 ALOGD("Incomplete frame received bytes_avail %d framesize %d", bytes_avail, rft.format.frameSizeInBytes);
                 buf_itr = frame_start;
                 bytes_avail += min_bytes_req;
                 goto read_again;
             }

             if (true == valid_frame) {
                 ALOGD("@@@Tunnel id %d encoding %d", tunnel_id, rft.format.encoding);
                 if (TNL_ENC_AFLOAT == rft.format.encoding) {
                     parse_audio_tunnel_data(out_fp[tunnel_id], buf_itr, rft.format.frameSizeInBytes);
                 } else {
                     fwrite(buf_itr, rft.format.frameSizeInBytes, 1, out_fp[tunnel_id]);
                 }
             }

             /* Calculate the frame drop count */
             if (notFirstFrame[tunnel_id]) {
                    frameDropCount[tunnel_id] += (rft.seqNo - lastSeqNum[tunnel_id] - 1);
             }
             lastSeqNum[tunnel_id] = rft.seqNo;
             notFirstFrame[tunnel_id] = 1;
             // Skip the data
             buf_itr += rft.format.frameSizeInBytes;
             bytes_avail -= rft.format.frameSizeInBytes;
             /* For debugging the tunnel read errors or wrong magic numbers or bus errors*/
             bytes_read += rft.format.frameSizeInBytes + min_bytes_req;
         } while (bytes_avail > min_bytes_req);
     }

 exit:
     for (i = 0; i < MAX_TUNNELS; i++) {
         if (notFirstFrame[i]) {
             ALOGE("drop count tunnel id %u: %u", i, frameDropCount[i]);
         }
     }
     ALOGE("bytes_read so far %d", bytes_read);
     if (buf) {
         free(buf);
         buf = NULL;
     }

     if (unp_out_fp) {
         fflush(unp_out_fp);
         fclose(unp_out_fp);
     }

     for (i = 0; i < MAX_TUNNELS; i++) {
         if (out_fp[i]) {
             fflush(out_fp[i]);
             fclose(out_fp[i]);
         }
     }

     for (i = 0; i < num_of_tunnels; i++) {
         err = ia_disable_tunneling_source(thdl, tunnel_src[i], tunnel_mode[i], tunnel_encode[i]);
         if (0 != err) {
             ALOGE("Failed to disable tunneling for tunl_id %u src_id %u", i, tunnel_src[i]);
         }
     }

     err = ia_stop_tunneling(thdl);
     if (0 != err) {
         ALOGE("Failed to stop tunneling");
     }

     timer_delete(timer_id);

     return 0;
 }
	/*
	* Copyright (C) 2018 Knowles Electronics
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <signal.h>
	#include <stdbool.h>
	#include <time.h>
	#include <errno.h>
	#include <unistd.h>

	#define LOG_TAG "ia_tunneling_hal_test"

	#include <log/log.h>
	#include "tunnel.h"
	#include "conversion_routines.h"
	#include <linux/mfd/adnc/iaxxx-system-identifiers.h>
	#include <linux/mfd/adnc/iaxxx-tunnel-intf.h>



	#define MAX_TUNNELS 32
	#define BUF_SIZE 32768
	#define MAX_FILE_PATH 256

	#define DEFAULT_PATH "/data/data"
	#define FILE_PREFIX "/tnl_op"
	#define UNPARSED_OUTPUT_FILE "/unparsed_output"

	struct raf_format_type {
	uint16_t frameSizeInBytes; /!< Frame length in bytes /
	uint8_t encoding; /!< Encoding /
	uint8_t sampleRate; /!< Sample rate /
	};

	struct raf_frame_type {
	uint64_t timeStamp; /!< Timestamp of the frame /
	uint32_t seqNo; /!< Optional sequence number of the frame /

	struct raf_format_type format; /!< Format information for the frame /
	uint32_t data[0]; /*!< Start of the variable size payload.
	It must start at 128 bit aligned address for all the frames */
	};

	volatile int capturing = 1;

	void sigint_handler(int sig __unused) {
	ALOGE("Interrupted, setting the exit condition");
	capturing = 0;
	}


	void parse_audio_tunnel_data(FILE out_fp, unsigned char buf_itr, int frame_sz_in_bytes) {
	char q16_buf[BUF_SIZE]; // This can be smaller but by how much?
	int frameSizeInWords = (frame_sz_in_bytes + 3) >> 2;

	if (NULL == buf_itr \|\| NULL == out_fp) {
	ALOGE("%s: Buffer or file pointer is NULL", __func__);
	return;
	}

	kst_float_to_q15_vector(q16_buf, buf_itr, frameSizeInWords);

	fwrite(q16_buf, (frameSizeInWords * 2), 1, out_fp);
	fflush(out_fp);
	}

	int main(int argc, char *argv[]) {
	struct ia_tunneling_hal *thdl = NULL;
	int err = 0;
	FILE *out_fp[MAX_TUNNELS] = { NULL };
	FILE *unp_out_fp = NULL;
	int bytes_avail = 0, bytes_rem = 0;
	int bytes_read = 0;
	void *buf = NULL;
	// The magic number is ROME in ASCII reversed. So we are looking for EMOR in the byte stream
	const unsigned char magic_num[4] = {0x45, 0x4D, 0x4F, 0x52};
	int i = 0;
	bool valid_frame = true;
	char filepath[MAX_FILE_PATH];
	char filename[MAX_FILE_PATH];
	int num_of_tunnels = 0;
	int num_tunnel_params;
	float timer_signal = 0;
	timer_t timer_id;
	int tunnel_src[MAX_TUNNELS] = { 0 };
	int tunnel_mode[MAX_TUNNELS] = { 0 };
	int tunnel_encode[MAX_TUNNELS];
	int lastSeqNum[MAX_TUNNELS] = { 0 };
	int notFirstFrame[MAX_TUNNELS] = { 0 };
	int frameDropCount[MAX_TUNNELS] = { 0 };
	uint64_t tunnel_time_stamps[MAX_TUNNELS] = { 0 };
	unsigned char frame_start, buf_itr;
	// Minimum bytes required is the magic number + tunnel id + reserved and crc + raf struct
	int min_bytes_req = 4 + 2 + 6 + sizeof(struct raf_frame_type);
	int instance;

	if (argc < 5) {
	ALOGE("USAGE: %s <instance number> <Number of tunnels> <Time in seconds> <Source End pt 1> <tnl mode> <encode fmt> <Source End pt 2> <tnl mode> <encode fmt>... <output path>", argv[0]);
	return -EINVAL;
	}

	instance = strtol(argv[1], NULL, 0);
	ALOGD("instance %d", instance);

	num_of_tunnels = strtol(argv[2], NULL, 0);
	ALOGD("Number of tunnels %d", num_of_tunnels);

	timer_signal = strtof(argv[3], NULL);
	ALOGD("tunnel out timer based req %f", timer_signal);
	err = timer_create(CLOCK_MONOTONIC, NULL, &timer_id);
	if (err != 0) {
	ALOGE("Couldn't create timer: %s", strerror(errno));
	return -EINVAL;
	}

	num_tunnel_params = num_of_tunnels * 3 + 4;
	#ifdef FILENAME_ASSIGN
	char filename_str_format[256] = {0};
	bool is_specified_name = false;
	bool is_specified_path= false;
	for (int i = 0; i < argc ; i++) {
	if (strncmp(argv[i], "-f", sizeof(char)*2) == 0) {
	if ((i+1) < argc) {
	snprintf(filename_str_format, sizeof(filename_str_format), "%s", argv[i+1]);
	ALOGE("specify a output file name %s, argc i = %d, argv[%d] = %s", filename_str_format, i, i+1, argv[i+1]);
	is_specified_name = true;
	}
	}
	if (strncmp(argv[i], "-p", sizeof(char)*2) == 0) {
	if ((i+1) < argc) {
	snprintf(filepath, sizeof(filepath), "%s", argv[i+1]);
	ALOGE("specify a output file path %s, argc i = %d, argv[%d] = %s", filepath, i, i+1, argv[i+1]);
	is_specified_path = true;
	}
	}
	}

	if (is_specified_name \|\| is_specified_path) {
	int spec_number = 2 * ((int) is_specified_name + (int) is_specified_path);

	if (argc != (num_tunnel_params + spec_number)) {
	ALOGE("USAGE: %s <instance number> <Number of tunnels> <Sync Tunnel req> <Source End pt 1> <tnl mode> <encode fmt> <Source End pt 2> <tnl mode> <encode fmt>... [-f filename] [-p filepath]", argv[0]);
	return -EINVAL;
	}
	else {
	ALOGE("is_specified_name = TRUE");
	}
	} else {
	if (argc != num_tunnel_params && argc != num_tunnel_params + 1) {
	ALOGE("USAGE: %s <instance number> <Number of tunnels> <Sync Tunnel req> <Source End pt 1> <tnl mode> <encode fmt> <Source End pt 2> <tnl mode> <encode fmt>...", argv[0]);
	return -EINVAL;
	}
	}
	#else
	if (argc != num_tunnel_params && argc != num_tunnel_params + 1) {
	ALOGE("USAGE: %s <instance number> <Number of tunnels> <Sync Tunnel req> <Source End pt 1> <tnl mode> <encode fmt> <Source End pt 2> <tnl mode> <encode fmt>...", argv[0]);
	return -EINVAL;
	}
	#endif /* FILENAME_ASSIGN */


	for (i = 0; i < num_of_tunnels; i++) {
	tunnel_src[i] = strtol(argv[i*3+4], NULL, 0);
	tunnel_mode[i] = strtol(argv[i*3+5], NULL, 0);
	tunnel_encode[i] = strtol(argv[i*3+6], NULL, 0);
	ALOGD("Tunnel source 0x%x Tunnel mode %d Tunnel encode %d", tunnel_src[i], tunnel_mode[i], tunnel_encode[i]);
	}

	#ifdef FILENAME_ASSIGN
	if (!is_specified_path) {
	strcpy(filepath, DEFAULT_PATH);
	}
	#else
	if (argc == num_tunnel_params) {
	strcpy(filepath, DEFAULT_PATH);
	} else {
	strcpy(filepath, argv[argc-1]);
	}
	#endif
	ALOGE("Output path %s", filepath);

	thdl = ia_start_tunneling(0);
	if (NULL == thdl) {
	ALOGE("Failed to start tunneling");
	goto exit;
	}

	for (i = 0; i < num_of_tunnels; i++) {
	err = ia_enable_tunneling_source(thdl, tunnel_src[i], tunnel_mode[i], tunnel_encode[i]);
	if (0 != err) {
	ALOGE("Failed to enable tunneling for src_id %u mode %u encode %u", tunnel_src[i], tunnel_mode[i], tunnel_encode[i]);
	goto exit;
	}
	}

	buf = malloc(BUF_SIZE * 2);
	if (NULL == buf) {
	ALOGE("Failed to allocate memory to read buffer");
	goto exit;
	}

	snprintf(filename, MAX_FILE_PATH, "%s%s", filepath, UNPARSED_OUTPUT_FILE);
	unp_out_fp = fopen(filename, "wb");
	if (NULL == unp_out_fp) {
	ALOGE("Failed to open the file %s", filename);
	goto exit;
	}

	signal(SIGINT, sigint_handler);

	if (num_of_tunnels && timer_signal) {
	struct itimerspec timer_spec;
	uint64_t timer_ns = timer_signal * NS_PER_SEC;

	signal(SIGALRM, sigint_handler);

	memset(&timer_spec, 0, sizeof(timer_spec));
	timer_spec.it_value.tv_sec = timer_ns / NS_PER_SEC;
	timer_spec.it_value.tv_nsec = timer_ns % NS_PER_SEC;
	timer_settime(timer_id, 0, &timer_spec, NULL);
	ALOGD("timer_settime %ld %ld",
	timer_spec.it_value.tv_sec,
	timer_spec.it_value.tv_nsec);
	}

	unsigned short int tunnel_id;
	unsigned short int tunl_src;
	while (1) {
	read_again:
	if (0 == capturing) {
	ALOGE("Time to bail from here");
	break;
	}

	if (0 != bytes_avail) {
	if (bytes_avail < 0) {
	bytes_rem = 0;
	} else {
	bytes_rem = bytes_avail;
	ALOGD("bytes_avail is %d", bytes_rem);
	memcpy(buf, buf_itr, bytes_rem);
	}
	} else {
	bytes_rem = 0;
	}

	// Ensure that we read BUF_SIZE always otherwise the kernel read will hang
	bytes_avail = ia_read_tunnel_data (thdl,
	(void )((unsigned char )buf + bytes_rem),
	BUF_SIZE);
	if (bytes_avail <= 0) {
	ALOGE("Failed to read data from the tunnel :%d", bytes_avail);
	break;
	}

	fwrite((void )((unsigned char )buf + bytes_rem), bytes_avail, 1, unp_out_fp);
	fflush(unp_out_fp);

	bytes_avail += bytes_rem; // update the available bytes with the previous reminder if any
	ALOGD("bytes_avail is after read %d", bytes_avail);
	buf_itr = (unsigned char *)buf;

	do {
	// Check for MagicNumber 0x454D4F52
	if (buf_itr[0] != magic_num[0] \|\| buf_itr[1] != magic_num[1] \|\|
	buf_itr[2] != magic_num[2] \|\| buf_itr[3] != magic_num[3]) {
	ALOGE("Could not find the magic number, reading again");
	ALOGE("buf_itr[0] %x buf_itr[1] %x buf_itr[2] %x buf_itr[3] %x ",
	buf_itr[0], buf_itr[1], buf_itr[2], buf_itr[3]);
	goto exit;
	}
	ALOGD("bytes_avail is after magic %d: prev :%d", bytes_avail, bytes_avail + 540);
	// Bookmark the start of the frame
	frame_start = buf_itr;

	// Skip the magic number
	buf_itr += 4;
	bytes_avail -= 4;

	// Read the tunnelID
	tunnel_id = ((unsigned char) (buf_itr[0]) \|
	(unsigned char) (buf_itr[1]) << 8);

	// Skip tunnelID
	buf_itr += 2;
	bytes_avail -= 2;

	tunl_src = ((unsigned char) (buf_itr[0]) \|
	(unsigned char) (buf_itr[1]) << 8);

	// Skip src id field and CRC - 6 bytes in total
	buf_itr += 6;
	bytes_avail -= 6;

	valid_frame = true;
	if (tunnel_id > MAX_TUNNELS) {
	ALOGE("Invalid tunnel id %d", tunnel_id);
	valid_frame = false;
	}

	struct raf_frame_type rft;
	memcpy(&rft, buf_itr, sizeof(struct raf_frame_type));
	if (true == valid_frame) {
	if (NULL == out_fp[tunnel_id]) {
	#ifdef FILENAME_ASSIGN
	if (is_specified_name) {
	snprintf(filename, 256, "%s/%s", filepath, filename_str_format);
	} else if (TNL_ENC_OPAQUE == rft.format.encoding) {
	#else
	if (TNL_ENC_OPAQUE == rft.format.encoding) {
	#endif /* FILENAME_ASSIGN */
	snprintf(filename, MAX_FILE_PATH, "%s%sid%d-src0x%x-enc0x%x_client%d.raw", filepath, FILE_PREFIX, tunnel_id, tunl_src, rft.format.encoding, instance);
	} else {
	snprintf(filename, MAX_FILE_PATH, "%s%sid%d-src0x%x-enc0x%x_client%d.pcm", filepath, FILE_PREFIX, tunnel_id, tunl_src, rft.format.encoding, instance);
	}
	// Open the file to dump
	out_fp[tunnel_id] = fopen(filename, "wb");
	if (NULL == out_fp[tunnel_id]) {
	ALOGE("ERROR: Failed to open the file %s", filename);
	goto exit;
	}
	}
	}

	ALOGD("Tunnel id %d timestamp %llu", tunnel_id, rft.timeStamp);
	tunnel_time_stamps[tunnel_id] = rft.timeStamp;

	// Skip the raf_frame_type
	buf_itr += sizeof(struct raf_frame_type);
	bytes_avail -= sizeof(struct raf_frame_type);

	if (bytes_avail < rft.format.frameSizeInBytes) {
	ALOGD("Incomplete frame received bytes_avail %d framesize %d", bytes_avail, rft.format.frameSizeInBytes);
	buf_itr = frame_start;
	bytes_avail += min_bytes_req;
	goto read_again;
	}

	if (true == valid_frame) {
	ALOGD("@@@Tunnel id %d encoding %d", tunnel_id, rft.format.encoding);
	if (TNL_ENC_AFLOAT == rft.format.encoding) {
	parse_audio_tunnel_data(out_fp[tunnel_id], buf_itr, rft.format.frameSizeInBytes);
	} else {
	fwrite(buf_itr, rft.format.frameSizeInBytes, 1, out_fp[tunnel_id]);
	}
	}

	/* Calculate the frame drop count */
	if (notFirstFrame[tunnel_id]) {
	frameDropCount[tunnel_id] += (rft.seqNo - lastSeqNum[tunnel_id] - 1);
	}
	lastSeqNum[tunnel_id] = rft.seqNo;
	notFirstFrame[tunnel_id] = 1;
	// Skip the data
	buf_itr += rft.format.frameSizeInBytes;
	bytes_avail -= rft.format.frameSizeInBytes;
	/* For debugging the tunnel read errors or wrong magic numbers or bus errors*/
	bytes_read += rft.format.frameSizeInBytes + min_bytes_req;
	} while (bytes_avail > min_bytes_req);
	}

	exit:
	for (i = 0; i < MAX_TUNNELS; i++) {
	if (notFirstFrame[i]) {
	ALOGE("drop count tunnel id %u: %u", i, frameDropCount[i]);
	}
	}
	ALOGE("bytes_read so far %d", bytes_read);
	if (buf) {
	free(buf);
	buf = NULL;
	}

	if (unp_out_fp) {
	fflush(unp_out_fp);
	fclose(unp_out_fp);
	}

	for (i = 0; i < MAX_TUNNELS; i++) {
	if (out_fp[i]) {
	fflush(out_fp[i]);
	fclose(out_fp[i]);
	}
	}

	for (i = 0; i < num_of_tunnels; i++) {
	err = ia_disable_tunneling_source(thdl, tunnel_src[i], tunnel_mode[i], tunnel_encode[i]);
	if (0 != err) {
	ALOGE("Failed to disable tunneling for tunl_id %u src_id %u", i, tunnel_src[i]);
	}
	}

	err = ia_stop_tunneling(thdl);
	if (0 != err) {
	ALOGE("Failed to stop tunneling");
	}

	timer_delete(timer_id);

	return 0;
	}