| /* |
| * Copyright (C) 2017 Amlogic, Inc. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for |
| * more details. |
| * |
| * You should have received a copy of the GNU General Public License along |
| * with this program; if not, write to the Free Software Foundation, Inc., |
| * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. |
| * |
| * Description: |
| */ |
| #include <linux/kernel.h> |
| #include <linux/module.h> |
| #include <linux/types.h> |
| #include <linux/errno.h> |
| #include <linux/interrupt.h> |
| #include <linux/semaphore.h> |
| #include <linux/delay.h> |
| #include <linux/timer.h> |
| #include <linux/kfifo.h> |
| #include <linux/kthread.h> |
| #include <linux/spinlock.h> |
| #include <linux/platform_device.h> |
| #include <linux/amlogic/media/vfm/vframe.h> |
| #include <linux/amlogic/media/utils/amstream.h> |
| #include <linux/amlogic/media/utils/vformat.h> |
| #include <linux/amlogic/media/frame_sync/ptsserv.h> |
| #include <linux/amlogic/media/canvas/canvas.h> |
| #include <linux/amlogic/media/vfm/vframe_provider.h> |
| #include <linux/amlogic/media/vfm/vframe_receiver.h> |
| #include <linux/dma-mapping.h> |
| #include <linux/dma-contiguous.h> |
| #include <linux/slab.h> |
| //#include <linux/amlogic/tee.h> |
| #include <uapi/linux/tee.h> |
| #include <linux/sched/clock.h> |
| #include "../../../stream_input/amports/amports_priv.h" |
| #include <linux/amlogic/media/codec_mm/codec_mm.h> |
| #include "../utils/decoder_mmu_box.h" |
| #include "../utils/decoder_bmmu_box.h" |
| #include "avs2_global.h" |
| |
| #include <linux/amlogic/media/utils/vdec_reg.h> |
| #include "../utils/vdec.h" |
| #include "../utils/amvdec.h" |
| |
| #undef pr_info |
| #define pr_info printk |
| |
| #define assert(chk_cond) {\ |
| if (!(chk_cond))\ |
| pr_info("error line %d\n", __LINE__);\ |
| while (!(chk_cond))\ |
| ;\ |
| } |
| |
| int16_t get_param(uint16_t value, int8_t *print_info) |
| { |
| if (is_avs2_print_param()) |
| pr_info("%s = %x\n", print_info, value); |
| return (int16_t)value; |
| } |
| |
| void readAlfCoeff(struct avs2_decoder *avs2_dec, struct ALFParam_s *Alfp) |
| { |
| int32_t pos; |
| union param_u *rpm_param = &avs2_dec->param; |
| |
| int32_t f = 0, symbol, pre_symbole; |
| const int32_t numCoeff = (int32_t)ALF_MAX_NUM_COEF; |
| |
| switch (Alfp->componentID) { |
| case ALF_Cb: |
| case ALF_Cr: { |
| for (pos = 0; pos < numCoeff; pos++) { |
| if (Alfp->componentID == ALF_Cb) |
| Alfp->coeffmulti[0][pos] = |
| get_param( |
| rpm_param->alf.alf_cb_coeffmulti[pos], |
| "Chroma ALF coefficients"); |
| else |
| Alfp->coeffmulti[0][pos] = |
| get_param( |
| rpm_param->alf.alf_cr_coeffmulti[pos], |
| "Chroma ALF coefficients"); |
| #if Check_Bitstream |
| if (pos <= 7) |
| assert(Alfp->coeffmulti[0][pos] >= -64 |
| && Alfp->coeffmulti[0][pos] <= 63); |
| if (pos == 8) |
| assert(Alfp->coeffmulti[0][pos] >= -1088 |
| && Alfp->coeffmulti[0][pos] <= 1071); |
| #endif |
| } |
| } |
| break; |
| case ALF_Y: { |
| int32_t region_distance_idx = 0; |
| Alfp->filters_per_group = |
| get_param(rpm_param->alf.alf_filters_num_m_1, |
| "ALF_filter_number_minus_1"); |
| #if Check_Bitstream |
| assert(Alfp->filters_per_group >= 0 |
| && Alfp->filters_per_group <= 15); |
| #endif |
| Alfp->filters_per_group = Alfp->filters_per_group + 1; |
| |
| memset(Alfp->filterPattern, 0, NO_VAR_BINS * sizeof(int32_t)); |
| pre_symbole = 0; |
| symbol = 0; |
| for (f = 0; f < Alfp->filters_per_group; f++) { |
| if (f > 0) { |
| if (Alfp->filters_per_group != 16) { |
| symbol = |
| get_param(rpm_param->alf.region_distance |
| [region_distance_idx++], |
| "Region distance"); |
| } else { |
| symbol = 1; |
| } |
| Alfp->filterPattern[symbol + pre_symbole] = 1; |
| pre_symbole = symbol + pre_symbole; |
| } |
| |
| for (pos = 0; pos < numCoeff; pos++) { |
| Alfp->coeffmulti[f][pos] = |
| get_param( |
| rpm_param->alf.alf_y_coeffmulti[f][pos], |
| "Luma ALF coefficients"); |
| #if Check_Bitstream |
| if (pos <= 7) |
| assert( |
| Alfp->coeffmulti[f][pos] |
| >= -64 && |
| Alfp->coeffmulti[f][pos] |
| <= 63); |
| if (pos == 8) |
| assert( |
| Alfp->coeffmulti[f][pos] |
| >= -1088 && |
| Alfp->coeffmulti[f][pos] |
| <= 1071); |
| #endif |
| |
| } |
| } |
| |
| #if Check_Bitstream |
| assert(pre_symbole >= 0 && pre_symbole <= 15); |
| |
| #endif |
| } |
| break; |
| default: { |
| pr_info("Not a legal component ID\n"); |
| assert(0); |
| return; /* exit(-1);*/ |
| } |
| } |
| } |
| |
| void Read_ALF_param(struct avs2_decoder *avs2_dec) |
| { |
| struct inp_par *input = &avs2_dec->input; |
| struct ImageParameters_s *img = &avs2_dec->img; |
| union param_u *rpm_param = &avs2_dec->param; |
| int32_t compIdx; |
| if (input->alf_enable) { |
| img->pic_alf_on[0] = |
| get_param( |
| rpm_param->alf.picture_alf_enable_Y, |
| "alf_pic_flag_Y"); |
| img->pic_alf_on[1] = |
| get_param( |
| rpm_param->alf.picture_alf_enable_Cb, |
| "alf_pic_flag_Cb"); |
| img->pic_alf_on[2] = |
| get_param( |
| rpm_param->alf.picture_alf_enable_Cr, |
| "alf_pic_flag_Cr"); |
| |
| avs2_dec->m_alfPictureParam[ALF_Y].alf_flag |
| = img->pic_alf_on[ALF_Y]; |
| avs2_dec->m_alfPictureParam[ALF_Cb].alf_flag |
| = img->pic_alf_on[ALF_Cb]; |
| avs2_dec->m_alfPictureParam[ALF_Cr].alf_flag |
| = img->pic_alf_on[ALF_Cr]; |
| if (img->pic_alf_on[0] |
| || img->pic_alf_on[1] |
| || img->pic_alf_on[2]) { |
| for (compIdx = 0; |
| compIdx < NUM_ALF_COMPONENT; |
| compIdx++) { |
| if (img->pic_alf_on[compIdx]) { |
| readAlfCoeff( |
| avs2_dec, |
| &avs2_dec->m_alfPictureParam[compIdx]); |
| } |
| } |
| } |
| } |
| |
| } |
| |
| void Get_SequenceHeader(struct avs2_decoder *avs2_dec) |
| { |
| struct inp_par *input = &avs2_dec->input; |
| struct ImageParameters_s *img = &avs2_dec->img; |
| struct Video_Com_data_s *hc = &avs2_dec->hc; |
| struct Video_Dec_data_s *hd = &avs2_dec->hd; |
| union param_u *rpm_param = &avs2_dec->param; |
| /*int32_t i, j;*/ |
| |
| /*fpr_info(stdout, "Sequence Header\n");*/ |
| /*memcpy(currStream->streamBuffer, buf, length);*/ |
| /*currStream->code_len = currStream->bitstream_length = length;*/ |
| /*currStream->read_len = currStream->frame_bitoffset = (startcodepos + |
| 1) * 8;*/ |
| |
| input->profile_id = |
| get_param(rpm_param->p.profile_id, "profile_id"); |
| input->level_id = |
| get_param(rpm_param->p.level_id, "level_id"); |
| hd->progressive_sequence = |
| get_param( |
| rpm_param->p.progressive_sequence, |
| "progressive_sequence"); |
| #if INTERLACE_CODING |
| hd->is_field_sequence = |
| get_param( |
| rpm_param->p.is_field_sequence, |
| "field_coded_sequence"); |
| #endif |
| #if HALF_PIXEL_COMPENSATION || HALF_PIXEL_CHROMA |
| img->is_field_sequence = hd->is_field_sequence; |
| #endif |
| hd->horizontal_size = |
| get_param(rpm_param->p.horizontal_size, "horizontal_size"); |
| hd->vertical_size = |
| get_param(rpm_param->p.vertical_size, "vertical_size"); |
| input->chroma_format = |
| get_param(rpm_param->p.chroma_format, "chroma_format"); |
| input->output_bit_depth = 8; |
| input->sample_bit_depth = 8; |
| hd->sample_precision = 1; |
| if (input->profile_id == BASELINE10_PROFILE) { /* 10bit profile (0x52)*/ |
| input->output_bit_depth = |
| get_param(rpm_param->p.sample_precision, |
| "sample_precision"); |
| input->output_bit_depth = |
| 6 + (input->output_bit_depth) * 2; |
| input->sample_bit_depth = |
| get_param(rpm_param->p.encoding_precision, |
| "encoding_precision"); |
| input->sample_bit_depth = |
| 6 + (input->sample_bit_depth) * 2; |
| } else { /* other profile*/ |
| hd->sample_precision = |
| get_param(rpm_param->p.sample_precision, |
| "sample_precision"); |
| } |
| hd->aspect_ratio_information = |
| get_param(rpm_param->p.aspect_ratio_information, |
| "aspect_ratio_information"); |
| hd->frame_rate_code = |
| get_param(rpm_param->p.frame_rate_code, "frame_rate_code"); |
| |
| hd->bit_rate_lower = |
| get_param(rpm_param->p.bit_rate_lower, "bit_rate_lower"); |
| /*hd->marker_bit = get_param(rpm_param->p.marker_bit, |
| * "marker bit");*/ |
| /*CHECKMARKERBIT*/ |
| hd->bit_rate_upper = |
| get_param(rpm_param->p.bit_rate_upper, "bit_rate_upper"); |
| hd->low_delay = |
| get_param(rpm_param->p.low_delay, "low_delay"); |
| /*hd->marker_bit = |
| get_param(rpm_param->p.marker_bit2, |
| "marker bit");*/ |
| /*CHECKMARKERBIT*/ |
| #if M3480_TEMPORAL_SCALABLE |
| hd->temporal_id_exist_flag = |
| get_param(rpm_param->p.temporal_id_exist_flag, |
| "temporal_id exist flag"); /*get |
| Extention Flag*/ |
| #endif |
| /*u_v(18, "bbv buffer size");*/ |
| input->g_uiMaxSizeInBit = |
| get_param(rpm_param->p.g_uiMaxSizeInBit, |
| "Largest Coding Block Size"); |
| |
| |
| /*hd->background_picture_enable = 0x01 ^ |
| (get_param(rpm_param->p.avs2_seq_flags, |
| "background_picture_disable") |
| >> BACKGROUND_PICTURE_DISABLE_BIT) & 0x1;*/ |
| /*rain???*/ |
| hd->background_picture_enable = 0x01 ^ |
| ((get_param(rpm_param->p.avs2_seq_flags, |
| "background_picture_disable") |
| >> BACKGROUND_PICTURE_DISABLE_BIT) & 0x1); |
| |
| |
| hd->b_dmh_enabled = 1; |
| |
| hd->b_mhpskip_enabled = |
| get_param(rpm_param->p.avs2_seq_flags >> B_MHPSKIP_ENABLED_BIT, |
| "mhpskip enabled") & 0x1; |
| hd->dhp_enabled = |
| get_param(rpm_param->p.avs2_seq_flags >> DHP_ENABLED_BIT, |
| "dhp enabled") & 0x1; |
| hd->wsm_enabled = |
| get_param(rpm_param->p.avs2_seq_flags >> WSM_ENABLED_BIT, |
| "wsm enabled") & 0x1; |
| |
| img->inter_amp_enable = |
| get_param(rpm_param->p.avs2_seq_flags >> INTER_AMP_ENABLE_BIT, |
| "Asymmetric Motion Partitions") & 0x1; |
| input->useNSQT = |
| get_param(rpm_param->p.avs2_seq_flags >> USENSQT_BIT, |
| "useNSQT") & 0x1; |
| input->useSDIP = |
| get_param(rpm_param->p.avs2_seq_flags >> USESDIP_BIT, |
| "useNSIP") & 0x1; |
| |
| hd->b_secT_enabled = |
| get_param(rpm_param->p.avs2_seq_flags >> B_SECT_ENABLED_BIT, |
| "secT enabled") & 0x1; |
| |
| input->sao_enable = |
| get_param(rpm_param->p.avs2_seq_flags >> SAO_ENABLE_BIT, |
| "SAO Enable Flag") & 0x1; |
| input->alf_enable = |
| get_param(rpm_param->p.avs2_seq_flags >> ALF_ENABLE_BIT, |
| "ALF Enable Flag") & 0x1; |
| hd->b_pmvr_enabled = |
| get_param(rpm_param->p.avs2_seq_flags >> B_PMVR_ENABLED_BIT, |
| "pmvr enabled") & 0x1; |
| |
| |
| hd->gop_size = get_param(rpm_param->p.num_of_RPS, |
| "num_of_RPS"); |
| #if Check_Bitstream |
| /*assert(hd->gop_size<=32);*/ |
| #endif |
| |
| if (hd->low_delay == 0) { |
| hd->picture_reorder_delay = |
| get_param(rpm_param->p.picture_reorder_delay, |
| "picture_reorder_delay"); |
| } |
| |
| input->crossSliceLoopFilter = |
| get_param(rpm_param->p.avs2_seq_flags |
| >> CROSSSLICELOOPFILTER_BIT, |
| "Cross Loop Filter Flag") & 0x1; |
| |
| #if BCBR |
| if ((input->profile_id == SCENE_PROFILE || |
| input->profile_id == SCENE10_PROFILE) && |
| hd->background_picture_enable) { |
| hd->bcbr_enable = u_v(1, |
| "block_composed_background_picture_enable"); |
| u_v(1, "reserved bits"); |
| } else { |
| hd->bcbr_enable = 0; |
| u_v(2, "reserved bits"); |
| } |
| #else |
| /*u_v(2, "reserved bits");*/ |
| #endif |
| |
| img->width = hd->horizontal_size; |
| img->height = hd->vertical_size; |
| img->width_cr = (img->width >> 1); |
| |
| if (input->chroma_format == 1) { |
| img->height_cr |
| = (img->height >> 1); |
| } |
| |
| img->PicWidthInMbs = img->width / MIN_CU_SIZE; |
| img->PicHeightInMbs = img->height / MIN_CU_SIZE; |
| img->PicSizeInMbs = img->PicWidthInMbs * img->PicHeightInMbs; |
| img->buf_cycle = input->buf_cycle + 1; |
| img->max_mb_nr = (img->width * img->height) |
| / (MIN_CU_SIZE * MIN_CU_SIZE); |
| |
| #ifdef AML |
| avs2_dec->lcu_size = |
| get_param(rpm_param->p.lcu_size, "lcu_size"); |
| avs2_dec->lcu_size = 1<<(avs2_dec->lcu_size); |
| #endif |
| hc->seq_header++; |
| } |
| |
| |
| void Get_I_Picture_Header(struct avs2_decoder *avs2_dec) |
| { |
| struct ImageParameters_s *img = &avs2_dec->img; |
| struct Video_Dec_data_s *hd = &avs2_dec->hd; |
| union param_u *rpm_param = &avs2_dec->param; |
| |
| #if RD1501_FIX_BG /*//Longfei.Wang@mediatek.com*/ |
| hd->background_picture_flag = 0; |
| hd->background_picture_output_flag = 0; |
| img->typeb = 0; |
| #endif |
| |
| hd->time_code_flag = |
| get_param(rpm_param->p.time_code_flag, |
| "time_code_flag"); |
| |
| if (hd->time_code_flag) { |
| hd->time_code = |
| get_param(rpm_param->p.time_code, |
| "time_code"); |
| } |
| if (hd->background_picture_enable) { |
| hd->background_picture_flag = |
| get_param(rpm_param->p.background_picture_flag, |
| "background_picture_flag"); |
| |
| if (hd->background_picture_flag) { |
| img->typeb = |
| BACKGROUND_IMG; |
| } else { |
| img->typeb = 0; |
| } |
| |
| if (img->typeb == BACKGROUND_IMG) { |
| hd->background_picture_output_flag = |
| get_param( |
| rpm_param->p.background_picture_output_flag, |
| "background_picture_output_flag"); |
| } |
| } |
| |
| |
| { |
| img->coding_order = |
| get_param(rpm_param->p.coding_order, |
| "coding_order"); |
| |
| |
| |
| #if M3480_TEMPORAL_SCALABLE |
| if (hd->temporal_id_exist_flag == 1) { |
| hd->cur_layer = |
| get_param(rpm_param->p.cur_layer, |
| "temporal_id"); |
| } |
| #endif |
| #if RD1501_FIX_BG /*Longfei.Wang@mediatek.com*/ |
| if (hd->low_delay == 0 |
| && !(hd->background_picture_flag && |
| !hd->background_picture_output_flag)) { /*cdp*/ |
| #else |
| if (hd->low_delay == 0 && |
| !(hd->background_picture_enable && |
| !hd->background_picture_output_flag)) { /*cdp*/ |
| #endif |
| hd->displaydelay = |
| get_param(rpm_param->p.displaydelay, |
| "picture_output_delay"); |
| } |
| |
| } |
| { |
| int32_t RPS_idx;/* = (img->coding_order-1) % gop_size;*/ |
| int32_t predict; |
| int32_t j; |
| predict = |
| get_param(rpm_param->p.predict, |
| "use RCS in SPS"); |
| /*if (predict) {*/ |
| RPS_idx = |
| get_param(rpm_param->p.RPS_idx, |
| "predict for RCS"); |
| /* hd->curr_RPS = hd->decod_RPS[RPS_idx];*/ |
| /*} else {*/ |
| /*gop size16*/ |
| hd->curr_RPS.referd_by_others = |
| get_param(rpm_param->p.referd_by_others_cur, |
| "refered by others"); |
| hd->curr_RPS.num_of_ref = |
| get_param(rpm_param->p.num_of_ref_cur, |
| "num of reference picture"); |
| for (j = 0; j < hd->curr_RPS.num_of_ref; j++) { |
| hd->curr_RPS.ref_pic[j] = |
| get_param(rpm_param->p.ref_pic_cur[j], |
| "delta COI of ref pic"); |
| } |
| hd->curr_RPS.num_to_remove = |
| get_param(rpm_param->p.num_to_remove_cur, |
| "num of removed picture"); |
| #ifdef SANITY_CHECK |
| if (hd->curr_RPS.num_to_remove > MAXREF) { |
| hd->curr_RPS.num_to_remove = MAXREF; |
| pr_info("Warning, %s: num_to_remove %d beyond range, force to MAXREF\n", |
| __func__, hd->curr_RPS.num_to_remove); |
| } |
| #endif |
| |
| for (j = 0; j < hd->curr_RPS.num_to_remove; j++) { |
| hd->curr_RPS.remove_pic[j] = |
| get_param( |
| rpm_param->p.remove_pic_cur[j], |
| "delta COI of removed pic"); |
| } |
| /*u_v(1, "marker bit");*/ |
| |
| /*}*/ |
| } |
| /*xyji 12.23*/ |
| if (hd->low_delay) { |
| /*ue_v( |
| "bbv check times");*/ |
| } |
| |
| hd->progressive_frame = |
| get_param(rpm_param->p.progressive_frame, |
| "progressive_frame"); |
| |
| if (!hd->progressive_frame) { |
| img->picture_structure = |
| get_param(rpm_param->p.picture_structure, |
| "picture_structure"); |
| } else { |
| img->picture_structure |
| = 1; |
| } |
| |
| hd->top_field_first = |
| get_param(rpm_param->p.top_field_first, |
| "top_field_first"); |
| hd->repeat_first_field = |
| get_param(rpm_param->p.repeat_first_field, |
| "repeat_first_field"); |
| #if INTERLACE_CODING |
| if (hd->is_field_sequence) { |
| hd->is_top_field = |
| get_param(rpm_param->p.is_top_field, |
| "is_top_field"); |
| #if HALF_PIXEL_COMPENSATION || HALF_PIXEL_CHROMA |
| img->is_top_field = hd->is_top_field; |
| #endif |
| } |
| #endif |
| |
| |
| img->qp = hd->picture_qp; |
| |
| img->type = I_IMG; |
| |
| } |
| |
| /* |
| * Function:pb picture header |
| * Input: |
| * Output: |
| * Return: |
| * Attention: |
| */ |
| |
| void Get_PB_Picture_Header(struct avs2_decoder *avs2_dec) |
| { |
| struct ImageParameters_s *img = &avs2_dec->img; |
| struct Video_Dec_data_s *hd = &avs2_dec->hd; |
| union param_u *rpm_param = &avs2_dec->param; |
| |
| |
| /*u_v(32, "bbv delay");*/ |
| |
| hd->picture_coding_type = |
| get_param(rpm_param->p.picture_coding_type, |
| "picture_coding_type"); |
| |
| if (hd->background_picture_enable && |
| (hd->picture_coding_type == 1 || |
| hd->picture_coding_type == 3)) { |
| if (hd->picture_coding_type == 1) { |
| hd->background_pred_flag = |
| get_param( |
| rpm_param->p.background_pred_flag, |
| "background_pred_flag"); |
| } else { |
| hd->background_pred_flag = 0; |
| } |
| if (hd->background_pred_flag == 0) { |
| |
| hd->background_reference_enable = |
| get_param( |
| rpm_param-> |
| p.background_reference_enable, |
| "background_reference_enable"); |
| |
| } else { |
| #if RD170_FIX_BG |
| hd->background_reference_enable = 1; |
| #else |
| hd->background_reference_enable = 0; |
| #endif |
| } |
| |
| } else { |
| hd->background_pred_flag = 0; |
| hd->background_reference_enable = 0; |
| } |
| |
| |
| |
| if (hd->picture_coding_type == 1) { |
| img->type = |
| P_IMG; |
| } else if (hd->picture_coding_type == 3) { |
| img->type = |
| F_IMG; |
| } else { |
| img->type = |
| B_IMG; |
| } |
| |
| |
| if (hd->picture_coding_type == 1 && |
| hd->background_pred_flag) { |
| img->typeb = BP_IMG; |
| } else { |
| img->typeb = 0; |
| } |
| |
| |
| { |
| img->coding_order = |
| get_param( |
| rpm_param->p.coding_order, |
| "coding_order"); |
| |
| |
| #if M3480_TEMPORAL_SCALABLE |
| if (hd->temporal_id_exist_flag == 1) { |
| hd->cur_layer = |
| get_param(rpm_param->p.cur_layer, |
| "temporal_id"); |
| } |
| #endif |
| |
| if (hd->low_delay == 0) { |
| hd->displaydelay = |
| get_param(rpm_param->p.displaydelay, |
| "displaydelay"); |
| } |
| } |
| { |
| int32_t RPS_idx;/* = (img->coding_order-1) % gop_size;*/ |
| int32_t predict; |
| predict = |
| get_param(rpm_param->p.predict, |
| "use RPS in SPS"); |
| if (predict) { |
| RPS_idx = |
| get_param(rpm_param->p.RPS_idx, |
| "predict for RPS"); |
| hd->curr_RPS = hd->decod_RPS[RPS_idx]; |
| } /*else*/ |
| { |
| /*gop size16*/ |
| int32_t j; |
| hd->curr_RPS.referd_by_others = |
| get_param( |
| rpm_param->p.referd_by_others_cur, |
| "refered by others"); |
| hd->curr_RPS.num_of_ref = |
| get_param( |
| rpm_param->p.num_of_ref_cur, |
| "num of reference picture"); |
| for (j = 0; j < hd->curr_RPS.num_of_ref; j++) { |
| hd->curr_RPS.ref_pic[j] = |
| get_param( |
| rpm_param->p.ref_pic_cur[j], |
| "delta COI of ref pic"); |
| } |
| hd->curr_RPS.num_to_remove = |
| get_param( |
| rpm_param->p.num_to_remove_cur, |
| "num of removed picture"); |
| #ifdef SANITY_CHECK |
| if (hd->curr_RPS.num_to_remove > MAXREF) { |
| hd->curr_RPS.num_to_remove = MAXREF; |
| pr_info("Warning, %s: num_to_remove %d beyond range, force to MAXREF\n", |
| __func__, hd->curr_RPS.num_to_remove); |
| } |
| #endif |
| for (j = 0; |
| j < hd->curr_RPS.num_to_remove; j++) { |
| hd->curr_RPS.remove_pic[j] = |
| get_param( |
| rpm_param->p.remove_pic_cur[j], |
| "delta COI of removed pic"); |
| } |
| /*u_v(1, "marker bit");*/ |
| |
| } |
| } |
| /*xyji 12.23*/ |
| if (hd->low_delay) { |
| /*ue_v( |
| "bbv check times");*/ |
| } |
| |
| hd->progressive_frame = |
| get_param(rpm_param->p.progressive_frame, |
| "progressive_frame"); |
| |
| if (!hd->progressive_frame) { |
| img->picture_structure = |
| get_param(rpm_param->p.picture_structure, |
| "picture_structure"); |
| } else { |
| img->picture_structure = 1; |
| } |
| |
| hd->top_field_first = |
| get_param(rpm_param->p.top_field_first, |
| "top_field_first"); |
| hd->repeat_first_field = |
| get_param(rpm_param->p.repeat_first_field, |
| "repeat_first_field"); |
| #if INTERLACE_CODING |
| if (hd->is_field_sequence) { |
| hd->is_top_field = |
| get_param(rpm_param->p.is_top_field, |
| "is_top_field"); |
| #if HALF_PIXEL_COMPENSATION || HALF_PIXEL_CHROMA |
| img->is_top_field = hd->is_top_field; |
| #endif |
| /*u_v(1, "reserved bit for interlace coding");*/ |
| } |
| #endif |
| |
| #if Check_Bitstream |
| /*assert(hd->picture_qp>=0&&hd->picture_qp<=(63 + 8 * |
| (input->sample_bit_depth - 8)));*/ |
| #endif |
| |
| img->random_access_decodable_flag = |
| get_param(rpm_param->p.random_access_decodable_flag, |
| "random_access_decodable_flag"); |
| |
| img->qp = hd->picture_qp; |
| } |
| |
| |
| |
| |
| void calc_picture_distance(struct avs2_decoder *avs2_dec) |
| { |
| struct ImageParameters_s *img = &avs2_dec->img; |
| struct Video_Com_data_s *hc = &avs2_dec->hc; |
| struct Video_Dec_data_s *hd = &avs2_dec->hd; |
| /* |
| union param_u *rpm_param = &avs2_dec->param; |
| |
| for POC mode 0: |
| uint32_t MaxPicDistanceLsb = (1 << 8); |
| */ |
| if (img->coding_order < img->PrevPicDistanceLsb) |
| |
| { |
| int32_t i, j; |
| |
| hc->total_frames++; |
| for (i = 0; i < avs2_dec->ref_maxbuffer; i++) { |
| if ( |
| avs2_dec->fref[i]->imgtr_fwRefDistance |
| >= 0) { |
| avs2_dec->fref[i]-> |
| imgtr_fwRefDistance -= 256; |
| avs2_dec->fref[i]-> |
| imgcoi_ref -= 256; |
| } |
| #if RD170_FIX_BG |
| for (j = 0; j < MAXREF; j++) { |
| #else |
| for (j = 0; j < 4; j++) { |
| #endif |
| avs2_dec->fref[i]->ref_poc[j] -= 256; |
| } |
| } |
| for (i = 0; i < avs2_dec->outprint.buffer_num; i++) { |
| avs2_dec->outprint.stdoutdata[i].framenum -= 256; |
| avs2_dec->outprint.stdoutdata[i].tr -= 256; |
| } |
| |
| hd->last_output -= 256; |
| hd->curr_IDRtr -= 256; |
| hd->curr_IDRcoi -= 256; |
| hd->next_IDRtr -= 256; |
| hd->next_IDRcoi -= 256; |
| } |
| if (hd->low_delay == 0) { |
| img->tr = img->coding_order + |
| hd->displaydelay - hd->picture_reorder_delay; |
| } else { |
| img->tr = |
| img->coding_order; |
| } |
| |
| #if REMOVE_UNUSED |
| img->pic_distance = img->tr; |
| #else |
| img->pic_distance = img->tr % 256; |
| #endif |
| hc->picture_distance = img->pic_distance; |
| |
| } |
| |
| int32_t avs2_init_global_buffers(struct avs2_decoder *avs2_dec) |
| { |
| struct inp_par *input = &avs2_dec->input; |
| struct ImageParameters_s *img = &avs2_dec->img; |
| struct Video_Com_data_s *hc = &avs2_dec->hc; |
| |
| int32_t refnum; |
| |
| int32_t memory_size = 0; |
| /* |
| int32_t img_height = (hd->vertical_size + img->auto_crop_bottom); |
| */ |
| img->buf_cycle = input->buf_cycle + 1; |
| |
| img->buf_cycle *= 2; |
| |
| hc->background_ref = hc->backgroundReferenceFrame; |
| |
| for (refnum = 0; refnum < REF_MAXBUFFER; refnum++) { |
| avs2_dec->fref[refnum] = &avs2_dec->frm_pool[refnum]; |
| |
| /*//avs2_dec->fref[i] memory allocation*/ |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info("[t] avs2_dec->fref[%d]@0x%p\n", |
| refnum, avs2_dec->fref[refnum]); |
| avs2_dec->fref[refnum]->imgcoi_ref = -257; |
| avs2_dec->fref[refnum]->is_output = -1; |
| avs2_dec->fref[refnum]->refered_by_others = -1; |
| avs2_dec->fref[refnum]-> |
| imgtr_fwRefDistance = -256; |
| init_frame_t(avs2_dec->fref[refnum]); |
| #ifdef AML |
| avs2_dec->fref[refnum]->index = refnum; |
| #endif |
| } |
| #ifdef AML |
| avs2_dec->f_bg = NULL; |
| |
| avs2_dec->m_bg = &avs2_dec->frm_pool[REF_MAXBUFFER]; |
| /*///avs2_dec->fref[i] memory allocation*/ |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info("[t] avs2_dec->m_bg@0x%p\n", |
| avs2_dec->m_bg); |
| avs2_dec->m_bg->imgcoi_ref = -257; |
| avs2_dec->m_bg->is_output = -1; |
| avs2_dec->m_bg->refered_by_others = -1; |
| avs2_dec->m_bg->imgtr_fwRefDistance = -256; |
| init_frame_t(avs2_dec->m_bg); |
| avs2_dec->m_bg->index = refnum; |
| #endif |
| |
| #if BCBR |
| /*init BCBR related*/ |
| img->iNumCUsInFrame = |
| ((img->width + MAX_CU_SIZE - 1) / MAX_CU_SIZE) |
| * ((img->height + MAX_CU_SIZE - 1) |
| / MAX_CU_SIZE); |
| /*img->BLCUidx = (int32_t*) calloc( |
| img->iNumCUsInFrame, sizeof(int32_t));*/ |
| /*memset( img->BLCUidx, 0, img->iNumCUsInFrame);*/ |
| #endif |
| return memory_size; |
| } |
| |
| #ifdef AML |
| static void free_unused_buffers(struct avs2_decoder *avs2_dec) |
| { |
| struct inp_par *input = &avs2_dec->input; |
| struct ImageParameters_s *img = &avs2_dec->img; |
| struct Video_Com_data_s *hc = &avs2_dec->hc; |
| |
| int32_t refnum; |
| |
| img->buf_cycle = input->buf_cycle + 1; |
| |
| img->buf_cycle *= 2; |
| |
| hc->background_ref = hc->backgroundReferenceFrame; |
| |
| for (refnum = 0; refnum < REF_MAXBUFFER; refnum++) { |
| #ifndef NO_DISPLAY |
| if (avs2_dec->fref[refnum]->vf_ref > 0 || |
| avs2_dec->fref[refnum]->to_prepare_disp) |
| continue; |
| #endif |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info("%s[t] avs2_dec->fref[%d]@0x%p\n", |
| __func__, refnum, avs2_dec->fref[refnum]); |
| avs2_dec->fref[refnum]->imgcoi_ref = -257; |
| avs2_dec->fref[refnum]->is_output = -1; |
| avs2_dec->fref[refnum]->refered_by_others = -1; |
| avs2_dec->fref[refnum]-> |
| imgtr_fwRefDistance = -256; |
| memset(avs2_dec->fref[refnum]->ref_poc, 0, |
| sizeof(avs2_dec->fref[refnum]->ref_poc)); |
| } |
| avs2_dec->f_bg = NULL; |
| |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info("%s[t] avs2_dec->m_bg@0x%p\n", |
| __func__, avs2_dec->m_bg); |
| avs2_dec->m_bg->imgcoi_ref = -257; |
| avs2_dec->m_bg->is_output = -1; |
| avs2_dec->m_bg->refered_by_others = -1; |
| avs2_dec->m_bg->imgtr_fwRefDistance = -256; |
| memset(avs2_dec->m_bg->ref_poc, 0, |
| sizeof(avs2_dec->m_bg->ref_poc)); |
| |
| #if BCBR |
| /*init BCBR related*/ |
| img->iNumCUsInFrame = |
| ((img->width + MAX_CU_SIZE - 1) / MAX_CU_SIZE) |
| * ((img->height + MAX_CU_SIZE - 1) |
| / MAX_CU_SIZE); |
| /*img->BLCUidx = (int32_t*) calloc( |
| img->iNumCUsInFrame, sizeof(int32_t));*/ |
| /*memset( img->BLCUidx, 0, img->iNumCUsInFrame);*/ |
| #endif |
| } |
| #endif |
| |
| void init_frame_t(struct avs2_frame_s *currfref) |
| { |
| memset(currfref, 0, sizeof(struct avs2_frame_s)); |
| currfref->imgcoi_ref = -257; |
| currfref->is_output = -1; |
| currfref->refered_by_others = -1; |
| currfref->imgtr_fwRefDistance = -256; |
| memset(currfref->ref_poc, 0, sizeof(currfref->ref_poc)); |
| } |
| |
| void get_reference_list_info(struct avs2_decoder *avs2_dec, int8_t *str) |
| { |
| struct ImageParameters_s *img = &avs2_dec->img; |
| struct Video_Com_data_s *hc = &avs2_dec->hc; |
| |
| int8_t str_tmp[16]; |
| int32_t i; |
| /* int32_t poc = hc->f_rec->imgtr_fwRefDistance; |
| fred.chiu@mediatek.com*/ |
| |
| if (img->num_of_references > 0) { |
| strcpy(str, "["); |
| for (i = 0; i < img->num_of_references; i++) { |
| #if RD1510_FIX_BG |
| if (img->type == B_IMG) { |
| sprintf(str_tmp, "%4d ", |
| hc->f_rec-> |
| ref_poc[ |
| img->num_of_references - 1 - i]); |
| } else { |
| sprintf(str_tmp, "%4d ", |
| hc->f_rec->ref_poc[i]); |
| } |
| #else |
| sprintf(str_tmp, "%4d ", |
| avs2_dec->fref[i]->imgtr_fwRefDistance); |
| #endif |
| |
| str_tmp[5] = '\0'; |
| strcat(str, str_tmp); |
| } |
| strcat(str, "]"); |
| } else { |
| str[0] = '\0'; |
| } |
| } |
| |
| void prepare_RefInfo(struct avs2_decoder *avs2_dec) |
| { |
| struct ImageParameters_s *img = &avs2_dec->img; |
| struct Video_Com_data_s *hc = &avs2_dec->hc; |
| struct Video_Dec_data_s *hd = &avs2_dec->hd; |
| |
| int32_t i, j; |
| int32_t ii; |
| struct avs2_frame_s *tmp_fref; |
| |
| /*update IDR frame*/ |
| if (img->tr > hd->next_IDRtr && hd->curr_IDRtr != hd->next_IDRtr) { |
| hd->curr_IDRtr = hd->next_IDRtr; |
| hd->curr_IDRcoi = hd->next_IDRcoi; |
| } |
| /* re-order the ref buffer according to RPS*/ |
| img->num_of_references = hd->curr_RPS.num_of_ref; |
| |
| #if 1 |
| /*rain*/ |
| if (is_avs2_print_bufmgr_detail()) { |
| pr_info("%s: coding_order is %d, curr_IDRcoi is %d\n", |
| __func__, img->coding_order, hd->curr_IDRcoi); |
| for (ii = 0; ii < MAXREF; ii++) { |
| pr_info("ref_pic(%d)=%d\n", |
| ii, hd->curr_RPS.ref_pic[ii]); |
| } |
| for (ii = 0; ii < avs2_dec->ref_maxbuffer; ii++) { |
| pr_info( |
| "fref[%d]: index %d imgcoi_ref %d imgtr_fwRefDistance %d\n", |
| ii, avs2_dec->fref[ii]->index, |
| avs2_dec->fref[ii]->imgcoi_ref, |
| avs2_dec->fref[ii]->imgtr_fwRefDistance); |
| } |
| } |
| #endif |
| |
| for (i = 0; i < hd->curr_RPS.num_of_ref; i++) { |
| /*int32_t accumulate = 0;*/ |
| /* copy tmp_fref from avs2_dec->fref[i] */ |
| tmp_fref = avs2_dec->fref[i]; |
| |
| #if REMOVE_UNUSED |
| for (j = i; j < avs2_dec->ref_maxbuffer; j++) { |
| /*/////////////to be modified IDR*/ |
| if (avs2_dec->fref[j]->imgcoi_ref == |
| img->coding_order - |
| hd->curr_RPS.ref_pic[i]) { |
| break; |
| } |
| } |
| #else |
| |
| for (j = i; j < avs2_dec->ref_maxbuffer; j++) { |
| /*/////////////to be modified IDR*/ |
| int32_t k , tmp_tr; |
| for (k = 0; k < avs2_dec->ref_maxbuffer; k++) { |
| if (((int32_t)img->coding_order - |
| (int32_t)hd->curr_RPS.ref_pic[i]) == |
| avs2_dec->fref[k]->imgcoi_ref && |
| avs2_dec->fref[k]->imgcoi_ref >= -256) { |
| break; |
| } |
| } |
| if (k == avs2_dec->ref_maxbuffer) { |
| tmp_tr = |
| -1-1; |
| } else { |
| tmp_tr = |
| avs2_dec->fref[k]->imgtr_fwRefDistance; |
| } |
| if (tmp_tr < hd->curr_IDRtr) { |
| hd->curr_RPS.ref_pic[i] = |
| img->coding_order - hd->curr_IDRcoi; |
| |
| for (k = 0; k < i; k++) { |
| if (hd->curr_RPS.ref_pic[k] == |
| hd->curr_RPS.ref_pic[i]) { |
| accumulate++; |
| break; |
| } |
| } |
| } |
| if (avs2_dec->fref[j]->imgcoi_ref == |
| img->coding_order - hd->curr_RPS.ref_pic[i]) { |
| break; |
| } |
| } |
| if (j == avs2_dec->ref_maxbuffer || accumulate) |
| img->num_of_references--; |
| #endif |
| if (j != avs2_dec->ref_maxbuffer) { |
| /* copy avs2_dec->fref[i] from avs2_dec->fref[j] */ |
| avs2_dec->fref[i] = avs2_dec->fref[j]; |
| /* copy avs2_dec->fref[j] from ferf[tmp] */ |
| avs2_dec->fref[j] = tmp_fref; |
| if (is_avs2_print_bufmgr_detail()) { |
| pr_info("%s, switch %d %d: ", __func__, i, j); |
| for (ii = 0; ii < hd->curr_RPS.num_of_ref |
| || ii <= j; ii++) |
| pr_info("%d ", |
| avs2_dec->fref[ii]->index); |
| pr_info("\n"); |
| } |
| } |
| } |
| if (img->type == B_IMG && |
| (avs2_dec->fref[0]->imgtr_fwRefDistance <= img->tr |
| || avs2_dec->fref[1]->imgtr_fwRefDistance >= img->tr)) { |
| |
| pr_info("wrong reference configuration for B frame\n"); |
| pr_info( |
| "fref0 imgtr_fwRefDistance %d, fref1 imgtr_fwRefDistance %d, img->tr %d\n", |
| avs2_dec->fref[0]->imgtr_fwRefDistance, |
| avs2_dec->fref[1]->imgtr_fwRefDistance, |
| img->tr); |
| hc->f_rec->error_mark = 1; |
| avs2_dec->bufmgr_error_flag = 1; |
| return; /* exit(-1);*/ |
| /*******************************************/ |
| } |
| |
| #if !FIX_PROFILE_LEVEL_DPB_RPS_1 |
| /* delete the frame that will never be used*/ |
| for (i = 0; i < hd->curr_RPS.num_to_remove; i++) { |
| for (j = 0; j < avs2_dec->ref_maxbuffer; j++) { |
| if (avs2_dec->fref[j]->imgcoi_ref >= -256 |
| && avs2_dec->fref[j]->imgcoi_ref |
| == img->coding_order - |
| hd->curr_RPS.remove_pic[i]) { |
| break; |
| } |
| } |
| if (j < avs2_dec->ref_maxbuffer && |
| j >= img->num_of_references) { |
| avs2_dec->fref[j]->imgcoi_ref = -257; |
| #if M3480_TEMPORAL_SCALABLE |
| avs2_dec->fref[j]->temporal_id = -1; |
| #endif |
| if (avs2_dec->fref[j]->is_output == -1) { |
| avs2_dec->fref[j]-> |
| imgtr_fwRefDistance = -256; |
| } |
| } |
| } |
| #endif |
| |
| /* add inter-view reference picture*/ |
| |
| /* add current frame to ref buffer*/ |
| for (i = 0; i < avs2_dec->ref_maxbuffer; i++) { |
| if ((avs2_dec->fref[i]->imgcoi_ref < -256 |
| || abs(avs2_dec->fref[i]-> |
| imgtr_fwRefDistance - img->tr) >= 128) |
| && avs2_dec->fref[i]->is_output == -1 |
| && avs2_dec->fref[i]->bg_flag == 0 |
| #ifndef NO_DISPLAY |
| && avs2_dec->fref[i]->vf_ref == 0 |
| && avs2_dec->fref[i]->to_prepare_disp == 0 |
| #endif |
| ) { |
| break; |
| } |
| } |
| if (i == avs2_dec->ref_maxbuffer) { |
| pr_info( |
| "%s, warning, no enough buf\n", |
| __func__); |
| i--; |
| } |
| |
| hc->f_rec = avs2_dec->fref[i]; |
| hc->currentFrame = hc->f_rec->ref; |
| hc->f_rec->imgtr_fwRefDistance = img->tr; |
| hc->f_rec->imgcoi_ref = img->coding_order; |
| #if M3480_TEMPORAL_SCALABLE |
| hc->f_rec->temporal_id = hd->cur_layer; |
| #endif |
| hc->f_rec->is_output = 1; |
| #ifdef AML |
| hc->f_rec->error_mark = 0; |
| hc->f_rec->decoded_lcu = 0; |
| hc->f_rec->slice_type = img->type; |
| #endif |
| hc->f_rec->refered_by_others = hd->curr_RPS.referd_by_others; |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info( |
| "%s, set f_rec (cur_pic) <= fref[%d] img->tr %d coding_order %d img_type %d\n", |
| __func__, i, img->tr, img->coding_order, |
| img->type); |
| |
| if (img->type != B_IMG) { |
| for (j = 0; |
| j < img->num_of_references; j++) { |
| hc->f_rec->ref_poc[j] = |
| avs2_dec->fref[j]->imgtr_fwRefDistance; |
| } |
| } else { |
| hc->f_rec->ref_poc[0] = |
| avs2_dec->fref[1]->imgtr_fwRefDistance; |
| hc->f_rec->ref_poc[1] = |
| avs2_dec->fref[0]->imgtr_fwRefDistance; |
| } |
| |
| #if M3480_TEMPORAL_SCALABLE |
| |
| for (j = img->num_of_references; |
| j < 4; j++) { |
| /**/ |
| hc->f_rec->ref_poc[j] = 0; |
| } |
| |
| if (img->type == INTRA_IMG) { |
| int32_t l; |
| for (l = 0; l < 4; l++) { |
| hc->f_rec->ref_poc[l] |
| = img->tr; |
| } |
| } |
| |
| #endif |
| |
| /*////////////////////////////////////////////////////////////////////////*/ |
| /* updata ref pointer*/ |
| |
| if (img->type != I_IMG) { |
| |
| img->imgtr_next_P = img->type == B_IMG ? |
| avs2_dec->fref[0]->imgtr_fwRefDistance : img->tr; |
| if (img->type == B_IMG) { |
| hd->trtmp = avs2_dec->fref[0]->imgtr_fwRefDistance; |
| avs2_dec->fref[0]->imgtr_fwRefDistance = |
| avs2_dec->fref[1]->imgtr_fwRefDistance; |
| } |
| } |
| #if 1 |
| /*rain*/ |
| if (is_avs2_print_bufmgr_detail()) { |
| for (ii = 0; ii < avs2_dec->ref_maxbuffer; ii++) { |
| pr_info( |
| "fref[%d]: index %d imgcoi_ref %d imgtr_fwRefDistance %d refered %d, is_out %d, bg %d, vf_ref %d ref_pos(%d,%d,%d,%d,%d,%d,%d)\n", |
| ii, avs2_dec->fref[ii]->index, |
| avs2_dec->fref[ii]->imgcoi_ref, |
| avs2_dec->fref[ii]->imgtr_fwRefDistance, |
| avs2_dec->fref[ii]->refered_by_others, |
| avs2_dec->fref[ii]->is_output, |
| avs2_dec->fref[ii]->bg_flag, |
| avs2_dec->fref[ii]->vf_ref, |
| avs2_dec->fref[ii]->ref_poc[0], |
| avs2_dec->fref[ii]->ref_poc[1], |
| avs2_dec->fref[ii]->ref_poc[2], |
| avs2_dec->fref[ii]->ref_poc[3], |
| avs2_dec->fref[ii]->ref_poc[4], |
| avs2_dec->fref[ii]->ref_poc[5], |
| avs2_dec->fref[ii]->ref_poc[6] |
| ); |
| } |
| } |
| #endif |
| } |
| |
| int32_t init_frame(struct avs2_decoder *avs2_dec) |
| { |
| struct ImageParameters_s *img = &avs2_dec->img; |
| struct Video_Com_data_s *hc = &avs2_dec->hc; |
| struct Video_Dec_data_s *hd = &avs2_dec->hd; |
| |
| |
| #if RD1510_FIX_BG |
| if (img->type == I_IMG && |
| img->typeb == BACKGROUND_IMG) { /*G/GB frame*/ |
| img->num_of_references = 0; |
| } else if (img->type == P_IMG && img->typeb == BP_IMG) { |
| /* only one reference frame(G\GB) for S frame*/ |
| img->num_of_references = 1; |
| } |
| #endif |
| |
| if (img->typeb == BACKGROUND_IMG && |
| hd->background_picture_output_flag == 0) { |
| hc->currentFrame = hc->background_ref; |
| #ifdef AML |
| hc->cur_pic = avs2_dec->m_bg; |
| #endif |
| } else { |
| prepare_RefInfo(avs2_dec); |
| #ifdef AML |
| hc->cur_pic = hc->f_rec; |
| #endif |
| } |
| |
| |
| #ifdef FIX_CHROMA_FIELD_MV_BK_DIST |
| if (img->typeb == BACKGROUND_IMG |
| && img->is_field_sequence) { |
| avs2_dec->bk_img_is_top_field |
| = img->is_top_field; |
| } |
| #endif |
| return 0; |
| } |
| |
| void delete_trbuffer(struct outdata_s *data, int32_t pos) |
| { |
| int32_t i; |
| for (i = pos; |
| i < data->buffer_num - 1; i++) { |
| data->stdoutdata[i] = |
| data->stdoutdata[i + 1]; |
| } |
| data->buffer_num--; |
| } |
| |
| #if RD170_FIX_BG |
| void flushDPB(struct avs2_decoder *avs2_dec) |
| { |
| struct Video_Dec_data_s *hd = &avs2_dec->hd; |
| int j, tmp_min, i, pos = -1; |
| int search_times = avs2_dec->outprint.buffer_num; |
| |
| tmp_min = 1 << 20; |
| i = 0, j = 0; |
| pos = -1; |
| |
| for (j = 0; j < search_times; j++) { |
| pos = -1; |
| tmp_min = (1 << 20); |
| /*search for min poi picture to display*/ |
| for (i = 0; i < avs2_dec->outprint.buffer_num; i++) { |
| if (avs2_dec->outprint.stdoutdata[i].tr < tmp_min) { |
| pos = i; |
| tmp_min = avs2_dec->outprint.stdoutdata[i].tr; |
| } |
| } |
| |
| if (pos != -1) { |
| hd->last_output = avs2_dec->outprint.stdoutdata[pos].tr; |
| report_frame(avs2_dec, &avs2_dec->outprint, pos); |
| if (avs2_dec->outprint.stdoutdata[pos].typeb |
| == BACKGROUND_IMG && |
| avs2_dec->outprint.stdoutdata[pos]. |
| background_picture_output_flag |
| == 0) { |
| /*write_GB_frame(hd->p_out_background);*/ |
| } else { |
| write_frame(avs2_dec, |
| avs2_dec->outprint.stdoutdata[pos].tr); |
| } |
| |
| delete_trbuffer(&avs2_dec->outprint, pos); |
| } |
| } |
| |
| /*clear dpb info*/ |
| for (j = 0; j < REF_MAXBUFFER; j++) { |
| avs2_dec->fref[j]->imgtr_fwRefDistance = -256; |
| avs2_dec->fref[j]->imgcoi_ref = -257; |
| avs2_dec->fref[j]->temporal_id = -1; |
| avs2_dec->fref[j]->refered_by_others = 0; |
| } |
| } |
| #endif |
| |
| |
| |
| #if M3480_TEMPORAL_SCALABLE |
| void cleanRefMVBufRef(int pos) |
| { |
| #if 0 |
| int k, x, y; |
| /*re-init mvbuf*/ |
| for (k = 0; k < 2; k++) { |
| for (y = 0; y < img->height / MIN_BLOCK_SIZE; y++) { |
| for (x = 0; x < img->width / MIN_BLOCK_SIZE; x++) |
| fref[pos]->mvbuf[y][x][k] = 0; |
| |
| } |
| } |
| /*re-init refbuf*/ |
| for (y = 0; y < img->height / MIN_BLOCK_SIZE; y++) { |
| for (x = 0; x < img->width / MIN_BLOCK_SIZE ; x++) |
| fref[pos]->refbuf[y][x] = -1; |
| |
| } |
| #endif |
| } |
| #endif |
| |
| static int frame_postprocessing(struct avs2_decoder *avs2_dec) |
| { |
| struct ImageParameters_s *img = &avs2_dec->img; |
| struct Video_Com_data_s *hc = &avs2_dec->hc; |
| struct Video_Dec_data_s *hd = &avs2_dec->hd; |
| |
| int32_t pointer_tmp = avs2_dec->outprint.buffer_num; |
| int32_t i; |
| struct STDOUT_DATA_s *p_outdata; |
| #if RD160_FIX_BG |
| int32_t j, tmp_min, output_cur_dec_pic, pos = -1; |
| int32_t search_times = avs2_dec->outprint.buffer_num; |
| #endif |
| /*pic dist by Grandview Semi. @ [06-07-20 15:25]*/ |
| img->PrevPicDistanceLsb = (img->coding_order % 256); |
| |
| pointer_tmp = avs2_dec->outprint.buffer_num; |
| p_outdata = &avs2_dec->outprint.stdoutdata[pointer_tmp]; |
| |
| p_outdata->type = img->type; |
| p_outdata->typeb = img->typeb; |
| p_outdata->framenum = img->tr; |
| p_outdata->tr = img->tr; |
| #if 0 /*def ORI*/ |
| p_outdata->qp = img->qp; |
| #else |
| p_outdata->qp = 0; |
| #endif |
| /*p_outdata->snr_y = snr->snr_y;*/ |
| /*p_outdata->snr_u = snr->snr_u;*/ |
| /*p_outdata->snr_v = snr->snr_v;*/ |
| p_outdata->tmp_time = hd->tmp_time; |
| p_outdata->picture_structure = img->picture_structure; |
| /*p_outdata->curr_frame_bits = |
| StatBitsPtr->curr_frame_bits;*/ |
| /*p_outdata->emulate_bits = StatBitsPtr->emulate_bits;*/ |
| #if RD1501_FIX_BG |
| p_outdata->background_picture_output_flag |
| = hd->background_picture_output_flag; |
| /*Longfei.Wang@mediatek.com*/ |
| #endif |
| |
| #if RD160_FIX_BG |
| p_outdata->picture_reorder_delay = hd->picture_reorder_delay; |
| #endif |
| avs2_dec->outprint.buffer_num++; |
| |
| #if RD170_FIX_BG |
| search_times = avs2_dec->outprint.buffer_num; |
| #endif |
| /* record the reference list*/ |
| strcpy(p_outdata->str_reference_list, hc->str_list_reference); |
| |
| #if !REF_OUTPUT |
| #error "!!!REF_OUTPUT should be 1" |
| for (i = 0; i < avs2_dec->outprint.buffer_num; i++) { |
| min_tr(avs2_dec->outprint, &pos); |
| if (avs2_dec->outprint.stdoutdata[pos].tr < img->tr |
| || avs2_dec->outprint.stdoutdata[pos].tr |
| == (hd->last_output + 1)) { |
| hd->last_output = avs2_dec->outprint.stdoutdata[pos].tr; |
| report_frame(avs2_dec, &avs2_dec->outprint, pos); |
| #if 0 /*def ORI*/ |
| write_frame(hd->p_out, |
| avs2_dec->outprint.stdoutdata[pos].tr); |
| #endif |
| delete_trbuffer(&avs2_dec->outprint, pos); |
| i--; |
| } else { |
| break; |
| } |
| } |
| #else |
| #if RD160_FIX_BG /*Longfei.Wang@mediatek.com*/ |
| tmp_min = 1 << 20; |
| i = 0, j = 0; |
| output_cur_dec_pic = 0; |
| pos = -1; |
| for (j = 0; j < search_times; j++) { |
| pos = -1; |
| tmp_min = (1 << 20); |
| /*search for min poi picture to display*/ |
| for (i = 0; i < avs2_dec->outprint.buffer_num; i++) { |
| if ((avs2_dec->outprint.stdoutdata[i].tr < tmp_min) && |
| ((avs2_dec->outprint.stdoutdata[i].tr |
| + avs2_dec->outprint.stdoutdata[i]. |
| picture_reorder_delay) |
| <= (int32_t)img->coding_order)) { |
| pos = i; |
| tmp_min = avs2_dec->outprint.stdoutdata[i].tr; |
| } |
| } |
| |
| if ((0 == hd->displaydelay) && (0 == output_cur_dec_pic)) { |
| if (img->tr <= tmp_min) {/*fred.chiu@mediatek.com*/ |
| /*output current decode picture |
| right now*/ |
| pos = avs2_dec->outprint.buffer_num - 1; |
| output_cur_dec_pic = 1; |
| } |
| } |
| if (pos != -1) { |
| hd->last_output = avs2_dec->outprint.stdoutdata[pos].tr; |
| report_frame(avs2_dec, &avs2_dec->outprint, pos); |
| #if 1 /*def ORI*/ |
| if (avs2_dec->outprint.stdoutdata[pos].typeb |
| == BACKGROUND_IMG && |
| avs2_dec->outprint.stdoutdata[pos]. |
| background_picture_output_flag == 0) { |
| /**/ |
| /**/ |
| } else { |
| write_frame(avs2_dec, |
| avs2_dec->outprint.stdoutdata[pos].tr); |
| } |
| #endif |
| delete_trbuffer(&avs2_dec->outprint, pos); |
| } |
| |
| } |
| |
| #else |
| #error "!!!RD160_FIX_BG should be defined" |
| if (img->coding_order + |
| (uint32_t)hc->total_frames * 256 >= |
| (uint32_t)hd->picture_reorder_delay) { |
| int32_t tmp_min, pos = -1; |
| tmp_min = 1 << 20; |
| |
| for (i = 0; i < |
| avs2_dec->outprint.buffer_num; i++) { |
| if (avs2_dec->outprint.stdoutdata[i].tr |
| < tmp_min && |
| avs2_dec->outprint.stdoutdata[i].tr |
| >= hd->last_output) { |
| /*GB has the same "tr" with "last_output"*/ |
| pos = i; |
| tmp_min = |
| avs2_dec->outprint.stdoutdata[i].tr; |
| } |
| } |
| |
| if (pos != -1) { |
| hd->last_output = avs2_dec->outprint.stdoutdata[pos].tr; |
| report_frame(avs2_dec, &avs2_dec->outprint, pos); |
| #if RD1501_FIX_BG |
| if (avs2_dec->outprint.stdoutdata[pos].typeb |
| == BACKGROUND_IMG && avs2_dec-> |
| outprint.stdoutdata[pos]. |
| background_picture_output_flag == 0) { |
| #else |
| if (avs2_dec->outprint.stdoutdata[pos].typeb |
| == BACKGROUND_IMG && |
| hd->background_picture_output_flag |
| == 0) { |
| #endif |
| write_GB_frame( |
| hd->p_out_background); |
| } else { |
| write_frame(avs2_dec, |
| avs2_dec->outprint.stdoutdata[pos].tr); |
| } |
| delete_trbuffer(&avs2_dec->outprint, pos); |
| |
| } |
| |
| } |
| #endif |
| #endif |
| return pos; |
| |
| } |
| |
| void write_frame(struct avs2_decoder *avs2_dec, int32_t pos) |
| { |
| int32_t j; |
| |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info("%s(pos = %d)\n", __func__, pos); |
| |
| for (j = 0; j < avs2_dec->ref_maxbuffer; j++) { |
| if (avs2_dec->fref[j]->imgtr_fwRefDistance == pos) { |
| avs2_dec->fref[j]->imgtr_fwRefDistance_bak = pos; |
| avs2_dec->fref[j]->is_output = -1; |
| avs2_dec->fref[j]->to_prepare_disp = |
| avs2_dec->to_prepare_disp_count++; |
| if (avs2_dec->fref[j]->refered_by_others == 0 |
| || avs2_dec->fref[j]->imgcoi_ref |
| == -257) { |
| avs2_dec->fref[j]->imgtr_fwRefDistance |
| = -256; |
| avs2_dec->fref[j]->imgcoi_ref = -257; |
| #if M3480_TEMPORAL_SCALABLE |
| avs2_dec->fref[j]->temporal_id = -1; |
| #endif |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info("%s, fref index %d\n", |
| __func__, j); |
| } |
| break; |
| } |
| } |
| } |
| |
| /*rain???, outdata *data*/ |
| void report_frame(struct avs2_decoder *avs2_dec, |
| struct outdata_s *data, int32_t pos) |
| { |
| struct ImageParameters_s *img = &avs2_dec->img; |
| struct Video_Com_data_s *hc = &avs2_dec->hc; |
| struct Video_Dec_data_s *hd = &avs2_dec->hd; |
| |
| int8_t *Frmfld; |
| int8_t Frm[] = "FRM"; |
| int8_t Fld[] = "FLD"; |
| struct STDOUT_DATA_s *p_stdoutdata |
| = &data->stdoutdata[pos]; |
| const int8_t *typ; |
| |
| #if 0 |
| if (input->MD5Enable & 0x02) { |
| sprintf(MD5str, "%08X%08X%08X%08X\0", |
| p_stdoutdata->DecMD5Value[0], |
| p_stdoutdata->DecMD5Value[1], |
| p_stdoutdata->DecMD5Value[2], |
| p_stdoutdata->DecMD5Value[3]); |
| } else { |
| memset(MD5val, 0, 16); |
| memset(MD5str, 0, 33); |
| } |
| #endif |
| |
| if (p_stdoutdata-> |
| picture_structure) { |
| Frmfld = Frm; |
| } else { |
| Frmfld = Fld; |
| } |
| #if INTERLACE_CODING |
| if (img->is_field_sequence) { /*rcs??*/ |
| Frmfld = Fld; |
| } |
| #endif |
| if ((p_stdoutdata->tr + hc->total_frames * 256) |
| == hd->end_SeqTr) { /* I picture*/ |
| /*if ( img->new_sequence_flag == 1 )*/ |
| { |
| img->sequence_end_flag = 0; |
| /*fprintf(stdout, "Sequence |
| End\n\n");*/ |
| } |
| } |
| if ((p_stdoutdata->tr + hc->total_frames * 256) |
| == hd->next_IDRtr) { |
| #if !RD170_FIX_BG |
| if (hd->vec_flag) /**/ |
| #endif |
| { |
| hd->vec_flag = 0; |
| /*fprintf(stdout, "Video Edit |
| Code\n");*/ |
| } |
| } |
| |
| if (p_stdoutdata->typeb == BACKGROUND_IMG) { |
| typ = (hd->background_picture_output_flag != 0) ? "G" : "GB"; |
| } else { |
| #if REMOVE_UNUSED |
| typ = (p_stdoutdata->type == INTRA_IMG) |
| ? "I" : (p_stdoutdata->type == INTER_IMG) ? |
| ((p_stdoutdata->typeb == BP_IMG) ? "S" : "P") |
| : (p_stdoutdata->type == F_IMG ? "F" : "B"); |
| #else |
| typ = (p_stdoutdata->type == INTRA_IMG) ? "I" : |
| (p_stdoutdata->type == INTER_IMG) ? |
| ((p_stdoutdata->type == BP_IMG) ? "S" : "P") |
| : (p_stdoutdata->type == F_IMG ? "F" : "B"); |
| #endif |
| } |
| |
| #if 0 |
| /*rain???*/ |
| pr_info("%3d(%s) %3d %5d %7.4f %7.4f %7.4f %5d\t\t%s %8d %6d\t%s", |
| p_stdoutdata->framenum + hc->total_frames * 256, |
| typ, p_stdoutdata->tr + hc->total_frames * 256, |
| p_stdoutdata->qp, p_stdoutdata->snr_y, |
| p_stdoutdata->snr_u, p_stdoutdata->snr_v, |
| p_stdoutdata->tmp_time, Frmfld, |
| p_stdoutdata->curr_frame_bits, |
| p_stdoutdata->emulate_bits, |
| ""); |
| #endif |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info(" %s\n", p_stdoutdata->str_reference_list); |
| |
| /*fflush(stdout);*/ |
| hd->FrameNum++; |
| } |
| |
| void avs2_prepare_header(struct avs2_decoder *avs2_dec, int32_t start_code) |
| { |
| struct ImageParameters_s *img = &avs2_dec->img; |
| struct Video_Dec_data_s *hd = &avs2_dec->hd; |
| |
| switch (start_code) { |
| case SEQUENCE_HEADER_CODE: |
| img->new_sequence_flag = 1; |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info("SEQUENCE\n"); |
| #ifdef TO_CHECK |
| #if SEQ_CHANGE_CHECKER |
| if (seq_checker_buf == NULL) { |
| seq_checker_buf = malloc(length); |
| seq_checker_length = length; |
| memcpy(seq_checker_buf, Buf, length); |
| } else { |
| if ((seq_checker_length != length) || |
| (memcmp(seq_checker_buf, Buf, length) != 0)) { |
| free(seq_checker_buf); |
| /*fprintf(stdout, |
| "Non-conformance |
| stream: sequence |
| header cannot change |
| !!\n");*/ |
| #if RD170_FIX_BG |
| seq_checker_buf = NULL; |
| seq_checker_length = 0; |
| seq_checker_buf = malloc(length); |
| seq_checker_length = length; |
| memcpy(seq_checker_buf, Buf, length); |
| #endif |
| } |
| |
| |
| } |
| #endif |
| #if RD170_FIX_BG |
| if (input->alf_enable |
| && alfParAllcoated == 1) { |
| ReleaseAlfGlobalBuffer(); |
| alfParAllcoated = 0; |
| } |
| #endif |
| /*TO_CHECK*/ |
| #endif |
| #if FIX_FLUSH_DPB_BY_LF |
| if (hd->vec_flag) { |
| int32_t k; |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info("vec_flag is 1, flushDPB and reinit bugmgr\n"); |
| |
| flushDPB(avs2_dec); |
| for (k = 0; k < avs2_dec->ref_maxbuffer; k++) |
| cleanRefMVBufRef(k); |
| |
| hd->vec_flag = 0; |
| #ifdef AML |
| free_unused_buffers(avs2_dec); |
| #else |
| free_global_buffers(avs2_dec); |
| #endif |
| img->number = 0; |
| img->PrevPicDistanceLsb = 0; |
| avs2_dec->init_hw_flag = 0; |
| } |
| #endif |
| |
| #if FIX_SEQ_END_FLUSH_DPB_BY_LF |
| if (img->new_sequence_flag |
| && img->sequence_end_flag) { |
| int32_t k; |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info( |
| "new_sequence_flag after sequence_end_flag, flushDPB and reinit bugmgr\n"); |
| flushDPB(avs2_dec); |
| for (k = 0; k < avs2_dec->ref_maxbuffer; k++) |
| cleanRefMVBufRef(k); |
| |
| #ifdef AML |
| free_unused_buffers(avs2_dec); |
| #else |
| free_global_buffers(avs2_dec); |
| #endif |
| img->number = 0; |
| img->PrevPicDistanceLsb = 0; |
| avs2_dec->init_hw_flag = 0; |
| } |
| #endif |
| img->seq_header_indicate = 1; |
| break; |
| case I_PICTURE_START_CODE: |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info("PIC-I\n"); |
| Get_SequenceHeader(avs2_dec); |
| Get_I_Picture_Header(avs2_dec); |
| calc_picture_distance(avs2_dec); |
| Read_ALF_param(avs2_dec); |
| if (!img->seq_header_indicate) { |
| img->B_discard_flag = 1; |
| /*fprintf(stdout, " I |
| %3d\t\tDIDSCARD!!\n", |
| img->tr);*/ |
| break; |
| } |
| break; |
| case PB_PICTURE_START_CODE: |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info("PIC-PB\n"); |
| Get_SequenceHeader(avs2_dec); |
| Get_PB_Picture_Header(avs2_dec); |
| calc_picture_distance(avs2_dec); |
| Read_ALF_param(avs2_dec); |
| /* xiaozhen zheng, 20071009*/ |
| if (!img->seq_header_indicate) { |
| img->B_discard_flag = 1; |
| |
| if (img->type == P_IMG) { |
| /*fprintf(stdout, " P |
| %3d\t\tDIDSCARD!!\n", |
| img->tr);*/ |
| } |
| if (img->type == F_IMG) { |
| /*fprintf(stdout, " F |
| %3d\t\tDIDSCARD!!\n", |
| img->tr);*/ |
| } else { |
| /*fprintf(stdout, " B |
| %3d\t\tDIDSCARD!!\n", |
| img->tr);*/ |
| } |
| |
| break; |
| } |
| |
| if (img->seq_header_indicate == 1 |
| && img->type != B_IMG) { |
| img->B_discard_flag = 0; |
| } |
| if (img->type == B_IMG && img->B_discard_flag == 1 |
| && !img->random_access_decodable_flag) { |
| /*fprintf(stdout, " B |
| %3d\t\tDIDSCARD!!\n", |
| img->tr);*/ |
| break; |
| } |
| |
| break; |
| case SEQUENCE_END_CODE: |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info("SEQUENCE_END_CODE\n"); |
| #ifdef TO_CHECK |
| #if SEQ_CHANGE_CHECKER |
| if (seq_checker_buf != NULL) { |
| free(seq_checker_buf); |
| seq_checker_buf = NULL; |
| seq_checker_length = 0; |
| } |
| #endif |
| #endif |
| img->new_sequence_flag = 1; |
| img->sequence_end_flag = 1; |
| break; |
| case VIDEO_EDIT_CODE: |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info("VIDEO_EDIT_CODE\n"); |
| /*video_edit_code_data(Buf, startcodepos, length);*/ |
| hd->vec_flag = 1; |
| #ifdef TO_CHECK |
| #if SEQ_CHANGE_CHECKER |
| if (seq_checker_buf != NULL) { |
| free(seq_checker_buf); |
| seq_checker_buf = NULL; |
| seq_checker_length = 0; |
| } |
| #endif |
| #endif |
| |
| break; |
| } |
| } |
| |
| #ifdef AML |
| static uint32_t log2i(uint32_t val) |
| { |
| uint32_t ret = -1; |
| while (val != 0) { |
| val >>= 1; |
| ret++; |
| } |
| return ret; |
| } |
| #endif |
| |
| int32_t avs2_process_header(struct avs2_decoder *avs2_dec) |
| { |
| struct inp_par *input = &avs2_dec->input; |
| struct ImageParameters_s *img = &avs2_dec->img; |
| struct Video_Dec_data_s *hd = &avs2_dec->hd; |
| int32_t lcu_x_num_div; |
| int32_t lcu_y_num_div; |
| |
| int32_t N8_SizeScale; |
| /*pr_info("%s\n", __func__);*/ |
| { |
| N8_SizeScale = 1; |
| |
| if (hd->horizontal_size % |
| (MIN_CU_SIZE * N8_SizeScale) != 0) { |
| img->auto_crop_right = |
| (MIN_CU_SIZE * N8_SizeScale) - |
| (hd->horizontal_size % |
| (MIN_CU_SIZE * N8_SizeScale)); |
| } else |
| img->auto_crop_right = 0; |
| |
| #if !INTERLACE_CODING |
| if (hd->progressive_sequence) /**/ |
| #endif |
| { |
| if (hd->vertical_size % |
| (MIN_CU_SIZE * N8_SizeScale) != 0) { |
| img->auto_crop_bottom = |
| (MIN_CU_SIZE * N8_SizeScale) - |
| (hd->vertical_size % |
| (MIN_CU_SIZE * N8_SizeScale)); |
| } else |
| img->auto_crop_bottom = 0; |
| } |
| |
| /* Reinit parameters (NOTE: need to do |
| before init_frame //*/ |
| img->width = |
| (hd->horizontal_size + img->auto_crop_right); |
| img->height = |
| (hd->vertical_size + img->auto_crop_bottom); |
| img->width_cr = (img->width >> 1); |
| |
| if (input->chroma_format == 1) |
| img->height_cr = (img->height >> 1); |
| |
| img->PicWidthInMbs = img->width / MIN_CU_SIZE; |
| img->PicHeightInMbs = img->height / MIN_CU_SIZE; |
| img->PicSizeInMbs = img->PicWidthInMbs * img->PicHeightInMbs; |
| img->max_mb_nr = (img->width * img->height) / |
| (MIN_CU_SIZE * MIN_CU_SIZE); |
| } |
| |
| if (img->new_sequence_flag && img->sequence_end_flag) { |
| #if 0/*RD170_FIX_BG //*/ |
| int32_t k; |
| flushDPB(); |
| for (k = 0; k < avs2_dec->ref_maxbuffer; k++) |
| cleanRefMVBufRef(k); |
| |
| free_global_buffers(); |
| img->number = 0; |
| #endif |
| hd->end_SeqTr = img->tr; |
| img->sequence_end_flag = 0; |
| } |
| if (img->new_sequence_flag) { |
| hd->next_IDRtr = img->tr; |
| hd->next_IDRcoi = img->coding_order; |
| img->new_sequence_flag = 0; |
| } |
| #if 0/*RD170_FIX_BG*/ |
| if (hd->vec_flag) { |
| int32_t k; |
| flushDPB(); |
| for (k = 0; k < avs2_dec->ref_maxbuffer; k++) |
| cleanRefMVBufRef(k); |
| |
| hd->vec_flag = 0; |
| free_global_buffers(); |
| img->number = 0; |
| } |
| #endif |
| /* allocate memory for frame buffers*/ |
| #if 0 |
| /* called in vavs2.c*/ |
| if (img->number == 0) |
| avs2_init_global_buffers(avs2_dec); |
| #endif |
| img->current_mb_nr = 0; |
| |
| init_frame(avs2_dec); |
| |
| img->types = img->type; /* jlzheng 7.15*/ |
| |
| if (img->type != B_IMG) { |
| hd->pre_img_type = img->type; |
| hd->pre_img_types = img->types; |
| } |
| |
| #ifdef AML |
| avs2_dec->lcu_size_log2 = log2i(avs2_dec->lcu_size); |
| lcu_x_num_div = (img->width/avs2_dec->lcu_size); |
| lcu_y_num_div = (img->height/avs2_dec->lcu_size); |
| avs2_dec->lcu_x_num = ((img->width % avs2_dec->lcu_size) == 0) ? |
| lcu_x_num_div : lcu_x_num_div+1; |
| avs2_dec->lcu_y_num = ((img->height % avs2_dec->lcu_size) == 0) ? |
| lcu_y_num_div : lcu_y_num_div+1; |
| avs2_dec->lcu_total = avs2_dec->lcu_x_num*avs2_dec->lcu_y_num; |
| #endif |
| return SOP; |
| } |
| |
| int avs2_post_process(struct avs2_decoder *avs2_dec) |
| { |
| struct ImageParameters_s *img = &avs2_dec->img; |
| struct Video_Com_data_s *hc = &avs2_dec->hc; |
| struct Video_Dec_data_s *hd = &avs2_dec->hd; |
| int32_t i; |
| int ret; |
| if (img->typeb == BACKGROUND_IMG && hd->background_picture_enable) { |
| #ifdef AML |
| for (i = 0; i < avs2_dec->ref_maxbuffer; i++) { |
| if (avs2_dec->fref[i]->bg_flag != 0) { |
| avs2_dec->fref[i]->bg_flag = 0; |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info( |
| "clear old BACKGROUND_IMG for index %d\r\n", |
| avs2_dec->fref[i]->index); |
| } |
| } |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info( |
| "post_process: set BACKGROUND_IMG flag for %d\r\n", |
| hc->cur_pic->index); |
| avs2_dec->f_bg = hc->cur_pic; |
| hc->cur_pic->bg_flag = 1; |
| #endif |
| } |
| |
| #if BCBR |
| if (hd->background_picture_enable |
| && hd->bcbr_enable && img->number > 0) |
| updateBgReference(); |
| #endif |
| |
| if (img->typeb == BACKGROUND_IMG && |
| hd->background_picture_output_flag == 0) |
| hd->background_number++; |
| |
| if (img->type == B_IMG) { |
| avs2_dec->fref[0]->imgtr_fwRefDistance |
| = hd->trtmp; |
| } |
| |
| /* record the reference list information*/ |
| get_reference_list_info(avs2_dec, avs2_dec->hc.str_list_reference); |
| |
| /*pr_info("%s\n", __func__);*/ |
| ret = frame_postprocessing(avs2_dec); |
| |
| #if FIX_PROFILE_LEVEL_DPB_RPS_1 |
| /* delete the frame that will never be used*/ |
| { |
| int32_t i, j; |
| if (is_avs2_print_bufmgr_detail()) { |
| pr_info( |
| "%s, coding_order %d to remove %d buf: ", |
| __func__, |
| img->coding_order, |
| hd->curr_RPS.num_to_remove); |
| for (i = 0; i < hd->curr_RPS.num_to_remove; i++) |
| pr_info("%d ", hd->curr_RPS.remove_pic[i]); |
| pr_info("\n"); |
| } |
| for (i = 0; i < hd->curr_RPS.num_to_remove; i++) { |
| for (j = 0; j < avs2_dec->ref_maxbuffer; j++) { |
| |
| if (avs2_dec->fref[j]->imgcoi_ref >= -256 |
| && avs2_dec->fref[j]->imgcoi_ref == |
| img->coding_order - |
| hd->curr_RPS.remove_pic[i]) |
| break; |
| } |
| if (j < avs2_dec->ref_maxbuffer) { /**/ |
| #if FIX_RPS_PICTURE_REMOVE |
| /* Label new frames as "un-referenced" */ |
| avs2_dec->fref[j]->refered_by_others = 0; |
| |
| /* remove frames which have been outputted */ |
| if (avs2_dec->fref[j]->is_output == -1) { |
| avs2_dec->fref[j]-> |
| imgtr_fwRefDistance = -256; |
| avs2_dec->fref[j]->imgcoi_ref = -257; |
| avs2_dec->fref[j]->temporal_id = -1; |
| |
| } |
| #else |
| avs2_dec->fref[j]->imgcoi_ref = -257; |
| #if M3480_TEMPORAL_SCALABLE |
| avs2_dec->fref[j]->temporal_id = -1; |
| #endif |
| if (avs2_dec->fref[j]->is_output == -1) { |
| avs2_dec->fref[j]->imgtr_fwRefDistance |
| = -256; |
| } |
| #endif |
| } |
| } |
| } |
| #endif |
| |
| |
| /*! TO 19.11.2001 Known Problem: for init_frame |
| * we have to know the picture type of the |
| * actual frame*/ |
| /*! in case the first slice of the P-Frame |
| * following the I-Frame was lost we decode this |
| * P-Frame but! do not write it because it |
| * was |
| * assumed to be an I-Frame in init_frame.So we |
| * force the decoder to*/ |
| /*! guess the right picture type. This is a hack |
| * a should be removed by the time there is a |
| * clean*/ |
| /*! solution where we do not have to know the |
| * picture type for the function init_frame.*/ |
| /*! End TO 19.11.2001//Lou*/ |
| |
| { |
| if (img->type == I_IMG || |
| img->type == P_IMG || |
| img->type == F_IMG) |
| img->number++; |
| else { |
| hc->Bframe_ctr++; /* B |
| pictures*/ |
| } |
| } |
| return ret; |
| } |
| |
| void init_avs2_decoder(struct avs2_decoder *avs2_dec) |
| { |
| int32_t i, j, k; |
| |
| struct inp_par *input = &avs2_dec->input; |
| struct ImageParameters_s *img = &avs2_dec->img; |
| struct Video_Com_data_s *hc = &avs2_dec->hc; |
| struct Video_Dec_data_s *hd = &avs2_dec->hd; |
| if (is_avs2_print_bufmgr_detail()) |
| pr_info("[t] struct avs2_dec @0x%p\n", avs2_dec); |
| memset(avs2_dec, 0, sizeof(struct avs2_decoder)); |
| #ifdef AML |
| avs2_dec->to_prepare_disp_count = 1; |
| #endif |
| /* |
| * ALFParam init |
| */ |
| for (i = 0; i < 3; i++) { |
| avs2_dec->m_alfPictureParam[i].alf_flag = 0; /*1*/ |
| avs2_dec->m_alfPictureParam[i].num_coeff = 9; /*1*/ |
| avs2_dec->m_alfPictureParam[i].filters_per_group = 3; /*1*/ |
| avs2_dec->m_alfPictureParam[i].componentID = i; /*1*/ |
| for (j = 0; j < 16; j++) { |
| avs2_dec->m_alfPictureParam[i].filterPattern[j] = 0; |
| /*16*/ |
| } |
| for (j = 0; j < 16; j++) { |
| for (k = 0; k < 9; k++) { |
| avs2_dec-> |
| m_alfPictureParam[i].coeffmulti[j][k] = 0; |
| /*16*9*/ |
| } |
| } |
| } |
| |
| img->seq_header_indicate = 0; |
| img->B_discard_flag = 0; |
| |
| hd->eos = 0; |
| |
| if (input->ref_pic_order) { /*ref order*/ |
| hd->dec_ref_num = 0; |
| } |
| |
| /* |
| memset(g_log2size, -1, MAX_CU_SIZE + 1); |
| c = 2; |
| for (k = 4; k <= MAX_CU_SIZE; k *= 2) { |
| g_log2size[k] = c; |
| c++; |
| } |
| */ |
| |
| avs2_dec->outprint.buffer_num = 0; |
| |
| hd->last_output = -1; |
| hd->end_SeqTr = -1; |
| hd->curr_IDRtr = 0; |
| hd->curr_IDRcoi = 0; |
| hd->next_IDRtr = 0; |
| hd->next_IDRcoi = 0; |
| /* Allocate Slice data struct*/ |
| img->number = 0; |
| img->type = I_IMG; |
| |
| img->imgtr_next_P = 0; |
| |
| img->imgcoi_next_ref = 0; |
| |
| |
| img->num_of_references = 0; |
| hc->seq_header = 0; |
| |
| img->new_sequence_flag = 1; |
| |
| hd->vec_flag = 0; |
| |
| hd->FrameNum = 0; |
| |
| /* B pictures*/ |
| hc->Bframe_ctr = 0; |
| hc->total_frames = 0; |
| |
| /* time for total decoding session*/ |
| hc->tot_time = 0; |
| |
| } |
| |
