/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	683k	IA_ERRORCODE iusace_calc_window(FLOAT64 **win, WORD32 win_sz, WORD32 win_sel) {
30	683k	switch (win_sel) {
31	408k	case WIN_SEL_0:
32	408k	switch (win_sz) {
33	151k	case WIN_LEN_96:
34	151k	win = (FLOAT64 )iexheaac_sine_win_96;
35	151k	break;
36	456	case WIN_LEN_192:
37	456	win = (FLOAT64 )iexheaac_sine_win_192;
38	456	break;
39	247k	case WIN_LEN_128:
40	247k	win = (FLOAT64 )iusace_sine_win_128;
41	247k	break;
42	1.81k	case WIN_LEN_256:
43	1.81k	win = (FLOAT64 )iusace_sine_win_256;
44	1.81k	break;
45	1.88k	case WIN_LEN_768:
46	1.88k	win = (FLOAT64 )iexheaac_sine_win_768;
47	1.88k	break;
48	4.54k	case WIN_LEN_1024:
49	4.54k	win = (FLOAT64 )iusace_sine_win_1024;
50	4.54k	break;
51	0	default:
52	0	return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_WINDOW_LENGTH;
53	0	break;
54	408k	}
55	408k	break;
56	408k	case WIN_SEL_1:
57	275k	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	74.8k	case WIN_LEN_768:
71	74.8k	win = (FLOAT64 )iexheaac_kbd_win_768;
72	74.8k	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	275k	}
80	275k	break;
81
82	275k	default:
83	0	return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_WINDOW_SHAPE;
84	0	break;
85	683k	}
86	683k	return IA_NO_ERROR;
87	683k	}
88
89		VOID iusace_windowing_long(FLOAT64 ptr_overlap, FLOAT64 ptr_win_long, FLOAT64 *ptr_win_buf,
90	185k	FLOAT64 *ptr_in_data, WORD32 n_long) {
91	185k	WORD32 i;
92	185k	FLOAT64 *ptr_win = ptr_win_long + n_long - 1;
93	185k	WORD32 data_size = (OVERLAP_WIN_SIZE_576 * n_long) / LEN_SUPERFRAME;
94
95	178M	for (i = 0; i < n_long; i++) {
96	178M	ptr_win_buf[i] = ptr_overlap[i] * ptr_win_long[i];
97	178M	}
98
99	185k	memcpy(ptr_overlap, ptr_overlap + n_long, data_size * sizeof(ptr_overlap[0]));
100	185k	memcpy(ptr_overlap + data_size, ptr_in_data, n_long * sizeof(ptr_overlap[0]));
101
102	178M	for (i = 0; i < n_long; i++) {
103	178M	ptr_win_buf[i + n_long] = ptr_overlap[i] * (*ptr_win--);
104	178M	}
105
106	185k	return;
107	185k	}
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	49.2k	WORD32 nflat_ls, FLOAT64 *ptr_win_med, WORD32 win_sz) {
112	49.2k	WORD32 i;
113	49.2k	FLOAT64 ptr_win = ptr_win_buf + 2 n_long - 1;
114	49.2k	WORD32 data_size = (OVERLAP_WIN_SIZE_576 * n_long) / LEN_SUPERFRAME;
115
116	46.3M	for (i = 0; i < n_long; i++) {
117	46.3M	ptr_win_buf[i] = ptr_overlap[i] * ptr_win_long[i];
118	46.3M	}
119
120	49.2k	memcpy(ptr_overlap, ptr_overlap + n_long, data_size * sizeof(ptr_overlap[0]));
121	49.2k	memcpy(ptr_overlap + data_size, ptr_in_data, n_long * sizeof(ptr_overlap[0]));
122	49.2k	memcpy(ptr_win_buf + n_long, ptr_overlap, nflat_ls * sizeof(ptr_win_buf[0]));
123
124	49.2k	ptr_win_med = ptr_win_med + win_sz - 1;
125	49.2k	win_sz = n_long - 2 * nflat_ls;
126
127	6.09M	for (i = 0; i < win_sz; i++) {
128	6.04M	ptr_win_buf[i + n_long + nflat_ls] = ptr_overlap[i + nflat_ls] * (*ptr_win_med--);
129	6.04M	}
130
131	20.1M	for (i = 0; i < nflat_ls; i++) {
132	20.1M	*ptr_win-- = 0;
133	20.1M	}
134
135	49.2k	return;
136	49.2k	}
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	44.9k	FLOAT64 *ptr_win_med, WORD32 win_sz) {
141	44.9k	WORD32 i;
142	44.9k	FLOAT64 *ptr_win = ptr_win_long + n_long - 1;
143	44.9k	WORD32 data_size = (OVERLAP_WIN_SIZE_576 * n_long) / LEN_SUPERFRAME;
144
145	44.9k	memset(ptr_win_buf, 0, nflat_ls * sizeof(FLOAT64));
146	5.33M	for (i = 0; i < win_sz; i++) {
147	5.28M	ptr_win_buf[i + nflat_ls] = ptr_overlap[i + nflat_ls] * ptr_win_med[i];
148	5.28M	}
149
150	44.9k	memcpy(ptr_win_buf + nflat_ls + win_sz, ptr_overlap + nflat_ls + win_sz,
151	44.9k	nflat_ls * sizeof(ptr_win_buf[0]));
152	44.9k	memcpy(ptr_overlap, ptr_overlap + n_long, data_size * sizeof(ptr_overlap[0]));
153	44.9k	memcpy(ptr_overlap + data_size, ptr_in_data, n_long * sizeof(ptr_overlap[0]));
154
155	42.2M	for (i = 0; i < n_long; i++) {
156	42.1M	ptr_win_buf[i + n_long] = ptr_overlap[i] * (*ptr_win--);
157	42.1M	}
158	44.9k	return;
159	44.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-02-07 06:17