home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 106 / EnigmaAmiga106CD.iso / software / sviluppo / ahisrc / device / addroutines_lofi.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-09-11  |  12.9 KB  |  653 lines

  1. /* $Id: addroutines_lofi.c,v 4.1 1999/09/11 22:56:51 lcs Exp $ */
  2.  
  3. /*
  4.      AHI - Hardware independent audio subsystem
  5.      Copyright (C) 1996-1999 Martin Blom <martin@blom.org>
  6.      
  7.      This library is free software; you can redistribute it and/or
  8.      modify it under the terms of the GNU Library General Public
  9.      License as published by the Free Software Foundation; either
  10.      version 2 of the License, or (at your option) any later version.
  11.      
  12.      This library 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 GNU
  15.      Library General Public License for more details.
  16.      
  17.      You should have received a copy of the GNU Library General Public
  18.      License along with this library; if not, write to the
  19.      Free Software Foundation, Inc., 59 Temple Place - Suite 330, Cambridge,
  20.      MA 02139, USA.
  21. */
  22.  
  23. #include <config.h>
  24. #include <CompilerSpecific.h>
  25. #include "addroutines.h"
  26.  
  27. /******************************************************************************
  28. ** Add-Routines ***************************************************************
  29. ******************************************************************************/
  30.  
  31. /* Forward mixing code */
  32.  
  33. #define offseti ( (long) ( offset >> 32 ) )
  34.  
  35. LONG
  36. AddLofiByteMono( ADDARGS )
  37. {
  38.   BYTE    *src    = Src;
  39.   WORD    *dst    = *Dst;
  40.   Fixed64  offset = *Offset;
  41.   int      i;
  42.   LONG     lastpoint, sample;
  43.  
  44.   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
  45.  
  46.   for( i = 0; i < Samples; i++)
  47.   {
  48.     sample = src[ offseti ] << 8;
  49.  
  50.     if( StopAtZero &&
  51.         ( ( lastpoint < 0 && sample >= 0 ) ||
  52.           ( lastpoint > 0 && sample <= 0 ) ) )
  53.     {
  54.       break;
  55.     }
  56.  
  57.     lastpoint = sample;
  58.  
  59.     *dst++ += ( ScaleLeft * sample ) >> 16;
  60.  
  61.     offset += Add;
  62.   }
  63.  
  64.   *Dst    = dst;
  65.   *Offset = offset;
  66.  
  67.   return i;
  68. }
  69.  
  70.  
  71. LONG
  72. AddLofiByteStereo( ADDARGS )
  73. {
  74.   BYTE    *src    = Src;
  75.   WORD    *dst    = *Dst;
  76.   Fixed64  offset = *Offset;
  77.   int      i;
  78.   LONG     lastpoint, sample;
  79.  
  80.   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
  81.   
  82.   for( i = 0; i < Samples; i++)
  83.   {
  84.     sample = src[ offseti ] << 8;
  85.  
  86.     if( StopAtZero &&
  87.         ( ( lastpoint < 0 && sample >= 0 ) ||
  88.           ( lastpoint > 0 && sample <= 0 ) ) )
  89.     {
  90.       break;
  91.     }
  92.  
  93.     lastpoint = sample;
  94.  
  95.     *dst++ += ( ScaleLeft * sample ) >> 16;
  96.     *dst++ += ( ScaleRight * sample ) >> 16;
  97.  
  98.     offset += Add;
  99.   }
  100.  
  101.   *Dst    = dst;
  102.   *Offset = offset;
  103.  
  104.   return i;
  105. }
  106.  
  107.  
  108. LONG
  109. AddLofiBytesMono( ADDARGS )
  110. {
  111.   BYTE    *src    = Src;
  112.   WORD    *dst    = *Dst;
  113.   Fixed64  offset = *Offset;
  114.   int      i;
  115.   LONG     lastpointL, lastpointR, sampleL, sampleR;
  116.  
  117.   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
  118.  
  119.   for( i = 0; i < Samples; i++)
  120.   {
  121.     sampleL = src[ offseti * 2 + 0 ] << 8;
  122.     sampleR = src[ offseti * 2 + 1 ] << 8;
  123.  
  124.     if( StopAtZero &&
  125.         ( ( lastpointL < 0 && sampleL >= 0 ) ||
  126.           ( lastpointR < 0 && sampleR >= 0 ) ||
  127.           ( lastpointL > 0 && sampleL <= 0 ) ||
  128.           ( lastpointR > 0 && sampleR <= 0 ) ) )
  129.     {
  130.       break;
  131.     }
  132.  
  133.     lastpointL = sampleL;
  134.     lastpointR = sampleR;
  135.  
  136.     *dst++ += ( ScaleLeft * sampleL + ScaleRight * sampleR ) >> 16;
  137.  
  138.     offset += Add;
  139.   }
  140.  
  141.   *Dst    = dst;
  142.   *Offset = offset;
  143.  
  144.   return i;
  145. }
  146.  
  147.  
  148. LONG
  149. AddLofiBytesStereo( ADDARGS )
  150. {
  151.   BYTE    *src    = Src;
  152.   WORD    *dst    = *Dst;
  153.   Fixed64  offset = *Offset;
  154.   int      i;
  155.   LONG     lastpointL, lastpointR, sampleL, sampleR;
  156.  
  157.   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
  158.  
  159.   for( i = 0; i < Samples; i++)
  160.   {
  161.     sampleL = src[ offseti * 2 + 0 ] << 8;
  162.     sampleR = src[ offseti * 2 + 1 ] << 8;
  163.  
  164.     if( StopAtZero &&
  165.         ( ( lastpointL < 0 && sampleL >= 0 ) ||
  166.           ( lastpointR < 0 && sampleR >= 0 ) ||
  167.           ( lastpointL > 0 && sampleL <= 0 ) ||
  168.           ( lastpointR > 0 && sampleR <= 0 ) ) )
  169.     {
  170.       break;
  171.     }
  172.  
  173.     lastpointL = sampleL;
  174.     lastpointR = sampleR;
  175.  
  176.     *dst++ += ( ScaleLeft * sampleL ) >> 16;
  177.     *dst++ += ( ScaleRight * sampleR ) >> 16;
  178.  
  179.     offset += Add;
  180.   }
  181.  
  182.   *Dst    = dst;
  183.   *Offset = offset;
  184.  
  185.   return i;
  186. }
  187.  
  188.  
  189. LONG
  190. AddLofiWordMono( ADDARGS )
  191. {
  192.   WORD    *src    = Src;
  193.   WORD    *dst    = *Dst;
  194.   Fixed64  offset = *Offset;
  195.   int      i;
  196.   LONG     lastpoint, sample;
  197.  
  198.   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
  199.  
  200.   for( i = 0; i < Samples; i++)
  201.   {
  202.     sample = src[ offseti ];
  203.  
  204.     if( StopAtZero &&
  205.         ( ( lastpoint < 0 && sample >= 0 ) ||
  206.           ( lastpoint > 0 && sample <= 0 ) ) )
  207.     {
  208.       break;
  209.     }
  210.  
  211.     lastpoint = sample;
  212.  
  213.     *dst++ += ( ScaleLeft * sample ) >> 16;
  214.  
  215.     offset += Add;
  216.   }
  217.  
  218.   *Dst    = dst;
  219.   *Offset = offset;
  220.  
  221.   return i;
  222. }
  223.  
  224.  
  225. LONG
  226. AddLofiWordStereo( ADDARGS )
  227. {
  228.   WORD    *src    = Src;
  229.   WORD    *dst    = *Dst;
  230.   Fixed64  offset = *Offset;
  231.   int      i;
  232.   LONG     lastpoint, sample;
  233.  
  234.   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
  235.   
  236.   for( i = 0; i < Samples; i++)
  237.   {
  238.     sample = src[ offseti ];
  239.  
  240.     if( StopAtZero &&
  241.         ( ( lastpoint < 0 && sample >= 0 ) ||
  242.           ( lastpoint > 0 && sample <= 0 ) ) )
  243.     {
  244.       break;
  245.     }
  246.  
  247.     lastpoint = sample;
  248.  
  249.     *dst++ += ( ScaleLeft * sample ) >> 16;
  250.     *dst++ += ( ScaleRight * sample ) >> 16;
  251.  
  252.     offset += Add;
  253.   }
  254.  
  255.   *Dst    = dst;
  256.   *Offset = offset;
  257.  
  258.   return i;
  259. }
  260.  
  261. LONG
  262. AddLofiWordsMono( ADDARGS )
  263. {
  264.   WORD    *src    = Src;
  265.   WORD    *dst    = *Dst;
  266.   Fixed64  offset = *Offset;
  267.   int      i;
  268.   LONG     lastpointL, lastpointR, sampleL, sampleR;
  269.  
  270.   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
  271.  
  272.   for( i = 0; i < Samples; i++)
  273.   {
  274.     sampleL = src[ offseti * 2 + 0 ];
  275.     sampleR = src[ offseti * 2 + 1 ];
  276.  
  277.     if( StopAtZero &&
  278.         ( ( lastpointL < 0 && sampleL >= 0 ) ||
  279.           ( lastpointR < 0 && sampleR >= 0 ) ||
  280.           ( lastpointL > 0 && sampleL <= 0 ) ||
  281.           ( lastpointR > 0 && sampleR <= 0 ) ) )
  282.     {
  283.       break;
  284.     }
  285.  
  286.     lastpointL = sampleL;
  287.     lastpointR = sampleR;
  288.  
  289.     *dst++ += ( ScaleLeft * sampleL + ScaleRight * sampleR ) >> 16;
  290.  
  291.     offset += Add;
  292.   }
  293.  
  294.   *Dst    = dst;
  295.   *Offset = offset;
  296.  
  297.   return i;
  298. }
  299.  
  300.  
  301. LONG
  302. AddLofiWordsStereo( ADDARGS )
  303. {
  304.   WORD    *src    = Src;
  305.   WORD    *dst    = *Dst;
  306.   Fixed64  offset = *Offset;
  307.   int      i;
  308.   LONG     lastpointL, lastpointR, sampleL, sampleR;
  309.  
  310.   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
  311.  
  312.   for( i = 0; i < Samples; i++)
  313.   {
  314.     sampleL = src[ offseti * 2 + 0 ];
  315.     sampleR = src[ offseti * 2 + 1 ];
  316.  
  317.     if( StopAtZero &&
  318.         ( ( lastpointL < 0 && sampleL >= 0 ) ||
  319.           ( lastpointR < 0 && sampleR >= 0 ) ||
  320.           ( lastpointL > 0 && sampleL <= 0 ) ||
  321.           ( lastpointR > 0 && sampleR <= 0 ) ) )
  322.     {
  323.       break;
  324.     }
  325.  
  326.     lastpointL = sampleL;
  327.     lastpointR = sampleR;
  328.  
  329.     *dst++ += ( ScaleLeft * sampleL ) >> 16;
  330.     *dst++ += ( ScaleRight * sampleR ) >> 16;
  331.  
  332.     offset += Add;
  333.   }
  334.  
  335.   *Dst    = dst;
  336.   *Offset = offset;
  337.  
  338.   return i;
  339. }
  340.  
  341. /*****************************************************************************/
  342.  
  343. /* Backward mixing code */
  344.  
  345. LONG
  346. AddLofiByteMonoB( ADDARGS )
  347. {
  348.   BYTE    *src    = Src;
  349.   WORD    *dst    = *Dst;
  350.   Fixed64  offset = *Offset;
  351.   int      i;
  352.   LONG     lastpoint, sample;
  353.  
  354.   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
  355.  
  356.   for( i = 0; i < Samples; i++)
  357.   {
  358.     sample = src[ offseti ] << 8;
  359.  
  360.     if( StopAtZero &&
  361.         ( ( lastpoint < 0 && sample >= 0 ) ||
  362.           ( lastpoint > 0 && sample <= 0 ) ) )
  363.     {
  364.       break;
  365.     }
  366.  
  367.     lastpoint = sample;
  368.  
  369.     *dst++ += ( ScaleLeft * sample ) >> 16;
  370.  
  371.     offset -= Add;
  372.   }
  373.  
  374.   *Dst    = dst;
  375.   *Offset = offset;
  376.  
  377.   return i;
  378. }
  379.  
  380.  
  381. LONG
  382. AddLofiByteStereoB( ADDARGS )
  383. {
  384.   BYTE    *src    = Src;
  385.   WORD    *dst    = *Dst;
  386.   Fixed64  offset = *Offset;
  387.   int      i;
  388.   LONG     lastpoint, sample;
  389.  
  390.   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
  391.   
  392.   for( i = 0; i < Samples; i++)
  393.   {
  394.     sample = src[ offseti ] << 8;
  395.  
  396.     if( StopAtZero &&
  397.         ( ( lastpoint < 0 && sample >= 0 ) ||
  398.           ( lastpoint > 0 && sample <= 0 ) ) )
  399.     {
  400.       break;
  401.     }
  402.  
  403.     lastpoint = sample;
  404.  
  405.     *dst++ += ( ScaleLeft * sample ) >> 16;
  406.     *dst++ += ( ScaleRight * sample ) >> 16;
  407.  
  408.     offset -= Add;
  409.   }
  410.  
  411.   *Dst    = dst;
  412.   *Offset = offset;
  413.  
  414.   return i;
  415. }
  416.  
  417.  
  418. LONG
  419. AddLofiBytesMonoB( ADDARGS )
  420. {
  421.   BYTE    *src    = Src;
  422.   WORD    *dst    = *Dst;
  423.   Fixed64  offset = *Offset;
  424.   int      i;
  425.   LONG     lastpointL, lastpointR, sampleL, sampleR;
  426.  
  427.   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
  428.  
  429.   for( i = 0; i < Samples; i++)
  430.   {
  431.     sampleL = src[ offseti * 2 + 0 ] << 8;
  432.     sampleR = src[ offseti * 2 + 1 ] << 8;
  433.  
  434.     if( StopAtZero &&
  435.         ( ( lastpointL < 0 && sampleL >= 0 ) ||
  436.           ( lastpointR < 0 && sampleR >= 0 ) ||
  437.           ( lastpointL > 0 && sampleL <= 0 ) ||
  438.           ( lastpointR > 0 && sampleR <= 0 ) ) )
  439.     {
  440.       break;
  441.     }
  442.  
  443.     lastpointL = sampleL;
  444.     lastpointR = sampleR;
  445.  
  446.     *dst++ += ( ScaleLeft * sampleL + ScaleRight * sampleR ) >> 16;
  447.  
  448.     offset -= Add;
  449.   }
  450.  
  451.   *Dst    = dst;
  452.   *Offset = offset;
  453.  
  454.   return i;
  455. }
  456.  
  457.  
  458. LONG
  459. AddLofiBytesStereoB( ADDARGS )
  460. {
  461.   BYTE    *src    = Src;
  462.   WORD    *dst    = *Dst;
  463.   Fixed64  offset = *Offset;
  464.   int      i;
  465.   LONG     lastpointL, lastpointR, sampleL, sampleR;
  466.  
  467.   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
  468.  
  469.   for( i = 0; i < Samples; i++)
  470.   {
  471.     sampleL = src[ offseti * 2 + 0 ] << 8;
  472.     sampleR = src[ offseti * 2 + 1 ] << 8;
  473.  
  474.     if( StopAtZero &&
  475.         ( ( lastpointL < 0 && sampleL >= 0 ) ||
  476.           ( lastpointR < 0 && sampleR >= 0 ) ||
  477.           ( lastpointL > 0 && sampleL <= 0 ) ||
  478.           ( lastpointR > 0 && sampleR <= 0 ) ) )
  479.     {
  480.       break;
  481.     }
  482.  
  483.     lastpointL = sampleL;
  484.     lastpointR = sampleR;
  485.  
  486.     *dst++ += ( ScaleLeft * sampleL ) >> 16;
  487.     *dst++ += ( ScaleRight * sampleR ) >> 16;
  488.  
  489.     offset -= Add;
  490.   }
  491.  
  492.   *Dst    = dst;
  493.   *Offset = offset;
  494.  
  495.   return i;
  496. }
  497.  
  498.  
  499. LONG
  500. AddLofiWordMonoB( ADDARGS )
  501. {
  502.   WORD    *src    = Src;
  503.   WORD    *dst    = *Dst;
  504.   Fixed64  offset = *Offset;
  505.   int      i;
  506.   LONG     lastpoint, sample;
  507.  
  508.   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
  509.  
  510.   for( i = 0; i < Samples; i++)
  511.   {
  512.     sample = src[ offseti ];
  513.  
  514.     if( StopAtZero &&
  515.         ( ( lastpoint < 0 && sample >= 0 ) ||
  516.           ( lastpoint > 0 && sample <= 0 ) ) )
  517.     {
  518.       break;
  519.     }
  520.  
  521.     lastpoint = sample;
  522.  
  523.     *dst++ += ( ScaleLeft * sample ) >> 16;
  524.  
  525.     offset -= Add;
  526.   }
  527.  
  528.   *Dst    = dst;
  529.   *Offset = offset;
  530.  
  531.   return i;
  532. }
  533.  
  534.  
  535. LONG
  536. AddLofiWordStereoB( ADDARGS )
  537. {
  538.   WORD    *src    = Src;
  539.   WORD    *dst    = *Dst;
  540.   Fixed64  offset = *Offset;
  541.   int      i;
  542.   LONG     lastpoint, sample;
  543.  
  544.   lastpoint = 0;                      // 0 doesn't affect the StopAtZero code
  545.   
  546.   for( i = 0; i < Samples; i++)
  547.   {
  548.     sample = src[ offseti ];
  549.  
  550.     if( StopAtZero &&
  551.         ( ( lastpoint < 0 && sample >= 0 ) ||
  552.           ( lastpoint > 0 && sample <= 0 ) ) )
  553.     {
  554.       break;
  555.     }
  556.  
  557.     lastpoint = sample;
  558.  
  559.     *dst++ += ( ScaleLeft * sample ) >> 16;
  560.     *dst++ += ( ScaleRight * sample ) >> 16;
  561.  
  562.     offset -= Add;
  563.   }
  564.  
  565.   *Dst    = dst;
  566.   *Offset = offset;
  567.  
  568.   return i;
  569. }
  570.  
  571.  
  572. LONG
  573. AddLofiWordsMonoB( ADDARGS )
  574. {
  575.   WORD    *src    = Src;
  576.   WORD    *dst    = *Dst;
  577.   Fixed64  offset = *Offset;
  578.   int      i;
  579.   LONG     lastpointL, lastpointR, sampleL, sampleR;
  580.  
  581.   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
  582.  
  583.   for( i = 0; i < Samples; i++)
  584.   {
  585.     sampleL = src[ offseti * 2 + 0 ];
  586.     sampleR = src[ offseti * 2 + 1 ];
  587.  
  588.     if( StopAtZero &&
  589.         ( ( lastpointL < 0 && sampleL >= 0 ) ||
  590.           ( lastpointR < 0 && sampleR >= 0 ) ||
  591.           ( lastpointL > 0 && sampleL <= 0 ) ||
  592.           ( lastpointR > 0 && sampleR <= 0 ) ) )
  593.     {
  594.       break;
  595.     }
  596.  
  597.     lastpointL = sampleL;
  598.     lastpointR = sampleR;
  599.  
  600.     *dst++ += ( ScaleLeft * sampleL + ScaleRight * sampleR ) >> 16;
  601.  
  602.     offset -= Add;
  603.   }
  604.  
  605.   *Dst    = dst;
  606.   *Offset = offset;
  607.  
  608.   return i;
  609. }
  610.  
  611.  
  612. LONG
  613. AddLofiWordsStereoB( ADDARGS )
  614. {
  615.   WORD    *src    = Src;
  616.   WORD    *dst    = *Dst;
  617.   Fixed64  offset = *Offset;
  618.   int      i;
  619.   LONG     lastpointL, lastpointR, sampleL, sampleR;
  620.  
  621.   lastpointL = lastpointR = 0;        // 0 doesn't affect the StopAtZero code
  622.  
  623.   for( i = 0; i < Samples; i++)
  624.   {
  625.     sampleL = src[ offseti * 2 + 0 ];
  626.     sampleR = src[ offseti * 2 + 1 ];
  627.  
  628.     if( StopAtZero &&
  629.         ( ( lastpointL < 0 && sampleL >= 0 ) ||
  630.           ( lastpointR < 0 && sampleR >= 0 ) ||
  631.           ( lastpointL > 0 && sampleL <= 0 ) ||
  632.           ( lastpointR > 0 && sampleR <= 0 ) ) )
  633.     {
  634.       break;
  635.     }
  636.  
  637.     lastpointL = sampleL;
  638.     lastpointR = sampleR;
  639.  
  640.     *dst++ += ( ScaleLeft * sampleL ) >> 16;
  641.     *dst++ += ( ScaleRight * sampleR ) >> 16;
  642.  
  643.     offset -= Add;
  644.   }
  645.  
  646.   *Dst    = dst;
  647.   *Offset = offset;
  648.  
  649.   return i;
  650. }
  651.  
  652. /*****************************************************************************/
  653.