开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
mix.c
资源名称：SDL_mixer-1.2.11.tar.gz　[点击查看]
上传用户：nini_0081
上传日期：2022-07-21
资源大小：2628k
文件大小：18k
源码类别：

多媒体编程

开发平台：

DOS

mix.c：源码内容
  1. /*
  3.     TiMidity -- Experimental MIDI to WAVE converter
  4.     Copyright (C) 1995 Tuukka Toivonen <toivonen@clinet.fi>
  6.     Suddenly, you realize that this program is free software; you get
  7.     an overwhelming urge to redistribute it and/or modify it under the
  8.     terms of the GNU General Public License as published by the Free
  9.     Software Foundation; either version 2 of the License, or (at your
  10.     option) any later version.
  12.     This program is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  17.     You should have received another copy of the GNU General Public
  18.     License along with this program; if not, write to the Free
  19.     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20.     I bet they'll be amazed.
  22.     mix.c */
  24. #include <math.h>
  25. #include <stdio.h>
  26. #include <stdlib.h>
  28. #include "config.h"
  29. #include "common.h"
  30. #include "instrum.h"
  31. #include "playmidi.h"
  32. #include "output.h"
  33. #include "ctrlmode.h"
  34. #include "tables.h"
  35. #include "resample.h"
  36. #include "mix.h"
  38. /* Returns 1 if envelope runs out */
  39. int recompute_envelope(int v)
  40. {
  41.   int stage;
  43.   stage = voice[v].envelope_stage;
  45.   if (stage>5)
  46.     {
  47.       /* Envelope ran out. */
  48.       int tmp=(voice[v].status == VOICE_DIE); /* Already displayed as dead */
  49.       voice[v].status = VOICE_FREE;
  50.       if(!tmp)
  51. ctl->note(v);
  52.       return 1;
  53.     }
  55.   if (voice[v].sample->modes & MODES_ENVELOPE)
  56.     {
  57.       if (voice[v].status==VOICE_ON || voice[v].status==VOICE_SUSTAINED)
  58. {
  59.   if (stage>2)
  60.     {
  61.       /* Freeze envelope until note turns off. Trumpets want this. */
  62.       voice[v].envelope_increment=0;
  63.       return 0;
  64.     }
  65. }
  66.     }
  67.   voice[v].envelope_stage=stage+1;
  69.   if (voice[v].envelope_volume==voice[v].sample->envelope_offset[stage])
  70.     return recompute_envelope(v);
  71.   voice[v].envelope_target=voice[v].sample->envelope_offset[stage];
  72.   voice[v].envelope_increment = voice[v].sample->envelope_rate[stage];
  73.   if (voice[v].envelope_target<voice[v].envelope_volume)
  74.     voice[v].envelope_increment = -voice[v].envelope_increment;
  75.   return 0;
  76. }
  78. void apply_envelope_to_amp(int v)
  79. {
  80.   FLOAT_T lamp=voice[v].left_amp, ramp, lramp, rramp, ceamp, lfeamp;
  81.   int32 la,ra, lra, rra, cea, lfea;
  82.   if (voice[v].panned == PANNED_MYSTERY)
  83.     {
  84.       lramp=voice[v].lr_amp;
  85.       ramp=voice[v].right_amp;
  86.       ceamp=voice[v].ce_amp;
  87.       rramp=voice[v].rr_amp;
  88.       lfeamp=voice[v].lfe_amp;
  90.       if (voice[v].tremolo_phase_increment)
  91. {
  92.   FLOAT_T tv = voice[v].tremolo_volume;
  93.   lramp *= tv;
  94.   lamp *= tv;
  95.   ceamp *= tv;
  96.   ramp *= tv;
  97.   rramp *= tv;
  98.   lfeamp *= tv;
  99. }
  100.       if (voice[v].sample->modes & MODES_ENVELOPE)
  101. {
  102.   FLOAT_T ev = (FLOAT_T)vol_table[voice[v].envelope_volume>>23];
  103.   lramp *= ev;
  104.   lamp *= ev;
  105.   ceamp *= ev;
  106.   ramp *= ev;
  107.   rramp *= ev;
  108.   lfeamp *= ev;
  109. }
  111.       la = (int32)FSCALE(lamp,AMP_BITS);
  112.       ra = (int32)FSCALE(ramp,AMP_BITS);
  113.       lra = (int32)FSCALE(lramp,AMP_BITS);
  114.       rra = (int32)FSCALE(rramp,AMP_BITS);
  115.       cea = (int32)FSCALE(ceamp,AMP_BITS);
  116.       lfea = (int32)FSCALE(lfeamp,AMP_BITS);
  117.       
  118.       if (la>MAX_AMP_VALUE) la=MAX_AMP_VALUE;
  119.       if (ra>MAX_AMP_VALUE) ra=MAX_AMP_VALUE;
  120.       if (lra>MAX_AMP_VALUE) lra=MAX_AMP_VALUE;
  121.       if (rra>MAX_AMP_VALUE) rra=MAX_AMP_VALUE;
  122.       if (cea>MAX_AMP_VALUE) cea=MAX_AMP_VALUE;
  123.       if (lfea>MAX_AMP_VALUE) lfea=MAX_AMP_VALUE;
  125.       voice[v].lr_mix=FINAL_VOLUME(lra);
  126.       voice[v].left_mix=FINAL_VOLUME(la);
  127.       voice[v].ce_mix=FINAL_VOLUME(cea);
  128.       voice[v].right_mix=FINAL_VOLUME(ra);
  129.       voice[v].rr_mix=FINAL_VOLUME(rra);
  130.       voice[v].lfe_mix=FINAL_VOLUME(lfea);
  131.     }
  132.   else
  133.     {
  134.       if (voice[v].tremolo_phase_increment)
  135. lamp *= voice[v].tremolo_volume;
  136.       if (voice[v].sample->modes & MODES_ENVELOPE)
  137. lamp *= (FLOAT_T)vol_table[voice[v].envelope_volume>>23];
  139.       la = (int32)FSCALE(lamp,AMP_BITS);
  141.       if (la>MAX_AMP_VALUE)
  142. la=MAX_AMP_VALUE;
  144.       voice[v].left_mix=FINAL_VOLUME(la);
  145.     }
  146. }
  148. static int update_envelope(int v)
  149. {
  150.   voice[v].envelope_volume += voice[v].envelope_increment;
  151.   /* Why is there no ^^ operator?? */
  152.   if (((voice[v].envelope_increment < 0) &&
  153.        (voice[v].envelope_volume <= voice[v].envelope_target)) ||
  154.       ((voice[v].envelope_increment > 0) &&
  155.    (voice[v].envelope_volume >= voice[v].envelope_target)))
  156.     {
  157.       voice[v].envelope_volume = voice[v].envelope_target;
  158.       if (recompute_envelope(v))
  159. return 1;
  160.     }
  161.   return 0;
  162. }
  164. static void update_tremolo(int v)
  165. {
  166.   int32 depth=voice[v].sample->tremolo_depth<<7;
  168.   if (voice[v].tremolo_sweep)
  169.     {
  170.       /* Update sweep position */
  172.       voice[v].tremolo_sweep_position += voice[v].tremolo_sweep;
  173.       if (voice[v].tremolo_sweep_position>=(1<<SWEEP_SHIFT))
  174. voice[v].tremolo_sweep=0; /* Swept to max amplitude */
  175.       else
  176. {
  177.   /* Need to adjust depth */
  178.   depth *= voice[v].tremolo_sweep_position;
  179.   depth >>= SWEEP_SHIFT;
  180. }
  181.     }
  183.   voice[v].tremolo_phase += voice[v].tremolo_phase_increment;
  185.   /* if (voice[v].tremolo_phase >= (SINE_CYCLE_LENGTH<<RATE_SHIFT))
  186.      voice[v].tremolo_phase -= SINE_CYCLE_LENGTH<<RATE_SHIFT;  */
  188.   voice[v].tremolo_volume = (FLOAT_T) 
  189.     (1.0 - FSCALENEG((sine(voice[v].tremolo_phase >> RATE_SHIFT) + 1.0)
  190.     * depth * TREMOLO_AMPLITUDE_TUNING,
  191.     17));
  193.   /* I'm not sure about the +1.0 there -- it makes tremoloed voices'
  194.      volumes on average the lower the higher the tremolo amplitude. */
  195. }
  197. /* Returns 1 if the note died */
  198. static int update_signal(int v)
  199. {
  200.   if (voice[v].envelope_increment && update_envelope(v))
  201.     return 1;
  203.   if (voice[v].tremolo_phase_increment)
  204.     update_tremolo(v);
  206.   apply_envelope_to_amp(v);
  207.   return 0;
  208. }
  210. #ifdef LOOKUP_HACK
  211. #  define MIXATION(a) *lp++ += mixup[(a<<8) | (uint8)s];
  212. #else
  213. #  define MIXATION(a) *lp++ += (a)*s;
  214. #endif
  216. #define MIXSKIP lp++
  217. #define MIXMAX(a,b) *lp++ += ((a>b)?a:b) * s
  218. #define MIXCENT(a,b) *lp++ += (a/2+b/2) * s
  219. #define MIXHALF(a) *lp++ += (a>>1)*s;
  221. static void mix_mystery_signal(resample_t *sp, int32 *lp, int v, int count)
  222. {
  223.   Voice *vp = voice + v;
  224.   final_volume_t 
  225.     left_rear=vp->lr_mix, 
  226.     left=vp->left_mix, 
  227.     center=vp->ce_mix, 
  228.     right=vp->right_mix, 
  229.     right_rear=vp->rr_mix, 
  230.     lfe=vp->lfe_mix;
  231.   int cc;
  232.   resample_t s;
  234.   if (!(cc = vp->control_counter))
  235.     {
  236.       cc = control_ratio;
  237.       if (update_signal(v))
  238. return; /* Envelope ran out */
  240. left_rear = vp->lr_mix;
  241. left = vp->left_mix;
  242. center = vp->ce_mix;
  243. right = vp->right_mix;
  244. right_rear = vp->rr_mix;
  245. lfe = vp->lfe_mix;
  246.     }
  247.   
  248.   while (count)
  249.     if (cc < count)
  250.       {
  251. count -= cc;
  252. while (cc--)
  253.   {
  254.     s = *sp++;
  255.        MIXATION(left);
  256.        MIXATION(right);
  257. if (num_ochannels >= 4) {
  258. MIXATION(left_rear);
  259. MIXATION(right_rear);
  260. }
  261. if (num_ochannels == 6) {
  262. MIXATION(center);
  263. MIXATION(lfe);
  264. }
  265.   }
  266. cc = control_ratio;
  267. if (update_signal(v))
  268.   return; /* Envelope ran out */
  269. left_rear = vp->lr_mix;
  270. left = vp->left_mix;
  271. center = vp->ce_mix;
  272. right = vp->right_mix;
  273. right_rear = vp->rr_mix;
  274. lfe = vp->lfe_mix;
  275.       }
  276.     else
  277.       {
  278. vp->control_counter = cc - count;
  279. while (count--)
  280.   {
  281.     s = *sp++;
  282.        MIXATION(left);
  283.        MIXATION(right);
  284. if (num_ochannels >= 4) {
  285. MIXATION(left_rear);
  286. MIXATION(right_rear);
  287. }
  288. if (num_ochannels == 6) {
  289. MIXATION(center);
  290. MIXATION(lfe);
  291. }
  292.   }
  293. return;
  294.       }
  295. }
  297. static void mix_center_signal(resample_t *sp, int32 *lp, int v, int count)
  298. {
  299.   Voice *vp = voice + v;
  300.   final_volume_t 
  301.     left=vp->left_mix;
  302.   int cc;
  303.   resample_t s;
  305.   if (!(cc = vp->control_counter))
  306.     {
  307.       cc = control_ratio;
  308.       if (update_signal(v))
  309. return; /* Envelope ran out */
  310.       left = vp->left_mix;
  311.     }
  312.   
  313.   while (count)
  314.     if (cc < count)
  315.       {
  316. count -= cc;
  317. while (cc--)
  318.   {
  319.     s = *sp++;
  320. if (num_ochannels == 2) {
  321.      MIXATION(left);
  322.      MIXATION(left);
  323. }
  324. else if (num_ochannels == 4) {
  325. MIXATION(left);
  326. MIXSKIP;
  327. MIXATION(left);
  328. MIXSKIP;
  329. }
  330. else if (num_ochannels == 6) {
  331. MIXSKIP;
  332. MIXSKIP;
  333. MIXSKIP;
  334. MIXSKIP;
  335. MIXATION(left);
  336. MIXATION(left);
  337. }
  338.   }
  339. cc = control_ratio;
  340. if (update_signal(v))
  341.   return; /* Envelope ran out */
  342. left = vp->left_mix;
  343.       }
  344.     else
  345.       {
  346. vp->control_counter = cc - count;
  347. while (count--)
  348.   {
  349.     s = *sp++;
  350. if (num_ochannels == 2) {
  351.      MIXATION(left);
  352.      MIXATION(left);
  353. }
  354. else if (num_ochannels == 4) {
  355. MIXATION(left);
  356. MIXSKIP;
  357. MIXATION(left);
  358. MIXSKIP;
  359. }
  360. else if (num_ochannels == 6) {
  361. MIXSKIP;
  362. MIXSKIP;
  363. MIXSKIP;
  364. MIXSKIP;
  365. MIXATION(left);
  366. MIXATION(left);
  367. }
  368.   }
  369. return;
  370.       }
  371. }
  373. static void mix_single_left_signal(resample_t *sp, int32 *lp, int v, int count)
  374. {
  375.   Voice *vp = voice + v;
  376.   final_volume_t 
  377.     left=vp->left_mix;
  378.   int cc;
  379.   resample_t s;
  380.   
  381.   if (!(cc = vp->control_counter))
  382.     {
  383.       cc = control_ratio;
  384.       if (update_signal(v))
  385. return; /* Envelope ran out */
  386.       left = vp->left_mix;
  387.     }
  388.   
  389.   while (count)
  390.     if (cc < count)
  391.       {
  392. count -= cc;
  393. while (cc--)
  394.   {
  395.     s = *sp++;
  396. if (num_ochannels == 2) {
  397. MIXATION(left);
  398.      MIXSKIP;
  399. }
  400. if (num_ochannels >= 4) {
  401. MIXHALF(left);
  402.      MIXSKIP;
  403. MIXATION(left);
  404.      MIXSKIP;
  405. }
  406. if (num_ochannels == 6) {
  407.      MIXSKIP;
  408. MIXATION(left);
  409. }
  410.   }
  411. cc = control_ratio;
  412. if (update_signal(v))
  413.   return; /* Envelope ran out */
  414. left = vp->left_mix;
  415.       }
  416.     else
  417.       {
  418. vp->control_counter = cc - count;
  419. while (count--)
  420.   {
  421.     s = *sp++;
  422. if (num_ochannels == 2) {
  423. MIXATION(left);
  424.      MIXSKIP;
  425. }
  426. if (num_ochannels >= 4) {
  427. MIXHALF(left);
  428.      MIXSKIP;
  429. MIXATION(left);
  430.      MIXSKIP;
  431. }
  432. if (num_ochannels == 6) {
  433.      MIXSKIP;
  434. MIXATION(left);
  435. }
  436.   }
  437. return;
  438.       }
  439. }
  441. static void mix_single_right_signal(resample_t *sp, int32 *lp, int v, int count)
  442. {
  443.   Voice *vp = voice + v;
  444.   final_volume_t 
  445.     left=vp->left_mix;
  446.   int cc;
  447.   resample_t s;
  448.   
  449.   if (!(cc = vp->control_counter))
  450.     {
  451.       cc = control_ratio;
  452.       if (update_signal(v))
  453. return; /* Envelope ran out */
  454.       left = vp->left_mix;
  455.     }
  456.   
  457.   while (count)
  458.     if (cc < count)
  459.       {
  460. count -= cc;
  461. while (cc--)
  462.   {
  463.     s = *sp++;
  464. if (num_ochannels == 2) {
  465.      MIXSKIP;
  466. MIXATION(left);
  467. }
  468. if (num_ochannels >= 4) {
  469.      MIXSKIP;
  470. MIXHALF(left);
  471.      MIXSKIP;
  472. MIXATION(left);
  473. } if (num_ochannels == 6) {
  474.      MIXSKIP;
  475. MIXATION(left);
  476. }
  477.   }
  478. cc = control_ratio;
  479. if (update_signal(v))
  480.   return; /* Envelope ran out */
  481. left = vp->left_mix;
  482.       }
  483.     else
  484.       {
  485. vp->control_counter = cc - count;
  486. while (count--)
  487.   {
  488.     s = *sp++;
  489. if (num_ochannels == 2) {
  490.      MIXSKIP;
  491. MIXATION(left);
  492. }
  493. if (num_ochannels >= 4) {
  494.      MIXSKIP;
  495. MIXHALF(left);
  496.      MIXSKIP;
  497. MIXATION(left);
  498. } if (num_ochannels == 6) {
  499.      MIXSKIP;
  500. MIXATION(left);
  501. }
  502.   }
  503. return;
  504.       }
  505. }
  507. static void mix_mono_signal(resample_t *sp, int32 *lp, int v, int count)
  508. {
  509.   Voice *vp = voice + v;
  510.   final_volume_t 
  511.     left=vp->left_mix;
  512.   int cc;
  513.   resample_t s;
  514.   
  515.   if (!(cc = vp->control_counter))
  516.     {
  517.       cc = control_ratio;
  518.       if (update_signal(v))
  519. return; /* Envelope ran out */
  520.       left = vp->left_mix;
  521.     }
  522.   
  523.   while (count)
  524.     if (cc < count)
  525.       {
  526. count -= cc;
  527. while (cc--)
  528.   {
  529.     s = *sp++;
  530.     MIXATION(left);
  531.   }
  532. cc = control_ratio;
  533. if (update_signal(v))
  534.   return; /* Envelope ran out */
  535. left = vp->left_mix;
  536.       }
  537.     else
  538.       {
  539. vp->control_counter = cc - count;
  540. while (count--)
  541.   {
  542.     s = *sp++;
  543.     MIXATION(left);
  544.   }
  545. return;
  546.       }
  547. }
  549. static void mix_mystery(resample_t *sp, int32 *lp, int v, int count)
  550. {
  551.   final_volume_t 
  552.     left_rear=voice[v].lr_mix, 
  553.     left=voice[v].left_mix, 
  554.     center=voice[v].ce_mix, 
  555.     right=voice[v].right_mix, 
  556.     right_rear=voice[v].rr_mix, 
  557.     lfe=voice[v].lfe_mix;
  558.   resample_t s;
  559.   
  560.   while (count--)
  561.     {
  562.       s = *sp++;
  563.        MIXATION(left);
  564.        MIXATION(right);
  565. if (num_ochannels >= 4) {
  566. MIXATION(left_rear);
  567. MIXATION(right_rear);
  568. }
  569. if (num_ochannels == 6) {
  570. MIXATION(center);
  571. MIXATION(lfe);
  572. }
  573.     }
  574. }
  576. static void mix_center(resample_t *sp, int32 *lp, int v, int count)
  577. {
  578.   final_volume_t 
  579.     left=voice[v].left_mix;
  580.   resample_t s;
  581.   
  582.   while (count--)
  583.     {
  584.       s = *sp++;
  585. if (num_ochannels == 2) {
  586.        MIXATION(left);
  587.        MIXATION(left);
  588. }
  589. else if (num_ochannels == 4) {
  590.        MIXATION(left);
  591.        MIXATION(left);
  592. MIXSKIP;
  593. MIXSKIP;
  594. }
  595. else if (num_ochannels == 6) {
  596. MIXSKIP;
  597. MIXSKIP;
  598. MIXSKIP;
  599. MIXSKIP;
  600. MIXATION(left);
  601. MIXATION(left);
  602. }
  603.     }
  604. }
  606. static void mix_single_left(resample_t *sp, int32 *lp, int v, int count)
  607. {
  608.   final_volume_t 
  609.     left=voice[v].left_mix;
  610.   resample_t s;
  611.   
  612.   while (count--)
  613.     {
  614.       s = *sp++;
  615. if (num_ochannels == 2) {
  616. MIXATION(left);
  617.        MIXSKIP;
  618. }
  619. if (num_ochannels >= 4) {
  620. MIXHALF(left);
  621.        MIXSKIP;
  622. MIXATION(left);
  623.        MIXSKIP;
  624. }
  625.         if (num_ochannels == 6) {
  626.        MIXSKIP;
  627. MIXATION(left);
  628. }
  629.     }
  630. }
  631. static void mix_single_right(resample_t *sp, int32 *lp, int v, int count)
  632. {
  633.   final_volume_t 
  634.     left=voice[v].left_mix;
  635.   resample_t s;
  636.   
  637.   while (count--)
  638.     {
  639.       s = *sp++;
  640. if (num_ochannels == 2) {
  641.        MIXSKIP;
  642. MIXATION(left);
  643. }
  644. if (num_ochannels >= 4) {
  645.        MIXSKIP;
  646. MIXHALF(left);
  647.        MIXSKIP;
  648. MIXATION(left);
  649. }
  650.         if (num_ochannels == 6) {
  651.        MIXSKIP;
  652. MIXATION(left);
  653. }
  654.     }
  655. }
  657. static void mix_mono(resample_t *sp, int32 *lp, int v, int count)
  658. {
  659.   final_volume_t 
  660.     left=voice[v].left_mix;
  661.   resample_t s;
  662.   
  663.   while (count--)
  664.     {
  665.       s = *sp++;
  666.       MIXATION(left);
  667.     }
  668. }
  670. /* Ramp a note out in c samples */
  671. static void ramp_out(resample_t *sp, int32 *lp, int v, int32 c)
  672. {
  674.   /* should be final_volume_t, but uint8 gives trouble. */
  675.   int32 left_rear, left, center, right, right_rear, lfe, li, ri;
  677.   resample_t s = 0; /* silly warning about uninitialized s */
  679.   /* Fix by James Caldwell */
  680.   if ( c == 0 ) c = 1;
  682.   left = voice[v].left_mix;
  683.   li = -(left/c);
  684.   if (!li) li = -1;
  686.   /* printf("Ramping out: left=%d, c=%d, li=%dn", left, c, li); */
  688.   if (!(play_mode->encoding & PE_MONO))
  689.     {
  690.       if (voice[v].panned==PANNED_MYSTERY)
  691. {
  692.   left_rear = voice[v].lr_mix;
  693.   center=voice[v].ce_mix;
  694.   right=voice[v].right_mix;
  695.   right_rear = voice[v].rr_mix;
  696.   lfe = voice[v].lfe_mix;
  698.   ri=-(right/c);
  699.   while (c--)
  700.     {
  701.       left_rear += li; if (left_rear<0) left_rear=0;
  702.       left += li; if (left<0) left=0;
  703.       center += li; if (center<0) center=0;
  704.       right += ri; if (right<0) right=0;
  705.       right_rear += ri; if (right_rear<0) right_rear=0;
  706.       lfe += li; if (lfe<0) lfe=0;
  707.       s=*sp++;
  708.        MIXATION(left);
  709.        MIXATION(right);
  710. if (num_ochannels >= 4) {
  711. MIXATION(left_rear);
  712. MIXATION(right_rear);
  713. }
  714. if (num_ochannels == 6) {
  715. MIXATION(center);
  716. MIXATION(lfe);
  717. }
  718.     }
  719. }
  720.       else if (voice[v].panned==PANNED_CENTER)
  721. {
  722.   while (c--)
  723.     {
  724.       left += li;
  725.       if (left<0)
  726. return;
  727.       s=*sp++;
  728. if (num_ochannels == 2) {
  729.        MIXATION(left);
  730.        MIXATION(left);
  731. }
  732. else if (num_ochannels == 4) {
  733. MIXATION(left);
  734.        MIXATION(left);
  735. MIXSKIP;
  736. MIXSKIP;
  737. }
  738. else if (num_ochannels == 6) {
  739. MIXSKIP;
  740. MIXSKIP;
  741. MIXSKIP;
  742. MIXSKIP;
  743.        MIXATION(left);
  744.        MIXATION(left);
  745. }
  746.     }
  747. }
  748.       else if (voice[v].panned==PANNED_LEFT)
  749. {
  750.   while (c--)
  751.     {
  752.       left += li;
  753.       if (left<0)
  754. return;
  755.       s=*sp++;
  756.       MIXATION(left);
  757.       MIXSKIP;
  758. if (num_ochannels >= 4) {
  759. MIXATION(left);
  760.        MIXSKIP;
  761. } if (num_ochannels == 6) {
  762. MIXATION(left);
  763. MIXATION(left);
  764. }
  765.     }
  766. }
  767.       else if (voice[v].panned==PANNED_RIGHT)
  768. {
  769.   while (c--)
  770.     {
  771.       left += li;
  772.       if (left<0)
  773. return;
  774.       s=*sp++;
  775.       MIXSKIP;
  776.       MIXATION(left);
  777. if (num_ochannels >= 4) {
  778.        MIXSKIP;
  779. MIXATION(left);
  780. } if (num_ochannels == 6) {
  781. MIXATION(left);
  782. MIXATION(left);
  783. }
  784.     }
  785. }
  786.     }
  787.   else
  788.     {
  789.       /* Mono output.  */
  790.       while (c--)
  791. {
  792.   left += li;
  793.   if (left<0)
  794.     return;
  795.   s=*sp++;
  796.   MIXATION(left);
  797. }
  798.     }
  799. }
  802. /**************** interface function ******************/
  804. void mix_voice(int32 *buf, int v, int32 c)
  805. {
  806.   Voice *vp=voice+v;
  807.   int32 count=c;
  808.   resample_t *sp;
  809.   if (c<0) return;
  810.   if (vp->status==VOICE_DIE)
  811.     {
  812.       if (count>=MAX_DIE_TIME)
  813. count=MAX_DIE_TIME;
  814.       sp=resample_voice(v, &count);
  815.       ramp_out(sp, buf, v, count);
  816.       vp->status=VOICE_FREE;
  817.     }
  818.   else
  819.     {
  820.       sp=resample_voice(v, &count);
  821.       if (count<0) return;
  822.       if (play_mode->encoding & PE_MONO)
  823. {
  824.   /* Mono output. */
  825.   if (vp->envelope_increment || vp->tremolo_phase_increment)
  826.     mix_mono_signal(sp, buf, v, count);
  827.   else
  828.     mix_mono(sp, buf, v, count);
  829. }
  830.       else
  831. {
  832.   if (vp->panned == PANNED_MYSTERY)
  833.     {
  834.       if (vp->envelope_increment || vp->tremolo_phase_increment)
  835. mix_mystery_signal(sp, buf, v, count);
  836.       else
  837. mix_mystery(sp, buf, v, count);
  838.     }
  839.   else if (vp->panned == PANNED_CENTER)
  840.     {
  841.       if (vp->envelope_increment || vp->tremolo_phase_increment)
  842. mix_center_signal(sp, buf, v, count);
  843.       else
  844. mix_center(sp, buf, v, count);
  845.     }
  846.   else
  847.     { 
  848.       /* It's either full left or full right. In either case,
  849.  every other sample is 0. Just get the offset right: */
  850.       
  851.       if (vp->envelope_increment || vp->tremolo_phase_increment)
  852.       {
  853.         if (vp->panned == PANNED_RIGHT)
  854. mix_single_right_signal(sp, buf, v, count);
  855. else mix_single_left_signal(sp, buf, v, count);
  856.       }
  857.       else 
  858.       {
  859.         if (vp->panned == PANNED_RIGHT)
  860. mix_single_right(sp, buf, v, count);
  861. else mix_single_left(sp, buf, v, count);
  862.       }
  863.     }
  864. }
  865.     }
  866. }