| /* ------------------------------------------------------------------ |
| * Copyright (C) 1998-2009 PacketVideo |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either |
| * express or implied. |
| * See the License for the specific language governing permissions |
| * and limitations under the License. |
| * ------------------------------------------------------------------- |
| */ |
| #include "avcenc_lib.h" |
| #include "avcenc_api.h" |
| |
| /** see subclause 7.4.2.1 */ |
| /* no need for checking the valid range , already done in SetEncodeParam(), |
| if we have to send another SPS, the ranges should be verified first before |
| users call PVAVCEncodeSPS() */ |
| AVCEnc_Status EncodeSPS(AVCEncObject *encvid, AVCEncBitstream *stream) |
| { |
| AVCCommonObj *video = encvid->common; |
| AVCSeqParamSet *seqParam = video->currSeqParams; |
| AVCVUIParams *vui = &(seqParam->vui_parameters); |
| int i; |
| AVCEnc_Status status = AVCENC_SUCCESS; |
| |
| //DEBUG_LOG(userData,AVC_LOGTYPE_INFO,"EncodeSPS",-1,-1); |
| |
| status = BitstreamWriteBits(stream, 8, seqParam->profile_idc); |
| status = BitstreamWrite1Bit(stream, seqParam->constrained_set0_flag); |
| status = BitstreamWrite1Bit(stream, seqParam->constrained_set1_flag); |
| status = BitstreamWrite1Bit(stream, seqParam->constrained_set2_flag); |
| status = BitstreamWrite1Bit(stream, seqParam->constrained_set3_flag); |
| status = BitstreamWriteBits(stream, 4, 0); /* forbidden zero bits */ |
| if (status != AVCENC_SUCCESS) /* we can check after each write also */ |
| { |
| return status; |
| } |
| |
| status = BitstreamWriteBits(stream, 8, seqParam->level_idc); |
| status = ue_v(stream, seqParam->seq_parameter_set_id); |
| status = ue_v(stream, seqParam->log2_max_frame_num_minus4); |
| status = ue_v(stream, seqParam->pic_order_cnt_type); |
| if (status != AVCENC_SUCCESS) |
| { |
| return status; |
| } |
| |
| if (seqParam->pic_order_cnt_type == 0) |
| { |
| status = ue_v(stream, seqParam->log2_max_pic_order_cnt_lsb_minus4); |
| } |
| else if (seqParam->pic_order_cnt_type == 1) |
| { |
| status = BitstreamWrite1Bit(stream, seqParam->delta_pic_order_always_zero_flag); |
| status = se_v(stream, seqParam->offset_for_non_ref_pic); /* upto 32 bits */ |
| status = se_v(stream, seqParam->offset_for_top_to_bottom_field); /* upto 32 bits */ |
| status = ue_v(stream, seqParam->num_ref_frames_in_pic_order_cnt_cycle); |
| |
| for (i = 0; i < (int)(seqParam->num_ref_frames_in_pic_order_cnt_cycle); i++) |
| { |
| status = se_v(stream, seqParam->offset_for_ref_frame[i]); /* upto 32 bits */ |
| } |
| } |
| if (status != AVCENC_SUCCESS) |
| { |
| return status; |
| } |
| |
| status = ue_v(stream, seqParam->num_ref_frames); |
| status = BitstreamWrite1Bit(stream, seqParam->gaps_in_frame_num_value_allowed_flag); |
| status = ue_v(stream, seqParam->pic_width_in_mbs_minus1); |
| status = ue_v(stream, seqParam->pic_height_in_map_units_minus1); |
| status = BitstreamWrite1Bit(stream, seqParam->frame_mbs_only_flag); |
| if (status != AVCENC_SUCCESS) |
| { |
| return status; |
| } |
| /* if frame_mbs_only_flag is 0, then write, mb_adaptive_frame_field_frame here */ |
| |
| status = BitstreamWrite1Bit(stream, seqParam->direct_8x8_inference_flag); |
| status = BitstreamWrite1Bit(stream, seqParam->frame_cropping_flag); |
| if (seqParam->frame_cropping_flag) |
| { |
| status = ue_v(stream, seqParam->frame_crop_left_offset); |
| status = ue_v(stream, seqParam->frame_crop_right_offset); |
| status = ue_v(stream, seqParam->frame_crop_top_offset); |
| status = ue_v(stream, seqParam->frame_crop_bottom_offset); |
| } |
| if (status != AVCENC_SUCCESS) |
| { |
| return status; |
| } |
| |
| status = BitstreamWrite1Bit(stream, seqParam->vui_parameters_present_flag); |
| if (seqParam->vui_parameters_present_flag) |
| { |
| /* not supported */ |
| //return AVCENC_SPS_FAIL; |
| EncodeVUI(stream, vui); |
| } |
| |
| return status; |
| } |
| |
| |
| void EncodeVUI(AVCEncBitstream* stream, AVCVUIParams* vui) |
| { |
| int temp; |
| |
| temp = vui->aspect_ratio_info_present_flag; |
| BitstreamWrite1Bit(stream, temp); |
| if (temp) |
| { |
| BitstreamWriteBits(stream, 8, vui->aspect_ratio_idc); |
| if (vui->aspect_ratio_idc == 255) |
| { |
| BitstreamWriteBits(stream, 16, vui->sar_width); |
| BitstreamWriteBits(stream, 16, vui->sar_height); |
| } |
| } |
| temp = vui->overscan_info_present_flag; |
| BitstreamWrite1Bit(stream, temp); |
| if (temp) |
| { |
| BitstreamWrite1Bit(stream, vui->overscan_appropriate_flag); |
| } |
| temp = vui->video_signal_type_present_flag; |
| BitstreamWrite1Bit(stream, temp); |
| if (temp) |
| { |
| BitstreamWriteBits(stream, 3, vui->video_format); |
| BitstreamWrite1Bit(stream, vui->video_full_range_flag); |
| temp = vui->colour_description_present_flag; |
| BitstreamWrite1Bit(stream, temp); |
| if (temp) |
| { |
| BitstreamWriteBits(stream, 8, vui->colour_primaries); |
| BitstreamWriteBits(stream, 8, vui->transfer_characteristics); |
| BitstreamWriteBits(stream, 8, vui->matrix_coefficients); |
| } |
| } |
| temp = vui->chroma_location_info_present_flag; |
| BitstreamWrite1Bit(stream, temp); |
| if (temp) |
| { |
| ue_v(stream, vui->chroma_sample_loc_type_top_field); |
| ue_v(stream, vui->chroma_sample_loc_type_bottom_field); |
| } |
| |
| temp = vui->timing_info_present_flag; |
| BitstreamWrite1Bit(stream, temp); |
| if (temp) |
| { |
| BitstreamWriteBits(stream, 32, vui->num_units_in_tick); |
| BitstreamWriteBits(stream, 32, vui->time_scale); |
| BitstreamWrite1Bit(stream, vui->fixed_frame_rate_flag); |
| } |
| |
| temp = vui->nal_hrd_parameters_present_flag; |
| BitstreamWrite1Bit(stream, temp); |
| if (temp) |
| { |
| EncodeHRD(stream, &(vui->nal_hrd_parameters)); |
| } |
| temp = vui->vcl_hrd_parameters_present_flag; |
| BitstreamWrite1Bit(stream, temp); |
| if (temp) |
| { |
| EncodeHRD(stream, &(vui->vcl_hrd_parameters)); |
| } |
| if (vui->nal_hrd_parameters_present_flag || vui->vcl_hrd_parameters_present_flag) |
| { |
| BitstreamWrite1Bit(stream, vui->low_delay_hrd_flag); |
| } |
| BitstreamWrite1Bit(stream, vui->pic_struct_present_flag); |
| temp = vui->bitstream_restriction_flag; |
| BitstreamWrite1Bit(stream, temp); |
| if (temp) |
| { |
| BitstreamWrite1Bit(stream, vui->motion_vectors_over_pic_boundaries_flag); |
| ue_v(stream, vui->max_bytes_per_pic_denom); |
| ue_v(stream, vui->max_bits_per_mb_denom); |
| ue_v(stream, vui->log2_max_mv_length_horizontal); |
| ue_v(stream, vui->log2_max_mv_length_vertical); |
| ue_v(stream, vui->max_dec_frame_reordering); |
| ue_v(stream, vui->max_dec_frame_buffering); |
| } |
| |
| return ; |
| } |
| |
| |
| void EncodeHRD(AVCEncBitstream* stream, AVCHRDParams* hrd) |
| { |
| int i; |
| |
| ue_v(stream, hrd->cpb_cnt_minus1); |
| BitstreamWriteBits(stream, 4, hrd->bit_rate_scale); |
| BitstreamWriteBits(stream, 4, hrd->cpb_size_scale); |
| for (i = 0; i <= (int)hrd->cpb_cnt_minus1; i++) |
| { |
| ue_v(stream, hrd->bit_rate_value_minus1[i]); |
| ue_v(stream, hrd->cpb_size_value_minus1[i]); |
| ue_v(stream, hrd->cbr_flag[i]); |
| } |
| BitstreamWriteBits(stream, 5, hrd->initial_cpb_removal_delay_length_minus1); |
| BitstreamWriteBits(stream, 5, hrd->cpb_removal_delay_length_minus1); |
| BitstreamWriteBits(stream, 5, hrd->dpb_output_delay_length_minus1); |
| BitstreamWriteBits(stream, 5, hrd->time_offset_length); |
| |
| return ; |
| } |
| |
| |
| |
| /** see subclause 7.4.2.2 */ |
| /* no need for checking the valid range , already done in SetEncodeParam(). |
| If we have to send another SPS, the ranges should be verified first before |
| users call PVAVCEncodeSPS()*/ |
| AVCEnc_Status EncodePPS(AVCEncObject *encvid, AVCEncBitstream *stream) |
| { |
| AVCCommonObj *video = encvid->common; |
| AVCEnc_Status status = AVCENC_SUCCESS; |
| AVCPicParamSet *picParam = video->currPicParams; |
| int i, iGroup, numBits; |
| uint temp; |
| |
| status = ue_v(stream, picParam->pic_parameter_set_id); |
| status = ue_v(stream, picParam->seq_parameter_set_id); |
| status = BitstreamWrite1Bit(stream, picParam->entropy_coding_mode_flag); |
| status = BitstreamWrite1Bit(stream, picParam->pic_order_present_flag); |
| if (status != AVCENC_SUCCESS) |
| { |
| return status; |
| } |
| |
| status = ue_v(stream, picParam->num_slice_groups_minus1); |
| if (picParam->num_slice_groups_minus1 > 0) |
| { |
| status = ue_v(stream, picParam->slice_group_map_type); |
| if (picParam->slice_group_map_type == 0) |
| { |
| for (iGroup = 0; iGroup <= (int)picParam->num_slice_groups_minus1; iGroup++) |
| { |
| status = ue_v(stream, picParam->run_length_minus1[iGroup]); |
| } |
| } |
| else if (picParam->slice_group_map_type == 2) |
| { |
| for (iGroup = 0; iGroup < (int)picParam->num_slice_groups_minus1; iGroup++) |
| { |
| status = ue_v(stream, picParam->top_left[iGroup]); |
| status = ue_v(stream, picParam->bottom_right[iGroup]); |
| } |
| } |
| else if (picParam->slice_group_map_type == 3 || |
| picParam->slice_group_map_type == 4 || |
| picParam->slice_group_map_type == 5) |
| { |
| status = BitstreamWrite1Bit(stream, picParam->slice_group_change_direction_flag); |
| status = ue_v(stream, picParam->slice_group_change_rate_minus1); |
| } |
| else /*if(picParam->slice_group_map_type == 6)*/ |
| { |
| status = ue_v(stream, picParam->pic_size_in_map_units_minus1); |
| |
| numBits = 0;/* ceil(log2(num_slice_groups_minus1+1)) bits */ |
| i = picParam->num_slice_groups_minus1; |
| while (i > 0) |
| { |
| numBits++; |
| i >>= 1; |
| } |
| |
| for (i = 0; i <= (int)picParam->pic_size_in_map_units_minus1; i++) |
| { |
| status = BitstreamWriteBits(stream, numBits, picParam->slice_group_id[i]); |
| } |
| } |
| } |
| if (status != AVCENC_SUCCESS) |
| { |
| return status; |
| } |
| |
| status = ue_v(stream, picParam->num_ref_idx_l0_active_minus1); |
| status = ue_v(stream, picParam->num_ref_idx_l1_active_minus1); |
| status = BitstreamWrite1Bit(stream, picParam->weighted_pred_flag); |
| status = BitstreamWriteBits(stream, 2, picParam->weighted_bipred_idc); |
| if (status != AVCENC_SUCCESS) |
| { |
| return status; |
| } |
| |
| status = se_v(stream, picParam->pic_init_qp_minus26); |
| status = se_v(stream, picParam->pic_init_qs_minus26); |
| status = se_v(stream, picParam->chroma_qp_index_offset); |
| |
| temp = picParam->deblocking_filter_control_present_flag << 2; |
| temp |= (picParam->constrained_intra_pred_flag << 1); |
| temp |= picParam->redundant_pic_cnt_present_flag; |
| |
| status = BitstreamWriteBits(stream, 3, temp); |
| |
| return status; |
| } |
| |
| /** see subclause 7.4.3 */ |
| AVCEnc_Status EncodeSliceHeader(AVCEncObject *encvid, AVCEncBitstream *stream) |
| { |
| AVCCommonObj *video = encvid->common; |
| AVCSliceHeader *sliceHdr = video->sliceHdr; |
| AVCPicParamSet *currPPS = video->currPicParams; |
| AVCSeqParamSet *currSPS = video->currSeqParams; |
| AVCEnc_Status status = AVCENC_SUCCESS; |
| int slice_type, temp, i; |
| int num_bits; |
| |
| num_bits = (stream->write_pos << 3) - stream->bit_left; |
| |
| status = ue_v(stream, sliceHdr->first_mb_in_slice); |
| |
| slice_type = video->slice_type; |
| |
| if (video->mbNum == 0) /* first mb in frame */ |
| { |
| status = ue_v(stream, sliceHdr->slice_type); |
| } |
| else |
| { |
| status = ue_v(stream, slice_type); |
| } |
| |
| status = ue_v(stream, sliceHdr->pic_parameter_set_id); |
| |
| status = BitstreamWriteBits(stream, currSPS->log2_max_frame_num_minus4 + 4, sliceHdr->frame_num); |
| |
| if (status != AVCENC_SUCCESS) |
| { |
| return status; |
| } |
| /* if frame_mbs_only_flag is 0, encode field_pic_flag, bottom_field_flag here */ |
| |
| if (video->nal_unit_type == AVC_NALTYPE_IDR) |
| { |
| status = ue_v(stream, sliceHdr->idr_pic_id); |
| } |
| |
| if (currSPS->pic_order_cnt_type == 0) |
| { |
| status = BitstreamWriteBits(stream, currSPS->log2_max_pic_order_cnt_lsb_minus4 + 4, |
| sliceHdr->pic_order_cnt_lsb); |
| |
| if (currPPS->pic_order_present_flag && !sliceHdr->field_pic_flag) |
| { |
| status = se_v(stream, sliceHdr->delta_pic_order_cnt_bottom); /* 32 bits */ |
| } |
| } |
| if (currSPS->pic_order_cnt_type == 1 && !currSPS->delta_pic_order_always_zero_flag) |
| { |
| status = se_v(stream, sliceHdr->delta_pic_order_cnt[0]); /* 32 bits */ |
| if (currPPS->pic_order_present_flag && !sliceHdr->field_pic_flag) |
| { |
| status = se_v(stream, sliceHdr->delta_pic_order_cnt[1]); /* 32 bits */ |
| } |
| } |
| |
| if (currPPS->redundant_pic_cnt_present_flag) |
| { |
| status = ue_v(stream, sliceHdr->redundant_pic_cnt); |
| } |
| |
| if (slice_type == AVC_B_SLICE) |
| { |
| status = BitstreamWrite1Bit(stream, sliceHdr->direct_spatial_mv_pred_flag); |
| } |
| |
| if (status != AVCENC_SUCCESS) |
| { |
| return status; |
| } |
| |
| if (slice_type == AVC_P_SLICE || slice_type == AVC_SP_SLICE || slice_type == AVC_B_SLICE) |
| { |
| status = BitstreamWrite1Bit(stream, sliceHdr->num_ref_idx_active_override_flag); |
| if (sliceHdr->num_ref_idx_active_override_flag) |
| { |
| /* we shouldn't enter this part at all */ |
| status = ue_v(stream, sliceHdr->num_ref_idx_l0_active_minus1); |
| if (slice_type == AVC_B_SLICE) |
| { |
| status = ue_v(stream, sliceHdr->num_ref_idx_l1_active_minus1); |
| } |
| } |
| } |
| if (status != AVCENC_SUCCESS) |
| { |
| return status; |
| } |
| |
| /* ref_pic_list_reordering() */ |
| status = ref_pic_list_reordering(video, stream, sliceHdr, slice_type); |
| if (status != AVCENC_SUCCESS) |
| { |
| return status; |
| } |
| |
| if ((currPPS->weighted_pred_flag && (slice_type == AVC_P_SLICE || slice_type == AVC_SP_SLICE)) || |
| (currPPS->weighted_bipred_idc == 1 && slice_type == AVC_B_SLICE)) |
| { |
| // pred_weight_table(); // not supported !! |
| return AVCENC_PRED_WEIGHT_TAB_FAIL; |
| } |
| |
| if (video->nal_ref_idc != 0) |
| { |
| status = dec_ref_pic_marking(video, stream, sliceHdr); |
| if (status != AVCENC_SUCCESS) |
| { |
| return status; |
| } |
| } |
| |
| if (currPPS->entropy_coding_mode_flag && slice_type != AVC_I_SLICE && slice_type != AVC_SI_SLICE) |
| { |
| return AVCENC_CABAC_FAIL; |
| /* ue_v(stream,&(sliceHdr->cabac_init_idc)); |
| if(sliceHdr->cabac_init_idc > 2){ |
| // not supported !!!! |
| }*/ |
| } |
| |
| status = se_v(stream, sliceHdr->slice_qp_delta); |
| if (status != AVCENC_SUCCESS) |
| { |
| return status; |
| } |
| |
| if (slice_type == AVC_SP_SLICE || slice_type == AVC_SI_SLICE) |
| { |
| if (slice_type == AVC_SP_SLICE) |
| { |
| status = BitstreamWrite1Bit(stream, sliceHdr->sp_for_switch_flag); |
| /* if sp_for_switch_flag is 0, P macroblocks in SP slice is decoded using |
| SP decoding process for non-switching pictures in 8.6.1 */ |
| /* else, P macroblocks in SP slice is decoded using SP and SI decoding |
| process for switching picture in 8.6.2 */ |
| } |
| status = se_v(stream, sliceHdr->slice_qs_delta); |
| if (status != AVCENC_SUCCESS) |
| { |
| return status; |
| } |
| } |
| |
| if (currPPS->deblocking_filter_control_present_flag) |
| { |
| |
| status = ue_v(stream, sliceHdr->disable_deblocking_filter_idc); |
| |
| if (sliceHdr->disable_deblocking_filter_idc != 1) |
| { |
| status = se_v(stream, sliceHdr->slice_alpha_c0_offset_div2); |
| |
| status = se_v(stream, sliceHdr->slice_beta_offset_div_2); |
| } |
| if (status != AVCENC_SUCCESS) |
| { |
| return status; |
| } |
| } |
| |
| if (currPPS->num_slice_groups_minus1 > 0 && currPPS->slice_group_map_type >= 3 |
| && currPPS->slice_group_map_type <= 5) |
| { |
| /* Ceil(Log2(PicSizeInMapUnits/(float)SliceGroupChangeRate + 1)) */ |
| temp = video->PicSizeInMapUnits / video->SliceGroupChangeRate; |
| if (video->PicSizeInMapUnits % video->SliceGroupChangeRate) |
| { |
| temp++; |
| } |
| i = 0; |
| while (temp > 1) |
| { |
| temp >>= 1; |
| i++; |
| } |
| |
| BitstreamWriteBits(stream, i, sliceHdr->slice_group_change_cycle); |
| } |
| |
| |
| encvid->rateCtrl->NumberofHeaderBits += (stream->write_pos << 3) - stream->bit_left - num_bits; |
| |
| return AVCENC_SUCCESS; |
| } |
| |
| /** see subclause 7.4.3.1 */ |
| AVCEnc_Status ref_pic_list_reordering(AVCCommonObj *video, AVCEncBitstream *stream, AVCSliceHeader *sliceHdr, int slice_type) |
| { |
| (void)(video); |
| int i; |
| AVCEnc_Status status = AVCENC_SUCCESS; |
| |
| if (slice_type != AVC_I_SLICE && slice_type != AVC_SI_SLICE) |
| { |
| status = BitstreamWrite1Bit(stream, sliceHdr->ref_pic_list_reordering_flag_l0); |
| if (sliceHdr->ref_pic_list_reordering_flag_l0) |
| { |
| i = 0; |
| do |
| { |
| status = ue_v(stream, sliceHdr->reordering_of_pic_nums_idc_l0[i]); |
| if (sliceHdr->reordering_of_pic_nums_idc_l0[i] == 0 || |
| sliceHdr->reordering_of_pic_nums_idc_l0[i] == 1) |
| { |
| status = ue_v(stream, sliceHdr->abs_diff_pic_num_minus1_l0[i]); |
| /* this check should be in InitSlice(), if we ever use it */ |
| /*if(sliceHdr->reordering_of_pic_nums_idc_l0[i] == 0 && |
| sliceHdr->abs_diff_pic_num_minus1_l0[i] > video->MaxPicNum/2 -1) |
| { |
| return AVCENC_REF_PIC_REORDER_FAIL; // out of range |
| } |
| if(sliceHdr->reordering_of_pic_nums_idc_l0[i] == 1 && |
| sliceHdr->abs_diff_pic_num_minus1_l0[i] > video->MaxPicNum/2 -2) |
| { |
| return AVCENC_REF_PIC_REORDER_FAIL; // out of range |
| }*/ |
| } |
| else if (sliceHdr->reordering_of_pic_nums_idc_l0[i] == 2) |
| { |
| status = ue_v(stream, sliceHdr->long_term_pic_num_l0[i]); |
| } |
| i++; |
| } |
| while (sliceHdr->reordering_of_pic_nums_idc_l0[i] != 3 |
| && i <= (int)sliceHdr->num_ref_idx_l0_active_minus1 + 1) ; |
| } |
| } |
| if (slice_type == AVC_B_SLICE) |
| { |
| status = BitstreamWrite1Bit(stream, sliceHdr->ref_pic_list_reordering_flag_l1); |
| if (sliceHdr->ref_pic_list_reordering_flag_l1) |
| { |
| i = 0; |
| do |
| { |
| status = ue_v(stream, sliceHdr->reordering_of_pic_nums_idc_l1[i]); |
| if (sliceHdr->reordering_of_pic_nums_idc_l1[i] == 0 || |
| sliceHdr->reordering_of_pic_nums_idc_l1[i] == 1) |
| { |
| status = ue_v(stream, sliceHdr->abs_diff_pic_num_minus1_l1[i]); |
| /* This check should be in InitSlice() if we ever use it |
| if(sliceHdr->reordering_of_pic_nums_idc_l1[i] == 0 && |
| sliceHdr->abs_diff_pic_num_minus1_l1[i] > video->MaxPicNum/2 -1) |
| { |
| return AVCENC_REF_PIC_REORDER_FAIL; // out of range |
| } |
| if(sliceHdr->reordering_of_pic_nums_idc_l1[i] == 1 && |
| sliceHdr->abs_diff_pic_num_minus1_l1[i] > video->MaxPicNum/2 -2) |
| { |
| return AVCENC_REF_PIC_REORDER_FAIL; // out of range |
| }*/ |
| } |
| else if (sliceHdr->reordering_of_pic_nums_idc_l1[i] == 2) |
| { |
| status = ue_v(stream, sliceHdr->long_term_pic_num_l1[i]); |
| } |
| i++; |
| } |
| while (sliceHdr->reordering_of_pic_nums_idc_l1[i] != 3 |
| && i <= (int)sliceHdr->num_ref_idx_l1_active_minus1 + 1) ; |
| } |
| } |
| |
| return status; |
| } |
| |
| /** see subclause 7.4.3.3 */ |
| AVCEnc_Status dec_ref_pic_marking(AVCCommonObj *video, AVCEncBitstream *stream, AVCSliceHeader *sliceHdr) |
| { |
| int i; |
| AVCEnc_Status status = AVCENC_SUCCESS; |
| |
| if (video->nal_unit_type == AVC_NALTYPE_IDR) |
| { |
| status = BitstreamWrite1Bit(stream, sliceHdr->no_output_of_prior_pics_flag); |
| status = BitstreamWrite1Bit(stream, sliceHdr->long_term_reference_flag); |
| if (sliceHdr->long_term_reference_flag == 0) /* used for short-term */ |
| { |
| video->MaxLongTermFrameIdx = -1; /* no long-term frame indx */ |
| } |
| else /* used for long-term */ |
| { |
| video->MaxLongTermFrameIdx = 0; |
| video->LongTermFrameIdx = 0; |
| } |
| } |
| else |
| { |
| status = BitstreamWrite1Bit(stream, sliceHdr->adaptive_ref_pic_marking_mode_flag); /* default to zero */ |
| if (sliceHdr->adaptive_ref_pic_marking_mode_flag) |
| { |
| i = 0; |
| do |
| { |
| status = ue_v(stream, sliceHdr->memory_management_control_operation[i]); |
| if (sliceHdr->memory_management_control_operation[i] == 1 || |
| sliceHdr->memory_management_control_operation[i] == 3) |
| { |
| status = ue_v(stream, sliceHdr->difference_of_pic_nums_minus1[i]); |
| } |
| if (sliceHdr->memory_management_control_operation[i] == 2) |
| { |
| status = ue_v(stream, sliceHdr->long_term_pic_num[i]); |
| } |
| if (sliceHdr->memory_management_control_operation[i] == 3 || |
| sliceHdr->memory_management_control_operation[i] == 6) |
| { |
| status = ue_v(stream, sliceHdr->long_term_frame_idx[i]); |
| } |
| if (sliceHdr->memory_management_control_operation[i] == 4) |
| { |
| status = ue_v(stream, sliceHdr->max_long_term_frame_idx_plus1[i]); |
| } |
| i++; |
| } |
| while (sliceHdr->memory_management_control_operation[i] != 0 && i < MAX_DEC_REF_PIC_MARKING); |
| if (i >= MAX_DEC_REF_PIC_MARKING && sliceHdr->memory_management_control_operation[i] != 0) |
| { |
| return AVCENC_DEC_REF_PIC_MARK_FAIL; /* we're screwed!!, not enough memory */ |
| } |
| } |
| } |
| |
| return status; |
| } |
| |
| /* see subclause 8.2.1 Decoding process for picture order count. |
| See also PostPOC() for initialization of some variables. */ |
| AVCEnc_Status InitPOC(AVCEncObject *encvid) |
| { |
| AVCCommonObj *video = encvid->common; |
| AVCSeqParamSet *currSPS = video->currSeqParams; |
| AVCSliceHeader *sliceHdr = video->sliceHdr; |
| AVCFrameIO *currInput = encvid->currInput; |
| int i; |
| |
| switch (currSPS->pic_order_cnt_type) |
| { |
| case 0: /* POC MODE 0 , subclause 8.2.1.1 */ |
| /* encoding part */ |
| if (video->nal_unit_type == AVC_NALTYPE_IDR) |
| { |
| encvid->dispOrdPOCRef = currInput->disp_order; |
| } |
| while (currInput->disp_order < encvid->dispOrdPOCRef) |
| { |
| encvid->dispOrdPOCRef -= video->MaxPicOrderCntLsb; |
| } |
| sliceHdr->pic_order_cnt_lsb = currInput->disp_order - encvid->dispOrdPOCRef; |
| while (sliceHdr->pic_order_cnt_lsb >= video->MaxPicOrderCntLsb) |
| { |
| sliceHdr->pic_order_cnt_lsb -= video->MaxPicOrderCntLsb; |
| } |
| /* decoding part */ |
| /* Calculate the MSBs of current picture */ |
| if (video->nal_unit_type == AVC_NALTYPE_IDR) |
| { |
| video->prevPicOrderCntMsb = 0; |
| video->prevPicOrderCntLsb = 0; |
| } |
| if (sliceHdr->pic_order_cnt_lsb < video->prevPicOrderCntLsb && |
| (video->prevPicOrderCntLsb - sliceHdr->pic_order_cnt_lsb) >= (video->MaxPicOrderCntLsb / 2)) |
| video->PicOrderCntMsb = video->prevPicOrderCntMsb + video->MaxPicOrderCntLsb; |
| else if (sliceHdr->pic_order_cnt_lsb > video->prevPicOrderCntLsb && |
| (sliceHdr->pic_order_cnt_lsb - video->prevPicOrderCntLsb) > (video->MaxPicOrderCntLsb / 2)) |
| video->PicOrderCntMsb = video->prevPicOrderCntMsb - video->MaxPicOrderCntLsb; |
| else |
| video->PicOrderCntMsb = video->prevPicOrderCntMsb; |
| |
| /* JVT-I010 page 81 is different from JM7.3 */ |
| if (!sliceHdr->field_pic_flag || !sliceHdr->bottom_field_flag) |
| { |
| video->PicOrderCnt = video->TopFieldOrderCnt = video->PicOrderCntMsb + sliceHdr->pic_order_cnt_lsb; |
| } |
| |
| if (!sliceHdr->field_pic_flag) |
| { |
| video->BottomFieldOrderCnt = video->TopFieldOrderCnt + sliceHdr->delta_pic_order_cnt_bottom; |
| } |
| else if (sliceHdr->bottom_field_flag) |
| { |
| video->PicOrderCnt = video->BottomFieldOrderCnt = video->PicOrderCntMsb + sliceHdr->pic_order_cnt_lsb; |
| } |
| |
| if (!sliceHdr->field_pic_flag) |
| { |
| video->PicOrderCnt = AVC_MIN(video->TopFieldOrderCnt, video->BottomFieldOrderCnt); |
| } |
| |
| if (video->currPicParams->pic_order_present_flag && !sliceHdr->field_pic_flag) |
| { |
| sliceHdr->delta_pic_order_cnt_bottom = 0; /* defaulted to zero */ |
| } |
| |
| break; |
| case 1: /* POC MODE 1, subclause 8.2.1.2 */ |
| /* calculate FrameNumOffset */ |
| if (video->nal_unit_type == AVC_NALTYPE_IDR) |
| { |
| encvid->dispOrdPOCRef = currInput->disp_order; /* reset the reference point */ |
| video->prevFrameNumOffset = 0; |
| video->FrameNumOffset = 0; |
| } |
| else if (video->prevFrameNum > sliceHdr->frame_num) |
| { |
| video->FrameNumOffset = video->prevFrameNumOffset + video->MaxFrameNum; |
| } |
| else |
| { |
| video->FrameNumOffset = video->prevFrameNumOffset; |
| } |
| /* calculate absFrameNum */ |
| if (currSPS->num_ref_frames_in_pic_order_cnt_cycle) |
| { |
| video->absFrameNum = video->FrameNumOffset + sliceHdr->frame_num; |
| } |
| else |
| { |
| video->absFrameNum = 0; |
| } |
| |
| if (video->absFrameNum > 0 && video->nal_ref_idc == 0) |
| { |
| video->absFrameNum--; |
| } |
| |
| /* derive picOrderCntCycleCnt and frameNumInPicOrderCntCycle */ |
| if (video->absFrameNum > 0) |
| { |
| video->picOrderCntCycleCnt = (video->absFrameNum - 1) / currSPS->num_ref_frames_in_pic_order_cnt_cycle; |
| video->frameNumInPicOrderCntCycle = (video->absFrameNum - 1) % currSPS->num_ref_frames_in_pic_order_cnt_cycle; |
| } |
| /* derive expectedDeltaPerPicOrderCntCycle, this value can be computed up front. */ |
| video->expectedDeltaPerPicOrderCntCycle = 0; |
| for (i = 0; i < (int)currSPS->num_ref_frames_in_pic_order_cnt_cycle; i++) |
| { |
| video->expectedDeltaPerPicOrderCntCycle += currSPS->offset_for_ref_frame[i]; |
| } |
| /* derive expectedPicOrderCnt */ |
| if (video->absFrameNum) |
| { |
| video->expectedPicOrderCnt = video->picOrderCntCycleCnt * video->expectedDeltaPerPicOrderCntCycle; |
| for (i = 0; i <= video->frameNumInPicOrderCntCycle; i++) |
| { |
| video->expectedPicOrderCnt += currSPS->offset_for_ref_frame[i]; |
| } |
| } |
| else |
| { |
| video->expectedPicOrderCnt = 0; |
| } |
| |
| if (video->nal_ref_idc == 0) |
| { |
| video->expectedPicOrderCnt += currSPS->offset_for_non_ref_pic; |
| } |
| /* derive TopFieldOrderCnt and BottomFieldOrderCnt */ |
| /* encoding part */ |
| if (!currSPS->delta_pic_order_always_zero_flag) |
| { |
| sliceHdr->delta_pic_order_cnt[0] = currInput->disp_order - encvid->dispOrdPOCRef - video->expectedPicOrderCnt; |
| |
| if (video->currPicParams->pic_order_present_flag && !sliceHdr->field_pic_flag) |
| { |
| sliceHdr->delta_pic_order_cnt[1] = sliceHdr->delta_pic_order_cnt[0]; /* should be calculated from currInput->bottom_field->disp_order */ |
| } |
| else |
| { |
| sliceHdr->delta_pic_order_cnt[1] = 0; |
| } |
| } |
| else |
| { |
| sliceHdr->delta_pic_order_cnt[0] = sliceHdr->delta_pic_order_cnt[1] = 0; |
| } |
| |
| if (sliceHdr->field_pic_flag == 0) |
| { |
| video->TopFieldOrderCnt = video->expectedPicOrderCnt + sliceHdr->delta_pic_order_cnt[0]; |
| video->BottomFieldOrderCnt = video->TopFieldOrderCnt + currSPS->offset_for_top_to_bottom_field + sliceHdr->delta_pic_order_cnt[1]; |
| |
| video->PicOrderCnt = AVC_MIN(video->TopFieldOrderCnt, video->BottomFieldOrderCnt); |
| } |
| else if (sliceHdr->bottom_field_flag == 0) |
| { |
| video->TopFieldOrderCnt = video->expectedPicOrderCnt + sliceHdr->delta_pic_order_cnt[0]; |
| video->PicOrderCnt = video->TopFieldOrderCnt; |
| } |
| else |
| { |
| video->BottomFieldOrderCnt = video->expectedPicOrderCnt + currSPS->offset_for_top_to_bottom_field + sliceHdr->delta_pic_order_cnt[0]; |
| video->PicOrderCnt = video->BottomFieldOrderCnt; |
| } |
| break; |
| |
| |
| case 2: /* POC MODE 2, subclause 8.2.1.3 */ |
| /* decoding order must be the same as display order */ |
| /* we don't check for that. The decoder will just output in decoding order. */ |
| /* Check for 2 consecutive non-reference frame */ |
| if (video->nal_ref_idc == 0) |
| { |
| if (encvid->dispOrdPOCRef == 1) |
| { |
| return AVCENC_CONSECUTIVE_NONREF; |
| } |
| encvid->dispOrdPOCRef = 1; /* act as a flag for non ref */ |
| } |
| else |
| { |
| encvid->dispOrdPOCRef = 0; |
| } |
| |
| |
| if (video->nal_unit_type == AVC_NALTYPE_IDR) |
| { |
| video->FrameNumOffset = 0; |
| } |
| else if (video->prevFrameNum > sliceHdr->frame_num) |
| { |
| video->FrameNumOffset = video->prevFrameNumOffset + video->MaxFrameNum; |
| } |
| else |
| { |
| video->FrameNumOffset = video->prevFrameNumOffset; |
| } |
| /* derive tempPicOrderCnt, we just use PicOrderCnt */ |
| if (video->nal_unit_type == AVC_NALTYPE_IDR) |
| { |
| video->PicOrderCnt = 0; |
| } |
| else if (video->nal_ref_idc == 0) |
| { |
| video->PicOrderCnt = 2 * (video->FrameNumOffset + sliceHdr->frame_num) - 1; |
| } |
| else |
| { |
| video->PicOrderCnt = 2 * (video->FrameNumOffset + sliceHdr->frame_num); |
| } |
| /* derive TopFieldOrderCnt and BottomFieldOrderCnt */ |
| if (sliceHdr->field_pic_flag == 0) |
| { |
| video->TopFieldOrderCnt = video->BottomFieldOrderCnt = video->PicOrderCnt; |
| } |
| else if (sliceHdr->bottom_field_flag) |
| { |
| video->BottomFieldOrderCnt = video->PicOrderCnt; |
| } |
| else |
| { |
| video->TopFieldOrderCnt = video->PicOrderCnt; |
| } |
| break; |
| default: |
| return AVCENC_POC_FAIL; |
| } |
| |
| return AVCENC_SUCCESS; |
| } |
| |
| /** see subclause 8.2.1 */ |
| AVCEnc_Status PostPOC(AVCCommonObj *video) |
| { |
| AVCSliceHeader *sliceHdr = video->sliceHdr; |
| AVCSeqParamSet *currSPS = video->currSeqParams; |
| |
| video->prevFrameNum = sliceHdr->frame_num; |
| |
| switch (currSPS->pic_order_cnt_type) |
| { |
| case 0: /* subclause 8.2.1.1 */ |
| if (video->mem_mgr_ctrl_eq_5) |
| { |
| video->prevPicOrderCntMsb = 0; |
| video->prevPicOrderCntLsb = video->TopFieldOrderCnt; |
| } |
| else |
| { |
| video->prevPicOrderCntMsb = video->PicOrderCntMsb; |
| video->prevPicOrderCntLsb = sliceHdr->pic_order_cnt_lsb; |
| } |
| break; |
| case 1: /* subclause 8.2.1.2 and 8.2.1.3 */ |
| case 2: |
| if (video->mem_mgr_ctrl_eq_5) |
| { |
| video->prevFrameNumOffset = 0; |
| } |
| else |
| { |
| video->prevFrameNumOffset = video->FrameNumOffset; |
| } |
| break; |
| } |
| |
| return AVCENC_SUCCESS; |
| } |
| |
