API tools faq
paste
Guest User

Untitled

a guest
Jan 19th, 2014
168
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 13.54 KB | None | 0 0
raw download clone embed print report
  1. if(order <= 12) {
  2.                 if(order > 8) {
  3.                         if(order > 10) {
  4.                                 if(order == 12) {
  5.                                         for(i = 0; i < (int)data_len; i++) {
  6.                                                 sum = 0;
  7.                                                 sum += qlp_coeff[11] * data[i-12];
  8.                                                 sum += qlp_coeff[10] * data[i-11];
  9.                                                 sum += qlp_coeff[9] * data[i-10];
  10.                                                 sum += qlp_coeff[8] * data[i-9];
  11.                                                 sum += qlp_coeff[7] * data[i-8];
  12.                                                 sum += qlp_coeff[6] * data[i-7];
  13.                                                 sum += qlp_coeff[5] * data[i-6];
  14.                                                 sum += qlp_coeff[4] * data[i-5];
  15.                                                 sum += qlp_coeff[3] * data[i-4];
  16.                                                 sum += qlp_coeff[2] * data[i-3];
  17.                                                 sum += qlp_coeff[1] * data[i-2];
  18.                                                 sum += qlp_coeff[0] * data[i-1];
  19.                                                 residual[i] = data[i] - (sum >> lp_quantization);
  20.                                         }
  21.                                 }
  22.                                 else { /* order == 11 */
  23.                                         for(i = 0; i < (int)data_len; i++) {
  24.                                                 sum = 0;
  25.                                                 sum += qlp_coeff[10] * data[i-11];
  26.                                                 sum += qlp_coeff[9] * data[i-10];
  27.                                                 sum += qlp_coeff[8] * data[i-9];
  28.                                                 sum += qlp_coeff[7] * data[i-8];
  29.                                                 sum += qlp_coeff[6] * data[i-7];
  30.                                                 sum += qlp_coeff[5] * data[i-6];
  31.                                                 sum += qlp_coeff[4] * data[i-5];
  32.                                                 sum += qlp_coeff[3] * data[i-4];
  33.                                                 sum += qlp_coeff[2] * data[i-3];
  34.                                                 sum += qlp_coeff[1] * data[i-2];
  35.                                                 sum += qlp_coeff[0] * data[i-1];
  36.                                                 residual[i] = data[i] - (sum >> lp_quantization);
  37.                                         }
  38.                                 }
  39.                         }
  40.                         else {
  41.                                 if(order == 10) {
  42.                                         for(i = 0; i < (int)data_len; i++) {
  43.                                                 sum = 0;
  44.                                                 sum += qlp_coeff[9] * data[i-10];
  45.                                                 sum += qlp_coeff[8] * data[i-9];
  46.                                                 sum += qlp_coeff[7] * data[i-8];
  47.                                                 sum += qlp_coeff[6] * data[i-7];
  48.                                                 sum += qlp_coeff[5] * data[i-6];
  49.                                                 sum += qlp_coeff[4] * data[i-5];
  50.                                                 sum += qlp_coeff[3] * data[i-4];
  51.                                                 sum += qlp_coeff[2] * data[i-3];
  52.                                                 sum += qlp_coeff[1] * data[i-2];
  53.                                                 sum += qlp_coeff[0] * data[i-1];
  54.                                                 residual[i] = data[i] - (sum >> lp_quantization);
  55.                                         }
  56.                                 }
  57.                                 else { /* order == 9 */
  58.                                         for(i = 0; i < (int)data_len; i++) {
  59.                                                 sum = 0;
  60.                                                 sum += qlp_coeff[8] * data[i-9];
  61.                                                 sum += qlp_coeff[7] * data[i-8];
  62.                                                 sum += qlp_coeff[6] * data[i-7];
  63.                                                 sum += qlp_coeff[5] * data[i-6];
  64.                                                 sum += qlp_coeff[4] * data[i-5];
  65.                                                 sum += qlp_coeff[3] * data[i-4];
  66.                                                 sum += qlp_coeff[2] * data[i-3];
  67.                                                 sum += qlp_coeff[1] * data[i-2];
  68.                                                 sum += qlp_coeff[0] * data[i-1];
  69.                                                 residual[i] = data[i] - (sum >> lp_quantization);
  70.                                         }
  71.                                 }
  72.                         }
  73.                 }
  74.                 else if(order > 4) {
  75.                         if(order > 6) {
  76.                                 if(order == 8) {
  77.                                         for(i = 0; i < (int)data_len; i++) {
  78.                                                 sum = 0;
  79.                                                 sum += qlp_coeff[7] * data[i-8];
  80.                                                 sum += qlp_coeff[6] * data[i-7];
  81.                                                 sum += qlp_coeff[5] * data[i-6];
  82.                                                 sum += qlp_coeff[4] * data[i-5];
  83.                                                 sum += qlp_coeff[3] * data[i-4];
  84.                                                 sum += qlp_coeff[2] * data[i-3];
  85.                                                 sum += qlp_coeff[1] * data[i-2];
  86.                                                 sum += qlp_coeff[0] * data[i-1];
  87.                                                 residual[i] = data[i] - (sum >> lp_quantization);
  88.                                         }
  89.                                 }
  90.                                 else { /* order == 7 */
  91.                                         for(i = 0; i < (int)data_len; i++) {
  92.                                                 sum = 0;
  93.                                                 sum += qlp_coeff[6] * data[i-7];
  94.                                                 sum += qlp_coeff[5] * data[i-6];
  95.                                                 sum += qlp_coeff[4] * data[i-5];
  96.                                                 sum += qlp_coeff[3] * data[i-4];
  97.                                                 sum += qlp_coeff[2] * data[i-3];
  98.                                                 sum += qlp_coeff[1] * data[i-2];
  99.                                                 sum += qlp_coeff[0] * data[i-1];
  100.                                                 residual[i] = data[i] - (sum >> lp_quantization);
  101.                                         }
  102.                                 }
  103.                         }
  104.                         else {
  105.                                 if(order == 6) {
  106.                                         for(i = 0; i < (int)data_len; i++) {
  107.                                                 sum = 0;
  108.                                                 sum += qlp_coeff[5] * data[i-6];
  109.                                                 sum += qlp_coeff[4] * data[i-5];
  110.                                                 sum += qlp_coeff[3] * data[i-4];
  111.                                                 sum += qlp_coeff[2] * data[i-3];
  112.                                                 sum += qlp_coeff[1] * data[i-2];
  113.                                                 sum += qlp_coeff[0] * data[i-1];
  114.                                                 residual[i] = data[i] - (sum >> lp_quantization);
  115.                                         }
  116.                                 }
  117.                                 else { /* order == 5 */
  118.                                         for(i = 0; i < (int)data_len; i++) {
  119.                                                 sum = 0;
  120.                                                 sum += qlp_coeff[4] * data[i-5];
  121.                                                 sum += qlp_coeff[3] * data[i-4];
  122.                                                 sum += qlp_coeff[2] * data[i-3];
  123.                                                 sum += qlp_coeff[1] * data[i-2];
  124.                                                 sum += qlp_coeff[0] * data[i-1];
  125.                                                 residual[i] = data[i] - (sum >> lp_quantization);
  126.                                         }
  127.                                 }
  128.                         }
  129.                 }
  130.                 else {
  131.                         if(order > 2) {
  132.                                 if(order == 4) {
  133.                                         for(i = 0; i < (int)data_len; i++) {
  134.                                                 sum = 0;
  135.                                                 sum += qlp_coeff[3] * data[i-4];
  136.                                                 sum += qlp_coeff[2] * data[i-3];
  137.                                                 sum += qlp_coeff[1] * data[i-2];
  138.                                                 sum += qlp_coeff[0] * data[i-1];
  139.                                                 residual[i] = data[i] - (sum >> lp_quantization);
  140.                                         }
  141.                                 }
  142.                                 else { /* order == 3 */
  143.                                         for(i = 0; i < (int)data_len; i++) {
  144.                                                 sum = 0;
  145.                                                 sum += qlp_coeff[2] * data[i-3];
  146.                                                 sum += qlp_coeff[1] * data[i-2];
  147.                                                 sum += qlp_coeff[0] * data[i-1];
  148.                                                 residual[i] = data[i] - (sum >> lp_quantization);
  149.                                         }
  150.                                 }
  151.                         }
  152.                         else {
  153.                                 if(order == 2) {
  154.                                         for(i = 0; i < (int)data_len; i++) {
  155.                                                 sum = 0;
  156.                                                 sum += qlp_coeff[1] * data[i-2];
  157.                                                 sum += qlp_coeff[0] * data[i-1];
  158.                                                 residual[i] = data[i] - (sum >> lp_quantization);
  159.                                         }
  160.                                 }
  161.                                 else { /* order == 1 */
  162.                                         for(i = 0; i < (int)data_len; i++)
  163.                                                 residual[i] = data[i] - ((qlp_coeff[0] * data[i-1]) >> lp_quantization);
  164.                                 }
  165.                         }
  166.                 }
  167.         }
  168.         else { /* order > 12 */
  169.                 for(i = 0; i < (int)data_len; i++) {
  170.                         sum = 0;
  171.                         switch(order) {
  172.                                 case 32: sum += qlp_coeff[31] * data[i-32];
  173.                                 case 31: sum += qlp_coeff[30] * data[i-31];
  174.                                 case 30: sum += qlp_coeff[29] * data[i-30];
  175.                                 case 29: sum += qlp_coeff[28] * data[i-29];
  176.                                 case 28: sum += qlp_coeff[27] * data[i-28];
  177.                                 case 27: sum += qlp_coeff[26] * data[i-27];
  178.                                 case 26: sum += qlp_coeff[25] * data[i-26];
  179.                                 case 25: sum += qlp_coeff[24] * data[i-25];
  180.                                 case 24: sum += qlp_coeff[23] * data[i-24];
  181.                                 case 23: sum += qlp_coeff[22] * data[i-23];
  182.                                 case 22: sum += qlp_coeff[21] * data[i-22];
  183.                                 case 21: sum += qlp_coeff[20] * data[i-21];
  184.                                 case 20: sum += qlp_coeff[19] * data[i-20];
  185.                                 case 19: sum += qlp_coeff[18] * data[i-19];
  186.                                 case 18: sum += qlp_coeff[17] * data[i-18];
  187.                                 case 17: sum += qlp_coeff[16] * data[i-17];
  188.                                 case 16: sum += qlp_coeff[15] * data[i-16];
  189.                                 case 15: sum += qlp_coeff[14] * data[i-15];
  190.                                 case 14: sum += qlp_coeff[13] * data[i-14];
  191.                                 case 13: sum += qlp_coeff[12] * data[i-13];
  192.                                  sum += qlp_coeff[11] * data[i-12];
  193.                                  sum += qlp_coeff[10] * data[i-11];
  194.                                  sum += qlp_coeff[ 9] * data[i-10];
  195.                                  sum += qlp_coeff[ 8] * data[i- 9];
  196.                                  sum += qlp_coeff[ 7] * data[i- 8];
  197.                                  sum += qlp_coeff[ 6] * data[i- 7];
  198.                                  sum += qlp_coeff[ 5] * data[i- 6];
  199.                                  sum += qlp_coeff[ 4] * data[i- 5];
  200.                                  sum += qlp_coeff[ 3] * data[i- 4];
  201.                                  sum += qlp_coeff[ 2] * data[i- 3];
  202.                                  sum += qlp_coeff[ 1] * data[i- 2];
  203.                                  sum += qlp_coeff[ 0] * data[i- 1];
  204.                         }
  205.                         residual[i] = data[i] - (sum >> lp_quantization);
  206.                 }
  207.         }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!