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 *******************************************************************************
23 * @file
24 * ih264e_cabac.c
25 *
26 * @brief
27 * Contains all functions to encode in CABAC entropy mode
28 *
29 *
30 * @author
31 * Doney Alex
32 *
33 * @par List of Functions:
34 *
35 *
36 * @remarks
37 * None
38 *
39 *******************************************************************************
40 */
41
42 /*****************************************************************************/
43 /* File Includes */
44 /*****************************************************************************/
45
46 /* System include files */
47 #include <stdio.h>
48 #include <assert.h>
49 #include <limits.h>
50 #include <string.h>
51
52 /* User include files */
53 #include "ih264e_config.h"
54 #include "ih264_typedefs.h"
55 #include "iv2.h"
56 #include "ive2.h"
57 #include "ih264_debug.h"
58 #include "ih264_defs.h"
59 #include "ih264e_defs.h"
60 #include "ih264_macros.h"
61 #include "ih264e_error.h"
62 #include "ih264e_bitstream.h"
63 #include "ime_distortion_metrics.h"
64 #include "ime_defs.h"
65 #include "ime_structs.h"
66 #include "ih264_error.h"
67 #include "ih264_structs.h"
68 #include "ih264_trans_quant_itrans_iquant.h"
69 #include "ih264_inter_pred_filters.h"
70 #include "ih264_mem_fns.h"
71 #include "ih264_padding.h"
72 #include "ih264_platform_macros.h"
73 #include "ih264_intra_pred_filters.h"
74 #include "ih264_deblk_edge_filters.h"
75 #include "ih264_cabac_tables.h"
76 #include "irc_cntrl_param.h"
77 #include "irc_frame_info_collector.h"
78 #include "ih264e_rate_control.h"
79 #include "ih264e_cabac_structs.h"
80 #include "ih264e_structs.h"
81 #include "ih264e_cabac.h"
82 #include "ih264e_encode_header.h"
83 #include "ih264_cavlc_tables.h"
84 #include "ih264e_cavlc.h"
85 #include "ih264e_statistics.h"
86 #include "ih264e_trace.h"
87
88 /*****************************************************************************/
89 /* Function Definitions */
90 /*****************************************************************************/
91
92
93
94
95 /**
96 *******************************************************************************
97 *
98 * @brief
99 * Encodes mb_skip_flag using CABAC entropy coding mode.
100 *
101 * @param[in] u1_mb_skip_flag
102 * mb_skip_flag
103 *
104 * @param[in] ps_cabac_ctxt
105 * Pointer to cabac context structure
106 *
107 * @param[in] u4_ctxidx_offset
108 * ctxIdxOffset for mb_skip_flag context
109 *
110 * @returns
111 *
112 * @remarks
113 * None
114 *
115 *******************************************************************************
116 */
ih264e_cabac_enc_mb_skip(UWORD8 u1_mb_skip_flag,cabac_ctxt_t * ps_cabac_ctxt,UWORD32 u4_ctxidx_offset)117 static void ih264e_cabac_enc_mb_skip(UWORD8 u1_mb_skip_flag,
118 cabac_ctxt_t *ps_cabac_ctxt,
119 UWORD32 u4_ctxidx_offset)
120 {
121
122 UWORD8 u4_ctx_inc;
123 WORD8 a, b;
124 a = ((ps_cabac_ctxt->ps_left_ctxt_mb_info->u1_mb_type & CAB_SKIP_MASK) ?
125 0 : 1);
126 b = ((ps_cabac_ctxt->ps_top_ctxt_mb_info->u1_mb_type & CAB_SKIP_MASK) ?
127 0 : 1);
128
129 u4_ctx_inc = a + b;
130 /* Encode the bin */
131 ih264e_cabac_encode_bin(ps_cabac_ctxt,
132 (UWORD32) u1_mb_skip_flag,
133 ps_cabac_ctxt->au1_cabac_ctxt_table + u4_ctxidx_offset
134 + u4_ctx_inc);
135
136 }
137
138
139 /* ! < Table 9-36 � Binarization for macroblock types in I slices in ITU_T_H264-201402
140 * Bits 0-7 : binarised value
141 * Bits 8-15: length of binary sequence
142 */
143 static const UWORD32 u4_mb_type_intra[26] =
144 { 0x0100, 0x0620, 0x0621, 0x0622, 0x0623, 0x0748, 0x0749, 0x074a, 0x074b,
145 0x074c, 0x074d, 0x074e, 0x074f, 0x0628, 0x0629, 0x062a, 0x062b, 0x0758,
146 0x0759, 0x075a, 0x075b, 0x075c, 0x075d, 0x075e, 0x075f, 0x0203 };
147
148
149 /* CtxInc for mb types */
150 static const UWORD32 u4_mb_ctxinc[2][26] =
151 {
152 /* Intra CtxInc's */
153 { 0x00,
154 0x03467, 0x03467, 0x03467, 0x03467, 0x034567, 0x034567, 0x034567,
155 0x034567, 0x034567, 0x034567, 0x034567, 0x034567, 0x03467, 0x03467,
156 0x03467, 0x03467, 0x034567, 0x034567, 0x034567, 0x034567, 0x034567,
157 0x034567, 0x034567, 0x034567, 0x00},
158 /* Inter CtxInc's */
159 { 0x00,
160 0x001233, 0x001233, 0x001233, 0x001233, 0x0012233, 0x0012233, 0x0012233,
161 0x0012233, 0x0012233, 0x0012233, 0x0012233, 0x0012233, 0x001233, 0x001233,
162 0x001233, 0x001233, 0x0012233, 0x0012233, 0x0012233, 0x0012233, 0x0012233,
163 0x0012233, 0x0012233, 0x0012233, 0x00}
164 };
165
166
167 /**
168 *******************************************************************************
169 *
170 * @brief
171 * Encodes mb_type for an intra MB.
172 *
173 * @param[in] u4_slice_type
174 * slice type
175 *
176 * @param[in] u4_intra_mb_type
177 * MB type (Table 7-11)
178 *
179 * @param[in] ps_cabac_ctxt
180 * Pointer to cabac context structure
181 *
182 ** @param[in] u4_ctxidx_offset
183 * ctxIdxOffset for mb_type context
184 *
185 * @returns
186 *
187 * @remarks
188 * None
189 *
190 *******************************************************************************
191 */
192
ih264e_cabac_enc_intra_mb_type(UWORD32 u4_slice_type,UWORD32 u4_intra_mb_type,cabac_ctxt_t * ps_cabac_ctxt,UWORD32 u4_ctx_idx_offset)193 static void ih264e_cabac_enc_intra_mb_type(UWORD32 u4_slice_type,
194 UWORD32 u4_intra_mb_type,
195 cabac_ctxt_t *ps_cabac_ctxt,
196 UWORD32 u4_ctx_idx_offset)
197 {
198
199 encoding_envirnoment_t *ps_cab_enc_env = &(ps_cabac_ctxt->s_cab_enc_env);
200 bin_ctxt_model *pu1_mb_bin_ctxt, *pu1_bin_ctxt;
201 UWORD8 u1_bin;
202 mb_info_ctxt_t *ps_left_ctxt = ps_cabac_ctxt->ps_left_ctxt_mb_info;
203 mb_info_ctxt_t *ps_top_ctxt = ps_cabac_ctxt->ps_top_ctxt_mb_info;
204 UWORD32 u4_bins;
205 UWORD32 u4_ctx_inc;
206 WORD8 i1_bins_len;
207 UWORD32 u4_code_int_range;
208 UWORD32 u4_code_int_low;
209 UWORD16 u2_quant_code_int_range;
210 UWORD16 u4_code_int_range_lps;
211 WORD8 i;
212 UWORD8 u1_ctx_inc;
213 UWORD32 u4_table_val;
214
215 pu1_mb_bin_ctxt = ps_cabac_ctxt->au1_cabac_ctxt_table + u4_ctx_idx_offset;
216
217 u4_bins = u4_mb_type_intra[u4_intra_mb_type];
218 i1_bins_len = (WORD8) ((u4_bins >> 8) & 0x0f);
219 u4_ctx_inc = u4_mb_ctxinc[(u4_slice_type != ISLICE)][u4_intra_mb_type];
220 u1_ctx_inc = 0;
221 if (u4_slice_type == ISLICE)
222 {
223 if (ps_left_ctxt != ps_cabac_ctxt->ps_def_ctxt_mb_info)
224 u1_ctx_inc += ((ps_left_ctxt->u1_mb_type != CAB_I4x4) ? 1 : 0);
225 if (ps_top_ctxt != ps_cabac_ctxt->ps_def_ctxt_mb_info)
226 u1_ctx_inc += ((ps_top_ctxt->u1_mb_type != CAB_I4x4) ? 1 : 0);
227
228 u4_ctx_inc = (u4_ctx_inc | (u1_ctx_inc << ((i1_bins_len - 1) << 2)));
229 }
230 else
231 {
232 pu1_mb_bin_ctxt += 3;
233 if (u4_slice_type == BSLICE)
234 pu1_mb_bin_ctxt += 2;
235
236 }
237
238 u4_code_int_range = ps_cab_enc_env->u4_code_int_range;
239 u4_code_int_low = ps_cab_enc_env->u4_code_int_low;
240
241 for (i = (i1_bins_len - 1); i >= 0; i--)
242 {
243 WORD32 shift;
244
245 u1_ctx_inc = ((u4_ctx_inc >> (i << 2)) & 0x0f);
246 u1_bin = ((u4_bins >> i) & 0x01);
247 /* Encode the bin */
248 pu1_bin_ctxt = pu1_mb_bin_ctxt + u1_ctx_inc;
249 if (i != (i1_bins_len - 2))
250 {
251 WORD8 i1_mps = !!((*pu1_bin_ctxt) & (0x40));
252 WORD8 i1_state = (*pu1_bin_ctxt) & 0x3F;
253
254 u2_quant_code_int_range = ((u4_code_int_range >> 6) & 0x03);
255 u4_table_val =
256 gau4_ih264_cabac_table[i1_state][u2_quant_code_int_range];
257 u4_code_int_range_lps = u4_table_val & 0xFF;
258
259 u4_code_int_range -= u4_code_int_range_lps;
260 if (u1_bin != i1_mps)
261 {
262 u4_code_int_low += u4_code_int_range;
263 u4_code_int_range = u4_code_int_range_lps;
264 if (i1_state == 0)
265 {
266 /* MPS(CtxIdx) = 1 - MPS(CtxIdx) */
267 i1_mps = 1 - i1_mps;
268 }
269
270 i1_state = (u4_table_val >> 15) & 0x3F;
271 }
272 else
273 {
274 i1_state = (u4_table_val >> 8) & 0x3F;
275
276 }
277
278 (*pu1_bin_ctxt) = (i1_mps << 6) | i1_state;
279 }
280 else
281 {
282 u4_code_int_range -= 2;
283 }
284
285 /* Renormalize */
286 /*****************************************************************/
287 /* Renormalization; calculate bits generated based on range(R) */
288 /* Note : 6 <= R < 512; R is 2 only for terminating encode */
289 /*****************************************************************/
290 GETRANGE(shift, u4_code_int_range);
291 shift = 9 - shift;
292 u4_code_int_low <<= shift;
293 u4_code_int_range <<= shift;
294
295 /* bits to be inserted in the bitstream */
296 ps_cab_enc_env->u4_bits_gen += shift;
297 ps_cab_enc_env->u4_code_int_range = u4_code_int_range;
298 ps_cab_enc_env->u4_code_int_low = u4_code_int_low;
299
300 /* generate stream when a byte is ready */
301 if (ps_cab_enc_env->u4_bits_gen > CABAC_BITS)
302 {
303 ih264e_cabac_put_byte(ps_cabac_ctxt);
304 u4_code_int_range = ps_cab_enc_env->u4_code_int_range;
305 u4_code_int_low = ps_cab_enc_env->u4_code_int_low;
306
307 }
308 }
309 }
310
311
312
313 /**
314 *******************************************************************************
315 *
316 * @brief
317 * Encodes prev_intra4x4_pred_mode_flag and
318 * rem_intra4x4_pred_mode using CABAC entropy coding mode
319 *
320 * @param[in] ps_cabac_ctxt
321 * Pointer to cabac context structure
322 *
323 * @param[in] pu1_intra_4x4_modes
324 * Pointer to array containing prev_intra4x4_pred_mode_flag and
325 * rem_intra4x4_pred_mode
326 *
327 * @returns
328 *
329 * @remarks
330 * None
331 *
332 *******************************************************************************
333 */
ih264e_cabac_enc_4x4mb_modes(cabac_ctxt_t * ps_cabac_ctxt,UWORD8 * pu1_intra_4x4_modes)334 static void ih264e_cabac_enc_4x4mb_modes(cabac_ctxt_t *ps_cabac_ctxt,
335 UWORD8 *pu1_intra_4x4_modes)
336 {
337 WORD32 i;
338 WORD8 byte;
339 for (i = 0; i < 16; i += 2)
340 {
341 /* sub blk idx 1 */
342 byte = *pu1_intra_4x4_modes++;
343 if (byte & 0x1)
344 {
345 ih264e_cabac_encode_bin(ps_cabac_ctxt,
346 1,
347 ps_cabac_ctxt->au1_cabac_ctxt_table
348 + PREV_INTRA4X4_PRED_MODE_FLAG);
349 }
350 else
351 {
352 /* Binarization is FL and Cmax=7 */
353 ih264e_encode_decision_bins(byte & 0xF,
354 4,
355 0x05554,
356 4,
357 ps_cabac_ctxt->au1_cabac_ctxt_table
358 + REM_INTRA4X4_PRED_MODE - 5,
359 ps_cabac_ctxt);
360 }
361 /* sub blk idx 2 */
362 byte >>= 4;
363 if (byte & 0x1)
364 {
365 ih264e_cabac_encode_bin(ps_cabac_ctxt,
366 1,
367 ps_cabac_ctxt->au1_cabac_ctxt_table
368 + PREV_INTRA4X4_PRED_MODE_FLAG);
369 }
370 else
371 {
372 ih264e_encode_decision_bins(byte & 0xF,
373 4,
374 0x05554,
375 4,
376 ps_cabac_ctxt->au1_cabac_ctxt_table
377 + REM_INTRA4X4_PRED_MODE - 5,
378 ps_cabac_ctxt);
379 }
380 }
381 }
382
383
384
385 /**
386 *******************************************************************************
387 *
388 * @brief
389 * Encodes chroma intrapred mode for the MB.
390 *
391 * @param[in] u1_chroma_pred_mode
392 * Chroma intr prediction mode
393 *
394 * @param[in] ps_cabac_ctxt
395 * Pointer to cabac context structure
396 *
397 * @returns
398 *
399 * @remarks
400 * None
401 *
402 *******************************************************************************
403 */
ih264e_cabac_enc_chroma_predmode(UWORD8 u1_chroma_pred_mode,cabac_ctxt_t * ps_cabac_ctxt)404 static void ih264e_cabac_enc_chroma_predmode(UWORD8 u1_chroma_pred_mode,
405 cabac_ctxt_t *ps_cabac_ctxt)
406 {
407
408 WORD8 i1_temp;
409 mb_info_ctxt_t *ps_curr_ctxt = ps_cabac_ctxt->ps_curr_ctxt_mb_info;
410 mb_info_ctxt_t *ps_left_ctxt = ps_cabac_ctxt->ps_left_ctxt_mb_info;
411 mb_info_ctxt_t *ps_top_ctxt = ps_cabac_ctxt->ps_top_ctxt_mb_info;
412 UWORD32 u4_bins = 0;
413 WORD8 i1_bins_len = 1;
414 UWORD32 u4_ctx_inc = 0;
415 UWORD8 a, b;
416 a = ((ps_left_ctxt->u1_intrapred_chroma_mode != 0) ? 1 : 0);
417 b = ((ps_top_ctxt->u1_intrapred_chroma_mode != 0) ? 1 : 0);
418
419 /* Binarization is TU and Cmax=3 */
420 ps_curr_ctxt->u1_intrapred_chroma_mode = u1_chroma_pred_mode;
421
422 u4_ctx_inc = a + b;
423 u4_ctx_inc = (u4_ctx_inc | 0x330);
424 if (u1_chroma_pred_mode)
425 {
426 u4_bins = 1;
427 i1_temp = u1_chroma_pred_mode;
428 i1_temp--;
429 /* Put a stream of 1's of length Chromaps_pred_mode_ctxt value */
430 while (i1_temp)
431 {
432 u4_bins = (u4_bins | (1 << i1_bins_len));
433 i1_bins_len++;
434 i1_temp--;
435 }
436 /* If Chromaps_pred_mode_ctxt < Cmax i.e 3. Terminate put a zero */
437 if (u1_chroma_pred_mode < 3)
438 {
439 i1_bins_len++;
440 }
441 }
442
443 ih264e_encode_decision_bins(u4_bins,
444 i1_bins_len,
445 u4_ctx_inc,
446 3,
447 ps_cabac_ctxt->au1_cabac_ctxt_table
448 + INTRA_CHROMA_PRED_MODE,
449 ps_cabac_ctxt);
450
451 }
452
453
454 /**
455 *******************************************************************************
456 *
457 * @brief
458 * Encodes CBP for the MB.
459 *
460 * @param[in] u1_cbp
461 * CBP for the MB
462 *
463 * @param[in] ps_cabac_ctxt
464 * Pointer to cabac context structure
465 *
466 * @returns
467 *
468 * @remarks
469 * None
470 *
471 *******************************************************************************
472 */
ih264e_cabac_enc_cbp(UWORD32 u4_cbp,cabac_ctxt_t * ps_cabac_ctxt)473 static void ih264e_cabac_enc_cbp(UWORD32 u4_cbp, cabac_ctxt_t *ps_cabac_ctxt)
474 {
475 mb_info_ctxt_t *ps_left_ctxt = ps_cabac_ctxt->ps_left_ctxt_mb_info;
476 mb_info_ctxt_t *ps_top_ctxt = ps_cabac_ctxt->ps_top_ctxt_mb_info;
477 WORD8 i2_cbp_chroma, i, j;
478 UWORD8 u1_ctxt_inc, u1_bin;
479 UWORD8 a, b;
480 UWORD32 u4_ctx_inc;
481 UWORD32 u4_bins;
482 WORD8 i1_bins_len;
483
484 /* CBP Luma, FL, Cmax = 15, L = 4 */
485 u4_ctx_inc = 0;
486 u4_bins = 0;
487 i1_bins_len = 5;
488 for (i = 0; i < 4; i++)
489 {
490 /* calulate ctxtInc, depending on neighbour availability */
491 /* u1_ctxt_inc = CondTerm(A) + 2 * CondTerm(B);
492 A: Left block and B: Top block */
493
494 /* Check for Top availability */
495 if (i >> 1)
496 {
497 j = i - 2;
498 /* Top is available always and it's current MB */
499 b = (((u4_cbp >> j) & 0x01) != 0 ? 0 : 1);
500 }
501 else
502 {
503 /* for blocks whose top reference is in another MB */
504 {
505 j = i + 2;
506 b = ((ps_top_ctxt->u1_cbp >> j) & 0x01) ? 0 : 1;
507 }
508 }
509
510 /* Check for Left availability */
511 if (i & 0x01)
512 {
513 /* Left is available always and it's current MB */
514 j = i - 1;
515 a = (((u4_cbp >> j) & 0x01) != 0 ? 0 : 1);
516 }
517 else
518 {
519 {
520 j = i + 1;
521 a = ((ps_left_ctxt->u1_cbp >> j) & 0x01) ? 0 : 1;
522 }
523 }
524 u1_ctxt_inc = a + 2 * b;
525 u1_bin = ((u4_cbp >> i) & 0x01);
526 u4_ctx_inc = (u4_ctx_inc | (u1_ctxt_inc << (i << 2)));
527 u4_bins = (u4_bins | (u1_bin << i));
528 }
529
530 /* CBP Chroma, TU, Cmax = 2 */
531 i2_cbp_chroma = u4_cbp >> 4;
532 /* calulate ctxtInc, depending on neighbour availability */
533 a = (ps_left_ctxt->u1_cbp > 15) ? 1 : 0;
534 b = (ps_top_ctxt->u1_cbp > 15) ? 1 : 0;
535
536 u1_ctxt_inc = a + 2 * b;
537 if (i2_cbp_chroma)
538 {
539 u4_ctx_inc = u4_ctx_inc | ((4 + u1_ctxt_inc) << 16);
540 u4_bins = (u4_bins | 0x10);
541 /* calulate ctxtInc, depending on neighbour availability */
542 a = (ps_left_ctxt->u1_cbp > 31) ? 1 : 0;
543 b = (ps_top_ctxt->u1_cbp > 31) ? 1 : 0;
544 u1_ctxt_inc = a + 2 * b;
545 u4_ctx_inc = u4_ctx_inc | ((8 + u1_ctxt_inc) << 20);
546 u4_bins = (u4_bins | (((i2_cbp_chroma >> 1) & 0x01) << i1_bins_len));
547 i1_bins_len++;
548 }
549 else
550 {
551 u4_ctx_inc = (u4_ctx_inc | ((4 + u1_ctxt_inc) << 16));
552 }
553 ih264e_encode_decision_bins(u4_bins, i1_bins_len, u4_ctx_inc, 8,
554 ps_cabac_ctxt->au1_cabac_ctxt_table + CBP_LUMA,
555 ps_cabac_ctxt);
556 }
557
558
559 /**
560 *******************************************************************************
561 *
562 * @brief
563 * Encodes mb_qp_delta for the MB.
564 *
565 * @param[in] i1_mb_qp_delta
566 * mb_qp_delta
567 *
568 * @param[in] ps_cabac_ctxt
569 * Pointer to cabac context structure
570 *
571 * @returns
572 *
573 * @remarks
574 * None
575 *
576 *******************************************************************************
577 */
ih264e_cabac_enc_mb_qp_delta(WORD8 i1_mb_qp_delta,cabac_ctxt_t * ps_cabac_ctxt)578 static void ih264e_cabac_enc_mb_qp_delta(WORD8 i1_mb_qp_delta,
579 cabac_ctxt_t *ps_cabac_ctxt)
580 {
581 UWORD8 u1_code_num;
582 UWORD8 u1_ctxt_inc;
583
584 UWORD32 u4_ctx_inc;
585 UWORD32 u4_bins;
586 WORD8 i1_bins_len;
587 UWORD8 u1_ctx_inc, u1_bin;
588 /* Range of ps_mb_qp_delta_ctxt= -26 to +25 inclusive */
589 ASSERT((i1_mb_qp_delta < 26) && (i1_mb_qp_delta > -27));
590 /* if ps_mb_qp_delta_ctxt=0, then codeNum=0 */
591 u1_code_num = 0;
592 if (i1_mb_qp_delta > 0)
593 u1_code_num = (i1_mb_qp_delta << 1) - 1;
594 else if (i1_mb_qp_delta < 0)
595 u1_code_num = (ABS(i1_mb_qp_delta)) << 1;
596
597 u4_ctx_inc = 0;
598 u4_bins = 0;
599 i1_bins_len = 1;
600 /* calculate ctxtInc, depending on neighbour availability */
601 u1_ctxt_inc = (!(!(ps_cabac_ctxt->i1_prevps_mb_qp_delta_ctxt)));
602 ps_cabac_ctxt->i1_prevps_mb_qp_delta_ctxt = i1_mb_qp_delta;
603
604 if (u1_code_num == 0)
605 {
606 /* b0 */
607 u1_bin = (UWORD8) (u4_bins);
608 u1_ctx_inc = u1_ctxt_inc & 0x0f;
609 /* Encode the bin */
610 ih264e_cabac_encode_bin(ps_cabac_ctxt,
611 u1_bin,
612 ps_cabac_ctxt->au1_cabac_ctxt_table + MB_QP_DELTA
613 + u1_ctx_inc);
614
615 }
616 else
617 {
618 /* b0 */
619 u4_ctx_inc = u1_ctxt_inc;
620 u4_bins = 1;
621 u1_code_num--;
622 if (u1_code_num == 0)
623 {
624 /* b1 */
625 u4_ctx_inc = (u4_ctx_inc | 0x20);
626 i1_bins_len++;
627 ih264e_encode_decision_bins(u4_bins, i1_bins_len, u4_ctx_inc, 3,
628 ps_cabac_ctxt->au1_cabac_ctxt_table + MB_QP_DELTA,
629 ps_cabac_ctxt);
630 }
631 else
632 {
633 /* b1 */
634 u4_ctx_inc = (u4_ctx_inc | 0x20);
635 u4_bins = (u4_bins | (1 << i1_bins_len));
636 i1_bins_len++;
637 u1_code_num--;
638 /* BinIdx from b2 onwards */
639 if (u1_code_num < 30)
640 { /* maximum i1_bins_len = 31 */
641 while (u1_code_num)
642 {
643 u4_bins = (u4_bins | (1 << i1_bins_len));
644 i1_bins_len++;
645 u1_code_num--;
646 };
647 u4_ctx_inc = (u4_ctx_inc | 0x300);
648 i1_bins_len++;
649 ih264e_encode_decision_bins(u4_bins,
650 i1_bins_len,
651 u4_ctx_inc,
652 2,
653 ps_cabac_ctxt->au1_cabac_ctxt_table
654 + MB_QP_DELTA,
655 ps_cabac_ctxt);
656 }
657 else
658 {
659 /* maximum i1_bins_len = 53 */
660 u4_bins = 0xffffffff;
661 i1_bins_len = 32;
662 u4_ctx_inc = (u4_ctx_inc | 0x300);
663 u1_code_num -= 30;
664 ih264e_encode_decision_bins(u4_bins,
665 i1_bins_len,
666 u4_ctx_inc,
667 2,
668 ps_cabac_ctxt->au1_cabac_ctxt_table
669 + MB_QP_DELTA,
670 ps_cabac_ctxt);
671 u4_bins = 0;
672 i1_bins_len = 0;
673 u4_ctx_inc = 0x033;
674 while (u1_code_num)
675 {
676 u4_bins = (u4_bins | (1 << i1_bins_len));
677 i1_bins_len++;
678 u1_code_num--;
679 };
680
681 u4_ctx_inc = (u4_ctx_inc | 0x300);
682 i1_bins_len++;
683 ih264e_encode_decision_bins(u4_bins,
684 i1_bins_len,
685 u4_ctx_inc,
686 1,
687 ps_cabac_ctxt->au1_cabac_ctxt_table
688 + MB_QP_DELTA,
689 ps_cabac_ctxt);
690 }
691 }
692 }
693 }
694
695
696
697
698 /**
699 *******************************************************************************
700 * @brief
701 * Encodes 4residual_block_cabac as defined in 7.3.5.3.3.
702 *
703 * @param[in] pi2_res_block
704 * pointer to the array of residues
705 *
706 * @param[in] u1_nnz
707 * Number of non zero coeffs in the block
708 *
709 * @param[in] u1_max_num_coeffs
710 * Max number of coeffs that can be there in the block
711 *
712 * @param[in] u2_sig_coeff_map
713 * Significant coeff map
714 *
715 * @param[in] u4_ctx_cat_offset
716 * ctxIdxOffset for absolute value contexts
717 *
718 * @param[in] pu1_ctxt_sig_coeff
719 * Pointer to residual state variables
720 *
721 * @param[in] ps_cabac_ctxt
722 * Pointer to cabac context structure
723 *
724 * @returns
725 *
726 * @remarks
727 * None
728 *
729 *******************************************************************************
730 */
ih264e_cabac_write_coeff4x4(WORD16 * pi2_res_block,UWORD8 u1_nnz,UWORD8 u1_max_num_coeffs,UWORD16 u2_sig_coeff_map,UWORD32 u4_ctx_cat_offset,bin_ctxt_model * pu1_ctxt_sig_coeff,cabac_ctxt_t * ps_cabac_ctxt)731 static void ih264e_cabac_write_coeff4x4(WORD16 *pi2_res_block, UWORD8 u1_nnz,
732 UWORD8 u1_max_num_coeffs,
733 UWORD16 u2_sig_coeff_map,
734 UWORD32 u4_ctx_cat_offset,
735 bin_ctxt_model *pu1_ctxt_sig_coeff,
736 cabac_ctxt_t *ps_cabac_ctxt)
737 {
738
739 WORD8 i;
740 WORD16 *pi16_coeffs;
741 UWORD32 u4_sig_coeff, u4_bins;
742 UWORD32 u4_ctx_inc;
743 UWORD8 u1_last_sig_coef_index = (31 - CLZ(u2_sig_coeff_map));
744
745 /* Always put Coded Block Flag as 1 */
746
747 pi16_coeffs = pi2_res_block;
748 {
749 bin_ctxt_model *pu1_bin_ctxt;
750 UWORD8 u1_bin, uc_last;
751
752 i = 0;
753 pu1_bin_ctxt = pu1_ctxt_sig_coeff;
754 u4_sig_coeff = 0;
755 u1_bin = 1;
756 if ((u1_last_sig_coef_index))
757 {
758 u1_bin = !!(u2_sig_coeff_map & 01);
759 }
760 uc_last = 1;
761
762 do
763 {
764 /* Encode Decision */
765 ih264e_cabac_encode_bin(ps_cabac_ctxt, u1_bin, pu1_bin_ctxt);
766
767 if (u1_bin & uc_last)
768 {
769 u4_sig_coeff = (u4_sig_coeff | (1 << i));
770 pu1_bin_ctxt = pu1_ctxt_sig_coeff + i
771 + LAST_SIGNIFICANT_COEFF_FLAG_FRAME
772 - SIGNIFICANT_COEFF_FLAG_FRAME;
773 u1_bin = (i == u1_last_sig_coef_index);
774 uc_last = 0;
775 }
776 else
777 {
778 i = i + 1;
779 pu1_bin_ctxt = pu1_ctxt_sig_coeff + i;
780 u1_bin = (i == u1_last_sig_coef_index);
781 uc_last = 1;
782 if ((i != u1_last_sig_coef_index))
783 {
784 u1_bin = !!((u2_sig_coeff_map >> i) & 01);
785 }
786 }
787 }while (!((i > u1_last_sig_coef_index)
788 || (i > (u1_max_num_coeffs - 1))));
789 }
790
791 /* Encode coeff_abs_level_minus1 and coeff_sign_flag */
792 {
793 UWORD8 u1_sign;
794 UWORD16 u2_abs_level;
795 UWORD8 u1_abs_level_equal1 = 1, u1_abs_level_gt1 = 0;
796 UWORD8 u1_ctx_inc;
797 UWORD8 u1_coff;
798 WORD16 i2_sufs;
799 WORD8 i1_bins_len;
800 i = u1_last_sig_coef_index;
801 pi16_coeffs = pi2_res_block + u1_nnz - 1;
802 do
803 {
804 {
805 u4_sig_coeff = u4_sig_coeff & ((1 << i) - 1);
806 u4_bins = 0;
807 u4_ctx_inc = 0;
808 i1_bins_len = 1;
809 /* Encode the AbsLevelMinus1 */
810 u2_abs_level = ABS(*(pi16_coeffs)) - 1;
811 /* CtxInc for bin0 */
812 u4_ctx_inc = MIN(u1_abs_level_equal1, 4);
813 /* CtxInc for remaining */
814 u1_ctx_inc = 5 + MIN(u1_abs_level_gt1, 4);
815 u4_ctx_inc = u4_ctx_inc + (u1_ctx_inc << 4);
816 if (u2_abs_level)
817 {
818 u1_abs_level_gt1++;
819 u1_abs_level_equal1 = 0;
820 }
821 if (!u1_abs_level_gt1)
822 u1_abs_level_equal1++;
823
824 u1_coff = 14;
825 if (u2_abs_level >= u1_coff)
826 {
827 /* Prefix TU i.e string of 14 1's */
828 u4_bins = 0x3fff;
829 i1_bins_len = 14;
830 ih264e_encode_decision_bins(u4_bins, i1_bins_len,
831 u4_ctx_inc, 1, ps_cabac_ctxt->au1_cabac_ctxt_table
832 + u4_ctx_cat_offset,
833 ps_cabac_ctxt);
834
835 /* Suffix, uses EncodeBypass */
836 i2_sufs = u2_abs_level - u1_coff;
837
838 u4_bins = ih264e_cabac_UEGk0_binarization(i2_sufs,
839 &i1_bins_len);
840
841 ih264e_cabac_encode_bypass_bins(ps_cabac_ctxt, u4_bins,
842 i1_bins_len);
843
844 }
845 else
846 {
847 /* Prefix only */
848 u4_bins = (1 << u2_abs_level) - 1;
849 i1_bins_len = u2_abs_level + 1;
850 /* Encode Terminating bit */
851 ih264e_encode_decision_bins(u4_bins, i1_bins_len,
852 u4_ctx_inc, 1, ps_cabac_ctxt->au1_cabac_ctxt_table
853 + u4_ctx_cat_offset,
854 ps_cabac_ctxt);
855 }
856 }
857 /* encode coeff_sign_flag[i] */
858 u1_sign = ((*pi16_coeffs) < 0) ? 1 : 0;
859 ih264e_cabac_encode_bypass_bin(ps_cabac_ctxt, u1_sign);
860 i = CLZ(u4_sig_coeff);
861 i = 31 - i;
862 pi16_coeffs--;
863 }while (u4_sig_coeff);
864 }
865
866 }
867
868
869 /**
870 *******************************************************************************
871 * @brief
872 * Write DC coeffs for intra predicted luma block
873 *
874 * @param[in] ps_ent_ctxt
875 * Pointer to entropy context structure
876 *
877 * @returns
878 *
879 * @remarks
880 * None
881 *
882 *******************************************************************************
883 */
ih264e_cabac_encode_residue_luma_dc(entropy_ctxt_t * ps_ent_ctxt)884 static void ih264e_cabac_encode_residue_luma_dc(entropy_ctxt_t *ps_ent_ctxt)
885 {
886
887 /* CABAC context */
888 cabac_ctxt_t *ps_cabac_ctxt = ps_ent_ctxt->ps_cabac;
889 tu_sblk_coeff_data_t *ps_mb_coeff_data;
890
891 /* packed residue */
892 void *pv_mb_coeff_data = ps_ent_ctxt->pv_mb_coeff_data;
893 UWORD16 u2_sig_coeff_map;
894 WORD16 *pi2_res_block;
895 UWORD8 u1_nnz;
896 UWORD8 u1_cbf;
897 mb_info_ctxt_t *ps_top_ctxt = ps_cabac_ctxt->ps_top_ctxt_mb_info;
898 mb_info_ctxt_t *p_CurCtxt = ps_cabac_ctxt->ps_curr_ctxt_mb_info;
899
900 PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data, u1_nnz,
901 u2_sig_coeff_map, pi2_res_block);
902
903 u1_cbf = !!(u1_nnz);
904
905 {
906 UWORD32 u4_ctx_inc;
907 UWORD8 u1_a, u1_b;
908
909 u1_a = ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0] & 0x1;
910 u1_b = ps_top_ctxt->u1_yuv_dc_csbp & 0x1;
911 u4_ctx_inc = u1_a + (u1_b << 1);
912
913 ih264e_cabac_encode_bin(ps_cabac_ctxt,
914 u1_cbf,
915 ps_cabac_ctxt->au1_cabac_ctxt_table + CBF
916 + (LUMA_DC_CTXCAT << 2) + u4_ctx_inc);
917 }
918
919 /* Write coded_block_flag */
920 if (u1_cbf)
921 {
922 ih264e_cabac_write_coeff4x4(pi2_res_block,
923 u1_nnz,
924 15,
925 u2_sig_coeff_map,
926 COEFF_ABS_LEVEL_MINUS1 + COEFF_ABS_LEVEL_CAT_0_OFFSET,
927 ps_cabac_ctxt->au1_cabac_ctxt_table
928 + SIGNIFICANT_COEFF_FLAG_FRAME
929 + SIG_COEFF_CTXT_CAT_0_OFFSET,
930 ps_cabac_ctxt);
931
932 ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0] |= 0x1;
933 p_CurCtxt->u1_yuv_dc_csbp |= 0x1;
934 }
935 else
936 {
937 ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0] &= 0x6;
938 p_CurCtxt->u1_yuv_dc_csbp &= 0x6;
939 }
940
941 ps_ent_ctxt->pv_mb_coeff_data = pv_mb_coeff_data;
942 }
943
944
945
946
947 /**
948 *******************************************************************************
949 * @brief
950 * Write chroma residues to the bitstream
951 *
952 * @param[in] ps_ent_ctxt
953 * Pointer to entropy context structure
954 *
955 * @param[in] u1_chroma_cbp
956 * coded block pattern, chroma
957 *
958 * @returns
959 *
960 * @remarks
961 * None
962 *
963 *******************************************************************************
964 */
ih264e_cabac_write_chroma_residue(entropy_ctxt_t * ps_ent_ctxt,UWORD8 u1_chroma_cbp)965 static void ih264e_cabac_write_chroma_residue(entropy_ctxt_t *ps_ent_ctxt,
966 UWORD8 u1_chroma_cbp)
967 {
968 /* CABAC context */
969 cabac_ctxt_t *ps_cabac_ctxt = ps_ent_ctxt->ps_cabac;
970 tu_sblk_coeff_data_t *ps_mb_coeff_data;
971 /* packed residue */
972 void *pv_mb_coeff_data = ps_ent_ctxt->pv_mb_coeff_data;
973 UWORD16 u2_sig_coeff_map;
974 UWORD8 u1_nnz;
975 mb_info_ctxt_t *ps_top_ctxt_mb_info, *ps_curr_ctxt;
976
977 ps_top_ctxt_mb_info = ps_cabac_ctxt->ps_top_ctxt_mb_info;
978 ps_curr_ctxt = ps_cabac_ctxt->ps_curr_ctxt_mb_info;
979
980 /********************/
981 /* Write Chroma DC */
982 /********************/
983 {
984 WORD16 *pi2_res_block;
985 UWORD8 u1_left_dc_csbp, u1_top_dc_csbp, u1_uv, u1_cbf;
986
987 u1_left_dc_csbp = (ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0]) >> 1;
988 u1_top_dc_csbp = (ps_top_ctxt_mb_info->u1_yuv_dc_csbp) >> 1;
989
990 for (u1_uv = 0; u1_uv < 2; u1_uv++)
991 {
992 PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data,
993 u1_nnz, u2_sig_coeff_map, pi2_res_block);
994 u1_cbf = !!(u1_nnz);
995 {
996 UWORD8 u1_a, u1_b;
997 UWORD32 u4_ctx_inc;
998 u1_a = (u1_left_dc_csbp >> u1_uv) & 0x01;
999 u1_b = (u1_top_dc_csbp >> u1_uv) & 0x01;
1000 u4_ctx_inc = (u1_a + (u1_b << 1));
1001
1002 ih264e_cabac_encode_bin(ps_cabac_ctxt,
1003 u1_cbf,
1004 ps_cabac_ctxt->au1_cabac_ctxt_table + CBF
1005 + (CHROMA_DC_CTXCAT << 2)
1006 + u4_ctx_inc);
1007 }
1008
1009 if (u1_cbf)
1010 {
1011 ih264e_cabac_write_coeff4x4(pi2_res_block,
1012 u1_nnz,
1013 3,
1014 u2_sig_coeff_map,
1015 COEFF_ABS_LEVEL_MINUS1
1016 + COEFF_ABS_LEVEL_CAT_3_OFFSET,
1017 ps_cabac_ctxt->au1_cabac_ctxt_table
1018 + SIGNIFICANT_COEFF_FLAG_FRAME
1019 + SIG_COEFF_CTXT_CAT_3_OFFSET,
1020 ps_cabac_ctxt);
1021
1022 SETBIT(u1_top_dc_csbp, u1_uv);
1023 SETBIT(u1_left_dc_csbp, u1_uv);
1024 }
1025 else
1026 {
1027 CLEARBIT(u1_top_dc_csbp, u1_uv);
1028 CLEARBIT(u1_left_dc_csbp, u1_uv);
1029 }
1030 }
1031 /*************************************************************/
1032 /* Update the DC csbp */
1033 /*************************************************************/
1034 ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0] &= 0x1;
1035 ps_curr_ctxt->u1_yuv_dc_csbp &= 0x1;
1036 ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0] |= (u1_left_dc_csbp << 1);
1037 ps_curr_ctxt->u1_yuv_dc_csbp |= (u1_top_dc_csbp << 1);
1038 }
1039 /*******************/
1040 /* Write Chroma AC */
1041 /*******************/
1042 {
1043 if (u1_chroma_cbp == 2)
1044 {
1045 UWORD8 u1_uv_blkno, u1_left_ac_csbp, u1_top_ac_csbp;
1046 WORD16 *pi2_res_block;
1047 u1_left_ac_csbp = ps_cabac_ctxt->pu1_left_uv_ac_csbp[0];
1048 u1_top_ac_csbp = ps_top_ctxt_mb_info->u1_yuv_ac_csbp >> 4;
1049
1050 for (u1_uv_blkno = 0; u1_uv_blkno < 8; u1_uv_blkno++)
1051 {
1052 UWORD8 u1_cbf;
1053 UWORD8 u1_b2b0, u1_b2b1;
1054 PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data,
1055 u1_nnz, u2_sig_coeff_map,
1056 pi2_res_block);
1057
1058 u1_cbf = !!(u1_nnz);
1059 u1_b2b0 = ((u1_uv_blkno & 0x4) >> 1) | (u1_uv_blkno & 0x1);
1060 u1_b2b1 = ((u1_uv_blkno & 0x4) >> 1)
1061 | ((u1_uv_blkno & 0x2) >> 1);
1062
1063 {
1064 UWORD8 u1_a, u1_b;
1065 UWORD32 u4_ctx_inc;
1066 /* write coded_block_flag */
1067 u1_a = (u1_left_ac_csbp >> u1_b2b1) & 0x1;
1068 u1_b = (u1_top_ac_csbp >> u1_b2b0) & 0x1;
1069 u4_ctx_inc = u1_a + (u1_b << 1);
1070
1071 ih264e_cabac_encode_bin(ps_cabac_ctxt,
1072 u1_cbf,
1073 ps_cabac_ctxt->au1_cabac_ctxt_table + CBF
1074 + (CHROMA_AC_CTXCAT << 2)
1075 + u4_ctx_inc);
1076
1077 }
1078 if (u1_cbf)
1079 {
1080 ih264e_cabac_write_coeff4x4(pi2_res_block,
1081 u1_nnz,
1082 14,
1083 u2_sig_coeff_map,
1084 COEFF_ABS_LEVEL_MINUS1
1085 + COEFF_ABS_LEVEL_CAT_4_OFFSET,
1086 ps_cabac_ctxt->au1_cabac_ctxt_table
1087 + +SIGNIFICANT_COEFF_FLAG_FRAME
1088 + SIG_COEFF_CTXT_CAT_4_OFFSET,
1089 ps_cabac_ctxt);
1090
1091 SETBIT(u1_left_ac_csbp, u1_b2b1);
1092 SETBIT(u1_top_ac_csbp, u1_b2b0);
1093 }
1094 else
1095 {
1096 CLEARBIT(u1_left_ac_csbp, u1_b2b1);
1097 CLEARBIT(u1_top_ac_csbp, u1_b2b0);
1098
1099 }
1100 }
1101 /*************************************************************/
1102 /* Update the AC csbp */
1103 /*************************************************************/
1104 ps_cabac_ctxt->pu1_left_uv_ac_csbp[0] = u1_left_ac_csbp;
1105 ps_curr_ctxt->u1_yuv_ac_csbp &= 0x0f;
1106 ps_curr_ctxt->u1_yuv_ac_csbp |= (u1_top_ac_csbp << 4);
1107 }
1108 else
1109 {
1110 ps_cabac_ctxt->pu1_left_uv_ac_csbp[0] = 0;
1111 ps_curr_ctxt->u1_yuv_ac_csbp &= 0xf;
1112 }
1113 }
1114 ps_ent_ctxt->pv_mb_coeff_data = pv_mb_coeff_data;
1115 }
1116
1117
1118
1119
1120 /**
1121 *******************************************************************************
1122 * @brief
1123 * Encodes Residues for the MB as defined in 7.3.5.3
1124 *
1125 * @param[in] ps_ent_ctxt
1126 * Pointer to entropy context structure
1127 *
1128 * @param[in] u1_cbp
1129 * coded block pattern
1130 *
1131 * @param[in] u1_ctx_cat
1132 * Context category, LUMA_AC_CTXCAT or LUMA_4x4_CTXCAT
1133 *
1134 * @returns
1135 *
1136 * @remarks
1137 * None
1138 *
1139 *******************************************************************************
1140 */
ih264e_cabac_encode_residue(entropy_ctxt_t * ps_ent_ctxt,UWORD32 u4_cbp,UWORD8 u1_ctx_cat)1141 static void ih264e_cabac_encode_residue(entropy_ctxt_t *ps_ent_ctxt,
1142 UWORD32 u4_cbp, UWORD8 u1_ctx_cat)
1143 {
1144 /* CABAC context */
1145 cabac_ctxt_t *ps_cabac_ctxt = ps_ent_ctxt->ps_cabac;
1146
1147 tu_sblk_coeff_data_t *ps_mb_coeff_data;
1148 /* packed residue */
1149 void *pv_mb_coeff_data = ps_ent_ctxt->pv_mb_coeff_data;
1150 UWORD16 u2_sig_coeff_map;
1151 UWORD8 u1_nnz;
1152 mb_info_ctxt_t *ps_curr_ctxt;
1153 mb_info_ctxt_t *ps_top_ctxt;
1154 UWORD8 u1_left_ac_csbp;
1155 UWORD8 u1_top_ac_csbp;
1156 UWORD32 u4_ctx_idx_offset_sig_coef, u4_ctx_idx_offset_abs_lvl;
1157 ps_curr_ctxt = ps_cabac_ctxt->ps_curr_ctxt_mb_info;
1158 ps_top_ctxt = ps_cabac_ctxt->ps_top_ctxt_mb_info;
1159 u1_left_ac_csbp = ps_cabac_ctxt->pu1_left_y_ac_csbp[0];
1160 u1_top_ac_csbp = ps_top_ctxt->u1_yuv_ac_csbp;
1161
1162 if (u4_cbp & 0xf)
1163 {
1164 /* Write luma residue */
1165 UWORD8 u1_offset;
1166 WORD16 *pi2_res_block;
1167 UWORD8 u1_subblk_num;
1168 if (u1_ctx_cat == LUMA_AC_CTXCAT)
1169 {
1170 u1_offset = 1;
1171 u4_ctx_idx_offset_sig_coef = SIG_COEFF_CTXT_CAT_1_OFFSET;
1172 u4_ctx_idx_offset_abs_lvl = COEFF_ABS_LEVEL_MINUS1
1173 + COEFF_ABS_LEVEL_CAT_1_OFFSET;
1174 }
1175 else
1176 {
1177 u1_offset = 0;
1178 u4_ctx_idx_offset_sig_coef = SIG_COEFF_CTXT_CAT_2_OFFSET;
1179 u4_ctx_idx_offset_abs_lvl = COEFF_ABS_LEVEL_MINUS1
1180 + COEFF_ABS_LEVEL_CAT_2_OFFSET;
1181 }
1182
1183 for (u1_subblk_num = 0; u1_subblk_num < 16; u1_subblk_num++)
1184 {
1185 UWORD8 u1_b0, u1_b1, u1_b2, u1_b3, u1_b2b0, u1_b3b1, u1_b3b2;
1186 u1_b0 = (u1_subblk_num & 0x1);
1187 u1_b1 = (u1_subblk_num & 0x2) >> 1;
1188 u1_b2 = (u1_subblk_num & 0x4) >> 2;
1189 u1_b3 = (u1_subblk_num & 0x8) >> 3;
1190 u1_b2b0 = (u1_b2 << 1) | (u1_b0);
1191 u1_b3b1 = (u1_b3 << 1) | (u1_b1);
1192 u1_b3b2 = (u1_b3 << 1) | (u1_b2);
1193
1194 if (!((u4_cbp >> u1_b3b2) & 0x1))
1195 {
1196 /* ---------------------------------------------------------- */
1197 /* The current block is not coded so skip all the sub block */
1198 /* and set the pointer of scan level, csbp accrodingly */
1199 /* ---------------------------------------------------------- */
1200 CLEARBIT(u1_top_ac_csbp, u1_b2b0);
1201 CLEARBIT(u1_top_ac_csbp, (u1_b2b0 + 1));
1202 CLEARBIT(u1_left_ac_csbp, u1_b3b1);
1203 CLEARBIT(u1_left_ac_csbp, (u1_b3b1 + 1));
1204
1205 u1_subblk_num += 3;
1206 }
1207 else
1208 {
1209 UWORD8 u1_csbf;
1210
1211 PARSE_COEFF_DATA_BLOCK_4x4(pv_mb_coeff_data, ps_mb_coeff_data,
1212 u1_nnz, u2_sig_coeff_map,
1213 pi2_res_block);
1214
1215 u1_csbf = !!(u1_nnz);
1216 {
1217 UWORD8 u1_a, u1_b;
1218 UWORD32 u4_ctx_inc;
1219 u1_b = (u1_top_ac_csbp >> u1_b2b0) & 0x01;
1220 u1_a = (u1_left_ac_csbp >> u1_b3b1) & 0x01;
1221 u4_ctx_inc = u1_a + (u1_b << 1);
1222
1223 /* Encode the bin */
1224 ih264e_cabac_encode_bin(ps_cabac_ctxt,
1225 u1_csbf,
1226 ps_cabac_ctxt->au1_cabac_ctxt_table + CBF
1227 + (u1_ctx_cat << 2) + u4_ctx_inc);
1228
1229 }
1230 /**************************/
1231 /* Write coded_block_flag */
1232 /**************************/
1233 if (u1_csbf)
1234 {
1235 ih264e_cabac_write_coeff4x4(pi2_res_block,
1236 u1_nnz,
1237 (UWORD8) (15 - u1_offset),
1238 u2_sig_coeff_map,
1239 u4_ctx_idx_offset_abs_lvl,
1240 ps_cabac_ctxt->au1_cabac_ctxt_table
1241 + SIGNIFICANT_COEFF_FLAG_FRAME
1242 + u4_ctx_idx_offset_sig_coef,
1243 ps_cabac_ctxt);
1244
1245 SETBIT(u1_top_ac_csbp, u1_b2b0);
1246 SETBIT(u1_left_ac_csbp, u1_b3b1);
1247 }
1248 else
1249 {
1250 CLEARBIT(u1_top_ac_csbp, u1_b2b0);
1251 CLEARBIT(u1_left_ac_csbp, u1_b3b1);
1252 }
1253 }
1254 }
1255 /**************************************************************************/
1256 /* Update the AC csbp */
1257 /**************************************************************************/
1258 ps_cabac_ctxt->pu1_left_y_ac_csbp[0] = u1_left_ac_csbp & 0xf;
1259 u1_top_ac_csbp &= 0x0f;
1260 ps_curr_ctxt->u1_yuv_ac_csbp &= 0xf0;
1261 ps_curr_ctxt->u1_yuv_ac_csbp |= u1_top_ac_csbp;
1262 }
1263 else
1264 {
1265 ps_cabac_ctxt->pu1_left_y_ac_csbp[0] = 0;
1266 ps_curr_ctxt->u1_yuv_ac_csbp &= 0xf0;
1267 }
1268
1269 /* Write chroma residue */
1270
1271 ps_ent_ctxt->pv_mb_coeff_data = pv_mb_coeff_data;
1272 {
1273 UWORD8 u1_cbp_chroma;
1274 u1_cbp_chroma = u4_cbp >> 4;
1275 if (u1_cbp_chroma)
1276 {
1277 ih264e_cabac_write_chroma_residue(ps_ent_ctxt, u1_cbp_chroma);
1278 }
1279 else
1280 {
1281 ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0] &= 0x1;
1282 ps_curr_ctxt->u1_yuv_dc_csbp &= 0x1;
1283 ps_cabac_ctxt->pu1_left_uv_ac_csbp[0] = 0;
1284 ps_curr_ctxt->u1_yuv_ac_csbp &= 0xf;
1285 }
1286 }
1287 }
1288
1289 /**
1290 *******************************************************************************
1291 * @brief
1292 * Encodes a Motion vector (9.3.3.1.1.7 )
1293 *
1294 * @param[in] u1_mvd
1295 * Motion vector to be encoded
1296 *
1297 * @param[in] u4_ctx_idx_offset
1298 * * ctxIdxOffset for MV_X or MV_Ycontext
1299 *
1300 * @param[in] ui2_abs_mvd
1301 * sum of absolute value of corresponding neighboring motion vectors
1302 *
1303 * @param[in] ps_cabac_ctxt
1304 * Pointer to cabac context structure
1305 *
1306 * @returns
1307 *
1308 * @remarks
1309 * None
1310 *
1311 *******************************************************************************
1312 */
ih264e_cabac_enc_ctx_mvd(WORD16 u1_mvd,UWORD32 u4_ctx_idx_offset,UWORD16 ui2_abs_mvd,cabac_ctxt_t * ps_cabac_ctxt)1313 static void ih264e_cabac_enc_ctx_mvd(WORD16 u1_mvd, UWORD32 u4_ctx_idx_offset,
1314 UWORD16 ui2_abs_mvd,
1315 cabac_ctxt_t *ps_cabac_ctxt)
1316 {
1317
1318 UWORD8 u1_bin, u1_ctxt_inc;
1319 WORD8 k = 3, u1_coff = 9;
1320 WORD16 i2_abs_mvd, i2_sufs;
1321 UWORD32 u4_ctx_inc;
1322 UWORD32 u4_bins;
1323 WORD8 i1_bins_len;
1324
1325 /* if mvd < u1_coff
1326 only Prefix
1327 else
1328 Prefix + Suffix
1329
1330 encode sign bit
1331
1332 Prefix TU encoding Cmax =u1_coff and Suffix 3rd order Exp-Golomb
1333 */
1334
1335 if (ui2_abs_mvd < 3)
1336 u4_ctx_inc = 0;
1337 else if (ui2_abs_mvd > 32)
1338 u4_ctx_inc = 2;
1339 else
1340 u4_ctx_inc = 1;
1341
1342 u4_bins = 0;
1343 i1_bins_len = 1;
1344
1345 if (u1_mvd == 0)
1346 {
1347 ih264e_cabac_encode_bin(ps_cabac_ctxt,
1348 0,
1349 ps_cabac_ctxt->au1_cabac_ctxt_table + u4_ctx_idx_offset
1350 + u4_ctx_inc);
1351 }
1352 else
1353 {
1354 i2_abs_mvd = ABS(u1_mvd);
1355 if (i2_abs_mvd >= u1_coff)
1356 {
1357 /* Prefix TU i.e string of 9 1's */
1358 u4_bins = 0x1ff;
1359 i1_bins_len = 9;
1360 u4_ctx_inc = (u4_ctx_inc | 0x065430);
1361
1362 ih264e_encode_decision_bins(u4_bins,
1363 i1_bins_len,
1364 u4_ctx_inc,
1365 4,
1366 ps_cabac_ctxt->au1_cabac_ctxt_table
1367 + u4_ctx_idx_offset,
1368 ps_cabac_ctxt);
1369
1370 /* Suffix, uses EncodeBypass */
1371 u4_bins = 0;
1372 i1_bins_len = 0;
1373 i2_sufs = i2_abs_mvd - u1_coff;
1374 while (1)
1375 {
1376 if (i2_sufs >= (1 << k))
1377 {
1378 u4_bins = (u4_bins | (1 << (31 - i1_bins_len)));
1379 i1_bins_len++;
1380 i2_sufs = i2_sufs - (1 << k);
1381 k++;
1382 }
1383 else
1384 {
1385 i1_bins_len++;
1386 while (k--)
1387 {
1388 u1_bin = ((i2_sufs >> k) & 0x01);
1389 u4_bins = (u4_bins | (u1_bin << (31 - i1_bins_len)));
1390 i1_bins_len++;
1391 }
1392 break;
1393 }
1394 }
1395 u4_bins >>= (32 - i1_bins_len);
1396 ih264e_cabac_encode_bypass_bins(ps_cabac_ctxt, u4_bins,
1397 i1_bins_len);
1398 }
1399 else
1400 {
1401 /* Prefix only */
1402 /* b0 */
1403 u4_bins = 1;
1404 i2_abs_mvd--;
1405 u1_ctxt_inc = 3;
1406 while (i2_abs_mvd)
1407 {
1408 i2_abs_mvd--;
1409 u4_bins = (u4_bins | (1 << i1_bins_len));
1410 if (u1_ctxt_inc <= 6)
1411 {
1412 u4_ctx_inc = (u4_ctx_inc
1413 | (u1_ctxt_inc << (i1_bins_len << 2)));
1414 u1_ctxt_inc++;
1415 }
1416 i1_bins_len++;
1417 }
1418 /* Encode Terminating bit */
1419 if (i1_bins_len <= 4)
1420 u4_ctx_inc = (u4_ctx_inc | (u1_ctxt_inc << (i1_bins_len << 2)));
1421 i1_bins_len++;
1422 ih264e_encode_decision_bins(u4_bins,
1423 i1_bins_len,
1424 u4_ctx_inc,
1425 4,
1426 ps_cabac_ctxt->au1_cabac_ctxt_table
1427 + u4_ctx_idx_offset,
1428 ps_cabac_ctxt);
1429 }
1430 /* sign bit, uses EncodeBypass */
1431 if (u1_mvd > 0)
1432 ih264e_cabac_encode_bypass_bin(ps_cabac_ctxt, 0);
1433 else
1434 ih264e_cabac_encode_bypass_bin(ps_cabac_ctxt, 1);
1435 }
1436 }
1437
1438 /**
1439 *******************************************************************************
1440 * @brief
1441 * Encodes all motion vectors for a P16x16 MB
1442 *
1443 * @param[in] ps_cabac_ctxt
1444 * Pointer to cabac context structure
1445 *
1446 * @param[in] pi2_mv_ptr
1447 * Pointer to array of motion vectors
1448 *
1449 * @returns
1450 *
1451 * @remarks
1452 * None
1453 *
1454 *******************************************************************************
1455 */
ih264e_cabac_enc_mvds_p16x16(cabac_ctxt_t * ps_cabac_ctxt,WORD16 * pi2_mv_ptr)1456 static void ih264e_cabac_enc_mvds_p16x16(cabac_ctxt_t *ps_cabac_ctxt,
1457 WORD16 *pi2_mv_ptr)
1458 {
1459
1460
1461 /* Encode the differential component of the motion vectors */
1462
1463 {
1464 UWORD8 u1_abs_mvd_x, u1_abs_mvd_y;
1465 UWORD8 *pu1_top_mv_ctxt, *pu1_lft_mv_ctxt;
1466 WORD16 u2_mv;
1467 u1_abs_mvd_x = 0;
1468 u1_abs_mvd_y = 0;
1469 pu1_top_mv_ctxt = ps_cabac_ctxt->ps_curr_ctxt_mb_info->u1_mv[0];
1470 pu1_lft_mv_ctxt = ps_cabac_ctxt->pu1_left_mv_ctxt_inc[0];
1471 {
1472 UWORD16 u2_abs_mvd_x_a, u2_abs_mvd_x_b, u2_abs_mvd_y_a,
1473 u2_abs_mvd_y_b;
1474 u2_abs_mvd_x_b = (UWORD16) pu1_top_mv_ctxt[0];
1475 u2_abs_mvd_y_b = (UWORD16) pu1_top_mv_ctxt[1];
1476 u2_abs_mvd_x_a = (UWORD16) pu1_lft_mv_ctxt[0];
1477 u2_abs_mvd_y_a = (UWORD16) pu1_lft_mv_ctxt[1];
1478 u2_mv = *(pi2_mv_ptr++);
1479
1480 ih264e_cabac_enc_ctx_mvd(u2_mv, MVD_X,
1481 (UWORD16) (u2_abs_mvd_x_a + u2_abs_mvd_x_b),
1482 ps_cabac_ctxt);
1483
1484 u1_abs_mvd_x = CLIP3(0, 127, ABS(u2_mv));
1485 u2_mv = *(pi2_mv_ptr++);
1486
1487 ih264e_cabac_enc_ctx_mvd(u2_mv, MVD_Y,
1488 (UWORD16) (u2_abs_mvd_y_a + u2_abs_mvd_y_b),
1489 ps_cabac_ctxt);
1490
1491 u1_abs_mvd_y = CLIP3(0, 127, ABS(u2_mv));
1492 }
1493 /***************************************************************/
1494 /* Store abs_mvd_values cabac contexts */
1495 /***************************************************************/
1496 pu1_top_mv_ctxt[0] = pu1_lft_mv_ctxt[0] = u1_abs_mvd_x;
1497 pu1_top_mv_ctxt[1] = pu1_lft_mv_ctxt[1] = u1_abs_mvd_y;
1498 }
1499 }
1500
1501
1502 /**
1503 *******************************************************************************
1504 * @brief
1505 * Encodes all motion vectors for a B MB (Assues that mbype is B_L0_16x16, B_L1_16x16 or B_Bi_16x16
1506 *
1507 * @param[in] ps_cabac_ctxt
1508 * Pointer to cabac context structure
1509 *
1510 * @param[in] pi2_mv_ptr
1511 * Pointer to array of motion vectors
1512 *
1513 * @returns
1514 *
1515 * @remarks
1516 * None
1517 *
1518 *******************************************************************************
1519 */
ih264e_cabac_enc_mvds_b16x16(cabac_ctxt_t * ps_cabac_ctxt,WORD16 * pi2_mv_ptr,WORD32 i4_mb_part_pred_mode)1520 static void ih264e_cabac_enc_mvds_b16x16(cabac_ctxt_t *ps_cabac_ctxt,
1521 WORD16 *pi2_mv_ptr,
1522 WORD32 i4_mb_part_pred_mode )
1523 {
1524
1525 /* Encode the differential component of the motion vectors */
1526
1527 {
1528 UWORD8 u1_abs_mvd_x, u1_abs_mvd_y;
1529 UWORD8 *pu1_top_mv_ctxt, *pu1_lft_mv_ctxt;
1530 WORD16 u2_mv;
1531 u1_abs_mvd_x = 0;
1532 u1_abs_mvd_y = 0;
1533 pu1_top_mv_ctxt = ps_cabac_ctxt->ps_curr_ctxt_mb_info->u1_mv[0];
1534 pu1_lft_mv_ctxt = ps_cabac_ctxt->pu1_left_mv_ctxt_inc[0];
1535 if (i4_mb_part_pred_mode != PRED_L1)/* || PRED_BI */
1536 {
1537 UWORD16 u2_abs_mvd_x_a, u2_abs_mvd_x_b, u2_abs_mvd_y_a,
1538 u2_abs_mvd_y_b;
1539 u2_abs_mvd_x_b = (UWORD16) pu1_top_mv_ctxt[0];
1540 u2_abs_mvd_y_b = (UWORD16) pu1_top_mv_ctxt[1];
1541 u2_abs_mvd_x_a = (UWORD16) pu1_lft_mv_ctxt[0];
1542 u2_abs_mvd_y_a = (UWORD16) pu1_lft_mv_ctxt[1];
1543 u2_mv = *(pi2_mv_ptr++);
1544
1545 ih264e_cabac_enc_ctx_mvd(u2_mv, MVD_X,
1546 (UWORD16) (u2_abs_mvd_x_a + u2_abs_mvd_x_b),
1547 ps_cabac_ctxt);
1548
1549 u1_abs_mvd_x = CLIP3(0, 127, ABS(u2_mv));
1550 u2_mv = *(pi2_mv_ptr++);
1551
1552 ih264e_cabac_enc_ctx_mvd(u2_mv, MVD_Y,
1553 (UWORD16) (u2_abs_mvd_y_a + u2_abs_mvd_y_b),
1554 ps_cabac_ctxt);
1555
1556 u1_abs_mvd_y = CLIP3(0, 127, ABS(u2_mv));
1557 }
1558 /***************************************************************/
1559 /* Store abs_mvd_values cabac contexts */
1560 /***************************************************************/
1561 pu1_top_mv_ctxt[0] = pu1_lft_mv_ctxt[0] = u1_abs_mvd_x;
1562 pu1_top_mv_ctxt[1] = pu1_lft_mv_ctxt[1] = u1_abs_mvd_y;
1563
1564 u1_abs_mvd_x = 0;
1565 u1_abs_mvd_y = 0;
1566 if (i4_mb_part_pred_mode != PRED_L0)/* || PRED_BI */
1567 {
1568 UWORD16 u2_abs_mvd_x_a, u2_abs_mvd_x_b, u2_abs_mvd_y_a,
1569 u2_abs_mvd_y_b;
1570 u2_abs_mvd_x_b = (UWORD16) pu1_top_mv_ctxt[2];
1571 u2_abs_mvd_y_b = (UWORD16) pu1_top_mv_ctxt[3];
1572 u2_abs_mvd_x_a = (UWORD16) pu1_lft_mv_ctxt[2];
1573 u2_abs_mvd_y_a = (UWORD16) pu1_lft_mv_ctxt[3];
1574 u2_mv = *(pi2_mv_ptr++);
1575
1576 ih264e_cabac_enc_ctx_mvd(u2_mv, MVD_X,
1577 (UWORD16) (u2_abs_mvd_x_a + u2_abs_mvd_x_b),
1578 ps_cabac_ctxt);
1579
1580 u1_abs_mvd_x = CLIP3(0, 127, ABS(u2_mv));
1581 u2_mv = *(pi2_mv_ptr++);
1582
1583 ih264e_cabac_enc_ctx_mvd(u2_mv, MVD_Y,
1584 (UWORD16) (u2_abs_mvd_y_a + u2_abs_mvd_y_b),
1585 ps_cabac_ctxt);
1586
1587 u1_abs_mvd_y = CLIP3(0, 127, ABS(u2_mv));
1588 }
1589 /***************************************************************/
1590 /* Store abs_mvd_values cabac contexts */
1591 /***************************************************************/
1592 pu1_top_mv_ctxt[2] = pu1_lft_mv_ctxt[2] = u1_abs_mvd_x;
1593 pu1_top_mv_ctxt[3] = pu1_lft_mv_ctxt[3] = u1_abs_mvd_y;
1594 }
1595 }
1596
1597
1598
1599 /**
1600 *******************************************************************************
1601 *
1602 * @brief
1603 * This function generates CABAC coded bit stream for an Intra Slice.
1604 *
1605 * @description
1606 * The mb syntax layer for intra slices constitutes luma mb mode, mb qp delta, coded block pattern, chroma mb mode and
1607 * luma/chroma residue. These syntax elements are written as directed by table
1608 * 7.3.5 of h264 specification.
1609 *
1610 * @param[in] ps_ent_ctxt
1611 * pointer to entropy context
1612 *
1613 * @returns error code
1614 *
1615 * @remarks none
1616 *
1617 *******************************************************************************
1618 */
ih264e_write_islice_mb_cabac(entropy_ctxt_t * ps_ent_ctxt)1619 IH264E_ERROR_T ih264e_write_islice_mb_cabac(entropy_ctxt_t *ps_ent_ctxt)
1620 {
1621 /* bit stream ptr */
1622 bitstrm_t *ps_bitstream = ps_ent_ctxt->ps_bitstrm;
1623 /* CABAC context */
1624 cabac_ctxt_t *ps_cabac_ctxt = ps_ent_ctxt->ps_cabac;
1625 /* packed header data */
1626 UWORD8 *pu1_byte = ps_ent_ctxt->pv_mb_header_data;
1627 mb_info_ctxt_t *ps_curr_ctxt;
1628 WORD32 mb_tpm, mb_type, cbp, chroma_intra_mode, luma_intra_mode;
1629 WORD8 mb_qp_delta;
1630 UWORD32 u4_cbp_l, u4_cbp_c;
1631 WORD32 byte_count = 0;
1632 WORD32 bitstream_start_offset, bitstream_end_offset;
1633
1634 if ((ps_bitstream->u4_strm_buf_offset + MIN_STREAM_SIZE_MB)
1635 >= ps_bitstream->u4_max_strm_size)
1636 {
1637 /* return without corrupting the buffer beyond its size */
1638 return (IH264E_BITSTREAM_BUFFER_OVERFLOW);
1639 }
1640 /* mb header info */
1641 mb_tpm = *pu1_byte++;
1642 byte_count++;
1643 cbp = *pu1_byte++;
1644 byte_count++;
1645 mb_qp_delta = *pu1_byte++;
1646 byte_count++;
1647 /* mb type */
1648 mb_type = mb_tpm & 0xF;
1649
1650 ih264e_get_cabac_context(ps_ent_ctxt, mb_type);
1651 ps_curr_ctxt = ps_cabac_ctxt->ps_curr_ctxt_mb_info;
1652
1653 /* Starting bitstream offset for header in bits */
1654 bitstream_start_offset = GET_NUM_BITS(ps_bitstream);
1655 u4_cbp_c = (cbp >> 4);
1656 u4_cbp_l = (cbp & 0xF);
1657 if (mb_type == I16x16)
1658 {
1659 luma_intra_mode = ((mb_tpm >> 4) & 3) + 1 + (u4_cbp_c << 2)
1660 + (u4_cbp_l == 15) * 12;
1661 }
1662 else
1663 {
1664 luma_intra_mode = 0;
1665 }
1666
1667 chroma_intra_mode = (mb_tpm >> 6);
1668
1669 /* Encode Intra pred mode, Luma */
1670 ih264e_cabac_enc_intra_mb_type(ISLICE, luma_intra_mode, ps_cabac_ctxt,
1671 MB_TYPE_I_SLICE);
1672
1673 if (mb_type == I4x4)
1674 { /* Encode 4x4 MB modes */
1675 ih264e_cabac_enc_4x4mb_modes(ps_cabac_ctxt, pu1_byte);
1676 byte_count += 8;
1677 }
1678 /* Encode chroma mode */
1679 ih264e_cabac_enc_chroma_predmode(chroma_intra_mode, ps_cabac_ctxt);
1680
1681 if (mb_type != I16x16)
1682 { /* Encode MB cbp */
1683 ih264e_cabac_enc_cbp(cbp, ps_cabac_ctxt);
1684 }
1685
1686 if ((cbp > 0) || (mb_type == I16x16))
1687 {
1688 /* Encode mb_qp_delta */
1689 ih264e_cabac_enc_mb_qp_delta(mb_qp_delta, ps_cabac_ctxt);
1690 /* Ending bitstream offset for header in bits */
1691 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
1692 ps_ent_ctxt->u4_header_bits[0] += bitstream_end_offset
1693 - bitstream_start_offset;
1694 /* Starting bitstream offset for residue */
1695 bitstream_start_offset = bitstream_end_offset;
1696 if (mb_type == I16x16)
1697 {
1698 ps_curr_ctxt->u1_mb_type = CAB_I16x16;
1699 ps_curr_ctxt->u1_cbp = cbp;
1700 ih264e_cabac_encode_residue_luma_dc(ps_ent_ctxt);
1701 ih264e_cabac_encode_residue(ps_ent_ctxt, cbp, LUMA_AC_CTXCAT);
1702 }
1703 else
1704 {
1705 ps_curr_ctxt->u1_cbp = cbp;
1706 ps_curr_ctxt->u1_mb_type = I4x4;
1707 ps_curr_ctxt->u1_mb_type = CAB_I4x4;
1708 ih264e_cabac_encode_residue(ps_ent_ctxt, cbp, LUMA_4X4_CTXCAT);
1709 ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0] &= 0x6;
1710 ps_cabac_ctxt->ps_curr_ctxt_mb_info->u1_yuv_dc_csbp &= 0x6;
1711 }
1712 /* Ending bitstream offset for reside in bits */
1713 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
1714 ps_ent_ctxt->u4_residue_bits[0] += bitstream_end_offset
1715 - bitstream_start_offset;
1716 }
1717 else
1718 {
1719 ps_curr_ctxt->u1_yuv_ac_csbp = 0;
1720 ps_curr_ctxt->u1_yuv_dc_csbp = 0;
1721 *(ps_cabac_ctxt->pu1_left_uv_ac_csbp) = 0;
1722 *(ps_cabac_ctxt->pu1_left_y_ac_csbp) = 0;
1723 *(ps_cabac_ctxt->pu1_left_yuv_dc_csbp) = 0;
1724 /* Ending bitstream offset for header in bits */
1725 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
1726 ps_ent_ctxt->u4_header_bits[0] += bitstream_end_offset
1727 - bitstream_start_offset;
1728
1729 /* Computing the number of used used for encoding the MB syntax */
1730 }
1731 memset(ps_curr_ctxt->u1_mv, 0, 16);
1732 memset(ps_cabac_ctxt->pu1_left_mv_ctxt_inc, 0, 16);
1733 ps_cabac_ctxt->ps_curr_ctxt_mb_info->u1_cbp = cbp;
1734 ps_ent_ctxt->pv_mb_header_data = ((WORD8 *)ps_ent_ctxt->pv_mb_header_data) + byte_count;
1735 if (mb_type == I16x16)
1736 {
1737 ps_curr_ctxt->u1_mb_type = CAB_I16x16;
1738
1739 }
1740 else
1741 {
1742 ps_curr_ctxt->u1_mb_type = CAB_I4x4;
1743
1744 }
1745 return IH264E_SUCCESS;
1746 }
1747
1748 /**
1749 *******************************************************************************
1750 *
1751 * @brief
1752 * This function generates CABAC coded bit stream for Inter slices
1753 *
1754 * @description
1755 * The mb syntax layer for inter slices constitutes luma mb mode, mb qp delta, coded block pattern, chroma mb mode and
1756 * luma/chroma residue. These syntax elements are written as directed by table
1757 * 7.3.5 of h264 specification
1758 *
1759 * @param[in] ps_ent_ctxt
1760 * pointer to entropy context
1761 *
1762 * @returns error code
1763 *
1764 * @remarks none
1765 *
1766 *******************************************************************************
1767 */
ih264e_write_pslice_mb_cabac(entropy_ctxt_t * ps_ent_ctxt)1768 IH264E_ERROR_T ih264e_write_pslice_mb_cabac(entropy_ctxt_t *ps_ent_ctxt)
1769 {
1770 /* bit stream ptr */
1771 bitstrm_t *ps_bitstream = ps_ent_ctxt->ps_bitstrm;
1772 /* CABAC context */
1773 cabac_ctxt_t *ps_cabac_ctxt = ps_ent_ctxt->ps_cabac;
1774
1775 mb_info_ctxt_t *ps_curr_ctxt;
1776
1777 WORD32 bitstream_start_offset, bitstream_end_offset;
1778 WORD32 mb_tpm, mb_type, cbp, chroma_intra_mode, luma_intra_mode;
1779 WORD8 mb_qp_delta;
1780 UWORD32 u4_cbp_l, u4_cbp_c;
1781 WORD32 byte_count = 0;
1782 UWORD8 *pu1_byte = ps_ent_ctxt->pv_mb_header_data;
1783
1784 if ((ps_bitstream->u4_strm_buf_offset + MIN_STREAM_SIZE_MB)
1785 >= ps_bitstream->u4_max_strm_size)
1786 {
1787 /* return without corrupting the buffer beyond its size */
1788 return (IH264E_BITSTREAM_BUFFER_OVERFLOW);
1789 }
1790 /* mb header info */
1791 mb_tpm = *pu1_byte++;
1792 byte_count++;
1793
1794 /* mb type */
1795 mb_type = mb_tpm & 0xF;
1796 /* CABAC contexts for the MB */
1797 ih264e_get_cabac_context(ps_ent_ctxt, mb_type);
1798 ps_curr_ctxt = ps_cabac_ctxt->ps_curr_ctxt_mb_info;
1799
1800 /* if Intra MB */
1801 if (mb_type == I16x16 || mb_type == I4x4)
1802 {
1803 cbp = *pu1_byte++;
1804 byte_count++;
1805 mb_qp_delta = *pu1_byte++;
1806 byte_count++;
1807
1808 /* Starting bitstream offset for header in bits */
1809 bitstream_start_offset = GET_NUM_BITS(ps_bitstream);
1810
1811 /* Encode mb_skip_flag */
1812 ih264e_cabac_enc_mb_skip(0, ps_cabac_ctxt, MB_SKIP_FLAG_P_SLICE);
1813 u4_cbp_c = (cbp >> 4);
1814 u4_cbp_l = (cbp & 0xF);
1815 if (mb_type == I16x16)
1816 {
1817 luma_intra_mode = ((mb_tpm >> 4) & 3) + 1 + (u4_cbp_c << 2)
1818 + (u4_cbp_l == 15) * 12;
1819 }
1820 else
1821 {
1822 luma_intra_mode = 0;
1823 }
1824 /* Encode intra mb type */
1825 {
1826 ih264e_cabac_encode_bin(ps_cabac_ctxt,
1827 1,
1828 ps_cabac_ctxt->au1_cabac_ctxt_table
1829 + MB_TYPE_P_SLICE);
1830
1831 ih264e_cabac_enc_intra_mb_type(PSLICE, (UWORD8) luma_intra_mode,
1832 ps_cabac_ctxt, MB_TYPE_P_SLICE);
1833 }
1834
1835 if (mb_type == I4x4)
1836 { /* Intra 4x4 modes */
1837 ih264e_cabac_enc_4x4mb_modes(ps_cabac_ctxt, pu1_byte);
1838 byte_count += 8;
1839 }
1840 chroma_intra_mode = (mb_tpm >> 6);
1841
1842 ih264e_cabac_enc_chroma_predmode(chroma_intra_mode, ps_cabac_ctxt);
1843
1844 if (mb_type != I16x16)
1845 {
1846 /* encode CBP */
1847 ih264e_cabac_enc_cbp(cbp, ps_cabac_ctxt);
1848 }
1849
1850 if ((cbp > 0) || (mb_type == I16x16))
1851 {
1852 ih264e_cabac_enc_mb_qp_delta(mb_qp_delta, ps_cabac_ctxt);
1853
1854 /* Ending bitstream offset for header in bits */
1855 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
1856 ps_ent_ctxt->u4_header_bits[0] += bitstream_end_offset
1857 - bitstream_start_offset;
1858 /* Starting bitstream offset for residue */
1859 bitstream_start_offset = bitstream_end_offset;
1860
1861 /* Encoding Residue */
1862 if (mb_type == I16x16)
1863 {
1864 ps_curr_ctxt->u1_mb_type = CAB_I16x16;
1865 ps_curr_ctxt->u1_cbp = (UWORD8) cbp;
1866 ih264e_cabac_encode_residue_luma_dc(ps_ent_ctxt);
1867 ih264e_cabac_encode_residue(ps_ent_ctxt, cbp, LUMA_AC_CTXCAT);
1868 }
1869 else
1870 {
1871 ps_curr_ctxt->u1_cbp = (UWORD8) cbp;
1872 ps_curr_ctxt->u1_mb_type = I4x4;
1873 ps_curr_ctxt->u1_mb_type = CAB_I4x4;
1874 ih264e_cabac_encode_residue(ps_ent_ctxt, cbp, LUMA_4X4_CTXCAT);
1875 ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0] &= 0x6;
1876 ps_cabac_ctxt->ps_curr_ctxt_mb_info->u1_yuv_dc_csbp &= 0x6;
1877 }
1878
1879 /* Ending bitstream offset for reside in bits */
1880 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
1881 ps_ent_ctxt->u4_residue_bits[0] += bitstream_end_offset
1882 - bitstream_start_offset;
1883 }
1884 else
1885 {
1886 ps_curr_ctxt->u1_yuv_ac_csbp = 0;
1887 ps_curr_ctxt->u1_yuv_dc_csbp = 0;
1888 *(ps_cabac_ctxt->pu1_left_uv_ac_csbp) = 0;
1889 *(ps_cabac_ctxt->pu1_left_y_ac_csbp) = 0;
1890 *(ps_cabac_ctxt->pu1_left_yuv_dc_csbp) = 0;
1891 /* Ending bitstream offset for header in bits */
1892 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
1893 ps_ent_ctxt->u4_header_bits[0] += bitstream_end_offset
1894 - bitstream_start_offset;
1895 }
1896
1897 memset(ps_curr_ctxt->u1_mv, 0, 16);
1898 memset(ps_cabac_ctxt->pu1_left_mv_ctxt_inc, 0, 16);
1899 ps_cabac_ctxt->ps_curr_ctxt_mb_info->u1_cbp = (UWORD8) cbp;
1900
1901 if (mb_type == I16x16)
1902 {
1903 ps_curr_ctxt->u1_mb_type = CAB_I16x16;
1904 }
1905 else
1906 {
1907 ps_curr_ctxt->u1_mb_type = CAB_I4x4;
1908 }
1909
1910 ps_ent_ctxt->pv_mb_header_data = ((WORD8 *)ps_ent_ctxt->pv_mb_header_data) + byte_count;
1911
1912 return IH264E_SUCCESS;
1913 }
1914 else /* Inter MB */
1915 {
1916 /* Starting bitstream offset for header in bits */
1917 bitstream_start_offset = GET_NUM_BITS(ps_bitstream);
1918 /* Encoding P16x16 */
1919 if (mb_type != PSKIP)
1920 {
1921 cbp = *pu1_byte++;
1922 byte_count++;
1923 mb_qp_delta = *pu1_byte++;
1924 byte_count++;
1925
1926 /* Encoding mb_skip */
1927 ih264e_cabac_enc_mb_skip(0, ps_cabac_ctxt, MB_SKIP_FLAG_P_SLICE);
1928
1929 /* Encoding mb_type as P16x16 */
1930 {
1931 UWORD32 u4_ctx_inc_p;
1932 u4_ctx_inc_p = (0x010 + ((2) << 8));
1933
1934 ih264e_encode_decision_bins(0, 3, u4_ctx_inc_p, 3,
1935 &(ps_cabac_ctxt->au1_cabac_ctxt_table[MB_TYPE_P_SLICE]),
1936 ps_cabac_ctxt);
1937 }
1938 ps_curr_ctxt->u1_mb_type = CAB_P;
1939 {
1940 WORD16 *pi2_mv_ptr = (WORD16 *) pu1_byte;
1941 byte_count += 4;
1942 ps_curr_ctxt->u1_mb_type = (ps_curr_ctxt->u1_mb_type
1943 | CAB_NON_BD16x16);
1944 /* Encoding motion vector for P16x16 */
1945 ih264e_cabac_enc_mvds_p16x16(ps_cabac_ctxt, pi2_mv_ptr);
1946 }
1947 /* Encode CBP */
1948 ih264e_cabac_enc_cbp(cbp, ps_cabac_ctxt);
1949
1950 if (cbp)
1951 {
1952 /* encode mb_qp_delta */
1953 ih264e_cabac_enc_mb_qp_delta(mb_qp_delta, ps_cabac_ctxt);
1954 }
1955
1956 /* Ending bitstream offset for header in bits */
1957 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
1958 ps_ent_ctxt->u4_header_bits[1] += bitstream_end_offset
1959 - bitstream_start_offset;
1960 /* Starting bitstream offset for residue */
1961 bitstream_start_offset = bitstream_end_offset;
1962
1963 }
1964 else/* MB = PSKIP */
1965 {
1966 ih264e_cabac_enc_mb_skip(1, ps_cabac_ctxt, MB_SKIP_FLAG_P_SLICE);
1967
1968 ps_curr_ctxt->u1_mb_type = CAB_P_SKIP;
1969 (*ps_ent_ctxt->pi4_mb_skip_run)++;
1970
1971 memset(ps_curr_ctxt->u1_mv, 0, 16);
1972 memset(ps_cabac_ctxt->pu1_left_mv_ctxt_inc, 0, 16);
1973 cbp = 0;
1974
1975 /* Ending bitstream offset for header in bits */
1976 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
1977 ps_ent_ctxt->u4_header_bits[1] += bitstream_end_offset
1978 - bitstream_start_offset;
1979 /* Starting bitstream offset for residue */
1980
1981 }
1982
1983 if (cbp > 0)
1984 {
1985 /* Encode residue */
1986 ih264e_cabac_encode_residue(ps_ent_ctxt, cbp, LUMA_4X4_CTXCAT);
1987 /* Ending bitstream offset for reside in bits */
1988 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
1989 ps_ent_ctxt->u4_residue_bits[1] += bitstream_end_offset
1990 - bitstream_start_offset;
1991
1992 ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0] &= 0x6;
1993 ps_curr_ctxt->u1_yuv_dc_csbp &= 0x6;
1994 }
1995 else
1996 {
1997 ps_curr_ctxt->u1_yuv_ac_csbp = 0;
1998 ps_curr_ctxt->u1_yuv_dc_csbp = 0;
1999 *(ps_cabac_ctxt->pu1_left_uv_ac_csbp) = 0;
2000 *(ps_cabac_ctxt->pu1_left_y_ac_csbp) = 0;
2001 *(ps_cabac_ctxt->pu1_left_yuv_dc_csbp) = 0;
2002 }
2003 ps_curr_ctxt->u1_intrapred_chroma_mode = 0;
2004 ps_curr_ctxt->u1_cbp = cbp;
2005 ps_ent_ctxt->pv_mb_header_data = ((WORD8 *)ps_ent_ctxt->pv_mb_header_data) + byte_count;
2006 return IH264E_SUCCESS;
2007 }
2008 }
2009
2010
2011 /* ! < Table 9-37 � Binarization for macroblock types in B slices in ITU_T_H264-201402
2012 * Bits 0-7 : binarised value
2013 * Bits 8-15: length of binary sequence */
2014
2015
2016 static const UWORD32 u4_b_mb_type[27] = { 0x0100, 0x0301, 0x0305, 0x0603,
2017 0x0623, 0x0613, 0x0633, 0x060b,
2018 0x062b, 0x061b, 0x063b, 0x061f,
2019 0x0707, 0x0747, 0x0727, 0x0767,
2020 0x0717, 0x0757, 0x0737, 0x0777,
2021 0x070f, 0x074f, 0x063f };
2022 /* CtxInc for mb types in B slices */
2023 static const UWORD32 ui_b_mb_type_ctx_inc[27] = { 0x00, 0x0530, 0x0530,
2024 0x0555430, 0x0555430,
2025 0x0555430, 0x0555430,
2026 0x0555430, 0x0555430,
2027 0x0555430, 0x0555430,
2028 0x0555430, 0x05555430,
2029 0x05555430, 0x05555430,
2030 0x05555430, 0x05555430,
2031 0x05555430, 0x05555430,
2032 0x05555430, 0x05555430,
2033 0x05555430, 0x0555430 };
2034
2035 /**
2036 *******************************************************************************
2037 *
2038 * @brief
2039 * This function generates CABAC coded bit stream for B slices
2040 *
2041 * @description
2042 * The mb syntax layer for inter slices constitutes luma mb mode,
2043 * mb qp delta, coded block pattern, chroma mb mode and
2044 * luma/chroma residue. These syntax elements are written as directed by table
2045 * 7.3.5 of h264 specification
2046 *
2047 * @param[in] ps_ent_ctxt
2048 * pointer to entropy context
2049 *
2050 * @returns error code
2051 *
2052 * @remarks none
2053 *
2054 *******************************************************************************
2055 */
ih264e_write_bslice_mb_cabac(entropy_ctxt_t * ps_ent_ctxt)2056 IH264E_ERROR_T ih264e_write_bslice_mb_cabac(entropy_ctxt_t *ps_ent_ctxt)
2057 {
2058 /* bit stream ptr */
2059 bitstrm_t *ps_bitstream = ps_ent_ctxt->ps_bitstrm;
2060 /* CABAC context */
2061 cabac_ctxt_t *ps_cabac_ctxt = ps_ent_ctxt->ps_cabac;
2062
2063 mb_info_ctxt_t *ps_curr_ctxt;
2064
2065 WORD32 bitstream_start_offset, bitstream_end_offset;
2066 WORD32 mb_tpm, mb_type, cbp, chroma_intra_mode, luma_intra_mode;
2067 WORD8 mb_qp_delta;
2068 UWORD32 u4_cbp_l, u4_cbp_c;
2069 WORD32 byte_count = 0;
2070 UWORD8 *pu1_byte = ps_ent_ctxt->pv_mb_header_data;
2071
2072 if ((ps_bitstream->u4_strm_buf_offset + MIN_STREAM_SIZE_MB)
2073 >= ps_bitstream->u4_max_strm_size)
2074 {
2075 /* return without corrupting the buffer beyond its size */
2076 return (IH264E_BITSTREAM_BUFFER_OVERFLOW);
2077 }
2078 /* mb header info */
2079 mb_tpm = *pu1_byte++;
2080 byte_count++;
2081
2082 /* mb type */
2083 mb_type = mb_tpm & 0xF;
2084 /* CABAC contexts for the MB */
2085 ih264e_get_cabac_context(ps_ent_ctxt, mb_type);
2086 ps_curr_ctxt = ps_cabac_ctxt->ps_curr_ctxt_mb_info;
2087
2088 /* if Intra MB */
2089 if (mb_type == I16x16 || mb_type == I4x4)
2090 {
2091 cbp = *pu1_byte++;
2092 byte_count++;
2093 mb_qp_delta = *pu1_byte++;
2094 byte_count++;
2095
2096 /* Starting bitstream offset for header in bits */
2097 bitstream_start_offset = GET_NUM_BITS(ps_bitstream);
2098
2099 /* Encode mb_skip_flag */
2100 ih264e_cabac_enc_mb_skip(0, ps_cabac_ctxt, MB_SKIP_FLAG_B_SLICE);
2101 u4_cbp_c = (cbp >> 4);
2102 u4_cbp_l = (cbp & 0xF);
2103 if (mb_type == I16x16)
2104 {
2105 luma_intra_mode = ((mb_tpm >> 4) & 3) + 1 + (u4_cbp_c << 2)
2106 + (u4_cbp_l == 15) * 12;
2107 }
2108 else
2109 {
2110 luma_intra_mode = 0;
2111 }
2112 /* Encode intra mb type */
2113 {
2114 mb_info_ctxt_t *ps_left_ctxt = ps_cabac_ctxt->ps_left_ctxt_mb_info;
2115 mb_info_ctxt_t *ps_top_ctxt = ps_cabac_ctxt->ps_top_ctxt_mb_info;
2116 UWORD32 u4_ctx_inc = 0;
2117
2118 if (ps_left_ctxt != ps_cabac_ctxt->ps_def_ctxt_mb_info)
2119 u4_ctx_inc += ((ps_left_ctxt->u1_mb_type & CAB_BD16x16_MASK)
2120 != CAB_BD16x16) ? 1 : 0;
2121 if (ps_top_ctxt != ps_cabac_ctxt->ps_def_ctxt_mb_info)
2122 u4_ctx_inc += ((ps_top_ctxt->u1_mb_type & CAB_BD16x16_MASK)
2123 != CAB_BD16x16) ? 1 : 0;
2124
2125 /* Intra Prefix Only "111101" */
2126 u4_ctx_inc = (u4_ctx_inc | 0x05555430);
2127 ih264e_encode_decision_bins(0x2f,
2128 6,
2129 u4_ctx_inc,
2130 3,
2131 ps_cabac_ctxt->au1_cabac_ctxt_table
2132 + MB_TYPE_B_SLICE,
2133 ps_cabac_ctxt);
2134
2135 ih264e_cabac_enc_intra_mb_type(BSLICE, (UWORD8) luma_intra_mode,
2136 ps_cabac_ctxt, MB_TYPE_B_SLICE);
2137
2138 }
2139
2140 if (mb_type == I4x4)
2141 { /* Intra 4x4 modes */
2142 ih264e_cabac_enc_4x4mb_modes(ps_cabac_ctxt, pu1_byte);
2143 byte_count += 8;
2144 }
2145 chroma_intra_mode = (mb_tpm >> 6);
2146
2147 ih264e_cabac_enc_chroma_predmode(chroma_intra_mode, ps_cabac_ctxt);
2148
2149 if (mb_type != I16x16)
2150 {
2151 /* encode CBP */
2152 ih264e_cabac_enc_cbp(cbp, ps_cabac_ctxt);
2153 }
2154
2155 if ((cbp > 0) || (mb_type == I16x16))
2156 {
2157 ih264e_cabac_enc_mb_qp_delta(mb_qp_delta, ps_cabac_ctxt);
2158
2159 /* Ending bitstream offset for header in bits */
2160 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
2161 ps_ent_ctxt->u4_header_bits[0] += bitstream_end_offset
2162 - bitstream_start_offset;
2163 /* Starting bitstream offset for residue */
2164 bitstream_start_offset = bitstream_end_offset;
2165
2166 /* Encoding Residue */
2167 if (mb_type == I16x16)
2168 {
2169 ps_curr_ctxt->u1_mb_type = CAB_I16x16;
2170 ps_curr_ctxt->u1_cbp = (UWORD8) cbp;
2171 ih264e_cabac_encode_residue_luma_dc(ps_ent_ctxt);
2172 ih264e_cabac_encode_residue(ps_ent_ctxt, cbp, LUMA_AC_CTXCAT);
2173 }
2174 else
2175 {
2176 ps_curr_ctxt->u1_cbp = (UWORD8) cbp;
2177 ps_curr_ctxt->u1_mb_type = I4x4;
2178 ps_curr_ctxt->u1_mb_type = CAB_I4x4;
2179 ih264e_cabac_encode_residue(ps_ent_ctxt, cbp, LUMA_4X4_CTXCAT);
2180 ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0] &= 0x6;
2181 ps_cabac_ctxt->ps_curr_ctxt_mb_info->u1_yuv_dc_csbp &= 0x6;
2182 }
2183
2184 /* Ending bitstream offset for reside in bits */
2185 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
2186 ps_ent_ctxt->u4_residue_bits[0] += bitstream_end_offset
2187 - bitstream_start_offset;
2188 }
2189 else
2190 {
2191 ps_curr_ctxt->u1_yuv_ac_csbp = 0;
2192 ps_curr_ctxt->u1_yuv_dc_csbp = 0;
2193 *(ps_cabac_ctxt->pu1_left_uv_ac_csbp) = 0;
2194 *(ps_cabac_ctxt->pu1_left_y_ac_csbp) = 0;
2195 *(ps_cabac_ctxt->pu1_left_yuv_dc_csbp) = 0;
2196 /* Ending bitstream offset for header in bits */
2197 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
2198 ps_ent_ctxt->u4_header_bits[0] += bitstream_end_offset
2199 - bitstream_start_offset;
2200 }
2201
2202 memset(ps_curr_ctxt->u1_mv, 0, 16);
2203 memset(ps_cabac_ctxt->pu1_left_mv_ctxt_inc, 0, 16);
2204 ps_cabac_ctxt->ps_curr_ctxt_mb_info->u1_cbp = (UWORD8) cbp;
2205
2206 if (mb_type == I16x16)
2207 {
2208 ps_curr_ctxt->u1_mb_type = CAB_I16x16;
2209 }
2210 else
2211 {
2212 ps_curr_ctxt->u1_mb_type = CAB_I4x4;
2213 }
2214
2215 ps_ent_ctxt->pv_mb_header_data = ((WORD8 *)ps_ent_ctxt->pv_mb_header_data) + byte_count;
2216
2217 return IH264E_SUCCESS;
2218 }
2219
2220 else /* Inter MB */
2221 {
2222 /* Starting bitstream offset for header in bits */
2223 bitstream_start_offset = GET_NUM_BITS(ps_bitstream);
2224 /* Encoding B_Direct_16x16 */
2225 if (mb_type == BDIRECT)
2226 {
2227 cbp = *pu1_byte++;
2228 byte_count++;
2229 mb_qp_delta = *pu1_byte++;
2230 byte_count++;
2231
2232 /* Encoding mb_skip */
2233 ih264e_cabac_enc_mb_skip(0, ps_cabac_ctxt, MB_SKIP_FLAG_B_SLICE);
2234
2235 /* Encoding mb_type as B_Direct_16x16 */
2236 {
2237
2238 mb_info_ctxt_t *ps_left_ctxt =
2239 ps_cabac_ctxt->ps_left_ctxt_mb_info;
2240 mb_info_ctxt_t *ps_top_ctxt = ps_cabac_ctxt->ps_top_ctxt_mb_info;
2241 UWORD32 u4_ctx_inc = 0;
2242
2243 if (ps_left_ctxt != ps_cabac_ctxt->ps_def_ctxt_mb_info)
2244 u4_ctx_inc += ((ps_left_ctxt->u1_mb_type & CAB_BD16x16_MASK)
2245 != CAB_BD16x16) ? 1 : 0;
2246 if (ps_top_ctxt != ps_cabac_ctxt->ps_def_ctxt_mb_info)
2247 u4_ctx_inc += ((ps_top_ctxt->u1_mb_type & CAB_BD16x16_MASK)
2248 != CAB_BD16x16) ? 1 : 0;
2249 /* Encode the bin */
2250 ih264e_cabac_encode_bin(
2251 ps_cabac_ctxt,
2252 0,
2253 ps_cabac_ctxt->au1_cabac_ctxt_table
2254 + MB_TYPE_B_SLICE + u4_ctx_inc);
2255
2256 }
2257 ps_curr_ctxt->u1_mb_type = CAB_BD16x16;
2258 memset(ps_curr_ctxt->u1_mv, 0, 16);
2259 memset(ps_cabac_ctxt->pu1_left_mv_ctxt_inc, 0, 16);
2260
2261 /* Encode CBP */
2262 ih264e_cabac_enc_cbp(cbp, ps_cabac_ctxt);
2263
2264 if (cbp)
2265 {
2266 /* encode mb_qp_delta */
2267 ih264e_cabac_enc_mb_qp_delta(mb_qp_delta, ps_cabac_ctxt);
2268 }
2269
2270 /* Ending bitstream offset for header in bits */
2271 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
2272 ps_ent_ctxt->u4_header_bits[1] += bitstream_end_offset
2273 - bitstream_start_offset;
2274 /* Starting bitstream offset for residue */
2275 bitstream_start_offset = bitstream_end_offset;
2276 /* Starting bitstream offset for residue */
2277
2278 }
2279
2280 else if (mb_type == BSKIP)/* MB = BSKIP */
2281 {
2282 ih264e_cabac_enc_mb_skip(1, ps_cabac_ctxt, MB_SKIP_FLAG_B_SLICE);
2283
2284 ps_curr_ctxt->u1_mb_type = CAB_B_SKIP;
2285
2286 memset(ps_curr_ctxt->u1_mv, 0, 16);
2287 memset(ps_cabac_ctxt->pu1_left_mv_ctxt_inc, 0, 16);
2288 cbp = 0;
2289
2290 /* Ending bitstream offset for header in bits */
2291 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
2292 ps_ent_ctxt->u4_header_bits[1] += bitstream_end_offset
2293 - bitstream_start_offset;
2294 /* Starting bitstream offset for residue */
2295
2296 }
2297
2298 else /* mbype is B_L0_16x16, B_L1_16x16 or B_Bi_16x16 */
2299 {
2300 WORD32 i4_mb_part_pred_mode = (mb_tpm >> 4);
2301 UWORD32 u4_mb_type = mb_type - B16x16 + B_L0_16x16
2302 + i4_mb_part_pred_mode;
2303 cbp = *pu1_byte++;
2304 byte_count++;
2305 mb_qp_delta = *pu1_byte++;
2306 byte_count++;
2307
2308 /* Encoding mb_skip */
2309 ih264e_cabac_enc_mb_skip(0, ps_cabac_ctxt, MB_SKIP_FLAG_B_SLICE);
2310
2311 /* Encoding mb_type as B16x16 */
2312 {
2313 mb_info_ctxt_t *ps_left_ctxt =
2314 ps_cabac_ctxt->ps_left_ctxt_mb_info;
2315 mb_info_ctxt_t *ps_top_ctxt = ps_cabac_ctxt->ps_top_ctxt_mb_info;
2316 UWORD32 u4_ctx_inc = 0;
2317
2318 UWORD32 u4_mb_type_bins = u4_b_mb_type[u4_mb_type];
2319 UWORD32 u4_bin_len = (u4_mb_type_bins >> 8) & 0x0F;
2320 u4_mb_type_bins = u4_mb_type_bins & 0xFF;
2321
2322 if (ps_left_ctxt != ps_cabac_ctxt->ps_def_ctxt_mb_info)
2323 u4_ctx_inc += ((ps_left_ctxt->u1_mb_type & CAB_BD16x16_MASK)
2324 != CAB_BD16x16) ? 1 : 0;
2325 if (ps_top_ctxt != ps_cabac_ctxt->ps_def_ctxt_mb_info)
2326 u4_ctx_inc += ((ps_top_ctxt->u1_mb_type & CAB_BD16x16_MASK)
2327 != CAB_BD16x16) ? 1 : 0;
2328
2329 u4_ctx_inc = u4_ctx_inc | ui_b_mb_type_ctx_inc[u4_mb_type];
2330
2331 ih264e_encode_decision_bins(u4_mb_type_bins,
2332 u4_bin_len,
2333 u4_ctx_inc,
2334 u4_bin_len,
2335 &(ps_cabac_ctxt->au1_cabac_ctxt_table[MB_TYPE_B_SLICE]),
2336 ps_cabac_ctxt);
2337 }
2338
2339 ps_curr_ctxt->u1_mb_type = CAB_NON_BD16x16;
2340 {
2341 WORD16 *pi2_mv_ptr = (WORD16 *) pu1_byte;
2342 /* Get the pred modes */
2343
2344 byte_count += 4 * (1 + (i4_mb_part_pred_mode == PRED_BI));
2345
2346 ps_curr_ctxt->u1_mb_type = (ps_curr_ctxt->u1_mb_type
2347 | CAB_NON_BD16x16);
2348 /* Encoding motion vector for B16x16 */
2349 ih264e_cabac_enc_mvds_b16x16(ps_cabac_ctxt, pi2_mv_ptr,
2350 i4_mb_part_pred_mode);
2351 }
2352 /* Encode CBP */
2353 ih264e_cabac_enc_cbp(cbp, ps_cabac_ctxt);
2354
2355 if (cbp)
2356 {
2357 /* encode mb_qp_delta */
2358 ih264e_cabac_enc_mb_qp_delta(mb_qp_delta, ps_cabac_ctxt);
2359 }
2360
2361 /* Ending bitstream offset for header in bits */
2362 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
2363 ps_ent_ctxt->u4_header_bits[1] += bitstream_end_offset
2364 - bitstream_start_offset;
2365 /* Starting bitstream offset for residue */
2366 bitstream_start_offset = bitstream_end_offset;
2367 }
2368
2369 if (cbp > 0)
2370 {
2371 /* Encode residue */
2372 ih264e_cabac_encode_residue(ps_ent_ctxt, cbp, LUMA_4X4_CTXCAT);
2373 /* Ending bitstream offset for reside in bits */
2374 bitstream_end_offset = GET_NUM_BITS(ps_bitstream);
2375 ps_ent_ctxt->u4_residue_bits[1] += bitstream_end_offset
2376 - bitstream_start_offset;
2377
2378 ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0] &= 0x6;
2379 ps_curr_ctxt->u1_yuv_dc_csbp &= 0x6;
2380 }
2381 else
2382 {
2383 ps_curr_ctxt->u1_yuv_ac_csbp = 0;
2384 ps_curr_ctxt->u1_yuv_dc_csbp = 0;
2385 *(ps_cabac_ctxt->pu1_left_uv_ac_csbp) = 0;
2386 *(ps_cabac_ctxt->pu1_left_y_ac_csbp) = 0;
2387 *(ps_cabac_ctxt->pu1_left_yuv_dc_csbp) = 0;
2388 }
2389 ps_curr_ctxt->u1_intrapred_chroma_mode = 0;
2390 ps_curr_ctxt->u1_cbp = cbp;
2391 ps_ent_ctxt->pv_mb_header_data = ((WORD8 *)ps_ent_ctxt->pv_mb_header_data) + byte_count;
2392 return IH264E_SUCCESS;
2393 }
2394 }
2395