1 /******************************************************************************
2 *
3 * Copyright (C) 2022 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 /**
22 *******************************************************************************
23 * @file
24 * isvce_ibl_eval.c
25 *
26 * @brief
27 * Contains functions used for SVC intra prediction
28 *
29 *******************************************************************************
30 */
31 #include <math.h>
32 #include <limits.h>
33 #include <stdbool.h>
34
35 #include "ih264_typedefs.h"
36 #include "iv2.h"
37 #include "isvc_macros.h"
38 #include "ih264_debug.h"
39 #include "ih264_padding.h"
40 #include "isvce_defs.h"
41 #include "isvce_ibl_private_defs.h"
42 #include "isvce_ibl_eval.h"
43 #include "isvce_utils.h"
44 #include "isvc_intra_resample.h"
45 #include "isvc_defs.h"
46
isvce_get_num_mb_states(UWORD32 u4_wd,UWORD32 u4_ht)47 static FORCEINLINE WORD32 isvce_get_num_mb_states(UWORD32 u4_wd, UWORD32 u4_ht)
48 {
49 return (u4_wd / MB_SIZE) * (u4_ht / MB_SIZE);
50 }
51
isvce_get_phase_array_size(DOUBLE d_spatial_res_ratio,bool b_is_chroma)52 static FORCEINLINE WORD32 isvce_get_phase_array_size(DOUBLE d_spatial_res_ratio, bool b_is_chroma)
53 {
54 return (2 == d_spatial_res_ratio) ? (b_is_chroma ? 3 : 0) : 5;
55 }
56
57 /**
58 *******************************************************************************
59 *
60 * @brief
61 * Returns size of buffers for storing residual pred ctxt
62 *
63 * @param[in] u1_num_spatial_layers
64 * Num Spatial Layers
65 *
66 * @param[in] d_spatial_res_ratio
67 * Resolution Ratio b/w spatial layers
68 *
69 * @param[in] u4_wd
70 * Input Width
71 *
72 * @param[in] u4_ht
73 * Input Height
74 *
75 * @returns Size of buffers
76 *
77 *******************************************************************************
78 */
isvce_get_svc_intra_pred_ctxt_size(UWORD8 u1_num_spatial_layers,DOUBLE d_spatial_res_ratio,UWORD32 u4_wd,UWORD32 u4_ht)79 UWORD32 isvce_get_svc_intra_pred_ctxt_size(UWORD8 u1_num_spatial_layers, DOUBLE d_spatial_res_ratio,
80 UWORD32 u4_wd, UWORD32 u4_ht)
81 {
82 WORD32 i, j;
83
84 UWORD32 u4_size = 0;
85
86 if(u1_num_spatial_layers > 1)
87 {
88 u4_size += MAX_PROCESS_CTXT * sizeof(svc_intra_pred_ctxt_t);
89 u4_size += MAX_PROCESS_CTXT * sizeof(intra_pred_state_t);
90 u4_size += MAX_PROCESS_CTXT * u1_num_spatial_layers * sizeof(intra_pred_layer_state_t);
91
92 for(i = u1_num_spatial_layers - 1; i >= 0; i--)
93 {
94 WORD32 i4_layer_luma_wd =
95 (WORD32) ((DOUBLE) u4_wd /
96 pow(d_spatial_res_ratio, u1_num_spatial_layers - 1 - i)) +
97 0.99;
98 WORD32 i4_layer_luma_ht =
99 ((DOUBLE) u4_ht / pow(d_spatial_res_ratio, u1_num_spatial_layers - 1 - i)) + 0.99;
100 WORD32 i4_layer_wd_mbs = i4_layer_luma_wd / MB_SIZE;
101 WORD32 i4_layer_ht_mbs = i4_layer_luma_ht / MB_SIZE;
102 /*Add PAD Mbs */
103 WORD32 i4_layer_luma_mbs =
104 ((i4_layer_luma_wd / MB_SIZE) + 2) * ((i4_layer_luma_ht / MB_SIZE) + 2);
105 WORD32 i4_num_mb_states = isvce_get_num_mb_states(i4_layer_luma_wd, i4_layer_luma_ht);
106
107 for(j = 0; j < NUM_SP_COMPONENTS; j++)
108 {
109 bool b_is_chroma = ((COMPONENT_TYPE) j) != Y;
110
111 u4_size += i4_num_mb_states * sizeof(intra_pred_mb_state_t);
112
113 /* pi4_ref_array_positions_x */
114 u4_size += MAX_REF_ARR_WD_HT * i4_layer_wd_mbs * sizeof(WORD32);
115
116 /* pi4_ref_array_positions_y */
117 u4_size += (i4_layer_ht_mbs >> b_is_chroma) * i4_layer_ht_mbs * sizeof(WORD32);
118
119 /* ps_ref_array_phases */
120 u4_size += isvce_get_phase_array_size(d_spatial_res_ratio, b_is_chroma) *
121 sizeof(coordinates_t);
122 }
123
124 /* pi1_mb_mode */
125 u4_size += i4_layer_luma_mbs * sizeof(WORD8);
126
127 /* pu1_refarray_buffer */
128 u4_size += MAX_PROCESS_CTXT * TEMP_BUF_SIZE_LUMA * sizeof(UWORD8);
129
130 /* pu1_refarray_cb, pu1_refarray_cr */
131 u4_size += MAX_PROCESS_CTXT * (TEMP_BUF_SIZE_CB + TEMP_BUF_SIZE_CR) * sizeof(UWORD8);
132
133 /* pi4_temp_interpolation_buffer */
134 u4_size += MAX_PROCESS_CTXT * TEMP_INTERPOLATION_BUF_SIZE * sizeof(WORD32);
135 }
136
137 /* intra_pred_outputs_t.s_pred_buf */
138 u4_size += MAX_PROCESS_CTXT * MB_SIZE * MB_SIZE * sizeof(UWORD8);
139
140 u4_size += MAX_PROCESS_CTXT * MB_SIZE * MB_SIZE * sizeof(UWORD8);
141 }
142
143 return u4_size;
144 }
145
isvce_get_scaled_pixel_pos(layer_resampler_props_t * ps_layer_props,WORD32 i4_pixel_pos,UWORD8 u1_dim_id)146 static FORCEINLINE WORD32 isvce_get_scaled_pixel_pos(layer_resampler_props_t *ps_layer_props,
147 WORD32 i4_pixel_pos, UWORD8 u1_dim_id)
148 {
149 if(1 == u1_dim_id)
150 {
151 return (((i4_pixel_pos - ps_layer_props->i4_offset_y) *
152 ((WORD64) ps_layer_props->u4_scale_y) +
153 ps_layer_props->i4_add_y) >>
154 (ps_layer_props->u4_shift_y - 4)) -
155 ps_layer_props->i4_delta_y;
156 }
157 else
158 {
159 return (((i4_pixel_pos - ps_layer_props->i4_offset_x) *
160 ((WORD64) ps_layer_props->u4_scale_x) +
161 ps_layer_props->i4_add_x) >>
162 (ps_layer_props->u4_shift_x - 4)) -
163 ps_layer_props->i4_delta_x;
164 }
165 }
166
isvce_ref_array_pos_init(layer_resampler_props_t * ps_layer_props,intra_pred_mb_state_t * ps_mb_state,coordinates_t * ps_mb_pos,DOUBLE d_spatial_res_ratio,UWORD8 u1_frame_mbs_only_flag,UWORD8 u1_field_mb_flag,UWORD8 u1_ref_layer_frame_mbs_only_flag)167 static FORCEINLINE void isvce_ref_array_pos_init(
168 layer_resampler_props_t *ps_layer_props, intra_pred_mb_state_t *ps_mb_state,
169 coordinates_t *ps_mb_pos, DOUBLE d_spatial_res_ratio, UWORD8 u1_frame_mbs_only_flag,
170 UWORD8 u1_field_mb_flag, UWORD8 u1_ref_layer_frame_mbs_only_flag)
171 {
172 if(1.5 == d_spatial_res_ratio)
173 {
174 UWORD32 i;
175
176 WORD32 *pi4_ref_array_positions_x = ps_mb_state->pi4_ref_array_positions_x;
177 WORD32 *pi4_ref_array_positions_y = ps_mb_state->pi4_ref_array_positions_y;
178 WORD32 i4_x_offset = ps_mb_state->s_offsets.i4_abscissa;
179 WORD32 i4_y_offset = ps_mb_state->s_offsets.i4_ordinate;
180
181 if(0 == ps_mb_pos->i4_abscissa)
182 {
183 for(i = 0; i < ps_layer_props->u4_mb_ht; i++)
184 {
185 WORD32 i4_y_ref16;
186
187 WORD32 i4_yc = ps_mb_pos->i4_ordinate * ps_layer_props->u4_mb_ht + i;
188
189 if((0 == u1_frame_mbs_only_flag) || (0 == u1_ref_layer_frame_mbs_only_flag))
190 {
191 i4_yc = i4_yc >> (1 - u1_field_mb_flag);
192 }
193
194 i4_y_ref16 = isvce_get_scaled_pixel_pos(ps_layer_props, i4_yc, 1);
195
196 pi4_ref_array_positions_y[i] = (i4_y_ref16 >> 4) - i4_y_offset;
197 }
198 }
199
200 if(0 == ps_mb_pos->i4_ordinate)
201 {
202 for(i = 0; i < MAX_REF_ARR_WD_HT; i++)
203 {
204 WORD32 i4_x_ref16;
205
206 WORD32 i4_xc = ps_mb_pos->i4_abscissa * ps_layer_props->u4_mb_wd + i;
207
208 i4_x_ref16 = isvce_get_scaled_pixel_pos(ps_layer_props, i4_xc, 0);
209
210 pi4_ref_array_positions_x[i] = (i4_x_ref16 >> 4) - i4_x_offset;
211 }
212 }
213 }
214 }
215
isvce_ref_array_phase_init(layer_resampler_props_t * ps_layer_props,intra_pred_mb_state_t * ps_mb_state,coordinates_t * ps_mb_pos,DOUBLE d_spatial_res_ratio,UWORD8 u1_frame_mbs_only_flag,UWORD8 u1_field_mb_flag,UWORD8 u1_ref_layer_frame_mbs_only_flag)216 static FORCEINLINE void isvce_ref_array_phase_init(
217 layer_resampler_props_t *ps_layer_props, intra_pred_mb_state_t *ps_mb_state,
218 coordinates_t *ps_mb_pos, DOUBLE d_spatial_res_ratio, UWORD8 u1_frame_mbs_only_flag,
219 UWORD8 u1_field_mb_flag, UWORD8 u1_ref_layer_frame_mbs_only_flag)
220 {
221 UWORD32 i, j;
222
223 coordinates_t *ps_ref_array_phases = ps_mb_state->ps_ref_array_phases;
224
225 WORD32 i4_x_offset = ps_mb_state->s_offsets.i4_abscissa;
226 WORD32 i4_y_offset = ps_mb_state->s_offsets.i4_ordinate;
227 UWORD32 u4_phase_array_idx = 0;
228
229 if(1.5 == d_spatial_res_ratio)
230 {
231 for(i = 0; i < 3; i++)
232 {
233 WORD32 i4_y_ref16;
234
235 WORD32 i4_yc = ps_mb_pos->i4_ordinate * ps_layer_props->u4_mb_ht + i;
236
237 if((0 == u1_frame_mbs_only_flag) || (0 == u1_ref_layer_frame_mbs_only_flag))
238 {
239 i4_yc = i4_yc >> (1 - u1_field_mb_flag);
240 }
241
242 i4_y_ref16 = isvce_get_scaled_pixel_pos(ps_layer_props, i4_yc, 1);
243
244 for(j = 0; j < ((0 == i) ? 3 : 1); j++)
245 {
246 WORD32 i4_x_ref16;
247
248 WORD32 i4_xc = ps_mb_pos->i4_abscissa * ps_layer_props->u4_mb_wd + j;
249
250 i4_x_ref16 = isvce_get_scaled_pixel_pos(ps_layer_props, i4_xc, 0);
251
252 ps_ref_array_phases[u4_phase_array_idx].i4_abscissa = i4_x_ref16 & 15;
253 ps_ref_array_phases[u4_phase_array_idx].i4_ordinate = i4_y_ref16 & 15;
254
255 u4_phase_array_idx++;
256 }
257 }
258 }
259 else
260 {
261 for(i = 0; i < 2; i++)
262 {
263 WORD32 i4_y_ref16;
264
265 WORD32 i4_yc = ps_mb_pos->i4_ordinate * ps_layer_props->u4_mb_ht + i;
266
267 if((0 == u1_frame_mbs_only_flag) || (0 == u1_ref_layer_frame_mbs_only_flag))
268 {
269 i4_yc = i4_yc >> (1 - u1_field_mb_flag);
270 }
271
272 i4_y_ref16 = isvce_get_scaled_pixel_pos(ps_layer_props, i4_yc, 1);
273
274 for(j = 0; j < ((0 == i) ? 2 : 1); j++)
275 {
276 WORD32 i4_x_ref16;
277
278 WORD32 i4_xc = ps_mb_pos->i4_abscissa * ps_layer_props->u4_mb_wd + j;
279
280 i4_x_ref16 = isvce_get_scaled_pixel_pos(ps_layer_props, i4_xc, 0);
281
282 ps_ref_array_phases[u4_phase_array_idx].i4_abscissa =
283 (i4_x_ref16 - (16 * i4_x_offset)) & 15;
284 ps_ref_array_phases[u4_phase_array_idx].i4_ordinate =
285 (i4_y_ref16 - (16 * i4_y_offset)) & 15;
286
287 u4_phase_array_idx++;
288 }
289 }
290 }
291 }
292
isvce_set_mb_states(layer_resampler_props_t * ps_layer_props,intra_pred_mb_state_t * ps_mb_states,coordinates_t * ps_mb_pos,DOUBLE d_spatial_res_ratio,UWORD32 u4_wd_in_mbs,bool b_is_chroma)293 static FORCEINLINE void isvce_set_mb_states(layer_resampler_props_t *ps_layer_props,
294 intra_pred_mb_state_t *ps_mb_states,
295 coordinates_t *ps_mb_pos, DOUBLE d_spatial_res_ratio,
296 UWORD32 u4_wd_in_mbs, bool b_is_chroma)
297 {
298 WORD32 i4_x_refmin16;
299 WORD32 i4_x_refmax16;
300 WORD32 i4_y_refmin16;
301 WORD32 i4_y_refmax16;
302 WORD32 i4_x_offset, i4_y_offset;
303
304 const UWORD8 u1_frame_mbs_only_flag = 1;
305 const UWORD8 u1_ref_layer_frame_mbs_only_flag = 1;
306 const UWORD8 u1_field_mb_flag = 0;
307
308 i4_x_refmin16 = isvce_get_scaled_pixel_pos(
309 ps_layer_props, ps_mb_pos->i4_abscissa * ps_layer_props->u4_mb_wd, 0);
310 i4_x_refmax16 = isvce_get_scaled_pixel_pos(
311 ps_layer_props,
312 ps_mb_pos->i4_abscissa * ps_layer_props->u4_mb_wd + ps_layer_props->u4_mb_wd - 1, 0);
313
314 i4_y_refmin16 = isvce_get_scaled_pixel_pos(
315 ps_layer_props, ps_mb_pos->i4_ordinate * ps_layer_props->u4_mb_ht, 1);
316 i4_y_refmax16 = isvce_get_scaled_pixel_pos(
317 ps_layer_props,
318 ps_mb_pos->i4_ordinate * ps_layer_props->u4_mb_ht + ps_layer_props->u4_mb_ht - 1, 1);
319
320 i4_x_offset = (i4_x_refmin16 >> 4);
321 i4_y_offset = (i4_y_refmin16 >> 4);
322
323 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
324 .s_offsets.i4_abscissa = i4_x_offset;
325 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
326 .s_offsets.i4_ordinate = i4_y_offset;
327 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
328 .s_ref_array_dims.i4_abscissa = (((i4_x_refmax16 + 15) >> 8) << 4) +
329 ((WORD32) (ps_layer_props->u4_mb_wd >> 1)) - i4_x_offset +
330 16;
331 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
332 .s_ref_array_dims.i4_ordinate = (((i4_y_refmax16 + 15) >> 8) << 4) +
333 ((WORD32) (ps_layer_props->u4_mb_ht >> 1)) - i4_y_offset +
334 16;
335
336 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
337 .s_max_pos.i4_abscissa = ((i4_x_refmax16 + 15) >> 4) - i4_x_offset;
338 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
339 .s_max_pos.i4_ordinate = ((i4_y_refmax16 + 15) >> 4) - i4_y_offset;
340
341 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
342 .s_min_pos.i4_abscissa = (i4_x_refmin16 >> 4) - i4_x_offset;
343 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
344 .s_min_pos.i4_ordinate = (i4_y_refmin16 >> 4) - i4_y_offset;
345
346 if((1.5 == d_spatial_res_ratio) &&
347 ((0 == ps_mb_pos->i4_abscissa) || (0 == ps_mb_pos->i4_ordinate)))
348 {
349 WORD32 i4_min, i4_max, i4_xr_index, i4_yr_index, i4_ref_array_wd, i4_ref_array_ht;
350
351 i4_x_offset = i4_x_offset - 2;
352 i4_ref_array_wd = ((i4_x_refmax16 + 15) >> 4) - (i4_x_refmin16 >> 4) + 1 + 4;
353
354 i4_min = i4_x_offset;
355 i4_xr_index = i4_min - ((i4_min / (WORD32) ps_layer_props->u4_mb_wd) *
356 (WORD32) ps_layer_props->u4_mb_wd);
357
358 if(i4_xr_index < (WORD32) (ps_layer_props->u4_mb_wd >> 1))
359 {
360 i4_ref_array_wd = i4_ref_array_wd + (ps_layer_props->u4_mb_wd >> 1);
361 i4_x_offset = i4_x_offset - ((WORD32) (ps_layer_props->u4_mb_wd >> 1));
362 }
363
364 i4_max = ((i4_x_refmax16 + 15) >> 4) + 2;
365 i4_xr_index = i4_max - ((i4_max / (WORD32) ps_layer_props->u4_mb_wd) *
366 (WORD32) ps_layer_props->u4_mb_wd);
367
368 if(i4_xr_index >= (WORD32) (ps_layer_props->u4_mb_wd >> 1))
369 {
370 i4_ref_array_wd = i4_ref_array_wd + (ps_layer_props->u4_mb_wd >> 1);
371 }
372
373 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
374 .s_ref_array_dims.i4_abscissa = i4_ref_array_wd;
375 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
376 .s_offsets.i4_abscissa = i4_x_offset;
377
378 i4_ref_array_ht = ((i4_y_refmax16 + 15) >> 4) - (i4_y_refmin16 >> 4) + 1 + 4;
379
380 i4_y_offset = (i4_y_refmin16 >> 4) - 2;
381
382 i4_min = i4_y_offset;
383
384 i4_yr_index = i4_min - ((i4_min / (WORD32) ps_layer_props->u4_mb_ht) *
385 (WORD32) ps_layer_props->u4_mb_ht);
386
387 if(i4_yr_index < (WORD32) (ps_layer_props->u4_mb_ht >> 1))
388 {
389 i4_ref_array_ht = i4_ref_array_ht + (ps_layer_props->u4_mb_ht >> 1);
390 i4_y_offset = i4_y_offset - ((WORD32) (ps_layer_props->u4_mb_ht >> 1));
391 }
392
393 i4_max = ((i4_y_refmax16 + 15) >> 4) + 2;
394 i4_yr_index = i4_max - ((i4_max / (WORD32) ps_layer_props->u4_mb_ht) *
395 (WORD32) ps_layer_props->u4_mb_ht);
396
397 if(i4_yr_index >= (WORD32) (ps_layer_props->u4_mb_ht >> 1))
398 {
399 i4_ref_array_ht = i4_ref_array_ht + (ps_layer_props->u4_mb_ht >> 1);
400 }
401
402 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
403 .s_ref_array_dims.i4_ordinate = i4_ref_array_ht;
404 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
405 .s_offsets.i4_ordinate = i4_y_offset;
406
407 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
408 .s_max_pos.i4_abscissa = ((i4_x_refmax16 + 15) >> 4) - i4_x_offset;
409 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
410 .s_max_pos.i4_ordinate = ((i4_y_refmax16 + 15) >> 4) - i4_y_offset;
411
412 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
413 .s_min_pos.i4_abscissa = (i4_x_refmin16 >> 4) - i4_x_offset;
414 ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs]
415 .s_min_pos.i4_ordinate = (i4_y_refmin16 >> 4) - i4_y_offset;
416
417 isvce_ref_array_pos_init(
418 ps_layer_props,
419 &ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs],
420 ps_mb_pos, d_spatial_res_ratio, u1_frame_mbs_only_flag, u1_field_mb_flag,
421 u1_ref_layer_frame_mbs_only_flag);
422
423 isvce_ref_array_phase_init(
424 ps_layer_props,
425 &ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs],
426 ps_mb_pos, d_spatial_res_ratio, u1_frame_mbs_only_flag, u1_field_mb_flag,
427 u1_ref_layer_frame_mbs_only_flag);
428 }
429 else if((2. == d_spatial_res_ratio) &&
430 ((0 == ps_mb_pos->i4_abscissa) && (0 == ps_mb_pos->i4_ordinate) && b_is_chroma))
431 {
432 isvce_ref_array_pos_init(
433 ps_layer_props,
434 &ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs],
435 ps_mb_pos, d_spatial_res_ratio, u1_frame_mbs_only_flag, u1_field_mb_flag,
436 u1_ref_layer_frame_mbs_only_flag);
437
438 isvce_ref_array_phase_init(
439 ps_layer_props,
440 &ps_mb_states[ps_mb_pos->i4_abscissa + ps_mb_pos->i4_ordinate * u4_wd_in_mbs],
441 ps_mb_pos, d_spatial_res_ratio, u1_frame_mbs_only_flag, u1_field_mb_flag,
442 u1_ref_layer_frame_mbs_only_flag);
443 }
444 }
445
isvce_ibl_layer_state_init(intra_pred_layer_state_t * ps_layer_state,DOUBLE d_spatial_res_ratio,UWORD32 u4_wd,UWORD32 u4_ht,UWORD8 u1_level_idc,IV_COLOR_FORMAT_T e_color_format)446 static void isvce_ibl_layer_state_init(intra_pred_layer_state_t *ps_layer_state,
447 DOUBLE d_spatial_res_ratio, UWORD32 u4_wd, UWORD32 u4_ht,
448 UWORD8 u1_level_idc, IV_COLOR_FORMAT_T e_color_format)
449 {
450 UWORD32 i, j, k;
451
452 const UWORD8 u1_ref_layer_field_pic_flag = 0;
453 const UWORD8 u1_field_pic_flag = 0;
454 const UWORD8 u1_frame_mbs_only_flag = 1;
455 const UWORD8 u1_ref_layer_frame_mbs_only_flag = 1;
456 const UWORD8 u1_bot_field_flag = 0;
457 const WORD32 i4_scaled_ref_layer_left_offset = 0;
458 const WORD32 i4_scaled_ref_layer_top_offset = 0;
459 const WORD32 i4_ref_layer_chroma_phase_x_plus1 = 1;
460 const WORD32 i4_ref_layer_chroma_phase_y_plus1 = 1;
461 const WORD32 i4_chroma_phase_x_plus1 = 1;
462 const WORD32 i4_chroma_phase_y_plus1 = 1;
463 const WORD32 i4_sub_wd_chroma = 2;
464 const WORD32 i4_sub_ht_chroma = 2;
465
466 ASSERT((IV_YUV_420P == e_color_format) || (IV_YUV_420SP_UV == e_color_format));
467
468 UNUSED(e_color_format);
469
470 for(i = 0; i < NUM_SP_COMPONENTS; i++)
471 {
472 intra_pred_mb_state_t *ps_mb_states;
473 layer_resampler_props_t *ps_layer_props;
474
475 UWORD32 u4_wd_in_mbs;
476 UWORD32 u4_ht_in_mbs;
477
478 UWORD8 u1_is_chroma = (Y != ((COMPONENT_TYPE) i));
479 UWORD32 u4_ref_wd = (u4_wd / d_spatial_res_ratio);
480 UWORD32 u4_ref_ht = (u4_ht / d_spatial_res_ratio) * (1 + u1_ref_layer_field_pic_flag);
481 UWORD32 u4_scaled_wd = u4_wd;
482 UWORD32 u4_scaled_ht = u4_ht * (1 + u1_field_pic_flag);
483
484 ps_mb_states =
485 u1_is_chroma ? ps_layer_state->ps_chroma_mb_states : ps_layer_state->ps_luma_mb_states;
486 ps_layer_props =
487 u1_is_chroma ? ps_layer_state->ps_chroma_props : ps_layer_state->ps_luma_props;
488
489 u4_ref_wd = u4_ref_wd >> u1_is_chroma;
490 u4_ref_ht = u4_ref_ht >> u1_is_chroma;
491 u4_scaled_wd = u4_scaled_wd >> u1_is_chroma;
492 u4_scaled_ht = u4_scaled_ht >> u1_is_chroma;
493
494 if(u1_is_chroma)
495 {
496 ps_layer_props->i4_refphase_x = i4_ref_layer_chroma_phase_x_plus1 - 1;
497 ps_layer_props->i4_refphase_y = i4_ref_layer_chroma_phase_y_plus1 - 1;
498 ps_layer_props->i4_phase_x = i4_chroma_phase_x_plus1 - 1;
499 ps_layer_props->i4_phase_y = i4_chroma_phase_y_plus1 - 1;
500 ps_layer_props->u4_sub_wd = i4_sub_wd_chroma;
501 ps_layer_props->u4_sub_ht = i4_sub_ht_chroma;
502 ps_layer_props->u4_mb_wd = MB_SIZE >> 1;
503 ps_layer_props->u4_mb_ht = MB_SIZE >> 1;
504 }
505 else
506 {
507 ps_layer_props->i4_refphase_x = 0;
508 ps_layer_props->i4_refphase_y = 0;
509 ps_layer_props->i4_phase_x = 0;
510 ps_layer_props->i4_phase_y = 0;
511 ps_layer_props->u4_sub_wd = 1;
512 ps_layer_props->u4_sub_ht = 1;
513 ps_layer_props->u4_mb_wd = MB_SIZE;
514 ps_layer_props->u4_mb_ht = MB_SIZE;
515 }
516
517 u4_wd_in_mbs = u4_scaled_wd / ps_layer_props->u4_mb_wd;
518 u4_ht_in_mbs = u4_scaled_ht / ps_layer_props->u4_mb_ht;
519
520 if(u1_level_idc <= 30)
521 {
522 ps_layer_props->u4_shift_x = 16;
523 ps_layer_props->u4_shift_y = 16;
524 }
525 else
526 {
527 ps_layer_props->u4_shift_x = 31 - isvcd_get_ceil_log2(u4_ref_wd);
528 ps_layer_props->u4_shift_y = 31 - isvcd_get_ceil_log2(u4_ref_ht);
529 }
530
531 if((0 == u1_frame_mbs_only_flag) || (0 == u1_ref_layer_frame_mbs_only_flag))
532 {
533 if(1 == u1_ref_layer_frame_mbs_only_flag)
534 {
535 ps_layer_props->i4_phase_y = ps_layer_props->i4_phase_y + (4 * u1_bot_field_flag) +
536 3 - ps_layer_props->u4_sub_ht;
537 ps_layer_props->i4_refphase_y = (2 * ps_layer_props->i4_refphase_y) + 2;
538 }
539 else
540 {
541 ps_layer_props->i4_phase_y = ps_layer_props->i4_phase_y + 4 * u1_bot_field_flag;
542 ps_layer_props->i4_refphase_y =
543 ps_layer_props->i4_refphase_y + (4 * u1_bot_field_flag);
544 }
545 }
546
547 ps_layer_props->u4_scale_x =
548 ((u4_ref_wd << ps_layer_props->u4_shift_x) + (u4_scaled_wd >> 1)) / (u4_scaled_wd);
549 ps_layer_props->u4_scale_y =
550 ((u4_ref_ht << ps_layer_props->u4_shift_y) + (u4_scaled_ht >> 1)) / (u4_scaled_ht);
551
552 ps_layer_props->i4_offset_x = i4_scaled_ref_layer_left_offset / ps_layer_props->u4_sub_wd;
553 ps_layer_props->i4_add_x =
554 (((u4_ref_wd * (2 + ps_layer_props->i4_phase_x)) << (ps_layer_props->u4_shift_x - 2)) +
555 (u4_scaled_wd >> 1)) /
556 u4_scaled_wd +
557 (1 << (ps_layer_props->u4_shift_x - 5));
558 ps_layer_props->i4_delta_x = 4 * (2 + ps_layer_props->i4_refphase_x);
559
560 if((1 == u1_frame_mbs_only_flag) && (1 == u1_ref_layer_frame_mbs_only_flag))
561 {
562 ps_layer_props->i4_offset_y =
563 i4_scaled_ref_layer_top_offset / ps_layer_props->u4_sub_ht;
564 ps_layer_props->i4_add_y = (((u4_ref_ht * (2 + ps_layer_props->i4_phase_y))
565 << (ps_layer_props->u4_shift_y - 2)) +
566 (u4_scaled_ht >> 1)) /
567 u4_scaled_ht +
568 (1 << (ps_layer_props->u4_shift_y - 5));
569 ps_layer_props->i4_delta_y = 4 * (2 + ps_layer_props->i4_refphase_y);
570 }
571 else
572 {
573 ps_layer_props->i4_offset_y =
574 i4_scaled_ref_layer_top_offset / (2 * ps_layer_props->u4_sub_ht);
575 ps_layer_props->i4_add_y = (((u4_ref_ht * (2 + ps_layer_props->i4_phase_y))
576 << (ps_layer_props->u4_shift_y - 3)) +
577 (u4_scaled_ht >> 1)) /
578 u4_scaled_ht +
579 (1 << (ps_layer_props->u4_shift_y - 5));
580 ps_layer_props->i4_delta_y = 2 * (2 + ps_layer_props->i4_refphase_y);
581 }
582
583 for(j = 0; j < u4_ht_in_mbs; j++)
584 {
585 for(k = 0; k < u4_wd_in_mbs; k++)
586 {
587 coordinates_t s_mb_pos = {k, j};
588
589 isvce_set_mb_states(ps_layer_props, ps_mb_states, &s_mb_pos, d_spatial_res_ratio,
590 u4_wd_in_mbs, u1_is_chroma);
591 }
592 }
593 }
594 }
595
596 /**
597 *******************************************************************************
598 *
599 * @brief
600 * Function to initialize svc ilp buffers
601 *
602 * @param[in] ps_codec
603 * Pointer to codec context
604 *
605 * @param[in] ps_mem_rec
606 * Pointer to memory allocated for input buffers
607 *
608 *******************************************************************************
609 */
isvce_intra_pred_ctxt_init(isvce_codec_t * ps_codec,iv_mem_rec_t * ps_mem_rec)610 void isvce_intra_pred_ctxt_init(isvce_codec_t *ps_codec, iv_mem_rec_t *ps_mem_rec)
611 {
612 intra_pred_state_t *ps_intra_pred_state;
613 svc_intra_pred_ctxt_t *ps_intra_pred_ctxt;
614 intra_pred_mb_state_t *aps_luma_mb_states[MAX_NUM_SPATIAL_LAYERS];
615 intra_pred_mb_state_t *aps_chroma_mb_states[MAX_NUM_SPATIAL_LAYERS];
616
617 WORD32 i, j, k, l, m;
618 WORD8 *api4_mb_modes[MAX_NUM_SPATIAL_LAYERS];
619
620 isvce_process_ctxt_t *ps_proc = ps_codec->as_process;
621
622 const WORD32 i4_num_proc_ctxts = sizeof(ps_codec->as_process) / sizeof(ps_codec->as_process[0]);
623 DOUBLE d_spatial_res_ratio = ps_codec->s_cfg.s_svc_params.d_spatial_res_ratio;
624 UWORD8 u1_num_spatial_layers = ps_codec->s_cfg.s_svc_params.u1_num_spatial_layers;
625 UWORD32 u4_wd = ps_codec->s_cfg.u4_wd;
626 UWORD32 u4_ht = ps_codec->s_cfg.u4_ht;
627 UWORD8 *pu1_buf = ps_mem_rec->pv_base;
628 WORD64 i8_alloc_mem_size = isvce_get_svc_intra_pred_ctxt_size(
629 u1_num_spatial_layers, d_spatial_res_ratio, u4_wd, u4_ht);
630
631 if(u1_num_spatial_layers > 1)
632 {
633 for(j = 0; j < i4_num_proc_ctxts; j++)
634 {
635 ps_proc = &ps_codec->as_process[j];
636 ps_intra_pred_ctxt = ps_proc->ps_intra_pred_ctxt = (svc_intra_pred_ctxt_t *) pu1_buf;
637 pu1_buf += sizeof(svc_intra_pred_ctxt_t);
638 i8_alloc_mem_size -= sizeof(svc_intra_pred_ctxt_t);
639
640 ps_intra_pred_ctxt->s_intra_pred_constants.pv_state = pu1_buf;
641 ps_intra_pred_state = (intra_pred_state_t *) pu1_buf;
642 pu1_buf += sizeof(intra_pred_state_t);
643 i8_alloc_mem_size -= sizeof(intra_pred_state_t);
644
645 ps_intra_pred_state->ps_layer_state = (intra_pred_layer_state_t *) pu1_buf;
646 pu1_buf += u1_num_spatial_layers * sizeof(ps_intra_pred_state->ps_layer_state[0]);
647 i8_alloc_mem_size -=
648 u1_num_spatial_layers * sizeof(ps_intra_pred_state->ps_layer_state[0]);
649
650 ASSERT(i8_alloc_mem_size >= 0);
651
652 for(i = u1_num_spatial_layers - 1; i >= 0; i--)
653 {
654 intra_pred_layer_state_t *ps_layer_state = &ps_intra_pred_state->ps_layer_state[i];
655
656 WORD32 i4_layer_luma_wd =
657 ((DOUBLE) u4_wd / pow(d_spatial_res_ratio, u1_num_spatial_layers - 1 - i)) +
658 0.99;
659 WORD32 i4_layer_luma_ht =
660 ((DOUBLE) u4_ht / pow(d_spatial_res_ratio, u1_num_spatial_layers - 1 - i)) +
661 0.99;
662 WORD32 i4_layer_wd_mbs = i4_layer_luma_wd / MB_SIZE;
663 WORD32 i4_layer_ht_mbs = i4_layer_luma_ht / MB_SIZE;
664 /* Add PAD MBs on all directions */
665 WORD32 i4_layer_luma_mbs =
666 ((i4_layer_luma_wd / MB_SIZE) + 2) * ((i4_layer_luma_ht / MB_SIZE) + 2);
667 WORD32 i4_num_mb_states =
668 isvce_get_num_mb_states(i4_layer_luma_wd, i4_layer_luma_ht);
669
670 if(0 == j)
671 {
672 UWORD32 au4_ref_xpos_array_size[NUM_SP_COMPONENTS];
673 UWORD32 au4_ref_ypos_array_size[NUM_SP_COMPONENTS];
674 UWORD32 au4_ref_phase_array_size[NUM_SP_COMPONENTS];
675
676 for(k = 0; k < NUM_SP_COMPONENTS; k++)
677 {
678 bool b_is_chroma = ((COMPONENT_TYPE) k) != Y;
679
680 au4_ref_xpos_array_size[k] = MAX_REF_ARR_WD_HT;
681 au4_ref_ypos_array_size[k] = (i4_layer_ht_mbs >> b_is_chroma);
682 au4_ref_phase_array_size[k] =
683 isvce_get_phase_array_size(d_spatial_res_ratio, b_is_chroma);
684 }
685
686 ps_layer_state->ps_luma_mb_states = (intra_pred_mb_state_t *) pu1_buf;
687 aps_luma_mb_states[i] = ps_layer_state->ps_luma_mb_states;
688 pu1_buf += i4_num_mb_states * sizeof(ps_layer_state->ps_luma_mb_states[0]);
689 i8_alloc_mem_size -=
690 i4_num_mb_states * sizeof(ps_layer_state->ps_luma_mb_states[0]);
691
692 ps_layer_state->ps_chroma_mb_states = (intra_pred_mb_state_t *) pu1_buf;
693 aps_chroma_mb_states[i] = ps_layer_state->ps_chroma_mb_states;
694 pu1_buf += i4_num_mb_states * sizeof(ps_layer_state->ps_chroma_mb_states[0]);
695 i8_alloc_mem_size -=
696 i4_num_mb_states * sizeof(ps_layer_state->ps_chroma_mb_states[0]);
697
698 if(1.5 == d_spatial_res_ratio)
699 {
700 for(k = 0; k < NUM_SP_COMPONENTS; k++)
701 {
702 bool b_is_chroma = ((COMPONENT_TYPE) k) != Y;
703
704 WORD32 *pi4_ref_array_positions_x = (WORD32 *) pu1_buf;
705 WORD32 *pi4_ref_array_positions_y =
706 pi4_ref_array_positions_x + MAX_REF_ARR_WD_HT * i4_layer_wd_mbs;
707 coordinates_t *ps_ref_array_phases =
708 (coordinates_t *) (pi4_ref_array_positions_y +
709 (i4_layer_ht_mbs >> b_is_chroma) *
710 i4_layer_ht_mbs);
711 intra_pred_mb_state_t *ps_mb_state =
712 b_is_chroma ? ps_layer_state->ps_chroma_mb_states
713 : ps_layer_state->ps_luma_mb_states;
714
715 for(l = 0; l < i4_layer_ht_mbs; l++)
716 {
717 for(m = 0; m < i4_layer_wd_mbs; m++)
718 {
719 ps_mb_state[l * i4_layer_wd_mbs + m].pi4_ref_array_positions_x =
720 pi4_ref_array_positions_x + m * au4_ref_xpos_array_size[k];
721 ps_mb_state[l * i4_layer_wd_mbs + m].pi4_ref_array_positions_y =
722 pi4_ref_array_positions_y + l * au4_ref_ypos_array_size[k];
723
724 ps_mb_state[l * i4_layer_wd_mbs + m].ps_ref_array_phases =
725 ps_ref_array_phases;
726 }
727 }
728
729 pu1_buf += i4_layer_wd_mbs * au4_ref_xpos_array_size[k] *
730 sizeof(pi4_ref_array_positions_x[0]);
731 pu1_buf += i4_layer_ht_mbs * au4_ref_ypos_array_size[k] *
732 sizeof(pi4_ref_array_positions_y[0]);
733 pu1_buf += au4_ref_phase_array_size[k] * sizeof(ps_ref_array_phases[0]);
734 i8_alloc_mem_size -= i4_layer_wd_mbs * au4_ref_xpos_array_size[k] *
735 sizeof(pi4_ref_array_positions_x[0]);
736 i8_alloc_mem_size -= i4_layer_ht_mbs * au4_ref_ypos_array_size[k] *
737 sizeof(pi4_ref_array_positions_y[0]);
738 i8_alloc_mem_size -=
739 au4_ref_phase_array_size[k] * sizeof(ps_ref_array_phases[0]);
740 }
741 }
742 else
743 {
744 intra_pred_mb_state_t *ps_mb_state;
745 coordinates_t *ps_ref_array_phases;
746
747 for(k = 0; k < NUM_SP_COMPONENTS; k++)
748 {
749 bool b_is_chroma = ((COMPONENT_TYPE) k) != Y;
750
751 ps_mb_state = b_is_chroma ? ps_layer_state->ps_chroma_mb_states
752 : ps_layer_state->ps_luma_mb_states;
753 ps_ref_array_phases = b_is_chroma ? ((coordinates_t *) pu1_buf) : NULL;
754
755 for(l = 0; l < i4_num_mb_states; l++)
756 {
757 ps_mb_state[l].pi4_ref_array_positions_x = NULL;
758 ps_mb_state[l].pi4_ref_array_positions_y = NULL;
759 ps_mb_state[l].ps_ref_array_phases = ps_ref_array_phases;
760 }
761 }
762
763 pu1_buf += au4_ref_phase_array_size[U] * sizeof(ps_ref_array_phases[0]);
764 i8_alloc_mem_size -=
765 au4_ref_phase_array_size[U] * sizeof(ps_ref_array_phases[0]);
766 }
767
768 ps_layer_state->i4_mb_mode_stride = (i4_layer_luma_wd / MB_SIZE) + 2;
769 ps_layer_state->pi1_mb_mode = (WORD8 *) pu1_buf;
770 ps_layer_state->pi1_mb_mode += ps_layer_state->i4_mb_mode_stride + 1;
771 api4_mb_modes[i] = ps_layer_state->pi1_mb_mode;
772 pu1_buf += i4_layer_luma_mbs * sizeof(ps_layer_state->pi1_mb_mode[0]);
773 i8_alloc_mem_size -=
774 u1_num_spatial_layers * sizeof(ps_layer_state->pi1_mb_mode[0]);
775 memset(ps_layer_state->pi1_mb_mode, -1, i4_layer_luma_mbs);
776
777 if(i > 0)
778 {
779 /* Asserts below verify that
780 * 'ps_codec->s_svc_ilp_data.aps_layer_resampler_props' is initialised
781 */
782 ASSERT(ps_codec->s_svc_ilp_data.aps_layer_resampler_props[Y][i].u4_mb_wd ==
783 MB_SIZE);
784 ASSERT(ps_codec->s_svc_ilp_data.aps_layer_resampler_props[UV][i].u4_mb_wd ==
785 (MB_SIZE / 2));
786
787 ps_layer_state->ps_luma_props =
788 &ps_codec->s_svc_ilp_data.aps_layer_resampler_props[Y][i];
789 ps_layer_state->ps_chroma_props =
790 &ps_codec->s_svc_ilp_data.aps_layer_resampler_props[UV][i];
791
792 isvce_ibl_layer_state_init(
793 ps_layer_state, d_spatial_res_ratio, i4_layer_luma_wd, i4_layer_luma_ht,
794 ps_codec->s_cfg.u4_max_level, ps_codec->s_cfg.e_inp_color_fmt);
795 }
796 else
797 {
798 ps_layer_state->ps_luma_props = NULL;
799 ps_layer_state->ps_chroma_props = NULL;
800 }
801 }
802 else
803 {
804 ps_layer_state->ps_luma_mb_states = aps_luma_mb_states[i];
805 ps_layer_state->ps_chroma_mb_states = aps_chroma_mb_states[i];
806
807 ps_layer_state->i4_mb_mode_stride = (i4_layer_luma_wd / MB_SIZE) + 2;
808 ps_layer_state->pi1_mb_mode = api4_mb_modes[i];
809
810 if(i > 0)
811 {
812 ps_layer_state->ps_luma_props =
813 &ps_codec->s_svc_ilp_data.aps_layer_resampler_props[Y][i];
814 ps_layer_state->ps_chroma_props =
815 &ps_codec->s_svc_ilp_data.aps_layer_resampler_props[UV][i];
816 }
817 else
818 {
819 ps_layer_state->ps_luma_props = NULL;
820 ps_layer_state->ps_chroma_props = NULL;
821 }
822 }
823
824 ps_layer_state->pu1_refarray_buffer = (UWORD8 *) pu1_buf;
825 memset(ps_layer_state->pu1_refarray_buffer, 0, TEMP_BUF_SIZE_LUMA * sizeof(UWORD8));
826 pu1_buf += TEMP_BUF_SIZE_LUMA * sizeof(UWORD8);
827 i8_alloc_mem_size -= TEMP_BUF_SIZE_LUMA * sizeof(UWORD8);
828
829 ps_layer_state->pu1_refarray_cb = (UWORD8 *) pu1_buf;
830 memset(ps_layer_state->pu1_refarray_cb, 0, TEMP_BUF_SIZE_CB * sizeof(UWORD8));
831 pu1_buf += TEMP_BUF_SIZE_CB * sizeof(UWORD8);
832 i8_alloc_mem_size -= TEMP_BUF_SIZE_CB * sizeof(UWORD8);
833
834 ps_layer_state->pu1_refarray_cr = (UWORD8 *) pu1_buf;
835 memset(ps_layer_state->pu1_refarray_cr, 0, TEMP_BUF_SIZE_CR * sizeof(UWORD8));
836 pu1_buf += TEMP_BUF_SIZE_CR * sizeof(UWORD8);
837 i8_alloc_mem_size -= TEMP_BUF_SIZE_CR * sizeof(UWORD8);
838
839 ps_layer_state->pi4_temp_interpolation_buffer = (WORD32 *) pu1_buf;
840 pu1_buf += (TEMP_INTERPOLATION_BUF_SIZE * sizeof(WORD32));
841 i8_alloc_mem_size -= (TEMP_INTERPOLATION_BUF_SIZE * sizeof(WORD32));
842
843 ASSERT(i8_alloc_mem_size >= 0);
844 }
845 }
846
847 for(i = 0; i < i4_num_proc_ctxts; i++)
848 {
849 isvce_process_ctxt_t *ps_proc = &ps_codec->as_process[i];
850 svc_intra_pred_ctxt_t *ps_intra_pred_ctxt = ps_proc->ps_intra_pred_ctxt;
851 yuv_buf_props_t *ps_mb_intra_pred_buf =
852 &ps_intra_pred_ctxt->s_intra_pred_outputs.s_pred_buf;
853
854 ps_proc->ps_mb_pred_buf = ps_mb_intra_pred_buf;
855
856 for(j = 0; j < NUM_SP_COMPONENTS; j++)
857 {
858 buffer_container_t *ps_comp_buf = &ps_mb_intra_pred_buf->as_component_bufs[j];
859
860 ps_comp_buf->pv_data = pu1_buf;
861 ps_comp_buf->i4_data_stride = MB_SIZE;
862 pu1_buf += MB_SIZE * MB_SIZE * sizeof(UWORD8);
863 i8_alloc_mem_size -= MB_SIZE * MB_SIZE * sizeof(WORD8);
864
865 ASSERT(i8_alloc_mem_size >= 0);
866 }
867
868 ps_mb_intra_pred_buf->as_component_bufs[V].pv_data = NULL;
869 ps_mb_intra_pred_buf->e_color_format = IV_YUV_420SP_UV;
870 ps_mb_intra_pred_buf->u1_bit_depth = 16;
871 ps_mb_intra_pred_buf->u4_width = MB_SIZE;
872 ps_mb_intra_pred_buf->u4_height = MB_SIZE;
873 }
874 }
875 else
876 {
877 for(i = 0; i < i4_num_proc_ctxts; i++)
878 {
879 isvce_process_ctxt_t *ps_proc = &ps_codec->as_process[i];
880
881 ps_proc->ps_intra_pred_ctxt = NULL;
882 }
883 }
884 }
885
isvce_intra_sampling_function_selector(intra_sampling_ctxt_t * ps_ctxt,DOUBLE d_spatial_res_ratio,IV_ARCH_T e_arch)886 void isvce_intra_sampling_function_selector(intra_sampling_ctxt_t *ps_ctxt,
887 DOUBLE d_spatial_res_ratio, IV_ARCH_T e_arch)
888 {
889 if(2. == d_spatial_res_ratio)
890 {
891 switch(e_arch)
892 {
893 #if defined(X86)
894 case ARCH_X86_SSE42:
895 {
896 ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id].pf_horz_interpol_chroma =
897 isvc_horz_interpol_chroma_dyadic_sse42;
898 ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id].pf_vert_interpol_chroma =
899 isvc_vert_interpol_chroma_dyadic_sse42;
900 ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id].pf_interpolate_luma =
901 isvc_interpolate_base_luma_dyadic_sse42;
902
903 break;
904 }
905 #elif defined(ARMV8)
906 case ARCH_ARM_A53:
907 case ARCH_ARM_A57:
908 case ARCH_ARM_V8_NEON:
909 {
910 ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id].pf_horz_interpol_chroma =
911 isvc_horz_interpol_chroma_dyadic_neon;
912 ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id].pf_vert_interpol_chroma =
913 isvc_vert_interpol_chroma_dyadic_neon;
914 ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id].pf_interpolate_luma =
915 isvc_interpolate_base_luma_dyadic_neon;
916
917 break;
918 }
919 #elif defined(ARM) && !defined(DISABLE_NEON)
920 case ARCH_ARM_A9Q:
921 case ARCH_ARM_A9A:
922 case ARCH_ARM_A9:
923 case ARCH_ARM_A7:
924 case ARCH_ARM_A5:
925 case ARCH_ARM_A15:
926 {
927 ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id].pf_horz_interpol_chroma =
928 isvc_horz_interpol_chroma_dyadic_neon;
929 ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id].pf_vert_interpol_chroma =
930 isvc_vert_interpol_chroma_dyadic_neon;
931 ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id].pf_interpolate_luma =
932 isvc_interpolate_base_luma_dyadic_neon;
933
934 break;
935 }
936 #endif
937 default:
938 {
939 ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id].pf_horz_interpol_chroma =
940 isvc_horz_interpol_chroma_dyadic;
941 ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id].pf_vert_interpol_chroma =
942 isvc_vert_interpol_chroma_dyadic;
943 ps_ctxt->as_res_lyrs[ps_ctxt->i4_res_lyr_id].pf_interpolate_luma =
944 isvc_interpolate_base_luma_dyadic;
945
946 break;
947 }
948 }
949 }
950 }
951
isvce_get_mb_intra_pred(isvce_process_ctxt_t * ps_proc)952 static void isvce_get_mb_intra_pred(isvce_process_ctxt_t *ps_proc)
953 {
954 mem_element_t s_ref_mb_mode;
955 mem_element_t s_inp_luma;
956 mem_element_t s_inp_chroma;
957 mem_element_t s_out_luma;
958 mem_element_t s_out_chroma;
959
960 coordinates_t s_frame_dims;
961 coordinates_t s_frame_dims_in_mbs;
962
963 WORD32 i4_cur_stride;
964 WORD32 i4_ref_stride;
965 WORD32 i;
966
967 intra_sampling_ctxt_t s_intra_samp_ctxt[NUM_SP_COMPONENTS];
968 isvce_codec_t *ps_codec = ps_proc->ps_codec;
969 svc_intra_pred_ctxt_t *ps_intra_pred_ctxt = ps_proc->ps_intra_pred_ctxt;
970 intra_pred_state_t *ps_intra_pred_state =
971 (intra_pred_state_t *) (ps_intra_pred_ctxt->s_intra_pred_constants.pv_state);
972 intra_pred_layer_state_t *ps_layer_state =
973 &ps_intra_pred_state->ps_layer_state[ps_proc->u1_spatial_layer_id];
974 intra_pred_layer_state_t *ps_ref_layer_state =
975 &ps_intra_pred_state->ps_layer_state[ps_proc->u1_spatial_layer_id - 1];
976
977 intra_pred_mb_state_t *ps_luma_mb_state;
978 intra_pred_mb_state_t *ps_chroma_mb_state;
979
980 coordinates_t *ps_mb_pos = &ps_intra_pred_ctxt->s_intra_pred_variables.s_mb_pos;
981 svc_ilp_data_t *ps_svc_ilp_data = ps_intra_pred_ctxt->s_intra_pred_variables.ps_svc_ilp_data;
982
983 s_frame_dims.i4_abscissa =
984 ps_svc_ilp_data->ps_intra_recon_bufs[ps_proc->u1_spatial_layer_id].u4_width;
985 s_frame_dims.i4_ordinate =
986 ps_svc_ilp_data->ps_intra_recon_bufs[ps_proc->u1_spatial_layer_id].u4_height;
987 s_frame_dims_in_mbs.i4_abscissa = s_frame_dims.i4_abscissa / MB_SIZE;
988 s_frame_dims_in_mbs.i4_ordinate = s_frame_dims.i4_ordinate / MB_SIZE;
989
990 ps_luma_mb_state = ps_layer_state->ps_luma_mb_states + ps_mb_pos->i4_abscissa +
991 ps_mb_pos->i4_ordinate * s_frame_dims_in_mbs.i4_abscissa;
992 ps_chroma_mb_state = ps_layer_state->ps_chroma_mb_states + ps_mb_pos->i4_abscissa +
993 ps_mb_pos->i4_ordinate * s_frame_dims_in_mbs.i4_abscissa;
994
995 for(i = 0; i < NUM_SP_COMPONENTS; i++)
996 {
997 UWORD32 u4_ref_wd, u4_ref_ht;
998
999 bool b_is_chroma = (Y != ((COMPONENT_TYPE) i));
1000 mem_element_t *ps_buf = b_is_chroma ? &s_out_chroma : &s_out_luma;
1001 intra_pred_mb_state_t *ps_mb_state = b_is_chroma ? ps_chroma_mb_state : ps_luma_mb_state;
1002 layer_resampler_props_t *ps_layer_props =
1003 b_is_chroma ? ps_layer_state->ps_chroma_props : ps_layer_state->ps_luma_props;
1004
1005 s_intra_samp_ctxt[i].i4_res_lyr_id = ps_proc->u1_spatial_layer_id;
1006
1007 s_intra_samp_ctxt[i].i4_refarray_stride = REF_ARRAY_WIDTH;
1008 s_intra_samp_ctxt[i].i4_ref_width =
1009 ps_svc_ilp_data->ps_intra_recon_bufs[ps_proc->u1_spatial_layer_id - 1].u4_width;
1010 s_intra_samp_ctxt[i].i4_ref_height =
1011 ps_svc_ilp_data->ps_intra_recon_bufs[ps_proc->u1_spatial_layer_id - 1].u4_height;
1012
1013 isvce_intra_sampling_function_selector(&s_intra_samp_ctxt[i],
1014 ps_codec->s_cfg.s_svc_params.d_spatial_res_ratio,
1015 ps_codec->s_cfg.e_arch);
1016
1017 s_intra_samp_ctxt[i].pu1_refarray_buffer = ps_layer_state->pu1_refarray_buffer;
1018 s_intra_samp_ctxt[i].pu1_refarray_cb = ps_layer_state->pu1_refarray_cb;
1019 s_intra_samp_ctxt[i].pu1_refarray_cr = ps_layer_state->pu1_refarray_cr;
1020 s_intra_samp_ctxt[i].pi4_temp_interpolation_buffer =
1021 ps_layer_state->pi4_temp_interpolation_buffer;
1022
1023 s_intra_samp_ctxt[i].as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id].ps_mb_pos = ps_mb_pos;
1024
1025 /* Phase is used only by chroma functions */
1026 s_intra_samp_ctxt[i].as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id].i4_x_phase_0 =
1027 ps_chroma_mb_state->ps_ref_array_phases[0].i4_abscissa;
1028 s_intra_samp_ctxt[i].as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id].i4_x_phase_1 =
1029 ps_chroma_mb_state->ps_ref_array_phases[1].i4_abscissa;
1030 s_intra_samp_ctxt[i].as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id].i4_y_phase_0 =
1031 ps_chroma_mb_state->ps_ref_array_phases[0].i4_ordinate;
1032 s_intra_samp_ctxt[i].as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id].i4_y_phase_1 =
1033 ps_chroma_mb_state->ps_ref_array_phases[2].i4_ordinate;
1034 s_intra_samp_ctxt[i]
1035 .as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id]
1036 .i1_constrained_intra_rsmpl_flag = 0;
1037 s_intra_samp_ctxt[i].as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id].i4_ref_width =
1038 ps_svc_ilp_data->ps_intra_recon_bufs[ps_proc->u1_spatial_layer_id - 1].u4_width;
1039 s_intra_samp_ctxt[i].as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id].i4_ref_height =
1040 ps_svc_ilp_data->ps_intra_recon_bufs[ps_proc->u1_spatial_layer_id - 1].u4_height;
1041
1042 s_intra_samp_ctxt[i].as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id].i2_x_min_pos =
1043 ps_mb_state->s_min_pos.i4_abscissa;
1044 s_intra_samp_ctxt[i].as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id].i2_x_max_pos =
1045 ps_mb_state->s_max_pos.i4_abscissa;
1046 s_intra_samp_ctxt[i].as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id].i2_y_min_pos =
1047 ps_mb_state->s_min_pos.i4_ordinate;
1048 s_intra_samp_ctxt[i].as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id].i2_y_max_pos =
1049 ps_mb_state->s_max_pos.i4_ordinate;
1050
1051 s_intra_samp_ctxt[i].as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id].ps_phase =
1052 ps_mb_state->ps_ref_array_phases;
1053
1054 s_intra_samp_ctxt[i]
1055 .as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id]
1056 .pi4_ref_array_positions_x = ps_mb_state->pi4_ref_array_positions_x;
1057 s_intra_samp_ctxt[i]
1058 .as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id]
1059 .pi4_ref_array_positions_y = ps_mb_state->pi4_ref_array_positions_y;
1060
1061 s_intra_samp_ctxt[i].as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id].ps_offsets =
1062 &ps_mb_state->s_offsets;
1063
1064 s_intra_samp_ctxt[i].as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id].ps_ref_array_dims =
1065 &ps_mb_state->s_ref_array_dims;
1066
1067 i4_cur_stride =
1068 ps_intra_pred_ctxt->s_intra_pred_outputs.s_pred_buf.as_component_bufs[i].i4_data_stride;
1069 ps_buf->pv_buffer =
1070 (UWORD8 *) (ps_intra_pred_ctxt->s_intra_pred_outputs.s_pred_buf.as_component_bufs[i]
1071 .pv_data);
1072
1073 ps_buf->i4_element_size = 1;
1074 ps_buf->i4_num_element_stride = i4_cur_stride;
1075
1076 ps_buf = b_is_chroma ? &s_inp_chroma : &s_inp_luma;
1077
1078 i4_ref_stride = ps_svc_ilp_data->ps_intra_recon_bufs[ps_proc->u1_spatial_layer_id - 1]
1079 .as_component_bufs[i]
1080 .i4_data_stride;
1081
1082 u4_ref_wd = ps_svc_ilp_data->ps_intra_recon_bufs[ps_proc->u1_spatial_layer_id - 1].u4_width;
1083 u4_ref_ht =
1084 ps_svc_ilp_data->ps_intra_recon_bufs[ps_proc->u1_spatial_layer_id - 1].u4_height;
1085
1086 /* For chroma, filteringModeFlag=1 */
1087 /* If filteringModeFlag=1, interpolation requires samples at an offset of -1
1088 * along both directions */
1089 if(ps_proc->s_svc_params.d_spatial_res_ratio == 2.0)
1090 {
1091 WORD8 i1_x_odd, i1_y_odd;
1092
1093 ps_buf->pv_buffer =
1094 (UWORD8 *) ps_svc_ilp_data->ps_intra_recon_bufs[ps_proc->u1_spatial_layer_id - 1]
1095 .as_component_bufs[i]
1096 .pv_data +
1097 (ps_mb_state->s_offsets.i4_abscissa << b_is_chroma) +
1098 ps_mb_state->s_offsets.i4_ordinate * i4_ref_stride;
1099
1100 if(!b_is_chroma)
1101 {
1102 ps_buf->pv_buffer = ((UWORD8 *) ps_buf->pv_buffer) + -1 + -1 * i4_ref_stride;
1103 }
1104
1105 i1_x_odd = (ps_proc->i4_mb_x & 1);
1106 i1_y_odd = (ps_proc->i4_mb_y & 1);
1107
1108 if(i1_x_odd)
1109 {
1110 ps_buf->pv_buffer = (UWORD8 *) ps_buf->pv_buffer - 8;
1111 }
1112 if(i1_y_odd)
1113 {
1114 ps_buf->pv_buffer =
1115 (UWORD8 *) ps_buf->pv_buffer - ((8 >> b_is_chroma) * i4_ref_stride);
1116 }
1117 }
1118 else
1119 {
1120 WORD32 i4_horz_dim = 0;
1121 WORD32 i4_vert_dim = 0;
1122 WORD32 i4_dim =
1123 (WORD32) (ps_mb_state->s_max_pos.i4_abscissa - ps_mb_state->s_min_pos.i4_abscissa) +
1124 (4 >> b_is_chroma);
1125
1126 if(i4_dim > i4_horz_dim)
1127 {
1128 i4_horz_dim = i4_dim;
1129 }
1130
1131 i4_dim =
1132 (WORD32) (ps_mb_state->s_max_pos.i4_ordinate - ps_mb_state->s_min_pos.i4_ordinate) +
1133 (4 >> b_is_chroma);
1134
1135 if(i4_dim > i4_vert_dim)
1136 {
1137 i4_vert_dim = i4_dim;
1138 }
1139
1140 isvc_intra_resamp_generate_segment_lookup(
1141 &(s_intra_samp_ctxt[i]
1142 .as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id]
1143 .as_seg_lookup_horz[0]),
1144 i4_horz_dim, ps_layer_props->u4_mb_wd, 3);
1145
1146 isvc_intra_resamp_generate_segment_lookup(
1147 &(s_intra_samp_ctxt[i]
1148 .as_res_lyrs[s_intra_samp_ctxt[i].i4_res_lyr_id]
1149 .as_seg_lookup_vert[0]),
1150 i4_vert_dim, ps_layer_props->u4_mb_ht, 4);
1151
1152 ps_buf->pv_buffer =
1153 (UWORD8 *) ps_svc_ilp_data->ps_intra_recon_bufs[ps_proc->u1_spatial_layer_id - 1]
1154 .as_component_bufs[i]
1155 .pv_data +
1156 (CLIP3(0, (WORD32) u4_ref_wd - 1, ps_mb_state->s_offsets.i4_abscissa)
1157 << b_is_chroma) +
1158 CLIP3(0, (WORD32) u4_ref_ht - 1, ps_mb_state->s_offsets.i4_ordinate) *
1159 i4_ref_stride;
1160 }
1161
1162 ps_buf->i4_element_size = 1;
1163 ps_buf->i4_num_element_stride = i4_ref_stride;
1164 }
1165
1166 s_ref_mb_mode.i4_element_size = 1;
1167 s_ref_mb_mode.i4_num_element_stride =
1168 (ps_svc_ilp_data->ps_intra_recon_bufs[ps_proc->u1_spatial_layer_id - 1].u4_width >> 4) + 2;
1169 s_ref_mb_mode.pv_buffer = ps_ref_layer_state->pi1_mb_mode;
1170
1171 if(ps_proc->s_svc_params.d_spatial_res_ratio == 2.0)
1172 {
1173 isvc_intra_samp_mb_dyadic(&s_intra_samp_ctxt[Y], &s_inp_luma, &s_inp_chroma, &s_ref_mb_mode,
1174 &s_out_luma, &s_out_chroma, ps_proc->i4_mb_x, ps_proc->i4_mb_y, 0,
1175 0);
1176 }
1177 else
1178 {
1179 isvc_intra_samp_mb(&s_intra_samp_ctxt[Y], &s_intra_samp_ctxt[UV], &s_inp_luma,
1180 &s_inp_chroma, &s_ref_mb_mode, &s_out_luma, &s_out_chroma);
1181 }
1182 }
1183
isvce_get_sad(UWORD8 * pu1_src,UWORD8 * pu1_pred,UWORD32 src_strd,UWORD32 pred_strd,WORD32 * pi4_distortion,UWORD32 u4_width,UWORD32 u4_height)1184 static FORCEINLINE void isvce_get_sad(UWORD8 *pu1_src, UWORD8 *pu1_pred, UWORD32 src_strd,
1185 UWORD32 pred_strd, WORD32 *pi4_distortion, UWORD32 u4_width,
1186 UWORD32 u4_height)
1187 {
1188 UWORD32 i, j;
1189 *pi4_distortion = 0;
1190 for(i = 0; i < u4_width; i++)
1191 {
1192 for(j = 0; j < u4_height; j++)
1193 {
1194 *pi4_distortion += ABS(pu1_src[j] - pu1_pred[j]);
1195 }
1196 pu1_src += src_strd;
1197 pu1_pred += pred_strd;
1198 }
1199 }
1200
1201 /**
1202 ******************************************************************************
1203 *
1204 * @brief
1205 * evaluate IBL mode
1206 *
1207 * @par Description
1208 * This function evaluates IBL mode for the macro-block
1209 *
1210 * @param[in] ps_proc_ctxt
1211 * pointer to proc ctxt
1212 *
1213 * @return none
1214 *
1215 ******************************************************************************
1216 */
isvce_evaluate_IBL_mode(isvce_process_ctxt_t * ps_proc)1217 void isvce_evaluate_IBL_mode(isvce_process_ctxt_t *ps_proc)
1218 {
1219 isvce_codec_t *ps_codec = ps_proc->ps_codec;
1220 svc_intra_pred_ctxt_t *ps_intra_pred_ctxt = ps_proc->ps_intra_pred_ctxt;
1221
1222 /* SAD(distortion metric) of a block */
1223 WORD32 i4_mb_distortion_least = INT_MAX;
1224
1225 /* cost = distortion + lambda*rate */
1226 WORD32 i4_mb_cost_least = INT_MAX;
1227
1228 WORD32 i4_src_strd = ps_proc->s_src_buf_props.as_component_bufs[Y].i4_data_stride;
1229
1230 UWORD8 *pu1_mb_src = (UWORD8 *) (ps_proc->s_src_buf_props.as_component_bufs[Y].pv_data);
1231
1232 WORD32 u4_cur_stride =
1233 ps_intra_pred_ctxt->s_intra_pred_outputs.s_pred_buf.as_component_bufs[Y].i4_data_stride;
1234
1235 UWORD8 *pu1_mb_pred =
1236 (UWORD8 *) (ps_intra_pred_ctxt->s_intra_pred_outputs.s_pred_buf.as_component_bufs[Y]
1237 .pv_data);
1238
1239 ps_intra_pred_ctxt->s_intra_pred_variables.ps_svc_ilp_data = &ps_codec->s_svc_ilp_data;
1240 ps_intra_pred_ctxt->s_intra_pred_variables.s_mb_pos.i4_abscissa = ps_proc->i4_mb_x;
1241 ps_intra_pred_ctxt->s_intra_pred_variables.s_mb_pos.i4_ordinate = ps_proc->i4_mb_y;
1242 ps_intra_pred_ctxt->s_intra_pred_variables.u1_spatial_layer_id = ps_proc->u1_spatial_layer_id;
1243
1244 isvce_get_mb_intra_pred(ps_proc);
1245
1246 /* Luma cost */
1247 isvce_get_sad(pu1_mb_src, pu1_mb_pred, i4_src_strd, u4_cur_stride, &i4_mb_distortion_least,
1248 ps_intra_pred_ctxt->s_intra_pred_outputs.s_pred_buf.u4_width,
1249 ps_intra_pred_ctxt->s_intra_pred_outputs.s_pred_buf.u4_height);
1250
1251 /* cost = distortion + lambda*rate */
1252 i4_mb_cost_least = i4_mb_distortion_least;
1253
1254 /* update the type of the mb if necessary */
1255 if(i4_mb_cost_least < ps_proc->i4_mb_cost)
1256 {
1257 ps_proc->i4_mb_cost = i4_mb_cost_least;
1258 ps_proc->i4_mb_distortion = i4_mb_distortion_least;
1259 ps_proc->ps_mb_info->i4_mb_distortion = i4_mb_distortion_least;
1260 ps_proc->ps_mb_info->u2_mb_type = BASE_MODE;
1261 ps_proc->ps_mb_info->u1_base_mode_flag = 1;
1262 ps_proc->ps_mb_info->u1_is_intra = 1;
1263 }
1264 else if(ps_proc->ps_mb_info->u2_mb_type != BASE_MODE)
1265 {
1266 ps_proc->ps_mb_info->u1_base_mode_flag = 0;
1267 }
1268 }
1269
isvce_update_ibl_info(svc_intra_pred_ctxt_t * ps_intra_pred_ctxt,UWORD8 u1_num_spatial_layers,UWORD8 u1_spatial_layer_id,UWORD16 u2_mb_type,WORD32 i4_mb_x,WORD32 i4_mb_y,WORD8 u1_base_mode_flag)1270 void isvce_update_ibl_info(svc_intra_pred_ctxt_t *ps_intra_pred_ctxt, UWORD8 u1_num_spatial_layers,
1271 UWORD8 u1_spatial_layer_id, UWORD16 u2_mb_type, WORD32 i4_mb_x,
1272 WORD32 i4_mb_y, WORD8 u1_base_mode_flag)
1273 {
1274 if(u1_num_spatial_layers > 1)
1275 {
1276 intra_pred_state_t *ps_intra_pred_state =
1277 (intra_pred_state_t *) (ps_intra_pred_ctxt->s_intra_pred_constants.pv_state);
1278 intra_pred_layer_state_t *ps_layer_state =
1279 &ps_intra_pred_state->ps_layer_state[u1_spatial_layer_id];
1280 WORD8 i1_is_intra = (u2_mb_type == I4x4 || u2_mb_type == I16x16 || u2_mb_type == I8x8);
1281
1282 WORD8 *pi1_mb_mode =
1283 &ps_layer_state->pi1_mb_mode[i4_mb_x + (i4_mb_y * (ps_layer_state->i4_mb_mode_stride))];
1284
1285 if(u1_base_mode_flag == 1)
1286 {
1287 *pi1_mb_mode = SVC_IBL_MB;
1288 }
1289 else
1290 {
1291 if(i1_is_intra)
1292 {
1293 *pi1_mb_mode = SVC_INTRA_MB;
1294 }
1295 else
1296 {
1297 *pi1_mb_mode = SVC_INTER_MB;
1298 }
1299 }
1300 }
1301 }
1302
isvce_pad_mb_mode_buf(svc_intra_pred_ctxt_t * ps_intra_pred_ctxt,UWORD8 u1_spatial_layer_id,UWORD8 u1_num_spatial_layers,DOUBLE d_spatial_res_ratio,UWORD32 u4_wd,UWORD32 u4_ht)1303 void isvce_pad_mb_mode_buf(svc_intra_pred_ctxt_t *ps_intra_pred_ctxt, UWORD8 u1_spatial_layer_id,
1304 UWORD8 u1_num_spatial_layers, DOUBLE d_spatial_res_ratio, UWORD32 u4_wd,
1305 UWORD32 u4_ht)
1306 {
1307 if(u1_num_spatial_layers > 1)
1308 {
1309 intra_pred_state_t *ps_intra_pred_state =
1310 (intra_pred_state_t *) (ps_intra_pred_ctxt->s_intra_pred_constants.pv_state);
1311 intra_pred_layer_state_t *ps_layer_state =
1312 &ps_intra_pred_state->ps_layer_state[u1_spatial_layer_id];
1313
1314 WORD32 i4_layer_luma_wd =
1315 ((DOUBLE) u4_wd /
1316 pow(d_spatial_res_ratio, u1_num_spatial_layers - 1 - u1_spatial_layer_id)) +
1317 0.99;
1318 WORD32 i4_layer_luma_ht =
1319 ((DOUBLE) u4_ht /
1320 pow(d_spatial_res_ratio, u1_num_spatial_layers - 1 - u1_spatial_layer_id)) +
1321 0.99;
1322
1323 WORD32 row, src_strd;
1324 WORD8 *pu1_src;
1325
1326 WORD8 *pi1_mb_mode = ps_layer_state->pi1_mb_mode;
1327 WORD32 i4_mb_mode_stride = ps_layer_state->i4_mb_mode_stride;
1328
1329 /* Add PAD MBs on all directions */
1330 i4_layer_luma_wd /= MB_SIZE;
1331 i4_layer_luma_ht /= MB_SIZE;
1332
1333 if(d_spatial_res_ratio == 2.0)
1334 {
1335 UWORD8 *pu1_mb_mode = (UWORD8 *) pi1_mb_mode;
1336 /* Pad left */
1337 ih264_pad_left_luma(pu1_mb_mode, i4_mb_mode_stride, i4_layer_luma_ht, 1);
1338
1339 /* Pad right */
1340 ih264_pad_right_luma(pu1_mb_mode + i4_layer_luma_wd, i4_mb_mode_stride,
1341 i4_layer_luma_ht, 1);
1342
1343 /* Pad top */
1344 ih264_pad_top(pu1_mb_mode - 1, i4_mb_mode_stride, i4_layer_luma_wd + 2, 1);
1345
1346 /* Pad bottom */
1347 ih264_pad_bottom(pu1_mb_mode + (i4_layer_luma_ht * i4_mb_mode_stride) - 1,
1348 i4_mb_mode_stride, i4_layer_luma_wd + 2, 1);
1349 }
1350 else
1351 {
1352 /* Pad left */
1353 pu1_src = pi1_mb_mode;
1354 src_strd = i4_mb_mode_stride;
1355 for(row = 0; row < i4_layer_luma_ht; row++)
1356 {
1357 memset(pu1_src - 1, -1, 1);
1358 pu1_src += src_strd;
1359 }
1360
1361 /* Pad right */
1362 pu1_src = pi1_mb_mode + i4_layer_luma_wd;
1363 for(row = 0; row < i4_layer_luma_ht; row++)
1364 {
1365 memset(pu1_src, -1, 1);
1366 pu1_src += src_strd;
1367 }
1368
1369 /* Pad top */
1370 pu1_src = pi1_mb_mode - 1;
1371 memset(pu1_src - src_strd, -1, i4_layer_luma_wd + 2);
1372
1373 /* Pad bottom */
1374 pu1_src = pi1_mb_mode + (i4_layer_luma_ht * i4_mb_mode_stride) - 1;
1375 memset(pu1_src, -1, i4_layer_luma_wd + 2);
1376 }
1377 }
1378 }
1379