/src/libxaac/encoder/iusace_windowing.c

Source
/******************************************************************************
 *                                                                            *
 * Copyright (C) 2023 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *****************************************************************************
 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
 */

#include <string.h>
#include "ixheaac_error_standards.h"
#include "ixheaac_type_def.h"
#include "iusace_cnst.h"
#include "iusace_block_switch_const.h"
#include "iusace_rom.h"
#include "ixheaace_error_codes.h"

IA_ERRORCODE iusace_calc_window(FLOAT64 **win, WORD32 win_sz, WORD32 win_sel) {
  switch (win_sel) {
    case WIN_SEL_0:
      switch (win_sz) {
        case WIN_LEN_96:
          *win = (FLOAT64 *)iexheaac_sine_win_96;
          break;
        case WIN_LEN_192:
          *win = (FLOAT64 *)iexheaac_sine_win_192;
          break;
        case WIN_LEN_128:
          *win = (FLOAT64 *)iusace_sine_win_128;
          break;
        case WIN_LEN_256:
          *win = (FLOAT64 *)iusace_sine_win_256;
          break;
        case WIN_LEN_768:
          *win = (FLOAT64 *)iexheaac_sine_win_768;
          break;
        case WIN_LEN_1024:
          *win = (FLOAT64 *)iusace_sine_win_1024;
          break;
        default:
          return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_WINDOW_LENGTH;
          break;
      }
      break;
    case WIN_SEL_1:
      switch (win_sz) {
        case WIN_LEN_96:
          *win = (FLOAT64 *)iexheaac_kbd_win_96;
          break;
        case WIN_LEN_128:
          *win = (FLOAT64 *)iusace_sine_win_128;
          break;
        case WIN_LEN_192:
          *win = (FLOAT64 *)iexheaac_kbd_win_192;
          break;
        case WIN_LEN_256:
          *win = (FLOAT64 *)iusace_kbd_win256;
          break;
        case WIN_LEN_768:
          *win = (FLOAT64 *)iexheaac_kbd_win_768;
          break;
        case WIN_LEN_1024:
          *win = (FLOAT64 *)iusace_kbd_win1024;
          break;
        default:
          return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_WINDOW_LENGTH;
          break;
      }
      break;

    default:
      return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_WINDOW_SHAPE;
      break;
  }
  return IA_NO_ERROR;
}

VOID iusace_windowing_long(FLOAT64 *ptr_overlap, FLOAT64 *ptr_win_long, FLOAT64 *ptr_win_buf,
                           FLOAT64 *ptr_in_data, WORD32 n_long) {
  WORD32 i;
  FLOAT64 *ptr_win = ptr_win_long + n_long - 1;
  WORD32 data_size = (OVERLAP_WIN_SIZE_576 * n_long) / LEN_SUPERFRAME;

  for (i = 0; i < n_long; i++) {
    ptr_win_buf[i] = ptr_overlap[i] * ptr_win_long[i];
  }

  memcpy(ptr_overlap, ptr_overlap + n_long, data_size * sizeof(ptr_overlap[0]));
  memcpy(ptr_overlap + data_size, ptr_in_data, n_long * sizeof(ptr_overlap[0]));

  for (i = 0; i < n_long; i++) {
    ptr_win_buf[i + n_long] = ptr_overlap[i] * (*ptr_win--);
  }

  return;
}

VOID iusace_windowing_long_start(FLOAT64 *ptr_overlap, FLOAT64 *ptr_win_long,
                                 FLOAT64 *ptr_win_buf, FLOAT64 *ptr_in_data, WORD32 n_long,
                                 WORD32 nflat_ls, FLOAT64 *ptr_win_med, WORD32 win_sz) {
  WORD32 i;
  FLOAT64 *ptr_win = ptr_win_buf + 2 * n_long - 1;
  WORD32 data_size = (OVERLAP_WIN_SIZE_576 * n_long) / LEN_SUPERFRAME;

  for (i = 0; i < n_long; i++) {
    ptr_win_buf[i] = ptr_overlap[i] * ptr_win_long[i];
  }

  memcpy(ptr_overlap, ptr_overlap + n_long, data_size * sizeof(ptr_overlap[0]));
  memcpy(ptr_overlap + data_size, ptr_in_data, n_long * sizeof(ptr_overlap[0]));
  memcpy(ptr_win_buf + n_long, ptr_overlap, nflat_ls * sizeof(ptr_win_buf[0]));

  ptr_win_med = ptr_win_med + win_sz - 1;
  win_sz = n_long - 2 * nflat_ls;

  for (i = 0; i < win_sz; i++) {
    ptr_win_buf[i + n_long + nflat_ls] = ptr_overlap[i + nflat_ls] * (*ptr_win_med--);
  }

  for (i = 0; i < nflat_ls; i++) {
    *ptr_win-- = 0;
  }

  return;
}

