| /* |
| * Copyright (c) 2016-2018, The Linux Foundation. All rights reserved. |
| * Not a Contribution. |
| * |
| * Copyright (C) 2015 The Android Open Source Project * |
| * 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. |
| */ |
| |
| /* Test app to capture event updates from kernel */ |
| /*#define LOG_NDEBUG 0*/ |
| #include <getopt.h> |
| #include <fcntl.h> |
| #include <linux/netlink.h> |
| #include <pthread.h> |
| #include <poll.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <sys/prctl.h> |
| #include <sys/stat.h> |
| #include <sys/socket.h> |
| #include <sys/types.h> |
| #include <utils/Log.h> |
| #include <signal.h> |
| #include <errno.h> |
| #include "qahw_api.h" |
| #include "qahw_defs.h" |
| |
| /* add local define to prevent compilation errors on other platforms */ |
| #ifndef AUDIO_DEVICE_IN_HDMI_ARC |
| #define AUDIO_DEVICE_IN_HDMI_ARC (AUDIO_DEVICE_BIT_IN | 0x8000000) |
| #endif |
| |
| static int sock_event_fd = -1; |
| |
| void *context = NULL; |
| FILE * log_file = NULL; |
| volatile bool stop_test = false; |
| volatile bool stop_record = false; |
| volatile bool record_active = false; |
| |
| #define HDMI_SYS_PATH "/sys/devices/platform/soc/78b7000.i2c/i2c-3/3-0064/" |
| const char hdmi_in_audio_sys_path[] = HDMI_SYS_PATH "link_on0"; |
| const char hdmi_in_power_on_sys_path[] = HDMI_SYS_PATH "power_on"; |
| const char hdmi_in_audio_path_sys_path[] = HDMI_SYS_PATH "audio_path"; |
| const char hdmi_in_arc_enable_sys_path[] = HDMI_SYS_PATH "arc_enable"; |
| |
| const char hdmi_in_audio_state_sys_path[] = HDMI_SYS_PATH "audio_state"; |
| const char hdmi_in_audio_format_sys_path[] = HDMI_SYS_PATH "audio_format"; |
| const char hdmi_in_audio_sample_rate_sys_path[] = HDMI_SYS_PATH "audio_rate"; |
| const char hdmi_in_audio_layout_sys_path[] = HDMI_SYS_PATH "audio_layout"; |
| |
| #define SPDIF_SYS_PATH "/sys/devices/platform/soc/soc:qcom,msm-dai-q6-spdif-pri-tx/" |
| const char spdif_in_audio_state_sys_path[] = SPDIF_SYS_PATH "audio_state"; |
| const char spdif_in_audio_format_sys_path[] = SPDIF_SYS_PATH "audio_format"; |
| const char spdif_in_audio_sample_rate_sys_path[] = SPDIF_SYS_PATH "audio_rate"; |
| |
| #define SPDIF_ARC_SYS_PATH "/sys/devices/platform/soc/soc:qcom,msm-dai-q6-spdif-sec-tx/" |
| const char spdif_arc_in_audio_state_sys_path[] = SPDIF_ARC_SYS_PATH "audio_state"; |
| const char spdif_arc_in_audio_format_sys_path[] = SPDIF_ARC_SYS_PATH "audio_format"; |
| const char spdif_arc_in_audio_sample_rate_sys_path[] = SPDIF_ARC_SYS_PATH "audio_rate"; |
| |
| #define ID_RIFF 0x46464952 |
| #define ID_WAVE 0x45564157 |
| #define ID_FMT 0x20746d66 |
| #define ID_DATA 0x61746164 |
| |
| #define FORMAT_PCM 1 |
| |
| 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 test_data { |
| qahw_module_handle_t *qahw_mod_handle; |
| audio_io_handle_t handle; |
| audio_devices_t input_device; |
| double record_length; |
| int rec_cnt; |
| |
| char *audio_fmt_chg_text; |
| int audio_fmt_chg_len; |
| pthread_t record_th; |
| pthread_t poll_event_th; |
| pthread_attr_t poll_event_attr; |
| |
| int bit_width; |
| audio_input_flags_t flags; |
| audio_config_t config; |
| audio_source_t source; |
| |
| int spdif_audio_state; |
| int spdif_audio_mode; |
| int spdif_sample_rate; |
| int spdif_num_channels; |
| |
| int hdmi_power_on; |
| int hdmi_audio_path; |
| int hdmi_arc_enable; |
| |
| int hdmi_audio_state; |
| int hdmi_audio_mode; |
| int hdmi_audio_layout; |
| int hdmi_sample_rate; |
| int hdmi_num_channels; |
| |
| int spdif_arc_audio_state; |
| int spdif_arc_audio_mode; |
| int spdif_arc_sample_rate; |
| int spdif_arc_num_channels; |
| |
| audio_devices_t new_input_device; |
| |
| audio_devices_t act_input_device; /* HDMI might use I2S and SPDIF */ |
| |
| int act_audio_state; /* audio active */ |
| int act_audio_mode; /* 0=LPCM, 1=Compr */ |
| int act_sample_rate; /* transmission sample rate */ |
| int act_num_channels; /* transmission channels */ |
| }; |
| |
| struct test_data tdata; |
| |
| void stop_signal_handler(int signal) |
| { |
| stop_test = true; |
| } |
| |
| void *start_input(void *thread_param) { |
| int rc = 0, ret = 0, count = 0; |
| ssize_t bytes_read = -1; |
| char file_name[256] = "/data/rec"; |
| int data_sz = 0, name_len = strlen(file_name); |
| qahw_in_buffer_t in_buf; |
| |
| qahw_module_handle_t *qahw_mod_handle = tdata.qahw_mod_handle; |
| |
| /* convert/check params before use */ |
| tdata.config.sample_rate = tdata.act_sample_rate; |
| |
| if (tdata.act_audio_mode) { |
| tdata.config.format = AUDIO_FORMAT_IEC61937; |
| tdata.flags = QAHW_INPUT_FLAG_COMPRESS | QAHW_INPUT_FLAG_PASSTHROUGH; |
| } else { |
| if (tdata.bit_width == 32) |
| tdata.config.format = AUDIO_FORMAT_PCM_8_24_BIT; |
| else if (tdata.bit_width == 24) |
| tdata.config.format = AUDIO_FORMAT_PCM_24_BIT_PACKED; |
| else |
| tdata.config.format = AUDIO_FORMAT_PCM_16_BIT; |
| tdata.flags = 0; |
| } |
| |
| switch (tdata.act_num_channels) { |
| case 2: |
| tdata.config.channel_mask = AUDIO_CHANNEL_IN_STEREO; |
| break; |
| case 8: |
| tdata.config.channel_mask = AUDIO_CHANNEL_INDEX_MASK_8; |
| break; |
| default: |
| fprintf(log_file, |
| "ERROR :::: channel count %d not supported\n", |
| tdata.act_num_channels); |
| pthread_exit(0); |
| } |
| tdata.config.frame_count = 0; |
| |
| /* Open audio input stream */ |
| qahw_stream_handle_t* in_handle = NULL; |
| |
| rc = qahw_open_input_stream(qahw_mod_handle, tdata.handle, |
| tdata.act_input_device, &tdata.config, &in_handle, tdata.flags, |
| "input_stream", tdata.source); |
| if (rc) { |
| fprintf(log_file, |
| "ERROR :::: Could not open input stream, handle(%d)\n", |
| tdata.handle); |
| pthread_exit(0); |
| } |
| |
| /* Get buffer size to get upper bound on data to read from the HAL */ |
| size_t buffer_size = qahw_in_get_buffer_size(in_handle); |
| char *buffer = (char *) calloc(1, buffer_size); |
| size_t written_size; |
| if (buffer == NULL) { |
| fprintf(log_file, "calloc failed!!, handle(%d)\n", tdata.handle); |
| pthread_exit(0); |
| } |
| |
| fprintf(log_file, " input opened, buffer %p, size %zu, handle(%d)\n", buffer, |
| buffer_size, tdata.handle); |
| |
| /* set profile for the recording session */ |
| qahw_in_set_parameters(in_handle, "audio_stream_profile=record_unprocessed"); |
| |
| if (audio_is_linear_pcm(tdata.config.format)) |
| snprintf(file_name + name_len, sizeof(file_name) - name_len, "%d.wav", |
| tdata.rec_cnt); |
| else |
| snprintf(file_name + name_len, sizeof(file_name) - name_len, "%d.raw", |
| tdata.rec_cnt); |
| |
| tdata.rec_cnt++; |
| |
| FILE *fd = fopen(file_name, "w"); |
| if (fd == NULL) { |
| fprintf(log_file, "File open failed\n"); |
| free(buffer); |
| pthread_exit(0); |
| } |
| |
| int bps = 16; |
| |
| switch (tdata.config.format) { |
| case AUDIO_FORMAT_PCM_24_BIT_PACKED: |
| bps = 24; |
| break; |
| case AUDIO_FORMAT_PCM_8_24_BIT: |
| case AUDIO_FORMAT_PCM_32_BIT: |
| bps = 32; |
| break; |
| case AUDIO_FORMAT_PCM_16_BIT: |
| default: |
| bps = 16; |
| } |
| |
| struct wav_header hdr; |
| hdr.riff_id = ID_RIFF; |
| hdr.riff_sz = 0; |
| hdr.riff_fmt = ID_WAVE; |
| hdr.fmt_id = ID_FMT; |
| hdr.fmt_sz = 16; |
| hdr.audio_format = FORMAT_PCM; |
| hdr.num_channels = tdata.act_num_channels; |
| hdr.sample_rate = tdata.config.sample_rate; |
| hdr.byte_rate = hdr.sample_rate * hdr.num_channels * (bps / 8); |
| hdr.block_align = hdr.num_channels * (bps / 8); |
| hdr.bits_per_sample = bps; |
| hdr.data_id = ID_DATA; |
| hdr.data_sz = 0; |
| if (audio_is_linear_pcm(tdata.config.format)) |
| fwrite(&hdr, 1, sizeof(hdr), fd); |
| |
| memset(&in_buf, 0, sizeof(qahw_in_buffer_t)); |
| while (true && !stop_record) { |
| in_buf.buffer = buffer; |
| in_buf.bytes = buffer_size; |
| bytes_read = qahw_in_read(in_handle, &in_buf); |
| |
| written_size = fwrite(in_buf.buffer, 1, bytes_read, fd); |
| if (written_size < bytes_read) { |
| printf("Error in fwrite(%d)=%s\n", ferror(fd), |
| strerror(ferror(fd))); |
| break; |
| } |
| data_sz += bytes_read; |
| } |
| |
| if (audio_is_linear_pcm(tdata.config.format)) { |
| /* update lengths in header */ |
| hdr.data_sz = data_sz; |
| hdr.riff_sz = data_sz + 44 - 8; |
| fseek(fd, 0, SEEK_SET); |
| fwrite(&hdr, 1, sizeof(hdr), fd); |
| } |
| free(buffer); |
| fclose(fd); |
| fd = NULL; |
| |
| fprintf(log_file, " closing input, handle(%d), written %d bytes", tdata.handle, data_sz); |
| |
| /* Close input stream and device. */ |
| rc = qahw_in_standby(in_handle); |
| if (rc) { |
| fprintf(log_file, "in standby failed %d, handle(%d)\n", rc, |
| tdata.handle); |
| } |
| |
| rc = qahw_close_input_stream(in_handle); |
| if (rc) { |
| fprintf(log_file, "could not close input stream %d, handle(%d)\n", rc, |
| tdata.handle); |
| } |
| |
| fprintf(log_file, |
| "\n\n The audio recording has been saved to %s.\n" |
| "The audio data has the following characteristics:\n Sample rate: %i\n Format: %d\n " |
| "Num channels: %i, handle(%d)\n\n", file_name, |
| tdata.config.sample_rate, tdata.config.format, tdata.act_num_channels, |
| tdata.handle); |
| |
| return NULL; |
| } |
| |
| void start_rec_thread(void) |
| { |
| int ret = 0; |
| |
| stop_record = false; |
| record_active = true; |
| |
| fprintf(log_file, "\n Create record thread \n"); |
| ret = pthread_create(&tdata.record_th, NULL, start_input, (void *)&tdata); |
| if (ret) { |
| fprintf(log_file, " Failed to create record thread\n"); |
| exit(1); |
| } |
| } |
| |
| void stop_rec_thread(void) |
| { |
| if (record_active) { |
| record_active = false; |
| stop_record = true; |
| fprintf(log_file, "\n Stop record thread \n"); |
| pthread_join(tdata.record_th, NULL); |
| } |
| } |
| |
| |
| void read_data_from_fd(const char* path, int *value) |
| { |
| int fd = -1; |
| char buf[16]; |
| int ret; |
| |
| fd = open(path, O_RDONLY, 0); |
| if (fd < 0) { |
| ALOGE("Unable open fd for file %s", path); |
| return; |
| } |
| |
| ret = read(fd, buf, 15); |
| if (ret < 0) { |
| ALOGE("File %s Data is empty", path); |
| close(fd); |
| return; |
| } |
| |
| buf[ret] = '\0'; |
| *value = atoi(buf); |
| close(fd); |
| } |
| |
| void get_input_status() |
| { |
| switch (tdata.input_device) { |
| case AUDIO_DEVICE_IN_SPDIF: |
| read_data_from_fd(spdif_in_audio_state_sys_path, &tdata.spdif_audio_state); |
| read_data_from_fd(spdif_in_audio_format_sys_path, &tdata.spdif_audio_mode); |
| read_data_from_fd(spdif_in_audio_sample_rate_sys_path, &tdata.spdif_sample_rate); |
| tdata.spdif_num_channels = 2; |
| tdata.new_input_device = AUDIO_DEVICE_IN_SPDIF; |
| |
| fprintf(log_file, "spdif audio_state: %d, audio_format: %d, sample_rate: %d, num_channels: %d\n", |
| tdata.spdif_audio_state, tdata.spdif_audio_mode, tdata.spdif_sample_rate, tdata.spdif_num_channels); |
| break; |
| case AUDIO_DEVICE_IN_HDMI: |
| read_data_from_fd(hdmi_in_power_on_sys_path, &tdata.hdmi_power_on); |
| read_data_from_fd(hdmi_in_audio_path_sys_path, &tdata.hdmi_audio_path); |
| read_data_from_fd(hdmi_in_arc_enable_sys_path, &tdata.hdmi_arc_enable); |
| |
| read_data_from_fd(hdmi_in_audio_state_sys_path, &tdata.hdmi_audio_state); |
| read_data_from_fd(hdmi_in_audio_format_sys_path, &tdata.hdmi_audio_mode); |
| read_data_from_fd(hdmi_in_audio_sample_rate_sys_path, &tdata.hdmi_sample_rate); |
| read_data_from_fd(hdmi_in_audio_layout_sys_path, &tdata.hdmi_audio_layout); |
| if (tdata.hdmi_audio_layout) |
| tdata.hdmi_num_channels = 8; |
| else |
| tdata.hdmi_num_channels = 2; |
| /* todo: read ch_count, ch_alloc */ |
| |
| read_data_from_fd(spdif_arc_in_audio_state_sys_path, &tdata.spdif_arc_audio_state); |
| read_data_from_fd(spdif_arc_in_audio_format_sys_path, &tdata.spdif_arc_audio_mode); |
| read_data_from_fd(spdif_arc_in_audio_sample_rate_sys_path, &tdata.spdif_arc_sample_rate); |
| tdata.spdif_arc_num_channels = 2; |
| |
| if (tdata.hdmi_arc_enable || |
| (tdata.hdmi_audio_state && (tdata.hdmi_audio_layout == 0) && tdata.hdmi_audio_mode)) { |
| tdata.new_input_device = AUDIO_DEVICE_IN_HDMI_ARC; |
| fprintf(log_file, "hdmi audio interface SPDIF_ARC\n"); |
| } else { |
| tdata.new_input_device = AUDIO_DEVICE_IN_HDMI; |
| fprintf(log_file, "hdmi audio interface MI2S\n"); |
| } |
| |
| fprintf(log_file, "hdmi audio_state: %d, audio_format: %d, sample_rate: %d, num_channels: %d\n", |
| tdata.hdmi_audio_state, tdata.hdmi_audio_mode, tdata.hdmi_sample_rate, tdata.hdmi_num_channels); |
| fprintf(log_file, "arc audio_state: %d, audio_format: %d, sample_rate: %d, num_channels: %d\n", |
| tdata.spdif_arc_audio_state, tdata.spdif_arc_audio_mode, tdata.spdif_arc_sample_rate, tdata.spdif_arc_num_channels); |
| break; |
| } |
| } |
| |
| void input_restart_check(void) |
| { |
| get_input_status(); |
| |
| switch (tdata.input_device) { |
| case AUDIO_DEVICE_IN_SPDIF: |
| if ((tdata.act_input_device != tdata.new_input_device) || |
| (tdata.spdif_audio_state == 2)) { |
| fprintf(log_file, "old audio_state: %d, audio_format: %d, rate: %d, channels: %d\n", |
| tdata.act_audio_state, tdata.act_audio_mode, |
| tdata.act_sample_rate, tdata.act_num_channels); |
| fprintf(log_file, "new spdif audio_state: %d, audio_format: %d, rate: %d, channels: %d\n", |
| tdata.spdif_audio_state, tdata.spdif_audio_mode, |
| tdata.spdif_sample_rate, tdata.spdif_num_channels); |
| |
| stop_rec_thread(); |
| |
| tdata.act_input_device = AUDIO_DEVICE_IN_SPDIF; |
| tdata.act_audio_state = 1; |
| tdata.act_audio_mode = tdata.spdif_audio_mode; |
| tdata.act_sample_rate = tdata.spdif_sample_rate; |
| tdata.act_num_channels = tdata.spdif_num_channels; |
| |
| start_rec_thread(); |
| } |
| break; |
| case AUDIO_DEVICE_IN_HDMI: |
| if (tdata.act_input_device != tdata.new_input_device) { |
| stop_rec_thread(); |
| |
| if (tdata.new_input_device == AUDIO_DEVICE_IN_HDMI) { |
| fprintf(log_file, "old audio_state: %d, audio_format: %d, rate: %d, channels: %d\n", |
| tdata.act_audio_state, tdata.act_audio_mode, |
| tdata.act_sample_rate, tdata.act_num_channels); |
| fprintf(log_file, "new hdmi audio_state: %d, audio_format: %d, rate: %d, channels: %d\n", |
| tdata.hdmi_audio_state, tdata.hdmi_audio_mode, |
| tdata.hdmi_sample_rate, tdata.hdmi_num_channels); |
| |
| tdata.act_input_device = AUDIO_DEVICE_IN_HDMI; |
| tdata.act_audio_state = tdata.hdmi_audio_state; |
| tdata.act_audio_mode = tdata.hdmi_audio_mode; |
| tdata.act_sample_rate = tdata.hdmi_sample_rate; |
| tdata.act_num_channels = tdata.hdmi_num_channels; |
| |
| if (tdata.hdmi_audio_state) |
| start_rec_thread(); |
| } else { |
| tdata.act_input_device = AUDIO_DEVICE_IN_HDMI_ARC; |
| if (tdata.hdmi_arc_enable) { |
| fprintf(log_file, "old audio_state: %d, audio_format: %d, rate: %d, channels: %d\n", |
| tdata.act_audio_state, tdata.act_audio_mode, |
| tdata.act_sample_rate, tdata.act_num_channels); |
| fprintf(log_file, "new arc audio_state: %d, audio_format: %d, rate: %d, channels: %d\n", |
| tdata.spdif_arc_audio_state, tdata.spdif_arc_audio_mode, |
| tdata.spdif_arc_sample_rate, tdata.spdif_arc_num_channels); |
| |
| tdata.act_audio_state = 1; |
| tdata.act_audio_mode = tdata.spdif_arc_audio_mode; |
| tdata.act_sample_rate = tdata.spdif_arc_sample_rate; |
| tdata.act_num_channels = tdata.spdif_arc_num_channels; |
| } else { |
| fprintf(log_file, "old audio_state: %d, audio_format: %d, rate: %d, channels: %d\n", |
| tdata.act_audio_state, tdata.act_audio_mode, |
| tdata.act_sample_rate, tdata.act_num_channels); |
| fprintf(log_file, "new arc (from hdmi) audio_state: %d, audio_format: %d, rate: %d, channels: %d\n", |
| tdata.hdmi_audio_state, tdata.hdmi_audio_mode, |
| tdata.hdmi_sample_rate, tdata.hdmi_num_channels); |
| |
| tdata.act_audio_state = 1; |
| tdata.act_audio_mode = tdata.hdmi_audio_mode; |
| tdata.act_sample_rate = tdata.hdmi_sample_rate; |
| tdata.act_num_channels = tdata.hdmi_num_channels; |
| } |
| start_rec_thread(); |
| } |
| } else { /* check for change on same audio device */ |
| if (tdata.new_input_device == AUDIO_DEVICE_IN_HDMI) { |
| if ((tdata.act_audio_state != tdata.hdmi_audio_state) || |
| (tdata.act_audio_mode != tdata.hdmi_audio_mode) || |
| (tdata.act_sample_rate != tdata.hdmi_sample_rate) || |
| (tdata.act_num_channels != tdata.hdmi_num_channels)) { |
| |
| fprintf(log_file, "old audio_state: %d, audio_format: %d, rate: %d, channels: %d\n", |
| tdata.act_audio_state, tdata.act_audio_mode, |
| tdata.act_sample_rate, tdata.act_num_channels); |
| fprintf(log_file, "new hdmi audio_state: %d, audio_format: %d, rate: %d, channels: %d\n", |
| tdata.hdmi_audio_state, tdata.hdmi_audio_mode, |
| tdata.hdmi_sample_rate, tdata.hdmi_num_channels); |
| |
| stop_rec_thread(); |
| |
| tdata.act_audio_state = tdata.hdmi_audio_state; |
| tdata.act_audio_mode = tdata.hdmi_audio_mode; |
| tdata.act_sample_rate = tdata.hdmi_sample_rate; |
| tdata.act_num_channels = tdata.hdmi_num_channels; |
| |
| if (tdata.hdmi_audio_state) |
| start_rec_thread(); |
| } |
| } else { |
| if (tdata.spdif_arc_audio_state == 2) { |
| fprintf(log_file, "old audio_state: %d, audio_format: %d, rate: %d, channels: %d\n", |
| tdata.act_audio_state, tdata.act_audio_mode, |
| tdata.act_sample_rate, tdata.act_num_channels); |
| fprintf(log_file, "new arc audio_state: %d, audio_format: %d, rate: %d, channels: %d\n", |
| tdata.spdif_arc_audio_state, tdata.spdif_arc_audio_mode, |
| tdata.spdif_arc_sample_rate, tdata.spdif_arc_num_channels); |
| |
| stop_rec_thread(); |
| |
| tdata.act_audio_state = 1; |
| tdata.act_audio_mode = tdata.spdif_arc_audio_mode; |
| tdata.act_sample_rate = tdata.spdif_arc_sample_rate; |
| tdata.act_num_channels = tdata.spdif_arc_num_channels; |
| |
| start_rec_thread(); |
| } |
| } |
| } |
| break; |
| } |
| } |
| |
| int poll_event_init() |
| { |
| struct sockaddr_nl sock_addr; |
| int sz = (64*1024); |
| int soc; |
| |
| memset(&sock_addr, 0, sizeof(sock_addr)); |
| sock_addr.nl_family = AF_NETLINK; |
| sock_addr.nl_pid = getpid(); |
| sock_addr.nl_groups = 0xffffffff; |
| |
| soc = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT); |
| if (soc < 0) { |
| return 0; |
| } |
| |
| setsockopt(soc, SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz)); |
| |
| if (bind(soc, (struct sockaddr*) &sock_addr, sizeof(sock_addr)) < 0) { |
| close(soc); |
| return 0; |
| } |
| |
| sock_event_fd = soc; |
| |
| return (soc > 0); |
| } |
| |
| void* listen_uevent() |
| { |
| char buffer[64*1024]; |
| struct pollfd fds; |
| int i, count; |
| int j; |
| char *dev_path = NULL; |
| char *switch_state = NULL; |
| char *switch_name = NULL; |
| int audio_changed; |
| |
| input_restart_check(); |
| |
| while(!stop_test) { |
| |
| fds.fd = sock_event_fd; |
| fds.events = POLLIN; |
| fds.revents = 0; |
| i = poll(&fds, 1, 5); /* wait 5 msec */ |
| |
| if (i > 0 && (fds.revents & POLLIN)) { |
| count = recv(sock_event_fd, buffer, (64*1024), 0 ); |
| if (count > 0) { |
| buffer[count] = '\0'; |
| audio_changed = 0; |
| j = 0; |
| while(j < count) { |
| if (strncmp(&buffer[j], "DEVPATH=", 8) == 0) { |
| dev_path = &buffer[j+8]; |
| j += 8; |
| continue; |
| } else if (tdata.input_device == AUDIO_DEVICE_IN_SPDIF) { |
| if (strncmp(&buffer[j], "PRI_SPDIF_TX=MEDIA_CONFIG_CHANGE", strlen("PRI_SPDIF_TX=MEDIA_CONFIG_CHANGE")) == 0) { |
| audio_changed = 1; |
| ALOGI("AUDIO CHANGE EVENT: %s\n", &buffer[j]); |
| j += strlen("PRI_SPDIF_TX=MEDIA_CONFIG_CHANGE"); |
| continue; |
| } |
| } else if (tdata.input_device == AUDIO_DEVICE_IN_HDMI) { |
| if (strncmp(&buffer[j], "EP92EVT_AUDIO=MEDIA_CONFIG_CHANGE", strlen("EP92EVT_AUDIO=MEDIA_CONFIG_CHANGE")) == 0) { |
| audio_changed = 1; |
| ALOGI("AUDIO CHANGE EVENT: %s\n", &buffer[j]); |
| j += strlen("EP92EVT_AUDIO=MEDIA_CONFIG_CHANGE"); |
| continue; |
| } else if (strncmp(&buffer[j], "SEC_SPDIF_TX=MEDIA_CONFIG_CHANGE", strlen("SEC_SPDIF_TX=MEDIA_CONFIG_CHANGE")) == 0) { |
| audio_changed = 1; |
| ALOGI("AUDIO CHANGE EVENT: %s\n", &buffer[j]); |
| j += strlen("SEC_SPDIF_TX=MEDIA_CONFIG_CHANGE"); |
| continue; |
| } else if (strncmp(&buffer[j], "EP92EVT_", 8) == 0) { |
| ALOGI("EVENT: %s\n", &buffer[j]); |
| j += 8; |
| continue; |
| } |
| } |
| j++; |
| } |
| |
| if (audio_changed) |
| input_restart_check(); |
| } |
| } else { |
| ALOGV("NO Data\n"); |
| } |
| } |
| |
| stop_rec_thread(); |
| } |
| |
| void fill_default_params(struct test_data *tdata) { |
| memset(tdata, 0, sizeof(struct test_data)); |
| |
| tdata->input_device = AUDIO_DEVICE_IN_SPDIF; |
| tdata->bit_width = 24; |
| tdata->source = AUDIO_SOURCE_UNPROCESSED; |
| tdata->record_length = 8 /*sec*/; |
| |
| tdata->handle = 0x99A; |
| } |
| |
| void usage() { |
| printf(" \n Command \n"); |
| printf(" \n fmt_change_test <options>\n"); |
| printf(" \n Options\n"); |
| printf(" -d --device <int> - see system/media/audio/include/system/audio.h for device values\n"); |
| printf(" spdif_in 2147549184, hdmi_in 2147483680\n"); |
| printf(" Optional Argument and Default value is spdif_in\n\n"); |
| printf(" -b --bits <int> - Bitwidth in PCM mode (16, 24 or 32), Default is 24\n\n"); |
| printf(" -F --flags <int> - Integer value of flags to be used for opening input stream\n\n"); |
| printf(" -t --recording-time <in seconds> - Time duration for the recording\n\n"); |
| printf(" -l --log-file <FILEPATH> - File path for debug msg, to print\n"); |
| printf(" on console use stdout or 1 \n\n"); |
| printf(" -h --help - Show this help\n\n"); |
| printf(" \n Examples \n"); |
| printf(" hdmi_in_event_test -> start a recording stream with default configurations\n\n"); |
| printf(" hdmi_in_event_test -d 2147483680 -t 20 -> start a recording session, with device hdmi_in,\n"); |
| printf(" record data for 20 secs.\n\n"); |
| } |
| |
| static void qti_audio_server_death_notify_cb(void *ctxt) { |
| fprintf(log_file, "qas died\n"); |
| fprintf(stderr, "qas died\n"); |
| stop_test = true; |
| stop_record = true; |
| } |
| |
| int main(int argc, char* argv[]) |
| { |
| qahw_module_handle_t *qahw_mod_handle; |
| const char *mod_name = "audio.primary"; |
| |
| char log_filename[256] = "stdout"; |
| int i; |
| int ret = -1; |
| |
| log_file = stdout; |
| fill_default_params(&tdata); |
| struct option long_options[] = { |
| /* These options set a flag. */ |
| {"device", required_argument, 0, 'd'}, |
| {"bits", required_argument, 0, 'b'}, |
| {"flags", required_argument, 0, 'F'}, |
| {"recording-time", required_argument, 0, 't'}, |
| {"log-file", required_argument, 0, 'l'}, |
| {"help", no_argument, 0, 'h'}, |
| {0, 0, 0, 0} |
| }; |
| |
| int opt = 0; |
| int option_index = 0; |
| while ((opt = getopt_long(argc, |
| argv, |
| "-d:b:F:t:l:h", |
| long_options, |
| &option_index)) != -1) { |
| switch (opt) { |
| case 'd': |
| tdata.input_device = atoll(optarg); |
| break; |
| case 'b': |
| tdata.bit_width = atoll(optarg); |
| break; |
| case 'F': |
| tdata.flags = atoll(optarg); |
| break; |
| case 't': |
| tdata.record_length = atoi(optarg); |
| break; |
| case 'l': |
| snprintf(log_filename, sizeof(log_filename), "%s", optarg); |
| break; |
| case 'h': |
| usage(); |
| return 0; |
| break; |
| } |
| } |
| fprintf(log_file, "registering qas callback"); |
| qahw_register_qas_death_notify_cb((audio_error_callback)qti_audio_server_death_notify_cb, context); |
| |
| switch (tdata.input_device) { |
| case AUDIO_DEVICE_IN_SPDIF: |
| break; |
| case AUDIO_DEVICE_IN_HDMI: |
| break; |
| default: |
| fprintf(log_file, "device %d not supported\n", tdata.input_device); |
| return -1; |
| } |
| |
| switch (tdata.bit_width) { |
| case 16: |
| case 24: |
| case 32: |
| break; |
| default: |
| fprintf(log_file, "bitwidth %d not supported\n", tdata.bit_width); |
| return -1; |
| } |
| |
| qahw_mod_handle = qahw_load_module(mod_name); |
| if(qahw_mod_handle == NULL) { |
| fprintf(log_file, " qahw_load_module failed"); |
| return -1; |
| } |
| fprintf(log_file, " Starting audio recording test. \n"); |
| if (strcasecmp(log_filename, "stdout") && strcasecmp(log_filename, "1")) { |
| if ((log_file = fopen(log_filename,"wb"))== NULL) { |
| fprintf(stderr, "Cannot open log file %s\n", log_filename); |
| /* continue to log to std out */ |
| log_file = stdout; |
| } |
| } |
| |
| tdata.qahw_mod_handle = qahw_mod_handle; |
| |
| /* Register the SIGINT to close the App properly */ |
| if (signal(SIGINT, stop_signal_handler) == SIG_ERR) |
| fprintf(log_file, "Failed to register SIGINT:%d\n", errno); |
| |
| /* Register the SIGTERM to close the App properly */ |
| if (signal(SIGTERM, stop_signal_handler) == SIG_ERR) |
| fprintf(log_file, "Failed to register SIGTERM:%d\n", errno); |
| |
| time_t start_time = time(0); |
| double time_elapsed = 0; |
| |
| pthread_attr_init(&tdata.poll_event_attr); |
| pthread_attr_setdetachstate(&tdata.poll_event_attr, PTHREAD_CREATE_JOINABLE); |
| poll_event_init(); |
| pthread_create(&tdata.poll_event_th, &tdata.poll_event_attr, |
| (void *) listen_uevent, NULL); |
| |
| while(true && !stop_test) { |
| time_elapsed = difftime(time(0), start_time); |
| if (tdata.record_length && (time_elapsed > tdata.record_length)) { |
| fprintf(log_file, "\n Test completed.\n"); |
| stop_test = true; |
| break; |
| } |
| } |
| |
| fprintf(log_file, "\n Stop test \n"); |
| |
| pthread_join(tdata.poll_event_th, NULL); |
| |
| fprintf(log_file, "\n Unload HAL\n"); |
| |
| ret = qahw_unload_module(qahw_mod_handle); |
| if (ret) { |
| fprintf(log_file, "could not unload hal %d\n", ret); |
| } |
| |
| fprintf(log_file, "Done with hal record test\n"); |
| if (log_file != stdout) { |
| if (log_file) { |
| fclose(log_file); |
| log_file = NULL; |
| } |
| } |
| |
| return 0; |
| } |