/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	702k	IA_ERRORCODE iusace_calc_window(FLOAT64 **win, WORD32 win_sz, WORD32 win_sel) {
30	702k	switch (win_sel) {
31	417k	case WIN_SEL_0:
32	417k	switch (win_sz) {
33	162k	case WIN_LEN_96:
34	162k	win = (FLOAT64 )iexheaac_sine_win_96;
35	162k	break;
36	503	case WIN_LEN_192:
37	503	win = (FLOAT64 )iexheaac_sine_win_192;
38	503	break;
39	245k	case WIN_LEN_128:
40	245k	win = (FLOAT64 )iusace_sine_win_128;
41	245k	break;
42	1.95k	case WIN_LEN_256:
43	1.95k	win = (FLOAT64 )iusace_sine_win_256;
44	1.95k	break;
45	2.04k	case WIN_LEN_768:
46	2.04k	win = (FLOAT64 )iexheaac_sine_win_768;
47	2.04k	break;
48	4.84k	case WIN_LEN_1024:
49	4.84k	win = (FLOAT64 )iusace_sine_win_1024;
50	4.84k	break;
51	0	default:
52	0	return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_WINDOW_LENGTH;
53	0	break;
54	417k	}
55	417k	break;
56	417k	case WIN_SEL_1:
57	285k	switch (win_sz) {
58	22	case WIN_LEN_96:
59	22	win = (FLOAT64 )iexheaac_kbd_win_96;
60	22	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	83.7k	case WIN_LEN_768:
71	83.7k	win = (FLOAT64 )iexheaac_kbd_win_768;
72	83.7k	break;
73	202k	case WIN_LEN_1024:
74	202k	win = (FLOAT64 )iusace_kbd_win1024;
75	202k	break;
76	0	default:
77	0	return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_WINDOW_LENGTH;
78	0	break;
79	285k	}
80	285k	break;
81
82	285k	default:
83	0	return IA_EXHEAACE_EXE_FATAL_USAC_INVALID_WINDOW_SHAPE;
84	0	break;
85	702k	}
86	702k	return IA_NO_ERROR;
87	702k	}
88
89		VOID iusace_windowing_long(FLOAT64 ptr_overlap, FLOAT64 ptr_win_long, FLOAT64 *ptr_win_buf,
90	192k	FLOAT64 *ptr_in_data, WORD32 n_long) {
91	192k	WORD32 i;
92	192k	FLOAT64 *ptr_win = ptr_win_long + n_long - 1;
93	192k	WORD32 data_size = (OVERLAP_WIN_SIZE_576 * n_long) / LEN_SUPERFRAME;
94
95	184M	for (i = 0; i < n_long; i++) {
96	184M	ptr_win_buf[i] = ptr_overlap[i] * ptr_win_long[i];
97	184M	}
98
99	192k	memcpy(ptr_overlap, ptr_overlap + n_long, data_size * sizeof(ptr_overlap[0]));
100	192k	memcpy(ptr_overlap + data_size, ptr_in_data, n_long * sizeof(ptr_overlap[0]));
101
102	184M	for (i = 0; i < n_long; i++) {
103	184M	ptr_win_buf[i + n_long] = ptr_overlap[i] * (*ptr_win--);
104	184M	}
105
106	192k	return;
107	192k	}
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	52.3k	WORD32 nflat_ls, FLOAT64 *ptr_win_med, WORD32 win_sz) {
112	52.3k	WORD32 i;
113	52.3k	FLOAT64 ptr_win = ptr_win_buf + 2 n_long - 1;
114	52.3k	WORD32 data_size = (OVERLAP_WIN_SIZE_576 * n_long) / LEN_SUPERFRAME;
115
116	49.0M	for (i = 0; i < n_long; i++) {
117	48.9M	ptr_win_buf[i] = ptr_overlap[i] * ptr_win_long[i];
118	48.9M	}
119
120	52.3k	memcpy(ptr_overlap, ptr_overlap + n_long, data_size * sizeof(ptr_overlap[0]));
121	52.3k	memcpy(ptr_overlap + data_size, ptr_in_data, n_long * sizeof(ptr_overlap[0]));
122	52.3k	memcpy(ptr_win_buf + n_long, ptr_overlap, nflat_ls * sizeof(ptr_win_buf[0]));
123
124	52.3k	ptr_win_med = ptr_win_med + win_sz - 1;
125	52.3k	win_sz = n_long - 2 * nflat_ls;
126
127	6.45M	for (i = 0; i < win_sz; i++) {
128	6.40M	ptr_win_buf[i + n_long + nflat_ls] = ptr_overlap[i + nflat_ls] * (*ptr_win_med--);
129	6.40M	}
130
131	21.3M	for (i = 0; i < nflat_ls; i++) {
132	21.2M	*ptr_win-- = 0;
133	21.2M	}
134
135	52.3k	return;
136	52.3k	}
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	47.7k	FLOAT64 *ptr_win_med, WORD32 win_sz) {
141	47.7k	WORD32 i;
142	47.7k	FLOAT64 *ptr_win = ptr_win_long + n_long - 1;
143	47.7k	WORD32 data_size = (OVERLAP_WIN_SIZE_576 * n_long) / LEN_SUPERFRAME;
144
145	47.7k	memset(ptr_win_buf, 0, nflat_ls * sizeof(FLOAT64));
146	5.63M	for (i = 0; i < win_sz; i++) {
147	5.58M	ptr_win_buf[i + nflat_ls] = ptr_overlap[i + nflat_ls] * ptr_win_med[i];
148	5.58M	}
149
150	47.7k	memcpy(ptr_win_buf + nflat_ls + win_sz, ptr_overlap + nflat_ls + win_sz,
151	47.7k	nflat_ls * sizeof(ptr_win_buf[0]));
152	47.7k	memcpy(ptr_overlap, ptr_overlap + n_long, data_size * sizeof(ptr_overlap[0]));
153	47.7k	memcpy(ptr_overlap + data_size, ptr_in_data, n_long * sizeof(ptr_overlap[0]));
154
155	44.5M	for (i = 0; i < n_long; i++) {
156	44.5M	ptr_win_buf[i + n_long] = ptr_overlap[i] * (*ptr_win--);
157	44.5M	}
158	47.7k	return;
159	47.7k	}
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-01-09 06:51