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 */ 117static 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 */ 143static 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 */ 150static 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 193static 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 */ 334static 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[i >> 1]; 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 */ 404static 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 */ 473static 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 */ 578static 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 */ 731static 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 */ 884static 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 */ 965static 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 */ 1141static 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 */ 1313static 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 */ 1456static 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 */ 1520static 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[0]; 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[1]; 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 /***************************************************************/ 1560 /* Store abs_mvd_values cabac contexts */ 1561 /***************************************************************/ 1562 pu1_top_mv_ctxt[0] = pu1_lft_mv_ctxt[0] = u1_abs_mvd_x; 1563 pu1_top_mv_ctxt[1] = pu1_lft_mv_ctxt[1] = u1_abs_mvd_y; 1564 1565 u1_abs_mvd_x = 0; 1566 u1_abs_mvd_y = 0; 1567 if (i4_mb_part_pred_mode != PRED_L0)/* || PRED_BI */ 1568 { 1569 UWORD16 u2_abs_mvd_x_a, u2_abs_mvd_x_b, u2_abs_mvd_y_a, 1570 u2_abs_mvd_y_b; 1571 u2_abs_mvd_x_b = (UWORD16) pu1_top_mv_ctxt[2]; 1572 u2_abs_mvd_y_b = (UWORD16) pu1_top_mv_ctxt[3]; 1573 u2_abs_mvd_x_a = (UWORD16) pu1_lft_mv_ctxt[2]; 1574 u2_abs_mvd_y_a = (UWORD16) pu1_lft_mv_ctxt[3]; 1575 u2_mv = pi2_mv_ptr[2]; 1576 1577 ih264e_cabac_enc_ctx_mvd(u2_mv, MVD_X, 1578 (UWORD16) (u2_abs_mvd_x_a + u2_abs_mvd_x_b), 1579 ps_cabac_ctxt); 1580 1581 u1_abs_mvd_x = CLIP3(0, 127, ABS(u2_mv)); 1582 u2_mv = pi2_mv_ptr[3]; 1583 1584 ih264e_cabac_enc_ctx_mvd(u2_mv, MVD_Y, 1585 (UWORD16) (u2_abs_mvd_y_a + u2_abs_mvd_y_b), 1586 ps_cabac_ctxt); 1587 1588 u1_abs_mvd_y = CLIP3(0, 127, ABS(u2_mv)); 1589 } 1590 /***************************************************************/ 1591 /* Store abs_mvd_values cabac contexts */ 1592 /***************************************************************/ 1593 pu1_top_mv_ctxt[2] = pu1_lft_mv_ctxt[2] = u1_abs_mvd_x; 1594 pu1_top_mv_ctxt[3] = pu1_lft_mv_ctxt[3] = u1_abs_mvd_y; 1595 } 1596} 1597 1598 1599 1600/** 1601 ******************************************************************************* 1602 * 1603 * @brief 1604 * This function generates CABAC coded bit stream for an Intra Slice. 1605 * 1606 * @description 1607 * The mb syntax layer for intra slices constitutes luma mb mode, mb qp delta, coded block pattern, chroma mb mode and 1608 * luma/chroma residue. These syntax elements are written as directed by table 1609 * 7.3.5 of h264 specification. 1610 * 1611 * @param[in] ps_ent_ctxt 1612 * pointer to entropy context 1613 * 1614 * @returns error code 1615 * 1616 * @remarks none 1617 * 1618 ******************************************************************************* 1619 */ 1620IH264E_ERROR_T ih264e_write_islice_mb_cabac(entropy_ctxt_t *ps_ent_ctxt) 1621{ 1622 /* bit stream ptr */ 1623 bitstrm_t *ps_bitstream = ps_ent_ctxt->ps_bitstrm; 1624 /* CABAC context */ 1625 cabac_ctxt_t *ps_cabac_ctxt = ps_ent_ctxt->ps_cabac; 1626 /* packed header data */ 1627 UWORD8 *pu1_byte = ps_ent_ctxt->pv_mb_header_data; 1628 mb_hdr_common_t *ps_mb_hdr = (mb_hdr_common_t *)ps_ent_ctxt->pv_mb_header_data; 1629 mb_info_ctxt_t *ps_curr_ctxt; 1630 WORD32 mb_tpm, mb_type, cbp, chroma_intra_mode, luma_intra_mode; 1631 WORD8 mb_qp_delta; 1632 UWORD32 u4_cbp_l, u4_cbp_c; 1633 WORD32 bitstream_start_offset, bitstream_end_offset; 1634 1635 if ((ps_bitstream->u4_strm_buf_offset + MIN_STREAM_SIZE_MB) 1636 >= ps_bitstream->u4_max_strm_size) 1637 { 1638 /* return without corrupting the buffer beyond its size */ 1639 return (IH264E_BITSTREAM_BUFFER_OVERFLOW); 1640 } 1641 /* mb header info */ 1642 mb_tpm = ps_mb_hdr->u1_mb_type_mode; 1643 cbp = ps_mb_hdr->u1_cbp; 1644 mb_qp_delta = ps_mb_hdr->u1_mb_qp_delta; 1645 1646 /* mb type */ 1647 mb_type = mb_tpm & 0xF; 1648 1649 ih264e_get_cabac_context(ps_ent_ctxt, mb_type); 1650 ps_curr_ctxt = ps_cabac_ctxt->ps_curr_ctxt_mb_info; 1651 1652 /* Starting bitstream offset for header in bits */ 1653 bitstream_start_offset = GET_NUM_BITS(ps_bitstream); 1654 u4_cbp_c = (cbp >> 4); 1655 u4_cbp_l = (cbp & 0xF); 1656 if (mb_type == I16x16) 1657 { 1658 luma_intra_mode = ((mb_tpm >> 4) & 3) + 1 + (u4_cbp_c << 2) 1659 + (u4_cbp_l == 15) * 12; 1660 } 1661 else 1662 { 1663 luma_intra_mode = 0; 1664 } 1665 1666 chroma_intra_mode = (mb_tpm >> 6); 1667 1668 /* Encode Intra pred mode, Luma */ 1669 ih264e_cabac_enc_intra_mb_type(ISLICE, luma_intra_mode, ps_cabac_ctxt, 1670 MB_TYPE_I_SLICE); 1671 1672 if (mb_type == I4x4) 1673 { 1674 /* Encode 4x4 MB modes */ 1675 mb_hdr_i4x4_t *ps_mb_hdr_i4x4 = (mb_hdr_i4x4_t *)ps_ent_ctxt->pv_mb_header_data; 1676 ih264e_cabac_enc_4x4mb_modes(ps_cabac_ctxt, ps_mb_hdr_i4x4->au1_sub_blk_modes); 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 1735 if (mb_type == I16x16) 1736 { 1737 ps_curr_ctxt->u1_mb_type = CAB_I16x16; 1738 pu1_byte += sizeof(mb_hdr_i16x16_t); 1739 } 1740 else 1741 { 1742 ps_curr_ctxt->u1_mb_type = CAB_I4x4; 1743 pu1_byte += sizeof(mb_hdr_i4x4_t); 1744 } 1745 ps_ent_ctxt->pv_mb_header_data = pu1_byte; 1746 return IH264E_SUCCESS; 1747} 1748 1749/** 1750 ******************************************************************************* 1751 * 1752 * @brief 1753 * This function generates CABAC coded bit stream for Inter slices 1754 * 1755 * @description 1756 * The mb syntax layer for inter slices constitutes luma mb mode, mb qp delta, coded block pattern, chroma mb mode and 1757 * luma/chroma residue. These syntax elements are written as directed by table 1758 * 7.3.5 of h264 specification 1759 * 1760 * @param[in] ps_ent_ctxt 1761 * pointer to entropy context 1762 * 1763 * @returns error code 1764 * 1765 * @remarks none 1766 * 1767 ******************************************************************************* 1768 */ 1769IH264E_ERROR_T ih264e_write_pslice_mb_cabac(entropy_ctxt_t *ps_ent_ctxt) 1770{ 1771 /* bit stream ptr */ 1772 bitstrm_t *ps_bitstream = ps_ent_ctxt->ps_bitstrm; 1773 /* CABAC context */ 1774 cabac_ctxt_t *ps_cabac_ctxt = ps_ent_ctxt->ps_cabac; 1775 1776 mb_info_ctxt_t *ps_curr_ctxt; 1777 1778 WORD32 bitstream_start_offset, bitstream_end_offset; 1779 WORD32 mb_tpm, mb_type, cbp, chroma_intra_mode, luma_intra_mode; 1780 WORD8 mb_qp_delta; 1781 UWORD32 u4_cbp_l, u4_cbp_c; 1782 UWORD8 *pu1_byte = ps_ent_ctxt->pv_mb_header_data; 1783 mb_hdr_common_t *ps_mb_hdr = (mb_hdr_common_t *)ps_ent_ctxt->pv_mb_header_data; 1784 1785 if ((ps_bitstream->u4_strm_buf_offset + MIN_STREAM_SIZE_MB) 1786 >= ps_bitstream->u4_max_strm_size) 1787 { 1788 /* return without corrupting the buffer beyond its size */ 1789 return (IH264E_BITSTREAM_BUFFER_OVERFLOW); 1790 } 1791 /* mb header info */ 1792 mb_tpm = ps_mb_hdr->u1_mb_type_mode; 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 = ps_mb_hdr->u1_cbp; 1804 mb_qp_delta = ps_mb_hdr->u1_mb_qp_delta; 1805 1806 /* Starting bitstream offset for header in bits */ 1807 bitstream_start_offset = GET_NUM_BITS(ps_bitstream); 1808 1809 /* Encode mb_skip_flag */ 1810 ih264e_cabac_enc_mb_skip(0, ps_cabac_ctxt, MB_SKIP_FLAG_P_SLICE); 1811 u4_cbp_c = (cbp >> 4); 1812 u4_cbp_l = (cbp & 0xF); 1813 if (mb_type == I16x16) 1814 { 1815 luma_intra_mode = ((mb_tpm >> 4) & 3) + 1 + (u4_cbp_c << 2) 1816 + (u4_cbp_l == 15) * 12; 1817 } 1818 else 1819 { 1820 luma_intra_mode = 0; 1821 } 1822 /* Encode intra mb type */ 1823 { 1824 ih264e_cabac_encode_bin(ps_cabac_ctxt, 1825 1, 1826 ps_cabac_ctxt->au1_cabac_ctxt_table 1827 + MB_TYPE_P_SLICE); 1828 1829 ih264e_cabac_enc_intra_mb_type(PSLICE, (UWORD8) luma_intra_mode, 1830 ps_cabac_ctxt, MB_TYPE_P_SLICE); 1831 } 1832 1833 if (mb_type == I4x4) 1834 { 1835 /* Intra 4x4 modes */ 1836 mb_hdr_i4x4_t *ps_mb_hdr_i4x4 = (mb_hdr_i4x4_t *)ps_ent_ctxt->pv_mb_header_data; 1837 ih264e_cabac_enc_4x4mb_modes(ps_cabac_ctxt, ps_mb_hdr_i4x4->au1_sub_blk_modes); 1838 } 1839 chroma_intra_mode = (mb_tpm >> 6); 1840 1841 ih264e_cabac_enc_chroma_predmode(chroma_intra_mode, ps_cabac_ctxt); 1842 1843 if (mb_type != I16x16) 1844 { 1845 /* encode CBP */ 1846 ih264e_cabac_enc_cbp(cbp, ps_cabac_ctxt); 1847 } 1848 1849 if ((cbp > 0) || (mb_type == I16x16)) 1850 { 1851 ih264e_cabac_enc_mb_qp_delta(mb_qp_delta, ps_cabac_ctxt); 1852 1853 /* Ending bitstream offset for header in bits */ 1854 bitstream_end_offset = GET_NUM_BITS(ps_bitstream); 1855 ps_ent_ctxt->u4_header_bits[0] += bitstream_end_offset 1856 - bitstream_start_offset; 1857 /* Starting bitstream offset for residue */ 1858 bitstream_start_offset = bitstream_end_offset; 1859 1860 /* Encoding Residue */ 1861 if (mb_type == I16x16) 1862 { 1863 ps_curr_ctxt->u1_mb_type = CAB_I16x16; 1864 ps_curr_ctxt->u1_cbp = (UWORD8) cbp; 1865 ih264e_cabac_encode_residue_luma_dc(ps_ent_ctxt); 1866 ih264e_cabac_encode_residue(ps_ent_ctxt, cbp, LUMA_AC_CTXCAT); 1867 } 1868 else 1869 { 1870 ps_curr_ctxt->u1_cbp = (UWORD8) cbp; 1871 ps_curr_ctxt->u1_mb_type = I4x4; 1872 ps_curr_ctxt->u1_mb_type = CAB_I4x4; 1873 ih264e_cabac_encode_residue(ps_ent_ctxt, cbp, LUMA_4X4_CTXCAT); 1874 ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0] &= 0x6; 1875 ps_cabac_ctxt->ps_curr_ctxt_mb_info->u1_yuv_dc_csbp &= 0x6; 1876 } 1877 1878 /* Ending bitstream offset for reside in bits */ 1879 bitstream_end_offset = GET_NUM_BITS(ps_bitstream); 1880 ps_ent_ctxt->u4_residue_bits[0] += bitstream_end_offset 1881 - bitstream_start_offset; 1882 } 1883 else 1884 { 1885 ps_curr_ctxt->u1_yuv_ac_csbp = 0; 1886 ps_curr_ctxt->u1_yuv_dc_csbp = 0; 1887 *(ps_cabac_ctxt->pu1_left_uv_ac_csbp) = 0; 1888 *(ps_cabac_ctxt->pu1_left_y_ac_csbp) = 0; 1889 *(ps_cabac_ctxt->pu1_left_yuv_dc_csbp) = 0; 1890 /* Ending bitstream offset for header in bits */ 1891 bitstream_end_offset = GET_NUM_BITS(ps_bitstream); 1892 ps_ent_ctxt->u4_header_bits[0] += bitstream_end_offset 1893 - bitstream_start_offset; 1894 } 1895 1896 memset(ps_curr_ctxt->u1_mv, 0, 16); 1897 memset(ps_cabac_ctxt->pu1_left_mv_ctxt_inc, 0, 16); 1898 ps_cabac_ctxt->ps_curr_ctxt_mb_info->u1_cbp = (UWORD8) cbp; 1899 1900 if (mb_type == I16x16) 1901 { 1902 ps_curr_ctxt->u1_mb_type = CAB_I16x16; 1903 pu1_byte += sizeof(mb_hdr_i16x16_t); 1904 } 1905 else 1906 { 1907 ps_curr_ctxt->u1_mb_type = CAB_I4x4; 1908 pu1_byte += sizeof(mb_hdr_i4x4_t); 1909 } 1910 1911 ps_ent_ctxt->pv_mb_header_data = pu1_byte; 1912 1913 return IH264E_SUCCESS; 1914 } 1915 else /* Inter MB */ 1916 { 1917 /* Starting bitstream offset for header in bits */ 1918 bitstream_start_offset = GET_NUM_BITS(ps_bitstream); 1919 /* Encoding P16x16 */ 1920 if (mb_type != PSKIP) 1921 { 1922 mb_hdr_p16x16_t *ps_mb_hdr_p16x16 = (mb_hdr_p16x16_t *)ps_ent_ctxt->pv_mb_header_data; 1923 cbp = ps_mb_hdr->u1_cbp; 1924 mb_qp_delta = ps_mb_hdr->u1_mb_qp_delta; 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 *) ps_mb_hdr_p16x16->ai2_mv; 1941 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 pu1_byte += sizeof(mb_hdr_p16x16_t); 1964 1965 } 1966 else/* MB = PSKIP */ 1967 { 1968 ih264e_cabac_enc_mb_skip(1, ps_cabac_ctxt, MB_SKIP_FLAG_P_SLICE); 1969 1970 ps_curr_ctxt->u1_mb_type = CAB_P_SKIP; 1971 (*ps_ent_ctxt->pi4_mb_skip_run)++; 1972 1973 memset(ps_curr_ctxt->u1_mv, 0, 16); 1974 memset(ps_cabac_ctxt->pu1_left_mv_ctxt_inc, 0, 16); 1975 cbp = 0; 1976 1977 /* Ending bitstream offset for header in bits */ 1978 bitstream_end_offset = GET_NUM_BITS(ps_bitstream); 1979 ps_ent_ctxt->u4_header_bits[1] += bitstream_end_offset 1980 - bitstream_start_offset; 1981 /* Starting bitstream offset for residue */ 1982 1983 pu1_byte += sizeof(mb_hdr_pskip_t); 1984 } 1985 1986 if (cbp > 0) 1987 { 1988 /* Encode residue */ 1989 ih264e_cabac_encode_residue(ps_ent_ctxt, cbp, LUMA_4X4_CTXCAT); 1990 /* Ending bitstream offset for reside in bits */ 1991 bitstream_end_offset = GET_NUM_BITS(ps_bitstream); 1992 ps_ent_ctxt->u4_residue_bits[1] += bitstream_end_offset 1993 - bitstream_start_offset; 1994 1995 ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0] &= 0x6; 1996 ps_curr_ctxt->u1_yuv_dc_csbp &= 0x6; 1997 } 1998 else 1999 { 2000 ps_curr_ctxt->u1_yuv_ac_csbp = 0; 2001 ps_curr_ctxt->u1_yuv_dc_csbp = 0; 2002 *(ps_cabac_ctxt->pu1_left_uv_ac_csbp) = 0; 2003 *(ps_cabac_ctxt->pu1_left_y_ac_csbp) = 0; 2004 *(ps_cabac_ctxt->pu1_left_yuv_dc_csbp) = 0; 2005 } 2006 ps_curr_ctxt->u1_intrapred_chroma_mode = 0; 2007 ps_curr_ctxt->u1_cbp = cbp; 2008 ps_ent_ctxt->pv_mb_header_data = pu1_byte; 2009 2010 return IH264E_SUCCESS; 2011 } 2012} 2013 2014 2015/* ! < Table 9-37 � Binarization for macroblock types in B slices in ITU_T_H264-201402 2016 * Bits 0-7 : binarised value 2017 * Bits 8-15: length of binary sequence */ 2018 2019 2020static const UWORD32 u4_b_mb_type[27] = { 0x0100, 0x0301, 0x0305, 0x0603, 2021 0x0623, 0x0613, 0x0633, 0x060b, 2022 0x062b, 0x061b, 0x063b, 0x061f, 2023 0x0707, 0x0747, 0x0727, 0x0767, 2024 0x0717, 0x0757, 0x0737, 0x0777, 2025 0x070f, 0x074f, 0x063f }; 2026/* CtxInc for mb types in B slices */ 2027static const UWORD32 ui_b_mb_type_ctx_inc[27] = { 0x00, 0x0530, 0x0530, 2028 0x0555430, 0x0555430, 2029 0x0555430, 0x0555430, 2030 0x0555430, 0x0555430, 2031 0x0555430, 0x0555430, 2032 0x0555430, 0x05555430, 2033 0x05555430, 0x05555430, 2034 0x05555430, 0x05555430, 2035 0x05555430, 0x05555430, 2036 0x05555430, 0x05555430, 2037 0x05555430, 0x0555430 }; 2038 2039/** 2040 ******************************************************************************* 2041 * 2042 * @brief 2043 * This function generates CABAC coded bit stream for B slices 2044 * 2045 * @description 2046 * The mb syntax layer for inter slices constitutes luma mb mode, 2047 * mb qp delta, coded block pattern, chroma mb mode and 2048 * luma/chroma residue. These syntax elements are written as directed by table 2049 * 7.3.5 of h264 specification 2050 * 2051 * @param[in] ps_ent_ctxt 2052 * pointer to entropy context 2053 * 2054 * @returns error code 2055 * 2056 * @remarks none 2057 * 2058 ******************************************************************************* 2059 */ 2060IH264E_ERROR_T ih264e_write_bslice_mb_cabac(entropy_ctxt_t *ps_ent_ctxt) 2061{ 2062 /* bit stream ptr */ 2063 bitstrm_t *ps_bitstream = ps_ent_ctxt->ps_bitstrm; 2064 /* CABAC context */ 2065 cabac_ctxt_t *ps_cabac_ctxt = ps_ent_ctxt->ps_cabac; 2066 2067 mb_info_ctxt_t *ps_curr_ctxt; 2068 2069 WORD32 bitstream_start_offset, bitstream_end_offset; 2070 WORD32 mb_tpm, mb_type, cbp, chroma_intra_mode, luma_intra_mode; 2071 WORD8 mb_qp_delta; 2072 UWORD32 u4_cbp_l, u4_cbp_c; 2073 UWORD8 *pu1_byte = ps_ent_ctxt->pv_mb_header_data; 2074 mb_hdr_common_t *ps_mb_hdr = (mb_hdr_common_t *)ps_ent_ctxt->pv_mb_header_data; 2075 2076 if ((ps_bitstream->u4_strm_buf_offset + MIN_STREAM_SIZE_MB) 2077 >= ps_bitstream->u4_max_strm_size) 2078 { 2079 /* return without corrupting the buffer beyond its size */ 2080 return (IH264E_BITSTREAM_BUFFER_OVERFLOW); 2081 } 2082 /* mb header info */ 2083 mb_tpm = ps_mb_hdr->u1_mb_type_mode; 2084 2085 /* mb type */ 2086 mb_type = mb_tpm & 0xF; 2087 /* CABAC contexts for the MB */ 2088 ih264e_get_cabac_context(ps_ent_ctxt, mb_type); 2089 ps_curr_ctxt = ps_cabac_ctxt->ps_curr_ctxt_mb_info; 2090 2091 /* if Intra MB */ 2092 if (mb_type == I16x16 || mb_type == I4x4) 2093 { 2094 cbp = ps_mb_hdr->u1_cbp; 2095 mb_qp_delta = ps_mb_hdr->u1_mb_qp_delta; 2096 2097 /* Starting bitstream offset for header in bits */ 2098 bitstream_start_offset = GET_NUM_BITS(ps_bitstream); 2099 2100 /* Encode mb_skip_flag */ 2101 ih264e_cabac_enc_mb_skip(0, ps_cabac_ctxt, MB_SKIP_FLAG_B_SLICE); 2102 u4_cbp_c = (cbp >> 4); 2103 u4_cbp_l = (cbp & 0xF); 2104 if (mb_type == I16x16) 2105 { 2106 luma_intra_mode = ((mb_tpm >> 4) & 3) + 1 + (u4_cbp_c << 2) 2107 + (u4_cbp_l == 15) * 12; 2108 } 2109 else 2110 { 2111 luma_intra_mode = 0; 2112 } 2113 /* Encode intra mb type */ 2114 { 2115 mb_info_ctxt_t *ps_left_ctxt = ps_cabac_ctxt->ps_left_ctxt_mb_info; 2116 mb_info_ctxt_t *ps_top_ctxt = ps_cabac_ctxt->ps_top_ctxt_mb_info; 2117 UWORD32 u4_ctx_inc = 0; 2118 2119 if (ps_left_ctxt != ps_cabac_ctxt->ps_def_ctxt_mb_info) 2120 u4_ctx_inc += ((ps_left_ctxt->u1_mb_type & CAB_BD16x16_MASK) 2121 != CAB_BD16x16) ? 1 : 0; 2122 if (ps_top_ctxt != ps_cabac_ctxt->ps_def_ctxt_mb_info) 2123 u4_ctx_inc += ((ps_top_ctxt->u1_mb_type & CAB_BD16x16_MASK) 2124 != CAB_BD16x16) ? 1 : 0; 2125 2126 /* Intra Prefix Only "111101" */ 2127 u4_ctx_inc = (u4_ctx_inc | 0x05555430); 2128 ih264e_encode_decision_bins(0x2f, 2129 6, 2130 u4_ctx_inc, 2131 3, 2132 ps_cabac_ctxt->au1_cabac_ctxt_table 2133 + MB_TYPE_B_SLICE, 2134 ps_cabac_ctxt); 2135 2136 ih264e_cabac_enc_intra_mb_type(BSLICE, (UWORD8) luma_intra_mode, 2137 ps_cabac_ctxt, MB_TYPE_B_SLICE); 2138 2139 } 2140 2141 if (mb_type == I4x4) 2142 { 2143 /* Intra 4x4 modes */ 2144 mb_hdr_i4x4_t *ps_mb_hdr_i4x4 = (mb_hdr_i4x4_t *)ps_ent_ctxt->pv_mb_header_data; 2145 ih264e_cabac_enc_4x4mb_modes(ps_cabac_ctxt, ps_mb_hdr_i4x4->au1_sub_blk_modes); 2146 } 2147 chroma_intra_mode = (mb_tpm >> 6); 2148 2149 ih264e_cabac_enc_chroma_predmode(chroma_intra_mode, ps_cabac_ctxt); 2150 2151 if (mb_type != I16x16) 2152 { 2153 /* encode CBP */ 2154 ih264e_cabac_enc_cbp(cbp, ps_cabac_ctxt); 2155 } 2156 2157 if ((cbp > 0) || (mb_type == I16x16)) 2158 { 2159 ih264e_cabac_enc_mb_qp_delta(mb_qp_delta, ps_cabac_ctxt); 2160 2161 /* Ending bitstream offset for header in bits */ 2162 bitstream_end_offset = GET_NUM_BITS(ps_bitstream); 2163 ps_ent_ctxt->u4_header_bits[0] += bitstream_end_offset 2164 - bitstream_start_offset; 2165 /* Starting bitstream offset for residue */ 2166 bitstream_start_offset = bitstream_end_offset; 2167 2168 /* Encoding Residue */ 2169 if (mb_type == I16x16) 2170 { 2171 ps_curr_ctxt->u1_mb_type = CAB_I16x16; 2172 ps_curr_ctxt->u1_cbp = (UWORD8) cbp; 2173 ih264e_cabac_encode_residue_luma_dc(ps_ent_ctxt); 2174 ih264e_cabac_encode_residue(ps_ent_ctxt, cbp, LUMA_AC_CTXCAT); 2175 } 2176 else 2177 { 2178 ps_curr_ctxt->u1_cbp = (UWORD8) cbp; 2179 ps_curr_ctxt->u1_mb_type = I4x4; 2180 ps_curr_ctxt->u1_mb_type = CAB_I4x4; 2181 ih264e_cabac_encode_residue(ps_ent_ctxt, cbp, LUMA_4X4_CTXCAT); 2182 ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0] &= 0x6; 2183 ps_cabac_ctxt->ps_curr_ctxt_mb_info->u1_yuv_dc_csbp &= 0x6; 2184 } 2185 2186 /* Ending bitstream offset for reside in bits */ 2187 bitstream_end_offset = GET_NUM_BITS(ps_bitstream); 2188 ps_ent_ctxt->u4_residue_bits[0] += bitstream_end_offset 2189 - bitstream_start_offset; 2190 } 2191 else 2192 { 2193 ps_curr_ctxt->u1_yuv_ac_csbp = 0; 2194 ps_curr_ctxt->u1_yuv_dc_csbp = 0; 2195 *(ps_cabac_ctxt->pu1_left_uv_ac_csbp) = 0; 2196 *(ps_cabac_ctxt->pu1_left_y_ac_csbp) = 0; 2197 *(ps_cabac_ctxt->pu1_left_yuv_dc_csbp) = 0; 2198 /* Ending bitstream offset for header in bits */ 2199 bitstream_end_offset = GET_NUM_BITS(ps_bitstream); 2200 ps_ent_ctxt->u4_header_bits[0] += bitstream_end_offset 2201 - bitstream_start_offset; 2202 } 2203 2204 memset(ps_curr_ctxt->u1_mv, 0, 16); 2205 memset(ps_cabac_ctxt->pu1_left_mv_ctxt_inc, 0, 16); 2206 ps_cabac_ctxt->ps_curr_ctxt_mb_info->u1_cbp = (UWORD8) cbp; 2207 2208 if (mb_type == I16x16) 2209 { 2210 ps_curr_ctxt->u1_mb_type = CAB_I16x16; 2211 pu1_byte += sizeof(mb_hdr_i16x16_t); 2212 } 2213 else 2214 { 2215 ps_curr_ctxt->u1_mb_type = CAB_I4x4; 2216 pu1_byte += sizeof(mb_hdr_i4x4_t); 2217 } 2218 2219 ps_ent_ctxt->pv_mb_header_data = pu1_byte; 2220 2221 return IH264E_SUCCESS; 2222 } 2223 2224 else /* Inter MB */ 2225 { 2226 /* Starting bitstream offset for header in bits */ 2227 bitstream_start_offset = GET_NUM_BITS(ps_bitstream); 2228 /* Encoding B_Direct_16x16 */ 2229 if (mb_type == BDIRECT) 2230 { 2231 cbp = ps_mb_hdr->u1_cbp; 2232 mb_qp_delta = ps_mb_hdr->u1_mb_qp_delta; 2233 2234 2235 /* Encoding mb_skip */ 2236 ih264e_cabac_enc_mb_skip(0, ps_cabac_ctxt, MB_SKIP_FLAG_B_SLICE); 2237 2238 /* Encoding mb_type as B_Direct_16x16 */ 2239 { 2240 2241 mb_info_ctxt_t *ps_left_ctxt = 2242 ps_cabac_ctxt->ps_left_ctxt_mb_info; 2243 mb_info_ctxt_t *ps_top_ctxt = ps_cabac_ctxt->ps_top_ctxt_mb_info; 2244 UWORD32 u4_ctx_inc = 0; 2245 2246 if (ps_left_ctxt != ps_cabac_ctxt->ps_def_ctxt_mb_info) 2247 u4_ctx_inc += ((ps_left_ctxt->u1_mb_type & CAB_BD16x16_MASK) 2248 != CAB_BD16x16) ? 1 : 0; 2249 if (ps_top_ctxt != ps_cabac_ctxt->ps_def_ctxt_mb_info) 2250 u4_ctx_inc += ((ps_top_ctxt->u1_mb_type & CAB_BD16x16_MASK) 2251 != CAB_BD16x16) ? 1 : 0; 2252 /* Encode the bin */ 2253 ih264e_cabac_encode_bin( 2254 ps_cabac_ctxt, 2255 0, 2256 ps_cabac_ctxt->au1_cabac_ctxt_table 2257 + MB_TYPE_B_SLICE + u4_ctx_inc); 2258 2259 } 2260 ps_curr_ctxt->u1_mb_type = CAB_BD16x16; 2261 memset(ps_curr_ctxt->u1_mv, 0, 16); 2262 memset(ps_cabac_ctxt->pu1_left_mv_ctxt_inc, 0, 16); 2263 2264 /* Encode CBP */ 2265 ih264e_cabac_enc_cbp(cbp, ps_cabac_ctxt); 2266 2267 if (cbp) 2268 { 2269 /* encode mb_qp_delta */ 2270 ih264e_cabac_enc_mb_qp_delta(mb_qp_delta, ps_cabac_ctxt); 2271 } 2272 2273 /* Ending bitstream offset for header in bits */ 2274 bitstream_end_offset = GET_NUM_BITS(ps_bitstream); 2275 ps_ent_ctxt->u4_header_bits[1] += bitstream_end_offset 2276 - bitstream_start_offset; 2277 /* Starting bitstream offset for residue */ 2278 bitstream_start_offset = bitstream_end_offset; 2279 /* Starting bitstream offset for residue */ 2280 2281 pu1_byte += sizeof(mb_hdr_bdirect_t); 2282 } 2283 2284 else if (mb_type == BSKIP)/* MB = BSKIP */ 2285 { 2286 ih264e_cabac_enc_mb_skip(1, ps_cabac_ctxt, MB_SKIP_FLAG_B_SLICE); 2287 2288 ps_curr_ctxt->u1_mb_type = CAB_B_SKIP; 2289 2290 memset(ps_curr_ctxt->u1_mv, 0, 16); 2291 memset(ps_cabac_ctxt->pu1_left_mv_ctxt_inc, 0, 16); 2292 cbp = 0; 2293 2294 /* Ending bitstream offset for header in bits */ 2295 bitstream_end_offset = GET_NUM_BITS(ps_bitstream); 2296 ps_ent_ctxt->u4_header_bits[1] += bitstream_end_offset 2297 - bitstream_start_offset; 2298 /* Starting bitstream offset for residue */ 2299 2300 pu1_byte += sizeof(mb_hdr_bskip_t); 2301 } 2302 2303 else /* mbype is B_L0_16x16, B_L1_16x16 or B_Bi_16x16 */ 2304 { 2305 mb_hdr_b16x16_t *ps_mb_hdr_b16x16 = (mb_hdr_b16x16_t *)ps_ent_ctxt->pv_mb_header_data; 2306 2307 WORD32 i4_mb_part_pred_mode = (mb_tpm >> 4); 2308 UWORD32 u4_mb_type = mb_type - B16x16 + B_L0_16x16 2309 + i4_mb_part_pred_mode; 2310 cbp = ps_mb_hdr->u1_cbp; 2311 mb_qp_delta = ps_mb_hdr->u1_mb_qp_delta; 2312 2313 /* Encoding mb_skip */ 2314 ih264e_cabac_enc_mb_skip(0, ps_cabac_ctxt, MB_SKIP_FLAG_B_SLICE); 2315 2316 /* Encoding mb_type as B16x16 */ 2317 { 2318 mb_info_ctxt_t *ps_left_ctxt = 2319 ps_cabac_ctxt->ps_left_ctxt_mb_info; 2320 mb_info_ctxt_t *ps_top_ctxt = ps_cabac_ctxt->ps_top_ctxt_mb_info; 2321 UWORD32 u4_ctx_inc = 0; 2322 2323 UWORD32 u4_mb_type_bins = u4_b_mb_type[u4_mb_type]; 2324 UWORD32 u4_bin_len = (u4_mb_type_bins >> 8) & 0x0F; 2325 u4_mb_type_bins = u4_mb_type_bins & 0xFF; 2326 2327 if (ps_left_ctxt != ps_cabac_ctxt->ps_def_ctxt_mb_info) 2328 u4_ctx_inc += ((ps_left_ctxt->u1_mb_type & CAB_BD16x16_MASK) 2329 != CAB_BD16x16) ? 1 : 0; 2330 if (ps_top_ctxt != ps_cabac_ctxt->ps_def_ctxt_mb_info) 2331 u4_ctx_inc += ((ps_top_ctxt->u1_mb_type & CAB_BD16x16_MASK) 2332 != CAB_BD16x16) ? 1 : 0; 2333 2334 u4_ctx_inc = u4_ctx_inc | ui_b_mb_type_ctx_inc[u4_mb_type]; 2335 2336 ih264e_encode_decision_bins(u4_mb_type_bins, 2337 u4_bin_len, 2338 u4_ctx_inc, 2339 u4_bin_len, 2340 &(ps_cabac_ctxt->au1_cabac_ctxt_table[MB_TYPE_B_SLICE]), 2341 ps_cabac_ctxt); 2342 } 2343 2344 ps_curr_ctxt->u1_mb_type = CAB_NON_BD16x16; 2345 { 2346 WORD16 *pi2_mv_ptr = (WORD16 *) ps_mb_hdr_b16x16->ai2_mv; 2347 2348 /* Get the pred modes */ 2349 ps_curr_ctxt->u1_mb_type = (ps_curr_ctxt->u1_mb_type 2350 | CAB_NON_BD16x16); 2351 /* Encoding motion vector for B16x16 */ 2352 ih264e_cabac_enc_mvds_b16x16(ps_cabac_ctxt, pi2_mv_ptr, 2353 i4_mb_part_pred_mode); 2354 } 2355 /* Encode CBP */ 2356 ih264e_cabac_enc_cbp(cbp, ps_cabac_ctxt); 2357 2358 if (cbp) 2359 { 2360 /* encode mb_qp_delta */ 2361 ih264e_cabac_enc_mb_qp_delta(mb_qp_delta, ps_cabac_ctxt); 2362 } 2363 2364 /* Ending bitstream offset for header in bits */ 2365 bitstream_end_offset = GET_NUM_BITS(ps_bitstream); 2366 ps_ent_ctxt->u4_header_bits[1] += bitstream_end_offset 2367 - bitstream_start_offset; 2368 /* Starting bitstream offset for residue */ 2369 bitstream_start_offset = bitstream_end_offset; 2370 2371 pu1_byte += sizeof(mb_hdr_b16x16_t); 2372 } 2373 2374 if (cbp > 0) 2375 { 2376 /* Encode residue */ 2377 ih264e_cabac_encode_residue(ps_ent_ctxt, cbp, LUMA_4X4_CTXCAT); 2378 /* Ending bitstream offset for reside in bits */ 2379 bitstream_end_offset = GET_NUM_BITS(ps_bitstream); 2380 ps_ent_ctxt->u4_residue_bits[1] += bitstream_end_offset 2381 - bitstream_start_offset; 2382 2383 ps_cabac_ctxt->pu1_left_yuv_dc_csbp[0] &= 0x6; 2384 ps_curr_ctxt->u1_yuv_dc_csbp &= 0x6; 2385 } 2386 else 2387 { 2388 ps_curr_ctxt->u1_yuv_ac_csbp = 0; 2389 ps_curr_ctxt->u1_yuv_dc_csbp = 0; 2390 *(ps_cabac_ctxt->pu1_left_uv_ac_csbp) = 0; 2391 *(ps_cabac_ctxt->pu1_left_y_ac_csbp) = 0; 2392 *(ps_cabac_ctxt->pu1_left_yuv_dc_csbp) = 0; 2393 } 2394 ps_curr_ctxt->u1_intrapred_chroma_mode = 0; 2395 ps_curr_ctxt->u1_cbp = cbp; 2396 ps_ent_ctxt->pv_mb_header_data = pu1_byte; 2397 return IH264E_SUCCESS; 2398 } 2399} 2400