home *** CD-ROM | disk | FTP | other *** search
/ ftp.ee.lbl.gov / 2014.05.ftp.ee.lbl.gov.tar / ftp.ee.lbl.gov / bmd-1.0beta.tar.Z / bmd-1.0beta.tar / bmd-1.0beta / app / omtd / merge.c < prev    next >
C/C++ Source or Header  |  1991-08-21  |  8KB  |  423 lines
  1. /*
  2.  * Copyright (c) 1990 Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms are permitted
  6.  * provided that the above copyright notice and this paragraph are
  7.  * duplicated in all such forms and that any documentation,
  8.  * advertising materials, and other materials related to such
  9.  * distribution and use acknowledge that the software was developed
  10.  * by the University of California, Lawrence Berkeley Laboratory,
  11.  * Berkeley, CA.  The name of the University may not be used to
  12.  * endorse or promote products derived from this software without
  13.  * specific prior written permission.
  14.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  15.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  16.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  17.  */
  18. #include <sys/types.h>
  19. #include <sundev/midi.h>
  20. #include "readline.h"
  21. #include "event.h"
  22. #include "setting.h"
  23. #include "etime.h"
  24. #include "track.h"
  25.  
  26. /*
  27.  * Merge last track recorded into a track.
  28.  */
  29.  
  30. void
  31. merge_command(trkp)
  32.     struct track *trkp;
  33. {
  34.     struct event *raw, **masterp, *p;
  35.     struct event *pending;
  36.     u_long lasttime;
  37.     int n = 0, new_track = 0;
  38.  
  39.     pending = 0;
  40.     masterp = &master_list;
  41.     for (raw = raw_list; raw != 0; raw = raw->next)
  42.     {
  43.         if (evt_noteoff_p(raw))
  44.         {
  45.             p = pq_remove_bynote(&pending, raw->m.mm_data[1]);
  46.             if (p != 0)
  47.                 p->duration = unwarp_time(s.tempo, 
  48.                               raw->m.mm_time)
  49.                     - p->m.mm_time;
  50.             continue;
  51.         }
  52.         ++n;
  53.         p = ealloc();
  54.         p->trk = trkp;
  55.         p->m = raw->m;
  56.         p->m.mm_time = unwarp_time(s.tempo, raw->m.mm_time);
  57.         if (evt_noteon_p(raw))
  58.             pq_insert(&pending, p);
  59.         /* 
  60.          * Insert event in master list.
  61.          */
  62.         while (*masterp && (*masterp)->m.mm_time <= p->m.mm_time)
  63.             masterp = &(*masterp)->next;
  64.         p->next = *masterp;
  65.         *masterp = p;
  66.     }
  67.     if (pending)
  68.     {
  69.         lasttime = p->m.mm_time;
  70.         for (; pending != 0; pending = pending->pqnext)
  71.             pending->duration = lasttime - pending->m.mm_time;
  72.     }
  73.     printf("Merged %d events\n", n);
  74.     efreel(raw_list);
  75.     raw_list = 0;
  76. }
  77.  
  78. void
  79. channel_command(trkp, channel)
  80.     struct track *trkp;
  81.     int channel;
  82. {
  83.     trkp->channel = (channel - 1) & 0xf;
  84. }
  85.  
  86. void
  87. clear_command(trk, start, end)
  88.     struct track *trk;
  89.     int start, end;
  90. {
  91.     struct event **pp;
  92.  
  93.     pp = &master_list;
  94.     while (*pp != 0) {
  95.         if ((*pp)->trk == trk && 
  96.             (*pp)->m.mm_time >= start &&
  97.             (*pp)->m.mm_time < end) {
  98.             struct event *tmp = *pp;
  99.  
  100.             *pp = (*pp)->next;
  101.             efree(tmp);
  102.         } else
  103.             pp = &(*pp)->next;
  104.     }
  105. }
  106.  
  107. void
  108. move_command(amt, start)
  109.     int amt, start;
  110. {
  111.     struct event *p;
  112.  
  113.     for (p = master_list; p != 0; p = p->next) {
  114.         if (p->m.mm_time >= start)
  115.             p->m.mm_time += amt;
  116.     }
  117. }
  118.  
  119. void
  120. mute_command(trk, val)
  121.     struct track *trk;
  122.     int val;
  123. {
  124.     if (trk == 0)
  125.         return;
  126.     trk->mute = val;
  127. }
  128.  
  129. void
  130. unmute_command(tp)
  131.     struct token *tp;
  132. {
  133.     struct track *trk;
  134.     struct event **pp;
  135.     int mute = 0;
  136.  
  137.     if (tp == 0)
  138.     {
  139.         for (trk = trklist; trk != 0; trk = trk->next)
  140.             trk->mute = mute;
  141.         return;
  142.     }
  143.     else if (tp->t_id != TK_IDENT)
  144.     {
  145.         error ("unmute track_name");
  146.         return;
  147.     }
  148.     if ((trk = find_track(tp->t_str)) != 0)
  149.         trk->mute = mute;
  150. }
  151.     
  152.  
  153. struct event *
  154. copyout_track(trk, start, end)
  155.     struct track *trk;
  156.     u_long start, end;
  157. {
  158.     struct event *head, **pp = &head, *p;
  159.  
  160.     for (p = master_list; p != 0; p = p->next)
  161.     {
  162.         if (p->trk == trk &&
  163.             p->m.mm_time >= start && p->m.mm_time < end)
  164.         {
  165.             *pp = ealloc();
  166.             **pp = *p;
  167.             pp = &(*pp)->next;
  168.         }
  169.     }
  170.     *pp = 0;
  171.     return head;
  172. }
  173.  
  174. struct event *
  175. extract_track(trk, start, end)
  176.     struct track *trk;
  177.     u_long start, end;
  178. {
  179.     struct event *head, **pp = &head, *p, **op;
  180.  
  181.     op = &master_list;
  182.     while (*op != 0)
  183.     {
  184.         if ((*op)->trk == trk && 
  185.             (*op)->m.mm_time >= start && (*op)->m.mm_time < end)
  186.         {
  187.             *pp = *op;
  188.             pp = &(*pp)->next;
  189.             *op = (*op)->next;
  190.         }
  191.         else
  192.             op = &(*op)->next;
  193.     }
  194.     *pp = 0;
  195.  
  196.     return head;
  197. }
  198.  
  199. void
  200. insert_list(elist)
  201.     struct event *elist;
  202. {
  203.     struct event **pp, *p;
  204.  
  205.     pp = &master_list;
  206.     while (elist != 0)
  207.     {
  208.         while (*pp && (*pp)->m.mm_time <= elist->m.mm_time)
  209.             pp = &(*pp)->next;
  210.         p = elist;
  211.         elist = elist->next;
  212.         p->next = *pp;
  213.         *pp = p;
  214.     }
  215. }
  216.  
  217. void
  218. copy_command(strk, start, end, dtrk, dstart, repeat)
  219.     struct track *strk, *dtrk;
  220.     u_long start = 0, end = ~0, dstart;
  221. {
  222.     u_long delta;
  223.     struct event *elist, *p;
  224.  
  225.     if (repeat > 1 && end == ~0) {
  226.         printf("must give length if repeat > 0\n");
  227.         return;
  228.     }
  229.     if (start > end) {
  230.         printf("start time must be less than end time\n");
  231.         return;
  232.     }
  233.     delta = dstart - start;
  234.  
  235.     while (--repeat >= 0) {
  236.         elist = copyout_track(strk, start, end);
  237.         for (p = elist; p != 0; p = p->next) {
  238.             p->trk = dtrk;
  239.             p->m.mm_time += delta;
  240.         }
  241.         insert_list(elist);
  242.         delta += end - start;
  243.     }
  244. }
  245.  
  246. void
  247. quantize_command(trk, n, d)
  248.     struct track *trk;
  249.     int n, d;
  250. {
  251.     struct event *p;
  252.     int t, r;
  253.  
  254.     if (d == 0) {
  255.         printf("error: division by zero\n");
  256.         return;
  257.     }
  258.     r = s.ticks_per_beat * n * 4;
  259.     r /= d;
  260.  
  261.     for (p = master_list; p != 0; p = p->next) {
  262.         if (p->trk == trk) {
  263.             t = p->m.mm_time;
  264.             t += r / 2;
  265.             t -= t % r;
  266.             p->m.mm_time = t;
  267.         }
  268.     }
  269. }
  270.  
  271. void
  272. insert_command(tp)
  273.     struct token *tp;
  274. {
  275.     struct track *trk;
  276.     struct event *p, *newlist;
  277.     u_long at = 0, amt = 0;
  278.  
  279.     if (tp == 0 || tp->t_id != TK_IDENT)
  280.         goto bad;
  281.     trk = find_track(tp->t_str);
  282.     if (trk == 0)
  283.         return;
  284.     tp = tp->next;
  285.     if (tp == 0 || tp->t_id != ':')
  286.         goto bad;
  287.  
  288.     tp = tp->next;
  289.     if (tp == 0)
  290.         goto bad;
  291.     tp = parse_time(tp, &at);
  292.     if (tp == 0)
  293.         goto bad;
  294.     tp = parse_time(tp, &amt);
  295.  
  296.     if (amt == 0)
  297.         return;
  298.  
  299.     newlist = extract_track(trk, at, (u_long)~0);
  300.     for (p = newlist; p != 0; p = p->next)
  301.         p->m.mm_time += amt;
  302.     insert_list(newlist);
  303.     return;
  304.  bad:
  305.     printf("error: insert trk:time amt\n");
  306. }
  307.  
  308. void
  309. volume_command(tp)
  310.     struct token *tp;
  311. {
  312.     struct track *trk;
  313.     struct event *p, *newlist;
  314.     int volume;
  315.     u_long start = 0, end = ~0;
  316.  
  317.     if (tp == 0 || tp->t_id != TK_INT)
  318.         goto bad;
  319.     volume = tp->t_int;
  320.     tp = tp->next;
  321.     if (tp == 0 || tp->t_id != TK_IDENT)
  322.         goto bad;
  323.     trk = find_track(tp->t_str);
  324.     if (trk == 0)
  325.         return;
  326.     tp = tp->next;
  327.     if (tp && tp->t_id == ':')
  328.     {
  329.         tp = tp->next;
  330.         tp = parse_time(tp, &start);
  331.         if (tp && tp->t_id == ',')
  332.         {
  333.             tp = tp->next;
  334.             tp = parse_time(tp, &end);
  335.         }
  336.     }
  337.     for (p = master_list; p != 0; p = p->next)
  338.         if (p->trk == trk && (p->m.mm_cmd & 0xf0) == 0x90 &&
  339.             p->m.mm_time >= start && p->m.mm_time < end)
  340.             p->m.mm_data[2] = volume;
  341.     return;
  342.  bad:
  343.     printf("error: volume amt trk:time\n");
  344. }
  345.  
  346. #define BAR_TO_TIME(bar, beat)    (((bar) * s.beats_per_bar + (beat)) * \
  347.                  s.ticks_per_beat)
  348. void
  349. transpose_command(tp)
  350.     struct token *tp;
  351. {
  352.     int    all_flag = 1,        /* transpose all tracks? */
  353.         trans_num,        /* # of notes by which to tranpose */
  354.         sign = 1;
  355.     struct track *trk;        /* track */
  356.     struct event *p, *curr;
  357.     u_long    st = 0,            /* start time */
  358.         et = ~0;        /* end time */
  359.  
  360.     if (tp && tp->t_id == TK_IDENT)
  361.     {
  362.         trk = find_track(tp->t_str);
  363.         all_flag = 0;
  364.     }
  365.     
  366.     if (tp == 0)
  367.         goto bad;
  368.     
  369.     tp = tp->next;
  370.     
  371.     if (tp && tp->t_id == ':')
  372.         tp = parse_window(tp->next, &st, &et);
  373.         
  374.     if (tp == 0)
  375.         goto bad;
  376.  
  377.     if (tp->t_id == '-')
  378.     {
  379.         sign = -1;
  380.         tp = tp->next;
  381.     }
  382.     
  383.     if (tp == 0 || tp->t_id != TK_INT)    
  384.         goto bad;
  385.  
  386.     trans_num = tp->t_int * sign;
  387.  
  388.     tp = tp->next;
  389.     if (tp != 0)
  390.         goto bad;
  391.  
  392.     for (p = master_list; p != 0; p = p->next)
  393.     {
  394.         if ((all_flag || p->trk == trk) &&
  395.             p->m.mm_time >= st &&
  396.             p->m.mm_time < et)
  397.         {
  398.             if (p->m.mm_data[1] + trans_num > 127)
  399.             {
  400.                 printf("Warning! Tranposition out of range.");
  401.                 printf("\nUndoing transposition.\n");
  402.                         
  403.                 for (curr = master_list; curr != p;
  404.                      curr = curr->next)
  405.                     if ((all_flag || curr->trk == trk) &&
  406.                         curr->m.mm_time >= st &&
  407.                         curr->m.mm_time < et)
  408.                     {
  409.                         curr->m.mm_data[1] -=
  410.                                 trans_num;
  411.                     }
  412.                 break;
  413.             }
  414.             p->m.mm_data[1] += trans_num;
  415.         }
  416.     }
  417.     return;
  418.     
  419. bad:
  420.     error("trans [track] [:[start_time][, end_time]] #_of_half_tones");
  421. }
  422.  
  423.