| |
| /*! |
| ************************************************************************************** |
| * \file |
| * slice.c |
| * \brief |
| * generate the slice header, setup the bit buffer for slices, |
| * and generates the slice NALU(s) |
| |
| * \author |
| * Main contributors (see contributors.h for copyright, address and affiliation details) |
| * - Thomas Stockhammer <stockhammer@ei.tum.de> |
| * - Detlev Marpe <marpe@hhi.de> |
| * - Stephan Wenger <stewe@cs.tu-berlin.de> |
| * - Alexis Michael Tourapis <alexismt@ieee.org> |
| *************************************************************************************** |
| */ |
| |
| #include "contributors.h" |
| |
| #include <stdlib.h> |
| #include <assert.h> |
| #include <math.h> |
| #include <float.h> |
| |
| #include "global.h" |
| #include "header.h" |
| #include "rtp.h" |
| #include "fmo.h" |
| #include "vlc.h" |
| #include "image.h" |
| #include "cabac.h" |
| #include "elements.h" |
| #include "me_epzs.h" |
| #include "ratectl.h" |
| #include "rc_quadratic.h" |
| #include "macroblock.h" |
| #include "symbol.h" |
| |
| // Local declarations |
| static Slice *malloc_slice(); |
| static void free_slice(Slice *slice); |
| static void init_slice(int start_mb_addr); |
| static void set_ref_pic_num(); |
| extern ColocatedParams *Co_located; |
| extern StorablePicture **listX[6]; |
| void poc_ref_pic_reorder(StorablePicture **list, unsigned num_ref_idx_lX_active, int *reordering_of_pic_nums_idc, int *abs_diff_pic_num_minus1, int *long_term_pic_idx, int list_no); |
| void SetLagrangianMultipliers(); |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * init_ref_pic_list_reordering initializations should go here |
| ************************************************************************ |
| */ |
| void init_ref_pic_list_reordering() |
| { |
| Slice* currSlice = img->currentSlice; |
| |
| currSlice->ref_pic_list_reordering_flag_l0 = 0; |
| currSlice->ref_pic_list_reordering_flag_l1 = 0; |
| } |
| |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * This function generates the slice (and partition) header(s) |
| * |
| * \return number of bits used for the slice (and partition) header(s) |
| * |
| * \par Side effects: |
| * Adds slice/partition header symbols to the symbol buffer |
| * increments Picture->no_slices, allocates memory for the |
| * slice, sets img->currSlice |
| ************************************************************************ |
| */ |
| int start_slice() |
| { |
| EncodingEnvironmentPtr eep; |
| Slice *currSlice = img->currentSlice; |
| Bitstream *currStream; |
| int header_len = 0; |
| int i; |
| int NumberOfPartitions = (input->partition_mode == PAR_DP_1?1:3); |
| |
| //one partition for IDR img |
| if(img->currentPicture->idr_flag) |
| { |
| NumberOfPartitions = 1; |
| } |
| |
| RTPUpdateTimestamp (img->tr); // this has no side effects, just leave it for all NALs |
| |
| for (i=0; i<NumberOfPartitions; i++) |
| { |
| currStream = (currSlice->partArr[i]).bitstream; |
| |
| currStream->write_flag = 0; |
| if (i==0) // First partition |
| header_len += SliceHeader (0); |
| else // Second/Third partition |
| header_len += Partition_BC_Header(i); |
| |
| //! Initialize CABAC |
| if (input->symbol_mode == CABAC) |
| { |
| eep = &((currSlice->partArr[i]).ee_cabac); |
| if (currStream->bits_to_go != 8) |
| header_len+=currStream->bits_to_go; |
| writeVlcByteAlign(currStream); |
| arienco_start_encoding(eep, currStream->streamBuffer, &(currStream->byte_pos)); |
| cabac_new_slice(); |
| } |
| else |
| { |
| // Initialize CA-VLC |
| CAVLC_init(); |
| } |
| } |
| if(input->symbol_mode == CABAC) |
| { |
| init_contexts(); |
| } |
| return header_len; |
| } |
| |
| |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * This function terminates a slice (but doesn't write it out), |
| * the old terminate_slice (0) |
| * \return |
| * 0 if OK, \n |
| * 1 in case of error |
| * |
| ************************************************************************ |
| */ |
| int terminate_slice(int lastslice) |
| { |
| static int MbWidthC [4]= { 0, 8, 8, 16}; |
| static int MbHeightC [4]= { 0, 8, 16, 16}; |
| |
| int bytes_written; |
| Bitstream *currStream; |
| Slice *currSlice = img->currentSlice; |
| EncodingEnvironmentPtr eep; |
| int i; |
| int byte_pos_before_startcode_emu_prevention; |
| int min_num_bytes=0; |
| int stuffing_bytes=0; |
| int RawMbBits; |
| |
| if (input->symbol_mode == CABAC) |
| write_terminating_bit (1); // only once, not for all partitions |
| |
| for (i=0; i<currSlice->max_part_nr; i++) |
| { |
| currStream = (currSlice->partArr[i]).bitstream; |
| if (input->symbol_mode == UVLC) |
| { |
| SODBtoRBSP(currStream); |
| byte_pos_before_startcode_emu_prevention = currStream->byte_pos; |
| currStream->byte_pos = RBSPtoEBSP(currStream->streamBuffer, 0 , currStream->byte_pos, 0); |
| *(stats->em_prev_bits) += (currStream->byte_pos - byte_pos_before_startcode_emu_prevention) * 8; |
| } |
| else // CABAC |
| { |
| eep = &((currSlice->partArr[i]).ee_cabac); |
| // terminate the arithmetic code |
| arienco_done_encoding(eep); |
| currStream->bits_to_go = eep->Ebits_to_go; |
| currStream->byte_buf = 0; |
| bytes_written = currStream->byte_pos; |
| img->bytes_in_picture += currStream->byte_pos; |
| |
| byte_pos_before_startcode_emu_prevention= currStream->byte_pos; |
| if (lastslice && i==((currSlice->max_part_nr-1))) |
| { |
| RawMbBits = 256 * img->bitdepth_luma + 2 * MbWidthC[active_sps->chroma_format_idc] * MbHeightC[active_sps->chroma_format_idc] * img->bitdepth_chroma; |
| min_num_bytes = ((96 * get_pic_bin_count()) - (RawMbBits * (int)img->PicSizeInMbs *3) + 1023) / 1024; |
| if (min_num_bytes>img->bytes_in_picture) |
| { |
| stuffing_bytes = min_num_bytes - img->bytes_in_picture; |
| printf ("CABAC stuffing words = %6d\n", stuffing_bytes/3); |
| } |
| } |
| |
| // printf ("bytepos: %d\n", currStream->byte_pos); |
| currStream->byte_pos = RBSPtoEBSP(currStream->streamBuffer, 0, currStream->byte_pos, currStream->byte_pos + stuffing_bytes); |
| *(stats->em_prev_bits) += (currStream->byte_pos - byte_pos_before_startcode_emu_prevention) * 8; |
| } // CABAC |
| } // partition loop |
| if( input->symbol_mode == CABAC ) |
| { |
| store_contexts(); |
| } |
| |
| if (img->type != I_SLICE || img->type != SI_SLICE) |
| free_ref_pic_list_reordering_buffer (currSlice); |
| return 0; |
| } |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Encodes one slice |
| * \par |
| * returns the number of coded MBs in the SLice |
| ************************************************************************ |
| */ |
| int encode_one_slice (int SliceGroupId, Picture *pic, int TotalCodedMBs) |
| { |
| Boolean end_of_slice = FALSE; |
| Boolean recode_macroblock; |
| int len; |
| int NumberOfCodedMBs = 0; |
| int CurrentMbAddr; |
| double FrameRDCost = DBL_MAX, FieldRDCost = DBL_MAX; |
| |
| img->cod_counter = 0; |
| |
| CurrentMbAddr = FmoGetFirstMacroblockInSlice (SliceGroupId); |
| // printf ("\n\nEncode_one_slice: PictureID %d SliceGroupId %d SliceID %d FirstMB %d \n", img->tr, SliceGroupId, img->current_slice_nr, CurrentMbInScanOrder); |
| |
| init_slice (CurrentMbAddr); |
| Bytes_After_Header = img->currentSlice->partArr[0].bitstream->byte_pos; |
| |
| SetLagrangianMultipliers(); |
| |
| if (input->symbol_mode==CABAC) |
| { |
| SetCtxModelNumber (); |
| } |
| |
| img->checkref = (input->rdopt && input->RestrictRef && (img->type==P_SLICE || img->type==SP_SLICE)); |
| |
| /* |
| // Tian Dong: June 7, 2002 JVT-B042 |
| // When the pictures are put into different layers and subseq, not all the reference frames |
| // in multi-frame buffer are valid for prediction. The acutual number of the valid reference |
| // frames, fb->num_short_used, will be given by start_slice(sym). |
| // Save the fb->short_used. |
| if (input->NumFramesInELSubSeq) |
| { |
| short_used = fb->short_used; |
| } |
| */ |
| |
| len = start_slice (); |
| |
| // Rate control |
| if (input->RCEnable) |
| { |
| generic_RC->NumberofHeaderBits +=len; |
| |
| // basic unit layer rate control |
| if(img->BasicUnit < img->FrameSizeInMbs) |
| generic_RC->NumberofBasicUnitHeaderBits +=len; |
| } |
| // printf("short size, used, num-used: (%d,%d,%d)\n", fb->short_size, fb->short_used, fb->num_short_used); |
| |
| /* |
| // Tian Dong: June 7, 2002 JVT-B042 |
| if (input->NumFramesInELSubSeq) |
| { |
| fb->short_used = fb->num_short_used; |
| } |
| */ |
| // Update statistics |
| stats->bit_slice += len; |
| stats->bit_use_header[img->type] += len; |
| // printf ("\n\n"); |
| |
| while (end_of_slice == FALSE) // loop over macroblocks |
| { |
| if (img->AdaptiveRounding && input->AdaptRndPeriod && (img->current_mb_nr % input->AdaptRndPeriod == 0)) |
| { |
| CalculateOffsetParam(); |
| |
| if(input->Transform8x8Mode) |
| { |
| CalculateOffset8Param(); |
| } |
| } |
| |
| //sw paff |
| if (!img->MbaffFrameFlag) |
| { |
| recode_macroblock = FALSE; |
| rdopt = &rddata_top_frame_mb; // store data in top frame MB |
| |
| start_macroblock (CurrentMbAddr, FALSE); |
| encode_one_macroblock (); |
| |
| write_one_macroblock (1); |
| |
| terminate_macroblock (&end_of_slice, &recode_macroblock); |
| |
| // printf ("encode_one_slice: mb %d, slice %d, bitbuf bytepos %d EOS %d\n", |
| // img->current_mb_nr, img->current_slice_nr, |
| // img->currentSlice->partArr[0].bitstream->byte_pos, end_of_slice); |
| |
| if (recode_macroblock == FALSE) // The final processing of the macroblock has been done |
| { |
| CurrentMbAddr = FmoGetNextMBNr (CurrentMbAddr); |
| if (CurrentMbAddr == -1) // end of slice |
| { |
| // printf ("FMO End of Slice Group detected, current MBs %d, force end of slice\n", NumberOfCodedMBs+1); |
| end_of_slice = TRUE; |
| } |
| NumberOfCodedMBs++; // only here we are sure that the coded MB is actually included in the slice |
| proceed2nextMacroblock (); |
| } |
| else |
| { |
| //!Go back to the previous MB to recode it |
| img->current_mb_nr = FmoGetPreviousMBNr(img->current_mb_nr); |
| if(img->current_mb_nr == -1 ) // The first MB of the slice group is too big, |
| // which means it's impossible to encode picture using current slice bits restriction |
| { |
| snprintf (errortext, ET_SIZE, "Error encoding first MB with specified parameter, bits of current MB may be too big"); |
| error (errortext, 300); |
| } |
| } |
| } |
| else // TBD -- Addition of FMO |
| { |
| |
| //! This following ugly code breaks slices, at least for a slice mode that accumulates a certain |
| //! number of bits into one slice. |
| //! The suggested algorithm is as follows: |
| //! |
| //! SaveState (Bitstream, stats, etc. etc.); |
| //! BitsForThisMBPairInFrameMode = CodeMB (Upper, FRAME_MODE) + CodeMB (Lower, FRAME_MODE); |
| //! DistortionForThisMBPairInFrameMode = CalculateDistortion(Upper) + CalculateDistortion (Lower); |
| //! RestoreState(); |
| //! BitsForThisMBPairInFieldMode = CodeMB (Upper, FIELD_MODE) + CodeMB (Lower, FIELD_MODE); |
| //! DistortionForThisMBPairInFrameMode = CalculateDistortion(Upper) + CalculateDistortion (Lower); |
| //! FrameFieldMode = Decision (...) |
| //! RestoreState() |
| //! if (FrameFieldMode == FRAME) { |
| //! CodeMB (Upper, FRAME); CodeMB (Lower, FRAME); |
| //! } else { |
| //! CodeMB (Upper FIELD); CodeMB (Lower, FIELD); |
| //! } |
| //! |
| //! Open questions/issues: |
| //! 1. CABAC/CA-VLC state: It seems that the CABAC/CA_VLC states are changed during the |
| //! dummy encoding processes (for the R-D based selection), but that they are never |
| //! reset, once the selection is made. I believe that this breaks the MB-adaptive |
| //! frame/field coding. The necessary code for the state saves is readily available |
| //! in macroblock.c, start_macroblock() and terminate_macroblock() (this code needs |
| //! to be double checked that it works with CA-VLC as well |
| //! 2. would it be an option to allocate Bitstreams with zero data in them (or copy the |
| //! already generated bitstream) for the "test coding"? |
| |
| img->write_macroblock = 0; |
| if (input->MbInterlace == ADAPTIVE_CODING || input->MbInterlace == FRAME_MB_PAIR_CODING) |
| { |
| //================ code MB pair as frame MB ================ |
| //---------------------------------------------------------- |
| recode_macroblock = FALSE; |
| |
| img->field_mode = 0; // MB coded as frame |
| img->top_field = 0; // Set top field to 0 |
| |
| //Rate control |
| img->write_macroblock = 0; |
| img->bot_MB = 0; |
| |
| // save RC state only when it is going to change |
| if ( input->RCEnable && input->MbInterlace == ADAPTIVE_CODING |
| && img->NumberofCodedMacroBlocks > 0 && (img->NumberofCodedMacroBlocks % img->BasicUnit) == 0 ) |
| copy_rc_jvt( quadratic_RC_init, quadratic_RC ); // save initial RC status |
| |
| if ( input->RCEnable && input->MbInterlace == ADAPTIVE_CODING ) |
| copy_rc_generic( generic_RC_init, generic_RC ); // save initial RC status |
| |
| start_macroblock (CurrentMbAddr, FALSE); |
| |
| rdopt = &rddata_top_frame_mb; // store data in top frame MB |
| encode_one_macroblock (); // code the MB as frame |
| |
| FrameRDCost = rdopt->min_rdcost; |
| //*** Top MB coded as frame MB ***// |
| |
| //Rate control |
| img->bot_MB = 1; //for Rate control |
| |
| // go to the bottom MB in the MB pair |
| img->field_mode = 0; // MB coded as frame //GB |
| |
| start_macroblock (CurrentMbAddr+1, FALSE); |
| rdopt = &rddata_bot_frame_mb; // store data in top frame MB |
| encode_one_macroblock (); // code the MB as frame |
| |
| if ( input->RCEnable && input->MbInterlace == ADAPTIVE_CODING |
| && img->NumberofCodedMacroBlocks > 0 && (img->NumberofCodedMacroBlocks % img->BasicUnit) == 0 ) |
| copy_rc_jvt( quadratic_RC_best, quadratic_RC ); // restore initial RC status |
| |
| if (input->RCEnable && input->MbInterlace == ADAPTIVE_CODING ) |
| copy_rc_generic( generic_RC_best, generic_RC ); // save frame RC stats |
| |
| FrameRDCost += rdopt->min_rdcost; |
| |
| //*** Bottom MB coded as frame MB ***// |
| } |
| |
| if ((input->MbInterlace == ADAPTIVE_CODING) || (input->MbInterlace == FIELD_CODING)) |
| { |
| //Rate control |
| img->bot_MB = 0; |
| |
| //=========== start coding the MB pair as a field MB pair ============= |
| //--------------------------------------------------------------------- |
| img->field_mode = 1; // MB coded as field |
| img->top_field = 1; // Set top field to 1 |
| img->buf_cycle <<= 1; |
| input->num_ref_frames <<= 1; |
| img->num_ref_idx_l0_active <<= 1; |
| img->num_ref_idx_l0_active += 1; |
| |
| if ( input->RCEnable && input->MbInterlace == ADAPTIVE_CODING |
| && img->NumberofCodedMacroBlocks > 0 && (img->NumberofCodedMacroBlocks % img->BasicUnit) == 0 ) |
| copy_rc_jvt( quadratic_RC, quadratic_RC_init ); // restore initial RC status |
| |
| if ( input->RCEnable && input->MbInterlace == ADAPTIVE_CODING ) |
| copy_rc_generic( generic_RC, generic_RC_init ); // reset RC stats |
| |
| start_macroblock (CurrentMbAddr, TRUE); |
| |
| rdopt = &rddata_top_field_mb; // store data in top frame MB |
| // TopFieldIsSkipped = 0; // set the top field MB skipped flag to 0 |
| encode_one_macroblock (); // code the MB as field |
| |
| FieldRDCost = rdopt->min_rdcost; |
| //*** Top MB coded as field MB ***// |
| //Rate control |
| img->bot_MB = 1;//for Rate control |
| |
| img->top_field = 0; // Set top field to 0 |
| start_macroblock (CurrentMbAddr+1, TRUE); |
| rdopt = &rddata_bot_field_mb; // store data in top frame MB |
| encode_one_macroblock (); // code the MB as field |
| |
| FieldRDCost += rdopt->min_rdcost; |
| //*** Bottom MB coded as field MB ***// |
| } |
| |
| //Rate control |
| img->write_mbaff_frame = 0; //Rate control |
| |
| //=========== decide between frame/field MB pair ============ |
| //----------------------------------------------------------- |
| if ( ((input->MbInterlace == ADAPTIVE_CODING) && (FrameRDCost < FieldRDCost)) || input->MbInterlace == FRAME_MB_PAIR_CODING ) |
| { |
| img->field_mode = 0; |
| MBPairIsField = 0; |
| if ( input->MbInterlace != FRAME_MB_PAIR_CODING ) |
| { |
| img->buf_cycle >>= 1; |
| input->num_ref_frames >>= 1; |
| img->num_ref_idx_l0_active -= 1; |
| img->num_ref_idx_l0_active >>= 1; |
| } |
| |
| if ( input->RCEnable && input->MbInterlace == ADAPTIVE_CODING |
| && img->NumberofCodedMacroBlocks > 0 && (img->NumberofCodedMacroBlocks % img->BasicUnit) == 0 ) |
| copy_rc_jvt( quadratic_RC, quadratic_RC_best ); // restore initial RC status |
| |
| if ( input->RCEnable && input->MbInterlace == ADAPTIVE_CODING ) |
| copy_rc_generic( generic_RC, generic_RC_best ); // restore frame RC stats |
| |
| //Rate control |
| img->write_mbaff_frame = 1; //for Rate control |
| } |
| else |
| { |
| img->field_mode = 1; |
| MBPairIsField = 1; |
| } |
| |
| //Rate control |
| img->write_macroblock = 1;//Rate control |
| |
| if (MBPairIsField) |
| img->top_field = 1; |
| else |
| img->top_field = 0; |
| |
| //Rate control |
| img->bot_MB = 0;// for Rate control |
| |
| // go back to the Top MB in the MB pair |
| start_macroblock (CurrentMbAddr, img->field_mode); |
| |
| rdopt = img->field_mode ? &rddata_top_field_mb : &rddata_top_frame_mb; |
| copy_rdopt_data (0); // copy the MB data for Top MB from the temp buffers |
| write_one_macroblock (1); // write the Top MB data to the bitstream |
| terminate_macroblock (&end_of_slice, &recode_macroblock); // done coding the Top MB |
| |
| if (recode_macroblock == FALSE) // The final processing of the macroblock has been done |
| { |
| CurrentMbAddr = FmoGetNextMBNr (CurrentMbAddr); |
| if (CurrentMbAddr == -1) // end of slice |
| { |
| end_of_slice = TRUE; |
| } |
| NumberOfCodedMBs++; // only here we are sure that the coded MB is actually included in the slice |
| proceed2nextMacroblock (); |
| |
| |
| //Rate control |
| img->bot_MB = 1;//for Rate control |
| // go to the Bottom MB in the MB pair |
| img->top_field = 0; |
| start_macroblock (CurrentMbAddr, img->field_mode); |
| |
| rdopt = img->field_mode ? &rddata_bot_field_mb : &rddata_bot_frame_mb; |
| copy_rdopt_data (1); // copy the MB data for Bottom MB from the temp buffers |
| |
| write_one_macroblock (0); // write the Bottom MB data to the bitstream |
| terminate_macroblock (&end_of_slice, &recode_macroblock); // done coding the Top MB |
| if (recode_macroblock == FALSE) // The final processing of the macroblock has been done |
| { |
| CurrentMbAddr = FmoGetNextMBNr (CurrentMbAddr); |
| if (CurrentMbAddr == -1) // end of slice |
| { |
| end_of_slice = TRUE; |
| } |
| NumberOfCodedMBs++; // only here we are sure that the coded MB is actually included in the slice |
| proceed2nextMacroblock (); |
| } |
| else |
| { |
| //Go back to the beginning of the macroblock pair to recode it |
| img->current_mb_nr = FmoGetPreviousMBNr(img->current_mb_nr); |
| img->current_mb_nr = FmoGetPreviousMBNr(img->current_mb_nr); |
| if(img->current_mb_nr == -1 ) // The first MB of the slice group is too big, |
| // which means it's impossible to encode picture using current slice bits restriction |
| { |
| snprintf (errortext, ET_SIZE, "Error encoding first MB with specified parameter, bits of current MB may be too big"); |
| error (errortext, 300); |
| } |
| } |
| } |
| else |
| { |
| //!Go back to the previous MB to recode it |
| img->current_mb_nr = FmoGetPreviousMBNr(img->current_mb_nr); |
| if(img->current_mb_nr == -1 ) // The first MB of the slice group is too big, |
| // which means it's impossible to encode picture using current slice bits restriction |
| { |
| snprintf (errortext, ET_SIZE, "Error encoding first MB with specified parameter, bits of current MB may be too big"); |
| error (errortext, 300); |
| } |
| } |
| |
| if (MBPairIsField) // if MB Pair was coded as field the buffer size variables back to frame mode |
| { |
| img->buf_cycle >>= 1; |
| input->num_ref_frames >>= 1; |
| img->num_ref_idx_l0_active -= 1; |
| img->num_ref_idx_l0_active >>= 1; |
| } |
| |
| img->field_mode = img->top_field = 0; // reset to frame mode |
| |
| if ( !end_of_slice ) |
| { |
| assert( CurrentMbAddr < (int)img->PicSizeInMbs ); |
| assert( CurrentMbAddr >= 0 ); |
| if (CurrentMbAddr == FmoGetLastCodedMBOfSliceGroup (FmoMB2SliceGroup (CurrentMbAddr))) |
| end_of_slice = TRUE; // just in case it doesn't get set in terminate_macroblock |
| } |
| } |
| } |
| /* |
| // Tian Dong: June 7, 2002 JVT-B042 |
| // Restore the short_used |
| if (input->NumFramesInELSubSeq) |
| { |
| fb->short_used = short_used; |
| } |
| */ |
| terminate_slice ( (NumberOfCodedMBs+TotalCodedMBs >= (int)img->PicSizeInMbs) ); |
| return NumberOfCodedMBs; |
| } |
| |
| |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Initializes the parameters for a new slice and |
| * allocates the memory for the coded slice in the Picture structure |
| * \par Side effects: |
| * Adds slice/partition header symbols to the symbol buffer |
| * increments Picture->no_slices, allocates memory for the |
| * slice, sets img->currSlice |
| ************************************************************************ |
| */ |
| static void init_slice (int start_mb_addr) |
| { |
| int i; |
| Picture *currPic = img->currentPicture; |
| DataPartition *dataPart; |
| Bitstream *currStream; |
| Slice *currSlice; |
| |
| img->current_mb_nr = start_mb_addr; |
| |
| // Allocate new Slice in the current Picture, and set img->currentSlice |
| assert (currPic != NULL); |
| currPic->no_slices++; |
| |
| if (currPic->no_slices >= MAXSLICEPERPICTURE) |
| error ("Too many slices per picture, increase MAXSLICEPERPICTURE in global.h.", -1); |
| |
| currPic->slices[currPic->no_slices-1] = malloc_slice(); |
| currSlice = currPic->slices[currPic->no_slices-1]; |
| |
| img->currentSlice = currSlice; |
| |
| currSlice->picture_id = img->tr % 256; |
| currSlice->qp = img->qp; |
| currSlice->start_mb_nr = start_mb_addr; |
| currSlice->slice_too_big = dummy_slice_too_big; |
| |
| for (i = 0; i < currSlice->max_part_nr; i++) |
| { |
| dataPart = &(currSlice->partArr[i]); |
| |
| currStream = dataPart->bitstream; |
| currStream->bits_to_go = 8; |
| currStream->byte_pos = 0; |
| currStream->byte_buf = 0; |
| } |
| |
| img->num_ref_idx_l0_active = active_pps->num_ref_idx_l0_active_minus1 + 1; |
| img->num_ref_idx_l1_active = active_pps->num_ref_idx_l1_active_minus1 + 1; |
| |
| // primary and redundant slices: number of references overriding. |
| if(input->redundant_pic_flag) |
| { |
| if(!redundant_coding) |
| { |
| img->num_ref_idx_l0_active = imin(img->number,input->NumRefPrimary); |
| } |
| else |
| { |
| // 1 reference picture for redundant slices |
| img->num_ref_idx_l0_active = 1; |
| } |
| } |
| |
| // code now also considers fields. Issue whether we should account this within the appropriate input params directly |
| if ((img->type == P_SLICE || img->type == SP_SLICE) && input->P_List0_refs) |
| { |
| img->num_ref_idx_l0_active = imin(img->num_ref_idx_l0_active, input->P_List0_refs * ((img->structure !=0) + 1)); |
| } |
| if (img->type == B_SLICE ) |
| { |
| if (input->B_List0_refs) |
| { |
| img->num_ref_idx_l0_active = imin(img->num_ref_idx_l0_active, input->B_List0_refs * ((img->structure !=0) + 1)); |
| } |
| if (input->B_List1_refs) |
| { |
| img->num_ref_idx_l1_active = imin(img->num_ref_idx_l1_active, input->B_List1_refs * ((img->structure !=0) + 1)); |
| } |
| } |
| // generate reference picture lists |
| init_lists(img->type, (PictureStructure) img->structure); |
| |
| // assign list 0 size from list size |
| img->num_ref_idx_l0_active = listXsize[0]; |
| img->num_ref_idx_l1_active = listXsize[1]; |
| |
| //Perform memory management based on poc distances |
| //if (img->nal_reference_idc && input->HierarchicalCoding && input->PocMemoryManagement && dpb.ref_frames_in_buffer==active_sps->num_ref_frames) |
| if (img->nal_reference_idc && input->PocMemoryManagement && dpb.ref_frames_in_buffer==active_sps->num_ref_frames) |
| { |
| poc_based_ref_management(img->frame_num); |
| } |
| |
| if (input->EnableOpenGOP) |
| { |
| for (i = 0; i<listXsize[0]; i++) |
| { |
| if (listX[0][i]->poc < img->last_valid_reference && img->ThisPOC > img->last_valid_reference) |
| { |
| listXsize[0] = img->num_ref_idx_l0_active = imax(1,i); |
| break; |
| } |
| } |
| |
| for (i = 0; i<listXsize[1]; i++) |
| { |
| if (listX[1][i]->poc < img->last_valid_reference && img->ThisPOC > img->last_valid_reference) |
| { |
| listXsize[1] = img->num_ref_idx_l1_active = imax(1,i); |
| break; |
| } |
| } |
| } |
| |
| init_ref_pic_list_reordering(); |
| |
| //Perform reordering based on poc distances for HierarchicalCoding |
| //if (img->type==P_SLICE && input->HierarchicalCoding && input->ReferenceReorder) |
| if (img->type==P_SLICE && input->ReferenceReorder) |
| { |
| |
| int i, num_ref; |
| |
| alloc_ref_pic_list_reordering_buffer(currSlice); |
| |
| if ((img->type != I_SLICE) && (img->type !=SI_SLICE)) |
| { |
| for (i=0; i<img->num_ref_idx_l0_active + 1; i++) |
| { |
| currSlice->reordering_of_pic_nums_idc_l0[i] = 3; |
| currSlice->abs_diff_pic_num_minus1_l0[i] = 0; |
| currSlice->long_term_pic_idx_l0[i] = 0; |
| } |
| |
| if (img->type == B_SLICE) |
| { |
| for (i=0; i<img->num_ref_idx_l1_active + 1; i++) |
| { |
| currSlice->reordering_of_pic_nums_idc_l1[i] = 3; |
| currSlice->abs_diff_pic_num_minus1_l1[i] = 0; |
| currSlice->long_term_pic_idx_l1[i] = 0; |
| } |
| } |
| } |
| |
| if ((img->type != I_SLICE) && (img->type !=SI_SLICE)) |
| { |
| num_ref = img->num_ref_idx_l0_active; |
| poc_ref_pic_reorder(listX[LIST_0], |
| num_ref, |
| currSlice->reordering_of_pic_nums_idc_l0, |
| currSlice->abs_diff_pic_num_minus1_l0, |
| currSlice->long_term_pic_idx_l0, LIST_0); |
| |
| //reference picture reordering |
| reorder_ref_pic_list(listX[LIST_0], &listXsize[LIST_0], |
| img->num_ref_idx_l0_active - 1, |
| currSlice->reordering_of_pic_nums_idc_l0, |
| currSlice->abs_diff_pic_num_minus1_l0, |
| currSlice->long_term_pic_idx_l0); |
| |
| // This is not necessary since order is already poc based... |
| if (img->type == B_SLICE) |
| { |
| num_ref = img->num_ref_idx_l1_active; |
| poc_ref_pic_reorder(listX[LIST_1], |
| num_ref, |
| currSlice->reordering_of_pic_nums_idc_l1, |
| currSlice->abs_diff_pic_num_minus1_l1, |
| currSlice->long_term_pic_idx_l1, LIST_1); |
| |
| //reference picture reordering |
| reorder_ref_pic_list(listX[LIST_1], &listXsize[LIST_1], |
| img->num_ref_idx_l1_active - 1, |
| currSlice->reordering_of_pic_nums_idc_l1, |
| currSlice->abs_diff_pic_num_minus1_l1, |
| currSlice->long_term_pic_idx_l1); |
| } |
| } |
| } |
| |
| |
| //if (img->MbaffFrameFlag) |
| if (img->structure==FRAME) |
| init_mbaff_lists(); |
| |
| if (img->type != I_SLICE && (active_pps->weighted_pred_flag == 1 || (active_pps->weighted_bipred_idc > 0 && (img->type == B_SLICE)))) |
| { |
| if (img->type==P_SLICE || img->type==SP_SLICE) |
| { |
| if (input->GenerateMultiplePPS && input->RDPictureDecision) |
| { |
| if (enc_picture==enc_frame_picture2) |
| estimate_weighting_factor_P_slice (0); |
| else |
| estimate_weighting_factor_P_slice (1); |
| } |
| else |
| estimate_weighting_factor_P_slice (0); |
| |
| } |
| else |
| estimate_weighting_factor_B_slice (); |
| } |
| |
| set_ref_pic_num(); |
| |
| if (img->type == B_SLICE) |
| compute_colocated(Co_located, listX); |
| if (img->type != I_SLICE && input->SearchMode == EPZS) |
| EPZSSliceInit(EPZSCo_located, listX); |
| |
| if (input->symbol_mode == UVLC) |
| { |
| writeMB_typeInfo = writeSE_UVLC; |
| writeIntraPredMode = writeIntraPredMode_CAVLC; |
| writeB8_typeInfo = writeSE_UVLC; |
| for (i=0; i<6; i++) |
| { |
| switch (listXsize[i]) |
| { |
| case 0: |
| writeRefFrame[i] = NULL; |
| break; |
| case 1: |
| writeRefFrame[i] = writeSE_Dummy; |
| break; |
| case 2: |
| writeRefFrame[i] = writeSE_invFlag; |
| break; |
| default: |
| writeRefFrame[i] = writeSE_UVLC; |
| break; |
| } |
| } |
| writeMVD = writeSE_SVLC; |
| writeCBP = writeCBP_VLC; |
| writeDquant = writeSE_SVLC; |
| writeCIPredMode = writeSE_UVLC; |
| writeFieldModeInfo = writeSE_Flag; |
| writeMB_transform_size = writeSE_Flag; |
| } |
| else |
| { |
| writeMB_typeInfo = writeMB_typeInfo_CABAC; |
| writeIntraPredMode = writeIntraPredMode_CABAC; |
| writeB8_typeInfo = writeB8_typeInfo_CABAC; |
| for (i=0; i<6; i++) |
| { |
| switch (listXsize[i]) |
| { |
| case 0: |
| writeRefFrame[i] = NULL; |
| case 1: |
| writeRefFrame[i] = writeSE_Dummy; |
| break; |
| default: |
| writeRefFrame[i] = writeRefFrame_CABAC; |
| } |
| } |
| writeMVD = writeMVD_CABAC; |
| writeCBP = writeCBP_CABAC; |
| writeDquant = writeDquant_CABAC; |
| writeCIPredMode = writeCIPredMode_CABAC; |
| writeFieldModeInfo = writeFieldModeInfo_CABAC; |
| writeMB_transform_size = writeMB_transform_size_CABAC; |
| } |
| |
| } |
| |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Allocates a slice structure along with its dependent data structures |
| * \return |
| * Pointer to a Slice |
| ************************************************************************ |
| */ |
| static Slice *malloc_slice() |
| { |
| int i; |
| DataPartition *dataPart; |
| Slice *slice; |
| |
| // const int buffer_size = (img->size * 4); // AH 190202: There can be data expansion with |
| // low QP values. So, we make sure that buffer |
| // does not overflow. 4 is probably safe multiplier. |
| int buffer_size; |
| |
| switch (input->slice_mode) |
| { |
| case 2: |
| buffer_size = 2 * input->slice_argument; |
| break; |
| case 1: |
| buffer_size = 500 + input->slice_argument * (128 + 256 * img->bitdepth_luma + 512 * img->bitdepth_chroma);; |
| break; |
| default: |
| buffer_size = 500 + img->FrameSizeInMbs * (128 + 256 * img->bitdepth_luma + 512 * img->bitdepth_chroma); |
| break; |
| } |
| |
| // KS: this is approx. max. allowed code picture size |
| |
| if ((slice = (Slice *) calloc(1, sizeof(Slice))) == NULL) no_mem_exit ("malloc_slice: slice structure"); |
| |
| if (input->symbol_mode == CABAC) |
| { |
| // create all context models |
| slice->mot_ctx = create_contexts_MotionInfo(); |
| slice->tex_ctx = create_contexts_TextureInfo(); |
| } |
| |
| slice->max_part_nr = input->partition_mode==0?1:3; |
| |
| //for IDR img there should be only one partition |
| if(img->currentPicture->idr_flag) |
| slice->max_part_nr = 1; |
| |
| assignSE2partition[0] = assignSE2partition_NoDP; |
| //ZL |
| //for IDR img all the syntax element should be mapped to one partition |
| if(!img->currentPicture->idr_flag&&input->partition_mode==1) |
| assignSE2partition[1] = assignSE2partition_DP; |
| else |
| assignSE2partition[1] = assignSE2partition_NoDP; |
| |
| |
| |
| slice->num_mb = 0; // no coded MBs so far |
| |
| if ((slice->partArr = (DataPartition *) calloc(slice->max_part_nr, sizeof(DataPartition))) == NULL) no_mem_exit ("malloc_slice: partArr"); |
| for (i=0; i<slice->max_part_nr; i++) // loop over all data partitions |
| { |
| dataPart = &(slice->partArr[i]); |
| if ((dataPart->bitstream = (Bitstream *) calloc(1, sizeof(Bitstream))) == NULL) no_mem_exit ("malloc_slice: Bitstream"); |
| if ((dataPart->bitstream->streamBuffer = (byte *) calloc(buffer_size, sizeof(byte))) == NULL) no_mem_exit ("malloc_slice: StreamBuffer"); |
| // Initialize storage of bitstream parameters |
| } |
| return slice; |
| } |
| |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Memory frees of all Slice structures and of its dependent |
| * data structures |
| * \par Input: |
| * Image Parameters struct struct img_par *img |
| ************************************************************************ |
| */ |
| void free_slice_list(Picture *currPic) |
| { |
| int i; |
| |
| for (i=0; i<currPic->no_slices; i++) |
| { |
| free_slice (currPic->slices[i]); |
| currPic->slices[i]=NULL; |
| } |
| } |
| |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * Memory frees of the Slice structure and of its dependent |
| * data structures |
| * \param slice: |
| * Slice to be freed |
| ************************************************************************ |
| */ |
| static void free_slice(Slice *slice) |
| { |
| int i; |
| DataPartition *dataPart; |
| |
| if (slice != NULL) |
| { |
| for (i=0; i<slice->max_part_nr; i++) // loop over all data partitions |
| { |
| dataPart = &(slice->partArr[i]); |
| if (dataPart != NULL) |
| { |
| if (dataPart->bitstream->streamBuffer != NULL) |
| free(dataPart->bitstream->streamBuffer); |
| if (dataPart->bitstream != NULL) |
| free(dataPart->bitstream); |
| } |
| } |
| if (slice->partArr != NULL) |
| free(slice->partArr); |
| if (input->symbol_mode == CABAC) |
| { |
| delete_contexts_MotionInfo(slice->mot_ctx); |
| delete_contexts_TextureInfo(slice->tex_ctx); |
| } |
| |
| free(slice); |
| } |
| } |
| |
| void set_ref_pic_num() |
| { |
| int i,j; |
| StorablePicture *this_ref; |
| |
| //! need to add field ref_pic_num that handles field pair. |
| |
| for (i=0;i<listXsize[LIST_0];i++) |
| { |
| this_ref = listX[LIST_0][i]; |
| enc_picture->ref_pic_num [LIST_0][i] = this_ref->poc * 2 + ((this_ref->structure==BOTTOM_FIELD)?1:0) ; |
| enc_picture->frm_ref_pic_num [LIST_0][i] = this_ref->frame_poc * 2; |
| enc_picture->top_ref_pic_num [LIST_0][i] = this_ref->top_poc * 2; |
| enc_picture->bottom_ref_pic_num [LIST_0][i] = this_ref->bottom_poc * 2 + 1; |
| } |
| |
| for (i=0;i<listXsize[LIST_1];i++) |
| { |
| this_ref = listX[LIST_1][i]; |
| enc_picture->ref_pic_num [LIST_1][i] = this_ref->poc *2 + ((this_ref->structure==BOTTOM_FIELD)?1:0); |
| enc_picture->frm_ref_pic_num [LIST_1][i] = this_ref->frame_poc * 2; |
| enc_picture->top_ref_pic_num [LIST_1][i] = this_ref->top_poc * 2; |
| enc_picture->bottom_ref_pic_num [LIST_1][i] = this_ref->bottom_poc * 2 + 1; |
| } |
| |
| if (!active_sps->frame_mbs_only_flag && img->structure==FRAME) |
| { |
| for (j=2;j<6;j++) |
| for (i=0;i<listXsize[j];i++) |
| { |
| this_ref = listX[j][i]; |
| enc_picture->ref_pic_num[j][i] = this_ref->poc * 2 + ((this_ref->structure==BOTTOM_FIELD)?1:0); |
| enc_picture->frm_ref_pic_num[j][i] = this_ref->frame_poc * 2 ; |
| enc_picture->top_ref_pic_num[j][i] = this_ref->top_poc * 2 ; |
| enc_picture->bottom_ref_pic_num[j][i] = this_ref->bottom_poc * 2 + 1; |
| } |
| } |
| } |
| |
| /*! |
| ************************************************************************ |
| * \brief |
| * decide reference picture reordering, Frame only |
| ************************************************************************ |
| */ |
| void poc_ref_pic_reorder(StorablePicture **list, unsigned num_ref_idx_lX_active, int *reordering_of_pic_nums_idc, int *abs_diff_pic_num_minus1, int *long_term_pic_idx, int list_no) |
| { |
| unsigned i,j,k; |
| |
| int currPicNum, picNumLXPred; |
| |
| int default_order[32]; |
| int re_order[32]; |
| int tmp_reorder[32]; |
| int list_sign[32]; |
| int reorder_stop, no_reorder; |
| int poc_diff[32]; |
| int tmp_value, diff; |
| |
| int abs_poc_dist; |
| int maxPicNum, MaxFrameNum = 1 << (log2_max_frame_num_minus4 + 4); |
| |
| if (img->structure==FRAME) |
| { |
| maxPicNum = MaxFrameNum; |
| currPicNum = img->frame_num; |
| } |
| else |
| { |
| maxPicNum = 2 * MaxFrameNum; |
| currPicNum = 2 * img->frame_num + 1; |
| } |
| |
| picNumLXPred = currPicNum; |
| |
| // First assign default list order. |
| for (i=0; i<num_ref_idx_lX_active; i++) |
| { |
| default_order[i] = list[i]->pic_num; |
| } |
| |
| // Now access all references in buffer and assign them |
| // to a pottential reordering list. For each one of these |
| // references compute the poc distance compared to current |
| // frame. |
| for (i=0; i<dpb.ref_frames_in_buffer; i++) |
| { |
| re_order[i] = dpb.fs_ref[i]->frame->pic_num; |
| |
| if (dpb.fs_ref[i]->is_used==3 && (dpb.fs_ref[i]->frame->used_for_reference)&&(!dpb.fs_ref[i]->frame->is_long_term)) |
| { |
| abs_poc_dist = iabs(dpb.fs_ref[i]->frame->poc - enc_picture->poc) ; |
| poc_diff[i] = abs_poc_dist; |
| if (list_no == LIST_0) |
| { |
| list_sign[i] = (enc_picture->poc < dpb.fs_ref[i]->frame->poc) ? +1 : -1; |
| } |
| else |
| { |
| list_sign[i] = (enc_picture->poc > dpb.fs_ref[i]->frame->poc) ? +1 : -1; |
| } |
| } |
| } |
| |
| |
| // now sort these references based on poc (temporal) distance |
| for (i=0; i< dpb.ref_frames_in_buffer-1; i++) |
| { |
| for (j=i+1; j< dpb.ref_frames_in_buffer; j++) |
| { |
| if (poc_diff[i]>poc_diff[j] || (poc_diff[i] == poc_diff[j] && list_sign[j] > list_sign[i])) |
| { |
| |
| tmp_value = poc_diff[i]; |
| poc_diff[i] = poc_diff[j]; |
| poc_diff[j] = tmp_value; |
| tmp_value = re_order[i]; |
| re_order[i] = re_order[j]; |
| re_order[j] = tmp_value ; |
| tmp_value = list_sign[i]; |
| list_sign[i] = list_sign[j]; |
| list_sign[j] = tmp_value ; |
| } |
| } |
| } |
| |
| // Check versus default list to see if any |
| // change has happened |
| no_reorder = 1; |
| for (i=0; i<num_ref_idx_lX_active; i++) |
| { |
| if (default_order[i] != re_order[i]) |
| { |
| no_reorder = 0; |
| } |
| } |
| |
| // If different, then signal reordering |
| if (no_reorder==0) |
| { |
| for (i=0; i<num_ref_idx_lX_active; i++) |
| { |
| diff = re_order[i]-picNumLXPred; |
| if (diff <= 0) |
| { |
| reordering_of_pic_nums_idc[i] = 0; |
| abs_diff_pic_num_minus1[i] = iabs(diff)-1; |
| if (abs_diff_pic_num_minus1[i] < 0) |
| abs_diff_pic_num_minus1[i] = maxPicNum -1; |
| } |
| else |
| { |
| reordering_of_pic_nums_idc[i] = 1; |
| abs_diff_pic_num_minus1[i] = iabs(diff)-1; |
| } |
| picNumLXPred = re_order[i]; |
| |
| tmp_reorder[i] = re_order[i]; |
| |
| k = i; |
| for (j=i; j<num_ref_idx_lX_active; j++) |
| { |
| if (default_order[j] != re_order[i]) |
| { |
| ++k; |
| tmp_reorder[k] = default_order[j]; |
| } |
| } |
| reorder_stop = 1; |
| for(j=i+1; j<num_ref_idx_lX_active; j++) |
| { |
| if (tmp_reorder[j] != re_order[j]) |
| { |
| reorder_stop = 0; |
| break; |
| } |
| } |
| |
| if (reorder_stop==1) |
| { |
| ++i; |
| break; |
| } |
| |
| for(j=0; j<num_ref_idx_lX_active; j++) |
| { |
| default_order[j] = tmp_reorder[j]; |
| } |
| |
| } |
| reordering_of_pic_nums_idc[i] = 3; |
| |
| for(j=0; j<num_ref_idx_lX_active; j++) |
| { |
| default_order[j] = tmp_reorder[j]; |
| } |
| |
| if (list_no==0) |
| { |
| img->currentSlice->ref_pic_list_reordering_flag_l0=1; |
| } |
| else |
| { |
| img->currentSlice->ref_pic_list_reordering_flag_l1=1; |
| } |
| } |
| } |
| |
| extern const int QP2QUANT[40]; |
| |
| void SetLagrangianMultipliers() |
| { |
| int qp, j, k; |
| double qp_temp; |
| double lambda_scale = 1.0 - dClip3(0.0,0.5,0.05 * (double) input->jumpd);; |
| |
| if (input->rdopt) // RDOPT on computation of Lagrangian multipliers |
| { |
| for (j = 0; j < 5; j++) |
| { |
| for (qp = -img->bitdepth_luma_qp_scale; qp < 52; qp++) |
| { |
| qp_temp = (double)qp + img->bitdepth_luma_qp_scale - SHIFT_QP; |
| |
| if (input->UseExplicitLambdaParams == 1) // consideration of explicit lambda weights. |
| { |
| img->lambda_md[j][qp] = input->LambdaWeight[j] * pow (2, qp_temp/3.0); |
| // Scale lambda due to hadamard qpel only consideration |
| img->lambda_md[j][qp] = ( (input->MEErrorMetric[H_PEL] == ERROR_SATD && input->MEErrorMetric[Q_PEL] == ERROR_SATD) ? 1.00 : 0.95) * img->lambda_md[j][qp]; |
| |
| for (k = F_PEL; k <= Q_PEL; k++) |
| { |
| img->lambda_me[j][qp][k] = input->MEErrorMetric[k] == ERROR_SSE ? img->lambda_md[j][qp] : sqrt(img->lambda_md[j][qp]); |
| img->lambda_mf[j][qp][k] = LAMBDA_FACTOR (img->lambda_me[j][qp][k]); |
| } |
| |
| if (j == B_SLICE) |
| { |
| img->lambda_md[5][qp] = input->LambdaWeight[5] * pow (2, qp_temp/3.0); |
| img->lambda_md[5][qp] = ((input->MEErrorMetric[H_PEL] == ERROR_SATD && input->MEErrorMetric[Q_PEL] == ERROR_SATD) ? 1.00 : 0.95) * img->lambda_md[5][qp]; |
| |
| for (k = F_PEL; k <= Q_PEL; k++) |
| { |
| img->lambda_me[5][qp][k] = input->MEErrorMetric[k] == ERROR_SSE ? img->lambda_md[5][qp] : sqrt(img->lambda_md[5][qp]); |
| img->lambda_mf[5][qp][k] = LAMBDA_FACTOR (img->lambda_me[5][qp][k]); |
| } |
| } |
| } |
| else if (input->UseExplicitLambdaParams == 2) // consideration of fixed lambda values. |
| { |
| img->lambda_md[j][qp] = input->FixedLambda[j]; |
| // Scale lambda due to hadamard qpel only consideration |
| img->lambda_md[j][qp] = ( (input->MEErrorMetric[H_PEL] == ERROR_SATD && input->MEErrorMetric[Q_PEL] == ERROR_SATD) ? 1.00 : 0.95) * img->lambda_md[j][qp]; |
| |
| for (k = F_PEL; k <= Q_PEL; k++) |
| { |
| img->lambda_me[j][qp][k] = input->MEErrorMetric[k] == ERROR_SSE ? img->lambda_md[j][qp] : sqrt(img->lambda_md[j][qp]); |
| img->lambda_mf[j][qp][k] = LAMBDA_FACTOR (img->lambda_me[j][qp][k]); |
| } |
| |
| if (j == B_SLICE) |
| { |
| img->lambda_md[5][qp] = input->FixedLambda[5]; |
| img->lambda_md[5][qp] = ((input->MEErrorMetric[H_PEL] == ERROR_SATD && input->MEErrorMetric[Q_PEL] == ERROR_SATD) ? 1.00 : 0.95) * img->lambda_md[5][qp]; |
| |
| for (k = F_PEL; k <= Q_PEL; k++) |
| { |
| img->lambda_me[5][qp][k] = input->MEErrorMetric[k] == ERROR_SSE ? img->lambda_md[5][qp] : sqrt(img->lambda_md[5][qp]); |
| img->lambda_mf[5][qp][k] = LAMBDA_FACTOR (img->lambda_me[5][qp][k]); |
| } |
| } |
| } |
| else |
| { |
| if (input->successive_Bframe>0) |
| img->lambda_md[j][qp] = 0.68 * pow (2, qp_temp/3.0) |
| * (j == B_SLICE ? dClip3(2.00,4.00,(qp_temp / 6.0)) : (j == SP_SLICE) ? dClip3(1.4,3.0,(qp_temp / 12.0)) : 1.0); |
| else |
| img->lambda_md[j][qp] = 0.85 * pow (2, qp_temp/3.0) |
| * ( (j == B_SLICE) ? 4.0 : (j == SP_SLICE) ? dClip3(1.4,3.0,(qp_temp / 12.0)) : 1.0); |
| // Scale lambda due to hadamard qpel only consideration |
| img->lambda_md[j][qp] = ((input->MEErrorMetric[H_PEL] == ERROR_SATD && input->MEErrorMetric[Q_PEL] == ERROR_SATD) ? 1.00 : 0.95) * img->lambda_md[j][qp]; |
| img->lambda_md[j][qp] = (j == B_SLICE && input->BRefPictures == 2 && img->b_frame_to_code == 0 ? 0.50 : 1.00) * img->lambda_md[j][qp]; |
| |
| if (j == B_SLICE) |
| { |
| img->lambda_md[5][qp] = img->lambda_md[j][qp]; |
| |
| if (input->HierarchicalCoding == 2) |
| img->lambda_md[5][qp] *= (1.0 - dmin(0.4,0.2 * (double) gop_structure[img->b_frame_to_code-1].hierarchy_layer)) ; |
| else |
| img->lambda_md[5][qp] *= 0.80; |
| |
| img->lambda_md[5][qp] *= lambda_scale; |
| |
| for (k = F_PEL; k <= Q_PEL; k++) |
| { |
| img->lambda_me[5][qp][k] = input->MEErrorMetric[k] == ERROR_SSE ? img->lambda_md[5][qp] : sqrt(img->lambda_md[5][qp]); |
| img->lambda_mf[5][qp][k] = LAMBDA_FACTOR (img->lambda_me[5][qp][k]); |
| } |
| } |
| else |
| img->lambda_md[j][qp] *= lambda_scale; |
| |
| for (k = F_PEL; k <= Q_PEL; k++) |
| { |
| img->lambda_me[j][qp][k] = input->MEErrorMetric[k] == ERROR_SSE ? img->lambda_md[j][qp] : sqrt(img->lambda_md[j][qp]); |
| img->lambda_mf[j][qp][k] = LAMBDA_FACTOR (img->lambda_me[j][qp][k]); |
| } |
| |
| if (input->CtxAdptLagrangeMult == 1) |
| { |
| int lambda_qp = (qp >= 32 && !input->RCEnable) ? imax(0, qp - 4) : imax(0, qp - 6); |
| img->lambda_mf_factor[j][qp] = log (img->lambda_me[j][lambda_qp][Q_PEL] + 1.0) / log (2.0); |
| } |
| } |
| } |
| } |
| } |
| else // RDOPT off computation of Lagrangian multipliers |
| { |
| for (j = 0; j < 6; j++) |
| { |
| for (qp = -img->bitdepth_luma_qp_scale; qp < 52; qp++) |
| { |
| img->lambda_md[j][qp] = QP2QUANT[imax(0,qp - SHIFT_QP)]; |
| |
| for (k = F_PEL; k <= Q_PEL; k++) |
| { |
| img->lambda_me[j][qp][k] = img->lambda_md[j][qp]; |
| img->lambda_me[j][qp][k] *= input->MEErrorMetric[k] == ERROR_SSE ? img->lambda_me[j][qp][k] : 1; |
| img->lambda_mf[j][qp][k] = LAMBDA_FACTOR (img->lambda_me[j][qp][k]); |
| } |
| |
| if (input->CtxAdptLagrangeMult == 1) |
| { |
| int lambda_qp = (qp >= 32 && !input->RCEnable) ? imax(0, qp-4) : imax(0, qp-6); |
| img->lambda_mf_factor[j][qp] = log (img->lambda_me[j][lambda_qp][Q_PEL] + 1.0) / log (2.0); |
| } |
| } |
| } |
| } |
| } |
| |
