/src/libxaac/decoder/ixheaacd_ps_bitdec.c

Source
/******************************************************************************
 *                                                                            *
 * Copyright (C) 2018 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 "ixheaacd_sbr_common.h"
#include "ixheaac_type_def.h"

#include "ixheaac_constants.h"
#include "ixheaac_basic_ops32.h"
#include "ixheaac_basic_ops16.h"
#include "ixheaac_basic_ops40.h"
#include "ixheaac_basic_ops.h"

#include "ixheaac_basic_op.h"
#include "ixheaacd_intrinsics.h"
#include "ixheaacd_bitbuffer.h"
#include "ixheaacd_sbrdecsettings.h"
#include "ixheaacd_sbr_scale.h"
#include "ixheaacd_lpp_tran.h"
#include "ixheaacd_env_extr_part.h"
#include "ixheaacd_sbr_rom.h"

#include "ixheaacd_hybrid.h"
#include "ixheaacd_ps_dec.h"

#include "ixheaacd_env_extr.h"
#include "ixheaacd_ps_bitdec.h"

const WORD16 ixheaacd_num_bands[3] = {10, 20, 34};

static WORD32 ixheaacd_clamp(WORD32 i, WORD16 min, WORD16 max) {
  WORD32 result = i;

  if (i < min) {
    result = min;
  } else {
    if (i > max) {
      result = max;
    }
  }

  return result;
}

WORD16 ixheaacd_divideby2(WORD op) {
  FLAG sign = (op < 0);

  if (sign) {
    op = -(op);
  }

  op = (op >> 1);

  if (sign) {
    op = -op;
  }

  return (WORD16)op;
}

WORD16 ixheaacd_divideby3(WORD op) {
  WORD16 temp, ret;
  FLAG sign = (op < 0);

  if (sign) {
    op = -(op);
  }

  temp = (WORD16)(op << 2);

  temp = ixheaac_mult16_shl(temp, 0x2aab);

  ret = (temp >> 2);

  if (sign) {
    ret = -(ret);
  }

  return (WORD16)ret;
}

VOID ixheaacd_decode_ps_data(ia_ps_dec_struct *ptr_ps_dec, WORD32 frame_size) {
  WORD e, i, temp;
  WORD16 iid_mode = (WORD16)((ptr_ps_dec->iid_mode) ? 1 : 2);
  WORD16 icc_mode = (WORD16)((ptr_ps_dec->icc_mode) ? 1 : 2);
  WORD16 num_iid_levels =
      (WORD16)(ptr_ps_dec->iid_quant ? NUM_IID_LEVELS_FINE : NUM_IID_LEVELS);
  WORD32 max_num_columns;

  if (frame_size == 960)
    max_num_columns = MAX_NUM_COLUMNS_960;
  else
    max_num_columns = MAX_NUM_COLUMNS;

  if (!ptr_ps_dec->ps_data_present) {
    ptr_ps_dec->num_env = 0;
  }

  for (e = 0; e < ptr_ps_dec->num_env; e++) {
    WORD16 *p_iid_par_prev;
    WORD16 *p_icc_par_prev;

    if (e == 0) {
      p_iid_par_prev = ptr_ps_dec->iid_par_prev;
      p_icc_par_prev = ptr_ps_dec->icc_par_prev;
    } else {
      p_iid_par_prev = ptr_ps_dec->iid_par_table[e - 1];
      p_icc_par_prev = ptr_ps_dec->icc_par_table[e - 1];
    }

    if (ptr_ps_dec->enable_iid) {
      if (ptr_ps_dec->iid_dt[e]) {
        for (i = 0; i < ixheaacd_num_bands[ptr_ps_dec->iid_mode]; i++) {
          temp =
              ixheaac_add16(*p_iid_par_prev, ptr_ps_dec->iid_par_table[e][i]);
          ptr_ps_dec->iid_par_table[e][i] = ixheaacd_clamp(
              temp, ixheaac_negate16(num_iid_levels), num_iid_levels);
          p_iid_par_prev += iid_mode;
        }
      } else {
        ptr_ps_dec->iid_par_table[e][0] =
            ixheaacd_clamp(ptr_ps_dec->iid_par_table[e][0],
                           ixheaac_negate16(num_iid_levels), num_iid_levels);
        for (i = 1; i < ixheaacd_num_bands[ptr_ps_dec->iid_mode]; i++) {
          temp = ixheaac_add16(ptr_ps_dec->iid_par_table[e][i - 1],
                                ptr_ps_dec->iid_par_table[e][i]);
          ptr_ps_dec->iid_par_table[e][i] = ixheaacd_clamp(
              temp, ixheaac_negate16(num_iid_levels), num_iid_levels);
        }
      }
    } else {
      memset(ptr_ps_dec->iid_par_table[e], 0,
             sizeof(WORD16) * ixheaacd_num_bands[ptr_ps_dec->iid_mode]);
    }

    if (iid_mode == 2) {
      for (i = (ixheaacd_num_bands[ptr_ps_dec->iid_mode] * iid_mode - 1);
           i != 0; i--) {
        ptr_ps_dec->iid_par_table[e][i] =
            ptr_ps_dec->iid_par_table[e][ixheaac_shr32(i, 1)];
      }
    }

    if (ptr_ps_dec->enable_icc) {
      if (ptr_ps_dec->icc_dt[e]) {
        for (i = 0; i < ixheaacd_num_bands[ptr_ps_dec->icc_mode]; i++) {
          temp =
              ixheaac_add16(*p_icc_par_prev, ptr_ps_dec->icc_par_table[e][i]);
          ptr_ps_dec->icc_par_table[e][i] =
              ixheaacd_clamp(temp, 0, (WORD16)(NUM_ICC_LEVELS - 1));
          p_icc_par_prev += icc_mode;
        }
      } else {
        ptr_ps_dec->icc_par_table[e][0] = ixheaacd_clamp(
            ptr_ps_dec->icc_par_table[e][0], 0, (WORD16)(NUM_ICC_LEVELS - 1));
        for (i = 1; i < ixheaacd_num_bands[ptr_ps_dec->icc_mode]; i++) {
          temp = ixheaac_add16(ptr_ps_dec->icc_par_table[e][i - 1],
                                ptr_ps_dec->icc_par_table[e][i]);
          ptr_ps_dec->icc_par_table[e][i] =
              ixheaacd_clamp(temp, 0, (WORD16)(NUM_ICC_LEVELS - 1));
        }
      }
    } else {
      memset(ptr_ps_dec->icc_par_table[e], 0,
             sizeof(WORD16) * ixheaacd_num_bands[ptr_ps_dec->icc_mode]);
    }

    if (icc_mode == 2) {
      for (i = (ixheaacd_num_bands[ptr_ps_dec->icc_mode] * icc_mode - 1);
           i != 0; i--) {
        ptr_ps_dec->icc_par_table[e][i] =
            ptr_ps_dec->icc_par_table[e][ixheaac_shr32(i, 1)];
      }
    }
  }

  if (ptr_ps_dec->num_env == 0) {
    ptr_ps_dec->num_env = 1;

    if (ptr_ps_dec->enable_iid) {
      memcpy(ptr_ps_dec->iid_par_table[0], ptr_ps_dec->iid_par_prev,
             sizeof(WORD16) * NUM_BANDS_FINE);
    } else {
      memset(ptr_ps_dec->iid_par_table[0], 0, sizeof(WORD16) * NUM_BANDS_FINE);
    }

    if (ptr_ps_dec->enable_icc) {
      memcpy(ptr_ps_dec->icc_par_table[0], ptr_ps_dec->icc_par_prev,
             sizeof(WORD16) * NUM_BANDS_FINE);
    } else {
      memset(ptr_ps_dec->icc_par_table[0], 0, sizeof(WORD16) * NUM_BANDS_FINE);
    }
  }

  memcpy(ptr_ps_dec->iid_par_prev,
         ptr_ps_dec->iid_par_table[ptr_ps_dec->num_env - 1],
         sizeof(WORD16) * NUM_BANDS_FINE);

  memcpy(ptr_ps_dec->icc_par_prev,
         ptr_ps_dec->icc_par_table[ptr_ps_dec->num_env - 1],
         sizeof(WORD16) * NUM_BANDS_FINE);

  ptr_ps_dec->ps_data_present = 0;

  if (ptr_ps_dec->frame_class == 0) {
    WORD env_count;
    WORD16 shift = 0;

    switch (ptr_ps_dec->num_env) {
      case 1:
        shift = 0;
        break;
      case 2:
        shift = 1;
        break;
      case 4:
        shift = 2;
        break;
    }
    ptr_ps_dec->border_position[0] = 0;
    env_count = 0;

    for (e = 1; e < ptr_ps_dec->num_env; e++) {
      env_count = add_d(env_count, max_num_columns);
      ptr_ps_dec->border_position[e] = (WORD16)(env_count >> shift);
    }
    ptr_ps_dec->border_position[ptr_ps_dec->num_env] = max_num_columns;
  } else {
    ptr_ps_dec->border_position[0] = 0;

    if (ptr_ps_dec->border_position[ptr_ps_dec->num_env] < max_num_columns) {
      ptr_ps_dec->num_env++;
      ptr_ps_dec->border_position[ptr_ps_dec->num_env] = max_num_columns;

      memcpy(ptr_ps_dec->iid_par_table[ptr_ps_dec->num_env - 1],
             ptr_ps_dec->iid_par_table[ptr_ps_dec->num_env - 2],
             sizeof(WORD16) * NUM_BANDS_FINE);

      memcpy(ptr_ps_dec->icc_par_table[ptr_ps_dec->num_env - 1],
             ptr_ps_dec->icc_par_table[ptr_ps_dec->num_env - 2],
             sizeof(WORD16) * NUM_BANDS_FINE);
    }

    for (e = 1; e < ptr_ps_dec->num_env; e++) {
      WORD threshold;
      threshold = sub_d(max_num_columns, sub_d(ptr_ps_dec->num_env, e));

      if (ptr_ps_dec->border_position[e] > threshold) {
        ptr_ps_dec->border_position[e] = threshold;
      } else {
        threshold = add_d(ptr_ps_dec->border_position[e - 1], 1);

        if (ptr_ps_dec->border_position[e] < threshold) {
          ptr_ps_dec->border_position[e] = threshold;
        }
      }
    }
  }

  for (e = 0; e < ptr_ps_dec->num_env; e++) {
    if (ptr_ps_dec->iid_mode == 2)
      ixheaacd_map_34_params_to_20(ptr_ps_dec->iid_par_table[e]);

    if (ptr_ps_dec->icc_mode == 2)
      ixheaacd_map_34_params_to_20(ptr_ps_dec->icc_par_table[e]);
  }
}

Coverage Report

Created: 2026-09-28 07:18

Line	Count	Source
1		/******************************************************************************
2		* *
3		* Copyright (C) 2018 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		#include <string.h>
21		#include "ixheaacd_sbr_common.h"
22		#include "ixheaac_type_def.h"
23
24		#include "ixheaac_constants.h"
25		#include "ixheaac_basic_ops32.h"
26		#include "ixheaac_basic_ops16.h"
27		#include "ixheaac_basic_ops40.h"
28		#include "ixheaac_basic_ops.h"
29
30		#include "ixheaac_basic_op.h"
31		#include "ixheaacd_intrinsics.h"
32		#include "ixheaacd_bitbuffer.h"
33		#include "ixheaacd_sbrdecsettings.h"
34		#include "ixheaacd_sbr_scale.h"
35		#include "ixheaacd_lpp_tran.h"
36		#include "ixheaacd_env_extr_part.h"
37		#include "ixheaacd_sbr_rom.h"
38
39		#include "ixheaacd_hybrid.h"
40		#include "ixheaacd_ps_dec.h"
41
42		#include "ixheaacd_env_extr.h"
43		#include "ixheaacd_ps_bitdec.h"
44
45		const WORD16 ixheaacd_num_bands[3] = {10, 20, 34};
46
47	10.2k	static WORD32 ixheaacd_clamp(WORD32 i, WORD16 min, WORD16 max) {
48	10.2k	WORD32 result = i;
49
50	10.2k	if (i < min) {
51	483	result = min;
52	9.71k	} else {
53	9.71k	if (i > max) {
54	190	result = max;
55	190	}
56	9.71k	}
57
58	10.2k	return result;
59	10.2k	}
60
61	21.9k	WORD16 ixheaacd_divideby2(WORD op) {
62	21.9k	FLAG sign = (op < 0);
63
64	21.9k	if (sign) {
65	11	op = -(op);
66	11	}
67
68	21.9k	op = (op >> 1);
69
70	21.9k	if (sign) {
71	11	op = -op;
72	11	}
73
74	21.9k	return (WORD16)op;
75	21.9k	}
76
77	7.98k	WORD16 ixheaacd_divideby3(WORD op) {
78	7.98k	WORD16 temp, ret;
79	7.98k	FLAG sign = (op < 0);
80
81	7.98k	if (sign) {
82	3	op = -(op);
83	3	}
84
85	7.98k	temp = (WORD16)(op << 2);
86
87	7.98k	temp = ixheaac_mult16_shl(temp, 0x2aab);
88
89	7.98k	ret = (temp >> 2);
90
91	7.98k	if (sign) {
92	3	ret = -(ret);
93	3	}
94
95	7.98k	return (WORD16)ret;
96	7.98k	}
97
98	15.8k	VOID ixheaacd_decode_ps_data(ia_ps_dec_struct *ptr_ps_dec, WORD32 frame_size) {
99	15.8k	WORD e, i, temp;
100	15.8k	WORD16 iid_mode = (WORD16)((ptr_ps_dec->iid_mode) ? 1 : 2);
101	15.8k	WORD16 icc_mode = (WORD16)((ptr_ps_dec->icc_mode) ? 1 : 2);
102	15.8k	WORD16 num_iid_levels =
103	15.8k	(WORD16)(ptr_ps_dec->iid_quant ? NUM_IID_LEVELS_FINE : NUM_IID_LEVELS);
104	15.8k	WORD32 max_num_columns;
105
106	15.8k	if (frame_size == 960)
107	0	max_num_columns = MAX_NUM_COLUMNS_960;
108	15.8k	else
109	15.8k	max_num_columns = MAX_NUM_COLUMNS;
110
111	15.8k	if (!ptr_ps_dec->ps_data_present) {
112	12.1k	ptr_ps_dec->num_env = 0;
113	12.1k	}
114
115	18.6k	for (e = 0; e < ptr_ps_dec->num_env; e++) {
116	2.75k	WORD16 *p_iid_par_prev;
117	2.75k	WORD16 *p_icc_par_prev;
118
119	2.75k	if (e == 0) {
120	2.54k	p_iid_par_prev = ptr_ps_dec->iid_par_prev;
121	2.54k	p_icc_par_prev = ptr_ps_dec->icc_par_prev;
122	2.54k	} else {
123	211	p_iid_par_prev = ptr_ps_dec->iid_par_table[e - 1];
124	211	p_icc_par_prev = ptr_ps_dec->icc_par_table[e - 1];
125	211	}
126
127	2.75k	if (ptr_ps_dec->enable_iid) {
128	808	if (ptr_ps_dec->iid_dt[e]) {
129	7.92k	for (i = 0; i < ixheaacd_num_bands[ptr_ps_dec->iid_mode]; i++) {
130	7.27k	temp =
131	7.27k	ixheaac_add16(*p_iid_par_prev, ptr_ps_dec->iid_par_table[e][i]);
132	7.27k	ptr_ps_dec->iid_par_table[e][i] = ixheaacd_clamp(
133	7.27k	temp, ixheaac_negate16(num_iid_levels), num_iid_levels);
134	7.27k	p_iid_par_prev += iid_mode;
135	7.27k	}
136	656	} else {
137	152	ptr_ps_dec->iid_par_table[e][0] =
138	152	ixheaacd_clamp(ptr_ps_dec->iid_par_table[e][0],
139	152	ixheaac_negate16(num_iid_levels), num_iid_levels);
140	1.52k	for (i = 1; i < ixheaacd_num_bands[ptr_ps_dec->iid_mode]; i++) {
141	1.36k	temp = ixheaac_add16(ptr_ps_dec->iid_par_table[e][i - 1],
142	1.36k	ptr_ps_dec->iid_par_table[e][i]);
143	1.36k	ptr_ps_dec->iid_par_table[e][i] = ixheaacd_clamp(
144	1.36k	temp, ixheaac_negate16(num_iid_levels), num_iid_levels);
145	1.36k	}
146	152	}
147	1.95k	} else {
148	1.95k	memset(ptr_ps_dec->iid_par_table[e], 0,
149	1.95k	sizeof(WORD16) * ixheaacd_num_bands[ptr_ps_dec->iid_mode]);
150	1.95k	}
151
152	2.75k	if (iid_mode == 2) {
153	2.68k	for (i = (ixheaacd_num_bands[ptr_ps_dec->iid_mode] * iid_mode - 1);
154	53.7k	i != 0; i--) {
155	51.0k	ptr_ps_dec->iid_par_table[e][i] =
156	51.0k	ptr_ps_dec->iid_par_table[e][ixheaac_shr32(i, 1)];
157	51.0k	}
158	2.68k	}
159
160	2.75k	if (ptr_ps_dec->enable_icc) {
161	75	if (ptr_ps_dec->icc_dt[e]) {
162	1.43k	for (i = 0; i < ixheaacd_num_bands[ptr_ps_dec->icc_mode]; i++) {
163	1.36k	temp =
164	1.36k	ixheaac_add16(*p_icc_par_prev, ptr_ps_dec->icc_par_table[e][i]);
165	1.36k	ptr_ps_dec->icc_par_table[e][i] =
166	1.36k	ixheaacd_clamp(temp, 0, (WORD16)(NUM_ICC_LEVELS - 1));
167	1.36k	p_icc_par_prev += icc_mode;
168	1.36k	}
169	71	} else {
170	4	ptr_ps_dec->icc_par_table[e][0] = ixheaacd_clamp(
171	4	ptr_ps_dec->icc_par_table[e][0], 0, (WORD16)(NUM_ICC_LEVELS - 1));
172	50	for (i = 1; i < ixheaacd_num_bands[ptr_ps_dec->icc_mode]; i++) {
173	46	temp = ixheaac_add16(ptr_ps_dec->icc_par_table[e][i - 1],
174	46	ptr_ps_dec->icc_par_table[e][i]);
175	46	ptr_ps_dec->icc_par_table[e][i] =
176	46	ixheaacd_clamp(temp, 0, (WORD16)(NUM_ICC_LEVELS - 1));
177	46	}
178	4	}
179	2.68k	} else {
180	2.68k	memset(ptr_ps_dec->icc_par_table[e], 0,
181	2.68k	sizeof(WORD16) * ixheaacd_num_bands[ptr_ps_dec->icc_mode]);
182	2.68k	}
183
184	2.75k	if (icc_mode == 2) {
185	2.67k	for (i = (ixheaacd_num_bands[ptr_ps_dec->icc_mode] * icc_mode - 1);
186	53.4k	i != 0; i--) {
187	50.8k	ptr_ps_dec->icc_par_table[e][i] =
188	50.8k	ptr_ps_dec->icc_par_table[e][ixheaac_shr32(i, 1)];
189	50.8k	}
190	2.67k	}
191	2.75k	}
192
193	15.8k	if (ptr_ps_dec->num_env == 0) {
194	13.3k	ptr_ps_dec->num_env = 1;
195
196	13.3k	if (ptr_ps_dec->enable_iid) {
197	4.59k	memcpy(ptr_ps_dec->iid_par_table[0], ptr_ps_dec->iid_par_prev,
198	4.59k	sizeof(WORD16) * NUM_BANDS_FINE);
199	8.73k	} else {
200	8.73k	memset(ptr_ps_dec->iid_par_table[0], 0, sizeof(WORD16) * NUM_BANDS_FINE);
201	8.73k	}
202
203	13.3k	if (ptr_ps_dec->enable_icc) {
204	2.33k	memcpy(ptr_ps_dec->icc_par_table[0], ptr_ps_dec->icc_par_prev,
205	2.33k	sizeof(WORD16) * NUM_BANDS_FINE);
206	11.0k	} else {
207	11.0k	memset(ptr_ps_dec->icc_par_table[0], 0, sizeof(WORD16) * NUM_BANDS_FINE);
208	11.0k	}
209	13.3k	}
210
211	15.8k	memcpy(ptr_ps_dec->iid_par_prev,
212	15.8k	ptr_ps_dec->iid_par_table[ptr_ps_dec->num_env - 1],
213	15.8k	sizeof(WORD16) * NUM_BANDS_FINE);
214
215	15.8k	memcpy(ptr_ps_dec->icc_par_prev,
216	15.8k	ptr_ps_dec->icc_par_table[ptr_ps_dec->num_env - 1],
217	15.8k	sizeof(WORD16) * NUM_BANDS_FINE);
218
219	15.8k	ptr_ps_dec->ps_data_present = 0;
220
221	15.8k	if (ptr_ps_dec->frame_class == 0) {
222	15.5k	WORD env_count;
223	15.5k	WORD16 shift = 0;
224
225	15.5k	switch (ptr_ps_dec->num_env) {
226	15.4k	case 1:
227	15.4k	shift = 0;
228	15.4k	break;
229	130	case 2:
230	130	shift = 1;
231	130	break;
232	1	case 4:
233	1	shift = 2;
234	1	break;
235	15.5k	}
236	15.5k	ptr_ps_dec->border_position[0] = 0;
237	15.5k	env_count = 0;
238
239	15.6k	for (e = 1; e < ptr_ps_dec->num_env; e++) {
240	133	env_count = add_d(env_count, max_num_columns);
241	133	ptr_ps_dec->border_position[e] = (WORD16)(env_count >> shift);
242	133	}
243	15.5k	ptr_ps_dec->border_position[ptr_ps_dec->num_env] = max_num_columns;
244	15.5k	} else {
245	342	ptr_ps_dec->border_position[0] = 0;
246
247	342	if (ptr_ps_dec->border_position[ptr_ps_dec->num_env] < max_num_columns) {
248	305	ptr_ps_dec->num_env++;
249	305	ptr_ps_dec->border_position[ptr_ps_dec->num_env] = max_num_columns;
250
251	305	memcpy(ptr_ps_dec->iid_par_table[ptr_ps_dec->num_env - 1],
252	305	ptr_ps_dec->iid_par_table[ptr_ps_dec->num_env - 2],
253	305	sizeof(WORD16) * NUM_BANDS_FINE);
254
255	305	memcpy(ptr_ps_dec->icc_par_table[ptr_ps_dec->num_env - 1],
256	305	ptr_ps_dec->icc_par_table[ptr_ps_dec->num_env - 2],
257	305	sizeof(WORD16) * NUM_BANDS_FINE);
258	305	}
259
260	725	for (e = 1; e < ptr_ps_dec->num_env; e++) {
261	383	WORD threshold;
262	383	threshold = sub_d(max_num_columns, sub_d(ptr_ps_dec->num_env, e));
263
264	383	if (ptr_ps_dec->border_position[e] > threshold) {
265	4	ptr_ps_dec->border_position[e] = threshold;
266	379	} else {
267	379	threshold = add_d(ptr_ps_dec->border_position[e - 1], 1);
268
269	379	if (ptr_ps_dec->border_position[e] < threshold) {
270	73	ptr_ps_dec->border_position[e] = threshold;
271	73	}
272	379	}
273	383	}
274	342	}
275
276	32.2k	for (e = 0; e < ptr_ps_dec->num_env; e++) {
277	16.3k	if (ptr_ps_dec->iid_mode == 2)
278	1.78k	ixheaacd_map_34_params_to_20(ptr_ps_dec->iid_par_table[e]);
279
280	16.3k	if (ptr_ps_dec->icc_mode == 2)
281	206	ixheaacd_map_34_params_to_20(ptr_ps_dec->icc_par_table[e]);
282	16.3k	}
283	15.8k	}