/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	653k	IA_ERRORCODE iusace_calc_window(FLOAT64 **win, WORD32 win_sz, WORD32 win_sel) {
30	653k	switch (win_sel) {
31	384k	case WIN_SEL_0:
32	384k	switch (win_sz) {
33	145k	case WIN_LEN_96:
34	145k	win = (FLOAT64 )iexheaac_sine_win_96;
35	145k	break;
36	423	case WIN_LEN_192:
37	423	win = (FLOAT64 )iexheaac_sine_win_192;
38	423	break;
39	228k	case WIN_LEN_128:
40	228k	win = (FLOAT64 )iusace_sine_win_128;
41	228k	break;
42	1.72k	case WIN_LEN_256:
43	1.72k	win = (FLOAT64 )iusace_sine_win_256;
44	1.72k	break;
45	4.06k	case WIN_LEN_768:
46	4.06k	win = (FLOAT64 )iexheaac_sine_win_768;
47	4.06k	break;
48	4.24k	case WIN_LEN_1024:
49	4.24k	win = (FLOAT64 )iusace_sine_win_1024;
50	4.24k	break;
51	0	default:
52	0	return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_WINDOW_LENGTH;
53	0	break;
54	384k	}
55	384k	break;
56	384k	case WIN_SEL_1:
57	269k	switch (win_sz) {
58	1.28k	case WIN_LEN_96:
59	1.28k	win = (FLOAT64 )iexheaac_kbd_win_96;
60	1.28k	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	70.1k	case WIN_LEN_768:
71	70.1k	win = (FLOAT64 )iexheaac_kbd_win_768;
72	70.1k	break;
73	198k	case WIN_LEN_1024:
74	198k	win = (FLOAT64 )iusace_kbd_win1024;
75	198k	break;
76	0	default:
77	0	return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_WINDOW_LENGTH;
78	0	break;
79	269k	}
80	269k	break;
81
82	269k	default:
83	0	return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_WINDOW_SHAPE;
84	0	break;
85	653k	}
86	653k	return IA_NO_ERROR;
87	653k	}
88
89		VOID iusace_windowing_long(FLOAT64 ptr_overlap, FLOAT64 ptr_win_long, FLOAT64 *ptr_win_buf,
90	188k	FLOAT64 *ptr_in_data, WORD32 n_long) {
91	188k	WORD32 i;
92	188k	FLOAT64 *ptr_win = ptr_win_long + n_long - 1;
93	188k	WORD32 data_size = (OVERLAP_WIN_SIZE_576 * n_long) / LEN_SUPERFRAME;
94
95	182M	for (i = 0; i < n_long; i++) {
96	181M	ptr_win_buf[i] = ptr_overlap[i] * ptr_win_long[i];
97	181M	}
98
99	188k	memcpy(ptr_overlap, ptr_overlap + n_long, data_size * sizeof(ptr_overlap[0]));
100	188k	memcpy(ptr_overlap + data_size, ptr_in_data, n_long * sizeof(ptr_overlap[0]));
101
102	182M	for (i = 0; i < n_long; i++) {
103	181M	ptr_win_buf[i + n_long] = ptr_overlap[i] * (*ptr_win--);
104	181M	}
105
106	188k	return;
107	188k	}
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	45.9k	WORD32 nflat_ls, FLOAT64 *ptr_win_med, WORD32 win_sz) {
112	45.9k	WORD32 i;
113	45.9k	FLOAT64 ptr_win = ptr_win_buf + 2 n_long - 1;
114	45.9k	WORD32 data_size = (OVERLAP_WIN_SIZE_576 * n_long) / LEN_SUPERFRAME;
115
116	43.2M	for (i = 0; i < n_long; i++) {
117	43.1M	ptr_win_buf[i] = ptr_overlap[i] * ptr_win_long[i];
118	43.1M	}
119
120	45.9k	memcpy(ptr_overlap, ptr_overlap + n_long, data_size * sizeof(ptr_overlap[0]));
121	45.9k	memcpy(ptr_overlap + data_size, ptr_in_data, n_long * sizeof(ptr_overlap[0]));
122	45.9k	memcpy(ptr_win_buf + n_long, ptr_overlap, nflat_ls * sizeof(ptr_win_buf[0]));
123
124	45.9k	ptr_win_med = ptr_win_med + win_sz - 1;
125	45.9k	win_sz = n_long - 2 * nflat_ls;
126
127	5.68M	for (i = 0; i < win_sz; i++) {
128	5.64M	ptr_win_buf[i + n_long + nflat_ls] = ptr_overlap[i + nflat_ls] * (*ptr_win_med--);
129	5.64M	}
130
131	18.8M	for (i = 0; i < nflat_ls; i++) {
132	18.7M	*ptr_win-- = 0;
133	18.7M	}
134
135	45.9k	return;
136	45.9k	}
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	41.9k	FLOAT64 *ptr_win_med, WORD32 win_sz) {
141	41.9k	WORD32 i;
142	41.9k	FLOAT64 *ptr_win = ptr_win_long + n_long - 1;
143	41.9k	WORD32 data_size = (OVERLAP_WIN_SIZE_576 * n_long) / LEN_SUPERFRAME;
144
145	41.9k	memset(ptr_win_buf, 0, nflat_ls * sizeof(FLOAT64));
146	4.97M	for (i = 0; i < win_sz; i++) {
147	4.93M	ptr_win_buf[i + nflat_ls] = ptr_overlap[i + nflat_ls] * ptr_win_med[i];
148	4.93M	}
149
150	41.9k	memcpy(ptr_win_buf + nflat_ls + win_sz, ptr_overlap + nflat_ls + win_sz,
151	41.9k	nflat_ls * sizeof(ptr_win_buf[0]));
152	41.9k	memcpy(ptr_overlap, ptr_overlap + n_long, data_size * sizeof(ptr_overlap[0]));
153	41.9k	memcpy(ptr_overlap + data_size, ptr_in_data, n_long * sizeof(ptr_overlap[0]));
154
155	39.3M	for (i = 0; i < n_long; i++) {
156	39.3M	ptr_win_buf[i + n_long] = ptr_overlap[i] * (*ptr_win--);
157	39.3M	}
158	41.9k	return;
159	41.9k	}
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-03-31 06:52