rk3588-game
/
android13
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
android13/hardware/knowles/athletico/sound_trigger_hal/tests/tunnel_test.c

417 lines
15 KiB
C
Raw Blame History

/*
* 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;
}
Reference in New Issue View Git Blame Copy Permalink