Symaptic: os/ossrv/genericopenlibs/liboil/tsrc/testsuite/wavelet/src/wavelet.c@bde4ae8d615e

     1 /*

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    19 #include <liboil/liboil.h>

    20 #include <liboil/liboilfunction.h>

    21 #include <stdio.h>

    22 #include <stdlib.h>

    24 #include <liboil/globals.h>

    26 #define LOG_FILE "c:\\logs\\testsuite_wavelet_log.txt"

    27 #include "std_log_result.h"

    28 #define LOG_FILENAME_LINE __FILE__, __LINE__

    30 #define SIZE    20

    32 void create_xml(int result)

    33 {

    34     if(result)

    35         assert_failed = 1;

    37     testResultXml("testsuite_wavelet");

    38     close_log_file();

    39 }

    41 void test_oil_add2_rshift_add_s16()

    42     {

    43     //int16_t * d, const int16_t * s1, const int16_t * s2, const int16_t * s3, const int16_t * s4_2, int n

    44     int16_t input1[SIZE];

    45     int16_t input2[SIZE];

    46     int16_t input3[SIZE];

    47     int16_t input4[2];

    48     int16_t output[SIZE];

    49     int16_t linux_output[] = {0,1,2,3,5,6,7,9,10,11,13,14,15,17,18,19,21,22,23,24};

    50     int i = 0;

    52     for(i=0; i<SIZE; i++)

    53         {

    54         input1[i] = i;

    55         input2[i] = i*2;

    56         input3[i] = i*3;

    57         if(i < 2)

    58             input4[i] = i*4;

    59         }

    61     oil_add2_rshift_add_s16(output, input1, input2, input3, input4, SIZE);

    63     for(i = 0; i < SIZE; i++)

    64         {

    65         if(output[i] != linux_output[i])

    66             {

    67             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

    68             assert_failed = 1;

    69             }

    70         }

    71     }

    73 void test_oil_add2_rshift_sub_s16()

    74     {

    75     //int16_t * d, const int16_t * s1, const int16_t * s2, const int16_t * s3, const int16_t * s4_2, int n

    76     int16_t input1[SIZE];

    77     int16_t input2[SIZE];

    78     int16_t input3[SIZE];

    79     int16_t input4[2];

    80     int16_t output[SIZE];

    81     int16_t linux_output[] = {0,1,2,3,3,4,5,5,6,7,7,8,9,9,10,11,11,12,13,14};

    82     int i = 0;

    84     for(i=0; i<SIZE; i++)

    85         {

    86         input1[i] = i;

    87         input2[i] = i*2;

    88         input3[i] = i*3;

    89         if(i < 2)

    90             input4[i] = i*4;

    91         }

    93     oil_add2_rshift_sub_s16(output, input1, input2, input3, input4, SIZE);

    95     for(i = 0; i < SIZE; i++)

    96         {

    97         if(output[i] != linux_output[i])

    98             {

    99             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   100             assert_failed = 1;

   101             }

   102         }

   103     }

   105 void test_oil_add_const_rshift_s16()

   106     {

   107     //int16_t * d1, const int16_t * s1, const int16_t * s2_2, int n

   108     int16_t input1[SIZE];

   109     int16_t input2[2];

   110     int16_t output[SIZE];

   111     int16_t linux_output[] = {0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4};

   112     int i = 0;

   114     for(i=0; i<SIZE; i++)

   115         {

   116         input1[i] = i;

   117         if(i < 2)

   118             input2[i] = i*2;

   119         }

   121     oil_add_const_rshift_s16(output, input1, input2, SIZE);

   123     for(i = 0; i < SIZE; i++)

   124         {

   125         if(output[i] != linux_output[i])

   126             {

   127             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   128             assert_failed = 1;

   129             }

   130         }

   131     }

   133 void test_oil_avg2_12xn_u8()

   134     {

   135     //uint8_t * d_12xn, int ds1, const uint8_t * s1_12xn, int ss1, const uint8_t * s2_12xn, int ss2, int n

   136     uint8_t input1[SIZE*12];

   137     uint8_t input2[SIZE*12];

   138     uint8_t output[SIZE*12];

   139     int16_t linux_output[] = {0,2,6,7,11,13,17,18,22,24,28,29,33,35,39,40,44,46,50,51,55,57,61,62,66,68,72,73,77,79,83,84,88,90,94,95,99,101,105,106,108,109,111,112,114,115,117,118,120,121,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

   140     int i = 0;

   142     for(i=0; i<SIZE*12; i++)

   143         {

   144         output[i] = 0;

   145         input1[i] = i;

   146         input2[i] = i*2;

   147         }

   149     oil_avg2_12xn_u8(output, 2, input1, 3, input2, 4, SIZE);

   151     for(i = 0; i < SIZE*12; i++)

   152         {

   153         if(output[i] != linux_output[i])

   154             {

   155             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   156             assert_failed = 1;

   157             }

   158         }

   159     }

   161 void test_oil_avg2_16xn_u8()

   162     {

   163     //uint8_t * d_16xn, int ds1, const uint8_t * s1_16xn, int ss1, const uint8_t * s2_16xn, int ss2, int n

   164     uint8_t input1[SIZE*16];

   165     uint8_t input2[SIZE*16];

   166     uint8_t output[SIZE*16];

   167     int16_t linux_output[] = {0,2,6,7,11,13,17,18,22,24,28,29,33,35,39,40,44,46,50,51,55,57,61,62,66,68,72,73,77,79,83,84,88,90,94,95,99,101,105,106,108,109,111,112,114,115,117,118,120,121,123,124,126,127,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

   168     int i = 0;

   170     for(i=0; i<SIZE*16; i++)

   171         {

   172         output[i] = 0;

   173         input1[i] = i;

   174         input2[i] = i*2;

   175         }

   177     oil_avg2_16xn_u8(output, 2, input1, 3, input2, 4, SIZE);

   179     for(i = 0; i < SIZE*16; i++)

   180         {

   181         if(output[i] != linux_output[i])

   182             {

   183             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   184             assert_failed = 1;

   185             }

   186         }

   187     }

   189 void test_oil_avg2_8xn_u8()

   190     {

   191     //uint8_t * d_8xn, int ds1, const uint8_t * s1_8xn, int ss1, const uint8_t * s2_8xn, int ss2, int n

   192     uint8_t input1[SIZE*8];

   193     uint8_t input2[SIZE*8];

   194     uint8_t output[SIZE*8];

   195     int16_t linux_output[] = {0,2,6,7,11,13,17,18,22,24,28,29,33,35,39,40,44,46,50,51,55,57,61,62,66,68,72,73,77,79,83,84,88,90,94,95,99,101,105,106,108,109,111,112,114,115,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

   196     int i = 0;

   198     for(i=0; i<SIZE*8; i++)

   199         {

   200         output[i] = 0;

   201         input1[i] = i;

   202         input2[i] = i*2;

   203         }

   205     oil_avg2_8xn_u8(output, 2, input1, 3, input2, 4, SIZE);

   207     for(i = 0; i < SIZE*8; i++)

   208         {

   209         if(output[i] != linux_output[i])

   210             {

   211             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   212             assert_failed = 1;

   213             }

   214         }

   215     }

   217 void test_oil_combine2_12xn_u8()

   218     {

   219     //uint8_t * d_12xn, int ds1, const uint8_t * s1_12xn, int ss1, const uint8_t * s2_12xn, int ss2, const int16_t * s3_4, int n

   220     uint8_t input1[SIZE*12];

   221     uint8_t input2[SIZE*12];

   222     int16_t input3[4];

   223     uint8_t output[SIZE*12];

   224     int16_t linux_output[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

   225     int i = 0;

   227     for(i=0; i<SIZE*12; i++)

   228         {

   229         output[i] = 0;

   230         input1[i] = i;

   231         input2[i] = i*2;

   233         if(i < 4)

   234             input3[i] = i*3;

   235         }

   237     oil_combine2_12xn_u8(output, 2, input1, 3, input2, 4, input3, SIZE);

   239     for(i = 0; i < SIZE*12; i++)

   240         {

   241         if(output[i] != linux_output[i])

   242             {

   243             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   244             assert_failed = 1;

   245             }

   246         }

   247     }

   249 void test_oil_combine2_16xn_u8()

   250     {

   251     //uint8_t * d_16xn, int ds1, const uint8_t * s1_16xn, int ss1, const uint8_t * s2_16xn, int ss2, const int16_t * s3_4, int n

   252     uint8_t input1[SIZE*16];

   253     uint8_t input2[SIZE*16];

   254     int16_t input3[4];

   255     uint8_t output[SIZE*16];

   256     int16_t linux_output[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};

   257     int i = 0;

   259     for(i=0; i<SIZE*16; i++)

   260         {

   261         output[i] = 1;

   262         input1[i] = i;

   263         input2[i] = i*2;

   265         if(i < 4)

   266             input3[i] = i*3;

   267         }

   269     oil_combine2_16xn_u8(output, 2, input1, 3, input2, 4, input3, SIZE);

   271     for(i = 0; i < SIZE*16; i++)

   272         {

   273         if(output[i] != linux_output[i])

   274             {

   275             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   276             assert_failed = 1;

   277             }

   278         }

   279     }

   281 void test_oil_combine2_8xn_u8()

   282     {

   283     //uint8_t * d_8xn, int ds1, const uint8_t * s1_8xn, int ss1, const uint8_t * s2_8xn, int ss2, const int16_t * s3_4, int n

   284     uint8_t input1[SIZE*8];

   285     uint8_t input2[SIZE*8];

   286     int16_t input3[4];

   287     uint8_t output[SIZE*8];

   288     int16_t linux_output[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2};

   289     int i = 0;

   291     for(i=0; i<SIZE*8; i++)

   292         {

   293         output[i] = 2;

   294         input1[i] = i;

   295         input2[i] = i*2;

   297         if(i < 4)

   298             input3[i] = i*3;

   299         }

   301     oil_combine2_8xn_u8(output, 2, input1, 3, input2, 4, input3, SIZE);

   303     for(i = 0; i < SIZE*8; i++)

   304         {

   305         if(output[i] != linux_output[i])

   306             {

   307             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   308             assert_failed = 1;

   309             }

   310         }

   311     }

   313 void test_oil_combine4_12xn_u8()

   314     {

   315     //uint8_t * d_12xn, int ds1, const uint8_t * s1_12xn, int ss1, const uint8_t * s2_12xn, int ss2, const uint8_t * s3_12xn, int ss3, const uint8_t * s4_12xn, int ss4, const int16_t * s5_6, int n

   316     uint8_t input1[SIZE*12];

   317     uint8_t input2[SIZE*12];

   318     uint8_t input3[SIZE*12];

   319     uint8_t input4[SIZE*12];

   320     int16_t input5[6];

   321     uint8_t output[SIZE*12];

   322  	uint8_t expected_output[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};

   324     int i = 0;

   326     for(i=0; i<SIZE*12; i++)

   327         {

   328         output[i] = 1;

   329         input1[i] = i;

   330         input2[i] = i+2;

   331         input3[i] = i+3;

   332         input4[i] = i+4;

   334         if(i < 6)

   335             input5[i] = i+5;

   336         }

   338     oil_combine4_12xn_u8(output, 1, input1, 1, input2, 2, input3, 3, input4, 4, input5, SIZE);

   340     for(i = 0; i < SIZE*12; i++)

   341         {

   342         if(output[i] != expected_output[i])

   343             {

   344             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,expected_output[i],output[i]);

   345             assert_failed = 1;

   346             }

   347         }

   348     }

   350 void test_oil_combine4_16xn_u8()

   351     {

   352     //uint8_t * d_16xn, int ds1, const uint8_t * s1_16xn, int ss1, const uint8_t * s2_16xn, int ss2, const uint8_t * s3_16xn, int ss3, const uint8_t * s4_16xn, int ss4, const int16_t * s5_6, int n

   353     uint8_t input1[SIZE*16];

   354     uint8_t input2[SIZE*16];

   355     uint8_t input3[SIZE*16];

   356     uint8_t input4[SIZE*16];

   357     int16_t input5[6];

   358     uint8_t output[SIZE*16];

   359     uint8_t expected_output[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};

   360     int i = 0;

   362     for(i=0; i<SIZE*16; i++)

   363         {

   364         output[i] = 1;

   365         input1[i] = i;

   366         input2[i] = i+2;

   367         input3[i] = i+3;

   368         input4[i] = i+4;

   370         if(i < 6)

   371             input5[i] = i+5;

   372         }

   374     oil_combine4_16xn_u8(output, 1, input1, 1, input2, 2, input3, 3, input4, 4, input5, SIZE);

   376     for(i = 0; i < SIZE*16; i++)

   377         {

   378         if(output[i] != expected_output[i])

   379             {

   380             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,expected_output[i],output[i]);

   381             assert_failed = 1;

   382             }

   383         }

   384     }

   386 void test_oil_combine4_8xn_u8()

   387     {

   388     //uint8_t * d_8xn, int ds1, const uint8_t * s1_8xn, int ss1, const uint8_t * s2_8xn, int ss2, const uint8_t * s3_8xn, int ss3, const uint8_t * s4_8xn, int ss4, const int16_t * s5_6, int n

   389     uint8_t input1[SIZE*8];

   390     uint8_t input2[SIZE*8];

   391     uint8_t input3[SIZE*8];

   392     uint8_t input4[SIZE*8];

   393     int16_t input5[6];

   394     uint8_t output[SIZE*8];

   395     uint8_t expected_output[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};

   396     int i = 0;

   398     for(i=0; i<SIZE*8; i++)

   399         {

   400         output[i] = 1;

   401         input1[i] = i;

   402         input2[i] = i+2;

   403         input3[i] = i+3;

   404         input4[i] = i+4;

   406         if(i < 6)

   407             input5[i] = i+5;

   408         }

   410     oil_combine4_8xn_u8(output, 1, input1, 1, input2, 2, input3, 3, input4, 4, input5, SIZE);

   412     for(i = 0; i < SIZE*8; i++)

   413         {

   414         if(output[i] != expected_output[i])

   415             {

   416             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,expected_output[i],output[i]);

   417             assert_failed = 1;

   418             }

   419         }

   420     }

   422 void test_oil_deinterleave()

   423     {

   424     //int16_t * d_2xn, const int16_t * s_2xn, int n

   425     int16_t input[SIZE*2];

   426     int16_t output[SIZE*2];

   427     int16_t linux_output[] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,37,39};

   428     int i = 0;

   430     for(i=0; i<SIZE*2; i++)

   431         {

   432         output[i] = 0;

   433         input[i] = i;

   434         }

   436     oil_deinterleave(output, input, SIZE);

   438     for(i = 0; i < SIZE*2; i++)

   439         {

   440         if(output[i] != linux_output[i])

   441             {

   442             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   443             assert_failed = 1;

   444             }

   445         }

   446     }

   448 void test_oil_deinterleave2_s16()

   449     {

   450     //int16_t * d1_n, int16_t * d2_n, const int16_t * s_2xn, int n

   451     int16_t input[SIZE*2];

   452     int16_t output1[SIZE];

   453     int16_t output2[SIZE];

   454     int16_t linux_output1[] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38};

   455     int16_t linux_output2[] = {1,3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,37,39};

   456     int i = 0;

   458     for(i=0; i<SIZE*2; i++)

   459         {

   460         if(i < SIZE)

   461             {

   462             output1[i] = i+1;

   463             output2[i] = i+2;

   464             }

   465         input[i] = i;

   466         }

   468     oil_deinterleave2_s16(output1, output2, input, SIZE);

   470     for(i = 0; i < SIZE; i++)

   471         {

   472         if(output1[i] != linux_output1[i])

   473             {

   474             std_log(LOG_FILENAME_LINE, "output1[%d]: expected value - %d, actual value - %d", i,linux_output1[i],output1[i]);

   475             assert_failed = 1;

   476             }

   478         if(output2[i] != linux_output2[i])

   479             {

   480             std_log(LOG_FILENAME_LINE, "output2[%d]: expected value - %d, actual value - %d", i,linux_output2[i],output2[i]);

   481             assert_failed = 1;

   482             }

   483         }

   484     }

   486 void test_oil_interleave()

   487     {

   488     //int16_t * d_2xn, const int16_t * s_2xn, int n

   489     int16_t input[SIZE*2];

   490     int16_t output[SIZE*2];

   491     int16_t linux_output[] = {0,20,1,21,2,22,3,23,4,24,5,25,6,26,7,27,8,28,9,29,10,30,11,31,12,32,13,33,14,34,15,35,16,36,17,37,18,38,19,39};

   492     int i = 0;

   494     for(i=0; i<SIZE*2; i++)

   495         {

   496         output[i] = 0;

   497         input[i] = i;

   498         }

   500     oil_interleave(output, input, SIZE);

   502     for(i = 0; i < SIZE*2; i++)

   503         {

   504         if(output[i] != linux_output[i])

   505             {

   506             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   507             assert_failed = 1;

   508             }

   509         }

   510     }

   512 void test_oil_interleave2_s16()

   513     {

   514     //int16_t * d_2xn, const int16_t * s1_n, const int16_t * s2_n, int n

   515     int16_t input1[SIZE];

   516     int16_t input2[SIZE];

   517     int16_t output[SIZE*2];

   518     int16_t linux_output[] = {1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11};

   519     int i = 0;

   521     for(i=0; i<SIZE*2; i++)

   522         {

   523         if(i < SIZE)

   524             {

   525             input1[i] = i+1;

   526             input2[i] = i+2;

   527             }

   528         output[i] = 0;

   529         }

   531     oil_interleave2_s16(output, input1, input2, SIZE);

   533     for(i = 0; i < SIZE; i++)

   534         {

   535         if(output[i] != linux_output[i])

   536             {

   537             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   538             assert_failed = 1;

   539             }

   540         }

   541     }

   543 void test_oil_lift_add_135()

   544     {

   545     //int16_t * d, const int16_t * s1, const int16_t * s2, const int16_t * s3, const int16_t * s4, const int16_t * s5, int n

   546     int16_t output[SIZE];

   547     int16_t input1[SIZE];

   548     int16_t input2[SIZE];

   549     int16_t input3[SIZE];

   550     int16_t input4[SIZE];

   551     int16_t input5[SIZE];

   552     int16_t linux_output[] = {15,5,7,10,12,14,16,18,20,22,24,26,28,30,32,34,36,39,41,32};

   553     int i = 0;

   555     for(i=0; i<SIZE; i++)

   556         {

   557         input1[i] = i+1;

   558         input2[i] = i+2;

   559         input3[i] = i+3;

   560         input4[i] = i+4;

   561         input5[i] = i+5;

   563         output[i] = 0;

   564         }

   566     oil_lift_add_135(output, input1, input2, input3, input4, input5, SIZE);

   568     for(i = 0; i < SIZE; i++)

   569         {

   570         if(output[i] != linux_output[i])

   571             {

   572             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   573             assert_failed = 1;

   574             }

   575         }

   576     }

   578 void test_oil_lift_add_mult_shift12()

   579     {

   580     //int16_t * d, const int16_t * s1, const int16_t * s2, const int16_t * s3, const int16_t * s4_1, int n

   581     int16_t output[SIZE];

   582     int16_t input1[SIZE];

   583     int16_t input2[SIZE];

   584     int16_t input3[SIZE];

   585     int16_t input4[1];

   586     int16_t linux_output[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};

   587     int i = 0;

   589     input4[0] = 4;

   590     for(i=0; i<SIZE; i++)

   591         {

   592         input1[i] = i+1;

   593         input2[i] = i+2;

   594         input3[i] = i+3;

   596         output[i] = 0;

   597         }

   599     oil_lift_add_mult_shift12(output, input1, input2, input3, input4, SIZE);

   601     for(i = 0; i < SIZE; i++)

   602         {

   603         if(output[i] != linux_output[i])

   604             {

   605             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   606             assert_failed = 1;

   607             }

   608         }

   609     }

   611 void test_oil_lift_add_shift1()

   612     {

   613     //int16_t * d, const int16_t * s1, const int16_t * s2, const int16_t * s3, int n

   614     int16_t output[SIZE];

   615     int16_t input1[SIZE];

   616     int16_t input2[SIZE];

   617     int16_t input3[SIZE];

   618     int16_t linux_output[] = {3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33,35,37,39,41};

   619     int i = 0;

   621     for(i=0; i<SIZE; i++)

   622         {

   623         input1[i] = i+1;

   624         input2[i] = i+2;

   625         input3[i] = i+3;

   627         output[i] = 0;

   628         }

   630     oil_lift_add_shift1(output, input1, input2, input3, SIZE);

   632     for(i = 0; i < SIZE; i++)

   633         {

   634         if(output[i] != linux_output[i])

   635             {

   636             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   637             assert_failed = 1;

   638             }

   639         }

   640     }

   642 void test_oil_lift_add_shift2()

   643     {

   644     //int16_t * d, const int16_t * s1, const int16_t * s2, const int16_t * s3, int n

   645     int16_t output[SIZE];

   646     int16_t input1[SIZE];

   647     int16_t input2[SIZE];

   648     int16_t input3[SIZE];

   649     int16_t linux_output[] = {2,3,5,6,8,9,11,12,14,15,17,18,20,21,23,24,26,27,29,30};

   650     int i = 0;

   652     for(i=0; i<SIZE; i++)

   653         {

   654         input1[i] = i+1;

   655         input2[i] = i+2;

   656         input3[i] = i+3;

   658         output[i] = 0;

   659         }

   661     oil_lift_add_shift2(output, input1, input2, input3, SIZE);

   663     for(i = 0; i < SIZE; i++)

   664         {

   665         if(output[i] != linux_output[i])

   666             {

   667             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   668             assert_failed = 1;

   669             }

   670         }

   671     }

   673 void test_oil_lift_sub_135()

   674     {

   675     //int16_t * d, const int16_t * s1, const int16_t * s2, const int16_t * s3, const int16_t * s4, const int16_t * s5, int n

   676     int16_t output[SIZE];

   677     int16_t input1[SIZE];

   678     int16_t input2[SIZE];

   679     int16_t input3[SIZE];

   680     int16_t input4[SIZE];

   681     int16_t input5[SIZE];

   682     int16_t linux_output[] = {-13,-1,-1,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-3,-3,8};

   683     int i = 0;

   685     for(i=0; i<SIZE; i++)

   686         {

   687         input1[i] = i+1;

   688         input2[i] = i+2;

   689         input3[i] = i+3;

   690         input4[i] = i+4;

   691         input5[i] = i+5;

   693         output[i] = 0;

   694         }

   696     oil_lift_sub_135(output, input1, input2, input3, input4, input5, SIZE);

   698     for(i = 0; i < SIZE; i++)

   699         {

   700         if(output[i] != linux_output[i])

   701             {

   702             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   703             assert_failed = 1;

   704             }

   705         }

   706     }

   708 void test_oil_lift_sub_mult_shift12()

   709     {

   710     //int16_t * d, const int16_t * s1, const int16_t * s2, const int16_t * s3, const int16_t * s4_1, int n

   711     int16_t output[SIZE];

   712     int16_t input1[SIZE];

   713     int16_t input2[SIZE];

   714     int16_t input3[SIZE];

   715     int16_t input4[1];

   716     int16_t linux_output[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};

   717     int i = 0;

   719     input4[0] = 4;

   720     for(i=0; i<SIZE; i++)

   721         {

   722         input1[i] = i+1;

   723         input2[i] = i+2;

   724         input3[i] = i+3;

   726         output[i] = 0;

   727         }

   729     oil_lift_sub_mult_shift12(output, input1, input2, input3, input4, SIZE);

   731     for(i = 0; i < SIZE; i++)

   732         {

   733         if(output[i] != linux_output[i])

   734             {

   735             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   736             assert_failed = 1;

   737             }

   738         }

   739     }

   741 void test_oil_lift_sub_shift1()

   742     {

   743     //int16_t * d, const int16_t * s1, const int16_t * s2, const int16_t * s3, int n

   744     int16_t output[SIZE];

   745     int16_t input1[SIZE];

   746     int16_t input2[SIZE];

   747     int16_t input3[SIZE];

   748     int16_t linux_output[] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};

   749     int i = 0;

   751     for(i=0; i<SIZE; i++)

   752         {

   753         input1[i] = i+1;

   754         input2[i] = i+2;

   755         input3[i] = i+3;

   757         output[i] = 0;

   758         }

   760     oil_lift_sub_shift1(output, input1, input2, input3, SIZE);

   762     for(i = 0; i < SIZE; i++)

   763         {

   764         if(output[i] != linux_output[i])

   765             {

   766             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   767             assert_failed = 1;

   768             }

   769         }

   770     }

   772 void test_oil_lift_sub_shift2()

   773     {

   774     //int16_t * d, const int16_t * s1, const int16_t * s2, const int16_t * s3, int n

   775     int16_t output[SIZE];

   776     int16_t input1[SIZE];

   777     int16_t input2[SIZE];

   778     int16_t input3[SIZE];

   779     int16_t linux_output[] = {0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10};

   780     int i = 0;

   782     for(i=0; i<SIZE; i++)

   783         {

   784         input1[i] = i+1;

   785         input2[i] = i+2;

   786         input3[i] = i+3;

   788         output[i] = 0;

   789         }

   791     oil_lift_sub_shift2(output, input1, input2, input3, SIZE);

   793     for(i = 0; i < SIZE; i++)

   794         {

   795         if(output[i] != linux_output[i])

   796             {

   797             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   798             assert_failed = 1;

   799             }

   800         }

   801     }

   803 void test_oil_lshift_s16()

   804     {

   805     //int16_t * d1, const int16_t * s1, const int16_t * s2_1, int n

   806     int16_t output[SIZE];

   807     int16_t input1[SIZE];

   808     int16_t input2[1];

   809     int16_t linux_output[] = {1024,2048,3072,4096,5120,6144,7168,8192,9216,10240,11264,12288,13312,14336,15360,16384,17408,18432,19456,20480};

   810     int i = 0;

   812     input2[0] = 10;

   813     for(i=0; i<SIZE; i++)

   814         {

   815         input1[i] = i+1;

   817         output[i] = 0;

   818         }

   820     oil_lshift_s16(output, input1, input2, SIZE);

   822     for(i = 0; i < SIZE; i++)

   823         {

   824         if(output[i] != linux_output[i])

   825             {

   826             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   827             assert_failed = 1;

   828             }

   829         }

   830     }

   832 void test_oil_multiply_and_acc_12xn_s16_u8()

   833     {

   834     //int16_t * i1_12xn, int is1, const int16_t * s1_12xn, int ss1, const uint8_t * s2_12xn, int ss2, int n

   835     int16_t input1[SIZE*12];

   836     uint8_t input2[SIZE*12];

   837     int16_t output[SIZE*12];

   838     int16_t linux_output[] = {2049,14105,-20630,-27882,1088,9482,6037,-508,-1416,11797,14588,22258,-22445,28216,-31104,-12536,9646,26705,29900,10241,25291,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

   839     int i = 0;

   841     for(i=0; i<SIZE*12; i++)

   842         {

   843         input1[i] = i+1;

   844         input2[i] = i+1;

   846         output[i] = 0;

   847         }

   849     oil_multiply_and_acc_12xn_s16_u8(output, 1, input1, 2, input2, 3, SIZE);

   851     for(i = 0; i < SIZE*12; i++)

   852         {

   853         if(output[i] != linux_output[i])

   854             {

   855             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   856             assert_failed = 1;

   857             }

   858         }

   859     }

   861 void test_oil_multiply_and_acc_16xn_s16_u8()

   862     {

   863     //int16_t * i1_16xn, int is1, const int16_t * s1_16xn, int ss1, const uint8_t * s2_16xn, int ss2, int n

   864     int16_t input1[SIZE*16];

   865     uint8_t input2[SIZE*16];

   866     int16_t output[SIZE*16];

   867     int16_t linux_output[] = {2562,15902,-16778,-21204,11363,24125,25819,25184,30958,-13657,-8553,1687,16812,-28204,-2288,28512,-32621,-9442,23776,-7240,19842,30750,16744,-30913,10112,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

   868     int i = 0;

   870     for(i=0; i<SIZE*16; i++)

   871         {

   872         input1[i] = i+1;

   873         input2[i] = i+2;

   875         output[i] = 0;

   876         }

   878     oil_multiply_and_acc_16xn_s16_u8(output, 1, input1, 2, input2, 3, SIZE);

   880     for(i = 0; i < SIZE*16; i++)

   881         {

   882         if(output[i] != linux_output[i])

   883             {

   884             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   885             assert_failed = 1;

   886             }

   887         }

   888     }

   890 void test_oil_multiply_and_acc_24xn_s16_u8()

   891     {

   892     //int16_t * i1_24xn, int is1, const int16_t * s1_24xn, int ss1, const uint8_t * s2_24xn, int ss2, int n

   893     int16_t input1[SIZE*24];

   894     uint8_t input2[SIZE*24];

   895     int16_t output[SIZE*24];

   896     int16_t linux_output[] = {2562,15902,-16778,-21204,11363,24125,25819,25184,30958,-13657,-8553,1687,16812,-28204,-2288,28512,-1083,-25540,20682,6507,-2529,-6425,-5181,1206,15666,28340,30493,13130,-31716,17517,20765,-29431,-11505,13,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

   897     int i = 0;

   899     for(i=0; i<SIZE*24; i++)

   900         {

   901         input1[i] = i+1;

   902         input2[i] = i+2;

   904         output[i] = 0;

   905         }

   907     oil_multiply_and_acc_24xn_s16_u8(output, 1, input1, 2, input2, 3, SIZE);

   909     for(i = 0; i < SIZE*24; i++)

   910         {

   911         if(output[i] != linux_output[i])

   912             {

   913             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   914             assert_failed = 1;

   915             }

   916         }

   917     }

   919 void test_oil_multiply_and_acc_6xn_s16_u8()

   920     {

   921     //int16_t * i1_6xn, int is1, const int16_t * s1_6xn, int ss1, const uint8_t * s2_6xn, int ss2, int n

   922     int16_t input1[SIZE*6];

   923     uint8_t input2[SIZE*6];

   924     int16_t output[SIZE*6];

   925     int16_t linux_output[] = {2562,15902,-16778,-21204,11363,24125,3235,19354,6945,31545,-12086,19342,-13979,10284,17859,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

   926     int i = 0;

   928     for(i=0; i<SIZE*6; i++)

   929         {

   930         input1[i] = i+1;

   931         input2[i] = i+2;

   933         output[i] = 0;

   934         }

   936     oil_multiply_and_acc_6xn_s16_u8(output, 1, input1, 2, input2, 3, SIZE);

   938     for(i = 0; i < SIZE*6; i++)

   939         {

   940         if(output[i] != linux_output[i])

   941             {

   942             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   943             assert_failed = 1;

   944             }

   945         }

   946     }

   948 void test_oil_multiply_and_acc_8xn_s16_u8()

   949     {

   950     //int16_t * i1_8xn, int is1, const int16_t * s1_8xn, int ss1, const uint8_t * s2_8xn, int ss2, int n

   951     int16_t input1[SIZE*8];

   952     uint8_t input2[SIZE*8];

   953     int16_t output[SIZE*8];

   954     int16_t linux_output[] = {2562,15902,-16778,-21204,11363,24125,25819,25184,-2412,19336,-14808,-27096,-26260,-21039,-20171,-32394,-910,6,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};

   955     int i = 0;

   957     for(i=0; i<SIZE*8; i++)

   958         {

   959         input1[i] = i+1;

   960         input2[i] = i+2;

   962         output[i] = 0;

   963         }

   965     oil_multiply_and_acc_8xn_s16_u8(output, 1, input1, 2, input2, 3, SIZE);

   967     for(i = 0; i < SIZE*8; i++)

   968         {

   969         if(output[i] != linux_output[i])

   970             {

   971             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

   972             assert_failed = 1;

   973             }

   974         }

   976     }

   978 void test_oil_multiply_and_add_s16()

   979     {

   980     //int16_t * d, const int16_t * src1, const int16_t * src2, const int16_t * src3, int n

   981     int16_t output[SIZE];

   982     int16_t input1[SIZE];

   983     int16_t input2[SIZE];

   984     int16_t input3[SIZE];

   985     int16_t linux_output[] = {7,14,23,34,47,62,79,98,119,142,167,194,223,254,287,322,359,398,439,482};

   986     int i = 0;

   988     for(i=0; i<SIZE; i++)

   989         {

   990         input1[i] = i+1;

   991         input2[i] = i+2;

   992         input3[i] = i+3;

   994         output[i] = 0;

   995         }

   997     oil_multiply_and_add_s16(output, input1, input2, input3, SIZE);

   999     for(i = 0; i < SIZE; i++)

  1000         {

  1001         if(output[i] != linux_output[i])

  1002             {

  1003             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

  1004             assert_failed = 1;

  1005             }

  1006         }

  1007     }

  1009 void test_oil_multiply_and_add_s16_u8()

  1010     {

  1011     //int16_t * d, const int16_t * src1, const int16_t * src2, const uint8_t * src3, int n

  1012     int16_t output[SIZE];

  1013     int16_t input1[SIZE];

  1014     int16_t input2[SIZE];

  1015     uint8_t input3[SIZE];

  1016     int16_t linux_output[] = {7,14,23,34,47,62,79,98,119,142,167,194,223,254,287,322,359,398,439,482};

  1017     int i = 0;

  1019     for(i=0; i<SIZE; i++)

  1020         {

  1021         input1[i] = i+1;

  1022         input2[i] = i+2;

  1023         input3[i] = i+3;

  1025         output[i] = 0;

  1026         }

  1028     oil_multiply_and_add_s16_u8(output, input1, input2, input3, SIZE);

  1030     for(i = 0; i < SIZE; i++)

  1031         {

  1032         if(output[i] != linux_output[i])

  1033             {

  1034             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

  1035             assert_failed = 1;

  1036             }

  1037         }

  1038     }

  1040 void test_oil_split_135()

  1041     {

  1042     //int16_t * d_2xn, const int16_t * s_2xn, int n

  1043     int16_t output[SIZE*2];

  1044     int16_t input1[SIZE*2];

  1045     int16_t linux_output[] = {1,1,3,0,4,0,7,0,9,0,11,0,13,0,15,0,17,0,19,0,21,0,23,0,25,0,27,0,29,0,31,0,33,0,35,0,36,0,39,1};

  1046     int i = 0;

  1048     for(i=0; i<SIZE*2; i++)

  1049         {

  1050         input1[i] = i+1;

  1051         output[i] = 0;

  1052         }

  1054     oil_split_135(output, input1, SIZE);

  1056     for(i = 0; i < SIZE*2; i++)

  1057         {

  1058         if(output[i] != linux_output[i])

  1059             {

  1060             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

  1061             assert_failed = 1;

  1062             }

  1063         }

  1064     }

  1066 void test_oil_split_53()

  1067     {

  1068     //int16_t * d_2xn, const int16_t * s_2xn, int n

  1069     int16_t output[SIZE*2];

  1070     int16_t input1[SIZE*2];

  1071     int16_t linux_output[] = {1,0,3,0,5,0,7,0,9,0,11,0,13,0,15,0,17,0,19,0,21,0,23,0,25,0,27,0,29,0,31,0,33,0,35,0,37,0,39,1};

  1072     int i = 0;

  1074     for(i=0; i<SIZE*2; i++)

  1075         {

  1076         input1[i] = i+1;

  1077         output[i] = 0;

  1078         }

  1080     oil_split_53(output, input1, SIZE);

  1082     for(i = 0; i < SIZE*2; i++)

  1083         {

  1084         if(output[i] != linux_output[i])

  1085             {

  1086             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

  1087             assert_failed = 1;

  1088             }

  1089         }

  1090     }

  1092 void test_oil_split_approx97()

  1093     {

  1094     //int16_t * d_2xn, const int16_t * s_2xn, int n

  1095     int16_t output[SIZE*2];

  1096     int16_t input1[SIZE*2];

  1097     int16_t linux_output[] = {1,1,3,0,5,0,7,0,9,0,11,0,13,0,15,0,17,0,19,0,21,0,23,0,25,0,27,0,29,0,31,0,33,0,35,0,37,0,39,1};

  1098     int i = 0;

  1100     for(i=0; i<SIZE*2; i++)

  1101         {

  1102         input1[i] = i+1;

  1103         output[i] = 0;

  1104         }

  1106     oil_split_approx97(output, input1, SIZE);

  1108     for(i = 0; i < SIZE*2; i++)

  1109         {

  1110         if(output[i] != linux_output[i])

  1111             {

  1112             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

  1113             assert_failed = 1;

  1114             }

  1115         }

  1116     }

  1118 void test_oil_split_daub97()

  1119     {

  1120     //int16_t * d_2xn, const int16_t * s_2xn, int n

  1121     int16_t output[SIZE*2];

  1122     int16_t input1[SIZE*2];

  1123     int16_t linux_output[] = {2,1,4,1,7,1,9,1,12,1,14,0,16,0,19,1,21,0,24,1,26,1,29,0,31,1,34,1,36,1,39,1,41,1,43,0,46,0,48,1};

  1124     int i = 0;

  1126     for(i=0; i<SIZE*2; i++)

  1127         {

  1128         input1[i] = i+1;

  1129         output[i] = 0;

  1130         }

  1132     oil_split_daub97(output, input1, SIZE);

  1134     for(i = 0; i < SIZE*2; i++)

  1135         {

  1136         if(output[i] != linux_output[i])

  1137             {

  1138             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

  1139             assert_failed = 1;

  1140             }

  1141         }

  1142     }

  1144 void test_oil_synth_135()

  1145     {

  1146     //int16_t * d_2xn, const int16_t * s_2xn, int n

  1147     int16_t output[SIZE*2];

  1148     int16_t input1[SIZE*2];

  1149     int16_t linux_output[] = {1,3,2,6,3,9,4,12,5,15,6,18,7,21,8,24,9,27,10,30,11,33,12,36,13,39,14,42,15,45,16,48,17,51,18,54,19,57,20,60};

  1150     int i = 0;

  1152     for(i=0; i<SIZE*2; i++)

  1153         {

  1154         input1[i] = i+1;

  1155         output[i] = 0;

  1156         }

  1158     oil_synth_135(output, input1, SIZE);

  1160     for(i = 0; i < SIZE*2; i++)

  1161         {

  1162         if(output[i] != linux_output[i])

  1163             {

  1164             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

  1165             assert_failed = 1;

  1166             }

  1167         }

  1168     }

  1170 void test_oil_synth_53()

  1171     {

  1172     //int16_t * d_2xn, const int16_t * s_2xn, int n

  1173     int16_t output[SIZE*2];

  1174     int16_t input1[SIZE*2];

  1175     int16_t linux_output[] = {0,3,2,6,3,9,4,12,5,15,6,18,7,21,8,24,9,27,10,30,11,33,12,36,13,39,14,42,15,45,16,48,17,51,18,54,19,57,20,60};

  1176     int i = 0;

  1178     for(i=0; i<SIZE*2; i++)

  1179         {

  1180         input1[i] = i+1;

  1181         output[i] = 0;

  1182         }

  1184     oil_synth_53(output, input1, SIZE);

  1186     for(i = 0; i < SIZE*2; i++)

  1187         {

  1188         if(output[i] != linux_output[i])

  1189             {

  1190             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

  1191             assert_failed = 1;

  1192             }

  1193         }

  1194     }

  1196 void test_oil_synth_approx97()

  1197     {

  1198     //int16_t * d_2xn, const int16_t * s_2xn, int n

  1199     int16_t output[SIZE*2];

  1200     int16_t input1[SIZE*2];

  1201     int16_t linux_output[] = {0,2,2,6,3,9,4,12,5,15,6,18,7,21,8,24,9,27,10,30,11,33,12,36,13,39,14,42,15,45,16,48,17,51,18,54,19,57,20,60};

  1202     int i = 0;

  1204     for(i=0; i<SIZE*2; i++)

  1205         {

  1206         input1[i] = i+1;

  1207         output[i] = 0;

  1208         }

  1210     oil_synth_approx97(output, input1, SIZE);

  1212     for(i = 0; i < SIZE*2; i++)

  1213         {

  1214         if(output[i] != linux_output[i])

  1215             {

  1216             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

  1217             assert_failed = 1;

  1218             }

  1219         }

  1220     }

  1222 void test_oil_synth_daub97()

  1223     {

  1224     //int16_t * d_2xn, const int16_t * s_2xn, int n

  1225     int16_t output[SIZE*2];

  1226     int16_t input1[SIZE*2];

  1227     int16_t linux_output[] = {0,3,1,6,1,8,1,10,2,13,2,16,3,20,3,22,3,25,4,27,4,29,4,33,5,37,6,40,6,42,6,44,6,46,6,51,8,55,8,57};

  1228     int i = 0;

  1230     for(i=0; i<SIZE*2; i++)

  1231         {

  1232         input1[i] = i+1;

  1233         output[i] = 0;

  1234         }

  1236     oil_synth_daub97(output, input1, SIZE);

  1238     for(i = 0; i < SIZE*2; i++)

  1239         {

  1240         if(output[i] != linux_output[i])

  1241             {

  1242             std_log(LOG_FILENAME_LINE, "output[%d]: expected value - %d, actual value - %d", i,linux_output[i],output[i]);

  1243             assert_failed = 1;

  1244             }

  1245         }

  1246     }

  1248 int main (int argc, char *argv[])

  1249     {

  1250     oil_init();

  1252     std_log(LOG_FILENAME_LINE,"START oil_add2_rshift_add_s16 TEST");

  1253     test_oil_add2_rshift_add_s16();

  1254     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1256     std_log(LOG_FILENAME_LINE,"START oil_add2_rshift_sub_s16 TEST");

  1257     test_oil_add2_rshift_sub_s16();

  1258     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1260     std_log(LOG_FILENAME_LINE,"START oil_add_const_rshift_s16 TEST");

  1261     test_oil_add_const_rshift_s16();

  1262     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1264     std_log(LOG_FILENAME_LINE,"START oil_avg2_12xn_u8 TEST");

  1265     test_oil_avg2_12xn_u8();

  1266     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1268     std_log(LOG_FILENAME_LINE,"START oil_avg2_16xn_u8 TEST");

  1269     test_oil_avg2_16xn_u8();

  1270     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1272     std_log(LOG_FILENAME_LINE,"START oil_avg2_8xn_u8 TEST");

  1273     test_oil_avg2_8xn_u8();

  1274     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1276     std_log(LOG_FILENAME_LINE,"START oil_combine2_12xn_u8 TEST");

  1277     test_oil_combine2_12xn_u8();

  1278     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1280     std_log(LOG_FILENAME_LINE,"START oil_combine2_16xn_u8 TEST");

  1281     test_oil_combine2_16xn_u8();

  1282     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1284     std_log(LOG_FILENAME_LINE,"START oil_combine2_8xn_u8 TEST");

  1285     test_oil_combine2_8xn_u8();

  1286     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1288     std_log(LOG_FILENAME_LINE,"START oil_combine4_12xn_u8 TEST");

  1289     test_oil_combine4_12xn_u8(); //case fails...getting diff result than linux one.

  1290     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1292     std_log(LOG_FILENAME_LINE,"START oil_combine4_16xn_u8 TEST");

  1293     test_oil_combine4_16xn_u8(); //case fails...getting diff result than linux one.

  1294     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1296     std_log(LOG_FILENAME_LINE,"START oil_combine4_8xn_u8 TEST");

  1297     test_oil_combine4_8xn_u8(); //case fails...getting diff result than linux one.

  1298     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1300     std_log(LOG_FILENAME_LINE,"START oil_deinterleave TEST");

  1301     test_oil_deinterleave();

  1302     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1304     std_log(LOG_FILENAME_LINE,"START oil_deinterleave2_s16 TEST");

  1305     test_oil_deinterleave2_s16();

  1306     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1308     std_log(LOG_FILENAME_LINE,"START oil_interleave TEST");

  1309     test_oil_interleave();

  1310     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1312     std_log(LOG_FILENAME_LINE,"START oil_interleave2_s16 TEST");

  1313     test_oil_interleave2_s16();

  1314     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1316     std_log(LOG_FILENAME_LINE,"START oil_lift_add_135 TEST");

  1317     test_oil_lift_add_135();

  1318     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1320     std_log(LOG_FILENAME_LINE,"START oil_lift_add_mult_shift12 TEST");

  1321     test_oil_lift_add_mult_shift12();

  1322     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1324     std_log(LOG_FILENAME_LINE,"START oil_lift_add_shift1 TEST");

  1325     test_oil_lift_add_shift1();

  1326     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1328     std_log(LOG_FILENAME_LINE,"START oil_interleave2_s16 TEST");

  1329     test_oil_lift_add_shift2();

  1330     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1332     std_log(LOG_FILENAME_LINE,"START oil_lift_sub_135 TEST");

  1333     test_oil_lift_sub_135();

  1334     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1336     std_log(LOG_FILENAME_LINE,"START oil_lift_sub_mult_shift12 TEST");

  1337     test_oil_lift_sub_mult_shift12();

  1338     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1340     std_log(LOG_FILENAME_LINE,"START oil_lift_sub_shift1 TEST");

  1341     test_oil_lift_sub_shift1();

  1342     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1344     std_log(LOG_FILENAME_LINE,"START oil_lift_sub_shift2 TEST");

  1345     test_oil_lift_sub_shift2();

  1346     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1348     std_log(LOG_FILENAME_LINE,"START oil_lshift_s16 TEST");

  1349     test_oil_lshift_s16();

  1350     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1352     std_log(LOG_FILENAME_LINE,"START oil_multiply_and_acc_12xn_s16_u8 TEST");

  1353     test_oil_multiply_and_acc_12xn_s16_u8();

  1354     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1356     std_log(LOG_FILENAME_LINE,"START oil_multiply_and_acc_16xn_s16_u8 TEST");

  1357     test_oil_multiply_and_acc_16xn_s16_u8();

  1358     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1360     std_log(LOG_FILENAME_LINE,"START oil_multiply_and_acc_24xn_s16_u8 TEST");

  1361     test_oil_multiply_and_acc_24xn_s16_u8();

  1362     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1364     std_log(LOG_FILENAME_LINE,"START oil_multiply_and_acc_6xn_s16_u8 TEST");

  1365     test_oil_multiply_and_acc_6xn_s16_u8();

  1366     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1368     std_log(LOG_FILENAME_LINE,"START oil_multiply_and_acc_8xn_s16_u8 TEST");

  1369     test_oil_multiply_and_acc_8xn_s16_u8();

  1370     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1372     std_log(LOG_FILENAME_LINE,"START oil_multiply_and_add_s16 TEST");

  1373     test_oil_multiply_and_add_s16();

  1374     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1376     std_log(LOG_FILENAME_LINE,"START oil_multiply_and_add_s16_u8 TEST");

  1377     test_oil_multiply_and_add_s16_u8();

  1378     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1380     std_log(LOG_FILENAME_LINE,"START oil_split_135 TEST");

  1381     test_oil_split_135();

  1382     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1384     std_log(LOG_FILENAME_LINE,"START oil_split_53 TEST");

  1385     test_oil_split_53();

  1386     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1388     std_log(LOG_FILENAME_LINE,"START oil_split_approx97 TEST");

  1389     test_oil_split_approx97();

  1390     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1392     std_log(LOG_FILENAME_LINE,"START oil_split_daub97 TEST");

  1393     test_oil_split_daub97();

  1394     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1396     std_log(LOG_FILENAME_LINE,"START oil_synth_135 TEST");

  1397     test_oil_synth_135();

  1398     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1400     std_log(LOG_FILENAME_LINE,"START oil_synth_53 TEST");

  1401     test_oil_synth_53();

  1402     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1404     std_log(LOG_FILENAME_LINE,"START oil_synth_approx97 TEST");

  1405     test_oil_synth_approx97();

  1406     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1408     std_log(LOG_FILENAME_LINE,"START oil_synth_daub97 TEST");

  1409     test_oil_synth_daub97();

  1410     std_log(LOG_FILENAME_LINE,"END TEST\n");

  1412     if(assert_failed)

  1413       std_log(LOG_FILENAME_LINE,"Test Failed");

  1414     else

  1415       std_log(LOG_FILENAME_LINE,"Test Successful");

  1417     create_xml(0);

  1419     return 0;

  1420     }

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--