1 /******************************************************************************
2 *
3 * Copyright (C) 2012 Ittiam Systems Pvt Ltd, Bangalore
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 /**
19 *******************************************************************************
20 * @file
21 * ihevcd_utils.c
22 *
23 * @brief
24 * Contains miscellaneous utility functions such as init() etc
25 *
26 * @author
27 * Harish
28 *
29 * @par List of Functions:
30 *
31 * @remarks
32 * None
33 *
34 *******************************************************************************
35 */
36 /*****************************************************************************/
37 /* File Includes */
38 /*****************************************************************************/
39 #include <stdio.h>
40 #include <stddef.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <assert.h>
44
45 #include "ihevc_typedefs.h"
46 #include "iv.h"
47 #include "ivd.h"
48 #include "ihevcd_cxa.h"
49 #include "ithread.h"
50
51 #include "ihevc_defs.h"
52 #include "ihevc_debug.h"
53 #include "ihevc_defs.h"
54 #include "ihevc_error.h"
55 #include "ihevc_structs.h"
56 #include "ihevc_buf_mgr.h"
57 #include "ihevc_dpb_mgr.h"
58 #include "ihevc_macros.h"
59 #include "ihevc_platform_macros.h"
60
61 #include "ihevc_common_tables.h"
62 #include "ihevc_buf_mgr.h"
63 #include "ihevc_disp_mgr.h"
64 #include "ihevc_cabac_tables.h"
65
66 #include "ihevcd_defs.h"
67
68 #include "ihevcd_function_selector.h"
69 #include "ihevcd_structs.h"
70 #include "ihevcd_error.h"
71 #include "ihevcd_nal.h"
72 #include "ihevcd_bitstream.h"
73 #include "ihevcd_utils.h"
74 #include "ihevcd_trace.h"
75 #include "ihevcd_process_slice.h"
76 #include "ihevcd_job_queue.h"
77 #define MAX_DPB_PIC_BUF 6
78
79 /* Function declarations */
80 mv_buf_t* ihevcd_mv_mgr_get_poc(buf_mgr_t *ps_mv_buf_mgr, UWORD32 abs_poc);
81
82 /**
83 *******************************************************************************
84 *
85 * @brief
86 * Used to get level index for a given level
87 *
88 * @par Description:
89 * Converts from level_idc (which is multiplied by 30) to an index that can be
90 * used as a lookup. Also used to ignore invalid levels like 2.2 , 3.2 etc
91 *
92 * @param[in] level
93 * Level of the stream
94 *
95 * @returns Level index for a given level
96 *
97 * @remarks
98 *
99 *
100 *******************************************************************************
101 */
ihevcd_get_lvl_idx(WORD32 level)102 WORD32 ihevcd_get_lvl_idx(WORD32 level)
103 {
104 WORD32 lvl_idx = 0;
105
106 if(level < IHEVC_LEVEL_20)
107 {
108 lvl_idx = 0;
109 }
110 else if(level >= IHEVC_LEVEL_20 && level < IHEVC_LEVEL_21)
111 {
112 lvl_idx = 1;
113 }
114 else if(level >= IHEVC_LEVEL_21 && level < IHEVC_LEVEL_30)
115 {
116 lvl_idx = 2;
117 }
118 else if(level >= IHEVC_LEVEL_30 && level < IHEVC_LEVEL_31)
119 {
120 lvl_idx = 3;
121 }
122 else if(level >= IHEVC_LEVEL_31 && level < IHEVC_LEVEL_40)
123 {
124 lvl_idx = 4;
125 }
126 else if(level >= IHEVC_LEVEL_40 && level < IHEVC_LEVEL_41)
127 {
128 lvl_idx = 5;
129 }
130 else if(level >= IHEVC_LEVEL_41 && level < IHEVC_LEVEL_50)
131 {
132 lvl_idx = 6;
133 }
134 else if(level >= IHEVC_LEVEL_50 && level < IHEVC_LEVEL_51)
135 {
136 lvl_idx = 7;
137 }
138 else if(level >= IHEVC_LEVEL_51 && level < IHEVC_LEVEL_52)
139 {
140 lvl_idx = 8;
141 }
142 else if(level >= IHEVC_LEVEL_52 && level < IHEVC_LEVEL_60)
143 {
144 lvl_idx = 9;
145 }
146 else if(level >= IHEVC_LEVEL_60 && level < IHEVC_LEVEL_61)
147 {
148 lvl_idx = 10;
149 }
150 else if(level >= IHEVC_LEVEL_61 && level < IHEVC_LEVEL_62)
151 {
152 lvl_idx = 11;
153 }
154 else if(level >= IHEVC_LEVEL_62)
155 {
156 lvl_idx = 12;
157 }
158
159 return (lvl_idx);
160 }
161
162 /**
163 *******************************************************************************
164 *
165 * @brief
166 * Used to get reference picture buffer size for a given level and
167 * and padding used
168 *
169 * @par Description:
170 * Used to get reference picture buffer size for a given level and padding used
171 * Each picture is padded on all four sides
172 *
173 * @param[in] pic_size
174 * Mumber of luma samples (Width * Height)
175 *
176 * @param[in] level
177 * Level
178 *
179 * @param[in] horz_pad
180 * Total padding used in horizontal direction
181 *
182 * @param[in] vert_pad
183 * Total padding used in vertical direction
184 *
185 * @returns Total picture buffer size
186 *
187 * @remarks
188 *
189 *
190 *******************************************************************************
191 */
ihevcd_get_total_pic_buf_size(codec_t * ps_codec,WORD32 wd,WORD32 ht)192 WORD32 ihevcd_get_total_pic_buf_size(codec_t *ps_codec,
193 WORD32 wd,
194 WORD32 ht)
195 {
196 WORD32 size;
197 WORD32 num_luma_samples;
198 WORD32 max_dpb_size;
199 WORD32 num_samples;
200
201
202 sps_t *ps_sps = (ps_codec->s_parse.ps_sps_base + ps_codec->i4_sps_id);
203
204 /* Get maximum number of buffers for the current picture size */
205 max_dpb_size = ps_sps->ai1_sps_max_dec_pic_buffering[ps_sps->i1_sps_max_sub_layers - 1];
206
207 if(ps_codec->e_frm_out_mode != IVD_DECODE_FRAME_OUT)
208 max_dpb_size += ps_sps->ai1_sps_max_num_reorder_pics[ps_sps->i1_sps_max_sub_layers - 1];
209
210 max_dpb_size++;
211 /* Allocation is required for
212 * (Wd + horz_pad) * (Ht + vert_pad) * (2 * max_dpb_size + 1)
213 */
214
215 /* Account for padding area */
216 num_luma_samples = (wd + PAD_WD) * (ht + PAD_HT);
217
218 /* Account for chroma */
219 num_samples = num_luma_samples * 3 / 2;
220
221 /* Number of bytes in reference pictures */
222 size = num_samples * max_dpb_size;
223
224
225 return size;
226 }
227 /**
228 *******************************************************************************
229 *
230 * @brief
231 * Used to get MV bank size for a given number of luma samples
232 *
233 * @par Description:
234 * For given number of luma samples one MV bank size is computed
235 * Each MV bank includes pu_map and pu_t for all the min PUs(4x4) in a picture
236 *
237 * @param[in] num_luma_samples
238 * Max number of luma pixels in the frame
239 *
240 * @returns Total MV Bank size
241 *
242 * @remarks
243 *
244 *
245 *******************************************************************************
246 */
ihevcd_get_pic_mv_bank_size(WORD32 num_luma_samples)247 WORD32 ihevcd_get_pic_mv_bank_size(WORD32 num_luma_samples)
248 {
249 WORD32 size;
250
251 WORD32 pic_size;
252
253 WORD32 mv_bank_size;
254 WORD32 num_pu;
255 WORD32 num_ctb;
256 pic_size = num_luma_samples;
257
258
259 num_pu = pic_size / (MIN_PU_SIZE * MIN_PU_SIZE);
260 num_ctb = pic_size / (MIN_CTB_SIZE * MIN_CTB_SIZE);
261
262 mv_bank_size = 0;
263
264 /* Size for storing pu_t start index each CTB */
265 /* One extra entry is needed to compute number of PUs in the last CTB */
266 mv_bank_size += (num_ctb + 1) * sizeof(WORD32);
267
268 /* Size for pu_map */
269 mv_bank_size += num_pu;
270
271 /* Size for storing pu_t for each PU */
272 mv_bank_size += num_pu * sizeof(pu_t);
273
274 /* Size for storing slice_idx for each CTB */
275 mv_bank_size += ALIGN4(num_ctb * sizeof(UWORD16));
276
277 size = mv_bank_size;
278 return size;
279 }
280 /**
281 *******************************************************************************
282 *
283 * @brief
284 * Used to get TU data size for a given number luma samples
285 *
286 * @par Description:
287 * For a given number of luma samples TU data size is computed
288 * Each TU data includes tu_map and tu_t and coeff data for all
289 * the min TUs(4x4) in given CTB
290 *
291 * @param[in] num_luma_samples
292 * Number of 64 x 64 CTBs for which TU data has to be allocated.
293 *
294 * @returns Total TU data size
295 *
296 * @remarks Assumption is num_luma_samples will be at least
297 * 64 x 64 to handle CTB of size 64 x 64. Can be frame size as well
298 *
299 *******************************************************************************
300 */
ihevcd_get_tu_data_size(WORD32 num_luma_samples)301 WORD32 ihevcd_get_tu_data_size(WORD32 num_luma_samples)
302 {
303
304
305 WORD32 tu_data_size;
306 WORD32 num_ctb;
307 WORD32 num_luma_tu, num_chroma_tu, num_tu;
308 num_ctb = num_luma_samples / (MIN_CTB_SIZE * MIN_CTB_SIZE);
309
310 num_luma_tu = num_luma_samples / (MIN_TU_SIZE * MIN_TU_SIZE);
311 num_chroma_tu = num_luma_tu >> 1;
312
313 num_tu = num_luma_tu + num_chroma_tu;
314 tu_data_size = 0;
315
316 /* Size for storing tu_t start index each CTB */
317 /* One extra entry is needed to compute number of TUs in the last CTB */
318 tu_data_size += (num_ctb + 1) * sizeof(WORD32);
319
320 /* Size for storing tu map */
321 tu_data_size += num_luma_tu * sizeof(UWORD8);
322
323 /* Size for storing tu_t for each TU */
324 tu_data_size += num_tu * sizeof(tu_t);
325
326 /* Size for storing number of coded subblocks and scan_idx for each TU */
327 tu_data_size += num_tu * (sizeof(WORD8) + sizeof(WORD8));
328
329 /* Size for storing coeff data for each TU */
330 tu_data_size += num_tu * sizeof(tu_sblk_coeff_data_t);
331
332
333 return tu_data_size;
334 }
335
336
ihevcd_nctb_cnt(codec_t * ps_codec,sps_t * ps_sps)337 WORD32 ihevcd_nctb_cnt(codec_t *ps_codec, sps_t *ps_sps)
338 {
339 WORD32 nctb = 1;
340 UNUSED(ps_codec);
341 //TODO: Currently set to 1
342 /* If CTB size is less than 32 x 32 then set nCTB as 4 */
343 if(ps_sps->i1_log2_ctb_size < 5)
344 nctb = 1;
345
346 return nctb;
347 }
348
ihevcd_get_tile_pos(pps_t * ps_pps,sps_t * ps_sps,WORD32 ctb_x,WORD32 ctb_y,WORD32 * pi4_ctb_tile_x,WORD32 * pi4_ctb_tile_y,WORD32 * pi4_tile_idx)349 IHEVCD_ERROR_T ihevcd_get_tile_pos(pps_t *ps_pps,
350 sps_t *ps_sps,
351 WORD32 ctb_x,
352 WORD32 ctb_y,
353 WORD32 *pi4_ctb_tile_x,
354 WORD32 *pi4_ctb_tile_y,
355 WORD32 *pi4_tile_idx)
356 {
357
358 tile_t *ps_tile_tmp;
359 WORD32 i;
360 WORD32 tile_row, tile_col;
361
362 if(ctb_x < 0 || ctb_y < 0)
363 {
364 *pi4_ctb_tile_x = 0;
365 *pi4_ctb_tile_y = 0;
366 *pi4_tile_idx = 0;
367
368 return (IHEVCD_ERROR_T)IHEVCD_SUCCESS;
369 }
370
371 tile_row = 0;
372 tile_col = 0;
373 ps_tile_tmp = ps_pps->ps_tile;
374 if(0 == ps_pps->i1_tiles_enabled_flag)
375 {
376 *pi4_ctb_tile_x = ctb_x;
377 *pi4_ctb_tile_y = ctb_y;
378 *pi4_tile_idx = 0;
379 }
380 else
381 {
382 for(i = 0; i < ps_pps->i1_num_tile_columns; i++)
383 {
384 WORD16 next_tile_ctb_x;
385 ps_tile_tmp = ps_pps->ps_tile + i; //* ps_pps->i1_num_tile_rows;
386 if((ps_pps->i1_num_tile_columns - 1) == i)
387 {
388 next_tile_ctb_x = ps_sps->i2_pic_wd_in_ctb;
389 }
390 else
391 {
392 tile_t *ps_tile_next_tmp;
393 ps_tile_next_tmp = ps_pps->ps_tile + i + 1;
394 next_tile_ctb_x = ps_tile_next_tmp->u1_pos_x;
395 }
396 if((ctb_x >= ps_tile_tmp->u1_pos_x) && (ctb_x < next_tile_ctb_x))
397 {
398 tile_col = i;
399 break;
400 }
401 }
402 *pi4_ctb_tile_x = ctb_x - ps_tile_tmp->u1_pos_x;
403
404 for(i = 0; i < ps_pps->i1_num_tile_rows; i++)
405 {
406 WORD16 next_tile_ctb_y;
407 ps_tile_tmp = ps_pps->ps_tile + i * ps_pps->i1_num_tile_columns;
408 if((ps_pps->i1_num_tile_rows - 1) == i)
409 {
410 next_tile_ctb_y = ps_sps->i2_pic_ht_in_ctb;
411 }
412 else
413 {
414 tile_t *ps_tile_next_tmp;
415 ps_tile_next_tmp = ps_pps->ps_tile + ((i + 1) * ps_pps->i1_num_tile_columns);
416 next_tile_ctb_y = ps_tile_next_tmp->u1_pos_y;
417 }
418 if((ctb_y >= ps_tile_tmp->u1_pos_y) && (ctb_y < next_tile_ctb_y))
419 {
420 tile_row = i;
421 break;
422 }
423
424 }
425 *pi4_ctb_tile_y = ctb_y - ps_tile_tmp->u1_pos_y;
426 *pi4_tile_idx = tile_row * ps_pps->i1_num_tile_columns
427 + tile_col;
428 }
429 return (IHEVCD_ERROR_T)IHEVCD_SUCCESS;
430 }
431 /**
432 *******************************************************************************
433 *
434 * @brief
435 * Function to initialize ps_pic_buf structs add pic buffers to
436 * buffer manager in case of non-shared mode
437 *
438 * @par Description:
439 * Function to initialize ps_pic_buf structs add pic buffers to
440 * buffer manager in case of non-shared mode
441 * To be called once per stream or for every reset
442 *
443 * @param[in] ps_codec
444 * Pointer to codec context
445 *
446 * @returns Error from IHEVCD_ERROR_T
447 *
448 * @remarks
449 *
450 *
451 *******************************************************************************
452 */
ihevcd_pic_buf_mgr_add_bufs(codec_t * ps_codec)453 IHEVCD_ERROR_T ihevcd_pic_buf_mgr_add_bufs(codec_t *ps_codec)
454 {
455 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS;
456 WORD32 i;
457 WORD32 max_dpb_size;
458 sps_t *ps_sps;
459 UWORD8 *pu1_buf;
460 pic_buf_t *ps_pic_buf;
461 WORD32 pic_buf_size_allocated;
462
463
464
465
466 /* Initialize Pic buffer manager */
467 ps_sps = ps_codec->s_parse.ps_sps;
468
469 /* Compute the number of Pic buffers needed */
470 max_dpb_size = ps_sps->ai1_sps_max_dec_pic_buffering[ps_sps->i1_sps_max_sub_layers - 1];
471
472 if(ps_codec->e_frm_out_mode != IVD_DECODE_FRAME_OUT)
473 max_dpb_size += ps_sps->ai1_sps_max_num_reorder_pics[ps_sps->i1_sps_max_sub_layers - 1];
474
475 /* Allocate one extra picture to handle current frame
476 * In case of asynchronous parsing and processing, number of buffers should increase here
477 * based on when parsing and processing threads are synchronized
478 */
479 max_dpb_size++;
480
481
482 pu1_buf = (UWORD8 *)ps_codec->pu1_ref_pic_buf_base;
483
484 ps_pic_buf = (pic_buf_t *)ps_codec->ps_pic_buf;
485
486 /* In case of non-shared mode, add picture buffers to buffer manager
487 * In case of shared mode buffers are added in the run-time
488 */
489 if(0 == ps_codec->i4_share_disp_buf)
490 {
491 WORD32 buf_ret;
492 WORD32 luma_samples;
493 WORD32 chroma_samples;
494 pic_buf_size_allocated = ps_codec->i4_total_pic_buf_size;
495
496 luma_samples = (ps_codec->i4_strd) *
497 (ps_sps->i2_pic_height_in_luma_samples + PAD_HT);
498
499 chroma_samples = luma_samples / 2;
500
501 /* Try to add as many buffers as possible since memory is already allocated */
502 /* If the number of buffers that can be added is less than max_num_bufs
503 * return with an error.
504 */
505 for(i = 0; i < max_dpb_size; i++)
506 {
507 pic_buf_size_allocated -= (luma_samples + chroma_samples);
508
509 if(pic_buf_size_allocated < 0)
510 {
511 ps_codec->s_parse.i4_error_code = IHEVCD_INSUFFICIENT_MEM_PICBUF;
512 return IHEVCD_INSUFFICIENT_MEM_PICBUF;
513 }
514
515 ps_pic_buf->pu1_luma = pu1_buf + ps_codec->i4_strd * PAD_TOP + PAD_LEFT;
516 pu1_buf += luma_samples;
517
518 ps_pic_buf->pu1_chroma = pu1_buf + ps_codec->i4_strd * (PAD_TOP / 2) + PAD_LEFT;
519 pu1_buf += chroma_samples;
520
521 /* Pad boundary pixels (one pixel on all sides) */
522 /* This ensures SAO does not read uninitialized pixels */
523 /* Note these are not used in actual processing */
524 {
525 UWORD8 *pu1_buf;
526 WORD32 strd, wd, ht;
527 WORD32 i;
528 strd = ps_codec->i4_strd;
529 wd = ps_codec->i4_wd;
530 ht = ps_codec->i4_ht;
531
532 pu1_buf = ps_pic_buf->pu1_luma;
533 for(i = 0; i < ht; i++)
534 {
535 pu1_buf[-1] = 0;
536 pu1_buf[wd] = 0;
537 pu1_buf += strd;
538 }
539 pu1_buf = ps_pic_buf->pu1_luma;
540 memset(pu1_buf - strd - 1, 0, wd + 2);
541
542 pu1_buf += strd * ht;
543 memset(pu1_buf - 1, 0, wd + 2);
544
545 pu1_buf = ps_pic_buf->pu1_chroma;
546 ht >>= 1;
547 for(i = 0; i < ht; i++)
548 {
549 pu1_buf[-1] = 0;
550 pu1_buf[-2] = 0;
551 pu1_buf[wd] = 0;
552 pu1_buf[wd + 1] = 0;
553 pu1_buf += strd;
554 }
555 pu1_buf = ps_pic_buf->pu1_chroma;
556 memset(pu1_buf - strd - 2, 0, wd + 4);
557
558 pu1_buf += strd * ht;
559 memset(pu1_buf - 2, 0, wd + 4);
560 }
561
562 buf_ret = ihevc_buf_mgr_add((buf_mgr_t *)ps_codec->pv_pic_buf_mgr, ps_pic_buf, i);
563
564
565 if(0 != buf_ret)
566 {
567 ps_codec->s_parse.i4_error_code = IHEVCD_BUF_MGR_ERROR;
568 return IHEVCD_BUF_MGR_ERROR;
569 }
570 ps_pic_buf++;
571 }
572 }
573 else
574 {
575 /* In case of shared mode, buffers are added without adjusting for padding.
576 Update luma and chroma pointers here to account for padding as per stride.
577 In some cases stride might not be available when set_display_frame is called.
578 Hence updated luma and chroma pointers here */
579
580 for(i = 0; i < BUF_MGR_MAX_CNT; i++)
581 {
582 ps_pic_buf = ihevc_buf_mgr_get_buf((buf_mgr_t *)ps_codec->pv_pic_buf_mgr, i);
583 if((NULL == ps_pic_buf) ||
584 (NULL == ps_pic_buf->pu1_luma) ||
585 (NULL == ps_pic_buf->pu1_chroma))
586 {
587 break;
588 }
589 ps_pic_buf->pu1_luma += ps_codec->i4_strd * PAD_TOP + PAD_LEFT;
590 ps_pic_buf->pu1_chroma += ps_codec->i4_strd * (PAD_TOP / 2) + PAD_LEFT;
591 }
592 }
593
594 return ret;
595 }
596 /**
597 *******************************************************************************
598 *
599 * @brief
600 * Function to add buffers to MV Bank buffer manager
601 *
602 * @par Description:
603 * Function to add buffers to MV Bank buffer manager
604 * To be called once per stream or for every reset
605 *
606 * @param[in] ps_codec
607 * Pointer to codec context
608 *
609 * @returns Error from IHEVCD_ERROR_T
610 *
611 * @remarks
612 *
613 *
614 *******************************************************************************
615 */
ihevcd_mv_buf_mgr_add_bufs(codec_t * ps_codec)616 IHEVCD_ERROR_T ihevcd_mv_buf_mgr_add_bufs(codec_t *ps_codec)
617 {
618 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS;
619 WORD32 i;
620 WORD32 max_dpb_size;
621 WORD32 mv_bank_size_allocated;
622 WORD32 pic_mv_bank_size;
623
624 sps_t *ps_sps;
625 UWORD8 *pu1_buf;
626 mv_buf_t *ps_mv_buf;
627
628
629 /* Initialize MV Bank buffer manager */
630 ps_sps = ps_codec->s_parse.ps_sps;
631
632
633 /* Compute the number of MV Bank buffers needed */
634 max_dpb_size = ps_sps->ai1_sps_max_dec_pic_buffering[ps_sps->i1_sps_max_sub_layers - 1];
635
636 /* Allocate one extra MV Bank to handle current frame
637 * In case of asynchronous parsing and processing, number of buffers should increase here
638 * based on when parsing and processing threads are synchronized
639 */
640 max_dpb_size++;
641
642 ps_codec->i4_max_dpb_size = max_dpb_size;
643
644 pu1_buf = (UWORD8 *)ps_codec->pv_mv_bank_buf_base;
645
646 ps_mv_buf = (mv_buf_t *)pu1_buf;
647 pu1_buf += max_dpb_size * sizeof(mv_buf_t);
648 ps_codec->ps_mv_buf = ps_mv_buf;
649 mv_bank_size_allocated = ps_codec->i4_total_mv_bank_size - max_dpb_size * sizeof(mv_buf_t);
650
651 /* Compute MV bank size per picture */
652 pic_mv_bank_size = ihevcd_get_pic_mv_bank_size(ALIGN64(ps_sps->i2_pic_width_in_luma_samples) *
653 ALIGN64(ps_sps->i2_pic_height_in_luma_samples));
654
655 for(i = 0; i < max_dpb_size; i++)
656 {
657 WORD32 buf_ret;
658 WORD32 num_pu;
659 WORD32 num_ctb;
660 WORD32 pic_size;
661 pic_size = ALIGN64(ps_sps->i2_pic_width_in_luma_samples) *
662 ALIGN64(ps_sps->i2_pic_height_in_luma_samples);
663
664
665 num_pu = pic_size / (MIN_PU_SIZE * MIN_PU_SIZE);
666 num_ctb = pic_size / (MIN_CTB_SIZE * MIN_CTB_SIZE);
667
668
669 mv_bank_size_allocated -= pic_mv_bank_size;
670
671 if(mv_bank_size_allocated < 0)
672 {
673 ps_codec->s_parse.i4_error_code = IHEVCD_INSUFFICIENT_MEM_MVBANK;
674 return IHEVCD_INSUFFICIENT_MEM_MVBANK;
675 }
676
677 ps_mv_buf->pu4_pic_pu_idx = (UWORD32 *)pu1_buf;
678 pu1_buf += (num_ctb + 1) * sizeof(WORD32);
679
680 ps_mv_buf->pu1_pic_pu_map = pu1_buf;
681 pu1_buf += num_pu;
682
683 ps_mv_buf->pu1_pic_slice_map = (UWORD16 *)pu1_buf;
684 pu1_buf += ALIGN4(num_ctb * sizeof(UWORD16));
685
686 ps_mv_buf->ps_pic_pu = (pu_t *)pu1_buf;
687 pu1_buf += num_pu * sizeof(pu_t);
688
689 buf_ret = ihevc_buf_mgr_add((buf_mgr_t *)ps_codec->pv_mv_buf_mgr, ps_mv_buf, i);
690
691 if(0 != buf_ret)
692 {
693 ps_codec->s_parse.i4_error_code = IHEVCD_BUF_MGR_ERROR;
694 return IHEVCD_BUF_MGR_ERROR;
695 }
696
697 ps_mv_buf++;
698
699 }
700 return ret;
701 }
702 /**
703 *******************************************************************************
704 *
705 * @brief
706 * Output buffer check
707 *
708 * @par Description:
709 * Check for the number of buffers and buffer sizes of output buffer
710 *
711 * @param[in] ps_codec
712 * Pointer to codec context
713 *
714 * @returns Error from IHEVCD_ERROR_T
715 *
716 * @remarks
717 *
718 *
719 *******************************************************************************
720 */
ihevcd_check_out_buf_size(codec_t * ps_codec)721 IHEVCD_ERROR_T ihevcd_check_out_buf_size(codec_t *ps_codec)
722 {
723 ivd_out_bufdesc_t *ps_out_buffer = ps_codec->ps_out_buffer;
724 UWORD32 au4_min_out_buf_size[IVD_VIDDEC_MAX_IO_BUFFERS];
725 UWORD32 u4_min_num_out_bufs = 0, i;
726 UWORD32 wd, ht;
727
728 if(0 == ps_codec->i4_share_disp_buf)
729 {
730 wd = ps_codec->i4_disp_wd;
731 ht = ps_codec->i4_disp_ht;
732 }
733 else
734 {
735 /* In case of shared mode, do not check validity of ps_codec->ps_out_buffer */
736 return (IHEVCD_ERROR_T)IHEVCD_SUCCESS;
737 }
738
739 if(ps_codec->e_chroma_fmt == IV_YUV_420P)
740 u4_min_num_out_bufs = MIN_OUT_BUFS_420;
741 else if(ps_codec->e_chroma_fmt == IV_YUV_422ILE)
742 u4_min_num_out_bufs = MIN_OUT_BUFS_422ILE;
743 else if(ps_codec->e_chroma_fmt == IV_RGB_565)
744 u4_min_num_out_bufs = MIN_OUT_BUFS_RGB565;
745 else if(ps_codec->e_chroma_fmt == IV_RGBA_8888)
746 u4_min_num_out_bufs = MIN_OUT_BUFS_RGBA8888;
747 else if((ps_codec->e_chroma_fmt == IV_YUV_420SP_UV)
748 || (ps_codec->e_chroma_fmt == IV_YUV_420SP_VU))
749 u4_min_num_out_bufs = MIN_OUT_BUFS_420SP;
750
751 if(ps_codec->e_chroma_fmt == IV_YUV_420P)
752 {
753 au4_min_out_buf_size[0] = (wd * ht);
754 au4_min_out_buf_size[1] = (wd * ht) >> 2;
755 au4_min_out_buf_size[2] = (wd * ht) >> 2;
756 }
757 else if(ps_codec->e_chroma_fmt == IV_YUV_422ILE)
758 {
759 au4_min_out_buf_size[0] = (wd * ht) * 2;
760 au4_min_out_buf_size[1] =
761 au4_min_out_buf_size[2] = 0;
762 }
763 else if(ps_codec->e_chroma_fmt == IV_RGB_565)
764 {
765 au4_min_out_buf_size[0] = (wd * ht) * 2;
766 au4_min_out_buf_size[1] =
767 au4_min_out_buf_size[2] = 0;
768 }
769 else if(ps_codec->e_chroma_fmt == IV_RGBA_8888)
770 {
771 au4_min_out_buf_size[0] = (wd * ht) * 4;
772 au4_min_out_buf_size[1] =
773 au4_min_out_buf_size[2] = 0;
774 }
775 else if((ps_codec->e_chroma_fmt == IV_YUV_420SP_UV)
776 || (ps_codec->e_chroma_fmt == IV_YUV_420SP_VU))
777 {
778 au4_min_out_buf_size[0] = (wd * ht);
779 au4_min_out_buf_size[1] = (wd * ht) >> 1;
780 au4_min_out_buf_size[2] = 0;
781 }
782
783 if(ps_out_buffer->u4_num_bufs < u4_min_num_out_bufs)
784 {
785 return (IHEVCD_ERROR_T)IV_FAIL;
786 }
787
788 for (i = 0 ; i < u4_min_num_out_bufs; i++)
789 {
790 if(ps_out_buffer->u4_min_out_buf_size[i] < au4_min_out_buf_size[i])
791 {
792 return (IHEVCD_ERROR_T)IV_FAIL;
793 }
794 }
795
796 return (IHEVCD_ERROR_T)IHEVCD_SUCCESS;
797 }
798
799 /**
800 *******************************************************************************
801 *
802 * @brief
803 * Picture level initializations required during parsing
804 *
805 * @par Description:
806 * Initialize picture level context variables during parsing Initialize mv
807 * bank buffer manager in the first init call
808 *
809 * @param[in] ps_codec
810 * Pointer to codec context
811 *
812 * @returns Error from IHEVCD_ERROR_T
813 *
814 * @remarks
815 *
816 *
817 *******************************************************************************
818 */
ihevcd_parse_pic_init(codec_t * ps_codec)819 IHEVCD_ERROR_T ihevcd_parse_pic_init(codec_t *ps_codec)
820 {
821 IHEVCD_ERROR_T ret = (IHEVCD_ERROR_T)IHEVCD_SUCCESS;
822 mv_buf_t *ps_mv_buf;
823 sps_t *ps_sps;
824 WORD32 num_min_cu;
825 WORD32 cur_pic_buf_id;
826 WORD32 cur_mv_bank_buf_id;
827 pic_buf_t *ps_cur_pic;
828 slice_header_t *ps_slice_hdr;
829 UWORD8 *pu1_cur_pic_luma, *pu1_cur_pic_chroma;
830 WORD32 i;
831
832 ps_codec->s_parse.i4_error_code = IHEVCD_SUCCESS;
833 ps_sps = ps_codec->s_parse.ps_sps;
834 ps_slice_hdr = ps_codec->s_parse.ps_slice_hdr;
835
836 /* Memset picture level intra map and transquant bypass map to zero */
837 num_min_cu = ((ps_sps->i2_pic_height_in_luma_samples + 7) / 8) * ((ps_sps->i2_pic_width_in_luma_samples + 63) / 64);
838 memset(ps_codec->s_parse.pu1_pic_intra_flag, 0, num_min_cu);
839 memset(ps_codec->s_parse.pu1_pic_no_loop_filter_flag, 0, num_min_cu);
840
841
842
843 if(0 == ps_codec->s_parse.i4_first_pic_init)
844 {
845 ret = ihevcd_mv_buf_mgr_add_bufs(ps_codec);
846 RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
847
848 ret = ihevcd_pic_buf_mgr_add_bufs(ps_codec);
849 RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
850
851 ps_codec->s_parse.i4_first_pic_init = 1;
852 }
853
854 /* Output buffer check */
855 ret = ihevcd_check_out_buf_size(ps_codec);
856 RETURN_IF((ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS), ret);
857
858 /* Initialize all the slice headers' slice addresses to zero */
859 {
860 WORD32 slice_idx;
861 WORD32 slice_start_idx;
862
863 slice_start_idx = ps_codec->i4_slice_error ? 2 : 1;
864
865 for(slice_idx = slice_start_idx; slice_idx < MAX_SLICE_HDR_CNT; slice_idx++)
866 {
867 slice_header_t *ps_slice_hdr_tmp = ps_codec->ps_slice_hdr_base + slice_idx;
868 ps_slice_hdr_tmp->i2_ctb_x = -1;
869 ps_slice_hdr_tmp->i2_ctb_y = -1;
870
871 }
872 }
873
874 /* Get free MV Bank to hold current picture's motion vector data */
875 {
876 ps_mv_buf = (mv_buf_t *)ihevc_buf_mgr_get_next_free((buf_mgr_t *)ps_codec->pv_mv_buf_mgr, &cur_mv_bank_buf_id);
877
878 /* If there are no free buffers then return with an error code.
879 * If the buffer is to be freed by another thread , change the
880 * following to call thread yield and wait for buffer to be freed
881 */
882 if(NULL == ps_mv_buf)
883 {
884 ps_codec->s_parse.i4_error_code = IHEVCD_NO_FREE_MVBANK;
885 ps_codec->i4_error_code = IHEVCD_NO_FREE_MVBANK;
886 return IHEVCD_NO_FREE_MVBANK;
887 }
888
889 ps_codec->s_parse.ps_cur_mv_buf = ps_mv_buf;
890 /* Set current ABS poc to ps_mv_buf, so that while freeing a reference buffer
891 * corresponding mv buffer can be found by looping through ps_codec->ps_mv_buf array
892 * and getting a buffer id to free
893 */
894 ps_mv_buf->i4_abs_poc = ps_slice_hdr->i4_abs_pic_order_cnt;
895 }
896
897 /* Get free picture buffer to hold current picture recon data */
898 /* TODO: For asynchronous api the following initializations related to picture
899 * buffer should be moved to processing side
900 */
901 {
902
903 UWORD8 *pu1_buf;
904 ps_cur_pic = (pic_buf_t *)ihevc_buf_mgr_get_next_free((buf_mgr_t *)ps_codec->pv_pic_buf_mgr, &cur_pic_buf_id);
905
906 /* If there are no free buffers then return with an error code.
907 * TODO: If the buffer is to be freed by another thread , change the
908 * following to call thread yield and wait for buffer to be freed
909 */
910 if(NULL == ps_cur_pic)
911 {
912 ps_codec->s_parse.i4_error_code = IHEVCD_NO_FREE_PICBUF;
913 ps_codec->i4_error_code = IHEVCD_NO_FREE_PICBUF;
914 return IHEVCD_NO_FREE_PICBUF;
915 }
916
917 /* Store input timestamp sent with input buffer */
918 ps_cur_pic->u4_ts = ps_codec->u4_ts;
919 ps_cur_pic->i4_abs_poc = ps_slice_hdr->i4_abs_pic_order_cnt;
920 ps_cur_pic->i4_poc_lsb = ps_slice_hdr->i4_pic_order_cnt_lsb;
921 pu1_buf = ps_cur_pic->pu1_luma;
922 pu1_cur_pic_luma = pu1_buf;
923
924 pu1_buf = ps_cur_pic->pu1_chroma;
925
926 pu1_cur_pic_chroma = pu1_buf;
927
928 ps_cur_pic->s_sei_params.i1_sei_parameters_present_flag = 0;
929 if(ps_codec->s_parse.s_sei_params.i1_sei_parameters_present_flag)
930 {
931 sei_params_t *ps_sei = &ps_codec->s_parse.s_sei_params;
932 ps_cur_pic->s_sei_params = ps_codec->s_parse.s_sei_params;
933
934 /* Once sei_params is copied to pic_buf,
935 * mark sei_params in s_parse as not present,
936 * this ensures that future frames do not use this data again.
937 */
938 ps_sei->i1_sei_parameters_present_flag = 0;
939 ps_sei->i1_user_data_registered_present_flag = 0;
940 ps_sei->i1_aud_present_flag = 0;
941 ps_sei->i1_time_code_present_flag = 0;
942 ps_sei->i1_buf_period_params_present_flag = 0;
943 ps_sei->i1_pic_timing_params_present_flag = 0;
944 ps_sei->i1_recovery_point_params_present_flag = 0;
945 ps_sei->i1_active_parameter_set = 0;
946 ps_sei->i4_sei_mastering_disp_colour_vol_params_present_flags = 0;
947 }
948 }
949
950 if(0 == ps_codec->u4_pic_cnt)
951 {
952 memset(ps_cur_pic->pu1_luma, 128, (ps_sps->i2_pic_width_in_luma_samples + PAD_WD) * ps_sps->i2_pic_height_in_luma_samples);
953 memset(ps_cur_pic->pu1_chroma, 128, (ps_sps->i2_pic_width_in_luma_samples + PAD_WD) * ps_sps->i2_pic_height_in_luma_samples / 2);
954 }
955
956 /* Fill the remaining entries of the reference lists with the nearest POC
957 * This is done to handle cases where there is a corruption in the reference index */
958 {
959 pic_buf_t *ps_pic_buf_ref;
960 mv_buf_t *ps_mv_buf_ref;
961 WORD32 r_idx;
962 dpb_mgr_t *ps_dpb_mgr = (dpb_mgr_t *)ps_codec->pv_dpb_mgr;
963 buf_mgr_t *ps_mv_buf_mgr = (buf_mgr_t *)ps_codec->pv_mv_buf_mgr;
964
965 ps_pic_buf_ref = ihevc_dpb_mgr_get_ref_by_nearest_poc(ps_dpb_mgr, ps_slice_hdr->i4_abs_pic_order_cnt);
966 if(NULL == ps_pic_buf_ref)
967 {
968 WORD32 size;
969
970 WORD32 num_pu;
971 WORD32 num_ctb;
972 WORD32 pic_size;
973 /* In case current mv buffer itself is being used as reference mv buffer for colocated
974 * calculations, then memset all the buffers to zero.
975 */
976 pic_size = ALIGN64(ps_sps->i2_pic_width_in_luma_samples) *
977 ALIGN64(ps_sps->i2_pic_height_in_luma_samples);
978
979 num_pu = pic_size / (MIN_PU_SIZE * MIN_PU_SIZE);
980 num_ctb = pic_size / (MIN_CTB_SIZE * MIN_CTB_SIZE);
981
982 memset(ps_mv_buf->ai4_l0_collocated_poc, 0, sizeof(ps_mv_buf->ai4_l0_collocated_poc));
983 memset(ps_mv_buf->ai1_l0_collocated_poc_lt, 0, sizeof(ps_mv_buf->ai1_l0_collocated_poc_lt));
984 memset(ps_mv_buf->ai4_l1_collocated_poc, 0, sizeof(ps_mv_buf->ai4_l1_collocated_poc));
985 memset(ps_mv_buf->ai1_l1_collocated_poc_lt, 0, sizeof(ps_mv_buf->ai1_l1_collocated_poc_lt));
986
987 size = (num_ctb + 1) * sizeof(WORD32);
988 memset(ps_mv_buf->pu4_pic_pu_idx, 0, size);
989
990 size = num_pu;
991 memset(ps_mv_buf->pu1_pic_pu_map, 0, size);
992 size = ALIGN4(num_ctb * sizeof(UWORD16));
993 memset(ps_mv_buf->pu1_pic_slice_map, 0, size);
994 size = num_pu * sizeof(pu_t);
995 memset(ps_mv_buf->ps_pic_pu, 0, size);
996
997 ps_pic_buf_ref = ps_cur_pic;
998 ps_mv_buf_ref = ps_mv_buf;
999 }
1000 else
1001 {
1002 ps_mv_buf_ref = ihevcd_mv_mgr_get_poc(ps_mv_buf_mgr, ps_pic_buf_ref->i4_abs_poc);
1003 }
1004
1005 for(r_idx = 0; r_idx < ps_slice_hdr->i1_num_ref_idx_l0_active; r_idx++)
1006 {
1007 if(NULL == ps_slice_hdr->as_ref_pic_list0[r_idx].pv_pic_buf)
1008 {
1009 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_pic_buf = (void *)ps_pic_buf_ref;
1010 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_mv_buf = (void *)ps_mv_buf_ref;
1011 }
1012 }
1013
1014 for(r_idx = ps_slice_hdr->i1_num_ref_idx_l0_active; r_idx < MAX_DPB_SIZE; r_idx++)
1015 {
1016 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_pic_buf = (void *)ps_pic_buf_ref;
1017 ps_slice_hdr->as_ref_pic_list0[r_idx].pv_mv_buf = (void *)ps_mv_buf_ref;
1018 }
1019
1020 for(r_idx = 0; r_idx < ps_slice_hdr->i1_num_ref_idx_l1_active; r_idx++)
1021 {
1022 if(NULL == ps_slice_hdr->as_ref_pic_list1[r_idx].pv_pic_buf)
1023 {
1024 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_pic_buf = (void *)ps_pic_buf_ref;
1025 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_mv_buf = (void *)ps_mv_buf_ref;
1026 }
1027 }
1028
1029 for(r_idx = ps_slice_hdr->i1_num_ref_idx_l1_active; r_idx < MAX_DPB_SIZE; r_idx++)
1030 {
1031 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_pic_buf = (void *)ps_pic_buf_ref;
1032 ps_slice_hdr->as_ref_pic_list1[r_idx].pv_mv_buf = (void *)ps_mv_buf_ref;
1033 }
1034 }
1035
1036
1037 /* Reset the jobq to start of the jobq buffer */
1038 ihevcd_jobq_reset((jobq_t *)ps_codec->pv_proc_jobq);
1039
1040 ps_codec->s_parse.i4_pic_pu_idx = 0;
1041 ps_codec->s_parse.i4_pic_tu_idx = 0;
1042
1043 ps_codec->s_parse.pu1_pic_pu_map = ps_mv_buf->pu1_pic_pu_map;
1044 ps_codec->s_parse.ps_pic_pu = ps_mv_buf->ps_pic_pu;
1045 ps_codec->s_parse.pu4_pic_pu_idx = ps_mv_buf->pu4_pic_pu_idx;
1046 ps_codec->s_parse.pu1_slice_idx = (UWORD16 *)ps_mv_buf->pu1_pic_slice_map;
1047 for(i = 0; i < MAX_PROCESS_THREADS; i++)
1048 {
1049 ps_codec->as_process[i].pu1_slice_idx = (UWORD16 *)ps_mv_buf->pu1_pic_slice_map;
1050 }
1051 ps_codec->s_parse.pu1_pu_map = ps_codec->s_parse.pu1_pic_pu_map;
1052 ps_codec->s_parse.ps_pu = ps_codec->s_parse.ps_pic_pu;
1053
1054 {
1055 UWORD8 *pu1_buf;
1056 WORD32 ctb_luma_min_tu_cnt, ctb_chroma_min_tu_cnt, ctb_min_tu_cnt;
1057 WORD32 pic_size;
1058 WORD32 num_ctb;
1059
1060 pic_size = ALIGN64(ps_sps->i2_pic_width_in_luma_samples) *
1061 ALIGN64(ps_sps->i2_pic_height_in_luma_samples);
1062
1063 ctb_luma_min_tu_cnt = pic_size / (MIN_TU_SIZE * MIN_TU_SIZE);
1064
1065 ctb_chroma_min_tu_cnt = ctb_luma_min_tu_cnt >> 1;
1066
1067 ctb_min_tu_cnt = ctb_luma_min_tu_cnt + ctb_chroma_min_tu_cnt;
1068
1069 num_ctb = pic_size / (MIN_CTB_SIZE * MIN_CTB_SIZE);
1070 pu1_buf = (UWORD8 *)ps_codec->pv_tu_data;
1071 ps_codec->s_parse.pu4_pic_tu_idx = (UWORD32 *)pu1_buf;
1072 pu1_buf += (num_ctb + 1) * sizeof(WORD32);
1073
1074 ps_codec->s_parse.pu1_pic_tu_map = pu1_buf;
1075 pu1_buf += ctb_min_tu_cnt;
1076
1077 ps_codec->s_parse.ps_pic_tu = (tu_t *)pu1_buf;
1078 pu1_buf += ctb_min_tu_cnt * sizeof(tu_t);
1079
1080 ps_codec->s_parse.pv_pic_tu_coeff_data = pu1_buf;
1081
1082 ps_codec->s_parse.pu1_tu_map = ps_codec->s_parse.pu1_pic_tu_map;
1083 ps_codec->s_parse.ps_tu = ps_codec->s_parse.ps_pic_tu;
1084 ps_codec->s_parse.pv_tu_coeff_data = ps_codec->s_parse.pv_pic_tu_coeff_data;
1085 }
1086
1087 ps_codec->s_parse.s_bs_ctxt.ps_pic_pu = ps_codec->s_parse.ps_pic_pu;
1088 ps_codec->s_parse.s_bs_ctxt.pu4_pic_pu_idx = ps_codec->s_parse.pu4_pic_pu_idx;
1089 ps_codec->s_parse.s_bs_ctxt.pu4_pic_tu_idx = ps_codec->s_parse.pu4_pic_tu_idx;
1090
1091
1092 /* Set number of CTBs to be processed simultaneously */
1093 ps_codec->i4_proc_nctb = ihevcd_nctb_cnt(ps_codec, ps_sps);
1094
1095 /* Memset Parse Map and process map at the start of frame */
1096 //TODO: In case of asynchronous API proc_map can not be set to zero here
1097 {
1098 WORD32 num_ctb;
1099
1100 num_ctb = ps_sps->i4_pic_size_in_ctb;
1101
1102 memset(ps_codec->pu1_parse_map, 0, num_ctb);
1103
1104 memset(ps_codec->pu1_proc_map, 0, num_ctb);
1105 }
1106
1107
1108
1109 /* Initialize disp buf id to -1, this will be updated at the end of frame if there is
1110 * buffer to be displayed
1111 */
1112 ps_codec->i4_disp_buf_id = -1;
1113 ps_codec->ps_disp_buf = NULL;
1114
1115 ps_codec->i4_disable_deblk_pic = 0;
1116 ps_codec->i4_disable_sao_pic = 0;
1117 ps_codec->i4_fullpel_inter_pred = 0;
1118 ps_codec->i4_mv_frac_mask = 0x7FFFFFFF;
1119
1120 /* If degrade is enabled, set the degrade flags appropriately */
1121 if(ps_codec->i4_degrade_type && ps_codec->i4_degrade_pics)
1122 {
1123 WORD32 degrade_pic;
1124 ps_codec->i4_degrade_pic_cnt++;
1125 degrade_pic = 0;
1126
1127 /* If degrade is to be done in all frames, then do not check further */
1128 switch(ps_codec->i4_degrade_pics)
1129 {
1130 case 4:
1131 {
1132 degrade_pic = 1;
1133 break;
1134 }
1135 case 3:
1136 {
1137 if(ps_slice_hdr->i1_slice_type != ISLICE)
1138 degrade_pic = 1;
1139
1140 break;
1141 }
1142 case 2:
1143 {
1144
1145 /* If pic count hits non-degrade interval or it is an islice, then do not degrade */
1146 if((ps_slice_hdr->i1_slice_type != ISLICE) &&
1147 (ps_codec->i4_degrade_pic_cnt != ps_codec->i4_nondegrade_interval))
1148 degrade_pic = 1;
1149
1150 break;
1151 }
1152 case 1:
1153 {
1154 /* Check if the current picture is non-ref */
1155 if((ps_slice_hdr->i1_nal_unit_type < NAL_BLA_W_LP) &&
1156 (ps_slice_hdr->i1_nal_unit_type % 2 == 0))
1157 {
1158 degrade_pic = 1;
1159 }
1160 break;
1161 }
1162
1163
1164 }
1165 if(degrade_pic)
1166 {
1167 if(ps_codec->i4_degrade_type & 0x1)
1168 ps_codec->i4_disable_sao_pic = 1;
1169
1170 if(ps_codec->i4_degrade_type & 0x2)
1171 ps_codec->i4_disable_deblk_pic = 1;
1172
1173 /* MC degrading is done only for non-ref pictures */
1174 if((ps_slice_hdr->i1_nal_unit_type < NAL_BLA_W_LP) &&
1175 (ps_slice_hdr->i1_nal_unit_type % 2 == 0))
1176 {
1177 if(ps_codec->i4_degrade_type & 0x4)
1178 ps_codec->i4_mv_frac_mask = 0;
1179
1180 if(ps_codec->i4_degrade_type & 0x8)
1181 ps_codec->i4_mv_frac_mask = 0;
1182 }
1183 }
1184 else
1185 ps_codec->i4_degrade_pic_cnt = 0;
1186 }
1187
1188
1189 {
1190 WORD32 i;
1191 for(i = 0; i < MAX_PROCESS_THREADS; i++)
1192 {
1193 ps_codec->as_process[i].pu4_pic_pu_idx = ps_codec->s_parse.pu4_pic_pu_idx;
1194 ps_codec->as_process[i].ps_pic_pu = ps_codec->s_parse.ps_pic_pu;
1195 ps_codec->as_process[i].pu1_pic_pu_map = ps_codec->s_parse.pu1_pic_pu_map;
1196 ps_codec->as_process[i].pu4_pic_tu_idx = ps_codec->s_parse.pu4_pic_tu_idx;
1197 ps_codec->as_process[i].ps_pic_tu = ps_codec->s_parse.ps_pic_tu;
1198 ps_codec->as_process[i].pu1_pic_tu_map = ps_codec->s_parse.pu1_pic_tu_map;
1199 ps_codec->as_process[i].pv_pic_tu_coeff_data = ps_codec->s_parse.pv_pic_tu_coeff_data;
1200 ps_codec->as_process[i].i4_cur_mv_bank_buf_id = cur_mv_bank_buf_id;
1201 ps_codec->as_process[i].s_sao_ctxt.pu1_slice_idx = ps_codec->as_process[i].pu1_slice_idx;
1202 ps_codec->as_process[i].s_sao_ctxt.pu1_tile_idx = ps_codec->as_process[i].pu1_tile_idx;
1203
1204 /* TODO: For asynchronous api the following initializations related to picture
1205 * buffer should be moved to processing side
1206 */
1207 ps_codec->as_process[i].pu1_cur_pic_luma = pu1_cur_pic_luma;
1208 ps_codec->as_process[i].pu1_cur_pic_chroma = pu1_cur_pic_chroma;
1209 ps_codec->as_process[i].ps_cur_pic = ps_cur_pic;
1210 ps_codec->as_process[i].i4_cur_pic_buf_id = cur_pic_buf_id;
1211
1212 ps_codec->as_process[i].ps_out_buffer = ps_codec->ps_out_buffer;
1213 if(1 < ps_codec->i4_num_cores)
1214 {
1215 ps_codec->as_process[i].i4_check_parse_status = 1;
1216 ps_codec->as_process[i].i4_check_proc_status = 1;
1217 }
1218 else
1219 {
1220 ps_codec->as_process[i].i4_check_parse_status = 0;
1221 ps_codec->as_process[i].i4_check_proc_status = 0;
1222 }
1223 ps_codec->as_process[i].pu1_pic_intra_flag = ps_codec->s_parse.pu1_pic_intra_flag;
1224 ps_codec->as_process[i].pu1_pic_no_loop_filter_flag = ps_codec->s_parse.pu1_pic_no_loop_filter_flag;
1225 ps_codec->as_process[i].i4_init_done = 0;
1226
1227 ps_codec->as_process[i].s_bs_ctxt.pu4_pic_tu_idx = ps_codec->as_process[i].pu4_pic_tu_idx;
1228 ps_codec->as_process[i].s_bs_ctxt.pu4_pic_pu_idx = ps_codec->as_process[i].pu4_pic_pu_idx;
1229 ps_codec->as_process[i].s_bs_ctxt.ps_pic_pu = ps_codec->as_process[i].ps_pic_pu;
1230 ps_codec->as_process[i].s_deblk_ctxt.pu1_pic_no_loop_filter_flag = ps_codec->s_parse.pu1_pic_no_loop_filter_flag;
1231 ps_codec->as_process[i].s_deblk_ctxt.pu1_cur_pic_luma = pu1_cur_pic_luma;
1232 ps_codec->as_process[i].s_deblk_ctxt.pu1_cur_pic_chroma = pu1_cur_pic_chroma;
1233 ps_codec->as_process[i].s_sao_ctxt.pu1_pic_no_loop_filter_flag = ps_codec->s_parse.pu1_pic_no_loop_filter_flag;
1234 ps_codec->as_process[i].s_sao_ctxt.pu1_cur_pic_luma = pu1_cur_pic_luma;
1235 ps_codec->as_process[i].s_sao_ctxt.pu1_cur_pic_chroma = pu1_cur_pic_chroma;
1236 if(i < (ps_codec->i4_num_cores - 1))
1237 {
1238 ithread_create(ps_codec->apv_process_thread_handle[i], NULL,
1239 (void *)ihevcd_process_thread,
1240 (void *)&ps_codec->as_process[i]);
1241 ps_codec->ai4_process_thread_created[i] = 1;
1242 }
1243 else
1244 {
1245 ps_codec->ai4_process_thread_created[i] = 0;
1246 }
1247
1248 }
1249 ps_codec->s_parse.s_deblk_ctxt.pu1_cur_pic_luma = pu1_cur_pic_luma;
1250 ps_codec->s_parse.s_deblk_ctxt.pu1_cur_pic_chroma = pu1_cur_pic_chroma;
1251
1252 ps_codec->s_parse.s_sao_ctxt.pu1_cur_pic_luma = pu1_cur_pic_luma;
1253 ps_codec->s_parse.s_sao_ctxt.pu1_cur_pic_chroma = pu1_cur_pic_chroma;
1254 }
1255 /* Since any input bitstream buffer that contains slice data will be sent to output(even in
1256 * case of error, this buffer is added to display queue and next buffer in the display queue
1257 * will be returned as the display buffer.
1258 * Note: If format conversion (or frame copy) is used and is scheduled
1259 * in a different thread then it has to check if the processing for the current row is complete before
1260 * it copies/converts a given row. In case of low delay or in case of B pictures, current frame being decoded has to be
1261 * returned, which requires a status check to ensure that the current row is reconstructed before copying.
1262 */
1263 /* Add current picture to display manager */
1264 {
1265 WORD32 abs_poc;
1266 slice_header_t *ps_slice_hdr;
1267 ps_slice_hdr = ps_codec->s_parse.ps_slice_hdr;
1268 abs_poc = ps_slice_hdr->i4_abs_pic_order_cnt;
1269 ihevc_disp_mgr_add((disp_mgr_t *)ps_codec->pv_disp_buf_mgr,
1270 ps_codec->as_process[0].i4_cur_pic_buf_id,
1271 abs_poc,
1272 ps_codec->as_process[0].ps_cur_pic);
1273 }
1274 ps_codec->ps_disp_buf = NULL;
1275 /* Get picture to be displayed if number of pictures decoded is more than max allowed reorder */
1276 /* Since the current will be decoded, check is fore >= instead of > */
1277 if(((WORD32)(ps_codec->u4_pic_cnt - ps_codec->u4_disp_cnt) >= ps_sps->ai1_sps_max_num_reorder_pics[ps_sps->i1_sps_max_sub_layers - 1]) ||
1278 (ps_codec->e_frm_out_mode == IVD_DECODE_FRAME_OUT))
1279
1280 {
1281 ps_codec->ps_disp_buf = (pic_buf_t *)ihevc_disp_mgr_get((disp_mgr_t *)ps_codec->pv_disp_buf_mgr, &ps_codec->i4_disp_buf_id);
1282 ps_codec->u4_disp_cnt++;
1283 }
1284
1285 ps_codec->s_fmt_conv.i4_cur_row = 0;
1286 /* Set number of rows to be processed at a time */
1287 ps_codec->s_fmt_conv.i4_num_rows = 4;
1288
1289 if(ps_codec->u4_enable_fmt_conv_ahead && (ps_codec->i4_num_cores > 1))
1290 {
1291 process_ctxt_t *ps_proc;
1292
1293 /* i4_num_cores - 1 contexts are currently being used by other threads */
1294 ps_proc = &ps_codec->as_process[ps_codec->i4_num_cores - 1];
1295
1296 /* If the frame being decoded and displayed are different, schedule format conversion jobs
1297 * this will keep the proc threads busy and lets parse thread decode few CTBs ahead
1298 * If the frame being decoded and displayed are same, then format conversion is scheduled later.
1299 */
1300 if((ps_codec->ps_disp_buf) && (ps_codec->i4_disp_buf_id != ps_proc->i4_cur_pic_buf_id) &&
1301 ((0 == ps_codec->i4_share_disp_buf) || (IV_YUV_420P == ps_codec->e_chroma_fmt)))
1302 {
1303
1304 for(i = 0; i < ps_sps->i2_pic_ht_in_ctb; i++)
1305 {
1306 proc_job_t s_job;
1307 IHEVCD_ERROR_T ret;
1308 s_job.i4_cmd = CMD_FMTCONV;
1309 s_job.i2_ctb_cnt = 0;
1310 s_job.i2_ctb_x = 0;
1311 s_job.i2_ctb_y = i;
1312 s_job.i2_slice_idx = 0;
1313 s_job.i4_tu_coeff_data_ofst = 0;
1314 ret = ihevcd_jobq_queue((jobq_t *)ps_codec->s_parse.pv_proc_jobq,
1315 &s_job, sizeof(proc_job_t), 1);
1316 if(ret != (IHEVCD_ERROR_T)IHEVCD_SUCCESS)
1317 return ret;
1318 }
1319 }
1320 }
1321
1322 /* If parse_pic_init is called, then slice data is present in the input bitstrea stream */
1323 ps_codec->i4_pic_present = 1;
1324
1325 return ret;
1326 }
1327
1328
1329