LCOV - code coverage report
Current view: top level - lib_com - tcx_mdct_window.c (source / functions) Hit Total Coverage
Test: Coverage on main -- short test vectors @ 6c9ddc4024a9c0e1ecb8f643f114a84a0e26ec6b Lines: 106 115 92.2 %
Date: 2025-05-23 08:37:30 Functions: 2 2 100.0 %

          Line data    Source code
       1             : /******************************************************************************************************
       2             : 
       3             :    (C) 2022-2025 IVAS codec Public Collaboration with portions copyright Dolby International AB, Ericsson AB,
       4             :    Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
       5             :    Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
       6             :    Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
       7             :    contributors to this repository. All Rights Reserved.
       8             : 
       9             :    This software is protected by copyright law and by international treaties.
      10             :    The IVAS codec Public Collaboration consisting of Dolby International AB, Ericsson AB,
      11             :    Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V., Huawei Technologies Co. LTD.,
      12             :    Koninklijke Philips N.V., Nippon Telegraph and Telephone Corporation, Nokia Technologies Oy, Orange,
      13             :    Panasonic Holdings Corporation, Qualcomm Technologies, Inc., VoiceAge Corporation, and other
      14             :    contributors to this repository retain full ownership rights in their respective contributions in
      15             :    the software. This notice grants no license of any kind, including but not limited to patent
      16             :    license, nor is any license granted by implication, estoppel or otherwise.
      17             : 
      18             :    Contributors are required to enter into the IVAS codec Public Collaboration agreement before making
      19             :    contributions.
      20             : 
      21             :    This software is provided "AS IS", without any express or implied warranties. The software is in the
      22             :    development stage. It is intended exclusively for experts who have experience with such software and
      23             :    solely for the purpose of inspection. All implied warranties of non-infringement, merchantability
      24             :    and fitness for a particular purpose are hereby disclaimed and excluded.
      25             : 
      26             :    Any dispute, controversy or claim arising under or in relation to providing this software shall be
      27             :    submitted to and settled by the final, binding jurisdiction of the courts of Munich, Germany in
      28             :    accordance with the laws of the Federal Republic of Germany excluding its conflict of law rules and
      29             :    the United Nations Convention on Contracts on the International Sales of Goods.
      30             : 
      31             : *******************************************************************************************************/
      32             : 
      33             : /*====================================================================================
      34             :     EVS Codec 3GPP TS26.443 Nov 04, 2021. Version 12.14.0 / 13.10.0 / 14.6.0 / 15.4.0 / 16.3.0
      35             :   ====================================================================================*/
      36             : 
      37             : #include <assert.h>
      38             : #include <stdint.h>
      39             : #include "options.h"
      40             : #ifdef DEBUGGING
      41             : #include "debug.h"
      42             : #endif
      43             : #include <math.h>
      44             : #include "cnst.h"
      45             : #include "prot.h"
      46             : #include "rom_com.h"
      47             : #include "wmc_auto.h"
      48             : 
      49             : /*-------------------------------------------------------------------
      50             :  * mdct_window_sine()
      51             :  *
      52             :  *
      53             :  *-------------------------------------------------------------------*/
      54     1044098 : void mdct_window_sine(
      55             :     float *window,
      56             :     const int32_t Fs,
      57             :     const int16_t n,
      58             :     const int16_t window_type,
      59             :     const int16_t element_mode )
      60             : {
      61     1044098 :     if ( element_mode == EVS_MONO )
      62             :     {
      63             :         int16_t i;
      64             :         float c;
      65             : 
      66        1344 :         c = EVS_PI / ( 2.0f * (float) n );
      67             : 
      68      171932 :         for ( i = 0; i < n; i++ )
      69             :         {
      70      170588 :             window[i] = (float) sin( c * ( 0.5f + (float) i ) );
      71             :         }
      72             :     }
      73             :     else
      74             :     {
      75     1042754 :         const float *window_table = 0;
      76     1042754 :         int16_t buf_in_size = 0;
      77     1042754 :         switch ( window_type )
      78             :         {
      79      557502 :             case FULL_OVERLAP:
      80      557502 :                 window_table = tcx_mdct_window_48;
      81      557502 :                 buf_in_size = 420;
      82      557502 :                 break;
      83      242626 :             case HALF_OVERLAP:
      84      242626 :                 window_table = tcx_mdct_window_half_48;
      85      242626 :                 buf_in_size = 180;
      86      242626 :                 break;
      87      242626 :             case TRANSITION_OVERLAP:
      88             :             case MIN_OVERLAP:
      89      242626 :                 window_table = tcx_mdct_window_trans_48;
      90      242626 :                 buf_in_size = 60;
      91      242626 :                 break;
      92             : 
      93           0 :             default:
      94           0 :                 assert( 0 && "Unsupported window type" );
      95             :                 break;
      96             :         }
      97             : 
      98     1042754 :         if ( Fs == 48000 )
      99             :         {
     100      286233 :             mvr2r( window_table, window, n );
     101             :         }
     102             :         else
     103             :         {
     104      756521 :             lerp( window_table, window, n, buf_in_size );
     105             :         }
     106             :     }
     107             : 
     108     1044098 :     return;
     109             : }
     110             : 
     111             : 
     112             : /*-------------------------------------------------------------------
     113             :  * mdct_window_aldo()
     114             :  *
     115             :  *
     116             :  *-------------------------------------------------------------------*/
     117             : 
     118      251060 : void mdct_window_aldo(
     119             :     float *window1,
     120             :     float *window2,
     121             :     const int16_t n )
     122             : {
     123             :     int16_t i, n1, n2, d;
     124             :     const float *p1, *p2;
     125             : 
     126             :     /* set table pointers and decimation factor */
     127      251060 :     switch ( n )
     128             :     {
     129           0 :         case 320 / 2:
     130           0 :             p1 = window_48kHz + 2;
     131           0 :             p2 = window_48kHz + 1110 - 3;
     132           0 :             d = 6;
     133           0 :             break;
     134       29121 :         case 512 / 2:
     135       29121 :             p1 = window_256kHz;
     136       29121 :             p2 = window_256kHz + 592 - 1;
     137       29121 :             d = 2;
     138       29121 :             break;
     139       43795 :         case 640 / 2:
     140       43795 :             p1 = window_48kHz + 1;
     141       43795 :             p2 = window_48kHz + 1110 - 2;
     142       43795 :             d = 3;
     143       43795 :             break;
     144       33582 :         case 1024 / 2:
     145       33582 :             p1 = window_256kHz;
     146       33582 :             p2 = window_256kHz + 592 - 1;
     147       33582 :             d = 1;
     148       33582 :             break;
     149       49257 :         case 1280 / 2:
     150       49257 :             p1 = window_48kHz + 1;
     151       49257 :             p2 = window_48kHz + 1110 - 2;
     152       49257 :             d = 3;
     153       49257 :             break;
     154       95305 :         case 1920 / 2:
     155       95305 :             p1 = window_48kHz;
     156       95305 :             p2 = window_48kHz + 1110 - 1;
     157       95305 :             d = 1;
     158       95305 :             break;
     159           0 :         default:
     160           0 :             assert( 0 );
     161             :             return;
     162             :     }
     163             : 
     164             :     /* set lengths */
     165      251060 :     n1 = n * 23 / 32; /* left slope length */
     166      251060 :     n2 = n * 14 / 32; /* right slope length */
     167             : 
     168             :     /* first part (long slope) */
     169      251060 :     if ( n != 1280 / 2 )
     170             :     {
     171    65279883 :         for ( i = 0; i < n / 2; i++ )
     172             :         {
     173    65078080 :             *window1 = *p1;
     174    65078080 :             window1++;
     175    65078080 :             p1 += d;
     176             :         }
     177             : 
     178      201803 :         if ( ( n == 512 / 2 ) || ( n == 320 / 2 ) )
     179       29121 :             p1++;
     180             : 
     181    28673463 :         for ( ; i < n1; i++ )
     182             :         {
     183    28471660 :             *window1 = *p1;
     184    28471660 :             window1++;
     185    28471660 :             p1 += d;
     186             :         }
     187             :     }
     188             :     else
     189             :     {
     190       49257 :         const float *pi = window_8_16_32kHz;
     191             : 
     192     7930377 :         for ( i = 0; i < n / 2; i += 2 )
     193             :         {
     194     7881120 :             *window1 = *p1;
     195     7881120 :             window1++;
     196     7881120 :             p1 += d;
     197             : 
     198     7881120 :             *window1 = *pi;
     199     7881120 :             window1++;
     200     7881120 :             pi++;
     201             :         }
     202     3497247 :         for ( ; i < n1; i += 2 )
     203             :         {
     204     3447990 :             *window1 = *pi;
     205     3447990 :             window1++;
     206     3447990 :             pi++;
     207             : 
     208     3447990 :             *window1 = *p1;
     209     3447990 :             window1++;
     210     3447990 :             p1 += d;
     211             :         }
     212             :     }
     213             : 
     214             :     /* second part (short slope) */
     215             : 
     216      251060 :     if ( n != 1280 / 2 )
     217             :     {
     218    28673463 :         for ( i = 0; i < n2 / 2; i++ )
     219             :         {
     220    28471660 :             *window2 = *p2;
     221    28471660 :             window2++;
     222    28471660 :             p2 -= d;
     223             :         }
     224             : 
     225      201803 :         if ( ( n == 512 / 2 ) || ( n == 320 / 2 ) )
     226       29121 :             p2--;
     227             : 
     228    28673463 :         for ( ; i < n2; i++ )
     229             :         {
     230    28471660 :             *window2 = *p2;
     231    28471660 :             window2++;
     232    28471660 :             p2 -= d;
     233             :         }
     234             :     }
     235             :     else
     236             :     {
     237       49257 :         const float *pi = window_8_16_32kHz + 370 - 1;
     238             : 
     239     3497247 :         for ( i = 0; i < n2 / 2; i += 2 )
     240             :         {
     241     3447990 :             *window2 = *p2;
     242     3447990 :             window2++;
     243     3447990 :             p2 -= d;
     244             : 
     245     3447990 :             *window2 = *pi;
     246     3447990 :             window2++;
     247     3447990 :             pi--;
     248             :         }
     249             : 
     250     3497247 :         for ( ; i < n2; i += 2 )
     251             :         {
     252     3447990 :             *window2 = *pi;
     253     3447990 :             window2++;
     254     3447990 :             pi--;
     255             : 
     256     3447990 :             *window2 = *p2;
     257     3447990 :             window2++;
     258     3447990 :             p2 -= d;
     259             :         }
     260             :     }
     261             : 
     262      251060 :     return;
     263             : }

Generated by: LCOV version 1.14