275 lines
8.4 KiB
C++
Executable File
275 lines
8.4 KiB
C++
Executable File
/*
|
|
* Audio Library for Linux and Windows
|
|
* ===================================
|
|
* Author: DJ0ABR
|
|
*
|
|
* Author: Kurt Moraw, Ham radio: DJ0ABR, github: dj0abr
|
|
* License: GPL-3
|
|
*
|
|
* compilation:
|
|
* Windows ... Visual Studio
|
|
* Linux ... make
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#ifdef WIN32
|
|
// ignore senseless warnings invented by M$ to confuse developers
|
|
#pragma warning( disable : 4091 )
|
|
#pragma warning( disable : 4003 )
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <signal.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
#include <stdint.h>
|
|
#include <wchar.h>
|
|
|
|
#ifdef WIN32
|
|
#include "Winsock2.h"
|
|
#include "io.h"
|
|
#include <Windows.h>
|
|
#include <iostream>
|
|
#include <process.h>
|
|
#include <Tlhelp32.h>
|
|
#include <winbase.h>
|
|
#include <Shlobj.h>
|
|
#define _USE_MATH_DEFINES
|
|
#include <math.h>
|
|
#include "portaudio.h"
|
|
#include "pa_win_wasapi.h"
|
|
|
|
#pragma comment(lib, "portaudio_x86.lib")
|
|
#pragma comment(lib, "libliquid.lib")
|
|
#else
|
|
#include <sys/socket.h>
|
|
#include <unistd.h>
|
|
#include <sys/time.h>
|
|
#include <sys/ioctl.h>
|
|
#include <termios.h>
|
|
#include <sys/file.h>
|
|
#include <pthread.h>
|
|
#include <netinet/in.h>
|
|
#include <netdb.h>
|
|
#include <arpa/inet.h>
|
|
#include <pwd.h>
|
|
#include <math.h>
|
|
#include "soundio.h"
|
|
#endif
|
|
|
|
#include "liquid.h"
|
|
|
|
/*
|
|
* Sample usage:
|
|
* init sound system
|
|
* 1. kmaudio_init();
|
|
* 2. kmaudio_getDeviceList();
|
|
*
|
|
* start a capture and a playback stream
|
|
* 3. kmaudio_startCapture() using a device name returned by io_getAudioDevicelist()
|
|
* 4. kmaudio_startPlayback() using a device name returned by io_getAudioDevicelist()
|
|
*
|
|
* now everything runs in the background, no more need for the user program
|
|
* to handle sound specific data
|
|
* now we can read/write sound samples as needed by our application
|
|
* as an example: get sound from microphone and send to speaker
|
|
* process in a loop:
|
|
* 5. kmaudio_readsamples()
|
|
* 6. kmaudio_playsamples()
|
|
*
|
|
* for a working example see main(), you will need to
|
|
* replace the device names with the names in your computer
|
|
*/
|
|
|
|
/*
|
|
* initialize the audio library, create required processes
|
|
* call only once when your application starts
|
|
* returns: 0 = OK, -1 = error
|
|
*/
|
|
int kmaudio_init();
|
|
|
|
/*
|
|
* closes and frees all resources
|
|
* call only when the application exits
|
|
*/
|
|
void kmaudio_close();
|
|
|
|
/*
|
|
* read a list of all available audio devices into devlist
|
|
* the list can then be read by calling io_getAudioDevicelist()
|
|
* call any time to find new plugged in/out devices
|
|
* returns: 0=OK, -1 if error
|
|
*/
|
|
int kmaudio_getDeviceList();
|
|
|
|
/*
|
|
* starts a capturing stream from devname with samprate
|
|
* returns: id of the capture stream or -1 = error
|
|
*/
|
|
int kmaudio_startCapture(char* devname, int samprate);
|
|
|
|
/*
|
|
* starts a playback stream to devname with samprate
|
|
* returns: id of the playback stream or -1 = error
|
|
*/
|
|
|
|
int kmaudio_startPlayback(char* devname, int samprate);
|
|
|
|
/*
|
|
* plays len samples from psamp to device id
|
|
* returns: 0=ok, -1=error
|
|
* id ... device id returned by kmaudio_startPlayback
|
|
* psamp ... float array of length len with the audio data (mono)
|
|
* len ... number of float values in psamp
|
|
* volume ... 0.0f..2.0f will be multiplied with the output sample
|
|
*/
|
|
int kmaudio_playsamples(int id, float* psamp, int len, float volume);
|
|
|
|
/*
|
|
* reads len samples from device id into psamp
|
|
* returns: 0=ok, -1=error
|
|
* id ... device id returned by kmaudio_startCapture
|
|
* psamp ... float array of length len getting the audio data (mono)
|
|
* len ... number of float values to write into psamp
|
|
* volume ... 0.0f..2.0f will be multiplied with the input sample
|
|
* wait ... 1=wait for data, 0=return if not enough data available (in this case psamp will return 0,0,0...)
|
|
*/
|
|
int kmaudio_readsamples(int id, float* psamp, int len, float volume, int wait);
|
|
|
|
/*
|
|
* reads the names of detected sound devices
|
|
* *len...length of the returned string
|
|
* returns: pointer to device string
|
|
* Format of the device string:
|
|
* first byte = 3 ... ID of this string, followed by pure text:
|
|
* Active status of the following device "0" or "1"
|
|
* Name of playback devices, followed by ~
|
|
* separator ^
|
|
* Active status of the following device "0" or "1"
|
|
* Name of capture devices, followed by ~
|
|
* these names are used for calls to kmaudio_startCapture and kmaudio_startPlayback
|
|
* to select the device
|
|
*/
|
|
uint8_t* io_getAudioDevicelist(int* len);
|
|
|
|
/*
|
|
* returns the max level (within 1 second) of this stream in % (0..100)
|
|
* if the level >= 100 the signal will get clipped and distorted
|
|
*/
|
|
uint8_t kmaudio_maxlevel(int id);
|
|
|
|
/*
|
|
* closes a stream which was started by
|
|
* kmaudio_startCapture or kmaudio_startPlayback
|
|
* id ... stream ID which was returned by kmaudio_startCapture or kmaudio_startPlayback
|
|
*/
|
|
void close_stream(int id);
|
|
|
|
/*
|
|
* handle the FIFO which is used to buffer audio data
|
|
* pipenum ... stream ID which was returned by kmaudio_startCapture or kmaudio_startPlayback
|
|
* IMPORTANT: this information MUST be used to synchonize the data flow into
|
|
* the fifo. The speed is always defined by the audio sample rate
|
|
* by checking the fifo an application knows when it has to put more audio samples
|
|
* into the fifo
|
|
*/
|
|
// returns number of remaining elements (audio 16 bit short values)
|
|
int io_fifo_freespace(int pipenum);
|
|
|
|
// returns number of used elements (audio 16 bit short values)
|
|
int io_fifo_usedspace(int pipenum);
|
|
|
|
// like before, but returns a number between 0 and 100 %
|
|
int io_fifo_usedpercent(int pipenum);
|
|
|
|
// clear the fifo
|
|
void io_fifo_clear(int pipenum);
|
|
|
|
|
|
// -------- functions for internal use only --------
|
|
|
|
#define MAXDEVICES 200
|
|
#define MAXDEVNAMELENGTH 150
|
|
|
|
typedef struct _DEVLIST_ {
|
|
int index = 0; // index to this list
|
|
int active = 0; // 1=device valid, 0=possibly disconencted
|
|
char name[MAXDEVNAMELENGTH] = { 0 };// real name
|
|
int in_out = 0; // 0=capture device, 1=playback device, 2=both
|
|
int supports_44100 = 0; // 1 if supported
|
|
int supports_48000 = 0; // 1 if supported
|
|
int requested_samprate = 0; // sample rate requested by caller
|
|
int real_samprate = 0; // real sample rate of the device
|
|
int working = 0; // 0=not running, 1=initialized and working
|
|
#ifdef WIN32 // Windows using portaudio
|
|
int devnum = -1; // port audio device number
|
|
PaStreamParameters inputParameters;
|
|
PaStreamParameters outputParameters;
|
|
PaStream* capStream = NULL;
|
|
PaStream* pbStream = NULL;
|
|
#else // Linux using libsoundio
|
|
struct SoundIoDevice* io_pb_device = NULL;
|
|
struct SoundIoDevice* io_cap_device = NULL;
|
|
struct SoundIoInStream* instream = NULL;
|
|
struct SoundIoOutStream* outstream = NULL;
|
|
int stereo_mono = 2; // 1=mono, 2=stereo
|
|
char id[1000] = { 0 };
|
|
#endif
|
|
} DEVLIST;
|
|
|
|
int searchDevice(char* devname, int io);
|
|
void measure_speed_bps(int len);
|
|
void sleep_ms(int ms);
|
|
void io_write_fifo(int pipenum, float sample);
|
|
void io_write_fifo_short(int pipenum, int16_t sample);
|
|
void io_fifo_clear(int pipenum);
|
|
void init_pipes();
|
|
int io_read_fifo_num(int pipenum, float* data, int num);
|
|
int io_read_fifo(int pipenum, float* data);
|
|
int getRealSamprate(int idx);
|
|
int io_fifo_elems_avail(int pipenum);
|
|
void sleep_ms(int ms);
|
|
void io_buildAudioDevString();
|
|
void resampler_create(int devidx);
|
|
float* resample(int id, float* psamp, int len, int* pnewlen);
|
|
uint64_t getms();
|
|
void init_maxarray();
|
|
void kmaudio_detectDropouts(int id);
|
|
int io_read_fifo_num_short(int pipenum, int16_t* data, int num);
|
|
void close_capture_stream(int idx);
|
|
void close_playback_stream(int idx);
|
|
|
|
extern DEVLIST devlist[MAXDEVICES];
|
|
extern int devanz;
|
|
extern int keeprunning;
|
|
|
|
#ifndef WIN32 // Linux
|
|
int kmaudio_init_linux();
|
|
void kmaudio_close_linux();
|
|
char* getDevID(char* devname, int io, int* pidx);
|
|
|
|
extern struct SoundIo* soundio;
|
|
#endif // ndef WIN32
|
|
|