| |
| /*! |
| ************************************************************************************* |
| * \file cabac.c |
| * |
| * \brief |
| * CABAC entropy coding routines |
| * |
| * \author |
| * Main contributors (see contributors.h for copyright, address and affiliation details) |
| * - Detlev Marpe <marpe@hhi.de> |
| ************************************************************************************** |
| */ |
| |
| #include <stdlib.h> |
| #include <assert.h> |
| #include <memory.h> |
| #include "global.h" |
| |
| #include "cabac.h" |
| #include "image.h" |
| #include "mb_access.h" |
| |
| int last_dquant = 0; |
| |
| #if TRACE |
| #define CABAC_TRACE if (dp->bitstream->trace_enabled) trace2out_cabac (se) |
| #else |
| #define CABAC_TRACE |
| #endif |
| |
| /*********************************************************************** |
| * L O C A L L Y D E F I N E D F U N C T I O N P R O T O T Y P E S |
| *********************************************************************** |
| */ |
| |
| |
| void unary_bin_encode(EncodingEnvironmentPtr eep_frame, |
| unsigned int symbol, |
| BiContextTypePtr ctx, |
| int ctx_offset); |
| |
| void unary_bin_max_encode(EncodingEnvironmentPtr eep_frame, |
| unsigned int symbol, |
| BiContextTypePtr ctx, |
| int ctx_offset, |
| unsigned int max_symbol); |
| |
| void unary_exp_golomb_level_encode( EncodingEnvironmentPtr eep_dp, |
| unsigned int symbol, |
| BiContextTypePtr ctx); |
| |
| void unary_exp_golomb_mv_encode(EncodingEnvironmentPtr eep_dp, |
| unsigned int symbol, |
| BiContextTypePtr ctx, |
| unsigned int max_bin); |
| |
| |
| void cabac_new_slice(void) |
| { |
| last_dquant=0; |
| } |
| |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Check for available neighbouring blocks |
| * and set pointers in current macroblock |
| ************************************************************************ |
| */ |
| void CheckAvailabilityOfNeighborsCABAC(void) |
| { |
| int mb_nr = img->current_mb_nr; |
| Macroblock *currMB = &img->mb_data[mb_nr]; |
| PixelPos up, left; |
| |
| getNeighbour(mb_nr, -1, 0, IS_LUMA, &left); |
| getNeighbour(mb_nr, 0, -1, IS_LUMA, &up); |
| |
| if (up.available) |
| currMB->mb_available_up = &img->mb_data[up.mb_addr]; |
| else |
| currMB->mb_available_up = NULL; |
| |
| if (left.available) |
| currMB->mb_available_left = &img->mb_data[left.mb_addr]; |
| else |
| currMB->mb_available_left = NULL; |
| } |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Allocation of contexts models for the motion info |
| * used for arithmetic encoding |
| ************************************************************************ |
| */ |
| MotionInfoContexts* create_contexts_MotionInfo(void) |
| { |
| MotionInfoContexts* enco_ctx; |
| |
| enco_ctx = (MotionInfoContexts*) calloc(1, sizeof(MotionInfoContexts) ); |
| if( enco_ctx == NULL ) |
| no_mem_exit("create_contexts_MotionInfo: enco_ctx"); |
| |
| return enco_ctx; |
| } |
| |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Allocates of contexts models for the texture info |
| * used for arithmetic encoding |
| ************************************************************************ |
| */ |
| TextureInfoContexts* create_contexts_TextureInfo(void) |
| { |
| TextureInfoContexts* enco_ctx; |
| |
| enco_ctx = (TextureInfoContexts*) calloc(1, sizeof(TextureInfoContexts) ); |
| if( enco_ctx == NULL ) |
| no_mem_exit("create_contexts_TextureInfo: enco_ctx"); |
| |
| return enco_ctx; |
| } |
| |
| |
| |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Frees the memory of the contexts models |
| * used for arithmetic encoding of the motion info. |
| ************************************************************************ |
| */ |
| void delete_contexts_MotionInfo(MotionInfoContexts *enco_ctx) |
| { |
| if( enco_ctx == NULL ) |
| return; |
| |
| free( enco_ctx ); |
| |
| return; |
| } |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Frees the memory of the contexts models |
| * used for arithmetic encoding of the texture info. |
| ************************************************************************ |
| */ |
| void delete_contexts_TextureInfo(TextureInfoContexts *enco_ctx) |
| { |
| if( enco_ctx == NULL ) |
| return; |
| |
| free( enco_ctx ); |
| |
| return; |
| } |
| |
| |
| /*! |
| *************************************************************************** |
| * \brief |
| * This function is used to arithmetically encode the field |
| * mode info of a given MB in the case of mb-based frame/field decision |
| *************************************************************************** |
| */ |
| void writeFieldModeInfo_CABAC(SyntaxElement *se, DataPartition *dp) |
| { |
| EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac); |
| int curr_len = arienco_bits_written(eep_dp); |
| int a,b,act_ctx; |
| MotionInfoContexts *ctx = (img->currentSlice)->mot_ctx; |
| Macroblock *currMB = &img->mb_data[img->current_mb_nr]; |
| int mb_field = se->value1; |
| |
| a = currMB->mbAvailA ? img->mb_data[currMB->mbAddrA].mb_field : 0; |
| b = currMB->mbAvailB ? img->mb_data[currMB->mbAddrB].mb_field : 0; |
| |
| act_ctx = a + b; |
| |
| biari_encode_symbol(eep_dp, (signed short) (mb_field != 0),&ctx->mb_aff_contexts[act_ctx]); |
| |
| se->context = act_ctx; |
| |
| dp->bitstream->write_flag = 1; |
| se->len = (arienco_bits_written(eep_dp) - curr_len); |
| CABAC_TRACE; |
| return; |
| } |
| |
| /*! |
| *************************************************************************** |
| * \brief |
| * This function is used to arithmetically encode the mb_skip_flag. |
| *************************************************************************** |
| */ |
| void writeMB_skip_flagInfo_CABAC(SyntaxElement *se, DataPartition *dp) |
| { |
| EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac); |
| int curr_len = arienco_bits_written(eep_dp); |
| int a,b,act_ctx; |
| int bframe = (img->type==B_SLICE); |
| MotionInfoContexts *ctx = (img->currentSlice)->mot_ctx; |
| Macroblock *currMB = &img->mb_data[img->current_mb_nr]; |
| int curr_mb_type = se->value1; |
| |
| if (bframe) |
| { |
| if (currMB->mb_available_up == NULL) |
| b = 0; |
| else |
| b = (currMB->mb_available_up->skip_flag==0 ? 1 : 0); |
| if (currMB->mb_available_left == NULL) |
| a = 0; |
| else |
| a = (currMB->mb_available_left->skip_flag==0 ? 1 : 0); |
| |
| act_ctx = 7 + a + b; |
| |
| if (se->value1==0 && se->value2==0) // DIRECT mode, no coefficients |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][act_ctx]); |
| else |
| biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[2][act_ctx]); |
| |
| currMB->skip_flag = (se->value1==0 && se->value2==0)?1:0; |
| } |
| else |
| { |
| if (currMB->mb_available_up == NULL) |
| b = 0; |
| else |
| b = (( (currMB->mb_available_up)->skip_flag == 0) ? 1 : 0 ); |
| if (currMB->mb_available_left == NULL) |
| a = 0; |
| else |
| a = (( (currMB->mb_available_left)->skip_flag == 0) ? 1 : 0 ); |
| |
| act_ctx = a + b; |
| |
| if (curr_mb_type==0) // SKIP |
| biari_encode_symbol(eep_dp, 1,&ctx->mb_type_contexts[1][act_ctx]); |
| else |
| biari_encode_symbol(eep_dp, 0,&ctx->mb_type_contexts[1][act_ctx]); |
| |
| currMB->skip_flag = (curr_mb_type==0)?1:0; |
| } |
| se->context = act_ctx; |
| |
| dp->bitstream->write_flag = 1; |
| se->len = (arienco_bits_written(eep_dp) - curr_len); |
| CABAC_TRACE; |
| return; |
| } |
| |
| /*! |
| *************************************************************************** |
| * \brief |
| * This function is used to arithmetically encode the macroblock |
| * intra_pred_size flag info of a given MB. |
| *************************************************************************** |
| */ |
| |
| void writeMB_transform_size_CABAC(SyntaxElement *se, DataPartition *dp) |
| { |
| EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac); |
| int curr_len = arienco_bits_written(eep_dp); |
| int a, b; |
| int act_ctx = 0; |
| int act_sym; |
| |
| MotionInfoContexts *ctx = (img->currentSlice)->mot_ctx; |
| Macroblock *currMB = &img->mb_data[img->current_mb_nr]; |
| |
| |
| b = (currMB->mb_available_up == NULL) ? 0 : currMB->mb_available_up->luma_transform_size_8x8_flag; |
| a = (currMB->mb_available_left == NULL) ? 0 :currMB->mb_available_left->luma_transform_size_8x8_flag; |
| |
| act_ctx = a + b; |
| act_sym = currMB->luma_transform_size_8x8_flag; |
| se->context = act_ctx; // store context |
| biari_encode_symbol(eep_dp, (signed short) (act_sym != 0), ctx->transform_size_contexts + act_ctx ); |
| |
| dp->bitstream->write_flag = 1; |
| se->len = (arienco_bits_written(eep_dp) - curr_len); |
| CABAC_TRACE; |
| return; |
| } |
| |
| /*! |
| *************************************************************************** |
| * \brief |
| * This function is used to arithmetically encode the macroblock |
| * type info of a given MB. |
| *************************************************************************** |
| */ |
| |
| void writeMB_typeInfo_CABAC(SyntaxElement *se, DataPartition *dp) |
| { |
| EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac); |
| int curr_len = arienco_bits_written(eep_dp); |
| int a, b; |
| int act_ctx = 0; |
| int act_sym; |
| signed short csym; |
| int bframe = (img->type==B_SLICE); |
| int mode_sym = 0; |
| int mode16x16; |
| |
| |
| MotionInfoContexts *ctx = (img->currentSlice)->mot_ctx; |
| Macroblock *currMB = &img->mb_data[img->current_mb_nr]; |
| int curr_mb_type = se->value1; |
| |
| if(img->type == I_SLICE) // INTRA-frame |
| { |
| if (currMB->mb_available_up == NULL) |
| b = 0; |
| else |
| b = ((currMB->mb_available_up->mb_type != I4MB && currMB->mb_available_up->mb_type != I8MB) ? 1 : 0 ); |
| |
| if (currMB->mb_available_left == NULL) |
| a = 0; |
| else |
| a = ((currMB->mb_available_left->mb_type != I4MB && currMB->mb_available_left->mb_type != I8MB) ? 1 : 0 ); |
| |
| act_ctx = a + b; |
| act_sym = curr_mb_type; |
| se->context = act_ctx; // store context |
| |
| if (act_sym==0) // 4x4 Intra |
| { |
| biari_encode_symbol(eep_dp, 0, ctx->mb_type_contexts[0] + act_ctx ); |
| } |
| else if( act_sym == 25 ) // PCM-MODE |
| { |
| biari_encode_symbol(eep_dp, 1, ctx->mb_type_contexts[0] + act_ctx ); |
| biari_encode_symbol_final(eep_dp, 1); |
| } |
| else // 16x16 Intra |
| { |
| biari_encode_symbol(eep_dp, 1, ctx->mb_type_contexts[0] + act_ctx ); |
| |
| biari_encode_symbol_final(eep_dp, 0); |
| |
| mode_sym = act_sym-1; // Values in the range of 0...23 |
| act_ctx = 4; |
| act_sym = mode_sym/12; |
| biari_encode_symbol(eep_dp, (signed short) act_sym, ctx->mb_type_contexts[0] + act_ctx ); // coding of AC/no AC |
| mode_sym = mode_sym % 12; |
| act_sym = mode_sym / 4; // coding of cbp: 0,1,2 |
| act_ctx = 5; |
| if (act_sym==0) |
| { |
| biari_encode_symbol(eep_dp, 0, ctx->mb_type_contexts[0] + act_ctx ); |
| } |
| else |
| { |
| biari_encode_symbol(eep_dp, 1, ctx->mb_type_contexts[0] + act_ctx ); |
| act_ctx=6; |
| biari_encode_symbol(eep_dp, (signed short) (act_sym!=1), ctx->mb_type_contexts[0] + act_ctx ); |
| } |
| mode_sym = mode_sym & 0x03; // coding of I pred-mode: 0,1,2,3 |
| act_sym = mode_sym >> 1; |
| act_ctx = 7; |
| biari_encode_symbol(eep_dp, (signed short) act_sym, ctx->mb_type_contexts[0] + act_ctx ); |
| act_ctx = 8; |
| act_sym = mode_sym & 0x01; |
| biari_encode_symbol(eep_dp, (signed short) act_sym, ctx->mb_type_contexts[0] + act_ctx ); |
| } |
| } |
| else // INTER |
| { |
| |
| if (bframe) |
| { |
| if (currMB->mb_available_up == NULL) |
| b = 0; |
| else |
| b = ((currMB->mb_available_up->mb_type != 0) ? 1 : 0 ); |
| |
| if (currMB->mb_available_left == NULL) |
| a = 0; |
| else |
| a = ((currMB->mb_available_left->mb_type != 0) ? 1 : 0 ); |
| act_ctx = a + b; |
| se->context = act_ctx; // store context |
| } |
| act_sym = curr_mb_type; |
| |
| if (act_sym>=(mode16x16=(bframe?24:7))) |
| { |
| mode_sym = act_sym-mode16x16; |
| act_sym = mode16x16; // 16x16 mode info |
| } |
| |
| if (!bframe) |
| { |
| switch (act_sym) |
| { |
| case 0: |
| break; |
| case 1: |
| biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][4]); |
| biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][5]); |
| biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][6]); |
| break; |
| case 2: |
| biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][4]); |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[1][5]); |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[1][7]); |
| break; |
| case 3: |
| biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][4]); |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[1][5]); |
| biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][7]); |
| break; |
| case 4: |
| case 5: |
| biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][4]); |
| biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][5]); |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[1][6]); |
| break; |
| case 6: |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[1][4]); |
| biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[1][7]); |
| break; |
| case 7: |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[1][4]); |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[1][7]); |
| break; |
| default: |
| printf ("Unsupported MB-MODE in writeMB_typeInfo_CABAC!\n"); |
| exit (1); |
| } |
| } |
| else //===== B-FRAMES ===== |
| { |
| if (act_sym==0) |
| { |
| biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[2][act_ctx]); |
| } |
| else if (act_sym<=2) |
| { |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][act_ctx]); |
| biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[2][4]); |
| csym = (act_sym-1 != 0); |
| biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]); |
| } |
| else if (act_sym<=10) |
| { |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][act_ctx]); |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][4]); |
| biari_encode_symbol (eep_dp, 0, &ctx->mb_type_contexts[2][5]); |
| csym=(((act_sym-3)>>2)&0x01) != 0; |
| biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]); |
| csym=(((act_sym-3)>>1)&0x01) != 0; |
| biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]); |
| csym=((act_sym-3)&0x01) != 0; |
| biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]); |
| } |
| else if (act_sym==11 || act_sym==22) |
| { |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][act_ctx]); |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][4]); |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][5]); |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][6]); |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][6]); |
| csym = (act_sym != 11); |
| biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]); |
| } |
| else |
| { |
| if (act_sym > 22) act_sym--; |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][act_ctx]); |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][4]); |
| biari_encode_symbol (eep_dp, 1, &ctx->mb_type_contexts[2][5]); |
| csym=(((act_sym-12)>>3)&0x01) != 0; |
| biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]); |
| csym=(((act_sym-12)>>2)&0x01) != 0; |
| biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]); |
| csym=(((act_sym-12)>>1)&0x01) != 0; |
| biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]); |
| csym=((act_sym-12)&0x01) != 0; |
| biari_encode_symbol (eep_dp, csym, &ctx->mb_type_contexts[2][6]); |
| if (act_sym >=22) act_sym++; |
| } |
| } |
| |
| if(act_sym==mode16x16) // additional info for 16x16 Intra-mode |
| { |
| if( mode_sym==25 ) |
| { |
| biari_encode_symbol_final(eep_dp, 1 ); |
| dp->bitstream->write_flag = 1; |
| se->len = (arienco_bits_written(eep_dp) - curr_len); |
| CABAC_TRACE; |
| return; |
| } |
| biari_encode_symbol_final(eep_dp, 0 ); |
| |
| act_ctx = 8; |
| act_sym = mode_sym/12; |
| biari_encode_symbol(eep_dp, (signed short) act_sym, ctx->mb_type_contexts[1] + act_ctx ); // coding of AC/no AC |
| mode_sym = mode_sym % 12; |
| |
| act_sym = mode_sym / 4; // coding of cbp: 0,1,2 |
| act_ctx = 9; |
| if (act_sym==0) |
| { |
| biari_encode_symbol(eep_dp, 0, ctx->mb_type_contexts[1] + act_ctx ); |
| } |
| else |
| { |
| biari_encode_symbol(eep_dp, 1, ctx->mb_type_contexts[1] + act_ctx ); |
| biari_encode_symbol(eep_dp, (signed short) (act_sym!=1), ctx->mb_type_contexts[1] + act_ctx ); |
| } |
| |
| mode_sym = mode_sym % 4; // coding of I pred-mode: 0,1,2,3 |
| act_ctx = 10; |
| act_sym = mode_sym/2; |
| biari_encode_symbol(eep_dp, (signed short) act_sym, ctx->mb_type_contexts[1] + act_ctx ); |
| act_sym = mode_sym%2; |
| biari_encode_symbol(eep_dp, (signed short) act_sym, ctx->mb_type_contexts[1] + act_ctx ); |
| } |
| } |
| dp->bitstream->write_flag = 1; |
| se->len = (arienco_bits_written(eep_dp) - curr_len); |
| CABAC_TRACE; |
| return; |
| } |
| |
| |
| /*! |
| *************************************************************************** |
| * \brief |
| * This function is used to arithmetically encode the 8x8 block |
| * type info |
| *************************************************************************** |
| */ |
| void writeB8_typeInfo_CABAC(SyntaxElement *se, DataPartition *dp) |
| { |
| EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac); |
| int curr_len = arienco_bits_written(eep_dp); |
| int act_ctx; |
| int act_sym; |
| signed short csym; |
| int bframe=(img->type==B_SLICE); |
| |
| MotionInfoContexts *ctx = (img->currentSlice)->mot_ctx; |
| |
| act_sym = se->value1; |
| act_ctx = 0; |
| |
| if (!bframe) |
| { |
| switch (act_sym) |
| { |
| case 0: |
| biari_encode_symbol (eep_dp, 1, &ctx->b8_type_contexts[0][1]); |
| break; |
| case 1: |
| biari_encode_symbol (eep_dp, 0, &ctx->b8_type_contexts[0][1]); |
| biari_encode_symbol (eep_dp, 0, &ctx->b8_type_contexts[0][3]); |
| break; |
| case 2: |
| biari_encode_symbol (eep_dp, 0, &ctx->b8_type_contexts[0][1]); |
| biari_encode_symbol (eep_dp, 1, &ctx->b8_type_contexts[0][3]); |
| biari_encode_symbol (eep_dp, 1, &ctx->b8_type_contexts[0][4]); |
| break; |
| case 3: |
| biari_encode_symbol (eep_dp, 0, &ctx->b8_type_contexts[0][1]); |
| biari_encode_symbol (eep_dp, 1, &ctx->b8_type_contexts[0][3]); |
| biari_encode_symbol (eep_dp, 0, &ctx->b8_type_contexts[0][4]); |
| break; |
| } |
| } |
| else //===== B-FRAME ===== |
| { |
| if (act_sym==0) |
| { |
| biari_encode_symbol (eep_dp, 0, &ctx->b8_type_contexts[1][0]); |
| dp->bitstream->write_flag = 1; |
| se->len = (arienco_bits_written(eep_dp) - curr_len); |
| CABAC_TRACE; |
| return; |
| } |
| else |
| { |
| biari_encode_symbol (eep_dp, 1, &ctx->b8_type_contexts[1][0]); |
| act_sym--; |
| } |
| if (act_sym<2) |
| { |
| biari_encode_symbol (eep_dp, 0, &ctx->b8_type_contexts[1][1]); |
| biari_encode_symbol (eep_dp, (signed short) (act_sym!=0), &ctx->b8_type_contexts[1][3]); |
| } |
| else if (act_sym<6) |
| { |
| biari_encode_symbol (eep_dp, 1, &ctx->b8_type_contexts[1][1]); |
| biari_encode_symbol (eep_dp, 0, &ctx->b8_type_contexts[1][2]); |
| csym=(((act_sym-2)>>1)&0x01) != 0; |
| biari_encode_symbol (eep_dp, csym, &ctx->b8_type_contexts[1][3]); |
| csym=((act_sym-2)&0x01) != 0; |
| biari_encode_symbol (eep_dp, csym, &ctx->b8_type_contexts[1][3]); |
| } |
| else |
| { |
| biari_encode_symbol (eep_dp, 1, &ctx->b8_type_contexts[1][1]); |
| biari_encode_symbol (eep_dp, 1, &ctx->b8_type_contexts[1][2]); |
| csym=(((act_sym-6)>>2)&0x01); |
| if (csym) |
| { |
| biari_encode_symbol (eep_dp, 1, &ctx->b8_type_contexts[1][3]); |
| csym=((act_sym-6)&0x01) != 0; |
| biari_encode_symbol (eep_dp, csym, &ctx->b8_type_contexts[1][3]); |
| } |
| else |
| { |
| biari_encode_symbol (eep_dp, 0, &ctx->b8_type_contexts[1][3]); |
| csym=(((act_sym-6)>>1)&0x01) != 0; |
| biari_encode_symbol (eep_dp, csym, &ctx->b8_type_contexts[1][3]); |
| csym=((act_sym-6)&0x01) != 0; |
| biari_encode_symbol (eep_dp, csym, &ctx->b8_type_contexts[1][3]); |
| } |
| } |
| } |
| |
| dp->bitstream->write_flag = 1; |
| se->len = (arienco_bits_written(eep_dp) - curr_len); |
| CABAC_TRACE; |
| return; |
| } |
| |
| /*! |
| **************************************************************************** |
| * \brief |
| * This function is used to arithmetically encode a pair of |
| * intra prediction modes of a given MB. |
| **************************************************************************** |
| */ |
| void writeIntraPredMode_CABAC(SyntaxElement *se, DataPartition *dp) |
| { |
| EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac); |
| int curr_len = arienco_bits_written(eep_dp); |
| TextureInfoContexts *ctx = img->currentSlice->tex_ctx; |
| |
| // use_most_probable_mode |
| if (se->value1 == -1) |
| biari_encode_symbol(eep_dp, 1, ctx->ipr_contexts); |
| else |
| { |
| biari_encode_symbol(eep_dp, 0, ctx->ipr_contexts); |
| |
| // remaining_mode_selector |
| biari_encode_symbol(eep_dp,(signed short)( se->value1 & 0x1 ), ctx->ipr_contexts+1); |
| biari_encode_symbol(eep_dp,(signed short)((se->value1 & 0x2)>>1), ctx->ipr_contexts+1); |
| biari_encode_symbol(eep_dp,(signed short)((se->value1 & 0x4)>>2), ctx->ipr_contexts+1); |
| } |
| |
| dp->bitstream->write_flag = 1; |
| se->len = (arienco_bits_written(eep_dp) - curr_len); |
| CABAC_TRACE; |
| return; |
| } |
| |
| /*! |
| **************************************************************************** |
| * \brief |
| * This function is used to arithmetically encode the reference |
| * parameter of a given MB. |
| **************************************************************************** |
| */ |
| void writeRefFrame_CABAC(SyntaxElement *se, DataPartition *dp) |
| { |
| EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac); |
| int curr_len = arienco_bits_written(eep_dp); |
| int mb_nr = img->current_mb_nr; |
| MotionInfoContexts *ctx = img->currentSlice->mot_ctx; |
| Macroblock *currMB = &img->mb_data[mb_nr]; |
| int addctx = 0; |
| |
| int a, b; |
| int act_ctx; |
| int act_sym; |
| signed char** refframe_array = enc_picture->ref_idx[se->value2]; |
| |
| int bslice = (img->type==B_SLICE); |
| |
| int b8a, b8b; |
| |
| PixelPos block_a, block_b; |
| |
| getLuma4x4Neighbour(mb_nr, (img->subblock_x << 2) - 1, (img->subblock_y << 2), &block_a); |
| getLuma4x4Neighbour(mb_nr, (img->subblock_x << 2), (img->subblock_y << 2) - 1, &block_b); |
| |
| b8a=((block_a.x >> 1) & 0x01)+2*((block_a.y >> 1) & 0x01); |
| b8b=((block_b.x >> 1) & 0x01)+2*((block_b.y >> 1) & 0x01); |
| |
| |
| if (!block_b.available) |
| b=0; |
| //else if (IS_DIRECT(&img->mb_data[block_b.mb_addr]) || (img->mb_data[block_b.mb_addr].b8mode[b8b]==0 && bslice)) |
| else if ((IS_DIRECT(&img->mb_data[block_b.mb_addr]) && !giRDOpt_B8OnlyFlag) || (img->mb_data[block_b.mb_addr].b8mode[b8b]==0 && bslice)) |
| b=0; |
| else |
| { |
| if (img->MbaffFrameFlag && (currMB->mb_field == 0) && (img->mb_data[block_b.mb_addr].mb_field == 1)) |
| b = (refframe_array[block_b.pos_y][block_b.pos_x] > 1 ? 1 : 0); |
| else |
| b = (refframe_array[block_b.pos_y][block_b.pos_x] > 0 ? 1 : 0); |
| } |
| |
| if (!block_a.available) |
| a=0; |
| // else if (IS_DIRECT(&img->mb_data[block_a.mb_addr]) || (img->mb_data[block_a.mb_addr].b8mode[b8a]==0 && bslice)) |
| else if ((IS_DIRECT(&img->mb_data[block_a.mb_addr]) && !giRDOpt_B8OnlyFlag) || (img->mb_data[block_a.mb_addr].b8mode[b8a]==0 && bslice)) |
| a=0; |
| else |
| { |
| if (img->MbaffFrameFlag && (currMB->mb_field == 0) && (img->mb_data[block_a.mb_addr].mb_field == 1)) |
| a = (refframe_array[block_a.pos_y][block_a.pos_x] > 1 ? 1 : 0); |
| else |
| a = (refframe_array[block_a.pos_y][block_a.pos_x] > 0 ? 1 : 0); |
| } |
| |
| act_ctx = a + 2*b; |
| se->context = act_ctx; // store context |
| act_sym = se->value1; |
| |
| if (act_sym==0) |
| { |
| biari_encode_symbol(eep_dp, 0, ctx->ref_no_contexts[addctx] + act_ctx ); |
| } |
| else |
| { |
| biari_encode_symbol(eep_dp, 1, ctx->ref_no_contexts[addctx] + act_ctx); |
| act_sym--; |
| act_ctx=4; |
| unary_bin_encode(eep_dp, act_sym,ctx->ref_no_contexts[addctx]+act_ctx,1); |
| } |
| |
| dp->bitstream->write_flag = 1; |
| se->len = (arienco_bits_written(eep_dp) - curr_len); |
| CABAC_TRACE; |
| return; |
| } |
| |
| /*! |
| **************************************************************************** |
| * \brief |
| * This function is used to arithmetically encode the coded |
| * block pattern of a given delta quant. |
| **************************************************************************** |
| */ |
| void writeDquant_CABAC(SyntaxElement *se, DataPartition *dp) |
| { |
| EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac); |
| int curr_len = arienco_bits_written(eep_dp); |
| |
| MotionInfoContexts *ctx = img->currentSlice->mot_ctx; |
| |
| int act_ctx; |
| int act_sym; |
| int dquant = se->value1; |
| int sign=0; |
| |
| Macroblock *currMB = &img->mb_data[img->current_mb_nr]; |
| |
| last_dquant=currMB->prev_delta_qp; |
| |
| if (dquant <= 0) |
| sign = 1; |
| act_sym = iabs(dquant) << 1; |
| |
| act_sym += sign; |
| act_sym --; |
| |
| act_ctx = ( (last_dquant != 0) ? 1 : 0); |
| |
| if (act_sym==0) |
| { |
| biari_encode_symbol(eep_dp, 0, ctx->delta_qp_contexts + act_ctx ); |
| } |
| else |
| { |
| biari_encode_symbol(eep_dp, 1, ctx->delta_qp_contexts + act_ctx); |
| act_ctx=2; |
| act_sym--; |
| unary_bin_encode(eep_dp, act_sym,ctx->delta_qp_contexts+act_ctx,1); |
| } |
| |
| dp->bitstream->write_flag = 1; |
| se->len = (arienco_bits_written(eep_dp) - curr_len); |
| CABAC_TRACE; |
| return; |
| } |
| |
| /*! |
| **************************************************************************** |
| * \brief |
| * This function is used to arithmetically encode the motion |
| * vector data of a B-frame MB. |
| **************************************************************************** |
| */ |
| void writeMVD_CABAC(SyntaxElement *se, DataPartition *dp) |
| { |
| EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac); |
| int curr_len = arienco_bits_written(eep_dp); |
| int i = (img->subblock_x << 2); |
| int j = (img->subblock_y << 2); |
| int a, b; |
| int act_ctx; |
| int act_sym; |
| int mv_pred_res; |
| int mv_local_err; |
| int mv_sign; |
| int list_idx = se->value2 & 0x01; |
| int k = (se->value2>>1); // MVD component |
| int mb_nr = img->current_mb_nr; |
| |
| PixelPos block_a, block_b; |
| |
| MotionInfoContexts *ctx = img->currentSlice->mot_ctx; |
| Macroblock *currMB = &img->mb_data[mb_nr]; |
| |
| getLuma4x4Neighbour(mb_nr, i - 1, j, &block_a); |
| getLuma4x4Neighbour(mb_nr, i , j - 1, &block_b); |
| |
| if (block_b.available) |
| { |
| b = iabs(img->mb_data[block_b.mb_addr].mvd[list_idx][block_b.y][block_b.x][k]); |
| if (img->MbaffFrameFlag && (k==1)) |
| { |
| if ((currMB->mb_field==0) && (img->mb_data[block_b.mb_addr].mb_field==1)) |
| b *= 2; |
| else if ((currMB->mb_field==1) && (img->mb_data[block_b.mb_addr].mb_field==0)) |
| b /= 2; |
| } |
| } |
| else |
| b=0; |
| |
| if (block_a.available) |
| { |
| a = iabs(img->mb_data[block_a.mb_addr].mvd[list_idx][block_a.y][block_a.x][k]); |
| if (img->MbaffFrameFlag && (k==1)) |
| { |
| if ((currMB->mb_field==0) && (img->mb_data[block_a.mb_addr].mb_field==1)) |
| a *= 2; |
| else if ((currMB->mb_field==1) && (img->mb_data[block_a.mb_addr].mb_field==0)) |
| a /= 2; |
| } |
| } |
| else |
| a = 0; |
| |
| if ((mv_local_err=a+b)<3) |
| act_ctx = 5*k; |
| else |
| { |
| if (mv_local_err>32) |
| act_ctx=5*k+3; |
| else |
| act_ctx=5*k+2; |
| } |
| |
| mv_pred_res = se->value1; |
| se->context = act_ctx; |
| |
| act_sym = iabs(mv_pred_res); |
| |
| if (act_sym == 0) |
| biari_encode_symbol(eep_dp, 0, &ctx->mv_res_contexts[0][act_ctx] ); |
| else |
| { |
| biari_encode_symbol(eep_dp, 1, &ctx->mv_res_contexts[0][act_ctx] ); |
| act_sym--; |
| act_ctx=5*k; |
| unary_exp_golomb_mv_encode(eep_dp,act_sym,ctx->mv_res_contexts[1]+act_ctx,3); |
| mv_sign = (mv_pred_res<0) ? 1: 0; |
| biari_encode_symbol_eq_prob(eep_dp, (signed short) mv_sign); |
| } |
| |
| dp->bitstream->write_flag = 1; |
| se->len = (arienco_bits_written(eep_dp) - curr_len); |
| CABAC_TRACE; |
| return; |
| } |
| |
| |
| /*! |
| **************************************************************************** |
| * \brief |
| * This function is used to arithmetically encode the chroma |
| * intra prediction mode of an 8x8 block |
| **************************************************************************** |
| */ |
| void writeCIPredMode_CABAC(SyntaxElement *se, DataPartition *dp) |
| { |
| EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac); |
| int curr_len = arienco_bits_written(eep_dp); |
| TextureInfoContexts *ctx = img->currentSlice->tex_ctx; |
| Macroblock *currMB = &img->mb_data[img->current_mb_nr]; |
| int act_ctx,a,b; |
| int act_sym = se->value1; |
| |
| if (currMB->mb_available_up == NULL) b = 0; |
| else b = ( ((currMB->mb_available_up)->c_ipred_mode != 0) ? 1 : 0); |
| |
| if (currMB->mb_available_left == NULL) a = 0; |
| else a = ( ((currMB->mb_available_left)->c_ipred_mode != 0) ? 1 : 0); |
| |
| act_ctx = a+b; |
| |
| if (act_sym==0) |
| biari_encode_symbol(eep_dp, 0, ctx->cipr_contexts + act_ctx ); |
| else |
| { |
| biari_encode_symbol(eep_dp, 1, ctx->cipr_contexts + act_ctx ); |
| unary_bin_max_encode(eep_dp,(unsigned int) (act_sym-1),ctx->cipr_contexts+3,0,2); |
| } |
| |
| dp->bitstream->write_flag = 1; |
| se->len = (arienco_bits_written(eep_dp) - curr_len); |
| CABAC_TRACE; |
| return; |
| } |
| |
| |
| /*! |
| **************************************************************************** |
| * \brief |
| * This function is used to arithmetically encode the coded |
| * block pattern of an 8x8 block |
| **************************************************************************** |
| */ |
| void writeCBP_BIT_CABAC (int b8, int bit, int cbp, Macroblock* currMB, int inter, EncodingEnvironmentPtr eep_dp) |
| { |
| PixelPos block_a; |
| int a, b; |
| |
| int mb_x=(b8 & 0x01)<<1; |
| int mb_y=(b8 >> 1)<<1; |
| |
| if (mb_y == 0) |
| { |
| if (currMB->mb_available_up == NULL) |
| b = 0; |
| else |
| { |
| if((currMB->mb_available_up)->mb_type==IPCM) |
| b=0; |
| else |
| b = (( ((currMB->mb_available_up)->cbp & (1<<(2+(mb_x>>1)))) == 0) ? 1 : 0); //VG-ADD |
| } |
| |
| } |
| else |
| b = ( ((cbp & (1<<(mb_x/2))) == 0) ? 1: 0); |
| |
| if (mb_x == 0) |
| { |
| getLuma4x4Neighbour(img->current_mb_nr, (mb_x << 2) - 1, (mb_y << 2), &block_a); |
| if (block_a.available) |
| { |
| { |
| if(img->mb_data[block_a.mb_addr].mb_type==IPCM) |
| a=0; |
| else |
| a = (( (img->mb_data[block_a.mb_addr].cbp & (1<<(2*(block_a.y>>1)+1))) == 0) ? 1 : 0); //VG-ADD |
| } |
| |
| } |
| else |
| a=0; |
| } |
| else |
| a = ( ((cbp & (1<<mb_y)) == 0) ? 1: 0); |
| |
| //===== WRITE BIT ===== |
| biari_encode_symbol (eep_dp, (signed short) bit, |
| img->currentSlice->tex_ctx->cbp_contexts[0] + a+2*b); |
| } |
| |
| /*! |
| **************************************************************************** |
| * \brief |
| * This function is used to arithmetically encode the coded |
| * block pattern of a macroblock |
| **************************************************************************** |
| */ |
| void writeCBP_CABAC(SyntaxElement *se, DataPartition *dp) |
| { |
| EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac); |
| int curr_len = arienco_bits_written(eep_dp); |
| TextureInfoContexts *ctx = img->currentSlice->tex_ctx; |
| Macroblock *currMB = &img->mb_data[img->current_mb_nr]; |
| |
| int a, b; |
| int curr_cbp_ctx, curr_cbp_idx; |
| int cbp = se->value1; // symbol to encode |
| int cbp_bit; |
| int b8; |
| |
| for (b8=0; b8<4; b8++) |
| { |
| curr_cbp_idx = (currMB->b8mode[b8] == IBLOCK ? 0 : 1); |
| writeCBP_BIT_CABAC (b8, cbp&(1<<b8), cbp, currMB, curr_cbp_idx, eep_dp); |
| } |
| |
| if (img->yuv_format != YUV400) |
| { |
| // coding of chroma part |
| b = 0; |
| if (currMB->mb_available_up != NULL) |
| { |
| if((currMB->mb_available_up)->mb_type==IPCM) |
| b=1; |
| else |
| b = ((currMB->mb_available_up)->cbp > 15) ? 1 : 0; |
| } |
| |
| |
| a = 0; |
| if (currMB->mb_available_left != NULL) |
| { |
| if((currMB->mb_available_left)->mb_type==IPCM) |
| a=1; |
| else |
| a = ((currMB->mb_available_left)->cbp > 15) ? 1 : 0; |
| } |
| |
| curr_cbp_ctx = a+2*b; |
| cbp_bit = (cbp > 15 ) ? 1 : 0; |
| biari_encode_symbol(eep_dp, (signed short) cbp_bit, ctx->cbp_contexts[1] + curr_cbp_ctx ); |
| |
| if (cbp > 15) |
| { |
| b = 0; |
| if (currMB->mb_available_up != NULL) |
| { |
| if((currMB->mb_available_up)->mb_type==IPCM) |
| b=1; |
| else |
| if ((currMB->mb_available_up)->cbp > 15) |
| b = (( ((currMB->mb_available_up)->cbp >> 4) == 2) ? 1 : 0); |
| } |
| |
| |
| a = 0; |
| if (currMB->mb_available_left != NULL) |
| { |
| if((currMB->mb_available_left)->mb_type==IPCM) |
| a=1; |
| else |
| if ((currMB->mb_available_left)->cbp > 15) |
| a = (( ((currMB->mb_available_left)->cbp >> 4) == 2) ? 1 : 0); |
| } |
| |
| curr_cbp_ctx = a+2*b; |
| cbp_bit = ((cbp>>4) == 2) ? 1 : 0; |
| biari_encode_symbol(eep_dp, (signed short) cbp_bit, ctx->cbp_contexts[2] + curr_cbp_ctx ); |
| } |
| } |
| |
| dp->bitstream->write_flag = 1; |
| se->len = (arienco_bits_written(eep_dp) - curr_len); |
| CABAC_TRACE; |
| return; |
| } |
| |
| static const int maxpos [] = {16, 15, 64, 32, 32, 16, 4, 15, 8, 16}; |
| static const int c1isdc [] = { 1, 0, 1, 1, 1, 1, 1, 0, 1, 1}; |
| |
| static const int type2ctx_bcbp[] = { 0, 1, 2, 2, 3, 4, 5, 6, 5, 5}; // 7 |
| static const int type2ctx_map [] = { 0, 1, 2, 3, 4, 5, 6, 7, 6, 6}; // 8 |
| static const int type2ctx_last[] = { 0, 1, 2, 3, 4, 5, 6, 7, 6, 6}; // 8 |
| static const int type2ctx_one [] = { 0, 1, 2, 3, 3, 4, 5, 6, 5, 5}; // 7 |
| static const int type2ctx_abs [] = { 0, 1, 2, 3, 3, 4, 5, 6, 5, 5}; // 7 |
| static const int max_c2 [] = { 4, 4, 4, 4, 4, 4, 3, 4, 3, 3}; // 9 |
| |
| |
| |
| /*! |
| **************************************************************************** |
| * \brief |
| * Write CBP4-BIT |
| **************************************************************************** |
| */ |
| void write_and_store_CBP_block_bit (Macroblock* currMB, EncodingEnvironmentPtr eep_dp, int type, int cbp_bit) |
| { |
| #define BIT_SET(x,n) ((int)(((x)&((int64)1<<(n)))>>(n))) |
| |
| int y_ac = (type==LUMA_16AC || type==LUMA_8x8 || type==LUMA_8x4 || type==LUMA_4x8 || type==LUMA_4x4); |
| int y_dc = (type==LUMA_16DC); |
| int u_ac = (type==CHROMA_AC && !img->is_v_block); |
| int v_ac = (type==CHROMA_AC && img->is_v_block); |
| int chroma_dc = (type==CHROMA_DC || type==CHROMA_DC_2x4 || type==CHROMA_DC_4x4); |
| int u_dc = (chroma_dc && !img->is_v_block); |
| int v_dc = (chroma_dc && img->is_v_block); |
| int j = (y_ac || u_ac || v_ac ? img->subblock_y : 0); |
| int i = (y_ac || u_ac || v_ac ? img->subblock_x : 0); |
| int bit = (y_dc ? 0 : y_ac ? 1 : u_dc ? 17 : v_dc ? 18 : u_ac ? 19 : 23); |
| int default_bit = (img->is_intra_block ? 1 : 0); |
| int upper_bit = default_bit; |
| int left_bit = default_bit; |
| int ctx; |
| |
| int bit_pos_a = 0; |
| int bit_pos_b = 0; |
| |
| PixelPos block_a, block_b; |
| |
| if (y_ac || y_dc) |
| { |
| getLuma4x4Neighbour(img->current_mb_nr, (i<<2) - 1, (j << 2), &block_a); |
| getLuma4x4Neighbour(img->current_mb_nr, (i<<2), (j << 2) -1, &block_b); |
| if (y_ac) |
| { |
| if (block_a.available) |
| bit_pos_a = 4*block_a.y + block_a.x; |
| if (block_b.available) |
| bit_pos_b = 4*block_b.y + block_b.x; |
| } |
| } |
| else |
| { |
| getChroma4x4Neighbour(img->current_mb_nr, (i<<2)-1, (j<<2), &block_a); |
| getChroma4x4Neighbour(img->current_mb_nr, (i<<2), (j<<2)-1,&block_b); |
| if (u_ac||v_ac) |
| { |
| if (block_a.available) |
| bit_pos_a = 4*block_a.y + block_a.x; |
| if (block_b.available) |
| bit_pos_b = 4*block_b.y + block_b.x; |
| } |
| } |
| |
| bit = (y_dc ? 0 : y_ac ? 1+4*j+i : u_dc ? 17 : v_dc ? 18 : u_ac ? 19+4*j+i : 35+4*j+i); |
| //--- set bits for current block --- |
| if (cbp_bit) |
| { |
| if (type==LUMA_8x8) |
| { |
| currMB->cbp_bits |= ((int64)1<< bit ); |
| currMB->cbp_bits |= ((int64)1<<(bit+1)); |
| currMB->cbp_bits |= ((int64)1<<(bit+4)); |
| currMB->cbp_bits |= ((int64)1<<(bit+5)); |
| } |
| else if (type==LUMA_8x4) |
| { |
| currMB->cbp_bits |= ((int64)1<< bit ); |
| currMB->cbp_bits |= ((int64)1<<(bit+1)); |
| } |
| else if (type==LUMA_4x8) |
| { |
| currMB->cbp_bits |= ((int64)1<< bit ); |
| currMB->cbp_bits |= ((int64)1<<(bit+4)); |
| } |
| else |
| { |
| currMB->cbp_bits |= ((int64)1<<bit); |
| } |
| } |
| |
| bit = (y_dc ? 0 : y_ac ? 1 : u_dc ? 17 : v_dc ? 18 : u_ac ? 19 : 35); |
| if (type!=LUMA_8x8) |
| { |
| if (block_b.available) |
| { |
| if(img->mb_data[block_b.mb_addr].mb_type==IPCM) |
| upper_bit=1; |
| else |
| upper_bit = BIT_SET(img->mb_data[block_b.mb_addr].cbp_bits,bit+bit_pos_b); |
| } |
| |
| |
| if (block_a.available) |
| { |
| if(img->mb_data[block_a.mb_addr].mb_type==IPCM) |
| left_bit=1; |
| else |
| left_bit = BIT_SET(img->mb_data[block_a.mb_addr].cbp_bits,bit+bit_pos_a); |
| } |
| |
| ctx = 2*upper_bit+left_bit; |
| |
| //===== encode symbol ===== |
| biari_encode_symbol (eep_dp, (short)cbp_bit, img->currentSlice->tex_ctx->bcbp_contexts[type2ctx_bcbp[type]]+ctx); |
| } |
| } |
| |
| |
| |
| |
| //===== position -> ctx for MAP ===== |
| //--- zig-zag scan ---- |
| static const int pos2ctx_map8x8 [] = { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, |
| 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9, 10, 9, 8, 7, |
| 7, 6, 11, 12, 13, 11, 6, 7, 8, 9, 14, 10, 9, 8, 6, 11, |
| 12, 13, 11, 6, 9, 14, 10, 9, 11, 12, 13, 11 ,14, 10, 12, 14}; // 15 CTX |
| static const int pos2ctx_map8x4 [] = { 0, 1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 9, 8, 6, 7, 8, |
| 9, 10, 11, 9, 8, 6, 12, 8, 9, 10, 11, 9, 13, 13, 14, 14}; // 15 CTX |
| static const int pos2ctx_map4x4 [] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 14}; // 15 CTX |
| static const int pos2ctx_map2x4c[] = { 0, 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}; // 15 CTX |
| static const int pos2ctx_map4x4c[] = { 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2}; // 15 CTX |
| static const int* pos2ctx_map [] = {pos2ctx_map4x4, pos2ctx_map4x4, pos2ctx_map8x8, pos2ctx_map8x4, |
| pos2ctx_map8x4, pos2ctx_map4x4, pos2ctx_map4x4, pos2ctx_map4x4, |
| pos2ctx_map2x4c, pos2ctx_map4x4c}; |
| |
| //--- interlace scan ---- |
| //Taken from ABT |
| static const int pos2ctx_map8x8i[] = { 0, 1, 1, 2, 2, 3, 3, 4, 5, 6, 7, 7, 7, 8, 4, 5, |
| 6, 9, 10, 10, 8, 11, 12, 11, 9, 9, 10, 10, 8, 11, 12, 11, |
| 9, 9, 10, 10, 8, 11, 12, 11, 9, 9, 10, 10, 8, 13, 13, 9, |
| 9, 10, 10, 8, 13, 13, 9, 9, 10, 10, 14, 14, 14, 14, 14, 14}; // 15 CTX |
| |
| static const int pos2ctx_map8x4i[] = { 0, 1, 2, 3, 4, 5, 6, 3, 4, 5, 6, 3, 4, 7, 6, 8, |
| 9, 7, 6, 8, 9, 10, 11, 12, 12, 10, 11, 13, 13, 14, 14, 14}; // 15 CTX |
| static const int pos2ctx_map4x8i[] = { 0, 1, 1, 1, 2, 3, 3, 4, 4, 4, 5, 6, 2, 7, 7, 8, |
| 8, 8, 5, 6, 9, 10, 10, 11, 11, 11, 12, 13, 13, 14, 14, 14}; // 15 CTX |
| static const int* pos2ctx_map_int[] = {pos2ctx_map4x4, pos2ctx_map4x4, pos2ctx_map8x8i,pos2ctx_map8x4i, |
| pos2ctx_map4x8i,pos2ctx_map4x4, pos2ctx_map4x4, pos2ctx_map4x4, |
| pos2ctx_map2x4c, pos2ctx_map4x4c}; |
| |
| |
| //===== position -> ctx for LAST ===== |
| static const int pos2ctx_last8x8 [] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
| 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
| 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, |
| 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8}; // 9 CTX |
| static const int pos2ctx_last8x4 [] = { 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, |
| 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8}; // 9 CTX |
| static const int pos2ctx_last4x4 [] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; // 15 CTX |
| static const int pos2ctx_last2x4c[] = { 0, 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}; // 15 CTX |
| static const int pos2ctx_last4x4c[] = { 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2}; // 15 CTX |
| static const int* pos2ctx_last [] = {pos2ctx_last4x4, pos2ctx_last4x4, pos2ctx_last8x8, pos2ctx_last8x4, |
| pos2ctx_last8x4, pos2ctx_last4x4, pos2ctx_last4x4, pos2ctx_last4x4, |
| pos2ctx_last2x4c, pos2ctx_last4x4c}; |
| |
| |
| |
| |
| /*! |
| **************************************************************************** |
| * \brief |
| * Write Significance MAP |
| **************************************************************************** |
| */ |
| void write_significance_map (Macroblock* currMB, EncodingEnvironmentPtr eep_dp, int type, int coeff[], int coeff_ctr) |
| { |
| int k; |
| unsigned short sig, last; |
| int k0 = 0; |
| int k1 = maxpos[type]-1; |
| TextureInfoContexts* tex_ctx = img->currentSlice->tex_ctx; |
| |
| int fld = ( img->structure!=FRAME || currMB->mb_field ); |
| BiContextTypePtr map_ctx = ( fld |
| ? tex_ctx->fld_map_contexts[type2ctx_map [type]] |
| : tex_ctx->map_contexts[type2ctx_map [type]] ); |
| BiContextTypePtr last_ctx = ( fld |
| ? tex_ctx->fld_last_contexts[type2ctx_last[type]] |
| : tex_ctx->last_contexts[type2ctx_last[type]] ); |
| |
| if (!c1isdc[type]) |
| { |
| k0++; k1++; coeff--; |
| } |
| |
| if (!fld) |
| { |
| for (k=k0; k<k1; k++) // if last coeff is reached, it has to be significant |
| { |
| sig = (coeff[k] != 0); |
| biari_encode_symbol (eep_dp, sig, map_ctx + pos2ctx_map [type][k]); |
| if (sig) |
| { |
| last = (--coeff_ctr == 0); |
| |
| biari_encode_symbol(eep_dp, last, last_ctx + pos2ctx_last[type][k]); |
| if (last) return; |
| } |
| } |
| return; |
| } |
| else |
| { |
| for (k=k0; k<k1; k++) // if last coeff is reached, it has to be significant |
| { |
| sig = (coeff[k] != 0); |
| |
| biari_encode_symbol (eep_dp, sig, map_ctx + pos2ctx_map_int [type][k]); |
| if (sig) |
| { |
| last = (--coeff_ctr == 0); |
| |
| biari_encode_symbol(eep_dp, last, last_ctx + pos2ctx_last[type][k]); |
| if (last) return; |
| } |
| } |
| } |
| } |
| |
| |
| /*! |
| **************************************************************************** |
| * \brief |
| * Write Levels |
| **************************************************************************** |
| */ |
| void write_significant_coefficients (Macroblock* currMB, EncodingEnvironmentPtr eep_dp, int type, int coeff[]) |
| { |
| int i; |
| int absLevel; |
| int ctx; |
| short sign; |
| short greater_one; |
| int c1 = 1; |
| int c2 = 0; |
| |
| for (i=maxpos[type]-1; i>=0; i--) |
| { |
| if (coeff[i]!=0) |
| { |
| if (coeff[i]>0) {absLevel = coeff[i]; sign = 0;} |
| else {absLevel = -coeff[i]; sign = 1;} |
| |
| greater_one = (absLevel>1); |
| |
| //--- if coefficient is one --- |
| ctx = imin(c1,4); |
| biari_encode_symbol (eep_dp, greater_one, img->currentSlice->tex_ctx->one_contexts[type2ctx_one[type]] + ctx); |
| |
| if (greater_one) |
| { |
| ctx = imin(c2, max_c2[type]); |
| unary_exp_golomb_level_encode(eep_dp, absLevel-2, img->currentSlice->tex_ctx->abs_contexts[type2ctx_abs[type]] + ctx); |
| c1 = 0; |
| c2++; |
| } |
| else if (c1) |
| { |
| c1++; |
| } |
| biari_encode_symbol_eq_prob (eep_dp, sign); |
| } |
| } |
| } |
| |
| |
| |
| /*! |
| **************************************************************************** |
| * \brief |
| * Write Block-Transform Coefficients |
| **************************************************************************** |
| */ |
| void writeRunLevel_CABAC (SyntaxElement *se, DataPartition *dp) |
| { |
| EncodingEnvironmentPtr eep_dp = &(dp->ee_cabac); |
| int curr_len = arienco_bits_written(eep_dp); |
| static int coeff[64]; |
| static int coeff_ctr = 0; |
| static int pos = 0; |
| |
| //--- accumulate run-level information --- |
| if (se->value1 != 0) |
| { |
| pos += se->value2; |
| coeff[pos++] = se->value1; |
| coeff_ctr++; |
| //return; |
| } |
| else |
| { |
| Macroblock* currMB = &img->mb_data[img->current_mb_nr]; |
| //===== encode CBP-BIT ===== |
| if (coeff_ctr>0) |
| { |
| write_and_store_CBP_block_bit (currMB, eep_dp, se->context, 1); |
| //===== encode significance map ===== |
| write_significance_map (currMB, eep_dp, se->context, coeff, coeff_ctr); |
| //===== encode significant coefficients ===== |
| write_significant_coefficients (currMB, eep_dp, se->context, coeff); |
| } |
| else |
| write_and_store_CBP_block_bit (currMB, eep_dp, se->context, 0); |
| |
| //--- reset counters --- |
| pos = coeff_ctr = 0; |
| memset(coeff, 0 , 64 * sizeof(int)); |
| } |
| |
| dp->bitstream->write_flag = 1; |
| se->len = (arienco_bits_written(eep_dp) - curr_len); |
| CABAC_TRACE; |
| return; |
| } |
| |
| |
| |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Unary binarization and encoding of a symbol by using |
| * one or two distinct models for the first two and all |
| * remaining bins |
| * |
| ************************************************************************/ |
| void unary_bin_encode(EncodingEnvironmentPtr eep_dp, |
| unsigned int symbol, |
| BiContextTypePtr ctx, |
| int ctx_offset) |
| { |
| unsigned int l; |
| BiContextTypePtr ictx; |
| |
| if (symbol==0) |
| { |
| biari_encode_symbol(eep_dp, 0, ctx ); |
| return; |
| } |
| else |
| { |
| biari_encode_symbol(eep_dp, 1, ctx ); |
| l = symbol; |
| ictx = ctx+ctx_offset; |
| while ((--l)>0) |
| biari_encode_symbol(eep_dp, 1, ictx); |
| biari_encode_symbol(eep_dp, 0, ictx); |
| } |
| return; |
| } |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Unary binarization and encoding of a symbol by using |
| * one or two distinct models for the first two and all |
| * remaining bins; no terminating "0" for max_symbol |
| * (finite symbol alphabet) |
| ************************************************************************ |
| */ |
| void unary_bin_max_encode(EncodingEnvironmentPtr eep_dp, |
| unsigned int symbol, |
| BiContextTypePtr ctx, |
| int ctx_offset, |
| unsigned int max_symbol) |
| { |
| unsigned int l; |
| BiContextTypePtr ictx; |
| |
| if (symbol==0) |
| { |
| biari_encode_symbol(eep_dp, 0, ctx ); |
| return; |
| } |
| else |
| { |
| biari_encode_symbol(eep_dp, 1, ctx ); |
| l=symbol; |
| ictx=ctx+ctx_offset; |
| while ((--l)>0) |
| biari_encode_symbol(eep_dp, 1, ictx); |
| if (symbol<max_symbol) |
| biari_encode_symbol(eep_dp, 0, ictx); |
| } |
| return; |
| } |
| |
| |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Exp Golomb binarization and encoding |
| ************************************************************************ |
| */ |
| void exp_golomb_encode_eq_prob( EncodingEnvironmentPtr eep_dp, |
| unsigned int symbol, |
| int k) |
| { |
| while(1) |
| { |
| if (symbol >= (unsigned int)(1<<k)) |
| { |
| biari_encode_symbol_eq_prob(eep_dp, 1); //first unary part |
| symbol = symbol - (1<<k); |
| k++; |
| } |
| else |
| { |
| biari_encode_symbol_eq_prob(eep_dp, 0); //now terminated zero of unary part |
| while (k--) //next binary part |
| biari_encode_symbol_eq_prob(eep_dp, (signed short)((symbol>>k)&1)); |
| break; |
| } |
| } |
| |
| return; |
| } |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Exp-Golomb for Level Encoding |
| * |
| ************************************************************************/ |
| void unary_exp_golomb_level_encode( EncodingEnvironmentPtr eep_dp, |
| unsigned int symbol, |
| BiContextTypePtr ctx) |
| { |
| unsigned int l,k; |
| unsigned int exp_start = 13; // 15-2 : 0,1 level decision always sent |
| |
| if (symbol==0) |
| { |
| biari_encode_symbol(eep_dp, 0, ctx ); |
| return; |
| } |
| else |
| { |
| biari_encode_symbol(eep_dp, 1, ctx ); |
| l=symbol; |
| k=1; |
| while (((--l)>0) && (++k <= exp_start)) |
| biari_encode_symbol(eep_dp, 1, ctx); |
| if (symbol < exp_start) biari_encode_symbol(eep_dp, 0, ctx); |
| else exp_golomb_encode_eq_prob(eep_dp,symbol-exp_start,0); |
| } |
| return; |
| } |
| |
| |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Exp-Golomb for MV Encoding |
| * |
| ************************************************************************/ |
| void unary_exp_golomb_mv_encode(EncodingEnvironmentPtr eep_dp, |
| unsigned int symbol, |
| BiContextTypePtr ctx, |
| unsigned int max_bin) |
| { |
| unsigned int l,k; |
| unsigned int bin=1; |
| BiContextTypePtr ictx=ctx; |
| unsigned int exp_start = 8; // 9-1 : 0 mvd decision always sent |
| |
| if (symbol==0) |
| { |
| biari_encode_symbol(eep_dp, 0, ictx ); |
| return; |
| } |
| else |
| { |
| biari_encode_symbol(eep_dp, 1, ictx ); |
| l=symbol; |
| k=1; |
| ictx++; |
| while (((--l)>0) && (++k <= exp_start)) |
| { |
| biari_encode_symbol(eep_dp, 1, ictx ); |
| if ((++bin)==2) ictx++; |
| if (bin==max_bin) ictx++; |
| } |
| if (symbol < exp_start) biari_encode_symbol(eep_dp, 0, ictx); |
| else exp_golomb_encode_eq_prob(eep_dp,symbol-exp_start,3); |
| } |
| return; |
| } |
| |
