[BACK]Return to dev.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / sndiod

Diff for /src/usr.bin/sndiod/dev.c between version 1.88 and 1.89

version 1.88, 2021/01/29 11:36:44 version 1.89, 2021/01/29 11:38:23
Line 122 
Line 122 
                 slot_array[i].unit = i;                  slot_array[i].unit = i;
                 slot_array[i].ops = NULL;                  slot_array[i].ops = NULL;
                 slot_array[i].vol = MIDI_MAXCTL;                  slot_array[i].vol = MIDI_MAXCTL;
                 slot_array[i].dev = NULL;                  slot_array[i].opt = NULL;
                 slot_array[i].serial = slot_serial++;                  slot_array[i].serial = slot_serial++;
                 memset(slot_array[i].name, 0, SLOT_NAMEMAX);                  memset(slot_array[i].name, 0, SLOT_NAMEMAX);
         }          }
Line 408 
Line 408 
         x.dev = SYSEX_DEV_ANY;          x.dev = SYSEX_DEV_ANY;
         x.id0 = SYSEX_AUCAT;          x.id0 = SYSEX_AUCAT;
         x.id1 = SYSEX_AUCAT_SLOTDESC;          x.id1 = SYSEX_AUCAT_SLOTDESC;
         if (*s->name != '\0')          if (s->opt != NULL && s->opt->dev == d)
                 slot_ctlname(s, (char *)x.u.slotdesc.name, SYSEX_NAMELEN);                  slot_ctlname(s, (char *)x.u.slotdesc.name, SYSEX_NAMELEN);
         x.u.slotdesc.chan = (s - slot_array);          x.u.slotdesc.chan = (s - slot_array);
         x.u.slotdesc.end = SYSEX_END;          x.u.slotdesc.end = SYSEX_END;
