21 #include "driver_interface.h"    22 #include "JackThreadedDriver.h"    23 #include "JackDriverLoader.h"    24 #include "JackOSSDriver.h"    25 #include "JackEngineControl.h"    26 #include "JackGraphManager.h"    27 #include "JackError.h"    29 #include "JackShmMem.h"    32 #include <sys/ioctl.h>    33 #include <sys/soundcard.h>    46 #define CYCLE_POINTS 500000    49     jack_time_t fBeforeRead;
    50     jack_time_t fAfterRead;
    51     jack_time_t fAfterReadConvert;
    52     jack_time_t fBeforeWrite;
    53     jack_time_t fAfterWrite;
    54     jack_time_t fBeforeWriteConvert;
    57 struct OSSCycleTable {
    58     jack_time_t fBeforeFirstWrite;
    59     jack_time_t fAfterFirstWrite;
    60     OSSCycle fTable[CYCLE_POINTS];
    63 OSSCycleTable gCycleTable;
    68 inline int int2pow2(
int x)      { 
int r = 0; 
while ((1 << r) < x) r++; 
return r; }
    70 static inline void CopyAndConvertIn(jack_sample_t *dst, 
void *src, 
size_t nframes, 
int channel, 
int chcount, 
int bits)
    75                     signed short *s16src = (
signed short*)src;
    77             sample_move_dS_s16(dst, (
char*)s16src, nframes, chcount<<1);
    81                         signed int *s32src = (
signed int*)src;
    83             sample_move_dS_s24(dst, (
char*)s32src, nframes, chcount<<2);
    87                         signed int *s32src = (
signed int*)src;
    89             sample_move_dS_s32u24(dst, (
char*)s32src, nframes, chcount<<2);
    95 static inline void CopyAndConvertOut(
void *dst, jack_sample_t *src, 
size_t nframes, 
int channel, 
int chcount, 
int bits)
   100                         signed short *s16dst = (
signed short*)dst;
   102             sample_move_d16_sS((
char*)s16dst, src, nframes, chcount<<1, NULL); 
   106                         signed int *s32dst = (
signed int*)dst;
   108             sample_move_d24_sS((
char*)s32dst, src, nframes, chcount<<2, NULL); 
   112             signed int *s32dst = (
signed int*)dst;
   114             sample_move_d32u24_sS((
char*)s32dst, src, nframes, chcount<<2, NULL);
   120 void JackOSSDriver::SetSampleFormat()
   125             fSampleFormat = AFMT_S24_NE;
   126             fSampleSize = 
sizeof(int);
   129             fSampleFormat = AFMT_S32_NE;
   130             fSampleSize = 
sizeof(int);
   134             fSampleFormat = AFMT_S16_NE;
   135             fSampleSize = 
sizeof(short);
   140 void JackOSSDriver::DisplayDeviceInfo()
   143     oss_audioinfo ai_in, ai_out;
   144     memset(&info, 0, 
sizeof(audio_buf_info));
   148     jack_info(
"Audio Interface Description :");
   149     jack_info(
"Sampling Frequency : %d, Sample Format : %d, Mode : %d", fEngineControl->fSampleRate, fSampleFormat, fRWMode);
   151     if (fRWMode & kWrite) {
   154         if (ioctl(fOutFD, OSS_SYSINFO, &si) == -1) {
   155             jack_error(
"JackOSSDriver::DisplayDeviceInfo OSS_SYSINFO failed : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   159             jack_info(
"OSS version num %d", si.versionnum);
   160             jack_info(
"OSS numaudios %d", si.numaudios);
   161             jack_info(
"OSS numaudioengines %d", si.numaudioengines);
   162             jack_info(
"OSS numcards %d", si.numcards);
   165         jack_info(
"Output capabilities - %d channels : ", fPlaybackChannels);
   166         jack_info(
"Output block size = %d", fOutputBufferSize);
   168         if (ioctl(fOutFD, SNDCTL_DSP_GETOSPACE, &info) == -1)  {
   169             jack_error(
"JackOSSDriver::DisplayDeviceInfo SNDCTL_DSP_GETOSPACE failed : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   171             jack_info(
"output space info: fragments = %d, fragstotal = %d, fragsize = %d, bytes = %d",
   172                 info.fragments, info.fragstotal, info.fragsize, info.bytes);
   175         if (ioctl(fOutFD, SNDCTL_DSP_GETCAPS, &cap) == -1)  {
   176             jack_error(
"JackOSSDriver::DisplayDeviceInfo SNDCTL_DSP_GETCAPS failed : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   178             if (cap & DSP_CAP_DUPLEX)   
jack_info(
" DSP_CAP_DUPLEX");
   179             if (cap & DSP_CAP_REALTIME) 
jack_info(
" DSP_CAP_REALTIME");
   180             if (cap & DSP_CAP_BATCH)    
jack_info(
" DSP_CAP_BATCH");
   181             if (cap & DSP_CAP_COPROC)   
jack_info(
" DSP_CAP_COPROC");
   182             if (cap & DSP_CAP_TRIGGER)  
jack_info(
" DSP_CAP_TRIGGER");
   183             if (cap & DSP_CAP_MMAP)     
jack_info(
" DSP_CAP_MMAP");
   184             if (cap & DSP_CAP_MULTI)    
jack_info(
" DSP_CAP_MULTI");
   185             if (cap & DSP_CAP_BIND)     
jack_info(
" DSP_CAP_BIND");
   189     if (fRWMode & kRead) {
   192         if (ioctl(fInFD, OSS_SYSINFO, &si) == -1) {
   193             jack_error(
"JackOSSDriver::DisplayDeviceInfo OSS_SYSINFO failed : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   197             jack_info(
"OSS version num %d", si.versionnum);
   198             jack_info(
"OSS numaudios %d", si.numaudios);
   199             jack_info(
"OSS numaudioengines %d", si.numaudioengines);
   200             jack_info(
"OSS numcards %d", si.numcards);
   203         jack_info(
"Input capabilities - %d channels : ", fCaptureChannels);
   204         jack_info(
"Input block size = %d", fInputBufferSize);
   206         if (ioctl(fInFD, SNDCTL_DSP_GETISPACE, &info) == -1) {
   207             jack_error(
"JackOSSDriver::DisplayDeviceInfo SNDCTL_DSP_GETOSPACE failed : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   209             jack_info(
"input space info: fragments = %d, fragstotal = %d, fragsize = %d, bytes = %d",
   210                 info.fragments, info.fragstotal, info.fragsize, info.bytes);
   213         if (ioctl(fInFD, SNDCTL_DSP_GETCAPS, &cap) == -1) {
   214             jack_error(
"JackOSSDriver::DisplayDeviceInfo SNDCTL_DSP_GETCAPS failed : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   216             if (cap & DSP_CAP_DUPLEX)   
jack_info(
" DSP_CAP_DUPLEX");
   217             if (cap & DSP_CAP_REALTIME) 
jack_info(
" DSP_CAP_REALTIME");
   218             if (cap & DSP_CAP_BATCH)    
jack_info(
" DSP_CAP_BATCH");
   219             if (cap & DSP_CAP_COPROC)   
jack_info(
" DSP_CAP_COPROC");
   220             if (cap & DSP_CAP_TRIGGER)  
jack_info(
" DSP_CAP_TRIGGER");
   221             if (cap & DSP_CAP_MMAP)     
jack_info(
" DSP_CAP_MMAP");
   222             if (cap & DSP_CAP_MULTI)    
jack_info(
" DSP_CAP_MULTI");
   223             if (cap & DSP_CAP_BIND)     
jack_info(
" DSP_CAP_BIND");
   227     if (ai_in.rate_source != ai_out.rate_source) {
   228         jack_info(
"Warning : input and output are not necessarily driven by the same clock!");
   232 int JackOSSDriver::OpenInput()
   236     int cur_capture_channels;
   237     int cur_sample_format;
   238     jack_nframes_t cur_sample_rate;
   240     if (fCaptureChannels == 0) fCaptureChannels = 2;
   242     if ((fInFD = open(fCaptureDriverName, O_RDONLY | ((fExcl) ? O_EXCL : 0))) < 0) {
   243         jack_error(
"JackOSSDriver::OpenInput failed to open device : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   247     jack_log(
"JackOSSDriver::OpenInput input fInFD = %d", fInFD);
   250         if (ioctl(fInFD, SNDCTL_DSP_COOKEDMODE, &flags) == -1) {
   251             jack_error(
"JackOSSDriver::OpenInput failed to set cooked mode : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   256     gFragFormat = (2 << 16) + int2pow2(fEngineControl->fBufferSize * fSampleSize * fCaptureChannels);
   257     if (ioctl(fInFD, SNDCTL_DSP_SETFRAGMENT, &gFragFormat) == -1) {
   258         jack_error(
"JackOSSDriver::OpenInput failed to set fragments : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   262     cur_sample_format = fSampleFormat;
   263     if (ioctl(fInFD, SNDCTL_DSP_SETFMT, &fSampleFormat) == -1) {
   264         jack_error(
"JackOSSDriver::OpenInput failed to set format : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   267     if (cur_sample_format != fSampleFormat) {
   268         jack_info(
"JackOSSDriver::OpenInput driver forced the sample format %ld", fSampleFormat);
   271     cur_capture_channels = fCaptureChannels;
   272     if (ioctl(fInFD, SNDCTL_DSP_CHANNELS, &fCaptureChannels) == -1) {
   273         jack_error(
"JackOSSDriver::OpenInput failed to set channels : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   276     if (cur_capture_channels != fCaptureChannels) {
   277         jack_info(
"JackOSSDriver::OpenInput driver forced the number of capture channels %ld", fCaptureChannels);
   280     cur_sample_rate = fEngineControl->fSampleRate;
   281     if (ioctl(fInFD, SNDCTL_DSP_SPEED, &fEngineControl->fSampleRate) == -1) {
   282         jack_error(
"JackOSSDriver::OpenInput failed to set sample rate : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   285     if (cur_sample_rate != fEngineControl->fSampleRate) {
   286         jack_info(
"JackOSSDriver::OpenInput driver forced the sample rate %ld", fEngineControl->fSampleRate);
   289     fInputBufferSize = 0;
   290     if (ioctl(fInFD, SNDCTL_DSP_GETBLKSIZE, &fInputBufferSize) == -1) {
   291         jack_error(
"JackOSSDriver::OpenInput failed to get fragments : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   295     if (fInputBufferSize != fEngineControl->fBufferSize * fSampleSize * fCaptureChannels) {
   297            int new_buffer_size = fInputBufferSize / (fSampleSize * fCaptureChannels);
   298            jack_info(
"JackOSSDriver::OpenInput driver forced buffer size %ld", new_buffer_size);
   299            JackAudioDriver::SetBufferSize(new_buffer_size); 
   301            jack_error(
"JackOSSDriver::OpenInput wanted buffer size cannot be obtained");
   306     fInputBuffer = (
void*)calloc(fInputBufferSize, 1);
   307     assert(fInputBuffer);
   315 int JackOSSDriver::OpenOutput()
   319     int cur_sample_format;
   320     int cur_playback_channels;
   321     jack_nframes_t cur_sample_rate;
   323     if (fPlaybackChannels == 0) fPlaybackChannels = 2;
   325     if ((fOutFD = open(fPlaybackDriverName, O_WRONLY | ((fExcl) ? O_EXCL : 0))) < 0) {
   326        jack_error(
"JackOSSDriver::OpenOutput failed to open device : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   330     jack_log(
"JackOSSDriver::OpenOutput output fOutFD = %d", fOutFD);
   333         if (ioctl(fOutFD, SNDCTL_DSP_COOKEDMODE, &flags) == -1) {
   334             jack_error(
"JackOSSDriver::OpenOutput failed to set cooked mode : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   339     gFragFormat = (2 << 16) + int2pow2(fEngineControl->fBufferSize * fSampleSize * fPlaybackChannels);
   340     if (ioctl(fOutFD, SNDCTL_DSP_SETFRAGMENT, &gFragFormat) == -1) {
   341         jack_error(
"JackOSSDriver::OpenOutput failed to set fragments : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   345     cur_sample_format = fSampleFormat;
   346     if (ioctl(fOutFD, SNDCTL_DSP_SETFMT, &fSampleFormat) == -1) {
   347         jack_error(
"JackOSSDriver::OpenOutput failed to set format : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   350     if (cur_sample_format != fSampleFormat) {
   351         jack_info(
"JackOSSDriver::OpenOutput driver forced the sample format %ld", fSampleFormat);
   354     cur_playback_channels = fPlaybackChannels;
   355     if (ioctl(fOutFD, SNDCTL_DSP_CHANNELS, &fPlaybackChannels) == -1) {
   356         jack_error(
"JackOSSDriver::OpenOutput failed to set channels : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   359     if (cur_playback_channels != fPlaybackChannels) {
   360         jack_info(
"JackOSSDriver::OpenOutput driver forced the number of playback channels %ld", fPlaybackChannels);
   363     cur_sample_rate = fEngineControl->fSampleRate;
   364     if (ioctl(fOutFD, SNDCTL_DSP_SPEED, &fEngineControl->fSampleRate) == -1) {
   365         jack_error(
"JackOSSDriver::OpenOutput failed to set sample rate : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   368     if (cur_sample_rate != fEngineControl->fSampleRate) {
   369         jack_info(
"JackOSSDriver::OpenInput driver forced the sample rate %ld", fEngineControl->fSampleRate);
   372     fOutputBufferSize = 0;
   373     if (ioctl(fOutFD, SNDCTL_DSP_GETBLKSIZE, &fOutputBufferSize) == -1) {
   374         jack_error(
"JackOSSDriver::OpenOutput failed to get fragments : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   378     if (fOutputBufferSize != fEngineControl->fBufferSize * fSampleSize * fPlaybackChannels) {
   380            int new_buffer_size = fOutputBufferSize / (fSampleSize * fPlaybackChannels);
   381            jack_info(
"JackOSSDriver::OpenOutput driver forced buffer size %ld", new_buffer_size);
   382            JackAudioDriver::SetBufferSize(new_buffer_size); 
   384            jack_error(
"JackOSSDriver::OpenInput wanted buffer size cannot be obtained");
   389     fOutputBuffer = (
void*)calloc(fOutputBufferSize, 1);
   391     assert(fOutputBuffer);
   399 int JackOSSDriver::Open(jack_nframes_t nframes,
   401                       jack_nframes_t samplerate,
   408                       const char* capture_driver_uid,
   409                       const char* playback_driver_uid,
   410                       jack_nframes_t capture_latency,
   411                       jack_nframes_t playback_latency,
   416     if (JackAudioDriver::Open(nframes, samplerate, capturing, playing, inchannels, outchannels, monitor,
   417         capture_driver_uid, playback_driver_uid, capture_latency, playback_latency) != 0) {
   421         if (!fEngineControl->fSyncMode) {
   422             jack_error(
"Cannot run in asynchronous mode, use the -S parameter for jackd");
   426         fRWMode |= ((capturing) ? kRead : 0);
   427         fRWMode |= ((playing) ? kWrite : 0);
   429         fIgnoreHW = ignorehwbuf;
   430         fNperiods = user_nperiods;
   435         memset(&gCycleTable, 0, 
sizeof(gCycleTable));
   447 int JackOSSDriver::Close()
   450     FILE* file = fopen(
"OSSProfiling.log", 
"w");
   453         jack_info(
"Writing OSS driver timing data....");
   454         for (
int i = 1; i < gCycleCount; i++) {
   455             int d1 = gCycleTable.fTable[i].fAfterRead - gCycleTable.fTable[i].fBeforeRead;
   456             int d2 = gCycleTable.fTable[i].fAfterReadConvert - gCycleTable.fTable[i].fAfterRead;
   457             int d3 = gCycleTable.fTable[i].fAfterWrite - gCycleTable.fTable[i].fBeforeWrite;
   458             int d4 = gCycleTable.fTable[i].fBeforeWrite - gCycleTable.fTable[i].fBeforeWriteConvert;
   459             fprintf(file, 
"%d \t %d \t %d \t %d \t \n", d1, d2, d3, d4);
   463         jack_error(
"JackOSSDriver::Close : cannot open OSSProfiling.log file");
   466     file = fopen(
"TimingOSS.plot", 
"w");
   469         jack_error(
"JackOSSDriver::Close cannot open TimingOSS.plot file");
   472         fprintf(file, 
"set grid\n");
   473         fprintf(file, 
"set title \"OSS audio driver timing\"\n");
   474         fprintf(file, 
"set xlabel \"audio cycles\"\n");
   475         fprintf(file, 
"set ylabel \"usec\"\n");
   476         fprintf(file, 
"plot \"OSSProfiling.log\" using 1 title \"Driver read wait\" with lines, \   477                             \"OSSProfiling.log\" using 2 title \"Driver read convert duration\" with lines, \   478                             \"OSSProfiling.log\" using 3 title \"Driver write wait\" with lines, \   479                             \"OSSProfiling.log\" using 4 title \"Driver write convert duration\" with lines\n");
   481         fprintf(file, 
"set output 'TimingOSS.pdf\n");
   482         fprintf(file, 
"set terminal pdf\n");
   484         fprintf(file, 
"set grid\n");
   485         fprintf(file, 
"set title \"OSS audio driver timing\"\n");
   486         fprintf(file, 
"set xlabel \"audio cycles\"\n");
   487         fprintf(file, 
"set ylabel \"usec\"\n");
   488         fprintf(file, 
"plot \"OSSProfiling.log\" using 1 title \"Driver read wait\" with lines, \   489                             \"OSSProfiling.log\" using 2 title \"Driver read convert duration\" with lines, \   490                             \"OSSProfiling.log\" using 3 title \"Driver write wait\" with lines, \   491                             \"OSSProfiling.log\" using 4 title \"Driver write convert duration\" with lines\n");
   496     int res = JackAudioDriver::Close();
   502 int JackOSSDriver::OpenAux()
   506     if ((fRWMode & kRead) && (OpenInput() < 0)) {
   510     if ((fRWMode & kWrite) && (OpenOutput() < 0)) {
   529 void JackOSSDriver::CloseAux()
   531     if (fRWMode & kRead && fInFD > 0) {
   536     if (fRWMode & kWrite && fOutFD > 0) {
   547     fOutputBuffer = NULL;
   550 int JackOSSDriver::Read()
   554         JackDriver::CycleTakeBeginTime();
   561     gCycleTable.fTable[gCycleCount].fBeforeRead = GetMicroSeconds();
   565     count = ::read(fInFD, fInputBuffer, fInputBufferSize);
   568     if (count > 0 && count != (
int)fInputBufferSize)
   569         jack_log(
"JackOSSDriver::Read count = %ld", count / (fSampleSize * fCaptureChannels));
   570     gCycleTable.fTable[gCycleCount].fAfterRead = GetMicroSeconds();
   574     if (ioctl(fInFD, SNDCTL_DSP_GETERROR, &ei_in) == 0) {
   576         if (ei_in.rec_overruns > 0 ) {
   578             jack_time_t cur_time = GetMicroSeconds();
   579             NotifyXRun(cur_time, 
float(cur_time - fBeginDateUst));   
   582         if (ei_in.rec_errorcount > 0 && ei_in.rec_lasterror != 0) {
   583             jack_error(
"%d OSS rec event(s), last=%05d:%d", ei_in.rec_errorcount, ei_in.rec_lasterror, ei_in.rec_errorparm);
   588         jack_log(
"JackOSSDriver::Read error = %s", strerror(errno));
   590     } 
else if (count < (
int)fInputBufferSize) {
   591         jack_error(
"JackOSSDriver::Read error bytes read = %ld", count);
   596         JackDriver::CycleTakeBeginTime();
   597         for (
int i = 0; i < fCaptureChannels; i++) {
   598             if (fGraphManager->GetConnectionsNum(fCapturePortList[i]) > 0) {
   599                 CopyAndConvertIn(GetInputBuffer(i), fInputBuffer, fEngineControl->fBufferSize, i, fCaptureChannels, fBits);
   604         gCycleTable.fTable[gCycleCount].fAfterReadConvert = GetMicroSeconds();
   611 int JackOSSDriver::Write()
   615         JackDriver::CycleTakeEndTime();
   620     audio_errinfo ei_out;
   626         memset(fOutputBuffer, 0, fOutputBufferSize);
   629         for (
int i = 0; i < fNperiods; i++) {
   630            count = ::write(fOutFD, fOutputBuffer, fOutputBufferSize);
   631            if (count < (
int)fOutputBufferSize) {
   632                 jack_error(
"JackOSSDriver::Write error bytes written = %ld", count);
   638         if (ioctl(fOutFD, SNDCTL_DSP_GETODELAY, &delay) == -1) {
   639             jack_error(
"JackOSSDriver::Write error get out delay : %s@%i, errno = %d", __FILE__, __LINE__, errno);
   643         delay /= fSampleSize * fPlaybackChannels;
   644         jack_info(
"JackOSSDriver::Write output latency frames = %ld", delay);
   648     gCycleTable.fTable[gCycleCount].fBeforeWriteConvert = GetMicroSeconds();
   651     memset(fOutputBuffer, 0, fOutputBufferSize);
   652     for (
int i = 0; i < fPlaybackChannels; i++) {
   653         if (fGraphManager->GetConnectionsNum(fPlaybackPortList[i]) > 0) {
   654             CopyAndConvertOut(fOutputBuffer, GetOutputBuffer(i), fEngineControl->fBufferSize, i, fPlaybackChannels, fBits);
   659     gCycleTable.fTable[gCycleCount].fBeforeWrite = GetMicroSeconds();
   663     JackDriver::CycleTakeEndTime();
   664     count = ::write(fOutFD, fOutputBuffer, fOutputBufferSize);
   667     if (count > 0 && count != (
int)fOutputBufferSize)
   668         jack_log(
"JackOSSDriver::Write count = %ld", count / (fSampleSize * fPlaybackChannels));
   669     gCycleTable.fTable[gCycleCount].fAfterWrite = GetMicroSeconds();
   670     gCycleCount = (gCycleCount == CYCLE_POINTS - 1) ? gCycleCount: gCycleCount + 1;
   674     if (ioctl(fOutFD, SNDCTL_DSP_GETERROR, &ei_out) == 0) {
   676         if (ei_out.play_underruns > 0) {
   678             jack_time_t cur_time = GetMicroSeconds();
   679             NotifyXRun(cur_time, 
float(cur_time - fBeginDateUst));   
   682         if (ei_out.play_errorcount > 0 && ei_out.play_lasterror != 0) {
   683             jack_error(
"%d OSS play event(s), last=%05d:%d",ei_out.play_errorcount, ei_out.play_lasterror, ei_out.play_errorparm);
   688         jack_log(
"JackOSSDriver::Write error = %s", strerror(errno));
   690     } 
else if (count < (
int)fOutputBufferSize) {
   691         jack_error(
"JackOSSDriver::Write error bytes written = %ld", count);
   698 int JackOSSDriver::SetBufferSize(jack_nframes_t buffer_size)
   701     JackAudioDriver::SetBufferSize(buffer_size); 
   705 int JackOSSDriver::ProcessSync()
   709         jack_error(
"ProcessSync: read error, skip cycle");
   721         jack_error(
"JackAudioDriver::ProcessSync: write error, skip cycle");
   741     desc = jack_driver_descriptor_construct(
"oss", JackDriverMaster, 
"OSS API based audio backend", &filler);
   743     value.ui = OSS_DRIVER_DEF_FS;
   744     jack_driver_descriptor_add_parameter(desc, &filler, 
"rate", 
'r', JackDriverParamUInt, &value, NULL, 
"Sample rate", NULL);
   746     value.ui = OSS_DRIVER_DEF_BLKSIZE;
   747     jack_driver_descriptor_add_parameter(desc, &filler, 
"period", 
'p', JackDriverParamUInt, &value, NULL, 
"Frames per period", NULL);
   749     value.ui = OSS_DRIVER_DEF_NPERIODS;
   750     jack_driver_descriptor_add_parameter(desc, &filler, 
"nperiods", 
'n', JackDriverParamUInt, &value, NULL, 
"Number of periods to prefill output buffer", NULL);
   752     value.i = OSS_DRIVER_DEF_BITS;
   753     jack_driver_descriptor_add_parameter(desc, &filler, 
"wordlength", 
'w', JackDriverParamInt, &value, NULL, 
"Word length", NULL);
   755     value.ui = OSS_DRIVER_DEF_INS;
   756     jack_driver_descriptor_add_parameter(desc, &filler, 
"inchannels", 
'i', JackDriverParamUInt, &value, NULL, 
"Capture channels", NULL);
   758     value.ui = OSS_DRIVER_DEF_OUTS;
   759     jack_driver_descriptor_add_parameter(desc, &filler, 
"outchannels", 
'o', JackDriverParamUInt, &value, NULL, 
"Playback channels", NULL);
   762     jack_driver_descriptor_add_parameter(desc, &filler, 
"excl", 
'e', JackDriverParamBool, &value, NULL, 
"Exclusif (O_EXCL) access mode", NULL);
   764     strcpy(value.str, OSS_DRIVER_DEF_DEV);
   765     jack_driver_descriptor_add_parameter(desc, &filler, 
"capture", 
'C', JackDriverParamString, &value, NULL, 
"Input device", NULL);
   766     jack_driver_descriptor_add_parameter(desc, &filler, 
"playback", 
'P', JackDriverParamString, &value, NULL, 
"Output device", NULL);
   767     jack_driver_descriptor_add_parameter(desc, &filler, 
"device", 
'd', JackDriverParamString, &value, NULL, 
"OSS device name", NULL);
   770     jack_driver_descriptor_add_parameter(desc, &filler, 
"ignorehwbuf", 
'b', JackDriverParamBool, &value, NULL, 
"Ignore hardware period size", NULL);
   773     jack_driver_descriptor_add_parameter(desc, &filler, 
"input-latency", 
'I', JackDriverParamUInt, &value, NULL, 
"Extra input latency", NULL);
   774     jack_driver_descriptor_add_parameter(desc, &filler, 
"output-latency", 
'O', JackDriverParamUInt, &value, NULL, 
"Extra output latency", NULL);
   781     int bits = OSS_DRIVER_DEF_BITS;
   782     jack_nframes_t srate = OSS_DRIVER_DEF_FS;
   783     jack_nframes_t frames_per_interrupt = OSS_DRIVER_DEF_BLKSIZE;
   784     const char* capture_pcm_name = OSS_DRIVER_DEF_DEV;
   785     const char* playback_pcm_name = OSS_DRIVER_DEF_DEV;
   786     bool capture = 
false;
   787     bool playback = 
false;
   790     bool monitor = 
false;
   792     unsigned int nperiods = OSS_DRIVER_DEF_NPERIODS;
   795     bool ignorehwbuf = 
false;
   796     jack_nframes_t systemic_input_latency = 0;
   797     jack_nframes_t systemic_output_latency = 0;
   799     for (node = params; node; node = jack_slist_next(node)) {
   803         switch (param->character) {
   806             srate = param->value.ui;
   810             frames_per_interrupt = (
unsigned int)param->value.ui;
   814             nperiods = (
unsigned int)param->value.ui;
   818             bits = param->value.i;
   822             chan_in = (int)param->value.ui;
   826             chan_out = (
int)param->value.ui;
   831             if (strcmp(param->value.str, 
"none") != 0) {
   832                 capture_pcm_name = param->value.str;
   838             if (strcmp(param->value.str, 
"none") != 0) {
   839                 playback_pcm_name = param->value.str;
   844             playback_pcm_name = param->value.str;
   845             capture_pcm_name = param->value.str;
   857             systemic_input_latency = param->value.ui;
   861             systemic_output_latency = param->value.ui;
   867     if (!capture && !playback) {
   876     if (oss_driver->Open(frames_per_interrupt, nperiods, srate, capture, playback, chan_in, chan_out,
   877         excl, monitor, capture_pcm_name, playback_pcm_name, systemic_input_latency, systemic_output_latency, bits, ignorehwbuf) == 0) {
   878         return threaded_driver;
   880         delete threaded_driver; 
 The base class for threaded drivers using a "decorator" pattern. Threaded drivers are used with block...
Locked Engine, access to methods is serialized using a mutex. 
Inter process synchronization using POSIX semaphore. 
SERVER_EXPORT void jack_error(const char *fmt,...)
SERVER_EXPORT void jack_info(const char *fmt,...)
The base interface for drivers clients. 
SERVER_EXPORT void jack_log(const char *fmt,...)