1 /******************************************************************************
2 *
3 * Copyright (C) 2015 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 * \file ih264d_parse_mb_header.c
23 *
24 * \brief
25 * This file contains context identifier encoding routines.
26 *
27 * \date
28 * 04/02/2003
29 *
30 * \author NS
31 ***************************************************************************
32 */
33 #include <string.h>
34 #include "ih264d_structs.h"
35 #include "ih264d_bitstrm.h"
36 #include "ih264d_cabac.h"
37 #include "ih264_typedefs.h"
38 #include "ih264_macros.h"
39 #include "ih264_platform_macros.h"
40 #include "ih264d_defs.h"
41 #include "ih264d_error_handler.h"
42 #include "ih264d_tables.h"
43 #include "ih264d_debug.h"
44 #include "ih264d_defs.h"
45 #include "ih264d_defs.h"
46 #include "ih264d_mb_utils.h"
47 #include "ih264d_parse_mb_header.h"
48 #include "ih264d_defs.h"
49
50 /*! < CtxtInc index 0 - CtxMbTypeI, CtxMbTypeSISuffix
51 index 1 - CtxMbTypePSuffix, CtxMbTypeBSuffix
52 */
53
54
55
56 /*!
57 **************************************************************************
58 * \if Function name : ih264d_parse_mb_type_intra_cabac \endif
59 *
60 * \brief
61 * This function decodes MB type using CABAC entropy coding mode.
62 *
63 * \return
64 * MBType.
65 *
66 **************************************************************************
67 */
ih264d_parse_mb_type_intra_cabac(UWORD8 u1_inter,struct _DecStruct * ps_dec)68 UWORD8 ih264d_parse_mb_type_intra_cabac(UWORD8 u1_inter,
69 struct _DecStruct * ps_dec)
70 {
71 decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;
72 dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
73 ctxt_inc_mb_info_t * ps_left_ctxt = ps_dec->p_left_ctxt_mb_info;
74 ctxt_inc_mb_info_t * ps_top_ctxt = ps_dec->p_top_ctxt_mb_info;
75 bin_ctxt_model_t *ps_mb_bin_ctxt = ps_dec->p_mb_type_t;
76 WORD8 u1_mb_type, u1_bin;
77 UWORD32 u4_cxt_inc;
78
79 u4_cxt_inc = 0;
80 if(!u1_inter)
81 {
82 if(ps_left_ctxt != ps_dec->ps_def_ctxt_mb_info)
83 u4_cxt_inc += ((ps_left_ctxt->u1_mb_type != CAB_I4x4) ? 1 : 0);
84 if(ps_top_ctxt != ps_dec->ps_def_ctxt_mb_info)
85 u4_cxt_inc += ((ps_top_ctxt->u1_mb_type != CAB_I4x4) ? 1 : 0);
86 }
87 else
88 {
89 ps_mb_bin_ctxt = ps_mb_bin_ctxt + 3 + (ps_dec->u1_B << 1);
90 }
91
92 /* b0 */
93 u1_mb_type = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt, ps_bitstrm,
94 ps_cab_env);
95 if(u1_mb_type)
96 {
97 /* I16x16 or I_PCM mode */
98 /* b1 */
99 u1_bin = ih264d_decode_terminate(ps_cab_env, ps_bitstrm);
100 if(u1_bin == 0)
101 {
102 /* I16x16 mode */
103 /* Read b2 and b3 */
104 u4_cxt_inc = (u1_inter) ? 0x021 : 0x043;
105
106 u1_bin = ih264d_decode_bins(2, u4_cxt_inc, ps_mb_bin_ctxt, ps_bitstrm,
107 ps_cab_env);
108
109 if(u1_bin & 0x01)
110 u1_mb_type += 4;
111
112 if(u1_bin & 0x02)
113 u1_mb_type += 12;
114
115 if(u1_bin & 0x01)
116 {
117 /* since b3=1, Read three bins */
118 u4_cxt_inc = (u1_inter) ? 0x0332 : 0x0765;
119 u1_bin = (UWORD8)ih264d_decode_bins(3, u4_cxt_inc, ps_mb_bin_ctxt,
120 ps_bitstrm, ps_cab_env);
121
122 }
123 else
124 {
125 /* Read two bins */
126 u4_cxt_inc = (u1_inter) ? 0x033 : 0x076;
127 u1_bin = (UWORD8)ih264d_decode_bins(2, u4_cxt_inc, ps_mb_bin_ctxt,
128 ps_bitstrm, ps_cab_env);
129 }
130 u1_mb_type += u1_bin;
131 }
132 else
133 {
134 /* I_PCM mode */
135 /* b1=1 */
136 u1_mb_type = 25;
137 }
138 }
139 return (u1_mb_type);
140 }
141
142 /*!
143 **************************************************************************
144 * \if Function name : ih264d_parse_mb_type_cabac \endif
145 *
146 * \brief
147 * This function decodes MB type using CABAC entropy coding mode.
148 *
149 * \return
150 * MBType.
151 *
152 **************************************************************************
153 */
ih264d_parse_mb_type_cabac(struct _DecStruct * ps_dec)154 UWORD32 ih264d_parse_mb_type_cabac(struct _DecStruct * ps_dec)
155 {
156 const UWORD8 uc_slice_type = ps_dec->ps_cur_slice->u1_slice_type;
157 decoding_envirnoment_t *ps_cab_env = &ps_dec->s_cab_dec_env;
158 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm;
159 ctxt_inc_mb_info_t *ps_left_ctxt = ps_dec->p_left_ctxt_mb_info;
160 ctxt_inc_mb_info_t *ps_top_ctxt = ps_dec->p_top_ctxt_mb_info;
161 WORD8 c_ctxt_inc;
162 bin_ctxt_model_t *ps_mb_bin_ctxt = ps_dec->p_mb_type_t;
163 WORD8 u1_mb_type = 0, u1_bin;
164 UWORD32 u4_cxt_inc;
165
166 INC_SYM_COUNT(ps_cab_env);
167
168 c_ctxt_inc = 0;
169
170 if(uc_slice_type == SI_SLICE)
171 {
172 /* b0 */
173 if(ps_left_ctxt != ps_dec->ps_def_ctxt_mb_info)
174 c_ctxt_inc += ((ps_left_ctxt->u1_mb_type != CAB_SI4x4) ? 1 : 0);
175 if(ps_top_ctxt != ps_dec->ps_def_ctxt_mb_info)
176 c_ctxt_inc += ((ps_top_ctxt->u1_mb_type != CAB_SI4x4) ? 1 : 0);
177
178 u4_cxt_inc = c_ctxt_inc;
179 u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt, ps_bitstrm,
180 ps_cab_env);
181 if(u1_bin == 0)
182 {
183 /* SI MB */
184 u1_mb_type = 0;
185 }
186 else
187 {
188 u1_mb_type = 1 + ih264d_parse_mb_type_intra_cabac(0, ps_dec);
189 }
190 }
191 else if(uc_slice_type == P_SLICE)
192 {
193 /* P Slice */
194 /* b0 */
195 u4_cxt_inc = 0;
196 u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt, ps_bitstrm,
197 ps_cab_env);
198 if(!u1_bin)
199 {
200 /* Inter MB types */
201 /* b1 */
202 u4_cxt_inc = 0x01;
203 u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt,
204 ps_bitstrm, ps_cab_env);
205 /* b2 */
206 u4_cxt_inc = u1_bin + 2;
207 u1_mb_type = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt,
208 ps_bitstrm, ps_cab_env);
209 u1_mb_type = (u1_bin << 1) + u1_mb_type;
210 if(u1_mb_type)
211 u1_mb_type = 4 - u1_mb_type;
212 }
213 else
214 {
215 /* Intra Prefix 1 found */
216 /* Intra MB type */
217 u1_mb_type = 5 + ih264d_parse_mb_type_intra_cabac(1, ps_dec);
218 }
219 }
220 else if(uc_slice_type == B_SLICE)
221 {
222 WORD8 a, b;
223 /* B Slice */
224 /* b0 */
225 /* a = b = 0, if B slice and MB is a SKIP or B_DIRECT16x16 */
226 a = 0;
227 b = 0;
228 u1_mb_type = 0;
229 if(ps_left_ctxt != ps_dec->ps_def_ctxt_mb_info)
230 a = ((ps_left_ctxt->u1_mb_type & CAB_BD16x16_MASK) != CAB_BD16x16);
231 if(ps_top_ctxt != ps_dec->ps_def_ctxt_mb_info)
232 b = ((ps_top_ctxt->u1_mb_type & CAB_BD16x16_MASK) != CAB_BD16x16);
233
234 u4_cxt_inc = a + b;
235
236 u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt, ps_bitstrm,
237 ps_cab_env);
238
239 if(u1_bin)
240 {
241
242 /* b1 */
243 u4_cxt_inc = 0x03;
244 u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt,
245 ps_bitstrm, ps_cab_env);
246
247 if(!u1_bin)
248 {
249 /* b2 */
250 u4_cxt_inc = 0x05;
251 u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt,
252 ps_bitstrm, ps_cab_env);
253
254 u1_mb_type = u1_bin + 1;
255 }
256 else
257 {
258 u1_mb_type = 3;
259 /* b2 */
260 u4_cxt_inc = 0x04;
261 u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt,
262 ps_bitstrm, ps_cab_env);
263
264 if(u1_bin)
265 {
266 u1_mb_type += 8;
267 /* b3 */
268 u4_cxt_inc = 0x05;
269 u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc, ps_mb_bin_ctxt,
270 ps_bitstrm, ps_cab_env);
271
272 if(!u1_bin)
273 {
274 u1_mb_type++;
275 /* b4, b5, b6 */
276 u4_cxt_inc = 0x0555;
277 u1_bin = (UWORD8)ih264d_decode_bins(3, u4_cxt_inc,
278 ps_mb_bin_ctxt,
279 ps_bitstrm,
280 ps_cab_env);
281
282
283
284 u1_mb_type += u1_bin;
285 }
286 else
287 {
288 /* b4 */
289 u4_cxt_inc = 0x05;
290 u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc,
291 ps_mb_bin_ctxt,
292 ps_bitstrm,
293 ps_cab_env);
294
295 if(u1_bin)
296 {
297 /* b5 */
298 u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc,
299 ps_mb_bin_ctxt,
300 ps_bitstrm,
301 ps_cab_env);
302
303 u1_mb_type += (u1_bin ? 11 : 0);
304 }
305 else
306 {
307 u1_mb_type = 20;
308 /* b5 */
309 u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc,
310 ps_mb_bin_ctxt,
311 ps_bitstrm,
312 ps_cab_env);
313
314 if(!u1_bin)
315 {
316 /* b6 */
317 u1_bin = (UWORD8)ih264d_decode_bin(u4_cxt_inc,
318 ps_mb_bin_ctxt,
319 ps_bitstrm,
320 ps_cab_env);
321
322 u1_mb_type += u1_bin;
323 }
324 else
325 {
326 /* Intra Prefix 111101 found */
327 /* Intra MB type */
328 u1_mb_type =
329 23
330 + ih264d_parse_mb_type_intra_cabac(
331 1,
332 ps_dec);
333 }
334 }
335 }
336 }
337 else
338 {
339 /* b3, b4, b5 */
340 u4_cxt_inc = 0x0555;
341 u1_bin = (UWORD8)ih264d_decode_bins(3, u4_cxt_inc,
342 ps_mb_bin_ctxt, ps_bitstrm,
343 ps_cab_env);
344
345
346
347
348 u1_mb_type += u1_bin;
349 }
350 }
351 }
352 }
353 return ((UWORD32)u1_mb_type);
354 }
355
356 /*!
357 **************************************************************************
358 * \if Function name : DecSubMBType \endif
359 *
360 * \brief
361 * This function decodes MB type using CABAC entropy coding mode.
362 *
363 * \return
364 * MBType.
365 *
366 **************************************************************************
367 */
ih264d_parse_submb_type_cabac(const UWORD8 u1_slc_type_b,decoding_envirnoment_t * ps_cab_env,dec_bit_stream_t * ps_bitstrm,bin_ctxt_model_t * ps_sub_mb_cxt)368 UWORD32 ih264d_parse_submb_type_cabac(const UWORD8 u1_slc_type_b,
369 decoding_envirnoment_t * ps_cab_env,
370 dec_bit_stream_t * ps_bitstrm,
371 bin_ctxt_model_t * ps_sub_mb_cxt)
372 {
373 WORD8 u1_sub_mb_type, u1_bin;
374
375 INC_SYM_COUNT(ps_cab_env);
376
377 u1_sub_mb_type = 0;
378 u1_bin = (UWORD8)ih264d_decode_bin(0, ps_sub_mb_cxt, ps_bitstrm,
379 ps_cab_env);
380
381 if(u1_slc_type_b ^ u1_bin)
382 return 0;
383
384 if(!u1_slc_type_b)
385 {
386 /* P Slice */
387 u1_sub_mb_type = 1;
388 u1_bin = (UWORD8)ih264d_decode_bin(1, ps_sub_mb_cxt, ps_bitstrm,
389 ps_cab_env);
390 if(u1_bin == 1)
391 {
392 u1_bin = (UWORD8)ih264d_decode_bin(2, ps_sub_mb_cxt, ps_bitstrm,
393 ps_cab_env);
394 u1_sub_mb_type = (2 + (!u1_bin));
395 }
396
397 return u1_sub_mb_type;
398 }
399 else
400 {
401 /* B Slice */
402
403 /* b1 */
404 u1_bin = (UWORD8)ih264d_decode_bin(1, ps_sub_mb_cxt, ps_bitstrm,
405 ps_cab_env);
406 if(u1_bin)
407 {
408 /* b2 */
409 u1_bin = (UWORD8)ih264d_decode_bin(2, ps_sub_mb_cxt, ps_bitstrm,
410 ps_cab_env);
411 if(u1_bin)
412 {
413 /* b3 */
414 u1_sub_mb_type = 7;
415 u1_bin = (UWORD8)ih264d_decode_bin(3, ps_sub_mb_cxt, ps_bitstrm,
416 ps_cab_env);
417 u1_sub_mb_type += u1_bin << 2;
418 u1_bin = !u1_bin;
419 /* b4 */
420 if(u1_bin == 0)
421 {
422 u1_bin = ih264d_decode_bin(3, ps_sub_mb_cxt, ps_bitstrm,
423 ps_cab_env);
424 }
425 else
426 {
427 u1_bin = (UWORD8)ih264d_decode_bins(2, 0x33, ps_sub_mb_cxt,
428 ps_bitstrm, ps_cab_env);
429 }
430
431 return (u1_sub_mb_type + u1_bin);
432 }
433 else
434 {
435 /* b3 */
436 u1_bin = (UWORD8)ih264d_decode_bins(2, 0x33, ps_sub_mb_cxt,
437 ps_bitstrm, ps_cab_env);
438 return (3 + u1_bin);
439 }
440 }
441 else
442 {
443 /* b2 */
444 u1_bin = (UWORD8)ih264d_decode_bin(3, ps_sub_mb_cxt, ps_bitstrm,
445 ps_cab_env);
446 return (1 + u1_bin);
447 }
448 }
449 }
450
451 /*!
452 **************************************************************************
453 * \if Function name : ih264d_parse_ref_idx_cabac \endif
454 *
455 * \brief
456 * This function decodes Reference Index using CABAC entropy coding mode.
457 *
458 * \return
459 * None
460 *
461 **************************************************************************
462 */
ih264d_parse_ref_idx_cabac(const UWORD8 u1_num_part,const UWORD8 u1_b2,const UWORD8 u1_max_ref_minus1,const UWORD8 u1_mb_mode,WORD8 * pi1_ref_idx,WORD8 * const pi1_lft_cxt,WORD8 * const pi1_top_cxt,decoding_envirnoment_t * const ps_cab_env,dec_bit_stream_t * const ps_bitstrm,bin_ctxt_model_t * const ps_ref_cxt)463 WORD32 ih264d_parse_ref_idx_cabac(const UWORD8 u1_num_part,
464 const UWORD8 u1_b2,
465 const UWORD8 u1_max_ref_minus1,
466 const UWORD8 u1_mb_mode,
467 WORD8 * pi1_ref_idx,
468 WORD8 * const pi1_lft_cxt,
469 WORD8 * const pi1_top_cxt,
470 decoding_envirnoment_t * const ps_cab_env,
471 dec_bit_stream_t * const ps_bitstrm,
472 bin_ctxt_model_t * const ps_ref_cxt)
473 {
474 UWORD8 u1_a, u1_b;
475 UWORD32 u4_cxt_inc;
476 UWORD8 u1_blk_no, u1_i, u1_idx_lft, u1_idx_top;
477 WORD8 i1_ref_idx;
478
479 for(u1_blk_no = 0, u1_i = 0; u1_i < u1_num_part; u1_i++, pi1_ref_idx++)
480 {
481 u1_idx_lft = ((u1_blk_no & 0x02) >> 1) + u1_b2;
482 u1_idx_top = (u1_blk_no & 0x01) + u1_b2;
483 i1_ref_idx = *pi1_ref_idx;
484
485 if(i1_ref_idx > 0)
486 {
487 u1_a = pi1_lft_cxt[u1_idx_lft] > 0;
488 u1_b = pi1_top_cxt[u1_idx_top] > 0;
489
490 u4_cxt_inc = u1_a + (u1_b << 1);
491 u4_cxt_inc = (u4_cxt_inc | 0x55540);
492
493 i1_ref_idx = (WORD8)ih264d_decode_bins_unary(32, u4_cxt_inc,
494 ps_ref_cxt, ps_bitstrm,
495 ps_cab_env);
496
497 if((i1_ref_idx > u1_max_ref_minus1) || (i1_ref_idx < 0))
498 {
499 return ERROR_REF_IDX;
500 }
501
502 *pi1_ref_idx = i1_ref_idx;
503
504 INC_SYM_COUNT(ps_cab_env);
505
506 }
507
508 /* Storing Reference Idx Information */
509 pi1_lft_cxt[u1_idx_lft] = i1_ref_idx;
510 pi1_top_cxt[u1_idx_top] = i1_ref_idx;
511 u1_blk_no = u1_blk_no + 1 + (u1_mb_mode & 0x01);
512 }
513 /* if(!u1_sub_mb) */
514 if(u1_num_part != 4)
515 {
516 pi1_lft_cxt[(!(u1_mb_mode & 0x1)) + u1_b2] = pi1_lft_cxt[u1_b2];
517 pi1_top_cxt[(!(u1_mb_mode & 0x2)) + u1_b2] = pi1_top_cxt[u1_b2];
518 }
519 return OK;
520 }
521
522 /*!
523 **************************************************************************
524 * \if Function name : ih264d_parse_mb_qp_delta_cabac \endif
525 *
526 * \brief
527 * This function decodes MB Qp delta using CABAC entropy coding mode.
528 *
529 * \return
530 * None
531 *
532 **************************************************************************
533 */
ih264d_parse_mb_qp_delta_cabac(struct _DecStruct * ps_dec,WORD8 * pi1_mb_qp_delta)534 WORD32 ih264d_parse_mb_qp_delta_cabac(struct _DecStruct * ps_dec,
535 WORD8 *pi1_mb_qp_delta)
536 {
537 decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;
538 dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
539
540 UWORD8 u1_code_num;
541 bin_ctxt_model_t *ps_mb_qp_delta_ctxt = ps_dec->p_mb_qp_delta_t;
542 UWORD32 u4_cxt_inc;
543
544 INC_SYM_COUNT(ps_cab_env);
545
546 u4_cxt_inc = (!(!(ps_dec->i1_prev_mb_qp_delta)));
547
548 u1_code_num = 0;
549 u4_cxt_inc = (u4_cxt_inc | 0x33320);
550 /* max number of bins = 53,
551 since Range for MbQpDelta= -26 to +25 inclusive, UNARY code */
552 u1_code_num = ih264d_decode_bins_unary(32, u4_cxt_inc, ps_mb_qp_delta_ctxt,
553 ps_bitstrm, ps_cab_env);
554 if(u1_code_num == 32)
555 {
556 /* Read remaining 21 bins */
557 UWORD8 uc_codeNumX;
558 u4_cxt_inc = 0x33333;
559 uc_codeNumX = ih264d_decode_bins_unary(21, u4_cxt_inc, ps_mb_qp_delta_ctxt,
560 ps_bitstrm, ps_cab_env);
561 u1_code_num = u1_code_num + uc_codeNumX;
562 }
563
564 *pi1_mb_qp_delta = (u1_code_num + 1) >> 1;
565 /* Table 9.3: If code_num is even Syntax Element has -ve value */
566 if(!(u1_code_num & 0x01))
567 *pi1_mb_qp_delta = -(*pi1_mb_qp_delta);
568
569 /* Range of MbQpDelta= -26 to +25 inclusive */
570 if((*pi1_mb_qp_delta < -26) || (*pi1_mb_qp_delta > 25))
571 return ERROR_INV_RANGE_QP_T;
572 ps_dec->i1_prev_mb_qp_delta = *pi1_mb_qp_delta;
573 return OK;
574 }
575 /*!
576 **************************************************************************
577 * \if Function name : ih264d_parse_chroma_pred_mode_cabac \endif
578 *
579 * \brief
580 * This function decodes Chroma Pred mode using CABAC entropy coding mode.
581 *
582 * \return
583 * None
584 *
585 **************************************************************************
586 */
ih264d_parse_chroma_pred_mode_cabac(struct _DecStruct * ps_dec)587 WORD8 ih264d_parse_chroma_pred_mode_cabac(struct _DecStruct * ps_dec)
588 {
589 decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;
590 dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
591 ctxt_inc_mb_info_t * ps_left_ctxt = ps_dec->p_left_ctxt_mb_info;
592 ctxt_inc_mb_info_t * ps_top_ctxt = ps_dec->p_top_ctxt_mb_info;
593 WORD8 i1_chroma_pred_mode, a, b;
594 UWORD32 u4_cxt_inc;
595
596 INC_SYM_COUNT(ps_cab_env);
597
598 /* Binarization is TU and Cmax=3 */
599 i1_chroma_pred_mode = 0;
600 a = 0;
601 b = 0;
602
603 a = ((ps_left_ctxt->u1_intra_chroma_pred_mode != 0) ? 1 : 0);
604
605 b = ((ps_top_ctxt->u1_intra_chroma_pred_mode != 0) ? 1 : 0);
606 u4_cxt_inc = a + b;
607
608 u4_cxt_inc = (u4_cxt_inc | 0x330);
609
610 i1_chroma_pred_mode = ih264d_decode_bins_tunary(
611 3, u4_cxt_inc, ps_dec->p_intra_chroma_pred_mode_t,
612 ps_bitstrm, ps_cab_env);
613
614 return (i1_chroma_pred_mode);
615 }
616
617 /*****************************************************************************/
618 /* */
619 /* Function Name : ih264d_parse_transform8x8flag_cabac */
620 /* */
621 /* Description : */
622 /* Inputs : */
623 /* */
624 /* */
625 /* Returns : */
626 /* */
627 /* Revision History: */
628 /* */
629 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
630 /* Rajasekhar Creation */
631 /* */
632 /*****************************************************************************/
ih264d_parse_transform8x8flag_cabac(struct _DecStruct * ps_dec,dec_mb_info_t * ps_cur_mb_info)633 UWORD8 ih264d_parse_transform8x8flag_cabac(struct _DecStruct * ps_dec,
634 dec_mb_info_t * ps_cur_mb_info)
635 {
636 decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;
637 dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
638 ctxt_inc_mb_info_t * ps_left_ctxt = ps_dec->p_left_ctxt_mb_info;
639 ctxt_inc_mb_info_t * ps_top_ctxt = ps_dec->p_top_ctxt_mb_info;
640 UWORD8 u1_transform_8x8flag;
641 UWORD8 u1_mb_ngbr_avail = ps_cur_mb_info->u1_mb_ngbr_availablity;
642
643 WORD8 a, b;
644 UWORD32 u4_cxt_inc;
645
646 /* for calculating the context increment for transform8x8 u4_flag */
647 /* it reads transform8x8 u4_flag of the neighbors through */
648
649 /* Binarization is FLC */
650 a = 0;
651 b = 0;
652
653 if(u1_mb_ngbr_avail & LEFT_MB_AVAILABLE_MASK)
654 {
655 a = ps_left_ctxt->u1_transform8x8_ctxt;
656 }
657 if(u1_mb_ngbr_avail & TOP_MB_AVAILABLE_MASK)
658 {
659 b = ps_top_ctxt->u1_transform8x8_ctxt;
660
661 }
662
663 u4_cxt_inc = a + b;
664
665 u1_transform_8x8flag = ih264d_decode_bin(
666 u4_cxt_inc, ps_dec->s_high_profile.ps_transform8x8_flag,
667 ps_bitstrm, ps_cab_env);
668
669 return (u1_transform_8x8flag);
670 }
671
672 /*!
673 **************************************************************************
674 * \if Function name : ih264d_read_intra_pred_modes_cabac \endif
675 *
676 * \brief
677 * Reads the intra pred mode related values of I4x4 MB from bitstream.
678 *
679 * This function will read the prev intra pred mode flags and
680 * stores it in pu1_prev_intra4x4_pred_mode_flag. If the u4_flag
681 * indicates that most probable mode is not intra pred mode, then
682 * the rem_intra4x4_pred_mode is read and stored in
683 * pu1_rem_intra4x4_pred_mode array.
684 *
685 *
686 * \return
687 * 0 on success and Error code otherwise
688 *
689 **************************************************************************
690 */
ih264d_read_intra_pred_modes_cabac(dec_struct_t * ps_dec,UWORD8 * pu1_prev_intra4x4_pred_mode_flag,UWORD8 * pu1_rem_intra4x4_pred_mode,UWORD8 u1_tran_form8x8)691 WORD32 ih264d_read_intra_pred_modes_cabac(dec_struct_t * ps_dec,
692 UWORD8 * pu1_prev_intra4x4_pred_mode_flag,
693 UWORD8 * pu1_rem_intra4x4_pred_mode,
694 UWORD8 u1_tran_form8x8)
695 {
696 WORD32 i4x4_luma_blk_idx = 0;
697 dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
698 decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;
699 bin_ctxt_model_t *ps_ctxt_ipred_luma_mpm, *ps_ctx_ipred_luma_rm;
700 WORD32 i4_rem_intra4x4_pred_mode;
701 UWORD32 u4_prev_intra4x4_pred_mode_flag;
702 UWORD32 u4_code_int_range, u4_code_int_val_ofst;
703 const UWORD32 *pu4_table = (const UWORD32 *)ps_cab_env->cabac_table;
704
705 ps_ctxt_ipred_luma_mpm = ps_dec->p_prev_intra4x4_pred_mode_flag_t;
706 ps_ctx_ipred_luma_rm = ps_dec->p_rem_intra4x4_pred_mode_t;
707 SWITCHOFFTRACE;
708
709 i4x4_luma_blk_idx = (0 == u1_tran_form8x8) ? 16 : 4;
710
711 u4_code_int_range = ps_cab_env->u4_code_int_range;
712 u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;
713
714 do
715 {
716
717 DECODE_ONE_BIN_MACRO(ps_ctxt_ipred_luma_mpm, u4_code_int_range,
718 u4_code_int_val_ofst, pu4_table, ps_bitstrm,
719 u4_prev_intra4x4_pred_mode_flag)
720 *pu1_prev_intra4x4_pred_mode_flag = u4_prev_intra4x4_pred_mode_flag;
721
722 i4_rem_intra4x4_pred_mode = -1;
723 if(!u4_prev_intra4x4_pred_mode_flag)
724 {
725
726 /*inlining DecodeDecisionBins_FLC*/
727
728 {
729
730 UWORD8 u1_max_bins = 3;
731 UWORD32 u4_value;
732 UWORD32 u4_symbol, i;
733
734 i = 0;
735 u4_value = 0;
736
737 do
738 {
739
740 DECODE_ONE_BIN_MACRO(ps_ctx_ipred_luma_rm, u4_code_int_range,
741 u4_code_int_val_ofst, pu4_table,
742 ps_bitstrm, u4_symbol)
743
744 INC_BIN_COUNT(ps_cab_env);INC_DECISION_BINS(ps_cab_env);
745
746 u4_value = u4_value | (u4_symbol << i);
747
748 i++;
749 }
750 while(i < u1_max_bins);
751
752 i4_rem_intra4x4_pred_mode = (u4_value);
753
754 }
755
756 }
757
758 (*pu1_rem_intra4x4_pred_mode) = i4_rem_intra4x4_pred_mode;
759
760 COPYTHECONTEXT("intra4x4_pred_mode", i4_rem_intra4x4_pred_mode);
761
762 pu1_prev_intra4x4_pred_mode_flag++;
763 pu1_rem_intra4x4_pred_mode++;
764
765 i4x4_luma_blk_idx--;
766 }
767 while(i4x4_luma_blk_idx);
768
769 ps_cab_env->u4_code_int_range = u4_code_int_range;
770 ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;
771
772 return (0);
773
774 }
775
776 /*!
777 **************************************************************************
778 * \if Function name : ih264d_parse_ctx_cbp_cabac \endif
779 *
780 * \brief
781 * This function decodes CtxCbpLuma and CtxCbpChroma (CBP of a Macroblock).
782 * using CABAC entropy coding mode.
783 *
784 * \return
785 * CBP of a MB.
786 *
787 **************************************************************************
788 */
ih264d_parse_ctx_cbp_cabac(struct _DecStruct * ps_dec)789 UWORD32 ih264d_parse_ctx_cbp_cabac(struct _DecStruct * ps_dec)
790 {
791
792 UWORD32 u4_cxt_inc;
793 decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;
794 dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
795 ctxt_inc_mb_info_t * ps_left_ctxt = ps_dec->p_left_ctxt_mb_info;
796 ctxt_inc_mb_info_t * ps_top_ctxt = ps_dec->p_top_ctxt_mb_info;
797 bin_ctxt_model_t *ps_ctxt_cbp_luma = ps_dec->p_cbp_luma_t, *ps_bin_ctxt;
798 WORD8 c_Cbp; //,i,j;
799 UWORD32 u4_code_int_range, u4_code_int_val_ofst;
800 UWORD32 u4_offset, *pu4_buffer;
801 const UWORD32 *pu4_table = (const UWORD32 *)ps_cab_env->cabac_table;
802
803 INC_SYM_COUNT(ps_cab_env);
804
805
806
807 /* CBP Luma, FL, Cmax = 15, L = 4 */
808 u4_cxt_inc = (!((ps_top_ctxt->u1_cbp >> 2) & 0x01)) << 1;
809 u4_cxt_inc += !((ps_left_ctxt->u1_cbp >> 1) & 0x01);
810
811 u4_offset = ps_bitstrm->u4_ofst;
812 pu4_buffer = ps_bitstrm->pu4_buffer;
813
814 u4_code_int_range = ps_cab_env->u4_code_int_range;
815 u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;
816 /*renormalize to ensure there 23 bits more in the u4_code_int_val_ofst*/
817 {
818 UWORD32 u4_clz, read_bits;
819
820 u4_clz = CLZ(u4_code_int_range);
821 FLUSHBITS(u4_offset, u4_clz)
822 NEXTBITS(read_bits, u4_offset, pu4_buffer, 23)
823 u4_code_int_range = u4_code_int_range << u4_clz;
824 u4_code_int_val_ofst = (u4_code_int_val_ofst << u4_clz) | read_bits;
825 }
826
827 ps_bin_ctxt = ps_ctxt_cbp_luma + u4_cxt_inc;
828
829 /*inlining DecodeDecision_onebin without renorm*/
830 {
831
832 UWORD32 u4_qnt_int_range, u4_int_range_lps;
833 UWORD32 u4_symbol, u1_mps_state;
834 UWORD32 table_lookup;
835 UWORD32 u4_clz;
836
837 u1_mps_state = (ps_bin_ctxt->u1_mps_state);
838
839 u4_clz = CLZ(u4_code_int_range);
840 u4_qnt_int_range = u4_code_int_range << u4_clz;
841 u4_qnt_int_range = (u4_qnt_int_range >> 29) & 0x3;
842
843 table_lookup = pu4_table[(u1_mps_state << 2) + u4_qnt_int_range];
844 u4_int_range_lps = table_lookup & 0xff;
845
846 u4_int_range_lps = u4_int_range_lps << (23 - u4_clz);
847 u4_code_int_range = u4_code_int_range - u4_int_range_lps;
848
849 u4_symbol = ((u1_mps_state >> 6) & 0x1);
850
851 /*if mps*/
852 u1_mps_state = (table_lookup >> 8) & 0x7F;
853
854 CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst, u4_symbol,
855 u4_int_range_lps, u1_mps_state, table_lookup)
856
857 INC_BIN_COUNT(ps_cab_env);
858
859 ps_bin_ctxt->u1_mps_state = u1_mps_state;
860
861 c_Cbp = u4_symbol;
862
863 }
864
865 u4_cxt_inc = (!((ps_top_ctxt->u1_cbp >> 3) & 0x01)) << 1;
866 u4_cxt_inc += !(c_Cbp & 0x01);
867 ps_bin_ctxt = ps_ctxt_cbp_luma + u4_cxt_inc;
868 /*inlining DecodeDecision_onebin without renorm*/
869
870 {
871
872 UWORD32 u4_qnt_int_range, u4_int_range_lps;
873 UWORD32 u4_symbol, u1_mps_state;
874 UWORD32 table_lookup;
875 UWORD32 u4_clz;
876
877 u1_mps_state = (ps_bin_ctxt->u1_mps_state);
878
879 u4_clz = CLZ(u4_code_int_range);
880 u4_qnt_int_range = u4_code_int_range << u4_clz;
881 u4_qnt_int_range = (u4_qnt_int_range >> 29) & 0x3;
882
883 table_lookup = pu4_table[(u1_mps_state << 2) + u4_qnt_int_range];
884 u4_int_range_lps = table_lookup & 0xff;
885
886 u4_int_range_lps = u4_int_range_lps << (23 - u4_clz);
887 u4_code_int_range = u4_code_int_range - u4_int_range_lps;
888
889 u4_symbol = ((u1_mps_state >> 6) & 0x1);
890
891 /*if mps*/
892 u1_mps_state = (table_lookup >> 8) & 0x7F;
893
894 CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst, u4_symbol,
895 u4_int_range_lps, u1_mps_state, table_lookup)
896
897 INC_BIN_COUNT(ps_cab_env);
898
899 ps_bin_ctxt->u1_mps_state = u1_mps_state;
900
901 c_Cbp |= u4_symbol << 1;
902
903 }
904
905 u4_cxt_inc = (!(c_Cbp & 0x01)) << 1;
906 u4_cxt_inc += !((ps_left_ctxt->u1_cbp >> 3) & 0x01);
907 ps_bin_ctxt = ps_ctxt_cbp_luma + u4_cxt_inc;
908 /*inlining DecodeDecision_onebin without renorm*/
909
910 {
911
912 UWORD32 u4_qnt_int_range, u4_int_range_lps;
913 UWORD32 u4_symbol, u1_mps_state;
914 UWORD32 table_lookup;
915 UWORD32 u4_clz;
916
917 u1_mps_state = (ps_bin_ctxt->u1_mps_state);
918
919 u4_clz = CLZ(u4_code_int_range);
920 u4_qnt_int_range = u4_code_int_range << u4_clz;
921 u4_qnt_int_range = (u4_qnt_int_range >> 29) & 0x3;
922
923 table_lookup = pu4_table[(u1_mps_state << 2) + u4_qnt_int_range];
924 u4_int_range_lps = table_lookup & 0xff;
925
926 u4_int_range_lps = u4_int_range_lps << (23 - u4_clz);
927 u4_code_int_range = u4_code_int_range - u4_int_range_lps;
928
929 u4_symbol = ((u1_mps_state >> 6) & 0x1);
930
931 /*if mps*/
932 u1_mps_state = (table_lookup >> 8) & 0x7F;
933
934 CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst, u4_symbol,
935 u4_int_range_lps, u1_mps_state, table_lookup)
936
937 INC_BIN_COUNT(ps_cab_env);
938
939 ps_bin_ctxt->u1_mps_state = u1_mps_state;
940
941 c_Cbp |= u4_symbol << 2;
942
943 }
944
945 u4_cxt_inc = (!((c_Cbp >> 1) & 0x01)) << 1;
946 u4_cxt_inc += !((c_Cbp >> 2) & 0x01);
947 ps_bin_ctxt = ps_ctxt_cbp_luma + u4_cxt_inc;
948 /*inlining DecodeDecision_onebin without renorm*/
949
950 {
951
952 UWORD32 u4_qnt_int_range, u4_int_range_lps;
953 UWORD32 u4_symbol, u1_mps_state;
954 UWORD32 table_lookup;
955 UWORD32 u4_clz;
956
957 u1_mps_state = (ps_bin_ctxt->u1_mps_state);
958
959 u4_clz = CLZ(u4_code_int_range);
960 u4_qnt_int_range = u4_code_int_range << u4_clz;
961 u4_qnt_int_range = (u4_qnt_int_range >> 29) & 0x3;
962
963 table_lookup = pu4_table[(u1_mps_state << 2) + u4_qnt_int_range];
964 u4_int_range_lps = table_lookup & 0xff;
965
966 u4_int_range_lps = u4_int_range_lps << (23 - u4_clz);
967 u4_code_int_range = u4_code_int_range - u4_int_range_lps;
968
969 u4_symbol = ((u1_mps_state >> 6) & 0x1);
970
971 /*if mps*/
972 u1_mps_state = (table_lookup >> 8) & 0x7F;
973
974 CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst, u4_symbol,
975 u4_int_range_lps, u1_mps_state, table_lookup)
976
977 INC_BIN_COUNT(ps_cab_env);
978
979 ps_bin_ctxt->u1_mps_state = u1_mps_state;
980
981 c_Cbp |= u4_symbol << 3;
982
983 }
984
985 if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_8)
986 {
987
988 RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst, u4_offset,
989 pu4_buffer)
990
991 }
992
993 {
994 UWORD32 u4_cxt_inc;
995 WORD8 a, b, c, d;
996 bin_ctxt_model_t *p_CtxtCbpChroma = ps_dec->p_cbp_chroma_t;
997
998 /* CBP Chroma, TU, Cmax = 2 */
999 a = 0;
1000 b = 0;
1001 c = 0;
1002 d = 0;
1003
1004 {
1005 a = (ps_top_ctxt->u1_cbp > 15) ? 2 : 0;
1006 c = (ps_top_ctxt->u1_cbp > 31) ? 2 : 0;
1007 }
1008
1009 {
1010 b = (ps_left_ctxt->u1_cbp > 15) ? 1 : 0;
1011 d = (ps_left_ctxt->u1_cbp > 31) ? 1 : 0;
1012 }
1013 u4_cxt_inc = a + b;
1014 u4_cxt_inc = (u4_cxt_inc | ((4 + c + d) << 4));
1015
1016 /*inlining ih264d_decode_bins_tunary */
1017
1018 {
1019
1020 UWORD8 u1_max_bins = 2;
1021 UWORD32 u4_ctx_inc = u4_cxt_inc;
1022
1023 UWORD32 u4_value;
1024 UWORD32 u4_symbol;
1025 UWORD8 u4_ctx_Inc;
1026 bin_ctxt_model_t *ps_bin_ctxt;
1027 u4_value = 0;
1028
1029 do
1030 {
1031 u4_ctx_Inc = u4_ctx_inc & 0xF;
1032 u4_ctx_inc = u4_ctx_inc >> 4;
1033
1034 ps_bin_ctxt = p_CtxtCbpChroma + u4_ctx_Inc;
1035 /*inlining DecodeDecision_onebin*/
1036 {
1037
1038 UWORD32 u4_qnt_int_range, u4_int_range_lps;
1039
1040 UWORD32 u1_mps_state;
1041 UWORD32 table_lookup;
1042 UWORD32 u4_clz;
1043
1044 u1_mps_state = (ps_bin_ctxt->u1_mps_state);
1045
1046 u4_clz = CLZ(u4_code_int_range);
1047 u4_qnt_int_range = u4_code_int_range << u4_clz;
1048 u4_qnt_int_range = (u4_qnt_int_range >> 29) & 0x3;
1049
1050 table_lookup = pu4_table[(u1_mps_state << 2)
1051 + u4_qnt_int_range];
1052 u4_int_range_lps = table_lookup & 0xff;
1053
1054 u4_int_range_lps = u4_int_range_lps << (23 - u4_clz);
1055 u4_code_int_range = u4_code_int_range - u4_int_range_lps;
1056
1057 u4_symbol = ((u1_mps_state >> 6) & 0x1);
1058
1059 /*if mps*/
1060 u1_mps_state = (table_lookup >> 8) & 0x7F;
1061
1062 CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst,
1063 u4_symbol, u4_int_range_lps, u1_mps_state,
1064 table_lookup)
1065
1066 if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_8)
1067 {
1068 RENORM_RANGE_OFFSET(u4_code_int_range,
1069 u4_code_int_val_ofst, u4_offset,
1070 pu4_buffer)
1071 }
1072 ps_bin_ctxt->u1_mps_state = u1_mps_state;
1073 }
1074
1075 INC_BIN_COUNT(ps_cab_env);INC_DECISION_BINS(
1076 ps_cab_env);
1077
1078 u4_value++;
1079 }
1080 while((u4_value < u1_max_bins) & (u4_symbol));
1081
1082 u4_value = u4_value - 1 + u4_symbol;
1083
1084 a = (u4_value);
1085
1086 }
1087
1088 c_Cbp = (c_Cbp | (a << 4));
1089 }
1090
1091 ps_bitstrm->u4_ofst = u4_offset;
1092
1093 ps_cab_env->u4_code_int_range = u4_code_int_range;
1094 ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;
1095
1096 return (c_Cbp);
1097 }
1098
1099 /*!
1100 **************************************************************************
1101 * \if Function name : ih264d_get_mvd_cabac \endif
1102 *
1103 * \brief
1104 * This function decodes Horz and Vert mvd_l0 and mvd_l1 using CABAC entropy
1105 * coding mode as defined in 9.3.2.3.
1106 *
1107 * \return
1108 * None
1109 *
1110 **************************************************************************
1111 */
ih264d_get_mvd_cabac(UWORD8 u1_sub_mb,UWORD8 u1_b2,UWORD8 u1_part_wd,UWORD8 u1_part_ht,UWORD8 u1_dec_mvd,dec_struct_t * ps_dec,mv_pred_t * ps_mv)1112 void ih264d_get_mvd_cabac(UWORD8 u1_sub_mb,
1113 UWORD8 u1_b2,
1114 UWORD8 u1_part_wd,
1115 UWORD8 u1_part_ht,
1116 UWORD8 u1_dec_mvd,
1117 dec_struct_t *ps_dec,
1118 mv_pred_t *ps_mv)
1119 {
1120 UWORD8 u1_abs_mvd_x = 0, u1_abs_mvd_y = 0;
1121 UWORD8 u1_sub_mb_x, u1_sub_mb_y;
1122 UWORD8 *pu1_top_mv_ctxt, *pu1_lft_mv_ctxt;
1123 WORD16 *pi2_mv;
1124
1125 u1_sub_mb_x = (UWORD8)(u1_sub_mb & 0x03);
1126 u1_sub_mb_y = (UWORD8)(u1_sub_mb >> 2);
1127 pu1_top_mv_ctxt = &ps_dec->ps_curr_ctxt_mb_info->u1_mv[u1_sub_mb_x][u1_b2];
1128 pu1_lft_mv_ctxt = &ps_dec->pu1_left_mv_ctxt_inc[u1_sub_mb_y][u1_b2];
1129 pi2_mv = &ps_mv->i2_mv[u1_b2];
1130
1131 if(u1_dec_mvd)
1132 {
1133 WORD16 i2_mv_x, i2_mv_y;
1134 WORD32 i2_temp;
1135 {
1136 decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;
1137 dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
1138 UWORD16 u2_abs_mvd_x_a, u2_abs_mvd_x_b, u2_abs_mvd_y_a,
1139 u2_abs_mvd_y_b;
1140
1141 u2_abs_mvd_x_b = (UWORD16)pu1_top_mv_ctxt[0];
1142 u2_abs_mvd_y_b = (UWORD16)pu1_top_mv_ctxt[1];
1143 u2_abs_mvd_x_a = (UWORD16)pu1_lft_mv_ctxt[0];
1144 u2_abs_mvd_y_a = (UWORD16)pu1_lft_mv_ctxt[1];
1145
1146 i2_temp = u2_abs_mvd_x_a + u2_abs_mvd_x_b;
1147
1148 i2_mv_x = ih264d_parse_mvd_cabac(ps_bitstrm, ps_cab_env,
1149 ps_dec->p_mvd_x_t, i2_temp);
1150
1151 i2_temp = u2_abs_mvd_y_a + u2_abs_mvd_y_b;
1152
1153 i2_mv_y = ih264d_parse_mvd_cabac(ps_bitstrm, ps_cab_env,
1154 ps_dec->p_mvd_y_t, i2_temp);
1155 }
1156
1157 /***********************************************************************/
1158 /* Store the abs_mvd_values in cabac contexts */
1159 /* The follownig code can be easily optimzed if mvX, mvY clip values */
1160 /* are packed in 16 bits follwed by memcpy */
1161 /***********************************************************************/
1162 u1_abs_mvd_x = CLIP3(0, 127, ABS(i2_mv_x));
1163 u1_abs_mvd_y = CLIP3(0, 127, ABS(i2_mv_y));
1164
1165 COPYTHECONTEXT("MVD", i2_mv_x);COPYTHECONTEXT("MVD", i2_mv_y);
1166
1167 /* Storing Mv residuals */
1168 pi2_mv[0] = i2_mv_x;
1169 pi2_mv[1] = i2_mv_y;
1170 }
1171
1172 /***************************************************************/
1173 /* Store abs_mvd_values cabac contexts */
1174 /***************************************************************/
1175 #ifndef ARM
1176 {
1177 UWORD8 u1_i;
1178 for(u1_i = 0; u1_i < u1_part_wd; u1_i++, pu1_top_mv_ctxt += 4)
1179 {
1180 pu1_top_mv_ctxt[0] = u1_abs_mvd_x;
1181 pu1_top_mv_ctxt[1] = u1_abs_mvd_y;
1182 }
1183
1184 for(u1_i = 0; u1_i < u1_part_ht; u1_i++, pu1_lft_mv_ctxt += 4)
1185 {
1186 pu1_lft_mv_ctxt[0] = u1_abs_mvd_x;
1187 pu1_lft_mv_ctxt[1] = u1_abs_mvd_y;
1188 }
1189 }
1190 #else
1191 /* Optimising the loop, with Little-Endian Assumption */
1192 {
1193 UWORD16 *pu2_top_cxt = (UWORD16 *)pu1_top_mv_ctxt;
1194 UWORD16 *pu2_lft_cxt = (UWORD16 *)pu1_lft_mv_ctxt;
1195 UWORD16 u2_pack_mvd = (UWORD16)((u1_abs_mvd_y << 8) | u1_abs_mvd_x);
1196 UWORD8 u1_wd = u1_part_wd, u1_ht = u1_part_ht;
1197
1198 u1_wd--;
1199 *pu2_top_cxt = u2_pack_mvd;
1200 pu2_top_cxt += 2;
1201 if(u1_wd)
1202 {
1203 u1_wd--;
1204 *pu2_top_cxt = u2_pack_mvd;
1205 pu2_top_cxt += 2;
1206 }
1207 if(u1_wd)
1208 {
1209 *pu2_top_cxt = u2_pack_mvd;
1210 pu2_top_cxt += 2;
1211 *pu2_top_cxt = u2_pack_mvd;
1212 }
1213 u1_ht--;
1214 *pu2_lft_cxt = u2_pack_mvd;
1215 pu2_lft_cxt += 2;
1216 if(u1_ht)
1217 {
1218 u1_ht--;
1219 *pu2_lft_cxt = u2_pack_mvd;
1220 pu2_lft_cxt += 2;
1221 }
1222 if(u1_ht)
1223 {
1224 *pu2_lft_cxt = u2_pack_mvd;
1225 pu2_lft_cxt += 2;
1226 *pu2_lft_cxt = u2_pack_mvd;
1227 }
1228 }
1229 #endif
1230 }
1231
1232 /*****************************************************************************/
1233 /* */
1234 /* Function Name : ih264d_parse_mvd_cabac */
1235 /* */
1236 /* Description : This cabac function decodes the mvd in a given direction */
1237 /* direction ( x or y ) as defined in 9.3.2.3. */
1238 /* */
1239 /* Inputs : 1. pointer to Bitstream */
1240 /* 2. pointer to cabac decoding environmnet */
1241 /* 3. pointer to Mvd context */
1242 /* 4. abs(Top mvd) = u2_abs_mvd_b */
1243 /* 5. abs(left mvd)= u2_abs_mvd_a */
1244 /* */
1245 /* Processing : see section 9.3.2.3 of the standard */
1246 /* */
1247 /* Outputs : i2_mvd */
1248 /* Returns : i2_mvd */
1249 /* */
1250 /* Issues : none */
1251 /* */
1252 /* Revision History: */
1253 /* */
1254 /* DD MM YYYY Author(s) Changes (Describe the changes made) */
1255 /* 16 06 2005 Jay Draft */
1256 /* */
1257 /*****************************************************************************/
ih264d_parse_mvd_cabac(dec_bit_stream_t * ps_bitstrm,decoding_envirnoment_t * ps_cab_env,bin_ctxt_model_t * p_ctxt_mvd,UWORD32 i4_temp)1258 WORD16 ih264d_parse_mvd_cabac(dec_bit_stream_t * ps_bitstrm,
1259 decoding_envirnoment_t * ps_cab_env,
1260 bin_ctxt_model_t * p_ctxt_mvd,
1261 UWORD32 i4_temp)
1262
1263 {
1264 WORD8 k;
1265 WORD16 i2_suf;
1266 WORD16 i2_mvd;
1267 UWORD16 u2_abs_mvd;
1268 UWORD32 u4_ctx_inc;
1269 UWORD32 u4_prefix;
1270 const UWORD32 *pu4_table = (const UWORD32 *)ps_cab_env->cabac_table;
1271 UWORD32 u4_code_int_range, u4_code_int_val_ofst;
1272
1273 /* if mvd < 9 */
1274 /* mvd = Prefix */
1275 /* else */
1276 /* mvd = Prefix + Suffix */
1277 /* decode sign bit */
1278 /* Prefix TU decoding Cmax =Ucoff and Suffix 3rd order Exp-Golomb */
1279
1280 u2_abs_mvd = (UWORD16)i4_temp;
1281 u4_ctx_inc = 1;
1282
1283 if(u2_abs_mvd < 3)
1284 u4_ctx_inc = 0;
1285 else if(u2_abs_mvd > 32)
1286 u4_ctx_inc = 2;
1287
1288 u4_ctx_inc = (u4_ctx_inc | 0x65430);
1289
1290 /*inlining modified version of ih264d_decode_bins_unary*/
1291
1292 {
1293 UWORD8 u1_max_bins = 9;
1294 UWORD32 u4_value;
1295 UWORD32 u4_symbol;
1296 bin_ctxt_model_t *ps_bin_ctxt;
1297 UWORD32 u4_ctx_Inc;
1298
1299 u4_value = 0;
1300 u4_code_int_range = ps_cab_env->u4_code_int_range;
1301 u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;
1302
1303 do
1304 {
1305 u4_ctx_Inc = u4_ctx_inc & 0xf;
1306 u4_ctx_inc = u4_ctx_inc >> 4;
1307
1308 ps_bin_ctxt = p_ctxt_mvd + u4_ctx_Inc;
1309
1310 DECODE_ONE_BIN_MACRO(ps_bin_ctxt, u4_code_int_range,
1311 u4_code_int_val_ofst, pu4_table, ps_bitstrm,
1312 u4_symbol)
1313
1314 INC_BIN_COUNT(ps_cab_env);INC_DECISION_BINS(ps_cab_env);
1315
1316 u4_value++;
1317
1318 }
1319 while(u4_symbol && u4_value < 5);
1320
1321 ps_bin_ctxt = p_ctxt_mvd + 6;
1322
1323 if(u4_symbol && (u4_value < u1_max_bins))
1324 {
1325
1326 do
1327 {
1328
1329 DECODE_ONE_BIN_MACRO(ps_bin_ctxt, u4_code_int_range,
1330 u4_code_int_val_ofst, pu4_table,
1331 ps_bitstrm, u4_symbol)
1332
1333 INC_BIN_COUNT(ps_cab_env);INC_DECISION_BINS(ps_cab_env);
1334 u4_value++;
1335 }
1336 while(u4_symbol && (u4_value < u1_max_bins));
1337
1338 }
1339
1340 ps_cab_env->u4_code_int_range = u4_code_int_range;
1341 ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;
1342 u4_value = u4_value - 1 + u4_symbol;
1343 u4_prefix = (u4_value);
1344 }
1345
1346 i2_mvd = u4_prefix;
1347
1348 if(i2_mvd == 9)
1349 {
1350 /* Read Suffix */
1351 k = ih264d_decode_bypass_bins_unary(ps_cab_env, ps_bitstrm);
1352 i2_suf = (1 << k) - 1;
1353 k = k + 3;
1354 i2_suf = (i2_suf << 3);
1355 i2_mvd += i2_suf;
1356 i2_suf = ih264d_decode_bypass_bins(ps_cab_env, k, ps_bitstrm);
1357 i2_mvd += i2_suf;
1358 }
1359 /* Read Sign bit */
1360 if(!i2_mvd)
1361 return (i2_mvd);
1362
1363 else
1364 {
1365 UWORD32 u4_code_int_val_ofst, u4_code_int_range;
1366
1367 u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst;
1368 u4_code_int_range = ps_cab_env->u4_code_int_range;
1369
1370 if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_9)
1371 {
1372 UWORD32 *pu4_buffer, u4_offset;
1373
1374 pu4_buffer = ps_bitstrm->pu4_buffer;
1375 u4_offset = ps_bitstrm->u4_ofst;
1376
1377 RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst,
1378 u4_offset, pu4_buffer)
1379 ps_bitstrm->u4_ofst = u4_offset;
1380 }
1381
1382 u4_code_int_range = u4_code_int_range >> 1;
1383
1384 if(u4_code_int_val_ofst >= u4_code_int_range)
1385 {
1386 /* S=1 */
1387 u4_code_int_val_ofst -= u4_code_int_range;
1388 i2_mvd = (-i2_mvd);
1389 }
1390
1391 ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst;
1392 ps_cab_env->u4_code_int_range = u4_code_int_range;
1393
1394 return (i2_mvd);
1395
1396 }
1397 }
1398