LCOV - code coverage report
Current view: top level - lib_com - tcx_mdct_window.c (source / functions) Hit Total Coverage
Test: Coverage on main -- conformance test test_26252.py @ a21f94bc6bac334fe001a5bad2f7b32b79038097 Lines: 106 115 92.2 %
Date: 2025-11-01 05:07:43 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      575342 : 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      575342 :     if ( element_mode == EVS_MONO )
      62             :     {
      63             :         int16_t i;
      64             :         float c;
      65             : 
      66        1038 :         c = EVS_PI / ( 2.0f * (float) n );
      67             : 
      68      139374 :         for ( i = 0; i < n; i++ )
      69             :         {
      70      138336 :             window[i] = (float) sin( c * ( 0.5f + (float) i ) );
      71             :         }
      72             :     }
      73             :     else
      74             :     {
      75      574304 :         const float *window_table = 0;
      76      574304 :         int16_t buf_in_size = 0;
      77      574304 :         switch ( window_type )
      78             :         {
      79      324150 :             case FULL_OVERLAP:
      80      324150 :                 window_table = tcx_mdct_window_48;
      81      324150 :                 buf_in_size = 420;
      82      324150 :                 break;
      83      125077 :             case HALF_OVERLAP:
      84      125077 :                 window_table = tcx_mdct_window_half_48;
      85      125077 :                 buf_in_size = 180;
      86      125077 :                 break;
      87      125077 :             case TRANSITION_OVERLAP:
      88             :             case MIN_OVERLAP:
      89      125077 :                 window_table = tcx_mdct_window_trans_48;
      90      125077 :                 buf_in_size = 60;
      91      125077 :                 break;
      92             : 
      93           0 :             default:
      94           0 :                 assert( 0 && "Unsupported window type" );
      95             :                 break;
      96             :         }
      97             : 
      98      574304 :         if ( Fs == 48000 )
      99             :         {
     100      154967 :             mvr2r( window_table, window, n );
     101             :         }
     102             :         else
     103             :         {
     104      419337 :             lerp( window_table, window, n, buf_in_size );
     105             :         }
     106             :     }
     107             : 
     108      575342 :     return;
     109             : }
     110             : 
     111             : 
     112             : /*-------------------------------------------------------------------
     113             :  * mdct_window_aldo()
     114             :  *
     115             :  *
     116             :  *-------------------------------------------------------------------*/
     117             : 
     118      129358 : 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      129358 :     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       13227 :         case 512 / 2:
     135       13227 :             p1 = window_256kHz;
     136       13227 :             p2 = window_256kHz + 592 - 1;
     137       13227 :             d = 2;
     138       13227 :             break;
     139       22668 :         case 640 / 2:
     140       22668 :             p1 = window_48kHz + 1;
     141       22668 :             p2 = window_48kHz + 1110 - 2;
     142       22668 :             d = 3;
     143       22668 :             break;
     144       16815 :         case 1024 / 2:
     145       16815 :             p1 = window_256kHz;
     146       16815 :             p2 = window_256kHz + 592 - 1;
     147       16815 :             d = 1;
     148       16815 :             break;
     149       24998 :         case 1280 / 2:
     150       24998 :             p1 = window_48kHz + 1;
     151       24998 :             p2 = window_48kHz + 1110 - 2;
     152       24998 :             d = 3;
     153       24998 :             break;
     154       51650 :         case 1920 / 2:
     155       51650 :             p1 = window_48kHz;
     156       51650 :             p2 = window_48kHz + 1110 - 1;
     157       51650 :             d = 1;
     158       51650 :             break;
     159           0 :         default:
     160           0 :             assert( 0 );
     161             :             return;
     162             :     }
     163             : 
     164             :     /* set lengths */
     165      129358 :     n1 = n * 23 / 32; /* left slope length */
     166      129358 :     n2 = n * 14 / 32; /* right slope length */
     167             : 
     168             :     /* first part (long slope) */
     169      129358 :     if ( n != 1280 / 2 )
     170             :     {
     171    34520936 :         for ( i = 0; i < n / 2; i++ )
     172             :         {
     173    34416576 :             *window1 = *p1;
     174    34416576 :             window1++;
     175    34416576 :             p1 += d;
     176             :         }
     177             : 
     178      104360 :         if ( ( n == 512 / 2 ) || ( n == 320 / 2 ) )
     179       13227 :             p1++;
     180             : 
     181    15161612 :         for ( ; i < n1; i++ )
     182             :         {
     183    15057252 :             *window1 = *p1;
     184    15057252 :             window1++;
     185    15057252 :             p1 += d;
     186             :         }
     187             :     }
     188             :     else
     189             :     {
     190       24998 :         const float *pi = window_8_16_32kHz;
     191             : 
     192     4024678 :         for ( i = 0; i < n / 2; i += 2 )
     193             :         {
     194     3999680 :             *window1 = *p1;
     195     3999680 :             window1++;
     196     3999680 :             p1 += d;
     197             : 
     198     3999680 :             *window1 = *pi;
     199     3999680 :             window1++;
     200     3999680 :             pi++;
     201             :         }
     202     1774858 :         for ( ; i < n1; i += 2 )
     203             :         {
     204     1749860 :             *window1 = *pi;
     205     1749860 :             window1++;
     206     1749860 :             pi++;
     207             : 
     208     1749860 :             *window1 = *p1;
     209     1749860 :             window1++;
     210     1749860 :             p1 += d;
     211             :         }
     212             :     }
     213             : 
     214             :     /* second part (short slope) */
     215             : 
     216      129358 :     if ( n != 1280 / 2 )
     217             :     {
     218    15161612 :         for ( i = 0; i < n2 / 2; i++ )
     219             :         {
     220    15057252 :             *window2 = *p2;
     221    15057252 :             window2++;
     222    15057252 :             p2 -= d;
     223             :         }
     224             : 
     225      104360 :         if ( ( n == 512 / 2 ) || ( n == 320 / 2 ) )
     226       13227 :             p2--;
     227             : 
     228    15161612 :         for ( ; i < n2; i++ )
     229             :         {
     230    15057252 :             *window2 = *p2;
     231    15057252 :             window2++;
     232    15057252 :             p2 -= d;
     233             :         }
     234             :     }
     235             :     else
     236             :     {
     237       24998 :         const float *pi = window_8_16_32kHz + 370 - 1;
     238             : 
     239     1774858 :         for ( i = 0; i < n2 / 2; i += 2 )
     240             :         {
     241     1749860 :             *window2 = *p2;
     242     1749860 :             window2++;
     243     1749860 :             p2 -= d;
     244             : 
     245     1749860 :             *window2 = *pi;
     246     1749860 :             window2++;
     247     1749860 :             pi--;
     248             :         }
     249             : 
     250     1774858 :         for ( ; i < n2; i += 2 )
     251             :         {
     252     1749860 :             *window2 = *pi;
     253     1749860 :             window2++;
     254     1749860 :             pi--;
     255             : 
     256     1749860 :             *window2 = *p2;
     257     1749860 :             window2++;
     258     1749860 :             p2 -= d;
     259             :         }
     260             :     }
     261             : 
     262      129358 :     return;
     263             : }

Generated by: LCOV version 1.14