Line 424 
Line 424 
   
         dev_midi_master(d);          dev_midi_master(d);
         for (i = 0, s = slot_array; i < DEV_NSLOT; i++, s++) {          for (i = 0, s = slot_array; i < DEV_NSLOT; i++, s++) {
                 if (s->dev != d)                  if (s->opt != NULL && s->opt->dev != d)
                         continue;                          continue;
                 dev_midi_slotdesc(d, s);                  dev_midi_slotdesc(d, s);
                 dev_midi_vol(d, s);                  dev_midi_vol(d, s);
Line 461 
Line 461 
                 chan = msg[0] & MIDI_CHANMASK;                  chan = msg[0] & MIDI_CHANMASK;
                 if (chan >= DEV_NSLOT)                  if (chan >= DEV_NSLOT)
                         return;                          return;
                 if (slot_array[chan].dev != d)                  if (slot_array[chan].opt == NULL ||
                       slot_array[chan].opt->dev != d)
                         return;                          return;
                 slot_setvol(slot_array + chan, msg[2]);                  slot_setvol(slot_array + chan, msg[2]);
                 dev_onval(d, CTLADDR_SLOT_LEVEL(chan), msg[2]);                  dev_onval(d, CTLADDR_SLOT_LEVEL(chan), msg[2]);
Line 1235 
Line 1236 
                 return 0;                  return 0;
   
         for (i = 0, s = slot_array; i < DEV_NSLOT; i++, s++) {          for (i = 0, s = slot_array; i < DEV_NSLOT; i++, s++) {
                 if (s->dev != d || s->name[0] == 0)                  if (s->opt == NULL || s->opt->dev != d || s->name[0] == 0)
                         continue;                          continue;
                 slot_ctlname(s, name, CTL_NAMEMAX);                  slot_ctlname(s, name, CTL_NAMEMAX);
                 dev_addctl(d, "app", CTL_NUM,                  dev_addctl(d, "app", CTL_NUM,
Line 1270 
Line 1271 
         struct ctlslot *c;          struct ctlslot *c;
   
         for (i = 0, s = slot_array; i < DEV_NSLOT; i++, s++) {          for (i = 0, s = slot_array; i < DEV_NSLOT; i++, s++) {
                 if (s->dev != d)                  if (s->opt == NULL || s->opt->dev != d)
                         continue;                          continue;
                 if (s->ops)                  if (s->ops) {
                         s->ops->exit(s->arg);                          s->ops->exit(s->arg);
                 s->ops = NULL;                          s->ops = NULL;
                   }
         }          }
         d->slot_list = NULL;          d->slot_list = NULL;
   
         for (c = ctlslot_array, i = DEV_NCTLSLOT; i > 0; i--, c++) {          for (c = ctlslot_array, i = DEV_NCTLSLOT; i > 0; i--, c++) {
                 if (c->opt->dev != d)                  if (c->opt->dev != d)
                         continue;                          continue;
                 if (c->ops)                  if (c->ops) {
                         c->ops->exit(c->arg);                          c->ops->exit(c->arg);
                 c->ops = NULL;                          c->ops = NULL;
                   }
         }          }
   
         midi_abort(d->midi);          midi_abort(d->midi);
Line 1574 
Line 1577 
         }          }
   
         for (i = 0, s = slot_array; i < DEV_NSLOT; i++, s++) {          for (i = 0, s = slot_array; i < DEV_NSLOT; i++, s++) {
                 if (s->dev != d || !s->ops || !s->opt->mmc)                  if (s->opt == NULL || s->opt->dev != d || !s->ops || !s->opt->mmc)
                         continue;                          continue;
                 if (s->pstate != SLOT_READY) {                  if (s->pstate != SLOT_READY) {
 #ifdef DEBUG  #ifdef DEBUG
Line 1590 
Line 1593 
                 return;                  return;
   
         for (i = 0, s = slot_array; i < DEV_NSLOT; i++, s++) {          for (i = 0, s = slot_array; i < DEV_NSLOT; i++, s++) {
                 if (s->dev != d || !s->ops || !s->opt->mmc)                  if (s->opt == NULL || s->opt->dev != d || !s->ops || !s->opt->mmc)
                         continue;                          continue;
                 slot_attach(s);                  slot_attach(s);
                 s->pstate = SLOT_RUN;                  s->pstate = SLOT_RUN;
Line 1670 
Line 1673 
 slot_initconv(struct slot *s)  slot_initconv(struct slot *s)
 {  {
         unsigned int dev_nch;          unsigned int dev_nch;
         struct dev *d = s->dev;          struct dev *d = s->opt->dev;
   
         if (s->mode & MODE_PLAY) {          if (s->mode & MODE_PLAY) {
                 cmap_init(&s->mix.cmap,                  cmap_init(&s->mix.cmap,
Line 1751 
Line 1754 
 void  void
 slot_allocbufs(struct slot *s)  slot_allocbufs(struct slot *s)
 {  {
         struct dev *d = s->dev;          struct dev *d = s->opt->dev;
   
         if (s->mode & MODE_PLAY) {          if (s->mode & MODE_PLAY) {
                 s->mix.bpf = s->par.bps * s->mix.nch;                  s->mix.bpf = s->par.bps * s->mix.nch;
Line 1826 
Line 1829 
  * allocate a new slot and register the given call-backs   * allocate a new slot and register the given call-backs
  */   */
 struct slot *  struct slot *
 slot_new(struct dev *d, struct opt *opt, unsigned int id, char *who,  slot_new(struct opt *opt, unsigned int id, char *who,
     struct slotops *ops, void *arg, int mode)      struct slotops *ops, void *arg, int mode)
 {  {
         char *p;          char *p;
Line 1923 
Line 1926 
                         slot_log(s);                          slot_log(s);
                         log_puts(": requested mode not allowed\n");                          log_puts(": requested mode not allowed\n");
                 }                  }
                 return 0;                  return NULL;
         }          }
         if (!dev_ref(d))          if (!dev_ref(opt->dev))
                 return NULL;                  return NULL;
         dev_label(d, s - slot_array);          if ((mode & opt->dev->mode) != mode) {
         if ((mode & d->mode) != mode) {  
                 if (log_level >= 1) {                  if (log_level >= 1) {
                         slot_log(s);                          slot_log(s);
                         log_puts(": requested mode not supported\n");                          log_puts(": requested mode not supported\n");
                 }                  }
                 dev_unref(d);                  dev_unref(opt->dev);
                 return NULL;                  return NULL;
         }          }
         s->dev = d;  
         s->opt = opt;          s->opt = opt;
         s->ops = ops;          s->ops = ops;
         s->arg = arg;          s->arg = arg;
Line 1948 
Line 1949 
         if (s->mode & MODE_RECMASK)          if (s->mode & MODE_RECMASK)
                 s->sub.nch = s->opt->rmax - s->opt->rmin + 1;                  s->sub.nch = s->opt->rmax - s->opt->rmin + 1;
         s->xrun = s->opt->mmc ? XRUN_SYNC : XRUN_IGNORE;          s->xrun = s->opt->mmc ? XRUN_SYNC : XRUN_IGNORE;
         s->appbufsz = d->bufsz;          s->appbufsz = s->opt->dev->bufsz;
         s->round = d->round;          s->round = s->opt->dev->round;
         s->rate = d->rate;          s->rate = s->opt->dev->rate;
         dev_midi_slotdesc(d, s);          dev_label(s->opt->dev, s - slot_array);
         dev_midi_vol(d, s);          dev_midi_slotdesc(s->opt->dev, s);
           dev_midi_vol(s->opt->dev, s);
 #ifdef DEBUG  #ifdef DEBUG
         if (log_level >= 3) {          if (log_level >= 3) {
                 slot_log(s);                  slot_log(s);
                 log_puts(": using ");                  log_puts(": using ");
                 dev_log(d);                  dev_log(s->opt->dev);
                 log_puts(".");                  log_puts(".");
                 log_puts(opt->name);                  log_puts(s->opt->name);
                 log_puts(", mode = ");                  log_puts(", mode = ");
                 log_putx(mode);                  log_putx(mode);
                 log_puts("\n");                  log_puts("\n");
Line 1987 
Line 1989 
                 slot_stop(s, 0);                  slot_stop(s, 0);
                 break;                  break;
         }          }
         dev_unref(s->dev);          dev_unref(s->opt->dev);
         s->dev = NULL;  
 }  }
   
 /*  /*
Line 2015 
Line 2016 
 void  void
 slot_attach(struct slot *s)  slot_attach(struct slot *s)
 {  {
         struct dev *d = s->dev;          struct dev *d = s->opt->dev;
         long long pos;          long long pos;
   
         /*          /*
Line 2080 
Line 2081 
          * device may be disconnected, and if so we're called from           * device may be disconnected, and if so we're called from
          * slot->ops->exit() on a closed device           * slot->ops->exit() on a closed device
          */           */
         if (s->dev->pstate == DEV_CFG)          if (s->opt->dev->pstate == DEV_CFG)
                 return;                  return;
         if (!s->opt->mmc) {          if (!s->opt->mmc) {
                 slot_attach(s);                  slot_attach(s);
                 s->pstate = SLOT_RUN;                  s->pstate = SLOT_RUN;
         } else          } else
                 dev_sync_attach(s->dev);                  dev_sync_attach(s->opt->dev);
 }  }
   
 /*  /*
Line 2096 
Line 2097 
 void  void
 slot_start(struct slot *s)  slot_start(struct slot *s)
 {  {
         struct dev *d = s->dev;          struct dev *d = s->opt->dev;
 #ifdef DEBUG  #ifdef DEBUG
         if (s->pstate != SLOT_INIT) {          if (s->pstate != SLOT_INIT) {
                 slot_log(s);                  slot_log(s);
Line 2156 
Line 2157 
 slot_detach(struct slot *s)  slot_detach(struct slot *s)
 {  {
         struct slot **ps;          struct slot **ps;
         struct dev *d = s->dev;          struct dev *d = s->opt->dev;
         long long pos;          long long pos;
   
         for (ps = &d->slot_list; *ps != s; ps = &(*ps)->next) {          for (ps = &d->slot_list; *ps != s; ps = &(*ps)->next) {
Line 2570 
Line 2571 
                 } else {                  } else {
                         num = addr - CTLADDR_SLOT_LEVEL(0);                          num = addr - CTLADDR_SLOT_LEVEL(0);
                         s = slot_array + num;                          s = slot_array + num;
                         if (s->dev != d)                          if (s->opt->dev != d)
                                 return 1;                                  return 1;
                         slot_setvol(s, val);                          slot_setvol(s, val);
                         dev_midi_vol(d, s);                          dev_midi_vol(d, s);
Legend:
Removed from v.1.88  
changed lines
  Added in v.1.89