jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
jack2 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4080 Commits
7 Branches
83MB
Tree: dc8cfd399a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'dc8cfd399a'
${ noResults }
jack2/solaris/oss/JackBoomerDriver.cpp

965 lines
33KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2009 Grame

  3. 

  4. This program is free software; you can redistribute it and/or modify

  5. it under the terms of the GNU General Public License as published by

  6. the Free Software Foundation; either version 2 of the License, or

  7. (at your option) any later version.

  8. 

  9. This program is distributed in the hope that it will be useful,

  10. but WITHOUT ANY WARRANTY; without even the implied warranty of

  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  12. GNU General Public License for more details.

  13. 

  14. You should have received a copy of the GNU General Public License

  15. along with this program; if not, write to the Free Software

  16. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  17. 

  18. */

  19. 

  20. #include "driver_interface.h"

  21. #include "JackThreadedDriver.h"

  22. #include "JackDriverLoader.h"

  23. #include "JackBoomerDriver.h"

  24. #include "JackEngineControl.h"

  25. #include "JackGraphManager.h"

  26. #include "JackError.h"

  27. #include "JackTime.h"

  28. #include "JackShmMem.h"

  29. #include "JackGlobals.h"

  30. #include "memops.h"

  31. 

  32. #include <sys/ioctl.h>

  33. #include <sys/soundcard.h>

  34. #include <fcntl.h>

  35. #include <iostream>

  36. #include <assert.h>

  37. #include <stdio.h>

  38. 

  39. using namespace std;

  40. 

  41. namespace Jack

  42. {

  43. 

  44. #ifdef JACK_MONITOR

  45. 

  46. #define CYCLE_POINTS 500000

  47. 

  48. struct OSSCycle {

  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;

  55. };

  56. 

  57. struct OSSCycleTable {

  58.     jack_time_t fBeforeFirstWrite;

  59.     jack_time_t fAfterFirstWrite;

  60.     OSSCycle fTable[CYCLE_POINTS];

  61. };

  62. 

  63. OSSCycleTable gCycleTable;

  64. int gCycleReadCount = 0;

  65. int gCycleWriteCount = 0;

  66. 

  67. #endif

  68. 

  69. inline int int2pow2(int x)	{ int r = 0; while ((1 << r) < x) r++; return r; }

  70. 

  71. static inline void CopyAndConvertIn(jack_sample_t *dst, void *src, size_t nframes, int channel, int byte_skip, int bits)

  72. {

  73.     switch (bits) {

  74. 

  75. 		case 16: {

  76. 		    signed short *s16src = (signed short*)src;

  77.             s16src += channel;

  78.             sample_move_dS_s16(dst, (char*)s16src, nframes, byte_skip);

  79. 			break;

  80.         }

  81. 		case 24: {

  82. 			signed int *s32src = (signed int*)src;

  83.             s32src += channel;

  84.             sample_move_dS_s24(dst, (char*)s32src, nframes, byte_skip);

  85. 			break;

  86.         }

  87. 		case 32: {

  88. 			signed int *s32src = (signed int*)src;

  89.             s32src += channel;

  90.             sample_move_dS_s32u24(dst, (char*)s32src, nframes, byte_skip);

  91. 			break;

  92.         }

  93. 	}

  94. }

  95. 

  96. static inline void CopyAndConvertOut(void *dst, jack_sample_t *src, size_t nframes, int channel, int byte_skip, int bits)

  97. {

  98. 	switch (bits) {

  99. 

  100. 		case 16: {

  101. 			signed short *s16dst = (signed short*)dst;

  102.             s16dst += channel;

  103.             sample_move_d16_sS((char*)s16dst, src, nframes, byte_skip, NULL); // No dithering for now...

  104. 			break;

  105.         }

  106. 		case 24: {

  107. 			signed int *s32dst = (signed int*)dst;

  108.             s32dst += channel;

  109.             sample_move_d24_sS((char*)s32dst, src, nframes, byte_skip, NULL);

  110. 			break;

  111.         }

  112. 		case 32: {

  113.             signed int *s32dst = (signed int*)dst;

  114.             s32dst += channel;

  115.             sample_move_d32u24_sS((char*)s32dst, src, nframes, byte_skip, NULL);

  116. 			break;

  117.         }

  118. 	}

  119. }

  120. 

  121. void JackBoomerDriver::SetSampleFormat()

  122. {

  123.     switch (fBits) {

  124. 

  125. 	    case 24:	/* native-endian LSB aligned 24-bits in 32-bits integer */

  126.             fSampleFormat = AFMT_S24_NE;

  127.             fSampleSize = 4;

  128. 			break;

  129. 		case 32:	/* native-endian 32-bit integer */

  130.             fSampleFormat = AFMT_S32_NE;

  131.             fSampleSize = 4;

  132. 			break;

  133. 		case 16:	/* native-endian 16-bit integer */

  134. 		default:

  135.             fSampleFormat = AFMT_S16_NE;

  136.             fSampleSize = 2;

  137. 			break;

  138.     }

  139. }

  140. 

  141. void JackBoomerDriver::DisplayDeviceInfo()

  142. {

  143.     audio_buf_info info;

  144.     memset(&info, 0, sizeof(audio_buf_info));

  145.     int cap = 0;

  146. 

  147.     // Duplex cards : http://manuals.opensound.com/developer/full_duplex.html

  148.     jack_info("Audio Interface Description :");

  149.     jack_info("Sampling Frequency : %d, Sample Format : %d, Mode : %d", fEngineControl->fSampleRate, fSampleFormat, fRWMode);

  150. 

  151.     if (fRWMode & kWrite) {

  152. 

  153.         oss_sysinfo si;

  154.         if (ioctl(fOutFD, OSS_SYSINFO, &si) == -1) {

  155.             jack_error("JackBoomerDriver::DisplayDeviceInfo OSS_SYSINFO failed : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  156.         } else {

  157.             jack_info("OSS product %s", si.product);

  158.             jack_info("OSS version %s", si.version);

  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);

  163.         }

  164. 

  165.         jack_info("Output capabilities - %d channels : ", fPlaybackChannels);

  166.         jack_info("Output block size = %d", fOutputBufferSize);

  167. 

  168.         if (ioctl(fOutFD, SNDCTL_DSP_GETOSPACE, &info) == -1)  {

  169.             jack_error("JackBoomerDriver::DisplayDeviceInfo SNDCTL_DSP_GETOSPACE failed : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  170.         } else {

  171.             jack_info("output space info: fragments = %d, fragstotal = %d, fragsize = %d, bytes = %d",

  172.                 info.fragments, info.fragstotal, info.fragsize, info.bytes);

  173.             fFragmentSize = info.fragsize;

  174.         }

  175. 

  176.         if (ioctl(fOutFD, SNDCTL_DSP_GETCAPS, &cap) == -1)  {

  177.             jack_error("JackBoomerDriver::DisplayDeviceInfo SNDCTL_DSP_GETCAPS failed : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  178.         } else {

  179.             if (cap & DSP_CAP_DUPLEX) 	jack_info(" DSP_CAP_DUPLEX");

  180.             if (cap & DSP_CAP_REALTIME) jack_info(" DSP_CAP_REALTIME");

  181.             if (cap & DSP_CAP_BATCH) 	jack_info(" DSP_CAP_BATCH");

  182.             if (cap & DSP_CAP_COPROC) 	jack_info(" DSP_CAP_COPROC");

  183.             if (cap & DSP_CAP_TRIGGER)  jack_info(" DSP_CAP_TRIGGER");

  184.             if (cap & DSP_CAP_MMAP) 	jack_info(" DSP_CAP_MMAP");

  185.             if (cap & DSP_CAP_MULTI) 	jack_info(" DSP_CAP_MULTI");

  186.             if (cap & DSP_CAP_BIND) 	jack_info(" DSP_CAP_BIND");

  187.         }

  188.     }

  189. 

  190.     if (fRWMode & kRead) {

  191. 

  192.       	oss_sysinfo si;

  193.         if (ioctl(fInFD, OSS_SYSINFO, &si) == -1) {

  194.             jack_error("JackBoomerDriver::DisplayDeviceInfo OSS_SYSINFO failed : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  195.         } else {

  196.             jack_info("OSS product %s", si.product);

  197.             jack_info("OSS version %s", si.version);

  198.             jack_info("OSS version num %d", si.versionnum);

  199.             jack_info("OSS numaudios %d", si.numaudios);

  200.             jack_info("OSS numaudioengines %d", si.numaudioengines);

  201.             jack_info("OSS numcards %d", si.numcards);

  202.         }

  203. 

  204.         jack_info("Input capabilities - %d channels : ", fCaptureChannels);

  205.         jack_info("Input block size = %d", fInputBufferSize);

  206. 

  207.         if (ioctl(fInFD, SNDCTL_DSP_GETISPACE, &info) == -1) {

  208.             jack_error("JackBoomerDriver::DisplayDeviceInfo SNDCTL_DSP_GETOSPACE failed : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  209.         } else {

  210.             jack_info("input space info: fragments = %d, fragstotal = %d, fragsize = %d, bytes = %d",

  211.                 info.fragments, info.fragstotal, info.fragsize, info.bytes);

  212.         }

  213. 

  214.         if (ioctl(fInFD, SNDCTL_DSP_GETCAPS, &cap) == -1) {

  215.             jack_error("JackBoomerDriver::DisplayDeviceInfo SNDCTL_DSP_GETCAPS failed : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  216.         } else {

  217.             if (cap & DSP_CAP_DUPLEX) 	jack_info(" DSP_CAP_DUPLEX");

  218.             if (cap & DSP_CAP_REALTIME) jack_info(" DSP_CAP_REALTIME");

  219.             if (cap & DSP_CAP_BATCH) 	jack_info(" DSP_CAP_BATCH");

  220.             if (cap & DSP_CAP_COPROC) 	jack_info(" DSP_CAP_COPROC");

  221.             if (cap & DSP_CAP_TRIGGER)  jack_info(" DSP_CAP_TRIGGER");

  222.             if (cap & DSP_CAP_MMAP) 	jack_info(" DSP_CAP_MMAP");

  223.             if (cap & DSP_CAP_MULTI) 	jack_info(" DSP_CAP_MULTI");

  224.             if (cap & DSP_CAP_BIND) 	jack_info(" DSP_CAP_BIND");

  225.         }

  226.     }

  227. }

  228. 

  229. JackBoomerDriver::JackBoomerDriver(const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table)

  230.                                 : JackAudioDriver(name, alias, engine, table),

  231.                                 fInFD(-1), fOutFD(-1), fBits(0),

  232.                                 fSampleFormat(0), fNperiods(0), fSampleSize(0), fFragmentSize(0),

  233.                                 fRWMode(0), fExcl(false), fSyncIO(false),

  234.                                 fInputBufferSize(0), fOutputBufferSize(0),

  235.                                 fInputBuffer(NULL), fOutputBuffer(NULL),

  236.                                 fInputThread(&fInputHandler), fOutputThread(&fOutputHandler),

  237.                                 fInputHandler(this), fOutputHandler(this)

  238. {

  239.     sem_init(&fReadSema, 0, 0);

  240.     sem_init(&fWriteSema, 0, 0);

  241. }

  242. 

  243. JackBoomerDriver::~JackBoomerDriver()

  244. {

  245.     sem_destroy(&fReadSema);

  246.     sem_destroy(&fWriteSema);

  247. }

  248. 

  249. int JackBoomerDriver::OpenInput()

  250. {

  251.     int flags = 0;

  252.     int gFragFormat;

  253.     int cur_capture_channels;

  254.     int cur_sample_format;

  255.     jack_nframes_t cur_sample_rate;

  256. 

  257.     if (fCaptureChannels == 0)

  258.         fCaptureChannels = 2;

  259. 

  260.     if ((fInFD = open(fCaptureDriverName, O_RDONLY | ((fExcl) ? O_EXCL : 0))) < 0) {

  261.         jack_error("JackBoomerDriver::OpenInput failed to open device : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  262.         return -1;

  263.     }

  264. 

  265.     jack_log("JackBoomerDriver::OpenInput input fInFD = %d", fInFD);

  266. 

  267.     if (fExcl) {

  268.         if (ioctl(fInFD, SNDCTL_DSP_COOKEDMODE, &flags) == -1) {

  269.             jack_error("JackBoomerDriver::OpenInput failed to set cooked mode : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  270.             goto error;

  271.         }

  272.     }

  273. 

  274.     gFragFormat = (2 << 16) + int2pow2(fEngineControl->fBufferSize * fSampleSize * fCaptureChannels);

  275.     if (ioctl(fInFD, SNDCTL_DSP_SETFRAGMENT, &gFragFormat) == -1) {

  276.         jack_error("JackBoomerDriver::OpenInput failed to set fragments : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  277.         goto error;

  278.     }

  279. 

  280.     cur_sample_format = fSampleFormat;

  281.     if (ioctl(fInFD, SNDCTL_DSP_SETFMT, &fSampleFormat) == -1) {

  282.         jack_error("JackBoomerDriver::OpenInput failed to set format : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  283.         goto error;

  284.     }

  285.     if (cur_sample_format != fSampleFormat) {

  286.         jack_info("JackBoomerDriver::OpenInput driver forced the sample format %ld", fSampleFormat);

  287.     }

  288. 

  289.     cur_capture_channels = fCaptureChannels;

  290.     if (ioctl(fInFD, SNDCTL_DSP_CHANNELS, &fCaptureChannels) == -1) {

  291.         jack_error("JackBoomerDriver::OpenInput failed to set channels : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  292.         goto error;

  293.     }

  294.     if (cur_capture_channels != fCaptureChannels) {

  295.         jack_info("JackBoomerDriver::OpenInput driver forced the number of capture channels %ld", fCaptureChannels);

  296.     }

  297. 

  298.     cur_sample_rate = fEngineControl->fSampleRate;

  299.     if (ioctl(fInFD, SNDCTL_DSP_SPEED, &fEngineControl->fSampleRate) == -1) {

  300.         jack_error("JackBoomerDriver::OpenInput failed to set sample rate : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  301.         goto error;

  302.     }

  303.     if (cur_sample_rate != fEngineControl->fSampleRate) {

  304.         jack_info("JackBoomerDriver::OpenInput driver forced the sample rate %ld", fEngineControl->fSampleRate);

  305.     }

  306. 

  307.     // Just set the read size to the value we want...

  308.     fInputBufferSize = fEngineControl->fBufferSize * fSampleSize * fCaptureChannels;

  309. 

  310.     fInputBuffer = (void*)calloc(fInputBufferSize, 1);

  311.     assert(fInputBuffer);

  312.     return 0;

  313. 

  314. error:

  315.     ::close(fInFD);

  316.     return -1;

  317. }

  318. 

  319. int JackBoomerDriver::OpenOutput()

  320. {

  321.     int flags = 0;

  322.     int gFragFormat;

  323.     int cur_sample_format;

  324.     int cur_playback_channels;

  325.     jack_nframes_t cur_sample_rate;

  326. 

  327.     if (fPlaybackChannels == 0)

  328.         fPlaybackChannels = 2;

  329. 

  330.     if ((fOutFD = open(fPlaybackDriverName, O_WRONLY | ((fExcl) ? O_EXCL : 0))) < 0) {

  331.        jack_error("JackBoomerDriver::OpenOutput failed to open device : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  332.        return -1;

  333.     }

  334. 

  335.     jack_log("JackBoomerDriver::OpenOutput output fOutFD = %d", fOutFD);

  336. 

  337.     if (fExcl) {

  338.         if (ioctl(fOutFD, SNDCTL_DSP_COOKEDMODE, &flags) == -1) {

  339.             jack_error("JackBoomerDriver::OpenOutput failed to set cooked mode : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  340.             goto error;

  341.         }

  342.     }

  343. 

  344.     gFragFormat = (2 << 16) + int2pow2(fEngineControl->fBufferSize * fSampleSize * fPlaybackChannels);

  345.     if (ioctl(fOutFD, SNDCTL_DSP_SETFRAGMENT, &gFragFormat) == -1) {

  346.         jack_error("JackBoomerDriver::OpenOutput failed to set fragments : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  347.         goto error;

  348.     }

  349. 

  350.     cur_sample_format = fSampleFormat;

  351.     if (ioctl(fOutFD, SNDCTL_DSP_SETFMT, &fSampleFormat) == -1) {

  352.         jack_error("JackBoomerDriver::OpenOutput failed to set format : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  353.         goto error;

  354.     }

  355.     if (cur_sample_format != fSampleFormat) {

  356.         jack_info("JackBoomerDriver::OpenOutput driver forced the sample format %ld", fSampleFormat);

  357.     }

  358. 

  359.     cur_playback_channels = fPlaybackChannels;

  360.     if (ioctl(fOutFD, SNDCTL_DSP_CHANNELS, &fPlaybackChannels) == -1) {

  361.         jack_error("JackBoomerDriver::OpenOutput failed to set channels : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  362.         goto error;

  363.     }

  364.     if (cur_playback_channels != fPlaybackChannels) {

  365.         jack_info("JackBoomerDriver::OpenOutput driver forced the number of playback channels %ld", fPlaybackChannels);

  366.     }

  367. 

  368.     cur_sample_rate = fEngineControl->fSampleRate;

  369.     if (ioctl(fOutFD, SNDCTL_DSP_SPEED, &fEngineControl->fSampleRate) == -1) {

  370.         jack_error("JackBoomerDriver::OpenOutput failed to set sample rate : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  371.         goto error;

  372.     }

  373.     if (cur_sample_rate != fEngineControl->fSampleRate) {

  374.         jack_info("JackBoomerDriver::OpenInput driver forced the sample rate %ld", fEngineControl->fSampleRate);

  375.     }

  376. 

  377.     // Just set the write size to the value we want...

  378.     fOutputBufferSize = fEngineControl->fBufferSize * fSampleSize * fPlaybackChannels;

  379. 

  380.     fOutputBuffer = (void*)calloc(fOutputBufferSize, 1);

  381.     assert(fOutputBuffer);

  382.     return 0;

  383. 

  384. error:

  385.     ::close(fOutFD);

  386.     return -1;

  387. }

  388. 

  389. int JackBoomerDriver::Open(jack_nframes_t nframes,

  390.                           int user_nperiods,

  391.                           jack_nframes_t samplerate,

  392.                           bool capturing,

  393.                           bool playing,

  394.                           int inchannels,

  395.                           int outchannels,

  396.                           bool excl,

  397.                           bool monitor,

  398.                           const char* capture_driver_uid,

  399.                           const char* playback_driver_uid,

  400.                           jack_nframes_t capture_latency,

  401.                           jack_nframes_t playback_latency,

  402.                           int bits, bool syncio)

  403. {

  404.     // Generic JackAudioDriver Open

  405.     if (JackAudioDriver::Open(nframes, samplerate, capturing, playing, inchannels, outchannels, monitor,

  406.         capture_driver_uid, playback_driver_uid, capture_latency, playback_latency) != 0) {

  407.         return -1;

  408.     } else {

  409. 

  410.         if (!fEngineControl->fSyncMode) {

  411.             jack_error("Cannot run in asynchronous mode, use the -S parameter for jackd");

  412.             return -1;

  413.         }

  414. 

  415.         fRWMode |= ((capturing) ? kRead : 0);

  416.         fRWMode |= ((playing) ? kWrite : 0);

  417.         fBits = bits;

  418.         fExcl = excl;

  419.         fNperiods = (user_nperiods == 0) ? 1 : user_nperiods ;

  420.         fSyncIO = syncio;

  421. 

  422.     #ifdef JACK_MONITOR

  423.         // Force memory page in

  424.         memset(&gCycleTable, 0, sizeof(gCycleTable));

  425.     #endif

  426. 

  427.         if (OpenAux() < 0) {

  428.             Close();

  429.             return -1;

  430.         } else {

  431.             return 0;

  432.         }

  433.     }

  434. }

  435. 

  436. int JackBoomerDriver::Close()

  437. {

  438.  #ifdef JACK_MONITOR

  439.     FILE* file = fopen("OSSProfiling.log", "w");

  440. 

  441.     if (file) {

  442.         jack_info("Writing OSS driver timing data....");

  443.         for (int i = 1; i < std::min(gCycleReadCount, gCycleWriteCount); i++) {

  444.             int d1 = gCycleTable.fTable[i].fAfterRead - gCycleTable.fTable[i].fBeforeRead;

  445.             int d2 = gCycleTable.fTable[i].fAfterReadConvert - gCycleTable.fTable[i].fAfterRead;

  446.             int d3 = gCycleTable.fTable[i].fAfterWrite - gCycleTable.fTable[i].fBeforeWrite;

  447.             int d4 = gCycleTable.fTable[i].fBeforeWrite - gCycleTable.fTable[i].fBeforeWriteConvert;

  448.             fprintf(file, "%d \t %d \t %d \t %d \t \n", d1, d2, d3, d4);

  449.         }

  450.         fclose(file);

  451.     } else {

  452.         jack_error("JackBoomerDriver::Close : cannot open OSSProfiling.log file");

  453.     }

  454. 

  455.     file = fopen("TimingOSS.plot", "w");

  456. 

  457.     if (file == NULL) {

  458.         jack_error("JackBoomerDriver::Close cannot open TimingOSS.plot file");

  459.     } else {

  460. 

  461.         fprintf(file, "set grid\n");

  462.         fprintf(file, "set title \"OSS audio driver timing\"\n");

  463.         fprintf(file, "set xlabel \"audio cycles\"\n");

  464.         fprintf(file, "set ylabel \"usec\"\n");

  465.         fprintf(file, "plot \"OSSProfiling.log\" using 1 title \"Driver read wait\" with lines, \

  466.                             \"OSSProfiling.log\" using 2 title \"Driver read convert duration\" with lines, \

  467.                             \"OSSProfiling.log\" using 3 title \"Driver write wait\" with lines, \

  468.                             \"OSSProfiling.log\" using 4 title \"Driver write convert duration\" with lines\n");

  469. 

  470.         fprintf(file, "set output 'TimingOSS.pdf\n");

  471.         fprintf(file, "set terminal pdf\n");

  472. 

  473.         fprintf(file, "set grid\n");

  474.         fprintf(file, "set title \"OSS audio driver timing\"\n");

  475.         fprintf(file, "set xlabel \"audio cycles\"\n");

  476.         fprintf(file, "set ylabel \"usec\"\n");

  477.         fprintf(file, "plot \"OSSProfiling.log\" using 1 title \"Driver read wait\" with lines, \

  478.                             \"OSSProfiling.log\" using 2 title \"Driver read convert duration\" with lines, \

  479.                             \"OSSProfiling.log\" using 3 title \"Driver write wait\" with lines, \

  480.                             \"OSSProfiling.log\" using 4 title \"Driver write convert duration\" with lines\n");

  481. 

  482.         fclose(file);

  483.     }

  484.  #endif

  485.     int res = JackAudioDriver::Close();

  486.     CloseAux();

  487.     return res;

  488. }

  489. 

  490. int JackBoomerDriver::OpenAux()

  491. {

  492.     SetSampleFormat();

  493. 

  494.     if ((fRWMode & kRead) && (OpenInput() < 0)) {

  495.         return -1;

  496.     }

  497. 

  498.     if ((fRWMode & kWrite) && (OpenOutput() < 0)) {

  499.         return -1;

  500.     }

  501. 

  502.     DisplayDeviceInfo();

  503.     return 0;

  504. }

  505. 

  506. void JackBoomerDriver::CloseAux()

  507. {

  508.     if (fRWMode & kRead && fInFD >= 0) {

  509.         close(fInFD);

  510.         fInFD = -1;

  511.     }

  512. 

  513.     if (fRWMode & kWrite && fOutFD >= 0) {

  514.         close(fOutFD);

  515.         fOutFD = -1;

  516.     }

  517. 

  518.     if (fInputBuffer)

  519.         free(fInputBuffer);

  520.     fInputBuffer = NULL;

  521. 

  522.     if (fOutputBuffer)

  523.         free(fOutputBuffer);

  524.     fOutputBuffer = NULL;

  525. }

  526. 

  527. int JackBoomerDriver::Start()

  528. {

  529.     jack_log("JackBoomerDriver::Start");

  530.     JackAudioDriver::Start();

  531. 

  532.     // Input/output synchronisation

  533.     if (fInFD >= 0 && fOutFD >= 0 && fSyncIO) {

  534. 

  535.         jack_log("JackBoomerDriver::Start sync input/output");

  536. 

  537.         // Create and fill synch group

  538.         int id;

  539.         oss_syncgroup group;

  540.         group.id = 0;

  541. 

  542.         group.mode = PCM_ENABLE_INPUT;

  543.         if (ioctl(fInFD, SNDCTL_DSP_SYNCGROUP, &group) == -1)

  544.             jack_error("JackBoomerDriver::Start failed to use SNDCTL_DSP_SYNCGROUP : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  545. 

  546.         group.mode = PCM_ENABLE_OUTPUT;

  547.         if (ioctl(fOutFD, SNDCTL_DSP_SYNCGROUP, &group) == -1)

  548.             jack_error("JackBoomerDriver::Start failed to use SNDCTL_DSP_SYNCGROUP : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  549. 

  550.         // Prefill output buffer : 2 fragments of silence as described in http://manuals.opensound.com/developer/synctest.c.html#LOC6

  551.         char* silence_buf = (char*)malloc(fFragmentSize);

  552.         memset(silence_buf, 0, fFragmentSize);

  553. 

  554.         jack_log ("JackBoomerDriver::Start prefill size = %d", fFragmentSize);

  555. 

  556.         for (int i = 0; i < 2; i++) {

  557.             ssize_t count = ::write(fOutFD, silence_buf, fFragmentSize);

  558.             if (count < (int)fFragmentSize) {

  559.                 jack_error("JackBoomerDriver::Start error bytes written = %ld", count);

  560.             }

  561.         }

  562. 

  563.         free(silence_buf);

  564. 

  565.         // Start input/output in sync

  566.         id = group.id;

  567. 

  568.         if (ioctl(fInFD, SNDCTL_DSP_SYNCSTART, &id) == -1)

  569.             jack_error("JackBoomerDriver::Start failed to use SNDCTL_DSP_SYNCSTART : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  570. 

  571.     } else if (fOutFD >= 0) {

  572. 

  573.         // Maybe necessary to write an empty output buffer first time : see http://manuals.opensound.com/developer/fulldup.c.html

  574.         memset(fOutputBuffer, 0, fOutputBufferSize);

  575. 

  576.         // Prefill output buffer

  577.         for (int i = 0; i < fNperiods; i++) {

  578.             ssize_t count = ::write(fOutFD, fOutputBuffer, fOutputBufferSize);

  579.             if (count < (int)fOutputBufferSize) {

  580.                 jack_error("JackBoomerDriver::Start error bytes written = %ld", count);

  581.             }

  582.         }

  583.     }

  584. 

  585.     // Start input thread only when needed

  586.     if (fInFD >= 0) {

  587.         if (fInputThread.StartSync() < 0) {

  588.             jack_error("Cannot start input thread");

  589.             return -1;

  590.         }

  591.     }

  592. 

  593.     // Start output thread only when needed

  594.     if (fOutFD >= 0) {

  595.         if (fOutputThread.StartSync() < 0) {

  596.             jack_error("Cannot start output thread");

  597.             return -1;

  598.         }

  599.     }

  600. 

  601.     return 0;

  602. }

  603. 

  604. int JackBoomerDriver::Stop()

  605. {

  606.     // Stop input thread only when needed

  607.     if (fInFD >= 0) {

  608.         fInputThread.Kill();

  609.     }

  610. 

  611.     // Stop output thread only when needed

  612.     if (fOutFD >= 0) {

  613.         fOutputThread.Kill();

  614.     }

  615. 

  616.     return 0;

  617. }

  618. 

  619. bool JackBoomerDriver::JackBoomerDriverInput::Init()

  620. {

  621.     if (fDriver->IsRealTime()) {

  622.         jack_log("JackBoomerDriverInput::Init IsRealTime");

  623.         if (fDriver->fInputThread.AcquireRealTime(GetEngineControl()->fServerPriority) < 0) {

  624.             jack_error("AcquireRealTime error");

  625.         } else {

  626.             set_threaded_log_function();

  627.         }

  628.     }

  629. 

  630.     return true;

  631. }

  632. 

  633. // TODO : better error handling

  634. bool JackBoomerDriver::JackBoomerDriverInput::Execute()

  635. {

  636. 

  637. #ifdef JACK_MONITOR

  638.     gCycleTable.fTable[gCycleReadCount].fBeforeRead = GetMicroSeconds();

  639. #endif

  640. 

  641.     audio_errinfo ei_in;

  642.     ssize_t count = ::read(fDriver->fInFD, fDriver->fInputBuffer, fDriver->fInputBufferSize);

  643. 

  644. #ifdef JACK_MONITOR

  645.     if (count > 0 && count != (int)fDriver->fInputBufferSize)

  646.         jack_log("JackBoomerDriverInput::Execute count = %ld", count / (fDriver->fSampleSize * fDriver->fCaptureChannels));

  647.     gCycleTable.fTable[gCycleReadCount].fAfterRead = GetMicroSeconds();

  648. #endif

  649. 

  650.     // XRun detection

  651.     if (ioctl(fDriver->fInFD, SNDCTL_DSP_GETERROR, &ei_in) == 0) {

  652. 

  653.         if (ei_in.rec_overruns > 0 ) {

  654.             jack_error("JackBoomerDriverInput::Execute overruns");

  655.             jack_time_t cur_time = GetMicroSeconds();

  656.             fDriver->NotifyXRun(cur_time, float(cur_time - fDriver->fBeginDateUst));   // Better this value than nothing...

  657.         }

  658. 

  659.         if (ei_in.rec_errorcount > 0 && ei_in.rec_lasterror != 0) {

  660.             jack_error("%d OSS rec event(s), last=%05d:%d", ei_in.rec_errorcount, ei_in.rec_lasterror, ei_in.rec_errorparm);

  661.         }

  662.     }

  663. 

  664.     if (count < 0) {

  665.         jack_log("JackBoomerDriverInput::Execute error = %s", strerror(errno));

  666.     } else if (count < (int)fDriver->fInputBufferSize) {

  667.         jack_error("JackBoomerDriverInput::Execute error bytes read = %ld", count);

  668.     } else {

  669. 

  670.         // Keep begin cycle time

  671.         fDriver->CycleTakeBeginTime();

  672.         for (int i = 0; i < fDriver->fCaptureChannels; i++) {

  673.             if (fDriver->fGraphManager->GetConnectionsNum(fDriver->fCapturePortList[i]) > 0) {

  674.                 CopyAndConvertIn(fDriver->GetInputBuffer(i),

  675.                                 fDriver->fInputBuffer,

  676.                                 fDriver->fEngineControl->fBufferSize,

  677.                                 i,

  678.                                 fDriver->fCaptureChannels * fDriver->fSampleSize,

  679.                                 fDriver->fBits);

  680.             }

  681.         }

  682. 

  683.     #ifdef JACK_MONITOR

  684.         gCycleTable.fTable[gCycleReadCount].fAfterReadConvert = GetMicroSeconds();

  685.         gCycleReadCount = (gCycleReadCount == CYCLE_POINTS - 1) ? gCycleReadCount: gCycleReadCount + 1;

  686.     #endif

  687.     }

  688. 

  689.     // Duplex : sync with write thread

  690.     if (fDriver->fInFD >= 0 && fDriver->fOutFD >= 0) {

  691.         fDriver->SynchronizeRead();

  692.     } else {

  693.         // Otherwise direct process

  694.         fDriver->Process();

  695.     }

  696.     return true;

  697. }

  698. 

  699. bool JackBoomerDriver::JackBoomerDriverOutput::Init()

  700. {

  701.     if (fDriver->IsRealTime()) {

  702.         jack_log("JackBoomerDriverOutput::Init IsRealTime");

  703.         if (fDriver->fOutputThread.AcquireRealTime(GetEngineControl()->fServerPriority) < 0) {

  704.             jack_error("AcquireRealTime error");

  705.         } else {

  706.             set_threaded_log_function();

  707.         }

  708.     }

  709. 

  710.     int delay;

  711.     if (ioctl(fDriver->fOutFD, SNDCTL_DSP_GETODELAY, &delay) == -1) {

  712.         jack_error("JackBoomerDriverOutput::Init error get out delay : %s@%i, errno = %d", __FILE__, __LINE__, errno);

  713.     }

  714. 

  715.     delay /= fDriver->fSampleSize * fDriver->fPlaybackChannels;

  716.     jack_info("JackBoomerDriverOutput::Init output latency frames = %ld", delay);

  717. 

  718.     return true;

  719. }

  720. 

  721. // TODO : better error handling

  722. bool JackBoomerDriver::JackBoomerDriverOutput::Execute()

  723. {

  724.     memset(fDriver->fOutputBuffer, 0, fDriver->fOutputBufferSize);

  725. 

  726. #ifdef JACK_MONITOR

  727.     gCycleTable.fTable[gCycleWriteCount].fBeforeWriteConvert = GetMicroSeconds();

  728. #endif

  729. 

  730.     for (int i = 0; i < fDriver->fPlaybackChannels; i++) {

  731.         if (fDriver->fGraphManager->GetConnectionsNum(fDriver->fPlaybackPortList[i]) > 0) {

  732.               CopyAndConvertOut(fDriver->fOutputBuffer,

  733.                                 fDriver->GetOutputBuffer(i),

  734.                                 fDriver->fEngineControl->fBufferSize,

  735.                                 i,

  736.                                 fDriver->fPlaybackChannels * fDriver->fSampleSize,

  737.                                 fDriver->fBits);

  738.         }

  739.     }

  740. 

  741. #ifdef JACK_MONITOR

  742.     gCycleTable.fTable[gCycleWriteCount].fBeforeWrite = GetMicroSeconds();

  743. #endif

  744. 

  745.     ssize_t count = ::write(fDriver->fOutFD, fDriver->fOutputBuffer, fDriver->fOutputBufferSize);

  746. 

  747. #ifdef JACK_MONITOR

  748.     if (count > 0 && count != (int)fDriver->fOutputBufferSize)

  749.         jack_log("JackBoomerDriverOutput::Execute count = %ld", count / (fDriver->fSampleSize * fDriver->fPlaybackChannels));

  750.     gCycleTable.fTable[gCycleWriteCount].fAfterWrite = GetMicroSeconds();

  751.     gCycleWriteCount = (gCycleWriteCount == CYCLE_POINTS - 1) ? gCycleWriteCount: gCycleWriteCount + 1;

  752. #endif

  753. 

  754.     // XRun detection

  755.     audio_errinfo ei_out;

  756.     if (ioctl(fDriver->fOutFD, SNDCTL_DSP_GETERROR, &ei_out) == 0) {

  757. 

  758.         if (ei_out.play_underruns > 0) {

  759.             jack_error("JackBoomerDriverOutput::Execute underruns");

  760.             jack_time_t cur_time = GetMicroSeconds();

  761.             fDriver->NotifyXRun(cur_time, float(cur_time - fDriver->fBeginDateUst));   // Better this value than nothing...

  762.         }

  763. 

  764.         if (ei_out.play_errorcount > 0 && ei_out.play_lasterror != 0) {

  765.             jack_error("%d OSS play event(s), last=%05d:%d",ei_out.play_errorcount, ei_out.play_lasterror, ei_out.play_errorparm);

  766.         }

  767.     }

  768. 

  769.     if (count < 0) {

  770.         jack_log("JackBoomerDriverOutput::Execute error = %s", strerror(errno));

  771.     } else if (count < (int)fDriver->fOutputBufferSize) {

  772.         jack_error("JackBoomerDriverOutput::Execute error bytes written = %ld", count);

  773.     }

  774. 

  775.     // Duplex : sync with read thread

  776.     if (fDriver->fInFD >= 0 && fDriver->fOutFD >= 0) {

  777.         fDriver->SynchronizeWrite();

  778.     } else {

  779.         // Otherwise direct process

  780.         fDriver->CycleTakeBeginTime();

  781.         fDriver->Process();

  782.     }

  783.     return true;

  784. }

  785. 

  786. void JackBoomerDriver::SynchronizeRead()

  787. {

  788.     sem_wait(&fWriteSema);

  789.     Process();

  790.     sem_post(&fReadSema);

  791. }

  792. 

  793. void JackBoomerDriver::SynchronizeWrite()

  794. {

  795.     sem_post(&fWriteSema);

  796.     sem_wait(&fReadSema);

  797. }

  798. 

  799. int JackBoomerDriver::SetBufferSize(jack_nframes_t buffer_size)

  800. {

  801.     CloseAux();

  802.     JackAudioDriver::SetBufferSize(buffer_size); // Generic change, never fails

  803.     return OpenAux();

  804. }

  805. 

  806. } // end of namespace

  807. 

  808. #ifdef __cplusplus

  809. extern "C"

  810. {

  811. #endif

  812. 

  813. SERVER_EXPORT jack_driver_desc_t* driver_get_descriptor()

  814. {

  815.     jack_driver_desc_t * desc;

  816.     jack_driver_desc_filler_t filler;

  817.     jack_driver_param_value_t value;

  818. 

  819.     desc = jack_driver_descriptor_construct("boomer", JackDriverMaster, "Boomer/OSS API based audio backend", &filler);

  820. 

  821.     value.ui = OSS_DRIVER_DEF_FS;

  822.     jack_driver_descriptor_add_parameter(desc, &filler, "rate", 'r', JackDriverParamUInt, &value, NULL, "Sample rate", NULL);

  823. 

  824.     value.ui = OSS_DRIVER_DEF_BLKSIZE;

  825.     jack_driver_descriptor_add_parameter(desc, &filler, "period", 'p', JackDriverParamUInt, &value, NULL, "Frames per period", NULL);

  826. 

  827.     value.ui = OSS_DRIVER_DEF_NPERIODS;

  828.     jack_driver_descriptor_add_parameter(desc, &filler, "nperiods", 'n', JackDriverParamUInt, &value, NULL, "Number of periods to prefill output buffer", NULL);

  829. 

  830.     value.i = OSS_DRIVER_DEF_BITS;

  831.     jack_driver_descriptor_add_parameter(desc, &filler, "wordlength", 'w', JackDriverParamInt, &value, NULL, "Word length", NULL);

  832. 

  833.     value.ui = OSS_DRIVER_DEF_INS;

  834.     jack_driver_descriptor_add_parameter(desc, &filler, "inchannels", 'i', JackDriverParamUInt, &value, NULL, "Capture channels", NULL);

  835. 

  836.     value.ui = OSS_DRIVER_DEF_OUTS;

  837.     jack_driver_descriptor_add_parameter(desc, &filler, "outchannels", 'o', JackDriverParamUInt, &value, NULL, "Playback channels", NULL);

  838. 

  839.     value.i = false;

  840.     jack_driver_descriptor_add_parameter(desc, &filler, "excl", 'e', JackDriverParamBool, &value, NULL, "Exclusif (O_EXCL) access mode", NULL);

  841. 

  842.     strcpy(value.str, OSS_DRIVER_DEF_DEV);

  843.     jack_driver_descriptor_add_parameter(desc, &filler, "capture", 'C', JackDriverParamString, &value, NULL, "Input device", NULL);

  844.     jack_driver_descriptor_add_parameter(desc, &filler, "playback", 'P', JackDriverParamString, &value, NULL, "Output device", NULL);

  845.     jack_driver_descriptor_add_parameter(desc, &filler, "device", 'd', JackDriverParamString, &value, NULL, "OSS device name", NULL);

  846. 

  847.     value.ui = 0;

  848.     jack_driver_descriptor_add_parameter(desc, &filler, "input-latency", 'I', JackDriverParamUInt, &value, NULL, "Extra input latency", NULL);

  849.     jack_driver_descriptor_add_parameter(desc, &filler, "output-latency", 'O', JackDriverParamUInt, &value, NULL, "Extra output latency", NULL);

  850. 

  851.     value.i = false;

  852.     jack_driver_descriptor_add_parameter(desc, &filler, "sync-io", 'S', JackDriverParamBool, &value, NULL, "In duplex mode, synchronize input and output", NULL);

  853. 

  854.     return desc;

  855. }

  856. 

  857. SERVER_EXPORT Jack::JackDriverClientInterface* driver_initialize(Jack::JackLockedEngine* engine, Jack::JackSynchro* table, const JSList* params)

  858. {

  859.     int bits = OSS_DRIVER_DEF_BITS;

  860.     jack_nframes_t srate = OSS_DRIVER_DEF_FS;

  861.     jack_nframes_t frames_per_interrupt = OSS_DRIVER_DEF_BLKSIZE;

  862.     const char* capture_pcm_name = OSS_DRIVER_DEF_DEV;

  863.     const char* playback_pcm_name = OSS_DRIVER_DEF_DEV;

  864.     bool capture = false;

  865.     bool playback = false;

  866.     int chan_in = 0;

  867.     int chan_out = 0;

  868.     bool monitor = false;

  869.     bool excl = false;

  870.     bool syncio = false;

  871.     unsigned int nperiods = OSS_DRIVER_DEF_NPERIODS;

  872.     const JSList *node;

  873.     const jack_driver_param_t *param;

  874.     jack_nframes_t systemic_input_latency = 0;

  875.     jack_nframes_t systemic_output_latency = 0;

  876. 

  877.     for (node = params; node; node = jack_slist_next(node)) {

  878. 

  879.         param = (const jack_driver_param_t *)node->data;

  880. 

  881.         switch (param->character) {

  882. 

  883.         case 'r':

  884.             srate = param->value.ui;

  885.             break;

  886. 

  887.         case 'p':

  888.             frames_per_interrupt = (unsigned int)param->value.ui;

  889.             break;

  890. 

  891.         case 'n':

  892.             nperiods = (unsigned int)param->value.ui;

  893.             break;

  894. 

  895.         case 'w':

  896.             bits = param->value.i;

  897.             break;

  898. 

  899.         case 'i':

  900.             chan_in = (int)param->value.ui;

  901.             break;

  902. 

  903.         case 'o':

  904.             chan_out = (int)param->value.ui;

  905.             break;

  906. 

  907.         case 'C':

  908.             capture = true;

  909.             if (strcmp(param->value.str, "none") != 0) {

  910.                 capture_pcm_name = param->value.str;

  911.             }

  912.             break;

  913. 

  914.         case 'P':

  915.             playback = true;

  916.             if (strcmp(param->value.str, "none") != 0) {

  917.                 playback_pcm_name = param->value.str;

  918.             }

  919.             break;

  920. 

  921.         case 'd':

  922.             playback_pcm_name = param->value.str;

  923.             capture_pcm_name = param->value.str;

  924.             break;

  925. 

  926.         case 'e':

  927.             excl = true;

  928.             break;

  929. 

  930.         case 'I':

  931.             systemic_input_latency = param->value.ui;

  932.             break;

  933. 

  934.         case 'O':

  935.             systemic_output_latency = param->value.ui;

  936.             break;

  937. 

  938.         case 'S':

  939.             syncio = true;

  940.             break;

  941.         }

  942.     }

  943. 

  944.     // duplex is the default

  945.     if (!capture && !playback) {

  946.         capture = true;

  947.         playback = true;

  948.     }

  949. 

  950.     Jack::JackBoomerDriver* boomer_driver = new Jack::JackBoomerDriver("system", "boomer", engine, table);

  951. 

  952.     // Special open for Boomer driver...

  953.     if (boomer_driver->Open(frames_per_interrupt, nperiods, srate, capture, playback, chan_in, chan_out, excl,

  954.         monitor, capture_pcm_name, playback_pcm_name, systemic_input_latency, systemic_output_latency, bits, syncio) == 0) {

  955.         return boomer_driver;

  956.     } else {

  957.         delete boomer_driver; // Delete the driver

  958.         return NULL;

  959.     }

  960. }

  961. 

  962. #ifdef __cplusplus

  963. }

  964. #endif