VOID iusace_windowing_long_stop(FLOAT64 *ptr_overlap, FLOAT64 *ptr_win_long, FLOAT64 *ptr_win_buf,
                                FLOAT64 *ptr_in_data, WORD32 n_long, WORD32 nflat_ls,
                                FLOAT64 *ptr_win_med, WORD32 win_sz) {
  WORD32 i;
  FLOAT64 *ptr_win = ptr_win_long + n_long - 1;
  WORD32 data_size = (OVERLAP_WIN_SIZE_576 * n_long) / LEN_SUPERFRAME;

  memset(ptr_win_buf, 0, nflat_ls * sizeof(FLOAT64));
  for (i = 0; i < win_sz; i++) {
    ptr_win_buf[i + nflat_ls] = ptr_overlap[i + nflat_ls] * ptr_win_med[i];
  }

  memcpy(ptr_win_buf + nflat_ls + win_sz, ptr_overlap + nflat_ls + win_sz,
         nflat_ls * sizeof(ptr_win_buf[0]));
  memcpy(ptr_overlap, ptr_overlap + n_long, data_size * sizeof(ptr_overlap[0]));
  memcpy(ptr_overlap + data_size, ptr_in_data, n_long * sizeof(ptr_overlap[0]));

  for (i = 0; i < n_long; i++) {
    ptr_win_buf[i + n_long] = ptr_overlap[i] * (*ptr_win--);
  }
  return;
}

VOID iusace_windowing_stop_start(FLOAT64 *ptr_overlap, FLOAT64 *ptr_win_buf, FLOAT64 *ptr_win_med,
                                 WORD32 win_sz, WORD32 n_long) {
  WORD32 i;
  FLOAT64 *win_gen;
  WORD32 wsize = (n_long - win_sz) >> 1;
  win_gen = ptr_win_med;

  for (i = 0; i < win_sz; i++) {
    ptr_win_buf[wsize + i] = ptr_overlap[wsize + i] * (*win_gen++);
  }
  memcpy(ptr_win_buf + wsize, ptr_overlap + wsize, wsize * sizeof(FLOAT64));
  memcpy(ptr_win_buf + n_long, ptr_overlap + n_long, wsize * sizeof(FLOAT64));

  win_gen = ptr_win_med + win_sz - 1;
  win_sz = n_long - 2 * wsize;

  for (i = 0; i < win_sz; i++) {
    ptr_win_buf[n_long + wsize + i] = ptr_overlap[n_long + wsize + i] * (*win_gen--);
  }
  return;
}

