| /************************************************************************************************** |
| Filename: ti_audio.c |
| |
| Description: audio over BLe, audio decoding app |
| |
| |
| Copyright 2013 Texas Instruments Incorporated. All rights reserved. |
| |
| IMPORTANT: Your use of this Software is limited to those specific rights |
| granted under the terms of a software license agreement between the user |
| who downloaded the software, his/her employer (which must be your employer) |
| and Texas Instruments Incorporated (the "License"). You may not use this |
| Software unless you agree to abide by the terms of the License. The License |
| limits your use, and you acknowledge, that the Software may not be modified, |
| copied or distributed unless embedded on a Texas Instruments microcontroller |
| or used solely and exclusively in conjunction with a Texas Instruments radio |
| frequency transceiver, which is integrated into your product. Other than for |
| the foregoing purpose, you may not use, reproduce, copy, prepare derivative |
| works of, modify, distribute, perform, display or sell this Software and/or |
| its documentation for any purpose. |
| |
| YOU FURTHER ACKNOWLEDGE AND AGREE THAT THE SOFTWARE AND DOCUMENTATION ARE |
| PROVIDED “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, |
| INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, TITLE, |
| NON-INFRINGEMENT AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL |
| TEXAS INSTRUMENTS OR ITS LICENSORS BE LIABLE OR OBLIGATED UNDER CONTRACT, |
| NEGLIGENCE, STRICT LIABILITY, CONTRIBUTION, BREACH OF WARRANTY, OR OTHER |
| LEGAL EQUITABLE THEORY ANY DIRECT OR INDIRECT DAMAGES OR EXPENSES |
| INCLUDING BUT NOT LIMITED TO ANY INCIDENTAL, SPECIAL, INDIRECT, PUNITIVE |
| OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF PROCUREMENT |
| OF SUBSTITUTE GOODS, TECHNOLOGY, SERVICES, OR ANY CLAIMS BY THIRD PARTIES |
| (INCLUDING BUT NOT LIMITED TO ANY DEFENSE THEREOF), OR OTHER SIMILAR COSTS. |
| |
| Should you have any questions regarding your right to use this Software, |
| contact Texas Instruments Incorporated at www.TI.com. |
| **************************************************************************************************/ |
| #include <fcntl.h> |
| #include <getopt.h> |
| #include <poll.h> |
| #include <pthread.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/time.h> |
| #include <unistd.h> |
| |
| #include "RAS_lib.h" |
| |
| #define FIFO_BTD2AUDIO_FILE "/tmp/Fifo_bdt_tiaudio" |
| |
| #define RAS_CMD_MASK 0x07 |
| #define RAS_START_CMD 0x04 |
| #define RAS_DATA_TIC1_CMD 0x01 |
| #define RAS_STOP_CMD 0x02 |
| #define RAS_DATA_RAW_CMD 0x03 |
| |
| #define TRUE 1 |
| #define FALSE 0 |
| |
| int fp; |
| |
| static pthread_mutex_t audio_mutex = PTHREAD_MUTEX_INITIALIZER; |
| |
| int frame_type; |
| int SeqNum, PrevSeqNum; |
| static float throughput, throughput_min = 10000000, throughput_max = 0, |
| throughput_ave = 0, throughput_raw_ave = 0; |
| static int cumulatedBytes = 0; |
| static int totalcumulatedBytes = 0; |
| static int totalcumulatedRawBytes = 0; |
| struct timeval prevTimeThrougput, prevTimeStarting, curTime, prevPacket; |
| long int elapsedTimeSinceLastPacket = 1; |
| char ras_pec_mode; |
| char previousFrameExist = 0; |
| unsigned char audioFrame[200]; |
| unsigned char audio_data_len; |
| unsigned char audioFrameIndex = 0; |
| FILE *fout_wav; |
| FILE *fout_tic1; |
| char outFile_wav[1024]; |
| char outFile_tic1[1024]; |
| char fileListIndex = 0; |
| char NewFilename[1024] = ""; |
| char NewOutputFilename[1024] = ""; |
| char outFile[1024]; |
| unsigned char Data_len; |
| int file_open = FALSE; |
| int streamStarted = TRUE; |
| int nbFrameLost; |
| int nbFrameReceived; |
| |
| static void audioRenameOutputFile(void) { |
| strcpy(NewFilename, ""); |
| strcpy(NewOutputFilename, ""); |
| strcat(NewOutputFilename, "gattToolAudio"); |
| |
| { |
| { |
| char temp[8]; |
| fileListIndex++; |
| strncat(NewOutputFilename, outFile, strlen(outFile)); |
| strcat(NewOutputFilename, "_"); |
| sprintf(temp, "%d", fileListIndex); |
| strcat(NewOutputFilename, temp); |
| } |
| } |
| |
| // Add the new suffix. |
| strcpy(outFile_wav, NewOutputFilename); |
| strcpy(outFile_tic1, NewOutputFilename); |
| strcat(outFile_wav, ".wav"); |
| strcat(outFile_tic1, ".tic1"); |
| |
| // Open the file |
| { |
| fout_wav = fopen(outFile_wav, "w"); |
| if (fout_wav != NULL) { |
| printf("===> Wav File Created %s <=== \n", outFile_wav); |
| |
| } else { |
| perror("fopen3:"); |
| exit(-1); |
| } |
| fout_tic1 = fopen(outFile_tic1, "w"); |
| if (fout_tic1 != NULL) { |
| printf("===> TIC1 File Created %s <=== \n", outFile_tic1); |
| } else { |
| perror("fopen4:"); |
| exit(-1); |
| } |
| file_open = TRUE; |
| } |
| } |
| |
| static void audioAddWaveHeader(FILE *fout_wav) { |
| // Initialize directly subchunksize1 |
| unsigned char Header[100] = {0x52, 0x49, 0x46, 0x46, 0xFF, 0xFF, |
| 0xFF, 0xFF, 0x57, 0x41, 0x56, 0x45}; |
| |
| // subchunksize2 |
| Header[12] = 0x66; |
| Header[13] = 0x6d; |
| Header[14] = 0x74; |
| Header[15] = 0x20; |
| |
| Header[16] = 16; |
| Header[17] = 0; |
| Header[18] = 0; |
| Header[19] = 0; |
| |
| Header[20] = 1; |
| Header[21] = 0; |
| |
| Header[22] = 1; |
| Header[23] = 0; |
| |
| Header[24] = 0x80; |
| Header[25] = 0x3E; |
| Header[26] = 0; |
| Header[27] = 0; |
| |
| Header[28] = 0x00; |
| Header[29] = 0x7D; |
| Header[30] = 0; |
| Header[31] = 0; |
| |
| Header[32] = 2; |
| Header[33] = 0; |
| |
| Header[34] = 16; |
| Header[35] = 0; |
| |
| Header[36] = 0x64; |
| Header[37] = 0x61; |
| Header[38] = 0x74; |
| Header[39] = 0x61; |
| |
| Header[40] = 0xFF; |
| Header[41] = 0xFF; |
| Header[42] = 0xFF; |
| Header[43] = 0xFF; |
| |
| fwrite(Header, sizeof(char), 44, fout_wav); |
| printf("===> Add Wav Header <=== \n"); |
| } |
| |
| long int audioElapsedTime(struct timeval *timeStart, struct timeval *timeEnd) { |
| long int diffPrev; |
| long int decrementValue; |
| int t = 0; |
| |
| if (timeStart->tv_usec >= timeEnd->tv_usec) { |
| diffPrev = timeStart->tv_usec - timeEnd->tv_usec; |
| t = 0; |
| } else { |
| diffPrev = (timeStart->tv_usec + 1000000) - timeEnd->tv_usec; |
| t = 1; |
| } |
| |
| decrementValue = |
| (diffPrev + 1000000 * (timeStart->tv_sec - timeEnd->tv_sec - t)) / |
| 1000; // Res in ms |
| return decrementValue; |
| } |
| |
| void audioResetStream(void) { |
| gettimeofday(&prevTimeThrougput, NULL); |
| gettimeofday(&prevTimeStarting, NULL); |
| |
| totalcumulatedBytes = 0; |
| totalcumulatedRawBytes = 0; |
| cumulatedBytes = 0; |
| throughput = 0; |
| throughput_min = 10000000; |
| throughput_max = 0; |
| throughput_ave = 0; |
| throughput_raw_ave = 0; |
| PrevSeqNum = 0; |
| ras_pec_mode = 1; |
| streamStarted = FALSE; |
| nbFrameLost = 0; |
| nbFrameReceived = 0; |
| |
| if (RAS_Init(ras_pec_mode)) { |
| // printf("fail to initialize remoTI audio subsystem"); |
| // exit(-1); |
| } |
| previousFrameExist = 0; |
| audioFrameIndex = 0; |
| |
| elapsedTimeSinceLastPacket = audioElapsedTime(&curTime, &prevPacket); |
| |
| if (file_open && elapsedTimeSinceLastPacket > 700) { |
| // Equivalent to dead link timer |
| // Close current file and reopen a new one. |
| // Stop Frame |
| fflush(fout_wav); |
| fclose(fout_wav); |
| fout_wav = NULL; |
| fflush(fout_tic1); |
| fclose(fout_tic1); |
| fout_tic1 = NULL; |
| |
| // Need to add File size in the header of the wav file |
| { |
| int filesize; |
| unsigned char file[4]; |
| fout_wav = fopen(outFile_wav, "r+b"); |
| if (fout_wav == NULL) { |
| perror("fopen6:"); |
| exit(-1); |
| } |
| |
| fseek(fout_wav, 0L, SEEK_END); |
| filesize = ftell(fout_wav); |
| |
| file[0] = (unsigned char)(((filesize - 44) & 0xFF)); |
| file[1] = (unsigned char)(((filesize - 44) & 0xFF00) >> 8); |
| file[2] = (unsigned char)(((filesize - 44) & 0xFF0000) >> 16); |
| file[3] = (unsigned char)(((filesize - 44) & 0xFF000000) >> 24); |
| fseek(fout_wav, 40, SEEK_SET); |
| fwrite(file, 1, 4, fout_wav); |
| fclose(fout_wav); |
| fout_wav = NULL; |
| } |
| file_open = FALSE; |
| |
| printf("===> AUDIO STOP BEFORE START <=== \n"); |
| } |
| |
| if (!file_open) { |
| audioRenameOutputFile(); |
| // Add .Wav header to .wave output file |
| if (fout_wav) audioAddWaveHeader(fout_wav); |
| } |
| } |
| |
| static void audio_ParseData(unsigned char *pdu, unsigned short len) { |
| long int decrementValue, elapsed_time; |
| int i; |
| frame_type = pdu[3] & 0x7; |
| SeqNum = (pdu[3] >> 3) & 0x1F; |
| // s = g_string_new(NULL); |
| |
| Data_len = |
| (len - |
| 4); // This is audio data length only (audio frame header+ audio data) |
| // printf("FT = 0x%02x ,SeqNum: %d, len: %d\n", frame_type, SeqNum, len); |
| |
| cumulatedBytes += Data_len; |
| totalcumulatedBytes += Data_len; |
| totalcumulatedRawBytes += Data_len + 3 + 4 + 1; |
| |
| gettimeofday(&curTime, NULL); |
| decrementValue = audioElapsedTime(&curTime, &prevTimeThrougput); |
| elapsed_time = audioElapsedTime(&curTime, &prevTimeStarting); |
| |
| // check if 1s has elapse since last packet. |
| if (decrementValue > 1000) { |
| // Calculate and Display Throughput |
| throughput = |
| (float)(8 * (((float)cumulatedBytes) / ((float)decrementValue))); |
| (throughput_min > throughput) ? throughput_min = throughput |
| : throughput_min; |
| (throughput_max < throughput) ? throughput_max = throughput |
| : throughput_max; |
| gettimeofday(&prevTimeThrougput, NULL); |
| } |
| |
| if (elapsed_time > 500) // Not meaningful before |
| { |
| throughput_ave = |
| (float)(8 * ((float)totalcumulatedBytes) / ((float)elapsed_time)); |
| throughput_raw_ave = |
| (float)(8 * ((float)totalcumulatedRawBytes) / ((float)elapsed_time)); |
| } |
| |
| if (decrementValue > 1000) { |
| cumulatedBytes = 0; |
| printf( |
| "ElapsedTime(ms): %ld, throughput(kbps): %2.2f (%2.2f/%2.2f) " |
| "Ave:(%2.2f) Raw Ave: (%2.2f), AudioPER:%2.2f%%, ( %d lost over %d " |
| "sent) \n", |
| elapsed_time, throughput, throughput_min, throughput_max, |
| throughput_ave, throughput_raw_ave, |
| (double)(100 * (double)nbFrameLost / |
| (double)(nbFrameLost + nbFrameReceived)), |
| nbFrameLost, nbFrameReceived + nbFrameLost); |
| } |
| |
| // Throughput estimation |
| if (frame_type == RAS_START_CMD) { |
| printf("===> AUDIO START <=== \n"); |
| audioResetStream(); |
| streamStarted = TRUE; |
| } else if (frame_type == RAS_DATA_TIC1_CMD) { |
| if (!streamStarted) { |
| audioResetStream(); |
| streamStarted = TRUE; |
| } |
| nbFrameReceived++; |
| gettimeofday(&prevPacket, NULL); |
| if (PrevSeqNum + 1 != SeqNum) { |
| if (SeqNum < (PrevSeqNum + 1)) { |
| nbFrameLost += 32 + SeqNum - (PrevSeqNum + 1); |
| } else |
| nbFrameLost += SeqNum - (PrevSeqNum + 1); |
| printf("FRAME LOST !!!!(%d != %d) (%d nbFrameLost for %d sent\n", |
| PrevSeqNum + 1, SeqNum, nbFrameLost, |
| nbFrameLost + nbFrameReceived); |
| } |
| |
| if (SeqNum == 31) |
| PrevSeqNum = -1; |
| else |
| PrevSeqNum = SeqNum; |
| |
| // Decode Frame if any exist. |
| if (previousFrameExist) { |
| short temp[1024]; |
| unsigned short decLength; |
| |
| // printf("decode Frame %d\n", PrevSeqNum ); |
| RAS_Decode(RAS_DECODE_TI_TYPE1, audioFrame, audio_data_len, temp, |
| &decLength); |
| if (fout_wav != NULL) { |
| /*Write the decoded audio to file*/ |
| fwrite(temp, sizeof(short), decLength / 2, fout_wav); |
| } |
| |
| if (fout_tic1 != NULL) { |
| int8 temp2[512]; |
| temp2[0] = audio_data_len; |
| memcpy(&temp2[1], audioFrame, audio_data_len); |
| |
| /*Write the decoded audio to file*/ |
| fwrite(temp2, sizeof(char), audio_data_len + 1, fout_tic1); |
| } |
| } |
| |
| previousFrameExist = 1; |
| |
| // Store Data in audio frame: |
| audioFrameIndex = 0; |
| audio_data_len = Data_len; // Remove audio frame Header |
| for (i = 0; i < Data_len; i++) audioFrame[audioFrameIndex++] = pdu[i + 4]; |
| |
| } else if (frame_type == RAS_STOP_CMD) { |
| printf("===> AUDIO STOP <=== \n"); |
| // Stop Frame |
| fflush(fout_wav); |
| fclose(fout_wav); |
| fout_wav = NULL; |
| fflush(fout_tic1); |
| fclose(fout_tic1); |
| previousFrameExist = 0; |
| fout_tic1 = NULL; |
| |
| // Need to add File size in the header of the wav file |
| { |
| int filesize; |
| unsigned char file[4]; |
| fout_wav = fopen(outFile_wav, "r+b"); |
| if (fout_wav != NULL) { |
| printf("===> Wav File open for length update: %s <=== \n", |
| outFile_wav); |
| } else { |
| perror("fopen5:"); |
| exit(-1); |
| } |
| fseek(fout_wav, 0L, SEEK_END); |
| filesize = ftell(fout_wav); |
| |
| file[0] = (unsigned char)(((filesize - 44) & 0xFF)); |
| file[1] = (unsigned char)(((filesize - 44) & 0xFF00) >> 8); |
| file[2] = (unsigned char)(((filesize - 44) & 0xFF0000) >> 16); |
| file[3] = (unsigned char)(((filesize - 44) & 0xFF000000) >> 24); |
| fseek(fout_wav, 40, SEEK_SET); |
| fwrite(file, 1, 4, fout_wav); |
| fclose(fout_wav); |
| fout_wav = NULL; |
| } |
| file_open = FALSE; |
| } |
| } |
| |
| int main(int argc, char **argv) { |
| int attframecnt = 0; |
| int bytes_read = 0; |
| int num_bytes = 0; |
| int total_bytes = 0; |
| int read_state = 0; |
| unsigned char readbuf[256]; |
| unsigned char dummybuf[256]; |
| |
| while (1) { |
| pthread_mutex_lock(&audio_mutex); |
| { |
| // printf("Open reading pipe ...\n"); |
| fp = open(FIFO_BTD2AUDIO_FILE, O_RDONLY); |
| if (fp == -1) { |
| printf("can't open the pipe\n"); |
| exit(-1); |
| } |
| |
| // Read a single byte to know the length of the data |
| bytes_read = read(fp, &num_bytes, 1); |
| printf("%d bytes of Data (bytes to read further=%d): \n", bytes_read, |
| num_bytes); |
| if ((bytes_read) && (num_bytes == 4)) { |
| printf("Reading %d bytes of Audio Frame\n", num_bytes); |
| bytes_read = read(fp, &readbuf[0], num_bytes); |
| total_bytes += bytes_read; |
| |
| printf("Submitting Audio Frame. Size=%d\n", total_bytes); |
| |
| // Call Audio protocol Handler: |
| audio_ParseData(&readbuf[0], total_bytes); |
| total_bytes = 0; |
| |
| } else if ((bytes_read) && (num_bytes == 23)) { |
| if (read_state == 0) { |
| int rasFrame = 0; |
| bytes_read = read(fp, &readbuf[total_bytes], num_bytes); |
| total_bytes += bytes_read; |
| printf( |
| "Received %d bytes of Data (total_bytes=%d), retrieve data: \n", |
| bytes_read, total_bytes); |
| |
| rasFrame = readbuf[3] & 0x7; |
| if (rasFrame == 0x01) { |
| // Reading Complete Audio Frame |
| read_state = 1; |
| attframecnt = 0; |
| } |
| } |
| |
| if (read_state == 1) { |
| /* |
| //Read a single byte to know |
| the length of the data |
| bytes_read = read(fp, |
| &num_bytes, 1); |
| printf("%d bytes of Data |
| (bytes to read further=%d): \n", bytes_read, num_bytes); |
| // printf("Bytes to read = |
| %d\n", |
| num_bytes); |
| if( (bytes_read) && (num_bytes |
| == 23)) |
| { |
| */ |
| // Read the ATT Header data(3 Bytes) to Dummy file |
| bytes_read = read(fp, &dummybuf[0], 3); |
| // Read Actual data to readbuf |
| bytes_read = read(fp, &readbuf[total_bytes], (num_bytes - 3)); |
| total_bytes += bytes_read; |
| printf("Received %d bytes of Data (total_bytes=%d): \n", bytes_read, |
| total_bytes); |
| attframecnt += 1; |
| /* } |
| else |
| { |
| if(bytes_read) |
| { |
| //Read the ATT frame |
| to Dummy buffer |
| printf("Error while |
| reading Audio ATT Frame. Only %d bytes\n", num_bytes); |
| bytes_read = read(fp, |
| &dummybuf[0], num_bytes); |
| printf("Audio noti: |
| Len: %d, Data: (0) 0x%x, Data: (1) 0x%x, Data: (2) 0x%x, Data: (3) |
| 0x%x, (4) 0x%x, (5) 0x%x, (6) 0x%x, (7) 0x%x, (8) 0x%x, (9) 0x%x, |
| (10) 0x%x, (11) 0x%x, (12) 0x%x, (19) 0x%x, (20) 0x%x, (21) 0x%x, |
| (22) 0x%x ", num_bytes, dummybuf[0], dummybuf[1], dummybuf[2], |
| dummybuf[3], dummybuf[4], dummybuf[5], dummybuf[6], dummybuf[7], |
| dummybuf[8], dummybuf[9], dummybuf[10], dummybuf[11], dummybuf[12], |
| dummybuf[num_bytes-4], dummybuf[num_bytes-3], |
| dummybuf[num_bytes-2], dummybuf[num_bytes-1]); |
| |
| } |
| } |
| */ |
| } |
| |
| if (attframecnt > 4) { |
| printf("Submitting Audio Frame. Size=%d\n", total_bytes); |
| // Call Audio protocol Handler: |
| audio_ParseData(&readbuf[0], total_bytes); |
| read_state = 0; |
| total_bytes = 0; |
| } |
| |
| } else { |
| if (bytes_read) { |
| // Read the ATT frame to Dummy buffer |
| bytes_read = read(fp, &dummybuf[0], num_bytes); |
| printf("Ignoring ATT Frame\n"); |
| } else { |
| printf("End of Pipe Reached. Closing Pipe\n"); |
| } |
| } |
| |
| // Send Data Back to the Coordinator or End Device |
| // printf("\n"); |
| |
| bytes_read = 0; |
| num_bytes = 0; |
| |
| printf("Close reading pipe...\n"); |
| close(fp); |
| } |
| pthread_mutex_unlock(&audio_mutex); |
| |
| // msleep(500); |
| } |
| |
| printf("Exiting App...\n"); |
| } |
