tools/zalsa/zita-a2j.cc

   1 // ----------------------------------------------------------------------------
   2 //
   3 //  Copyright (C) 2012 Fons Adriaensen <fons@linuxaudio.org>
   4 //
   5 //  This program is free software; you can redistribute it and/or modify
   6 //  it under the terms of the GNU General Public License as published by
   7 //  the Free Software Foundation; either version 3 of the License, or
   8 //  (at your option) any later version.
   9 //
  10 //  This program is distributed in the hope that it will be useful,
  11 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 //  GNU General Public License for more details.
  14 //
  15 //  You should have received a copy of the GNU General Public License
  16 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 //
  18 // ----------------------------------------------------------------------------
  19
  20
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <ctype.h>
  24 #include <stdio.h>
  25 #include <signal.h>
  26 #include "alsathread.h"
  27 #include "jackclient.h"
  28 #include "lfqueue.h"
  29 #include "jack/control.h"
  30
  31 static const char *clopt = "hvLSwj:d:r:p:n:c:Q:I:";
  32
  33 static void help (void)
  34 {
  35     jack_info ("%s-%s", APPNAME, VERSION);
  36     jack_info ("(C) 2012-2018 Fons Adriaensen  <fons@linuxaudio.org>");
  37     jack_info ("Use ALSA capture device as a Jack client.");
  38     jack_info ("Options:");
  39     jack_info ("  -h                 Display this text");
  40     jack_info ("  -j <jackname>      Name as Jack client [%s]", APPNAME);
  41     jack_info ("  -d <device>        ALSA capture device [none]");
  42     jack_info ("  -r <rate>          Sample rate [48000]");
  43     jack_info ("  -p <period>        Period size [256]");
  44     jack_info ("  -n <nfrags>        Number of fragments [2]");
  45     jack_info ("  -c <nchannels>     Number of channels [2]");
  46     jack_info ("  -S                 Word clock sync, no resampling");
  47     jack_info ("  -Q <quality>       Resampling quality, 16..96 [auto]");
  48     jack_info ("  -I <samples>       Latency adjustment [0]");
  49     jack_info ("  -L                 Force 16-bit and 2 channels [off]");
  50     jack_info ("  -w                 Wait until soundcard is available [off]");
  51     jack_info ("  -v                 Print tracing information [off]");
  52 }
  53
  54 class zita_a2j
  55 {
  56         Lfq_int32 *commq;
  57         Lfq_adata *alsaq;
  58         Lfq_jdata *infoq;
  59         Lfq_audio *audioq;
  60         bool stop;
  61         bool v_opt;
  62         bool L_opt;
  63         bool S_opt;
  64         bool w_opt;
  65         char *jname;
  66         char *device;
  67         int fsamp;
  68         int bsize;
  69         int nfrag;
  70         int nchan;
  71         int rqual;
  72         int ltcor;
  73
  74 public:
  75
  76     zita_a2j()
  77     {
  78         commq = new Lfq_int32(16);
  79         alsaq = new Lfq_adata(256);
  80         infoq = new Lfq_jdata(256);
  81         audioq = 0;
  82         stop = false;
  83         v_opt = false;
  84         L_opt = false;
  85         S_opt = false;
  86         w_opt = false;
  87         jname = strdup(APPNAME);
  88         device = 0;
  89         fsamp = 48000;
  90         bsize = 128;
  91         nfrag = 2;
  92         nchan = 2;
  93         rqual = 0;
  94         ltcor = 0;
  95         A = 0;
  96         C = 0;
  97         J = 0;
  98         t = 0;
  99     }
 100
 101 private:
 102
 103     int procoptions (int ac, const char *av [])
 104     {
 105         int k;
 106
 107         optind = 1;
 108         opterr = 0;
 109         while ((k = getopt (ac, (char **) av, (char *) clopt)) != -1)
 110         {
 111             if (optarg && (*optarg == '-'))
 112             {
 113                 jack_error (APPNAME ":   Missing argument for '-%c' option.", k);
 114                 jack_error (APPNAME ":   Use '-h' to see all options.");
 115                 return 1;
 116             }
 117             switch (k)
 118             {
 119             case 'h' : help (); return 1;
 120             case 'v' : v_opt = true; break;
 121             case 'L' : L_opt = true; break;
 122             case 'S' : S_opt = true; break;
 123             case 'w' : w_opt = true; break;
 124             case 'j' : jname = optarg; break;
 125             case 'd' : device = optarg; break;
 126             case 'r' : fsamp = atoi (optarg); break;
 127             case 'p' : bsize = atoi (optarg); break;
 128             case 'n' : nfrag = atoi (optarg); break;
 129             case 'c' : nchan = atoi (optarg); break;
 130             case 'Q' : rqual = atoi (optarg); break;
 131             case 'I' : ltcor = atoi (optarg); break;
 132             case '?':
 133                 if (optopt != ':' && strchr (clopt, optopt))
 134                 {
 135                     jack_error (APPNAME ":   Missing argument for '-%c' option.", optopt);
 136                 }
 137                 else if (isprint (optopt))
 138                 {
 139                     jack_error (APPNAME ":   Unknown option '-%c'.", optopt);
 140                 }
 141                 else
 142                 {
 143                     jack_error (APPNAME ":   Unknown option character '0x%02x'.", optopt & 255);
 144                 }
 145                 jack_error (APPNAME ":   Use '-h' to see all options.");
 146                 return 1;
 147             default:
 148                 return 1;
 149             }
 150         }
 151         return 0;
 152     }
 153
 154     int parse_options (const char* load_init)
 155     {
 156         int argsz;
 157         int argc = 0;
 158         const char** argv;
 159         char* args = strdup (load_init);
 160         char* token;
 161         char* ptr = args;
 162         char* savep;
 163
 164             if (!load_init) {
 165             return 0;
 166         }
 167
 168         argsz = 8; /* random guess at "maxargs" */
 169         argv = (const char **) malloc (sizeof (char *) * argsz);
 170
 171         argv[argc++] = APPNAME;
 172
 173         while (1) {
 174
 175             if ((token = strtok_r (ptr, " ", &savep)) == NULL) {
 176                 break;
 177             }
 178
 179             if (argc == argsz) {
 180                 argsz *= 2;
 181                 argv = (const char **) realloc (argv, sizeof (char *) * argsz);
 182             }
 183
 184             argv[argc++] = token;
 185             ptr = NULL;
 186         }
 187
 188         return procoptions (argc, argv);
 189     }
 190
 191     void printinfo (void)
 192     {
 193         int     n, k;
 194         double  e, r;
 195         Jdata   *J;
 196
 197         n = 0;
 198         k = 99999;
 199         e = r = 0;
 200         while (infoq->rd_avail ())
 201         {
 202             J = infoq->rd_datap ();
 203             if (J->_state == Jackclient::TERM)
 204             {
 205                 jack_error (APPNAME ": Fatal error condition, terminating.");
 206                 stop = true;
 207                 return;
 208             }
 209             else if (J->_state == Jackclient::WAIT)
 210             {
 211                 jack_info (APPNAME ": Detected excessive timing errors, waiting 10 seconds.");
 212                 n = 0;
 213             }
 214             else if (J->_state == Jackclient::SYNC0)
 215             {
 216                 jack_info (APPNAME ": Starting synchronisation.");
 217             }
 218             else if (v_opt)
 219             {
 220                 n++;
 221                 e += J->_error;
 222                 r += J->_ratio;
 223                 if (J->_bstat < k) k = J->_bstat;
 224             }
 225             infoq->rd_commit ();
 226         }
 227         if (n) jack_info (APPNAME ": %8.3lf %10.6lf %5d", e / n, r / n, k);
 228     }
 229
 230
 231     Alsa_pcmi      *A;
 232     Alsathread     *C;
 233     Jackclient     *J;
 234
 235     pthread_t t;
 236     int       topts;
 237
 238     static void* _retry_alsa_pcmi (void *arg)
 239     {
 240         ((zita_a2j*)arg)->retry_alsa_pcmi ();
 241         return NULL;
 242     }
 243
 244     void retry_alsa_pcmi ()
 245     {
 246         Alsa_pcmi *a;
 247
 248         while (! stop)
 249         {
 250             sleep(1);
 251
 252             a = new Alsa_pcmi (0, device, 0, fsamp, bsize, nfrag, topts);
 253             if (a->state ())
 254             {
 255                 delete a;
 256                 continue;
 257             }
 258
 259             A = a;
 260             if (v_opt) A->printinfo ();
 261             C = new Alsathread (A, Alsathread::CAPT);
 262             usleep (100*1000);
 263             jack_initialize_part2 ();
 264             jack_info (APPNAME ": Device is now available and has been activated");
 265             break;
 266         }
 267
 268         t = 0;
 269     }
 270
 271 public:
 272
 273     int
 274     jack_initialize (jack_client_t* client, const char* load_init)
 275     {
 276         int opts;
 277
 278         if (parse_options (load_init)) {
 279             jack_error (APPNAME ": parse options failed");
 280             delete this;
 281             return 1;
 282         }
 283
 284         if (device == 0)
 285         {
 286             help ();
 287             delete this;
 288             return 1;
 289         }
 290         if (rqual < 16) rqual = 16;
 291         if (rqual > 96) rqual = 96;
 292         if ((fsamp < 8000) || (bsize < 16) || (nfrag < 2) || (nchan < 1))
 293         {
 294             jack_error (APPNAME ": Illegal parameter value(s).");
 295             delete this;
 296             return 1;
 297         }
 298
 299         opts = 0;
 300         if (v_opt) opts |= Alsa_pcmi::DEBUG_ALL;
 301         if (L_opt) opts |= Alsa_pcmi::FORCE_16B | Alsa_pcmi::FORCE_2CH;
 302         if (w_opt)
 303         {
 304             J = new Jackclient (client, 0, Jackclient::CAPT, nchan, S_opt, this);
 305             A = new Alsa_pcmi (0, device, 0, fsamp, bsize, nfrag, opts);
 306
 307             // if device is not available, spawn thread to keep trying
 308             if (A->state ())
 309             {
 310                 delete A;
 311                 A = NULL;
 312                 topts = opts;
 313                 pthread_create (&t, NULL, _retry_alsa_pcmi, this);
 314                 jack_info (APPNAME ": Could not open device, will keep trying in new thread...");
 315                 return 0;
 316             }
 317
 318             // otherwise continue as normal
 319             if (v_opt) A->printinfo ();
 320             C = new Alsathread (A, Alsathread::CAPT);
 321         }
 322         else
 323         {
 324             A = new Alsa_pcmi (0, device, 0, fsamp, bsize, nfrag, opts);
 325             if (A->state ())
 326             {
 327                 jack_error (APPNAME ": Can't open ALSA capture device '%s'.", device);
 328                 delete this;
 329                 return 1;
 330             }
 331             if (v_opt) A->printinfo ();
 332             if (nchan > A->ncapt ())
 333             {
 334                 nchan = A->ncapt ();
 335                 jack_error (APPNAME ": Warning: only %d channels are available.", nchan);
 336             }
 337             C = new Alsathread (A, Alsathread::CAPT);
 338             J = new Jackclient (client, 0, Jackclient::CAPT, nchan, S_opt, this);
 339         }
 340
 341         usleep (100*1000);
 342         jack_initialize_part2 ();
 343         return 0;
 344     }
 345
 346     void jack_initialize_part2 ()
 347     {
 348         int            k, k_del;
 349         double         t_alsa;
 350         double         t_jack;
 351         double         t_del;
 352
 353         t_alsa = (double) bsize / fsamp;
 354         if (t_alsa < 1e-3) t_alsa = 1e-3;
 355         t_jack = (double) J->bsize () / J->fsamp ();
 356         t_del = t_alsa + t_jack;
 357         k_del = (int)(t_del * fsamp);
 358         for (k = 256; k < 2 * k_del; k *= 2);
 359         audioq = new Lfq_audio (k, nchan);
 360
 361         if (rqual == 0)
 362         {
 363             k = (fsamp < J->fsamp ()) ? fsamp : J->fsamp ();
 364             if (k < 44100) k = 44100;
 365             rqual = (int)((6.7 * k) / (k - 38000));
 366         }
 367         if (rqual < 16) rqual = 16;
 368         if (rqual > 96) rqual = 96;
 369
 370         C->start (audioq, commq, alsaq, J->rprio () + 10);
 371         J->start (audioq, commq, alsaq, infoq, J->fsamp () / (double) fsamp, k_del, ltcor, rqual);
 372     }
 373
 374     void jack_finish (void* arg)
 375     {
 376         if (t != 0)
 377         {
 378             stop = true;
 379             pthread_join(t, NULL);
 380         }
 381
 382         commq->wr_int32 (Alsathread::TERM);
 383         usleep (100000);
 384         delete C;
 385         delete A;
 386         delete J;
 387         delete audioq;
 388     }
 389 };
 390
 391 extern "C" {
 392
 393 int
 394 jack_initialize (jack_client_t* client, const char* load_init)
 395 {
 396         zita_a2j *c = new zita_a2j();
 397         return c->jack_initialize(client, load_init);
 398 }
 399
 400 void jack_finish (void* arg)
 401 {
 402         if (!arg) return;
 403         Jackclient *J = (Jackclient *)arg;
 404         zita_a2j *c = (zita_a2j *)J->getarg();
 405         c->jack_finish(arg);
 406         delete c;
 407 }
 408
 409 } /* extern "C" */