VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
976 Commits
4 Branches
540MB
Tree: dd8f761dbf
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'dd8f761dbf'
${ noResults }
Rack/plugins/community/repos/AudibleInstruments/eurorack/avrlib/op.h

748 lines
19KB
Raw Blame History 

  1. // Copyright 2009 Olivier Gillet.

  2. //

  3. // Author: Olivier Gillet (ol.gillet@gmail.com)

  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. // This program is distributed in the hope that it will be useful,

  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of

  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  12. // GNU General Public License for more details.

  13. // You should have received a copy of the GNU General Public License

  14. // along with this program.  If not, see <http://www.gnu.org/licenses/>.

  15. //

  16. // -----------------------------------------------------------------------------

  17. //

  18. // A set of basic operands, especially useful for fixed-point arithmetic, with

  19. // fast ASM implementations.

  20. 

  21. #ifndef AVRLIB_OP_H_

  22. #define AVRLIB_OP_H_

  23. 

  24. #define USE_OPTIMIZED_OP

  25. 

  26. #include <avr/pgmspace.h>

  27. 

  28. #include "avrlib/base.h"

  29. 

  30. namespace avrlib {

  31. 

  32. static inline int16_t Clip(int16_t value, int16_t min, int16_t max) {

  33.   return value < min ? min : (value > max ? max : value);

  34. }

  35. 

  36. static inline int16_t S16ClipU14(int16_t value) {

  37.   uint8_t msb = static_cast<uint16_t>(value) >> 8;

  38.   if (msb & 0x80) {

  39.     return 0;

  40.   } if (msb & 0x40) {

  41.     return 16383;

  42.   }

  43.   return value;

  44. }

  45. 

  46. static inline uint8_t U8AddClip(uint8_t value, uint8_t increment, uint8_t max) {

  47.   value += increment;

  48.   if (value > max) {

  49.     value = max;

  50.   }

  51.   return value;

  52. }

  53. 

  54. // Correct only if the input is positive.

  55. static inline uint8_t S16ShiftRight8(int16_t value) {

  56.   return static_cast<uint16_t>(value) >> 8;

  57. }

  58. 

  59. #ifdef USE_OPTIMIZED_OP

  60. 

  61. static inline uint24c_t U24AddC(uint24c_t a, uint24_t b) {

  62.   uint16_t a_int = a.integral;

  63.   uint16_t b_int = b.integral;

  64.   uint8_t a_frac = a.fractional;

  65.   uint8_t b_frac = b.fractional;

  66.   uint8_t a_carry = 0;

  67.   uint24c_t result;

  68.   asm(

  69.     "add %0, %6"      "\n\t"

  70.     "adc %A1, %A7"    "\n\t"

  71.     "adc %B1, %B7"    "\n\t"

  72.     "adc %2, r1"      "\n\t"

  73.     : "=r" (a_frac), "=r" (a_int), "=r" (a_carry)

  74.     : "0" (a_frac), "1" (a_int), "2" (a_carry), "a" (b_frac), "a" (b_int)

  75.   );

  76.   result.integral = a_int;

  77.   result.fractional = a_frac;

  78.   result.carry = a_carry;

  79.   return result;

  80. }

  81. 

  82. static inline uint24_t U24Add(uint24_t a, uint24_t b) {

  83.   uint16_t a_int = a.integral;

  84.   uint16_t b_int = b.integral;

  85.   uint8_t a_frac = a.fractional;

  86.   uint8_t b_frac = b.fractional;

  87.   uint24_t result;

  88.   asm(

  89.     "add %0, %4"      "\n\t"

  90.     "adc %A1, %A5"    "\n\t"

  91.     "adc %B1, %B5"    "\n\t"

  92.     : "=r" (a_frac), "=r" (a_int)

  93.     : "0" (a_frac), "1" (a_int), "a" (b_frac), "a" (b_int)

  94.   );

  95.   result.integral = a_int;

  96.   result.fractional = a_frac;

  97.   return result;

  98. }

  99. 

  100. static inline uint24_t U24Sub(uint24_t a, uint24_t b) {

  101.   uint16_t a_int = a.integral;

  102.   uint16_t b_int = b.integral;

  103.   uint8_t a_frac = a.fractional;

  104.   uint8_t b_frac = b.fractional;

  105.   uint24_t result;

  106.   asm(

  107.     "sub %0, %4"      "\n\t"

  108.     "sbc %A1, %A5"    "\n\t"

  109.     "sbc %B1, %B5"    "\n\t"

  110.     : "=r" (a_frac), "=r" (a_int)

  111.     : "0" (a_frac), "1" (a_int), "a" (b_frac), "a" (b_int)

  112.   );

  113.   result.integral = a_int;

  114.   result.fractional = a_frac;

  115.   return result;

  116. }

  117. 

  118. static inline uint24_t U24ShiftRight(uint24_t a) {

  119.   uint16_t a_int = a.integral;

  120.   uint8_t a_frac = a.fractional;

  121.   uint24_t result;

  122.   asm(

  123.     "lsr %B1"      "\n\t"

  124.     "ror %A1"    "\n\t"

  125.     "ror %0"    "\n\t"

  126.     : "=r" (a_frac), "=r" (a_int)

  127.     : "0" (a_frac), "1" (a_int)

  128.   );

  129.   result.integral = a_int;

  130.   result.fractional = a_frac;

  131.   return result;

  132. }

  133. 

  134. static inline uint24_t U24ShiftLeft(uint24_t a) {

  135.   uint16_t a_int = a.integral;

  136.   uint8_t a_frac = a.fractional;

  137.   uint24_t result;

  138.   asm(

  139.     "lsl %0"    "\n\t"

  140.     "rol %A1"    "\n\t"

  141.     "rol %B1"      "\n\t"

  142.     : "=r" (a_frac), "=r" (a_int)

  143.     : "0" (a_frac), "1" (a_int)

  144.   );

  145.   result.integral = a_int;

  146.   result.fractional = a_frac;

  147.   return result;

  148. }

  149. 

  150. static inline uint8_t S16ClipU8(int16_t value) {

  151.   uint8_t result;

  152.   asm(

  153.     "mov %0, %A1"   "\n\t"  // by default, copy the value.

  154.     "or %B1, %B1"   "\n\t"  // load H to set flags.

  155.     "brpl .+4"      "\n\t"  // if positive, skip

  156.     "ldi %0, 0"     "\n\t"  // set to 0.

  157.     "rjmp .+4"      "\n\t"  // and jump.

  158.     "breq .+2"      "\n\t"  // if null, skip

  159.     "ldi %0, 255"   "\n\t"  // set to 255

  160.     : "=r" (result)

  161.     : "a" (value)

  162.   );

  163.   return result;

  164. }

  165. 

  166. static inline int8_t S16ClipS8(int16_t value) {

  167.   return S16ClipU8(value + 128) + 128;

  168. }

  169. 

  170. static inline uint8_t U8Mix(uint8_t a, uint8_t b, uint8_t balance) {

  171.   Word sum;

  172.   asm(

  173.     "mul %3, %2"      "\n\t"  // b * balance

  174.     "movw %A0, r0"    "\n\t"  // to sum

  175.     "com %2"          "\n\t"  // 255 - balance

  176.     "mul %1, %2"      "\n\t"  // a * (255 - balance)

  177.     "com %2"          "\n\t"  // reset balance to its previous value

  178.     "add %A0, r0"     "\n\t"  // add to sum L

  179.     "adc %B0, r1"     "\n\t"  // add to sum H

  180.     "eor r1, r1"      "\n\t"  // reset r1 after multiplication

  181.     : "&=r" (sum)

  182.     : "a" (a), "a" (balance), "a" (b)

  183.     );

  184.   return sum.bytes[1];

  185. }

  186. 

  187. static inline uint8_t U8Mix(

  188.     uint8_t a, uint8_t b,

  189.     uint8_t gain_a, uint8_t gain_b) {

  190.   Word sum;

  191.   asm(

  192.     "mul %3, %4"      "\n\t"  // b * gain_b

  193.     "movw %A0, r0"    "\n\t"  // to sum

  194.     "mul %1, %2"      "\n\t"  // a * gain_a

  195.     "add %A0, r0"     "\n\t"  // add to sum L

  196.     "adc %B0, r1"     "\n\t"  // add to sum H

  197.     "eor r1, r1"      "\n\t"  // reset r1 after multiplication

  198.     : "&=r" (sum)

  199.     : "a" (a), "a" (gain_a), "a" (b), "a" (gain_b)

  200.     );

  201.   return sum.bytes[1];

  202. }

  203. 

  204. static inline int8_t S8Mix(

  205.     int8_t a, int8_t b,

  206.     uint8_t gain_a, uint8_t gain_b) {

  207.   Word sum;

  208.   asm(

  209.     "mulsu %3, %4"    "\n\t"  // b * gain_b

  210.     "movw %A0, r0"    "\n\t"  // to sum

  211.     "mulsu %1, %2"    "\n\t"  // a * gain_a

  212.     "add %A0, r0"     "\n\t"  // add to sum L

  213.     "adc %B0, r1"     "\n\t"  // add to sum H

  214.     "eor r1, r1"      "\n\t"  // reset r1 after multiplication

  215.     : "&=r" (sum)

  216.     : "a" (a), "a" (gain_a), "a" (b), "a" (gain_b)

  217.     );

  218.   return sum.bytes[1];

  219. }

  220. 

  221. static inline uint16_t U8MixU16(uint8_t a, uint8_t b, uint8_t balance) {

  222.   Word sum;

  223.   asm(

  224.     "mul %3, %2"      "\n\t"  // b * balance

  225.     "movw %A0, r0"    "\n\t"  // to sum

  226.     "com %2"          "\n\t"  // 255 - balance

  227.     "mul %1, %2"      "\n\t"  // a * (255 - balance)

  228.     "com %2"          "\n\t"  // reset balance to its previous value

  229.     "add %A0, r0"     "\n\t"  // add to sum L

  230.     "adc %B0, r1"     "\n\t"  // add to sum H

  231.     "eor r1, r1"      "\n\t"  // reset r1 after multiplication

  232.     : "&=r" (sum)

  233.     : "a" (a), "a" (balance), "a" (b)

  234.     );

  235.   return sum.value;

  236. }

  237. 

  238. static inline uint8_t U8U4MixU8(uint8_t a, uint8_t b, uint8_t balance) {

  239.   uint16_t sum;

  240.   asm(

  241.     "mul %2, %1"      "\n\t"  // b * balance

  242.     "movw %A3, r0"    "\n\t"  // to sum

  243.     "com %1"          "\n\t"  // 255 - balance

  244.     "subi %1, 240"    "\n\t"  // 15 - balance

  245.     "mul %0, %1"      "\n\t"  // a * (15 - balance)

  246.     "subi %1, 16"     "\n\t"

  247.     "com %1"          "\n\t"  // reset balance to its previous value

  248.     "add %A3, r0"     "\n\t"  // add to sum L

  249.     "adc %B3, r1"     "\n\t"  // add to sum H

  250.     "eor r1, r1"      "\n\t"  // reset r1 after multiplication

  251.     "andi %B3, 15"    "\n\t"  // keep 4 lowest bits of H

  252.     "andi %A3, 240"   "\n\t"  // keep 4 highest bits of L 

  253.     "or %B3, %A3"     "\n\t"  // copy 4 high bits of L to H -> LLLLHHHH

  254.     "swap %B3"        "\n\t"  // swap to get HHHHLLLL

  255.     "mov %0, %B3"     "\n\t"  // move to output

  256.     : "=r" (a)

  257.     : "a" (balance), "a" (b), "a" (sum)

  258.     );

  259.   return a;

  260. }

  261. 

  262. static inline uint16_t U8U4MixU12(uint8_t a, uint8_t b, uint8_t balance) {

  263.   uint16_t sum;

  264.   asm(

  265.     "mul %3, %2"      "\n\t"  // b * balance

  266.     "movw %A0, r0"    "\n\t"  // to sum

  267.     "com %2"          "\n\t"  // 255 - balance

  268.     "subi %2, 240"    "\n\t"  // 15 - balance

  269.     "mul %1, %2"      "\n\t"  // a * (15 - balance)

  270.     "subi %2, 16"     "\n\t"

  271.     "com %2"          "\n\t"  // reset balance to its previous value

  272.     "add %A0, r0"     "\n\t"  // add to sum L

  273.     "adc %B0, r1"     "\n\t"  // add to sum H

  274.     "eor r1, r1"      "\n\t"  // reset r1 after multiplication

  275.     : "&=r" (sum)

  276.     : "a" (a), "a" (balance), "a" (b)

  277.     );

  278.   return sum;

  279. }

  280. 

  281. static inline uint8_t U8ShiftLeft4(uint8_t a) {

  282.   uint8_t result;

  283.   asm(

  284.     "mov %0, %1"      "\n\t"

  285.     "swap %0"         "\n\t"

  286.     "andi %0, 240"     "\n\t"

  287.     : "=r" (result)

  288.     : "a" (a)

  289.     );

  290.   return result;

  291. }

  292. 

  293. static inline uint8_t U8Swap4(uint8_t a) {

  294.   uint8_t result;

  295.   asm(

  296.     "mov %0, %1"      "\n\t"

  297.     "swap %0"         "\n\t"

  298.     : "=r" (result)

  299.     : "a" (a)

  300.     );

  301.   return result;

  302. }

  303. 

  304. static inline uint8_t U8ShiftRight4(uint8_t a) {

  305.   uint8_t result;

  306.   asm(

  307.     "mov %0, %1"      "\n\t"

  308.     "swap %0"         "\n\t"

  309.     "andi %0, 15"     "\n\t"

  310.     : "=r" (result)

  311.     : "a" (a)

  312.     );

  313.   return result;

  314. }

  315. 

  316. static inline uint16_t U16ShiftRight4(uint16_t a) {

  317.   uint16_t result;

  318.   asm(

  319.     "movw %A0, %A1" "\n\t"

  320.     "lsr %B0"      "\n\t"

  321.     "ror %A0"      "\n\t"

  322.     "lsr %B0"      "\n\t"

  323.     "ror %A0"      "\n\t"

  324.     "lsr %B0"      "\n\t"

  325.     "ror %A0"      "\n\t"

  326.     "lsr %B0"      "\n\t"

  327.     "ror %A0"      "\n\t"

  328.     : "=r" (result)

  329.     : "a" (a)

  330.     );

  331.   return result;

  332. }

  333. 

  334. 

  335. static inline uint8_t U8U8MulShift8(uint8_t a, uint8_t b) {

  336.   uint8_t result;

  337.   asm(

  338.     "mul %1, %2"      "\n\t"

  339.     "mov %0, r1"      "\n\t"

  340.     "eor r1, r1"      "\n\t"

  341.     : "=r" (result)

  342.     : "a" (a), "a" (b)

  343.   );

  344.   return result;

  345. }

  346. 

  347. static inline int8_t S8U8MulShift8(int8_t a, uint8_t b) {

  348.   uint8_t result;

  349.   asm(

  350.     "mulsu %1, %2"    "\n\t"

  351.     "mov %0, r1"      "\n\t"

  352.     "eor r1, r1"      "\n\t"

  353.     : "=r" (result)

  354.     : "a" (a), "a" (b)

  355.   );

  356.   return result;

  357. }

  358. 

  359. static inline int16_t S8U8Mul(int8_t a, uint8_t b) {

  360.   int16_t result;

  361.   asm(

  362.     "mulsu %1, %2"    "\n\t"

  363.     "movw %0, r0"      "\n\t"

  364.     "eor r1, r1"      "\n\t"

  365.     : "=r" (result)

  366.     : "a" (a), "a" (b)

  367.   );

  368.   return result;

  369. }

  370. 

  371. static inline int16_t S8S8Mul(int8_t a, int8_t b) {

  372.   int16_t result;

  373.   asm(

  374.     "muls %1, %2"    "\n\t"

  375.     "movw %0, r0"      "\n\t"

  376.     "eor r1, r1"      "\n\t"

  377.     : "=r" (result)

  378.     : "a" (a), "a" (b)

  379.   );

  380.   return result;

  381. }

  382. 

  383. static inline uint16_t U8U8Mul(uint8_t a, uint8_t b) {

  384.   uint16_t result;

  385.   asm(

  386.     "mul %1, %2"    "\n\t"

  387.     "movw %0, r0"      "\n\t"

  388.     "eor r1, r1"      "\n\t"

  389.     : "=r" (result)

  390.     : "a" (a), "a" (b)

  391.   );

  392.   return result;

  393. }

  394. 

  395. static inline int8_t S8S8MulShift8(int8_t a, int8_t b) {

  396.   uint8_t result;

  397.   asm(

  398.     "muls %1, %2"    "\n\t"

  399.     "mov %0, r1"      "\n\t"

  400.     "eor r1, r1"      "\n\t"

  401.     : "=r" (result)

  402.     : "a" (a), "a" (b)

  403.   );

  404.   return result;

  405. }

  406. 

  407. // The code generated by gcc for >> 6 is short but uses a loop. This saves

  408. // a couple of cycles. Note that this solution only works for operands with

  409. // a 14-bits resolution.

  410. static inline uint8_t U14ShiftRight6(uint16_t value) {

  411.   uint8_t b = value >> 8;

  412.   uint8_t a = value & 0xff;

  413.   uint8_t result;

  414.   asm(

  415.     "add %1, %1"       "\n\t"

  416.     "adc %2, %2"       "\n\t"

  417.     "add %1, %1"       "\n\t"

  418.     "adc %2, %2"       "\n\t"

  419.     : "=r" (result)

  420.     : "a" (a), "0" (b)

  421.   );

  422.   return result;

  423. }

  424. 

  425. static inline uint8_t U15ShiftRight7(uint16_t value) {

  426.   uint8_t b = value >> 8;

  427.   uint8_t a = value & 0xff;

  428.   uint8_t result;

  429.   asm(

  430.     "add %1, %1"       "\n\t"

  431.     "adc %2, %2"       "\n\t"

  432.     : "=r" (result)

  433.     : "a" (a), "0" (b)

  434.   );

  435.   return result;

  436. }

  437. 

  438. static inline int16_t S16U16MulShift16(int16_t a, uint16_t b) {

  439.   int16_t result;

  440.   int16_t tmp;

  441.   asm(

  442.     "eor %A1, %A1"    "\n\t"

  443.     "mul %A2, %A3"    "\n\t"

  444.     "mov %B1, r1"    "\n\t"

  445.     "mulsu %B2, %B3"  "\n\t"

  446.     "movw %A0, r0"    "\n\t"

  447.     "mul %B3, %A2"    "\n\t"

  448.     "add %B1, r0"     "\n\t"

  449.     "adc %A0, r1"     "\n\t"

  450.     "adc %B0, %A1"    "\n\t"

  451.     "mulsu %B2, %A3"  "\n\t"

  452.     "sbc %B0, %A1"    "\n\t"

  453.     "add %B1, r0"     "\n\t"

  454.     "adc %A0, r1"     "\n\t"

  455.     "adc %B0, %A1"    "\n\t"

  456.     "eor r1, r1"      "\n\t"

  457.     : "=&r" (result), "=&r" (tmp)

  458.     : "a" (a), "a" (b)

  459.   );

  460.   return result;

  461. }

  462. 

  463. static inline uint16_t U16U16MulShift16(uint16_t a, uint16_t b) {

  464.   uint16_t result;

  465.   uint16_t tmp;

  466.   asm(

  467.     "eor %A1, %A1"    "\n\t"

  468.     "mul %A2, %A3"    "\n\t"

  469.     "mov %B1, r1"     "\n\t"

  470.     "mul %B2, %B3"    "\n\t"

  471.     "movw %A0, r0"    "\n\t"

  472.     "mul %B3, %A2"    "\n\t"

  473.     "add %B1, r0"     "\n\t"

  474.     "adc %A0, r1"     "\n\t"

  475.     "adc %B0, %A1"    "\n\t"

  476.     "mul %B2, %A3"    "\n\t"

  477.     "add %B1, r0"     "\n\t"

  478.     "adc %A0, r1"     "\n\t"

  479.     "adc %B0, %A1"    "\n\t"

  480.     "eor r1, r1"      "\n\t"

  481.     : "=&r" (result), "=&r" (tmp)

  482.     : "a" (a), "a" (b)

  483.   );

  484.   return result;

  485. }

  486. 

  487. static inline int16_t S16U8MulShift8(int16_t a, uint8_t b) {

  488.   int16_t result;

  489.   asm(

  490.     "eor %B0, %B0"    "\n\t"

  491.     "mul %A1, %A2"    "\n\t"

  492.     "mov %A0, r1"     "\n\t"

  493.     "mulsu %B1, %A2"  "\n\t"

  494.     "add %A0, r0"     "\n\t"

  495.     "adc %B0, r1"     "\n\t"

  496.     "eor r1, r1"      "\n\t"

  497.     : "=&r" (result)

  498.     : "a" (a), "a" (b)

  499.   );

  500.   return result;

  501. }

  502. 

  503. static inline uint16_t U16U8MulShift8(uint16_t a, uint8_t b) {

  504.   uint16_t result;

  505.   asm(

  506.     "eor %B0, %B0"    "\n\t"

  507.     "mul %A1, %A2"    "\n\t"

  508.     "mov %A0, r1"     "\n\t"

  509.     "mul %B1, %A2"  "\n\t"

  510.     "add %A0, r0"     "\n\t"

  511.     "adc %B0, r1"     "\n\t"

  512.     "eor r1, r1"      "\n\t"

  513.     : "=&r" (result)

  514.     : "a" (a), "a" (b)

  515.   );

  516.   return result;

  517. }

  518. 

  519. static inline int16_t S16S8MulShift8(int16_t a, int8_t b) {

  520.   int16_t result;

  521.   asm(

  522.     "eor %B0, %B0"    "\n\t"

  523.     "muls %A2, %B1"   "\n\t"

  524.     "movw %A0, r0"    "\n\t"

  525.     "mulsu %A2, %A1"  "\n\t"

  526.     "eor r0, r0"      "\n\t"

  527.     "sbc %B0, r0"     "\n\t"

  528.     "add %A0, r1"     "\n\t"

  529.     "adc %B0, r0"     "\n\t"

  530.     "eor r1, r1"      "\n\t"

  531.     : "=&r" (result)

  532.     : "a" (a), "a" (b)

  533.   );

  534.   return result;

  535. }

  536. 

  537. static inline uint8_t InterpolateSample(

  538.     const prog_uint8_t* table,

  539.     uint16_t phase) __attribute__((always_inline));

  540. 

  541. static inline uint8_t InterpolateSample(

  542.     const prog_uint8_t* table,

  543.     uint16_t phase) {

  544.   uint8_t result;

  545.   uint8_t work;

  546.   asm(

  547.     "movw r30, %A2"           "\n\t"  // copy base address to r30:r31

  548.     "add r30, %B3"            "\n\t"  // increment table address by phaseH

  549.     "adc r31, r1"             "\n\t"  // just carry

  550.     "mov %1, %A3"             "\n\t"  // move phaseL to working register

  551.     "lpm %0, z+"              "\n\t"  // load sample[n]

  552.     "lpm r1, z+"              "\n\t"  // load sample[n+1]

  553.     "mul %1, r1"              "\n\t"  // multiply second sample by phaseL

  554.     "movw r30, r0"            "\n\t"  // result to accumulator

  555.     "com %1"                  "\n\t"  // 255 - phaseL -> phaseL

  556.     "mul %1, %0"              "\n\t"  // multiply first sample by phaseL

  557.     "add r30, r0"             "\n\t"  // accumulate L

  558.     "adc r31, r1"             "\n\t"  // accumulate H

  559.     "eor r1, r1"              "\n\t"  // reset r1 after multiplication

  560.     "mov %0, r31"             "\n\t"  // use sum H as output

  561.     : "=r" (result), "=r" (work)

  562.     : "r" (table), "r" (phase)

  563.     : "r30", "r31"

  564.   );

  565.   return result;

  566. }

  567. 

  568. #else

  569. 

  570. static inline uint24c_t U24AddC(uint24c_t a, uint24_t b) {

  571.   uint24c_t result;

  572.   

  573.   uint32_t av = static_cast<uint32_t>(a.integral) << 8;

  574.   av += a.fractional;

  575.   

  576.   uint32_t bv = static_cast<uint32_t>(b.integral) << 8;

  577.   bv += b.fractional;

  578.   

  579.   uint32_t sum = av + bv;

  580.   result.integral = sum >> 8;

  581.   result.fractional = sum & 0xff;

  582.   result.carry = (sum & 0xff000000) != 0;

  583.   return result;

  584. }

  585. 

  586. static inline uint24_t U24Add(uint24_t a, uint24_t b) {

  587.   uint24_t result;

  588.   

  589.   uint32_t av = static_cast<uint32_t>(a.integral) << 8;

  590.   av += a.fractional;

  591.   

  592.   uint32_t bv = static_cast<uint32_t>(b.integral) << 8;

  593.   bv += b.fractional;

  594.   

  595.   uint32_t sum = av + bv;

  596.   result.integral = sum >> 8;

  597.   result.fractional = sum & 0xff;

  598.   return result;

  599. }

  600. 

  601. static inline uint24_t U24Sub(uint24_t a, uint24_t b) {

  602.   uint24_t result;

  603.   

  604.   uint32_t av = static_cast<uint32_t>(a.integral) << 8;

  605.   av += a.fractional;

  606.   

  607.   uint32_t bv = static_cast<uint32_t>(b.integral) << 8;

  608.   bv += b.fractional;

  609.   

  610.   uint32_t difference = av - bv;

  611.   result.integral = sum >> 8;

  612.   result.fractional = sum & 0xff;

  613.   return result;

  614. }

  615. 

  616. static inline uint24_t U24ShiftRight(uint24_t a) {

  617.   uint24_t result;

  618.   uint32_t av = static_cast<uint32_t>(a.integral) << 8;

  619.   av += a.fractional;

  620.   av >>= 1;

  621.   result.integral = av >> 8;

  622.   result.fractional = av & 0xff;

  623.   return result;

  624. }

  625. 

  626. static inline uint24_t U24ShiftLeft(uint24_t a) {

  627.   uint24_t result;

  628.   uint32_t av = static_cast<uint32_t>(a.integral) << 8;

  629.   av += a.fractional;

  630.   av <<= 1;

  631.   result.integral = av >> 8;

  632.   result.fractional = av & 0xff;

  633.   return result;

  634. }

  635. 

  636. static inline uint8_t S16ClipU8(int16_t value) {

  637.   return value < 0 ? 0 : (value > 255 ? 255 : value);

  638. }

  639. 

  640. static inline int8_t S16ClipS8(int16_t value) {

  641.   return value < -128 ? -128 : (value > 127 ? 127 : value);

  642. }

  643. 

  644. static inline uint8_t U8Mix(uint8_t a, uint8_t b, uint8_t balance) {

  645.   return a * (255 - balance) + b * balance >> 8;

  646. }

  647. 

  648. static inline uint8_t U8Mix(uint8_t a, uint8_t b, uint8_t gain_a, uint8_t gain_b) {

  649.   return a * gain_a + b * gain_b >> 8;

  650. }

  651. 

  652. static inline int8_t S8Mix(

  653.     int8_t a, int8_t b,

  654.     uint8_t gain_a, uint8_t gain_b) {

  655.   return a * gain_a + b * gain_b >> 8;

  656. }

  657. 

  658. static inline uint16_t U8MixU16(uint8_t a, uint8_t b, uint8_t balance) {

  659.   return a * (255 - balance) + b * balance;

  660. }

  661. 

  662. static inline uint8_t U8U4MixU8(uint8_t a, uint8_t b, uint8_t balance) {

  663.   return (a * (15 - balance) + b * balance) >> 4;

  664. }

  665. 

  666. static inline uint16_t U8U4MixU12(uint8_t a, uint8_t b, uint8_t balance) {

  667.   return a * (15 - balance) + b * balance;

  668. }

  669. 

  670. static inline uint8_t U8ShiftRight4(uint8_t a) {

  671.   return a >> 4;

  672. }

  673. 

  674. static inline uint8_t U8ShiftLeft4(uint8_t a) {

  675.   return a << 4;

  676. }

  677. 

  678. static inline uint8_t U8Swap4(uint8_t a) {

  679.   return (a << 4) | (a >> 4);

  680. }

  681. 

  682. static inline uint8_t U8U8MulShift8(uint8_t a, uint8_t b) {

  683.   return a * b >> 8;

  684. }

  685. 

  686. static inline int8_t S8U8MulShift8(int8_t a, uint8_t b) {

  687.   return a * b >> 8;

  688. }

  689. 

  690. static inline int16_t S8U8Mul(int8_t a, uint8_t b) {

  691.   return a * b;

  692. }

  693. 

  694. static inline int16_t S8S8Mul(int8_t a, int8_t b) {

  695.   return a * b;

  696. }

  697. 

  698. static inline uint16_t U8U8Mul(uint8_t a, uint8_t b) {

  699.   return a * b;

  700. }

  701. 

  702. static inline int8_t S8S8MulShift8(int8_t a, int8_t b) {

  703.   return a * b >> 8;

  704. }

  705. 

  706. static inline uint16_t Mul16Scale8(uint16_t a, uint16_t b) {

  707.   return static_cast<uint32_t>(a) * b >> 8;

  708. }

  709. 

  710. static inline uint8_t U14ShiftRight6(uint16_t value) {

  711.   return value >> 6;

  712. }

  713. 

  714. static inline uint8_t U15ShiftRight7(uint16_t value) {

  715.   return value >> 7;

  716. }

  717. 

  718. static inline uint16_t U16ShiftRight4(uint16_t a) {

  719.   return a >> 4;

  720. }

  721. 

  722. static inline int16_t S16U16MulShift16(int16_t a, uint16_t b) {

  723.   return (static_cast<int32_t>(a) * static_cast<uint32_t>(b)) >> 16;

  724. }

  725. 

  726. static inline int16_t S16U8MulShift8(int16_t a, uint8_t b) {

  727.   return (static_cast<int32_t>(a) * static_cast<uint32_t>(b)) >> 8;

  728. }

  729. 

  730. static inline uint16_t U16U8MulShift8(uint16_t a, uint8_t b) {

  731.   return (static_cast<uint32_t>(a) * static_cast<uint32_t>(b)) >> 8;

  732. }

  733. 

  734. static inline uint8_t InterpolateSample(

  735.     const prog_uint8_t* table,

  736.     uint16_t phase) {

  737.   return U8Mix(

  738.       pgm_read_byte(table + (phase >> 8)),

  739.       pgm_read_byte(1 + table + (phase >> 8)),

  740.       phase & 0xff);

  741. }

  742. 

  743. #endif  // USE_OPTIMIZED_OP

  744. 

  745. }  // namespace avrlib

  746. 

  747. #endif  // AVRLIB_OP_H_