Line	Count	Source
1		/******************************************************************************
2		* *
3		* Copyright (C) 2023 The Android Open Source Project
4		*
5		* Licensed under the Apache License, Version 2.0 (the "License");
6		* you may not use this file except in compliance with the License.
7		* You may obtain a copy of the License at:
8		*
9		* http://www.apache.org/licenses/LICENSE-2.0
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*
17		*****************************************************************************
18		* Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore
19		*/
20
21		#include <string.h>
22		#include "ixheaac_error_standards.h"
23		#include "ixheaac_type_def.h"
24		#include "iusace_cnst.h"
25		#include "iusace_block_switch_const.h"
26		#include "iusace_rom.h"
27		#include "ixheaace_error_codes.h"
28
29	640k	IA_ERRORCODE iusace_calc_window(FLOAT64 **win, WORD32 win_sz, WORD32 win_sel) {
30	640k	switch (win_sel) {
31	369k	case WIN_SEL_0:
32	369k	switch (win_sz) {
33	116k	case WIN_LEN_96:
34	116k	win = (FLOAT64 )iexheaac_sine_win_96;
35	116k	break;
36	406	case WIN_LEN_192:
37	406	win = (FLOAT64 )iexheaac_sine_win_192;
38	406	break;
39	241k	case WIN_LEN_128:
40	241k	win = (FLOAT64 )iusace_sine_win_128;
41	241k	break;
42	1.73k	case WIN_LEN_256:
43	1.73k	win = (FLOAT64 )iusace_sine_win_256;
44	1.73k	break;
45	4.62k	case WIN_LEN_768:
46	4.62k	win = (FLOAT64 )iexheaac_sine_win_768;
47	4.62k	break;
48	4.42k	case WIN_LEN_1024:
49	4.42k	win = (FLOAT64 )iusace_sine_win_1024;
50	4.42k	break;
51	0	default:
52	0	return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_WINDOW_LENGTH;
53	0	break;
54	369k	}
55	369k	break;
56	369k	case WIN_SEL_1:
57	271k	switch (win_sz) {
58	1.29k	case WIN_LEN_96:
59	1.29k	win = (FLOAT64 )iexheaac_kbd_win_96;
60	1.29k	break;
61	0	case WIN_LEN_128:
62	0	win = (FLOAT64 )iusace_sine_win_128;
63	0	break;
64	0	case WIN_LEN_192:
65	0	win = (FLOAT64 )iexheaac_kbd_win_192;
66	0	break;
67	0	case WIN_LEN_256:
68	0	win = (FLOAT64 )iusace_kbd_win256;
69	0	break;
70	54.1k	case WIN_LEN_768:
71	54.1k	win = (FLOAT64 )iexheaac_kbd_win_768;
72	54.1k	break;
73	215k	case WIN_LEN_1024:
74	215k	win = (FLOAT64 )iusace_kbd_win1024;
75	215k	break;
76	0	default:
77	0	return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_WINDOW_LENGTH;
78	0	break;
79	271k	}
80	271k	break;
81
82	271k	default:
83	0	return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_WINDOW_SHAPE;
84	0	break;
85	640k	}
86	640k	return IA_NO_ERROR;
87	640k	}
88
89		VOID iusace_windowing_long(FLOAT64 ptr_overlap, FLOAT64 ptr_win_long, FLOAT64 *ptr_win_buf,
90	193k	FLOAT64 *ptr_in_data, WORD32 n_long) {
91	193k	WORD32 i;
92	193k	FLOAT64 *ptr_win = ptr_win_long + n_long - 1;
93	193k	WORD32 data_size = (OVERLAP_WIN_SIZE_576 * n_long) / LEN_SUPERFRAME;
94
95	189M	for (i = 0; i < n_long; i++) {
96	189M	ptr_win_buf[i] = ptr_overlap[i] * ptr_win_long[i];
97	189M	}
98
99	193k	memcpy(ptr_overlap, ptr_overlap + n_long, data_size * sizeof(ptr_overlap[0]));
100	193k	memcpy(ptr_overlap + data_size, ptr_in_data, n_long * sizeof(ptr_overlap[0]));
101
102	189M	for (i = 0; i < n_long; i++) {
103	189M	ptr_win_buf[i + n_long] = ptr_overlap[i] * (*ptr_win--);
104	189M	}
105
106	193k	return;
107	193k	}
108
109		VOID iusace_windowing_long_start(FLOAT64 ptr_overlap, FLOAT64 ptr_win_long,
110		FLOAT64 ptr_win_buf, FLOAT64 ptr_in_data, WORD32 n_long,
111	44.6k	WORD32 nflat_ls, FLOAT64 *ptr_win_med, WORD32 win_sz) {
112	44.6k	WORD32 i;
113	44.6k	FLOAT64 ptr_win = ptr_win_buf + 2 n_long - 1;
114	44.6k	WORD32 data_size = (OVERLAP_WIN_SIZE_576 * n_long) / LEN_SUPERFRAME;
115
116	42.7M	for (i = 0; i < n_long; i++) {
117	42.6M	ptr_win_buf[i] = ptr_overlap[i] * ptr_win_long[i];
118	42.6M	}
119
120	44.6k	memcpy(ptr_overlap, ptr_overlap + n_long, data_size * sizeof(ptr_overlap[0]));
121	44.6k	memcpy(ptr_overlap + data_size, ptr_in_data, n_long * sizeof(ptr_overlap[0]));
122	44.6k	memcpy(ptr_win_buf + n_long, ptr_overlap, nflat_ls * sizeof(ptr_win_buf[0]));
123
124	44.6k	ptr_win_med = ptr_win_med + win_sz - 1;
125	44.6k	win_sz = n_long - 2 * nflat_ls;
126
127	5.60M	for (i = 0; i < win_sz; i++) {
128	5.56M	ptr_win_buf[i + n_long + nflat_ls] = ptr_overlap[i + nflat_ls] * (*ptr_win_med--);
129	5.56M	}
130
131	18.5M	for (i = 0; i < nflat_ls; i++) {
132	18.5M	*ptr_win-- = 0;
133	18.5M	}
134
135	44.6k	return;
136	44.6k	}
137
138		VOID iusace_windowing_long_stop(FLOAT64 ptr_overlap, FLOAT64 ptr_win_long, FLOAT64 *ptr_win_buf,
139		FLOAT64 *ptr_in_data, WORD32 n_long, WORD32 nflat_ls,
140	40.6k	FLOAT64 *ptr_win_med, WORD32 win_sz) {
141	40.6k	WORD32 i;
142	40.6k	FLOAT64 *ptr_win = ptr_win_long + n_long - 1;
143	40.6k	WORD32 data_size = (OVERLAP_WIN_SIZE_576 * n_long) / LEN_SUPERFRAME;
144
145	40.6k	memset(ptr_win_buf, 0, nflat_ls * sizeof(FLOAT64));
146	4.92M	for (i = 0; i < win_sz; i++) {
147	4.88M	ptr_win_buf[i + nflat_ls] = ptr_overlap[i + nflat_ls] * ptr_win_med[i];
148	4.88M	}
149
150	40.6k	memcpy(ptr_win_buf + nflat_ls + win_sz, ptr_overlap + nflat_ls + win_sz,
151	40.6k	nflat_ls * sizeof(ptr_win_buf[0]));
152	40.6k	memcpy(ptr_overlap, ptr_overlap + n_long, data_size * sizeof(ptr_overlap[0]));
153	40.6k	memcpy(ptr_overlap + data_size, ptr_in_data, n_long * sizeof(ptr_overlap[0]));
154
155	38.8M	for (i = 0; i < n_long; i++) {
156	38.7M	ptr_win_buf[i + n_long] = ptr_overlap[i] * (*ptr_win--);
157	38.7M	}
158	40.6k	return;
159	40.6k	}
160
161		VOID iusace_windowing_stop_start(FLOAT64 ptr_overlap, FLOAT64 ptr_win_buf, FLOAT64 *ptr_win_med,
162	0	WORD32 win_sz, WORD32 n_long) {
163	0	WORD32 i;
164	0	FLOAT64 *win_gen;
165	0	WORD32 wsize = (n_long - win_sz) >> 1;
166	0	win_gen = ptr_win_med;
167
168	0	for (i = 0; i < win_sz; i++) {
169	0	ptr_win_buf[wsize + i] = ptr_overlap[wsize + i] * (*win_gen++);
170	0	}
171	0	memcpy(ptr_win_buf + wsize, ptr_overlap + wsize, wsize * sizeof(FLOAT64));
172	0	memcpy(ptr_win_buf + n_long, ptr_overlap + n_long, wsize * sizeof(FLOAT64));
173
174	0	win_gen = ptr_win_med + win_sz - 1;
175	0	win_sz = n_long - 2 * wsize;
176
177	0	for (i = 0; i < win_sz; i++) {
178	0	ptr_win_buf[n_long + wsize + i] = ptr_overlap[n_long + wsize + i] * (*win_gen--);
179	0	}
180	0	return;
181	0	}

Coverage Report

Created: 2026-08-13 06:34