/****************************************************************************** * * Copyright (C) 2022 The Android Open Source Project * * 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. * ***************************************************************************** * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore */ /** ******************************************************************************* * @file * isvcd_mode_mv_resamp.c * * @brief * Contains routines that resample for SVC resampling * * @author * Kishore * * @par List of Functions: * - isvcd_ref_lyr_part_idc() * - isvcd_check_motion() * - isvcd_get_min_positive() * - isvcd_motion_scale_crop_wdw_change() * - isvcd_interlyr_motion_scale() * - isvcd_store_motion_map() * - isvcd_check_mv_diff() * - isvcd_interlyr_motion_submbmode_pred() * - isvcd_interlyr_mbmode_pred_bmb() * - isvcd_populate_ref_idx() * - isvcd_interlyr_mbmode_pred() * - isvcd_compute_interlyr_motion_mode() * - isvcd_interlyr_motion_mode_pred_dyadic() * - isvcd_compute_scaled_offsets() * - isvcd_comp_mode_mv_res_init() * * @remarks * None * ******************************************************************************* */ #include #include #include "ih264_typedefs.h" #include "ih264_macros.h" #include "ih264_platform_macros.h" #include "ih264_defs.h" #include "ih264d_bitstrm.h" #include "ih264d_defs.h" #include "ih264d_debug.h" #include "isvcd_structs.h" #include "ih264d_defs.h" #include "ih264d_parse_cavlc.h" #include "ih264d_mb_utils.h" #include "ih264d_deblocking.h" #include "ih264d_dpb_manager.h" #include "ih264d_mvpred.h" #include "ih264d_inter_pred.h" #include "ih264d_process_pslice.h" #include "ih264d_error_handler.h" #include "ih264d_cabac.h" #include "ih264d_debug.h" #include "ih264d_tables.h" #include "ih264d_parse_slice.h" #include "ih264d_utils.h" #include "ih264d_parse_islice.h" #include "ih264d_process_bslice.h" #include "ih264d_process_intra_mb.h" #include "isvcd_mode_mv_resamp.h" #include "ih264_debug.h" const WORD32 g_i4_dpb_size[16] = { 396, 396, 900, 2376, 2376, 2376, 4752, 8100, 8100, 18000, 20480, 32768, 32768, 34816, 110400, 184320, }; /*****************************************************************************/ /* total_coeff and trailing 1's decode table */ /*****************************************************************************/ /*-----------------------------------------------------------------------*/ /* This table consists of info about the NNZ and t1 table */ /*-----------------------------------------------------------------------*/ const UWORD16 g_au2_nnz_tbl_offsets[9] = {0, 0, 120, 120, 224, 224, 224, 224, 224}; /*-----------------------------------------------------------------------*/ /* For given bits in the bitstream, this table consists of 3 parts */ /* | tcoeff(4) | t1s(2) | suffix(2)| */ /*-----------------------------------------------------------------------*/ const UWORD8 g_au1_codegx_avc[312] = { 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 4, 4, 4, 4, 4, 4, 24, 24, 24, 24, 24, 24, 24, 24, 22, 22, 2, 2, 45, 45, 45, 45, 78, 78, 42, 42, 61, 61, 61, 61, 94, 94, 58, 58, 38, 38, 18, 18, 110, 110, 74, 74, 54, 54, 34, 34, 126, 126, 90, 90, 70, 70, 50, 50, 142, 142, 106, 106, 86, 86, 66, 66, 115, 139, 119, 99, 159, 123, 103, 83, 191, 171, 151, 147, 175, 155, 135, 131, 223, 203, 183, 179, 207, 187, 167, 163, 255, 235, 231, 211, 239, 219, 215, 195, 242, 242, 250, 250, 246, 246, 226, 226, 196, 196, 196, 196, 196, 196, 196, 196, 5, 5, 5, 5, 1, 1, 1, 1, 62, 62, 46, 46, 25, 25, 25, 25, 95, 43, 39, 3, 78, 78, 22, 22, 110, 110, 58, 58, 54, 54, 18, 18, 126, 126, 74, 74, 70, 70, 34, 34, 66, 66, 90, 90, 86, 86, 50, 50, 142, 142, 106, 106, 102, 102, 82, 82, 175, 139, 135, 115, 159, 123, 119, 99, 163, 171, 167, 147, 191, 155, 151, 131, 223, 203, 199, 195, 207, 187, 183, 179, 231, 227, 235, 215, 218, 218, 210, 210, 254, 254, 250, 250, 246, 246, 242, 242, 236, 236, 236, 236, 236, 236, 236, 236, 111, 95, 79, 63, 47, 27, 7, 0, 71, 75, 55, 59, 39, 127, 43, 23, 35, 107, 103, 19, 143, 91, 87, 3, 99, 83, 139, 67, 159, 123, 119, 51, 191, 171, 151, 131, 175, 155, 135, 115, 179, 203, 183, 163, 207, 187, 167, 147, 231, 211, 223, 219, 215, 195, 198, 198, 246, 246, 226, 226, 238, 238, 234, 234, 253, 253, 253, 253, 249, 249, 249, 249, 240, 240, 240, 240, 240, 240, 240, 240}; /*-----------------------------------------------------------------------*/ /* For given bits in the bitstream the decoded codeword consists of 2 */ /* fields: */ /* | targetcoefftokenidx(6) | suffix(2) | */ /*-----------------------------------------------------------------------*/ const UWORD8 g_au1_codegx_svc[312] = { 16, 16, 16, 16, 16, 16, 16, 16, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 22, 22, 18, 18, 13, 13, 13, 13, 34, 34, 30, 30, 25, 25, 25, 25, 50, 50, 46, 46, 42, 42, 38, 38, 66, 66, 62, 62, 58, 58, 54, 54, 82, 82, 78, 78, 74, 74, 70, 70, 98, 98, 94, 94, 90, 90, 86, 86, 131, 127, 123, 119, 115, 111, 107, 103, 163, 159, 155, 151, 147, 143, 139, 135, 195, 191, 187, 183, 179, 175, 171, 167, 231, 227, 223, 219, 215, 211, 207, 203, 246, 246, 242, 242, 238, 238, 234, 234, 196, 196, 196, 196, 196, 196, 196, 196, 5, 5, 5, 5, 29, 29, 29, 29, 18, 18, 14, 14, 9, 9, 9, 9, 43, 39, 35, 31, 26, 26, 22, 22, 58, 58, 54, 54, 50, 50, 46, 46, 74, 74, 70, 70, 66, 66, 62, 62, 90, 90, 86, 86, 82, 82, 78, 78, 106, 106, 102, 102, 98, 98, 94, 94, 139, 135, 131, 127, 123, 119, 115, 111, 171, 167, 163, 159, 155, 151, 147, 143, 203, 199, 195, 191, 187, 183, 179, 175, 227, 223, 231, 219, 210, 210, 206, 206, 234, 234, 246, 246, 242, 242, 238, 238, 212, 212, 212, 212, 212, 212, 212, 212, 31, 27, 23, 19, 15, 11, 7, 64, 63, 59, 55, 51, 47, 43, 39, 35, 95, 91, 87, 83, 79, 75, 71, 67, 127, 123, 119, 115, 111, 107, 103, 99, 159, 155, 151, 147, 143, 139, 135, 131, 191, 187, 183, 179, 175, 171, 167, 163, 219, 215, 211, 207, 203, 199, 194, 194, 234, 234, 230, 230, 226, 226, 222, 222, 241, 241, 241, 241, 237, 237, 237, 237, 244, 244, 244, 244, 244, 244, 244, 244, 64, 64, 64, 64, 64, 64, 64, 64 }; /*---------------------------------------------------------------------------*/ /* A lookup table, when nC>=8, to get the targetcoefftokenidx */ /*---------------------------------------------------------------------------*/ const UWORD8 g_au1_target_coeff_token_idx[68] = { 0, 0, 0, 0, 16, 1, 1, 1, 20, 8, 2, 2, 23, 11, 9, 3, 24, 13, 12, 4, 28, 15, 14, 5, 30, 17, 18, 6, 31, 21, 22, 7, 32, 25, 26, 10, 36, 33, 29, 19, 40, 37, 34, 27, 44, 41, 38, 35, 47, 45, 42, 39, 49, 48, 46, 43, 53, 50, 51, 52, 57, 54, 55, 56, 61, 58, 59, 60}; /*---------------------------------------------------------------------------*/ /* A lookup table for invTotalCoeff( coeffTokenIdx) and */ /* invTrailingOnes( coeffTokenIdx ) */ /*---------------------------------------------------------------------------*/ const UWORD8 g_au1_inv_tcoeff_t1[186] = { 0, 5, 10, 15, 4, 9, 19, 14, 23, 8, 13, 18, 27, 12, 17, 22, 31, 16, 21, 26, 35, 20, 25, 30, 39, 24, 29, 34, 43, 28, 33, 38, 32, 36, 37, 42, 47, 40, 41, 46, 51, 44, 45, 50, 55, 48, 49, 54, 59, 53, 52, 57, 58, 63, 56, 61, 62, 67, 60, 65, 66, 64, 0, 5, 10, 15, 19, 9, 23, 4, 13, 14, 27, 8, 17, 18, 31, 12, 21, 22, 35, 16, 25, 26, 20, 24, 29, 30, 39, 28, 33, 34, 43, 32, 37, 38, 47, 36, 41, 42, 51, 40, 45, 46, 44, 48, 49, 50, 55, 52, 53, 54, 59, 56, 58, 63, 57, 60, 61, 62, 67, 64, 65, 66, 0, 5, 10, 15, 19, 23, 27, 31, 9, 14, 35, 13, 18, 17, 22, 21, 4, 25, 26, 39, 8, 29, 30, 12, 16, 33, 34, 43, 20, 38, 24, 28, 32, 37, 42, 47, 36, 41, 46, 51, 40, 45, 50, 55, 44, 49, 54, 48, 53, 52, 57, 58, 59, 56, 61, 62, 63, 60, 65, 66, 67, 64}; /*---------------------------------------------------------------------------*/ /* A lookup table for decoding the chroma nnz's and trailing 1's */ /*---------------------------------------------------------------------------*/ const UWORD8 g_au1_chroma_dc_nnz_t1[28] = {4, 4, 4, 4, 0, 0, 0, 0, 24, 24, 24, 24, 18, 46, 22, 2, 49, 49, 33, 33, 41, 41, 37, 37, 57, 57, 53, 53}; /*****************************************************************************/ /* Total zeroes table */ /*****************************************************************************/ /*-----------------------------------------------------------------------*/ /* Contains information about tz table. Each entry consists of 3 fields */ /* | table offset (8) | max zeroes(4) | bit offset(2) | */ /*-----------------------------------------------------------------------*/ const UWORD16 g_au2_tz_tbl_offsets[27] = {0, 37, 1178, 2778, 4374, 5718, 7066, 8666, 10265, 11097, 11925, 12625, 13200, 13516, 13768, 13956, 14092, 14344, 14532, 14677, 15374, 16206, 17034, 17609, 17928, 18116, 18240}; /*-----------------------------------------------------------------------*/ /* Total zero table */ /*-----------------------------------------------------------------------*/ const UWORD8 g_au1_tz_tbl[285] = { 0, 0, 9, 5, 17, 13, 25, 21, 33, 29, 41, 37, 49, 45, 57, 53, 60, 60, 14, 10, 6, 2, 26, 22, 17, 17, 33, 33, 29, 29, 41, 41, 37, 37, 49, 49, 45, 45, 52, 52, 52, 52, 56, 26, 14, 10, 6, 18, 2, 29, 29, 33, 33, 21, 21, 41, 41, 37, 37, 48, 48, 48, 48, 44, 44, 44, 44, 52, 26, 22, 18, 6, 14, 10, 33, 33, 37, 37, 29, 29, 41, 41, 1, 1, 44, 44, 44, 44, 48, 26, 22, 18, 14, 6, 2, 29, 29, 33, 33, 9, 9, 40, 40, 40, 40, 36, 36, 36, 36, 44, 22, 18, 14, 10, 29, 29, 25, 25, 36, 36, 36, 36, 32, 32, 32, 32, 4, 4, 4, 4, 0, 0, 0, 0, 40, 14, 10, 21, 21, 25, 25, 17, 17, 32, 32, 32, 32, 28, 28, 28, 28, 4, 4, 4, 4, 0, 0, 0, 0, 36, 21, 17, 25, 13, 28, 28, 4, 4, 8, 8, 0, 0, 32, 17, 13, 24, 24, 20, 20, 8, 8, 28, 28, 0, 0, 4, 17, 13, 20, 20, 8, 8, 24, 24, 0, 0, 4, 16, 16, 13, 21, 8, 8, 4, 4, 0, 12, 8, 16, 4, 0, 8, 12, 4, 0, 8, 4, 0, 4, 0, 0, 4, 8, 12, 0, 4, 8, 0, 4, 0, 0, 5, 9, 13, 17, 20, 20, 24, 24, 28, /*11*/ 14, 18, 22, 26, 4, 4, 4, 4, 8, 8, 8, 8, 0, /*13*/ 13, 13, 18, 22, 8, 8, 8, 8, 4, 4, 4, 4, 0, /*13*/ 13, 13, 2, 18, 8, 8, 8, 8, 4, /*9*/ 9, 13, 4, 4, 0, /*5*/ 8, 4, 0, /*3*/ 4, 0 /*2*/ }; /*****************************************************************************/ /* Run before table */ /*****************************************************************************/ const UWORD8 g_au1_run_bef_tbl[64] = {0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 5, 5, 1, 1, 1, 1, 10, 10, 6, 6, 1, 1, 1, 1, 14, 14, 10, 10, 6, 6, 2, 2, 19, 15, 10, 10, 6, 6, 2, 2, 23, 19, 15, 11, 6, 6, 2, 2, 7, 11, 19, 15, 27, 23, 2, 2, 27, 27, 23, 19, 15, 11, 7, 3}; /*****************************************************************************/ /* CBP table */ /*****************************************************************************/ /*-----------------------------------------------------------------------*/ /* Contains both inter and intra tables */ /*-----------------------------------------------------------------------*/ const UWORD8 g_au1_intra_cbp[48] = {47, 31, 15, 0, 23, 27, 29, 30, 7, 11, 13, 14, 39, 43, 45, 46, 16, 3, 5, 10, 12, 19, 21, 26, 28, 35, 37, 42, 44, 1, 2, 4, 8, 17, 18, 20, 24, 6, 9, 22, 25, 32, 33, 34, 36, 40, 38, 41}; const UWORD8 g_au1_inter_cbp[48] = {0, 16, 1, 2, 4, 8, 32, 3, 5, 10, 12, 15, 47, 7, 11, 13, 14, 6, 9, 31, 35, 37, 42, 44, 33, 34, 36, 40, 39, 43, 45, 46, 17, 18, 20, 24, 19, 21, 26, 28, 23, 27, 29, 30, 22, 25, 38, 41}; /*---------------------------------------------------------------------------*/ /* Contains the cbp table for intra16x16 mb type */ /*---------------------------------------------------------------------------*/ const UWORD8 g_au1_intra16x16_cbp[6] = {0, 16, 32, 15, 31, 47}; /*****************************************************************************/ /* Inverse scan table */ /*****************************************************************************/ /*-----------------------------------------------------------------------*/ /* Regular inverse scan tables */ /*-----------------------------------------------------------------------*/ const UWORD8 g_au1_regular_inv_scan[16] = {0, 1, 4, 8, 5, 2, 3, 6, 9, 12, 13, 10, 7, 11, 14, 15}; const UWORD8 g_au1_regular_inv_scan_field[16] = {0, 4, 1, 8, 12, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15}; const UWORD8 g_au1_regular_inv_scan8x8[64] = { 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63}; UWORD8 const g_au1_subblk_8x8_offsets[16] = {0, 0, 0, 0, 64, 64, 64, 64, 128, 128, 128, 128, 192, 192, 192, 192}; /*---------------------------------------------------------------------------*/ /* 8x8 inverse scan tables */ /*---------------------------------------------------------------------------*/ const UWORD8 g_au1_prog_deinter_inv_scan[4][16] = { {0, 9, 17, 18, 12, 40, 27, 7, 35, 57, 29, 30, 58, 38, 53, 47}, /* for First subblock */ {1, 2, 24, 11, 19, 48, 20, 14, 42, 50, 22, 37, 59, 31, 60, 55}, /* for second subblock */ {8, 3, 32, 4, 26, 41, 13, 21, 49, 43, 15, 44, 52, 39, 61, 62}, /* for third subblock */ {16, 10, 25, 5, 33, 34, 6, 28, 56, 36, 23, 51, 45, 46, 54, 63} /* for fourth subblock */ }; const UWORD8 g_au1_prog_8x8_inv_scan[64] = { 0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63}; /*****************************************************************************/ /* SUBMB partition tables */ /*****************************************************************************/ /*---------------------------------------------------------------------------*/ /* Number of sub Mb's in 8x8 partition mode */ /*---------------------------------------------------------------------------*/ const UWORD8 g_au1_num_sub_mb_part[4] = {1, 2, 2, 4}; /*---------------------------------------------------------------------------*/ /* Width and height of submb's in terms of 4x4 (for 8x8 partition mode) */ /*---------------------------------------------------------------------------*/ const UWORD8 g_au1_sub_mb_part_wd[4] = {2, 2, 1, 1}; const UWORD8 g_au1_sub_mb_part_ht[4] = {2, 1, 2, 1}; /*---------------------------------------------------------------------------*/ /* SubMB mc mode table */ /*---------------------------------------------------------------------------*/ const UWORD8 g_au1_sub_mb_mc_mode[20] = {SUBMB_8x8, SUBMB_8x4, SUBMB_4x8, SUBMB_4x4, SUBMB_8x8, SUBMB_8x8, SUBMB_8x8, SUBMB_8x8, SUBMB_8x4, SUBMB_4x8, SUBMB_8x4, SUBMB_4x8, SUBMB_8x4, SUBMB_4x8, SUBMB_4x4, SUBMB_4x4, SUBMB_4x4, /* Self defined modes B DIRECT8x8 */ SUBMB_4x4, SUBMB_4x4, SUBMB_4x4}; /*---------------------------------------------------------------------------*/ /* SubMb prediciton mode table */ /*---------------------------------------------------------------------------*/ const UWORD8 g_au1_sub_mb_pred_mode[20] = { PRED_L0, PRED_L0, PRED_L0, PRED_L0, B_DIRECT, PRED_L0, PRED_L1, BI_PRED, PRED_L0, PRED_L0, PRED_L1, PRED_L1, BI_PRED, BI_PRED, PRED_L0, PRED_L1, BI_PRED, /* Self defined modes for B DIRECT8x8 */ BI_PRED, PRED_L0, PRED_L1, }; /*****************************************************************************/ /* MB partition tables */ /*****************************************************************************/ /*---------------------------------------------------------------------------*/ /* Number of MB partitions */ /*---------------------------------------------------------------------------*/ const UWORD8 g_au1_num_mb_part[5] = {1, 2, 2, 4, 4}; /*---------------------------------------------------------------------------*/ /* MB partitions width and height in terms of submbs */ /*---------------------------------------------------------------------------*/ const UWORD8 g_au1_mb_part_wd[5] = {4, 4, 2, 2, 2}; const UWORD8 g_au1_mb_part_ht[5] = {4, 2, 4, 2, 2}; /*---------------------------------------------------------------------------*/ /* MB MC mode of mb partitions */ /*---------------------------------------------------------------------------*/ const UWORD8 g_au1_mb_mc_mode[31] = { PRED_16x16, PRED_16x8, PRED_8x16, PRED_8x8, PRED_8x8R0, PRED_16x16, PRED_16x16, PRED_16x16, PRED_16x16, PRED_16x8, PRED_8x16, PRED_16x8, PRED_8x16, PRED_16x8, PRED_8x16, PRED_16x8, PRED_8x16, PRED_16x8, PRED_8x16, PRED_16x8, PRED_8x16, PRED_16x8, PRED_8x16, PRED_16x8, PRED_8x16, PRED_16x8, PRED_8x16, PRED_8x8, /* Self defined modes for B_SKIP and DIRECT16x16 */ PRED_8x8, PRED_8x8, PRED_8x8}; /*---------------------------------------------------------------------------*/ /* MB prediciton mode table */ /*---------------------------------------------------------------------------*/ const WORD8 g_au1_mb_pred_mode[2][32] = { { PRED_L0, PRED_L0, PRED_L0, PRED_INVALID, PRED_INVALID, B_DIRECT, PRED_L0, PRED_L1, BI_PRED, PRED_L0, PRED_L0, PRED_L1, PRED_L1, PRED_L0, PRED_L0, PRED_L1, PRED_L1, PRED_L0, PRED_L0, PRED_L1, PRED_L1, BI_PRED, BI_PRED, BI_PRED, BI_PRED, BI_PRED, BI_PRED, PRED_INVALID, /* Self defined modes for B_SKIP and DIRECT16x16 */ BI_PRED, PRED_L0, PRED_L1, }, {PRED_INVALID, PRED_L0, PRED_L0, PRED_INVALID, PRED_INVALID, PRED_INVALID, PRED_INVALID, PRED_INVALID, PRED_INVALID, PRED_L0, PRED_L0, PRED_L1, PRED_L1, PRED_L1, PRED_L1, PRED_L0, PRED_L0, BI_PRED, BI_PRED, BI_PRED, BI_PRED, PRED_L0, PRED_L0, PRED_L1, PRED_L1, BI_PRED, BI_PRED, PRED_INVALID, /* Self defined modes for B_SKIP and DIRECT16x16 */ PRED_INVALID, PRED_INVALID, PRED_INVALID}}; /*---------------------------------------------------------------------------*/ /* Neighbour partition address offsets table */ /*---------------------------------------------------------------------------*/ const UWORD8 g_au1_neighbors_addr_offset[2][16 * 4] = { /* Each row has current, left, top, top right */ /* Each row corresponds to sub_mb_num */ /* Partition width 4 */ { 0, 0, 0, 1, 1, 0, 1, 2, 2, 1, 2, 3, 3, 2, 3, 5, 4, 1, 0, 1, 5, 4, 1, 0, 6, 5, 2, 3, 7, 6, 3, 2, 8, 2, 4, 5, 9, 8, 5, 6, 10, 9, 6, 7, 11, 10, 7, 6, 12, 3, 8, 9, 13, 12, 9, 8, 14, 13, 10, 11, 15, 14, 11, 10, }, /* Partition width 8 */ {/* Only alternate rows are valid */ 0, 0, 0, 2, 0, 0, 0, 0, 2, 1, 2, 4, 0, 0, 0, 0, 4, 1, 0, 2, 0, 0, 0, 0, 6, 5, 2, 1, 0, 0, 0, 0, 8, 2, 4, 6, 0, 0, 0, 0, 10, 9, 6, 5, 0, 0, 0, 0, 12, 3, 8, 10, 0, 0, 0, 0, 14, 13, 10, 9, 0, 0, 0, 0}}; /*---------------------------------------------------------------------------*/ /* Reference index comparison map table */ /*---------------------------------------------------------------------------*/ const UWORD8 g_au1_ref_idx_comp_map[16 * 2 * 16] = { /* SUB MB NUMBER 0 */ 0, 1, 6, 7, 0, 1, 6, 7, 0, 1, 6, 7, 4, 5, 6, 7, /* Partition width 4 */ 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, /* Partition width 8 */ /* SUB MB NUMBER 1 */ 1, 1, 7, 7, 5, 5, 7, 7, 1, 1, 3, 3, 1, 1, 7, 7, /* Partition width 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Partition width 8 */ /* SUB MB NUMBER 2 */ 0, 1, 6, 7, 0, 1, 6, 7, 0, 1, 6, 7, 0, 1, 6, 7, /* Partition width 4 */ 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, /* Partition width 8 */ /* SUB MB NUMBER 3 */ 1, 1, 7, 7, 1, 1, 7, 7, 1, 1, 3, 3, 5, 5, 7, 7, /* Partition width 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Partition width 8 */ /* SUB MB NUMBER 4 */ 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, /* Partition width 4 */ 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, /* Partition width 8 */ /* SUB MB NUMBER 5 */ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, /* Partition width 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Partition width 8 */ /* SUB MB NUMBER 6 */ 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, /* Partition width 4 */ 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, /* Partition width 8 */ /* SUB MB NUMBER 7 */ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, /* Partition width 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Partition width 8 */ /* SUB MB NUMBER 8 */ 0, 1, 6, 7, 0, 1, 6, 7, 0, 1, 6, 7, 0, 1, 6, 7, /* Partition width 4 */ 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, /* Partition width 8 */ /* SUB MB NUMBER 9 */ 1, 1, 3, 3, 5, 5, 7, 7, 1, 1, 3, 3, 5, 5, 7, 7, /* Partition width 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Partition width 8 */ /* SUB MB NUMBER 10 */ 0, 1, 6, 7, 0, 1, 6, 7, 0, 1, 6, 7, 0, 1, 6, 7, /* Partition width 4 */ 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7, /* Partition width 8 */ /* SUB MB NUMBER 11 */ 1, 1, 7, 7, 1, 1, 7, 7, 1, 1, 7, 7, 1, 1, 7, 7, /* Partition width 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Partition width 8 */ /* SUB MB NUMBER 12 */ 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, /* Partition width 4 */ 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, /* Partition width 8 */ /* SUB MB NUMBER 13 */ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, /* Partition width 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* Partition width 8 */ /* SUB MB NUMBER 14 */ 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, /* Partition width 4 */ 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, /* Partition width 8 */ /* SUB MB NUMBER 15 */ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, /* Partition width 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 /* Partition width 8 */ }; /*-----------------------------------------------------------------------*/ /* SUB MB index */ /*-----------------------------------------------------------------------*/ const UWORD8 g_au1_sub_mb_idx_mod[16] = { 0, 0, /* 16x16 */ 0, 8, /* 16x8 */ 0, 2, /* 8x16 */ 0, 0, /* 8x8 */ 0, 4, /* 8x4 */ 0, 1, /* 4x8 */ 0, 1, 3, 1 /* 4x4 */ }; /*****************************************************************************/ /* Raster scan offset table */ /*****************************************************************************/ const UWORD8 g_au1_sub_blk_rast_scan_offsets[16] = {0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15}; /*****************************************************************************/ /*Motion and mode computation tables */ /*****************************************************************************/ /* B MB TYPES */ const UWORD8 g_au1_eb_mb_type[36] = { B_L0_16x16, B_L0_16x16, B_L0_16x16, B_L1_16x16, B_L1_16x16, B_L1_16x16, B_BI_16x16, B_BI_16x16, B_BI_16x16, B_L0_L0_16x8, B_L0_L1_16x8, B_L0_BI_16x8, B_L1_L0_16x8, B_L1_L1_16x8, B_L1_BI_16x8, B_BI_L0_16x8, B_BI_L1_16x8, B_BI_BI_16x8, B_L0_L0_8x16, B_L0_L1_8x16, B_L0_BI_8x16, B_L1_L0_8x16, B_L1_L1_8x16, B_L1_BI_8x16, B_BI_L0_8x16, B_BI_L1_8x16, B_BI_BI_8x16, B_8x8, B_8x8, B_8x8, B_8x8, B_8x8, B_8x8, B_8x8, B_8x8, B_8x8}; /* P MB TYPES */ const UWORD8 g_au1_ep_mb_type[4] = {P_L0_16x16, P_L0_L0_16x8, P_L0_L0_8x16, P_8x8}; /* P SUB MB TYPES */ const UWORD8 g_au1_ep_submb_type[4] = {P_L0_8x8, P_L0_8x4, P_L0_4x8, P_L0_4x4}; /* B SUB MB TYPES */ const UWORD8 g_au1_eb_submb_type[12] = {B_L0_8x8, B_L1_8x8, B_BI_8x8, B_L0_8x4, B_L1_8x4, B_BI_8x4, B_L0_4x8, B_L1_4x8, B_BI_4x8, B_L0_4x4, B_L1_4x4, B_BI_4x4}; /*****************************************************************************/ /* Deblocking related tables */ /*****************************************************************************/ /* chroma QP values luma Qp is used to index to this table */ const UWORD8 g_au1_qp_scale_chroma[52] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 34, 35, 35, 36, 36, 37, 37, 37, 38, 38, 38, 39, 39, 39, 39}; /* alpha table used in deblocking */ const UWORD8 g_au1_alpha_table[52] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 5, 6, 7, 8, 9, 10, 12, 13, 15, 17, 20, 22, 25, 28, 32, 36, 40, 45, 50, 56, 63, 71, 80, 90, 101, 113, 127, 144, 162, 182, 203, 226, 255, 255}; /* clip table used in deblcoking */ const UWORD8 g_au1_clip_table_deblk[75] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51}; /* Beta table used in deblocking*/ const UWORD8 g_au1_beta_table[52] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18}; /* clip table used baed on index BS and other vakues */ const UWORD8 g_au1_clip_table[52][4] = { {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 1}, {0, 0, 0, 1}, {0, 0, 0, 1}, {0, 0, 0, 1}, {0, 0, 1, 1}, {0, 0, 1, 1}, {0, 1, 1, 1}, {0, 1, 1, 1}, {0, 1, 1, 1}, {0, 1, 1, 1}, {0, 1, 1, 2}, {0, 1, 1, 2}, {0, 1, 1, 2}, {0, 1, 1, 2}, {0, 1, 2, 3}, {0, 1, 2, 3}, {0, 2, 2, 3}, {0, 2, 2, 4}, {0, 2, 3, 4}, {0, 2, 3, 4}, {0, 3, 3, 5}, {0, 3, 4, 6}, {0, 3, 4, 6}, {0, 4, 5, 7}, {0, 4, 5, 8}, {0, 4, 6, 9}, {0, 5, 7, 10}, {0, 6, 8, 11}, {0, 6, 8, 13}, {0, 7, 10, 14}, {0, 8, 11, 16}, {0, 9, 12, 18}, {0, 10, 13, 20}, {0, 11, 15, 23}, {0, 13, 17, 25}}; /*****************************************************************************/ /* QUANTIZATION TABLES */ /*****************************************************************************/ const UWORD8 g_au1_luma_to_chroma_qp_map[52] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 29, 30, 31, 32, 32, 33, 34, 34, 35, 35, 36, 36, 37, 37, 37, 38, 38, 38, 39, 39, 39, 39}; const UWORD8 g_au1_scale_factor_table[6] = {8, 9, 10, 11, 13, 14}; /*****************************************************************************/ /* SCALING MATRICIES TABLE */ /*****************************************************************************/ /* Default table used for INTRA 4x4 blocks */ const WORD16 g_ai2_default_intra4x4[16] = {6, 13, 13, 20, 20, 20, 28, 28, 28, 28, 32, 32, 32, 37, 37, 42}; /* Default table used for INTER 4x4 blocks */ const WORD16 g_ai2_default_inter4x4[16] = {10, 14, 14, 20, 20, 20, 24, 24, 24, 24, 27, 27, 27, 30, 30, 34}; /* Flat table used for 4x4 blocks */ const WORD16 g_ai2_flat_4x4[16] = {16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16}; /* Flat table used for 4x4 blocks */ const WORD16 g_ai2_flat_8x8[64] = {16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16}; /* Default table used for INTRA 8x8 blocks */ const WORD16 g_ai2_default_intra8x8[64] = { 6, 10, 10, 13, 11, 13, 16, 16, 16, 16, 18, 18, 18, 18, 18, 23, 23, 23, 23, 23, 23, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27, 27, 27, 27, 27, 27, 29, 29, 29, 29, 29, 29, 29, 31, 31, 31, 31, 31, 31, 33, 33, 33, 33, 33, 36, 36, 36, 36, 38, 38, 38, 40, 40, 42}; /* Default table used for INTER 8x8 blocks */ const WORD16 g_ai2_default_inter8x8[64] = { 9, 13, 13, 15, 13, 15, 17, 17, 17, 17, 19, 19, 19, 19, 19, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 30, 30, 30, 30, 32, 32, 32, 33, 33, 35}; /* V(qp%6) table */ const WORD8 g_ai1_scale_quant_matrix[6][16] = { {10, 13, 13, 10, 16, 10, 13, 13, 13, 13, 16, 10, 16, 13, 13, 16}, {11, 14, 14, 11, 18, 11, 14, 14, 14, 14, 18, 11, 18, 14, 14, 18}, {13, 16, 16, 13, 20, 13, 16, 16, 16, 16, 20, 13, 20, 16, 16, 20}, {14, 18, 18, 14, 23, 14, 18, 18, 18, 18, 23, 14, 23, 18, 18, 23}, {16, 20, 20, 16, 25, 16, 20, 20, 20, 20, 25, 16, 25, 20, 20, 25}, {18, 23, 23, 18, 29, 18, 23, 23, 23, 23, 29, 18, 29, 23, 23, 29}}; /* V(qp%6) table for 8x8 */ const UWORD8 g_ai1_8x8_scale_quant_matrix[6][64] = { {20, 19, 19, 25, 18, 25, 19, 24, 24, 19, 20, 18, 32, 18, 20, 19, 19, 24, 24, 19, 19, 25, 18, 25, 18, 25, 18, 25, 19, 24, 24, 19, 19, 24, 24, 19, 18, 32, 18, 20, 18, 32, 18, 24, 24, 19, 19, 24, 24, 18, 25, 18, 25, 18, 19, 24, 24, 19, 18, 32, 18, 24, 24, 18}, {22, 21, 21, 28, 19, 28, 21, 26, 26, 21, 22, 19, 35, 19, 22, 21, 21, 26, 26, 21, 21, 28, 19, 28, 19, 28, 19, 28, 21, 26, 26, 21, 21, 26, 26, 21, 19, 35, 19, 22, 19, 35, 19, 26, 26, 21, 21, 26, 26, 19, 28, 19, 28, 19, 21, 26, 26, 21, 19, 35, 19, 26, 26, 19}, {26, 24, 24, 33, 23, 33, 24, 31, 31, 24, 26, 23, 42, 23, 26, 24, 24, 31, 31, 24, 24, 33, 23, 33, 23, 33, 23, 33, 24, 31, 31, 24, 24, 31, 31, 24, 23, 42, 23, 26, 23, 42, 23, 31, 31, 24, 24, 31, 31, 23, 33, 23, 33, 23, 24, 31, 31, 24, 23, 42, 23, 31, 31, 23}, {28, 26, 26, 35, 25, 35, 26, 33, 33, 26, 28, 25, 45, 25, 28, 26, 26, 33, 33, 26, 26, 35, 25, 35, 25, 35, 25, 35, 26, 33, 33, 26, 26, 33, 33, 26, 25, 45, 25, 28, 25, 45, 25, 33, 33, 26, 26, 33, 33, 25, 35, 25, 35, 25, 26, 33, 33, 26, 25, 45, 25, 33, 33, 25}, {32, 30, 30, 40, 28, 40, 30, 38, 38, 30, 32, 28, 51, 28, 32, 30, 30, 38, 38, 30, 30, 40, 28, 40, 28, 40, 28, 40, 30, 38, 38, 30, 30, 38, 38, 30, 28, 51, 28, 32, 28, 51, 28, 38, 38, 30, 30, 38, 38, 28, 40, 28, 40, 28, 30, 38, 38, 30, 28, 51, 28, 38, 38, 28}, {36, 34, 34, 46, 32, 46, 34, 43, 43, 34, 36, 32, 58, 32, 36, 34, 34, 43, 43, 34, 34, 46, 32, 46, 32, 46, 32, 46, 34, 43, 43, 34, 34, 43, 43, 34, 32, 58, 32, 36, 32, 58, 32, 43, 43, 34, 34, 43, 43, 32, 46, 32, 46, 32, 34, 43, 43, 34, 32, 58, 32, 43, 43, 32} }; /*****************************************************************************/ /* CABAC engine tables */ /*****************************************************************************/ const UWORD8 g_au1_sig_coeff_ctxt_inc[64] = { 0, 1, 2, 3, 4, 5, 5, 4, 4, 3, 3, 4, 4, 4, 5, 5, 4, 4, 4, 4, 3, 3, 6, 7, 7, 7, 8, 9, 10, 9, 8, 7, 7, 6, 11, 12, 13, 11, 6, 7, 8, 9, 14, 10, 9, 8, 6, 11, 12, 13, 11, 6, 9, 14, 10, 9, 11, 12, 13, 11, 14, 10, 12, 255}; const UWORD8 g_au1_last_coeff_ctxt_inc[64] = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 255}; /*-----------------------------------------------------------------------*/ /* Range table */ /*-----------------------------------------------------------------------*/ const UWORD8 g_au1_cabac_rtab[64][4] = { {128, 176, 208, 240}, {128, 167, 197, 227}, {128, 158, 187, 216}, {123, 150, 178, 205}, {116, 142, 169, 195}, {111, 135, 160, 185}, {105, 128, 152, 175}, {100, 122, 144, 166}, {95, 116, 137, 158}, {90, 110, 130, 150}, {85, 104, 123, 142}, {81, 99, 117, 135}, {77, 94, 111, 128}, {73, 89, 105, 122}, {69, 85, 100, 116}, {66, 80, 95, 110}, {62, 76, 90, 104}, {59, 72, 86, 99}, {56, 69, 81, 94}, {53, 65, 77, 89}, {51, 62, 73, 85}, {48, 59, 69, 80}, {46, 56, 66, 76}, {43, 53, 63, 72}, {41, 50, 59, 69}, {39, 48, 56, 65}, {37, 45, 54, 62}, {35, 43, 51, 59}, {33, 41, 48, 56}, {32, 39, 46, 53}, {30, 37, 43, 50}, {29, 35, 41, 48}, {27, 33, 39, 45}, {26, 31, 37, 43}, {24, 30, 35, 41}, {23, 28, 33, 39}, {22, 27, 32, 37}, {21, 26, 30, 35}, {20, 24, 29, 33}, {19, 23, 27, 31}, {18, 22, 26, 30}, {17, 21, 25, 28}, {16, 20, 23, 27}, {15, 19, 22, 25}, {14, 18, 21, 24}, {14, 17, 20, 23}, {13, 16, 19, 22}, {12, 15, 18, 21}, {12, 14, 17, 20}, {11, 14, 16, 19}, {11, 13, 15, 18}, {10, 12, 15, 17}, {10, 12, 14, 16}, {9, 11, 13, 15}, {9, 11, 12, 14}, {8, 10, 12, 14}, {8, 9, 11, 13}, {7, 9, 11, 12}, {7, 9, 10, 12}, {7, 8, 10, 11}, {6, 8, 9, 11}, {6, 7, 9, 10}, {6, 7, 8, 9}, {2, 2, 2, 2}}; /*-----------------------------------------------------------------------*/ /* Next state MPS_LPS table */ /*-----------------------------------------------------------------------*/ const UWORD16 g_au2_cabac_next_state_mps_lps[64] = { 0x100, 0x200, 0x301, 0x402, 0x502, 0x604, 0x704, 0x805, 0x906, 0xa07, 0xb08, 0xc09, 0xd09, 0xe0b, 0xf0b, 0x100c, 0x110d, 0x120d, 0x130f, 0x140f, 0x1510, 0x1610, 0x1712, 0x1812, 0x1913, 0x1a13, 0x1b15, 0x1c15, 0x1d16, 0x1e16, 0x1f17, 0x2018, 0x2118, 0x2219, 0x231a, 0x241a, 0x251b, 0x261b, 0x271c, 0x281d, 0x291d, 0x2a1e, 0x2b1e, 0x2c1e, 0x2d1f, 0x2e20, 0x2f20, 0x3021, 0x3121, 0x3221, 0x3322, 0x3422, 0x3523, 0x3623, 0x3723, 0x3824, 0x3924, 0x3a24, 0x3b25, 0x3c25, 0x3d25, 0x3e26, 0x3e26, 0x3f3f}; /*****************************************************************************/ /* */ /* Function Name : isvcd_ref_lyr_part_idc */ /* */ /* Description : this function computes the reference layer partition map */ /* for all the 4x4 partitions of the current MB */ /* */ /* Inputs : pv_comp_mode_mv_ctxt : mode motion handle */ /* ai4_ref_part_idc : pointer to reference layer partition */ /* indentification */ /* pi4_intra_flag : pointer to store the intra flag */ /* i4_mb_addr : current MB address */ /* Globals : none */ /* Processing : it projects the each 4x4 block onto the refernce layer */ /* and gets the co-located location. it checks the MB mode */ /* of the reference layer MB for INTRA and performs actions */ /* appropriately. it modifies the intra declared partitions */ /* for non-dydaic cases */ /* Outputs : packed offset x and offset y in the refernce layer array */ /* Returns : none */ /* */ /* Issues : none */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 06 09 2021 vijayakumar creation */ /* */ /*****************************************************************************/ void isvcd_ref_lyr_part_idc(void *pv_comp_mode_mv_ctxt, WORD32 ai4_ref_part_idc[4][4], WORD32 *pi4_intra_flag, void *pv_mb_params) { /*! Flow of the module is as follows */ /*! 1. runs loops over the 16 4x4 blocks and gets teh reference layer patition information by projecting the 1,1 locations of each block */ /*! 2. if the projected partition is in INTRA MB then its stores -1 to the partition idc array */ /*! 3. if projected partition is in INTER MB then it packs and stores the offsets form the starting pointer in the part_idc array */ /*! 4. IN non dyaydic cases. the part idc having -1 are replaced by neighbours if the current MB projected is not INTRA */ /*! 5. the -1 values are replaced first on a 4x4 inside an 8x8 basis */ /*! 6. in second iteration -1 are replaced at an 8x8 basis */ /*! 7. stores the intra MB status in the location given */ mode_motion_ctxt_t *ps_ctxt; mode_motion_lyr_ctxt *ps_lyr_mem; inter_lyr_mb_prms_t *ps_inter_lyr_mb_prms; WORD32 i4_blk_y, i4_blk_x; WORD32 i4_mb_x, i4_mb_y; WORD32 i4_intra_mb_flag; WORD32 i4_inter_lyr_mb_prms_stride; dec_mb_info_t *ps_mb_params; ps_mb_params = (dec_mb_info_t *) pv_mb_params; ps_ctxt = (mode_motion_ctxt_t *) pv_comp_mode_mv_ctxt; /* get the current layer ctxt */ ps_lyr_mem = &ps_ctxt->as_res_lyr_mem[ps_ctxt->i4_res_id]; /* ref layer mb mode */ ps_inter_lyr_mb_prms = (inter_lyr_mb_prms_t *) ps_lyr_mem->s_ref_mb_mode.pv_buffer; i4_inter_lyr_mb_prms_stride = ps_lyr_mem->s_ref_mb_mode.i4_num_element_stride; /* derive the MB_X and MB_Y for the current MB */ i4_mb_x = ps_mb_params->u2_mbx; i4_mb_y = ps_mb_params->u2_mby; /* set the intra MB flag to default TRUE */ i4_intra_mb_flag = SVCD_TRUE; /*-----------------------------------------------------------------------*/ /* derive the reference layer part idc for all 16 partitions */ /*-----------------------------------------------------------------------*/ for(i4_blk_y = 0; i4_blk_y < NUM_SUB_MB_PARTS; i4_blk_y++) { for(i4_blk_x = 0; i4_blk_x < NUM_SUB_MB_PARTS; i4_blk_x++) { WORD32 i4_curr_x, i4_curr_y; WORD32 i4_ref_x, i4_ref_y; WORD32 i4_ref_mb_x, i4_ref_mb_y; WORD8 i1_ref_mb_mode; inter_lyr_mb_prms_t *ps_inter_lyr_mb_prms_temp; i4_curr_x = (i4_mb_x << 4) + (i4_blk_x << 2) + 1; i4_curr_y = (i4_mb_y << 4) + (i4_blk_y << 2) + 1; /* get the colocated position in the refernce layer */ i4_ref_x = ps_lyr_mem->pi2_ref_loc_x[i4_curr_x]; i4_ref_y = ps_lyr_mem->pi2_ref_loc_y[i4_curr_y]; i4_ref_x = CLIP3(0, ((ps_lyr_mem->i4_ref_width) - 1), i4_ref_x); i4_ref_y = CLIP3(0, ((ps_lyr_mem->i4_ref_height) - 1), i4_ref_y); /* get the reference mb x and y */ i4_ref_mb_x = (i4_ref_x >> 4); i4_ref_mb_y = (i4_ref_y >> 4); /* get the appropriate mb params in reference layer */ ps_inter_lyr_mb_prms_temp = ps_inter_lyr_mb_prms + i4_ref_mb_x; ps_inter_lyr_mb_prms_temp += i4_ref_mb_y * i4_inter_lyr_mb_prms_stride; i1_ref_mb_mode = ps_inter_lyr_mb_prms_temp->i1_mb_mode; /* check if the MB mode of the refernce MB is Intra*/ if(i1_ref_mb_mode > SVC_INTER_MB) { /* store the -1 value */ ai4_ref_part_idc[i4_blk_y][i4_blk_x] = -1; } else { /* pack and store the reference x and y */ ai4_ref_part_idc[i4_blk_y][i4_blk_x] = (i4_ref_y << 16) + i4_ref_x; i4_intra_mb_flag = SVCD_FALSE; } } /* end of block x loop */ } /* end of block y loop */ /*************************************************************************/ /* if the restricted spatial resolution change flag is 0 */ /* modify the part_idc for all the partitions */ /*************************************************************************/ if(SVCD_FALSE == (ps_lyr_mem->ps_curr_lyr_res_prms->u1_rstrct_res_change_flag) && (SVCD_FALSE == i4_intra_mb_flag)) { /* replace values of "-1" on a 4x4 block basis */ WORD32 i4_xp, i4_yp; WORD32 i4_indx_x, i4_indx_y; WORD32 ai4_flag_8x8[2][2] = {SVCD_FALSE}; /* loop over (4) 8x8 partitions */ for(i4_yp = 0; i4_yp < 2; i4_yp++) { for(i4_xp = 0; i4_xp < 2; i4_xp++) { WORD32 i4_xs, i4_ys; WORD32 ai4_flag_4x4[2][2] = {SVCD_FALSE}; /* loop over (4) 4x4 partitions */ for(i4_ys = 0; i4_ys < 2; i4_ys++) { for(i4_xs = 0; i4_xs < 2; i4_xs++) { /* index to the exact 4x4 block */ i4_indx_y = (i4_yp << 1) + i4_ys; i4_indx_x = (i4_xp << 1) + i4_xs; /* check if the current part idc is -1*/ if(ai4_ref_part_idc[i4_indx_y][i4_indx_x] == -1) { WORD32 i4_temp_x = 1 - i4_xs; WORD32 i4_temp_y = 1 - i4_ys; WORD32 i4_temp_part_y = (i4_yp << 1) + i4_temp_y; WORD32 i4_temp_part_x = (i4_xp << 1) + i4_temp_x; ai4_flag_4x4[i4_ys][i4_xs] = SVCD_TRUE; /* replace with appropriate values */ if((SVCD_FALSE == ai4_flag_4x4[i4_ys][i4_temp_x]) && (ai4_ref_part_idc[i4_indx_y][i4_temp_part_x] != -1)) { ai4_ref_part_idc[i4_indx_y][i4_indx_x] = ai4_ref_part_idc[i4_indx_y][i4_temp_part_x]; } else if((SVCD_FALSE == ai4_flag_4x4[i4_temp_y][i4_xs]) && (ai4_ref_part_idc[i4_temp_part_y][i4_indx_x] != -1)) { ai4_ref_part_idc[i4_indx_y][i4_indx_x] = ai4_ref_part_idc[i4_temp_part_y][i4_indx_x]; } else if((SVCD_FALSE == ai4_flag_4x4[i4_temp_y][i4_temp_x]) && (ai4_ref_part_idc[i4_temp_part_y][i4_temp_part_x] != -1)) { ai4_ref_part_idc[i4_indx_y][i4_indx_x] = ai4_ref_part_idc[i4_temp_part_y][i4_temp_part_x]; } } /* end of part idc equal to -1 check */ } /* end of sub partition xs loop */ } /* end of sub partition ys loop */ } /* end of partition xp loop */ } /* end of partition yp loop */ /* replace values of "-1" on an 8x8 block basis */ /* loop over (4) 8x8 partitions */ for(i4_yp = 0; i4_yp < 2; i4_yp++) { for(i4_xp = 0; i4_xp < 2; i4_xp++) { WORD32 i4_yp_inv = 1 - i4_yp; WORD32 i4_xp_inv = 1 - i4_xp; WORD32 i4_xo_inv = (2 - i4_xp); WORD32 i4_yo_inv = (2 - i4_yp); i4_indx_x = (i4_xp << 1); i4_indx_y = (i4_yp << 1); /* check if the current part idc is -1*/ if(ai4_ref_part_idc[i4_indx_y][i4_indx_x] == -1) { ai4_flag_8x8[i4_yp][i4_xp] = SVCD_TRUE; /* replace the -1 with appropriate values */ if(SVCD_FALSE == ai4_flag_8x8[i4_yp][i4_xp_inv] && ai4_ref_part_idc[i4_indx_y][i4_xo_inv] != -1) { ai4_ref_part_idc[i4_indx_y][i4_indx_x] = ai4_ref_part_idc[i4_indx_y][i4_xo_inv]; ai4_ref_part_idc[i4_indx_y + 1][i4_indx_x] = ai4_ref_part_idc[i4_indx_y + 1][i4_xo_inv]; ai4_ref_part_idc[i4_indx_y][i4_indx_x + 1] = ai4_ref_part_idc[i4_indx_y][i4_xo_inv]; ai4_ref_part_idc[i4_indx_y + 1][i4_indx_x + 1] = ai4_ref_part_idc[i4_indx_y + 1][i4_xo_inv]; } else if(SVCD_FALSE == ai4_flag_8x8[i4_yp_inv][i4_xp] && ai4_ref_part_idc[i4_yo_inv][i4_indx_x] != -1) { ai4_ref_part_idc[i4_indx_y][i4_indx_x] = ai4_ref_part_idc[i4_yo_inv][i4_indx_x]; ai4_ref_part_idc[i4_indx_y + 1][i4_indx_x] = ai4_ref_part_idc[i4_yo_inv][i4_indx_x]; ai4_ref_part_idc[i4_indx_y][i4_indx_x + 1] = ai4_ref_part_idc[i4_yo_inv][i4_indx_x + 1]; ai4_ref_part_idc[i4_indx_y + 1][i4_indx_x + 1] = ai4_ref_part_idc[i4_yo_inv][i4_indx_x + 1]; } else if(SVCD_FALSE == ai4_flag_8x8[i4_yp_inv][i4_xp_inv] && ai4_ref_part_idc[i4_yo_inv][i4_xo_inv] != -1) { ai4_ref_part_idc[i4_indx_y][i4_indx_x] = ai4_ref_part_idc[i4_yo_inv][i4_xo_inv]; ai4_ref_part_idc[i4_indx_y + 1][i4_indx_x] = ai4_ref_part_idc[i4_yo_inv][i4_xo_inv]; ai4_ref_part_idc[i4_indx_y][i4_indx_x + 1] = ai4_ref_part_idc[i4_yo_inv][i4_xo_inv]; ai4_ref_part_idc[i4_indx_y + 1][i4_indx_x + 1] = ai4_ref_part_idc[i4_yo_inv][i4_xo_inv]; } } /* end of part idc equal to -1 check */ } /* end of partition xp loop */ } /* end of partition yp loop */ } /* end of refinement of part idc for non dyadic case*/ /* store the intra flag in the location provided */ *pi4_intra_flag = i4_intra_mb_flag; return; } /*****************************************************************************/ /* */ /* Function Name : isvcd_check_motion */ /* */ /* Description :this function calculates the MV diff b/w to motion vectors*/ /* and returns 1 if it is under threshold equal to 0 */ /* */ /* Inputs : pv_motion_prm_mb_part_a : pointer to motion struct part A*/ /* pv_motion_prm_mb_part_b : pointer to motion struct part B*/ /* i4_listx : lists to be checked */ /* Globals : none */ /* Processing : it compares reference indcies fo given number of lists */ /* it calculates the mv diff and compares it with 0 */ /* it does the above for given number of lists */ /* Outputs : none */ /* Returns : 1 if matching 0 if not matching */ /* */ /* Issues : none */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 06 09 2021 vijayakumar creation */ /* */ /*****************************************************************************/ WORD32 isvcd_check_motion(void *pv_motion_prm_mb_part_a, void *pv_motion_prm_mb_part_b, WORD32 i4_listx) { mv_pred_t *ps_part_a; mv_pred_t *ps_part_b; WORD32 i4_cntr; WORD32 i4_mv_treshold; WORD32 i4_flag = 0; ps_part_a = (mv_pred_t *) pv_motion_prm_mb_part_a; ps_part_b = (mv_pred_t *) pv_motion_prm_mb_part_b; for(i4_cntr = 0; i4_cntr < i4_listx; i4_cntr++) { /* calculate the absolute diff of both components */ i4_mv_treshold = ABS((ps_part_a->i2_mv[2 * i4_cntr]) - (ps_part_b->i2_mv[2 * i4_cntr])); i4_mv_treshold += ABS((ps_part_a->i2_mv[1 + 2 * i4_cntr]) - (ps_part_b->i2_mv[1 + 2 * i4_cntr])); if((0 == i4_mv_treshold) && (ps_part_a->i1_ref_frame[i4_cntr] == ps_part_b->i1_ref_frame[i4_cntr])) { i4_flag = 1; } else { i4_flag = 0; return (i4_flag); } } /* end of loop over lists */ return (i4_flag); } /*****************************************************************************/ /* */ /* Function Name : isvcd_get_min_positive */ /* */ /* Description : this utility return the minimum positive b/w the given */ /* inputs */ /* */ /* Inputs : i4_input_1: value A , i4_input_2: value B */ /* Globals : none */ /* Processing : if A & B are greater than -1 thenit returns MIN(A + u4_y + < + u4_x + = + u4_x - > - u4_y - < - u4_x - = - u4_x 0 = 0 u4_x - n/a + u4_y + n/a - u4_x */ if((u4_y < u4_x) && (0 <= i4_input_2)) { i4_min_positive = i4_input_2; } else { i4_min_positive = i4_input_1; } return (i4_min_positive); } /*****************************************************************************/ /* */ /* Function Name : isvcd_motion_scale_crop_wdw_change */ /* */ /* Description : This function does the up scaling of motion vectors and */ /* for crop window change cases */ /* Inputs : pv_comp_mode_mv_ctxt : mode motion handle */ /* ps_lyr_mem : pointer current layer memory */ /* ps_mb_params : pointer to mb params structure */ /* ps_ref_mv : pointer to reference MVs */ /* ps_motion_pred : pointer to current 4x4 part mv pred */ /* i4_listx : lists to be processed */ /* i4_part_frm_x: horz location in the picture of the */ /* current sub partition */ /* i4_part_frm_y: vertical location in the picture of the */ /* current sub partition */ /* Globals : */ /* Processing : it takes care of cropping */ /* change flag */ /* Outputs : it stores the interlayer MV pred in the structure */ /* Returns : none */ /* */ /* Issues : none */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 06 09 2021 vijayakumar creation */ /* */ /*****************************************************************************/ void isvcd_motion_scale_crop_wdw_change(mode_motion_ctxt_t *ps_ctxt, mode_motion_lyr_ctxt *ps_lyr_mem, dec_mb_info_t *ps_mb_params, mv_pred_t *ps_ref_mv, mv_pred_t *ps_motion_pred, WORD32 i4_lists, WORD32 i4_part_frm_x, WORD32 i4_part_frm_y, void **ppv_map_ref_idx_to_poc, UWORD8 u1_list_x) { ref_lyr_scaled_offset_t *ps_curr_lyr_offset; ref_lyr_scaled_offset_t *ps_ref_pic_lyr_offset; WORD32 i4_ref_lyr_width, i4_ref_lyr_height; WORD32 i4_curr_lyr_width, i4_curr_lyr_height; WORD32 i4_ref_indx; WORD32 i4_mv_x, i4_mv_y; WORD32 i4_x, i4_y; WORD32 i4_dox, i4_doy, i4_dsw, i4_dsh; WORD32 i4_scale_x, i4_scale_y; WORD8 *pi1_ref_idx_map; UNUSED(ps_ctxt); UNUSED(ps_mb_params); /* get the reference index */ i4_ref_indx = ps_motion_pred->i1_ref_frame[u1_list_x]; i4_mv_x = (WORD32) ps_ref_mv->i2_mv[2 * u1_list_x]; i4_mv_y = (WORD32) ps_ref_mv->i2_mv[1 + 2 * u1_list_x]; /* get the Map buffer pointer */ if(0 == i4_lists) { pi1_ref_idx_map = (WORD8 *) ppv_map_ref_idx_to_poc; } else { pi1_ref_idx_map = (WORD8 *) (ppv_map_ref_idx_to_poc + POC_LIST_L0_TO_L1_DIFF); } /* get the Ref layer width and height */ i4_ref_lyr_width = ps_lyr_mem->i4_ref_width; i4_ref_lyr_height = ps_lyr_mem->i4_ref_height; /* get the Scaled ref layer width and height */ i4_curr_lyr_width = ps_lyr_mem->ps_curr_lyr_res_prms->u2_scaled_ref_width; i4_curr_lyr_height = ps_lyr_mem->ps_curr_lyr_res_prms->u2_scaled_ref_height; /* get the offset stucture pointer */ ps_curr_lyr_offset = &ps_lyr_mem->ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset; /* get the reference offset structure pointer */ ps_ref_pic_lyr_offset = ps_lyr_mem->ps_ref_pic_lyr_offsets + pi1_ref_idx_map[i4_ref_indx]; /* calculate the correction variables */ i4_dox = ps_curr_lyr_offset->i2_left - ps_ref_pic_lyr_offset->i2_left; i4_doy = ps_curr_lyr_offset->i2_top - ps_ref_pic_lyr_offset->i2_top; i4_dsw = ps_curr_lyr_offset->i2_rt - ps_ref_pic_lyr_offset->i2_rt + i4_dox; i4_dsh = ps_curr_lyr_offset->i2_bot - ps_ref_pic_lyr_offset->i2_bot + i4_doy; i4_scale_x = (((i4_curr_lyr_width + i4_dsw) << 16) + (i4_ref_lyr_width >> 1)) / i4_ref_lyr_width; i4_scale_y = (((i4_curr_lyr_height + i4_dsh) << 16) + (i4_ref_lyr_height >> 1)) / i4_ref_lyr_height; /* scale the motion vectors */ i4_mv_x = (i4_mv_x * i4_scale_x + 32768) >> 16; i4_mv_y = (i4_mv_y * i4_scale_y + 32768) >> 16; /* subtract the offsets */ i4_x = i4_part_frm_x - ps_lyr_mem->i4_offset_x; i4_y = i4_part_frm_y - ps_lyr_mem->i4_offset_y; /* get the scale factors */ i4_scale_x = (((4 * i4_dsw) << 16) + (i4_curr_lyr_width >> 1)) / i4_curr_lyr_width; i4_scale_y = (((4 * i4_dsh) << 16) + (i4_curr_lyr_height >> 1)) / i4_curr_lyr_height; /* add the correction */ i4_mv_x += ((i4_x * i4_scale_x + 32768) >> 16) - 4 * i4_dox; i4_mv_y += ((i4_y * i4_scale_y + 32768) >> 16) - 4 * i4_doy; /* store the final motion vectors */ ps_motion_pred->i2_mv[2 * u1_list_x] = i4_mv_x; ps_motion_pred->i2_mv[1 + 2 * u1_list_x] = i4_mv_y; } /*****************************************************************************/ /* */ /* Function Name : isvcd_interlayer_motion_scale */ /* */ /* Description : This function does the up scaling of motion vectors and */ /* and stores the inter layer MV and reference indices */ /* in the mv prediction structure for a 4x4 part */ /* Inputs : pv_comp_mode_mv_ctxt : mode motion handle */ /* pi4_ref_part_idc : pointer current 4x4 part ref_idc */ /* pv_motion_pred : pointer to current 4x4 part mv pred */ /* i4_listx : lists to be processed */ /* i4_part_frm_x: horz location in the picture of the */ /* current sub partition */ /* i4_part_frm_y: vertical location in the picture of the */ /* current sub partition */ /* Globals : */ /* Processing : it stores the default values if the refernce indx of */ /* ref lyr partiton is -1. if not it upscales the motion */ /* vectors based on scale factors. it takes care of cropping*/ /* change flag */ /* Outputs : it stores the interlayer MV pred in the structure */ /* Returns : none */ /* */ /* Issues : none */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 06 09 2021 vijayakumar creation */ /* */ /*****************************************************************************/ WORD32 isvcd_interlyr_motion_scale(void *pv_comp_mode_mv_ctxt, WORD32 *pi4_ref_part_idc, dec_mb_info_t *ps_mb_params, void *pv_motion_pred, WORD32 i4_listx, WORD32 i4_part_frm_x, WORD32 i4_part_frm_y, void **ppv_map_ref_idx_to_poc) { /*! Flow of the module is as follows */ /*! 1. derive the offsets form part idc */ /*! 2. takes the motion vector and scales it based on scale factor */ /*! 3. adds the correction factors for crop window change cases */ /*! 4. store the default motion params for intra projected blocks */ mode_motion_ctxt_t *ps_ctxt; mode_motion_lyr_ctxt *ps_lyr_mem; mv_pred_t *ps_motion_pred; mv_pred_t *ps_ref_mv; WORD32 i4_lists; WORD32 i4_ref_16x16_flag = 0; WORD32 i4_scale_x, i4_scale_y; WORD16 i2_max_mv_x, i2_max_mv_y; ps_ctxt = (mode_motion_ctxt_t *) pv_comp_mode_mv_ctxt; /* get the current layer ctxt */ ps_lyr_mem = &ps_ctxt->as_res_lyr_mem[ps_ctxt->i4_res_id]; /* ----------- Get the reference layer MV structure ---------- */ { mv_pred_t *ps_ref_lyr_motion_prms; WORD32 i4_ref_x, i4_ref_y; WORD32 i4_ref_mb_x, i4_ref_mb_y; WORD32 i4_ref_width; ps_ref_lyr_motion_prms = (mv_pred_t *) ps_lyr_mem->pv_ref_mv_bank_l0; i4_ref_width = ps_lyr_mem->i4_ref_width; i2_max_mv_x = i4_ref_width << 2; i2_max_mv_y = ps_lyr_mem->i4_ref_height << 2; /* extract the reference x and y positions */ i4_ref_x = (*pi4_ref_part_idc) & 0xFFFF; i4_ref_y = (*pi4_ref_part_idc) >> 16; /* get the reference mb x and y */ i4_ref_mb_x = (i4_ref_x >> 4); i4_ref_mb_y = (i4_ref_y >> 4); /* get the reference layer motion struct pointing */ /* to first 4x4 partition of the refernce layer MB */ ps_ref_mv = ps_ref_lyr_motion_prms + (i4_ref_mb_x << 4); ps_ref_mv += (i4_ref_mb_y * i4_ref_width); /* if reference layer mb type is non 16x16 */ if(0 == i4_ref_16x16_flag) { /* increment the pointer to appropaite 4x4 */ ps_ref_mv += ((i4_ref_x >> 2) & 0x03); ps_ref_mv += (((i4_ref_y >> 2) & 0x03) << 2); } } /* motion pred structure */ ps_motion_pred = pv_motion_pred; /* retrive the scale factors */ i4_scale_x = ps_lyr_mem->i4_scale_mv_x; i4_scale_y = ps_lyr_mem->i4_scale_mv_y; /* loop on the lists given as input */ for(i4_lists = 0; i4_lists < i4_listx; i4_lists++) { WORD32 i4_mv_x, i4_mv_y; WORD16 i2_mv_x, i2_mv_y; /* if the refernce index is -1 set the default values */ if(-1 == ps_ref_mv->i1_ref_frame[i4_lists]) { ps_motion_pred->i1_ref_frame[i4_lists] = -1; ps_motion_pred->i2_mv[2 * i4_lists] = 0; ps_motion_pred->i2_mv[1 + 2 * i4_lists] = 0; } else { /* field MB and field pictures modification are present */ /* currently not implemented */ ps_motion_pred->i1_ref_frame[i4_lists] = ps_ref_mv->i1_ref_frame[i4_lists]; i2_mv_x = ps_ref_mv->i2_mv[2 * i4_lists]; i2_mv_y = ps_ref_mv->i2_mv[1 + 2 * i4_lists]; i2_mv_x = CLIP3(-i2_max_mv_x, i2_max_mv_x, i2_mv_x); i2_mv_y = CLIP3(-i2_max_mv_y, i2_max_mv_y, i2_mv_y); /* scale the motion vectors */ i4_mv_x = (i2_mv_x * i4_scale_x + 32768) >> 16; i4_mv_y = (i2_mv_y * i4_scale_y + 32768) >> 16; /* store the final motion vectors */ ps_motion_pred->i2_mv[2 * i4_lists] = i4_mv_x; ps_motion_pred->i2_mv[1 + 2 * i4_lists] = i4_mv_y; /* if cropping change flag is present */ if(SVCD_TRUE == ps_lyr_mem->ps_curr_lyr_res_prms->u1_cropping_change_flag) { /* over write the motion vectors x and y */ isvcd_motion_scale_crop_wdw_change(ps_ctxt, ps_lyr_mem, ps_mb_params, ps_ref_mv, ps_motion_pred, i4_listx, i4_part_frm_x, i4_part_frm_y, ppv_map_ref_idx_to_poc, i4_lists); } } } /* end of lists loop */ return (i4_ref_16x16_flag); } /*****************************************************************************/ /* */ /* Function Name : isvcd_store_motion_map */ /* */ /* Description : this fucntion copies the souce structure contents to */ /* destination entires of part width x part height */ /* */ /* Inputs : pv_motion_pred : pointer to the source structure */ /* ps_curr_lyr_motion_map : pointer to the destination */ /* in the map */ /* i4_src_stride : source stride */ /* i4_dst_stride : destination stride */ /* i4_part_width : width to be copied in terms of sub mbs */ /* i4_part_height : height to be copied */ /* i4_src_update_flag : source update flag */ /* Globals : none */ /* Processing : it copies the src contents to destination */ /* */ /* Outputs : none */ /* Returns : none */ /* */ /* Issues : none */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 06 09 2021 vijayakumar creation */ /* */ /*****************************************************************************/ void isvcd_store_motion_map(void *pv_motion_pred, void *pv_curr_lyr_motion_map, WORD32 i4_src_stride, WORD32 i4_dst_stride, WORD32 i4_part_width, WORD32 i4_part_height, WORD32 i4_src_update_flag) { /*! Flow of the module is as follows */ /*! 1. loops over part_width and part_height */ /*! 2. copies the src params toi destination */ /*! 3. updates the source pointer if src_update flag is set to 1 */ WORD32 i4_i, i4_j; mv_pred_t *ps_mv_pred_src; mv_pred_t *ps_mv_map_dst; ps_mv_pred_src = (mv_pred_t *) pv_motion_pred; ps_mv_map_dst = (mv_pred_t *) pv_curr_lyr_motion_map; /* store the current motion pred to all the motion map structures */ for(i4_i = 0; i4_i < i4_part_height; i4_i++) { for(i4_j = 0; i4_j < i4_part_width; i4_j++) { /* copy form source to destination */ *(ps_mv_map_dst + i4_j) = *(ps_mv_pred_src + (i4_src_update_flag * i4_j)); } /* end of loop over partition width */ ps_mv_map_dst += i4_dst_stride; ps_mv_pred_src += (i4_src_stride * i4_src_update_flag); } /* end of loop over partition height */ return; } /*****************************************************************************/ /* */ /* Function Name : isvcd_check_mv_diff */ /* */ /* Description :this function calculates the MV diff b/w to motion vectors*/ /* and returns 1 if it is under threshold */ /* */ /* Inputs : pv_motion_prm_a : pointer to motion struct part A */ /* pv_motion_prm_b : pointer to motion struct part B */ /* i4_listx : lists to be checked */ /* i4_actual_threshold : threshold with which the mv diff */ /* is to be compared with */ /* Globals : none */ /* Processing : it calculates the mv diff and compares it with threshold */ /* returns 1 if under threshold */ /* Outputs : none */ /* Returns : 1 if under threshold 0 if not under threshold */ /* */ /* Issues : none */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 06 09 2021 vijayakumar creation */ /* */ /*****************************************************************************/ WORD32 isvcd_check_mv_diff(void *pv_motion_prm_a, void *pv_motion_prm_b, WORD32 i4_listx, WORD32 i4_actual_threshold) { mv_pred_t *ps_part_a; mv_pred_t *ps_part_b; WORD32 i4_cntr; WORD32 i4_mv_treshold; WORD32 i4_flag; ps_part_a = (mv_pred_t *) pv_motion_prm_a; ps_part_b = (mv_pred_t *) pv_motion_prm_b; i4_flag = 1; for(i4_cntr = 0; i4_cntr < i4_listx; i4_cntr++) { /* calculate the absolute diff of both components */ i4_mv_treshold = ABS((ps_part_a->i2_mv[2 * i4_cntr]) - (ps_part_b->i2_mv[2 * i4_cntr])); i4_mv_treshold += ABS((ps_part_a->i2_mv[1 + (2 * i4_cntr)]) - (ps_part_b->i2_mv[1 + (2 * i4_cntr)])); if(i4_actual_threshold < i4_mv_treshold) { i4_flag = 0; break; } } /* end of loop over lists */ return (i4_flag); } /*****************************************************************************/ /* */ /* Function Name : isvcd_interlayer_motion_submbmode_pred */ /* */ /* Description : this function does the inter layer motion predcition for */ /* all sub partitions of a macro block */ /* */ /* Inputs : pv_comp_mode_mv_ctxt : motion mode handle */ /* pv_mb_params : pointer to MB params structure */ /* ai4_ref_part_idc : ref partitons idc of all 4x4 blocks */ /* pi4_sub_mb_mode : pointer to store the sub mb modes */ /* i4_mb_addr : current mb address */ /* pi4_intra_flag : location to store the intra status */ /* Globals : none */ /* Processing : it computes the motion vectors and futher modifictaion is*/ /* done for NON -DYAdic cases */ /* Outputs : inter layer predicted motion vectors and ref indices */ /* sub mbmodes of the 4 mb partitions */ /* Returns : none */ /* */ /* Issues : none */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 06 09 2021 vijayakumar creation */ /* */ /*****************************************************************************/ void isvcd_interlyr_motion_submbmode_pred(void *pv_comp_mode_mv_ctxt, void *pv_mb_params, void *pv_svc_mb_params, WORD32 ai4_ref_part_idc[4][4], WORD32 *pi4_sub_mb_mode, void *pv_dec) { /*! Flow of the module is as follows */ /*! 1. if dyadic case it calculates the motion vectors based on dyadic scale factor and loop counts calculated at layer level */ /*! 2. if non dyadic then it calculates the motion vectors based on reference layer part idc */ /*! 3. does the motion vector modification for non dyayic cases, by calculating the minimum positive of reference indices of 4 4x4 blocks and getiing a single reference index for 8x8 */ /*! 4. if direct 8x8 inference is present and current slice is B OR EB, then it stores the corner motion vectors for each 8x8 */ /*! 5. does the sub mb mode prediction and merging of motion vectors which are closely related by setting appropriate thresholds for MVs */ /*! 6. stores the sub mb modes in the array given as input */ mode_motion_ctxt_t *ps_ctxt; mode_motion_lyr_ctxt *ps_lyr_mem; mv_pred_t *ps_motion_pred; dec_mb_info_t *ps_mb_params; dec_svc_mb_info_t *ps_svc_mb_params; WORD32 i4_blk_y, i4_blk_x; WORD32 i4_i; WORD32 i4_listx; WORD32 i4_mv_treshold; WORD32 ai4_temp_ref_indx[NUM_REF_LISTS][NUM_MB_PARTS] = {0}; WORD32 i4_mb_x, i4_mb_y; WORD32 i4_mb_pic_x, i4_mb_pic_y; dec_struct_t *ps_dec; ps_dec = (dec_struct_t *) pv_dec; ps_ctxt = (mode_motion_ctxt_t *) pv_comp_mode_mv_ctxt; /* get the current layer ctxt */ ps_lyr_mem = &ps_ctxt->as_res_lyr_mem[ps_ctxt->i4_res_id]; ps_mb_params = (dec_mb_info_t *) pv_mb_params; ps_svc_mb_params = (dec_svc_mb_info_t *) pv_svc_mb_params; ps_motion_pred = ps_ctxt->ps_motion_pred_struct; i4_listx = ps_ctxt->i4_listx; /* derive the MB_X and MB_Y for the current MB */ i4_mb_x = ps_mb_params->u2_mbx; i4_mb_y = ps_mb_params->u2_mby; /* convert into picture units */ i4_mb_pic_x = i4_mb_x << 4; i4_mb_pic_y = i4_mb_y << 4; /* compute the motion vectors and reference indices of all part */ for(i4_blk_y = 0; i4_blk_y < NUM_SUB_MB_PARTS; i4_blk_y++) { for(i4_blk_x = 0; i4_blk_x < NUM_SUB_MB_PARTS; i4_blk_x++) { isvcd_interlyr_motion_scale(pv_comp_mode_mv_ctxt, &ai4_ref_part_idc[i4_blk_y][i4_blk_x], ps_mb_params, (ps_motion_pred + (4 * i4_blk_y) + i4_blk_x), i4_listx, (i4_mb_pic_x + (i4_blk_x << 2) + 1), (i4_mb_pic_y + (i4_blk_y << 2) + 1), ps_dec->ppv_map_ref_idx_to_poc); } /* end of blk x loop */ } /* end of blk y loop */ /********************************************************/ /* get the final reference index into a temparory array */ /********************************************************/ /* set reference indices */ for(i4_i = 0; i4_i < i4_listx; i4_i++) { ai4_temp_ref_indx[i4_i][0] = ps_motion_pred[0].i1_ref_frame[i4_i]; ai4_temp_ref_indx[i4_i][1] = ps_motion_pred[2].i1_ref_frame[i4_i]; ai4_temp_ref_indx[i4_i][2] = ps_motion_pred[8].i1_ref_frame[i4_i]; ai4_temp_ref_indx[i4_i][3] = ps_motion_pred[10].i1_ref_frame[i4_i]; } /* end of loop over lists */ /* if restricted spatial resolution change is not set */ if(SVCD_FALSE == ps_lyr_mem->ps_curr_lyr_res_prms->u1_rstrct_res_change_flag) { WORD32 i4_xp, i4_yp; WORD32 i4_xs, i4_ys; /* merge reference indices and modify the motion vectors */ for(i4_i = 0; i4_i < i4_listx; i4_i++) { for(i4_yp = 0; i4_yp < 2; i4_yp++) { for(i4_xp = 0; i4_xp < 2; i4_xp++) { /* get the minimum positive of the refernce index */ for(i4_ys = 0; i4_ys < 2; i4_ys++) { for(i4_xs = 0; i4_xs < 2; i4_xs++) { mv_pred_t *ps_temp; ps_temp = ps_motion_pred + (i4_xp << 1) + i4_xs; ps_temp += 4 * ((i4_yp << 1) + i4_ys); /* get the minimum positive */ ai4_temp_ref_indx[i4_i][2 * i4_yp + i4_xp] = isvcd_get_min_positive(ai4_temp_ref_indx[i4_i][2 * i4_yp + i4_xp], ps_temp->i1_ref_frame[i4_i]); } } /* update motion vectors */ for(i4_ys = 0; i4_ys < 2; i4_ys++) { for(i4_xs = 0; i4_xs < 2; i4_xs++) { mv_pred_t *ps_temp; ps_temp = ps_motion_pred + (i4_xp << 1) + i4_xs; ps_temp += 4 * ((i4_yp << 1) + i4_ys); /* check if the current part reference index is */ /* not choosen as the final reference index */ /* if not copy the neighbours MV */ if(ai4_temp_ref_indx[i4_i][2 * i4_yp + i4_xp] != ps_temp->i1_ref_frame[i4_i]) { mv_pred_t *ps_temp_1; WORD32 i4_updated_flag = SVCD_FALSE; ps_temp_1 = ps_motion_pred + (i4_xp << 1) + (1 - i4_xs); ps_temp_1 += 4 * ((i4_yp << 1) + i4_ys); /* store the appropriate neighbours */ if(ai4_temp_ref_indx[i4_i][2 * i4_yp + i4_xp] == ps_temp_1->i1_ref_frame[i4_i]) { ps_temp->i2_mv[2 * i4_i] = ps_temp_1->i2_mv[2 * i4_i]; ps_temp->i2_mv[1 + (2 * i4_i)] = ps_temp_1->i2_mv[1 + (2 * i4_i)]; i4_updated_flag = SVCD_TRUE; } if(SVCD_FALSE == i4_updated_flag) { ps_temp_1 = ps_motion_pred + (i4_xp << 1) + i4_xs; ps_temp_1 += 4 * ((i4_yp << 1) + 1 - i4_ys); if(ai4_temp_ref_indx[i4_i][2 * i4_yp + i4_xp] == ps_temp_1->i1_ref_frame[i4_i]) { ps_temp->i2_mv[2 * i4_i] = ps_temp_1->i2_mv[2 * i4_i]; ps_temp->i2_mv[1 + (2 * i4_i)] = ps_temp_1->i2_mv[1 + (2 * i4_i)]; i4_updated_flag = SVCD_TRUE; } } if(SVCD_FALSE == i4_updated_flag) { ps_temp_1 = ps_motion_pred + (i4_xp << 1) + (1 - i4_xs); ps_temp_1 += 4 * ((i4_yp << 1) + 1 - i4_ys); ps_temp->i2_mv[2 * i4_i] = ps_temp_1->i2_mv[2 * i4_i]; ps_temp->i2_mv[1 + (2 * i4_i)] = ps_temp_1->i2_mv[1 + (2 * i4_i)]; i4_updated_flag = SVCD_TRUE; } } /* end of replacement of mv based on ref indx */ } /* end of loop over sub partition xs */ } /* end of loop over sub partition ys */ } /* end of loop over partition xp */ } /* end of loop over partition yp */ } /* end of loop over lists */ } /************************************************************************/ /* if restircted saptial resolution change flag is 0 */ /* modify the reference indixes and motion vectors */ /************************************************************************/ if((SVCD_FALSE == ps_lyr_mem->ps_curr_lyr_res_prms->u1_rstrct_res_change_flag) && (2 == i4_listx) && (SVCD_TRUE == ps_ctxt->u1_direct_8x8_inference_flag)) { /* only applicable for EB Slice */ /* store the corner 4x4 motion vectors to the whole block */ /* 2 lists and 4 partitions */ mot_vec_t s_temp_mv[2][4]; WORD32 i4_xp, i4_yp; memset(&s_temp_mv[0][0], 0, sizeof(s_temp_mv)); for(i4_i = 0; i4_i < i4_listx; i4_i++) { s_temp_mv[i4_i][0].i2_mv_x = ps_motion_pred[0].i2_mv[2 * i4_i]; s_temp_mv[i4_i][0].i2_mv_y = ps_motion_pred[0].i2_mv[1 + (2 * i4_i)]; s_temp_mv[i4_i][1].i2_mv_x = ps_motion_pred[3].i2_mv[2 * i4_i]; s_temp_mv[i4_i][1].i2_mv_y = ps_motion_pred[3].i2_mv[1 + (2 * i4_i)]; s_temp_mv[i4_i][2].i2_mv_x = ps_motion_pred[12].i2_mv[2 * i4_i]; s_temp_mv[i4_i][2].i2_mv_y = ps_motion_pred[12].i2_mv[1 + (2 * i4_i)]; s_temp_mv[i4_i][3].i2_mv_x = ps_motion_pred[15].i2_mv[2 * i4_i]; s_temp_mv[i4_i][3].i2_mv_y = ps_motion_pred[15].i2_mv[1 + (2 * i4_i)]; } /* end of loop over lists */ /* replace the motion vectors */ for(i4_i = 0; i4_i < i4_listx; i4_i++) { for(i4_yp = 0; i4_yp < 4; i4_yp++) { for(i4_xp = 0; i4_xp < 4; i4_xp++) { mv_pred_t *ps_temp; ps_temp = ps_motion_pred + i4_xp; ps_temp += 4 * i4_yp; ps_temp->i2_mv[2 * i4_i] = s_temp_mv[i4_i][2 * (i4_yp >> 1) + (i4_xp >> 1)].i2_mv_x; ps_temp->i2_mv[1 + (2 * i4_i)] = s_temp_mv[i4_i][2 * (i4_yp >> 1) + (i4_xp >> 1)].i2_mv_y; } /* end of loop over sub partitions xp */ } /* end of loop over sub partitions yp */ } /* end of loop over lists */ } /* store the final reference index for all sub partitions */ /* approporiate reference index is stored for each 4x4 belonging to 8x8 */ { WORD32 i4_xp, i4_yp; for(i4_i = 0; i4_i < i4_listx; i4_i++) { for(i4_yp = 0; i4_yp < 4; i4_yp++) { for(i4_xp = 0; i4_xp < 4; i4_xp++) { mv_pred_t *ps_temp; ps_temp = ps_motion_pred + i4_xp; ps_temp += 4 * i4_yp; ps_temp->i1_ref_frame[i4_i] = ai4_temp_ref_indx[i4_i][2 * (i4_yp >> 1) + (i4_xp >> 1)]; } /* end of loop over partition xp */ } /* end of loop over partition yp */ } /* end of loop over lists */ } /********************************************************************/ /* modify the motion vectors for non dyadic cases, set the mv */ /* threshold appropraitely to derive the sub MB type */ /********************************************************************/ if(SVCD_FALSE == ps_lyr_mem->ps_curr_lyr_res_prms->u1_rstrct_res_change_flag) { /* non dyadic cases set the mv treshold to 1 */ i4_mv_treshold = 1; } else { /* dyadic cases set the mv treshold to 0 */ i4_mv_treshold = 0; } /* modify the motion vectors and get sub mb mode if base mode flag is 1 */ if((SVCD_FALSE == ps_lyr_mem->ps_curr_lyr_res_prms->u1_rstrct_res_change_flag) || (1 == ps_svc_mb_params->u1_base_mode_flag)) { WORD32 i4_xp, i4_yp; for(i4_yp = 0; i4_yp < 2; i4_yp++) { for(i4_xp = 0; i4_xp < 2; i4_xp++) { mv_pred_t *ps_temp; WORD32 i4_part_size = 0; WORD32 i4_horz1_match, i4_vert1_match; WORD32 i4_horz2_match, i4_vert2_match; WORD32 i4_diag_match; WORD32 i4_8x8_match, i4_horz_match, i4_vert_match; WORD32 i4_mv_x, i4_mv_y; ps_temp = ps_motion_pred + (i4_xp << 1); ps_temp += 4 * ((i4_yp << 1)); /* default init */ i4_8x8_match = i4_horz_match = i4_vert_match = SVCD_TRUE; /* check if the mv diff in horz direction is under threshold*/ i4_horz1_match = isvcd_check_mv_diff(ps_temp, (ps_temp + 1), i4_listx, i4_mv_treshold); i4_horz2_match = isvcd_check_mv_diff((ps_temp + 4), (ps_temp + 4 + 1), i4_listx, i4_mv_treshold); /* check if the mv diff in horz direction is under threshold*/ i4_vert1_match = isvcd_check_mv_diff(ps_temp, (ps_temp + 4), i4_listx, i4_mv_treshold); i4_vert2_match = isvcd_check_mv_diff((ps_temp + 1), (ps_temp + 4 + 1), i4_listx, i4_mv_treshold); /* check if in diagonal direction is under threshold*/ i4_diag_match = isvcd_check_mv_diff(ps_temp, (ps_temp + 4 + 1), i4_listx, i4_mv_treshold); /* calculate the excat matching points*/ i4_8x8_match = i4_8x8_match && i4_horz1_match && i4_vert1_match && i4_diag_match; i4_horz_match = i4_horz_match && i4_horz1_match && i4_horz2_match; i4_vert_match = i4_vert_match && i4_vert1_match && i4_vert2_match; /* modify the motion vectors appropriately */ for(i4_i = 0; i4_i < i4_listx; i4_i++) { /* 8x8 mode all the 4 blocks are under threshold */ if(SVCD_TRUE == i4_8x8_match) { /* calculate the avarage */ i4_mv_x = ((ps_temp[0].i2_mv[2 * i4_i]) + (ps_temp[1].i2_mv[2 * i4_i]) + (ps_temp[4].i2_mv[2 * i4_i]) + (ps_temp[5].i2_mv[2 * i4_i] + 2)) >> 2; i4_mv_y = ((ps_temp[0].i2_mv[1 + (2 * i4_i)]) + (ps_temp[1].i2_mv[1 + (2 * i4_i)]) + (ps_temp[4].i2_mv[1 + (2 * i4_i)]) + (ps_temp[5].i2_mv[1 + (2 * i4_i)] + 2)) >> 2; /* store the modified motion vectors */ ps_temp[0].i2_mv[2 * i4_i] = (WORD16) i4_mv_x; ps_temp[1].i2_mv[2 * i4_i] = (WORD16) i4_mv_x; ps_temp[4].i2_mv[2 * i4_i] = (WORD16) i4_mv_x; ps_temp[5].i2_mv[2 * i4_i] = (WORD16) i4_mv_x; ps_temp[0].i2_mv[1 + (2 * i4_i)] = (WORD16) i4_mv_y; ps_temp[1].i2_mv[1 + (2 * i4_i)] = (WORD16) i4_mv_y; ps_temp[4].i2_mv[1 + (2 * i4_i)] = (WORD16) i4_mv_y; ps_temp[5].i2_mv[1 + (2 * i4_i)] = (WORD16) i4_mv_y; /* store the sub mb partition size */ i4_part_size = SUBMB_8x8; } /* 8x4 mode */ else if(SVCD_TRUE == i4_horz_match) { /* horizontal directional merging */ /* calculate the average of first two and store back*/ i4_mv_x = ((ps_temp[0].i2_mv[2 * i4_i]) + (ps_temp[1].i2_mv[2 * i4_i] + 1)) >> 1; i4_mv_y = ((ps_temp[0].i2_mv[1 + (2 * i4_i)]) + (ps_temp[1].i2_mv[1 + (2 * i4_i)] + 1)) >> 1; ps_temp[0].i2_mv[2 * i4_i] = (WORD16) i4_mv_x; ps_temp[1].i2_mv[2 * i4_i] = (WORD16) i4_mv_x; ps_temp[0].i2_mv[1 + (2 * i4_i)] = (WORD16) i4_mv_y; ps_temp[1].i2_mv[1 + (2 * i4_i)] = (WORD16) i4_mv_y; /* calculate the average of next two and store back*/ i4_mv_x = ((ps_temp[4].i2_mv[2 * i4_i]) + (ps_temp[5].i2_mv[2 * i4_i] + 1)) >> 1; i4_mv_y = ((ps_temp[4].i2_mv[1 + (2 * i4_i)]) + (ps_temp[5].i2_mv[1 + (2 * i4_i)] + 1)) >> 1; ps_temp[4].i2_mv[2 * i4_i] = (WORD16) i4_mv_x; ps_temp[5].i2_mv[2 * i4_i] = (WORD16) i4_mv_x; ps_temp[4].i2_mv[1 + (2 * i4_i)] = (WORD16) i4_mv_y; ps_temp[5].i2_mv[1 + (2 * i4_i)] = (WORD16) i4_mv_y; /* store the sub mb partition size */ i4_part_size = SUBMB_8x4; } /* 4x8 mode all the 4 blocks are under threshold */ else if(SVCD_TRUE == i4_vert_match) { /* vertical directional merging */ i4_mv_x = ((ps_temp[0].i2_mv[2 * i4_i]) + (ps_temp[4].i2_mv[2 * i4_i] + 1)) >> 1; i4_mv_y = ((ps_temp[0].i2_mv[1 + (2 * i4_i)]) + (ps_temp[4].i2_mv[1 + (2 * i4_i)] + 1)) >> 1; ps_temp[0].i2_mv[2 * i4_i] = (WORD16) i4_mv_x; ps_temp[4].i2_mv[2 * i4_i] = (WORD16) i4_mv_x; ps_temp[0].i2_mv[1 + (2 * i4_i)] = (WORD16) i4_mv_y; ps_temp[4].i2_mv[1 + (2 * i4_i)] = (WORD16) i4_mv_y; /* calculate the average of next two and store back*/ i4_mv_x = ((ps_temp[1].i2_mv[2 * i4_i]) + (ps_temp[5].i2_mv[2 * i4_i] + 1)) >> 1; i4_mv_y = ((ps_temp[1].i2_mv[1 + (2 * i4_i)]) + (ps_temp[5].i2_mv[1 + (2 * i4_i)] + 1)) >> 1; ps_temp[1].i2_mv[2 * i4_i] = (WORD16) i4_mv_x; ps_temp[5].i2_mv[2 * i4_i] = (WORD16) i4_mv_x; ps_temp[1].i2_mv[1 + (2 * i4_i)] = (WORD16) i4_mv_y; ps_temp[5].i2_mv[1 + (2 * i4_i)] = (WORD16) i4_mv_y; /* store the sub mb partition size */ i4_part_size = SUBMB_4x8; } else { /* store the sub mb partition size */ i4_part_size = SUBMB_4x4; } } /* end of loop over lists */ /* store the sub MB type B slice */ if(2 == i4_listx) { WORD32 i4_part_mode_a; WORD32 i4_indx; i4_part_mode_a = 0; /* check the 0th partiton reference indices */ if(0 <= ps_temp[0].i1_ref_frame[0]) { i4_part_mode_a += 1; } if(0 <= ps_temp[0].i1_ref_frame[1]) { i4_part_mode_a += 2; } i4_indx = 3 * i4_part_size + (i4_part_mode_a - 1); pi4_sub_mb_mode[2 * i4_yp + i4_xp] = g_au1_eb_submb_type[i4_indx]; } /* P slice */ else { pi4_sub_mb_mode[2 * i4_yp + i4_xp] = g_au1_ep_submb_type[i4_part_size]; } } /* end of loop over partition xp */ } /* end of loop over partition yp */ } return; } /*****************************************************************************/ /* */ /* Function Name : isvcd_interlyr_mbmode_pred_bmb */ /* */ /* Description : this module does the mode predcition for base mode B_MB */ /* */ /* */ /* Inputs : pv_comp_mode_mv_ctxt : motion mode hanldle */ /* Globals : none */ /* Processing : it checks the sub MB type derived motion prediction. if */ /* all partitions are 8x8 then it goes further matching */ /* finally it stores the MB type using a look up table */ /* Outputs : none */ /* Returns : none */ /* */ /* Issues : none */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 06 09 2021 vijayakumar creation */ /* */ /*****************************************************************************/ void isvcd_interlyr_mbmode_pred_bmb(mode_motion_ctxt_t *ps_ctxt, mv_pred_t *ps_motion_pred, WORD32 i4_cur_mot_stride, WORD32 i4_part_size, WORD32 *pi4_sub_mb_mode, void *pv_mb_params, void *pv_part, UWORD8 *pu1_col_info) { WORD32 i4_part_mode_a, i4_part_mode_b; WORD32 i4_idx; dec_mb_info_t *ps_mb_params = (dec_mb_info_t *) pv_mb_params; parse_part_params_t *ps_part = (parse_part_params_t *) pv_part; UNUSED(ps_ctxt); i4_part_mode_a = 0; /* check the 0th partiton reference indices */ if(PRED_8x8 != i4_part_size) { if(0 <= ps_motion_pred[0].i1_ref_frame[0]) { i4_part_mode_a += 1; } if(0 <= ps_motion_pred[0].i1_ref_frame[1]) { i4_part_mode_a += 2; } } /* check the 15th partiton reference indices */ /* this done since all the reference indices will be replicated */ i4_part_mode_b = 0; if((PRED_16x8 == i4_part_size) || (PRED_8x16 == i4_part_size)) { ps_motion_pred += (3 * i4_cur_mot_stride) + 3; if(0 <= ps_motion_pred[0].i1_ref_frame[0]) { i4_part_mode_b += 1; } if(0 <= ps_motion_pred[0].i1_ref_frame[1]) { i4_part_mode_b += 2; } } /* update the pred modes for B cases */ /* If partition size is not equal to 8x8 */ /* then update the prediciton mode of */ /* partitions */ if(PRED_8x8 != i4_part_size) { UWORD8 u1_pred_mode_part0; UWORD8 u1_pred_mode_part1; i4_idx = 3 * i4_part_size; i4_idx += 3 * (i4_part_mode_a - 1); i4_part_mode_b = (i4_part_mode_b > 0) ? i4_part_mode_b : 1; i4_idx += (i4_part_mode_b - 1); i4_idx = (i4_idx < 0) ? 0 : i4_idx; /* Get the mb type */ /* From mb type - get prediciton modes */ /* of parttions */ /* Update the prediciton mode parma of */ /* mb param structure */ ps_mb_params->u1_mb_type = g_au1_eb_mb_type[i4_idx + (6 * i4_part_size)]; u1_pred_mode_part0 = g_au1_mb_pred_mode[0][5 + ps_mb_params->u1_mb_type]; u1_pred_mode_part1 = g_au1_mb_pred_mode[1][5 + ps_mb_params->u1_mb_type]; ps_part[0].u1_pred_mode = u1_pred_mode_part0; ps_part[1].u1_pred_mode = u1_pred_mode_part1; } else { WORD32 i4_i, i4_ctr, i4_num_submb_part; UWORD8 u1_sub_mb_type, u1_sub_mb_mc_mode; UWORD8 u1_pred_mode; ps_mb_params->u1_mb_type = B_8x8; for(i4_i = 0; i4_i < NUM_MB_PARTS; i4_i++) { u1_sub_mb_type = (UWORD8) pi4_sub_mb_mode[i4_i]; u1_sub_mb_mc_mode = gau1_ih264d_submb_mc_mode[4 + u1_sub_mb_type]; i4_num_submb_part = g_au1_num_sub_mb_part[u1_sub_mb_mc_mode]; *pu1_col_info |= (u1_sub_mb_mc_mode << 4); pu1_col_info++; u1_pred_mode = g_au1_sub_mb_pred_mode[4 + u1_sub_mb_type]; for(i4_ctr = 0; i4_ctr < i4_num_submb_part; i4_ctr++) { ps_part->u1_pred_mode = u1_pred_mode; ps_part++; } } } return; } /*****************************************************************************/ /* */ /* Function Name : isvcd_populate_ref_idx */ /* */ /* Description : this module populates the reference idx based on the */ /* motion prediction flags */ /* */ /* Inputs : */ /* Globals : none */ /* Processing : */ /* Outputs : none */ /* Returns : none */ /* */ /* Issues : none */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 06 09 2021 vijayakumar creation */ /* */ /*****************************************************************************/ void isvcd_populate_ref_idx(dec_mb_info_t *ps_mb_params, dec_svc_mb_info_t *ps_svc_mb_params, mv_pred_t *ps_motion_pred, parse_pmbarams_t *ps_mb_part_info, WORD32 i4_listx) { UWORD8 u1_mot_pred_flag; WORD32 i4_lx; for(i4_lx = 0; i4_lx < i4_listx; i4_lx++) { u1_mot_pred_flag = ps_svc_mb_params->au1_motion_pred_flag[i4_lx]; if((PRED_16x16 == ps_mb_params->u1_mb_mc_mode) && (u1_mot_pred_flag & 0x1)) { ps_mb_part_info->i1_ref_idx[i4_lx][0] = ps_motion_pred[0].i1_ref_frame[i4_lx]; } else if((PRED_8x16 == ps_mb_params->u1_mb_mc_mode)) { if(u1_mot_pred_flag & 0x01) { ps_mb_part_info->i1_ref_idx[i4_lx][0] = ps_motion_pred[0].i1_ref_frame[i4_lx]; } if(u1_mot_pred_flag & 0x02) { ps_mb_part_info->i1_ref_idx[i4_lx][1] = ps_motion_pred[2].i1_ref_frame[i4_lx]; } } else if((PRED_16x8 == ps_mb_params->u1_mb_mc_mode)) { if(u1_mot_pred_flag & 0x01) { ps_mb_part_info->i1_ref_idx[i4_lx][0] = ps_motion_pred[0].i1_ref_frame[i4_lx]; } if(u1_mot_pred_flag & 0x02) { ps_mb_part_info->i1_ref_idx[i4_lx][1] = ps_motion_pred[8].i1_ref_frame[i4_lx]; } } else if((PRED_8x8 == ps_mb_params->u1_mb_mc_mode)) { if(u1_mot_pred_flag & 0x01) { ps_mb_part_info->i1_ref_idx[i4_lx][0] = ps_motion_pred[0].i1_ref_frame[i4_lx]; } if(u1_mot_pred_flag & 0x02) { ps_mb_part_info->i1_ref_idx[i4_lx][1] = ps_motion_pred[2].i1_ref_frame[i4_lx]; } if(u1_mot_pred_flag & 0x04) { ps_mb_part_info->i1_ref_idx[i4_lx][2] = ps_motion_pred[8].i1_ref_frame[i4_lx]; } if(u1_mot_pred_flag & 0x08) { ps_mb_part_info->i1_ref_idx[i4_lx][3] = ps_motion_pred[10].i1_ref_frame[i4_lx]; } } } } /*****************************************************************************/ /* */ /* Function Name : svcd_interlayer_mbmode_pred */ /* */ /* Description : this module does the mode predcition for base mode MB */ /* */ /* */ /* Inputs : pv_comp_mode_mv_ctxt : motion mode hanldle */ /* pv_mb_params : pointer to MB params structure */ /* pi4_sub_mb_mode: pointer to sub mbmodes predicted */ /* Globals : none */ /* Processing : it checks the sub MB type derived motion prediction. if */ /* all partitions are 8x8 then it goes further matching */ /* finally it stores the MB type using a look up table */ /* Outputs : none */ /* Returns : none */ /* */ /* Issues : none */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 06 09 2021 vijayakumar creation */ /* */ /*****************************************************************************/ void isvcd_interlyr_mbmode_pred(void *pv_comp_mode_mv_ctxt, void *pv_mb_params, WORD32 *pi4_sub_mb_mode, WORD32 *pi4_mb_mode, void *pv_dec, void *pv_mb_part_info, void *pv_part) { /*! Flow of the module is as follows */ /*! 1. it checks if all the sub mb modes are 8x8 modes */ /*! 2. it matches the motion vectors at 8x8 level and computes the partiton size. store the same in the part type of mb params */ /*! 3. stores the pred modes based on slcie type and reference indices */ /*! 4. stores the sub mb type in the mb params if teh part size is 8x8 */ mode_motion_ctxt_t *ps_ctxt; mv_pred_t *ps_motion_pred; dec_mb_info_t *ps_mb_params; WORD32 i4_listx; WORD32 i4_part_size; WORD32 i4_mb_mode_flag; WORD32 i4_i; WORD32 i4_blk_mode; parse_part_params_t *ps_part = (parse_part_params_t *) pv_part; parse_pmbarams_t *ps_mb_part_info = (parse_pmbarams_t *) pv_mb_part_info; UWORD8 *pu1_col_info = ps_mb_part_info->u1_col_info; UNUSED(pv_dec); ps_ctxt = (mode_motion_ctxt_t *) pv_comp_mode_mv_ctxt; ps_motion_pred = ps_ctxt->ps_motion_pred_struct; ps_mb_params = (dec_mb_info_t *) pv_mb_params; /*********** store the MB mode as inter *************************/ *pi4_mb_mode = SVC_INTER_MB; /***********************************************************************/ /* derivation of part type */ /***********************************************************************/ i4_listx = ps_ctxt->i4_listx; /* set the mb mode derivation flag to false */ i4_mb_mode_flag = SVCD_FALSE; /* for B and P slice different blk mod treshold */ if(2 == i4_listx) { i4_blk_mode = B_BI_8x8; } else { i4_blk_mode = P_L0_8x8; } /* set the mode derivation flag to true base on conditions */ if((i4_blk_mode >= pi4_sub_mb_mode[0]) && (i4_blk_mode >= pi4_sub_mb_mode[1]) && (i4_blk_mode >= pi4_sub_mb_mode[2]) && (i4_blk_mode >= pi4_sub_mb_mode[3])) { i4_mb_mode_flag = SVCD_TRUE; } /* store the default 8x8 mode */ ps_mb_part_info->u1_num_part = 4; i4_part_size = PRED_8x8; /* further check is present if all are 8x8 mode */ if(SVCD_TRUE == i4_mb_mode_flag) { WORD32 i4_horz_match, i4_vert_match; /* check if the motion in horz direction are same*/ i4_horz_match = isvcd_check_motion(ps_motion_pred, (ps_motion_pred + 2), i4_listx); i4_horz_match += isvcd_check_motion((ps_motion_pred + 8), (ps_motion_pred + 10), i4_listx); /* check if the motion in vertical direction is same */ i4_vert_match = isvcd_check_motion(ps_motion_pred, (ps_motion_pred + 8), i4_listx); i4_vert_match += isvcd_check_motion((ps_motion_pred + 2), (ps_motion_pred + 10), i4_listx); /* decide the partition size based on the results of matching */ if((2 == i4_horz_match) && (2 == i4_vert_match)) { ps_mb_params->u1_mb_type = P_L0_16x16; i4_part_size = PRED_16x16; ps_mb_part_info->u1_num_part = 1; *pu1_col_info++ = (PRED_16x16 << 6); ps_mb_part_info->i1_ref_idx[0][0] = ps_motion_pred->i1_ref_frame[0]; if(2 == i4_listx) ps_mb_part_info->i1_ref_idx[1][0] = ps_motion_pred->i1_ref_frame[1]; ps_part->u1_partwidth = 4; // interms of 4x4 ps_part->u1_partheight = 4; ps_part->u1_pred_mode = PRED_L0; ps_part->u1_is_direct = 0; ps_part->u1_sub_mb_num = 0; } else if(2 == i4_horz_match) { i4_part_size = PRED_16x8; ps_mb_params->u1_mb_type = P_L0_L0_16x8; ps_mb_part_info->u1_num_part = 2; *pu1_col_info++ = (PRED_16x8 << 6); *pu1_col_info++ = (PRED_16x8 << 6); ps_mb_part_info->i1_ref_idx[0][0] = ps_motion_pred->i1_ref_frame[0]; ps_mb_part_info->i1_ref_idx[0][1] = ps_motion_pred[8].i1_ref_frame[0]; if(2 == i4_listx) { ps_mb_part_info->i1_ref_idx[1][0] = ps_motion_pred->i1_ref_frame[1]; ps_mb_part_info->i1_ref_idx[1][1] = ps_motion_pred[8].i1_ref_frame[1]; } ps_part->u1_partwidth = 4; // interms of 4x4 ps_part->u1_partheight = 2; ps_part->u1_pred_mode = PRED_L0; ps_part->u1_is_direct = 0; ps_part->u1_sub_mb_num = 0; ps_part++; ps_part->u1_partwidth = 4; ps_part->u1_partheight = 2; ps_part->u1_pred_mode = PRED_L0; ps_part->u1_is_direct = 0; ps_part->u1_sub_mb_num = 8; } else if(2 == i4_vert_match) { ps_mb_params->u1_mb_type = P_L0_L0_8x16; i4_part_size = PRED_8x16; ps_mb_part_info->u1_num_part = 2; *pu1_col_info++ = (PRED_8x16 << 6); *pu1_col_info++ = (PRED_8x16 << 6); ps_mb_part_info->i1_ref_idx[0][0] = ps_motion_pred->i1_ref_frame[0]; ps_mb_part_info->i1_ref_idx[0][1] = ps_motion_pred[2].i1_ref_frame[0]; if(2 == i4_listx) { ps_mb_part_info->i1_ref_idx[1][0] = ps_motion_pred->i1_ref_frame[1]; ps_mb_part_info->i1_ref_idx[1][1] = ps_motion_pred[2].i1_ref_frame[1]; } ps_part->u1_partwidth = 2; // interms of 4x4 ps_part->u1_partheight = 4; ps_part->u1_pred_mode = PRED_L0; ps_part->u1_is_direct = 0; ps_part->u1_sub_mb_num = 0; ps_part++; ps_part->u1_partwidth = 2; ps_part->u1_partheight = 4; ps_part->u1_pred_mode = PRED_L0; ps_part->u1_is_direct = 0; ps_part->u1_sub_mb_num = 2; } } /* store the part size to the mb params */ ps_mb_params->u1_mb_mc_mode = i4_part_size; /* in case of slice derive the partition modes */ { /* store the sub MB modes if 8x8 mode is choosen */ if(PRED_8x8 == i4_part_size) { UWORD8 u1_sub_mb_type, u1_sub_mb_mc_mode = 0; /* for P_MB sub part type is same as sub mb type */ ps_mb_params->u1_mb_type = P_8x8; ps_mb_part_info->i1_ref_idx[0][0] = ps_motion_pred[0].i1_ref_frame[0]; ps_mb_part_info->i1_ref_idx[0][1] = ps_motion_pred[2].i1_ref_frame[0]; ps_mb_part_info->i1_ref_idx[0][2] = ps_motion_pred[8].i1_ref_frame[0]; ps_mb_part_info->i1_ref_idx[0][3] = ps_motion_pred[10].i1_ref_frame[0]; if(2 == i4_listx) { ps_mb_part_info->i1_ref_idx[1][0] = ps_motion_pred[0].i1_ref_frame[1]; ps_mb_part_info->i1_ref_idx[1][1] = ps_motion_pred[2].i1_ref_frame[1]; ps_mb_part_info->i1_ref_idx[1][2] = ps_motion_pred[8].i1_ref_frame[1]; ps_mb_part_info->i1_ref_idx[1][3] = ps_motion_pred[10].i1_ref_frame[1]; } ps_mb_part_info->u1_num_part = 0; for(i4_i = 0; i4_i < NUM_MB_PARTS; i4_i++) { WORD32 i4_num_submb_part, i4_part_width, i4_part_height, i4_ctr; u1_sub_mb_type = (UWORD8) pi4_sub_mb_mode[i4_i]; if(1 == i4_listx) { u1_sub_mb_mc_mode = gau1_ih264d_submb_mc_mode[u1_sub_mb_type]; } else if(2 == i4_listx) { u1_sub_mb_mc_mode = gau1_ih264d_submb_mc_mode[4 + u1_sub_mb_type]; } i4_num_submb_part = g_au1_num_sub_mb_part[u1_sub_mb_mc_mode]; ps_mb_part_info->u1_num_part += i4_num_submb_part; i4_part_width = g_au1_sub_mb_part_wd[u1_sub_mb_mc_mode]; i4_part_height = g_au1_sub_mb_part_ht[u1_sub_mb_mc_mode]; *pu1_col_info++ = (PRED_8x8 << 6) | (u1_sub_mb_mc_mode << 4); for(i4_ctr = 0; i4_ctr < i4_num_submb_part; i4_ctr++) { ps_part->u1_partwidth = i4_part_width; // interms of 4x4 ps_part->u1_partheight = i4_part_height; ps_part->u1_pred_mode = PRED_L0; ps_part->u1_is_direct = 0; ps_part->u1_sub_mb_num = (i4_i & 0x01) * 2 + (i4_i >> 1) * 8; if(i4_num_submb_part == 2) { ps_part->u1_sub_mb_num += i4_ctr ? (((i4_part_width - 1) << 2) + (i4_part_height - 1)) : 0; } else if(i4_num_submb_part == 4) { ps_part->u1_sub_mb_num += ((i4_ctr >> 1) << 2) + (i4_ctr & 0x01); } ps_part++; } } } if(2 == i4_listx) { ps_part = (parse_part_params_t *) pv_part; pu1_col_info = ps_mb_part_info->u1_col_info; /* B_MBs */ isvcd_interlyr_mbmode_pred_bmb(ps_ctxt, ps_motion_pred, 4, i4_part_size, pi4_sub_mb_mode, ps_mb_params, ps_part, pu1_col_info); } } return; } /*****************************************************************************/ /* */ /* Function Name : isvcd_compute_interlayer_motion_mode */ /* */ /* Description : this function does the inter layer motion and mode */ /* prediction. of the current MB */ /* */ /* Inputs : pv_comp_mode_mv_ctxt : mode motion handle */ /* pv_ref_layer_motion_mem_elements : pointer to memory */ /* elements of reference layer motion params */ /* pv_mb_params : pointer to mb params structure */ /* Globals : none */ /* Processing : it calls the module for cal ref part idc and intra flag */ /* if not intra it calls the motion prediction module */ /* if base mdoe flag then it call teh mode prediction module*/ /* Outputs : inter layer predicted parameters */ /* Returns : none */ /* */ /* Issues : none */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 06 09 2021 vijayakumar creation */ /* */ /*****************************************************************************/ WORD32 isvcd_compute_interlyr_motion_mode(void *pv_comp_mode_mv_ctxt, void *pv_mb_params, void *pv_svc_mb_params, void *pv_dec, void *pv_mb_part_info, void *pv_part) { /*! Flow of the module is as follows */ /*! 1. if dyaydic case then it sets the sub mb mode to 8x8 */ /*! 2. else it call the ref part idc comute fucntion */ /*! 3. it calls the motion vectors and submb mode derive function. if the current mb is not inffered as INTRA */ /*! 4. it calls the mode predcition module if base mode flag is 1 */ mode_motion_ctxt_t *ps_ctxt; WORD32 i4_intra_flag; WORD32 ai4_sub_mb_mode[NUM_MB_PARTS] = {0}; dec_mb_info_t *ps_mb_params; dec_svc_mb_info_t *ps_svc_mb_params; dec_struct_t *ps_dec = (dec_struct_t *) pv_dec; WORD32 i4_mb_mode = -1; parse_pmbarams_t *ps_mb_part_info = (parse_pmbarams_t *) pv_mb_part_info; parse_part_params_t *ps_part = (parse_part_params_t *) pv_part; ps_ctxt = (mode_motion_ctxt_t *) pv_comp_mode_mv_ctxt; ps_mb_params = (dec_mb_info_t *) pv_mb_params; ps_svc_mb_params = (dec_svc_mb_info_t *) pv_svc_mb_params; i4_intra_flag = SVCD_FALSE; isvcd_ref_lyr_part_idc(pv_comp_mode_mv_ctxt, ps_ctxt->ai4_ref_part_idc, &i4_intra_flag, pv_mb_params); /* If base is Intra */ if(SVCD_TRUE == i4_intra_flag) { if(1 == ps_svc_mb_params->u1_base_mode_flag) { i4_mb_mode = SVC_IBL_MB; ps_svc_mb_params->u1_residual_prediction_flag = 0; } } else { /* derive the motion and reference index by inter layer predcition */ isvcd_interlyr_motion_submbmode_pred(pv_comp_mode_mv_ctxt, ps_mb_params, ps_svc_mb_params, ps_ctxt->ai4_ref_part_idc, ai4_sub_mb_mode, pv_dec); /* derive the MB mode */ if(1 == ps_svc_mb_params->u1_base_mode_flag) { isvcd_interlyr_mbmode_pred(pv_comp_mode_mv_ctxt, pv_mb_params, ai4_sub_mb_mode, &i4_mb_mode, ps_dec, ps_mb_part_info, ps_part); } else { isvcd_populate_ref_idx(ps_mb_params, ps_svc_mb_params, ps_ctxt->ps_motion_pred_struct, ps_mb_part_info, ps_ctxt->i4_listx); } } return i4_mb_mode; } /*****************************************************************************/ /* */ /* Function Name : isvcd_interlyr_motion_mode_pred_dyadic */ /* */ /* Description : this function does the inter layer motion predcition for */ /* dyadic cases */ /* */ /* Inputs : pv_comp_mode_mv_ctxt : motion mode handle */ /* pv_ref_layer_motion_mem_elements : pointer to memory */ /* elements of reference layer motion params */ /* pv_mb_params : pointer to MB params structure */ /* ai4_ref_part_idc : ref partitons idc of all 4x4 blocks */ /* pi4_sub_mb_mode : pointer to store the sub mb modes */ /* i4_mb_addr : current mb address */ /* pi4_intra_flag : location to store the intra status */ /* Globals : none */ /* Processing : it computes the motion vectors and */ /* Outputs : inter layer predicted motion vectors and ref indices */ /* sub mbmodes of the 4 mb partitions */ /* Returns : none */ /* */ /* Issues : none */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 06 09 2021 vijayakumar creation */ /* */ /*****************************************************************************/ WORD32 isvcd_interlyr_motion_mode_pred_dyadic(void *pv_comp_mode_mv_ctxt, void *pv_mb_params, void *pv_svc_mb_params, void *pv_dec, void *pv_mb_part_info, void *pv_part) { mode_motion_ctxt_t *ps_ctxt; mode_motion_lyr_ctxt *ps_lyr_mem; dec_mb_info_t *ps_mb_params; dec_svc_mb_info_t *ps_svc_mb_params; WORD32 i4_listx; WORD32 i4_mb_pic_x, i4_mb_pic_y; WORD32 i4_ref_x, i4_ref_y; UWORD8 u1_base_mode_flag; dec_struct_t *ps_dec = (dec_struct_t *) pv_dec; WORD32 i4_mb_mode = -1; parse_pmbarams_t *ps_mb_part_info = (parse_pmbarams_t *) pv_mb_part_info; UWORD8 *pu1_col_info = ps_mb_part_info->u1_col_info; parse_part_params_t *ps_part = (parse_part_params_t *) pv_part; ps_ctxt = (mode_motion_ctxt_t *) pv_comp_mode_mv_ctxt; /* get the current layer ctxt */ ps_lyr_mem = &ps_ctxt->as_res_lyr_mem[ps_ctxt->i4_res_id]; ps_mb_params = (dec_mb_info_t *) pv_mb_params; ps_svc_mb_params = (dec_svc_mb_info_t *) pv_svc_mb_params; i4_listx = ps_ctxt->i4_listx; { WORD32 i4_mb_x, i4_mb_y; /* derive the MB_X and MB_Y for the current MB */ i4_mb_x = ps_mb_params->u2_mbx; i4_mb_y = ps_mb_params->u2_mby; /* get the colocated position in the refernce layer */ i4_ref_x = ps_lyr_mem->pi2_ref_loc_x[i4_mb_x << 4]; i4_ref_y = ps_lyr_mem->pi2_ref_loc_y[i4_mb_y << 4]; i4_ref_x = CLIP3(0, ((ps_lyr_mem->i4_ref_width) - 1), i4_ref_x); i4_ref_y = CLIP3(0, ((ps_lyr_mem->i4_ref_height) - 1), i4_ref_y); /* convert into picture units */ i4_mb_pic_x = i4_mb_x << 4; i4_mb_pic_y = i4_mb_y << 4; } /* ref layer mb mode */ { inter_lyr_mb_prms_t *ps_inter_lyr_mb_prms; WORD32 i4_inter_lyr_mb_prms_stride; WORD32 i4_ref_mb_x, i4_ref_mb_y; WORD8 i1_ref_mb_mode; ps_inter_lyr_mb_prms = (inter_lyr_mb_prms_t *) ps_lyr_mem->s_ref_mb_mode.pv_buffer; i4_inter_lyr_mb_prms_stride = ps_lyr_mem->s_ref_mb_mode.i4_num_element_stride; /* get the reference mb x and y */ i4_ref_mb_x = (i4_ref_x >> 4); i4_ref_mb_y = (i4_ref_y >> 4); /* get the appropriate mb params in reference layer */ ps_inter_lyr_mb_prms += i4_ref_mb_x; ps_inter_lyr_mb_prms += i4_ref_mb_y * i4_inter_lyr_mb_prms_stride; i1_ref_mb_mode = ps_inter_lyr_mb_prms->i1_mb_mode; u1_base_mode_flag = ps_svc_mb_params->u1_base_mode_flag; /* check if the MB mode of the refernce MB is Intra*/ if(i1_ref_mb_mode > SVC_INTER_MB) { if(1 == u1_base_mode_flag) { i4_mb_mode = SVC_IBL_MB; ps_svc_mb_params->u1_residual_prediction_flag = 0; } return i4_mb_mode; } } /*-----------------------------------------------------------------------*/ /* Inter MB upsampling process */ /*-----------------------------------------------------------------------*/ { mv_pred_t *ps_motion_pred; WORD32 i4_16x16_flag; WORD32 i4_part_idc; WORD32 i4_blk_idx; WORD32 i4_curr_mot_stride; /* choose the appropriate mv bank pointer and stride */ if(1 == u1_base_mode_flag) { i4_mb_mode = SVC_INTER_MB; } ps_motion_pred = ps_ctxt->ps_motion_pred_struct; i4_curr_mot_stride = 4; /* call the motion upsampling for 1st 4x4 */ i4_part_idc = (i4_ref_y << 16) + i4_ref_x; i4_16x16_flag = isvcd_interlyr_motion_scale( pv_comp_mode_mv_ctxt, &i4_part_idc, ps_mb_params, ps_motion_pred, i4_listx, (i4_mb_pic_x + 1), (i4_mb_pic_y + 1), ps_dec->ppv_map_ref_idx_to_poc); /* ---------- reference layer MB is 16x16 ------------------*/ if(i4_16x16_flag) { if(1 == u1_base_mode_flag) { ps_mb_params->u1_mb_type = P_L0_16x16; ps_mb_params->u1_mb_mc_mode = PRED_16x16; ps_mb_part_info->u1_num_part = 1; *pu1_col_info++ = (PRED_16x16 << 6); ps_mb_part_info->i1_ref_idx[0][0] = ps_motion_pred->i1_ref_frame[0]; ps_part->u1_partwidth = 4; // interms of 4x4 ps_part->u1_partheight = 4; ps_part->u1_pred_mode = PRED_L0; ps_part->u1_is_direct = 0; ps_part->u1_sub_mb_num = 0; if(2 == i4_listx) { WORD32 i4_part_mode_a = 0; WORD32 i4_temp; ps_mb_part_info->i1_ref_idx[1][0] = ps_motion_pred->i1_ref_frame[1]; if(0 <= ps_motion_pred[0].i1_ref_frame[0]) { i4_part_mode_a += 1; } if(0 <= ps_motion_pred[0].i1_ref_frame[1]) { i4_part_mode_a += 2; } i4_temp = 3 * PRED_16x16; i4_temp += (3 * (i4_part_mode_a - 1) - 1); i4_temp = (i4_temp < 0) ? 0 : i4_temp; i4_temp = g_au1_eb_mb_type[i4_temp]; ps_mb_params->u1_mb_type = i4_temp; ps_part->u1_pred_mode = g_au1_mb_pred_mode[0][5 + i4_temp]; } } else { /* motion prediction flag cases replicate the motion vectors for entire MB */ isvcd_store_motion_map(ps_motion_pred, (ps_motion_pred), 0, i4_curr_mot_stride, NUM_MB_PARTS, NUM_MB_PARTS, SVCD_FALSE); isvcd_populate_ref_idx(ps_mb_params, ps_svc_mb_params, ps_motion_pred, ps_mb_part_info, i4_listx); } return i4_mb_mode; } /* ---------- reference layer MB is non 16x16 ------------------ */ else { WORD32 ai4_sub_mb_mode[NUM_MB_PARTS] = {0}; /* replicate the motion vectors for 8x8 */ isvcd_store_motion_map(ps_motion_pred, ps_motion_pred, 0, i4_curr_mot_stride, 2, 2, SVCD_FALSE); if(2 == i4_listx) { WORD32 i4_indx = 0; /* replicate the motion vectors for 8x8 */ /* check the 0th partiton reference indices */ if(0 <= ps_motion_pred[0].i1_ref_frame[0]) { i4_indx += 1; } if(0 <= ps_motion_pred[0].i1_ref_frame[1]) { i4_indx += 2; } i4_indx = 3 * PRED_8x8 + (i4_indx - 1); ai4_sub_mb_mode[0] = g_au1_eb_submb_type[i4_indx]; } /* derive the motion vectors and reference indices of 3 rem partitions */ for(i4_blk_idx = 1; i4_blk_idx < NUM_MB_PARTS; i4_blk_idx++) { WORD32 i4_blk_y, i4_blk_x; mv_pred_t *ps_temp; i4_blk_x = i4_blk_idx & 1; i4_blk_y = i4_blk_idx >> 1; ps_temp = ps_motion_pred + (i4_blk_x << 1); ps_temp += (i4_blk_y * i4_curr_mot_stride << 1); /* store the reference layer positions */ i4_part_idc = ((i4_ref_y + (i4_blk_y << 2)) << 16) + (i4_ref_x + (i4_blk_x << 2)); isvcd_interlyr_motion_scale(pv_comp_mode_mv_ctxt, &i4_part_idc, ps_mb_params, ps_temp, i4_listx, (i4_mb_pic_x + (i4_blk_x << 2) + 1), (i4_mb_pic_y + (i4_blk_y << 2) + 1), ps_dec->ppv_map_ref_idx_to_poc); /* replicate the motion vectors for 8x8 */ isvcd_store_motion_map(ps_temp, ps_temp, 0, i4_curr_mot_stride, 2, 2, SVCD_FALSE); if(2 == i4_listx) { WORD32 i4_indx = 0; /* check the 0th partiton reference indices */ if(0 <= ps_temp[0].i1_ref_frame[0]) { i4_indx += 1; } if(0 <= ps_temp[0].i1_ref_frame[1]) { i4_indx += 2; } i4_indx = 3 * PRED_8x8 + (i4_indx - 1); ai4_sub_mb_mode[i4_blk_idx] = g_au1_eb_submb_type[i4_indx]; } } /* if MB mode has to derivied */ if(1 == u1_base_mode_flag) { WORD32 i4_horz_match, i4_vert_match; WORD32 i4_part_size = PRED_8x8; mv_pred_t *ps_motion_1; mv_pred_t *ps_motion_2; mv_pred_t *ps_motion_3; ps_motion_1 = ps_motion_pred + 2; ps_motion_2 = ps_motion_pred + (i4_curr_mot_stride << 1); ps_motion_3 = ps_motion_2 + 2; /* check if the motion in horz direction are same*/ i4_horz_match = isvcd_check_motion(ps_motion_pred, ps_motion_1, i4_listx); i4_horz_match += isvcd_check_motion(ps_motion_2, ps_motion_3, i4_listx); /* check if the motion in vertical direction is same */ i4_vert_match = isvcd_check_motion(ps_motion_pred, ps_motion_2, i4_listx); i4_vert_match += isvcd_check_motion(ps_motion_1, ps_motion_3, i4_listx); ps_mb_part_info->u1_num_part = 4; /* decide the partition size based on the results of matching */ if((2 == i4_horz_match) && (2 == i4_vert_match)) { ps_mb_params->u1_mb_type = P_L0_16x16; i4_part_size = PRED_16x16; ps_mb_part_info->u1_num_part = 1; *pu1_col_info++ = (PRED_16x16 << 6); ps_mb_part_info->i1_ref_idx[0][0] = ps_motion_pred->i1_ref_frame[0]; if(2 == i4_listx) ps_mb_part_info->i1_ref_idx[1][0] = ps_motion_pred->i1_ref_frame[1]; ps_part->u1_partwidth = 4; // interms of 4x4 ps_part->u1_partheight = 4; ps_part->u1_pred_mode = PRED_L0; ps_part->u1_is_direct = 0; ps_part->u1_sub_mb_num = 0; } else if(2 == i4_horz_match) { ps_mb_params->u1_mb_type = P_L0_L0_16x8; i4_part_size = PRED_16x8; ps_mb_part_info->u1_num_part = 2; *pu1_col_info++ = (PRED_16x8 << 6); *pu1_col_info++ = (PRED_16x8 << 6); ps_mb_part_info->i1_ref_idx[0][0] = ps_motion_pred->i1_ref_frame[0]; ps_mb_part_info->i1_ref_idx[0][1] = ps_motion_pred[8].i1_ref_frame[0]; if(2 == i4_listx) { ps_mb_part_info->i1_ref_idx[1][0] = ps_motion_pred->i1_ref_frame[1]; ps_mb_part_info->i1_ref_idx[1][1] = ps_motion_pred[8].i1_ref_frame[1]; } ps_part->u1_partwidth = 4; // interms of 4x4 ps_part->u1_partheight = 2; ps_part->u1_pred_mode = PRED_L0; ps_part->u1_is_direct = 0; ps_part->u1_sub_mb_num = 0; ps_part++; ps_part->u1_partwidth = 4; ps_part->u1_partheight = 2; ps_part->u1_pred_mode = PRED_L0; ps_part->u1_is_direct = 0; ps_part->u1_sub_mb_num = 8; } else if(2 == i4_vert_match) { ps_mb_params->u1_mb_type = P_L0_L0_8x16; i4_part_size = PRED_8x16; ps_mb_part_info->u1_num_part = 2; *pu1_col_info++ = (PRED_8x16 << 6); *pu1_col_info++ = (PRED_8x16 << 6); ps_mb_part_info->i1_ref_idx[0][0] = ps_motion_pred->i1_ref_frame[0]; ps_mb_part_info->i1_ref_idx[0][1] = ps_motion_pred[2].i1_ref_frame[0]; if(2 == i4_listx) { ps_mb_part_info->i1_ref_idx[1][0] = ps_motion_pred->i1_ref_frame[1]; ps_mb_part_info->i1_ref_idx[1][1] = ps_motion_pred[2].i1_ref_frame[1]; } ps_part->u1_partwidth = 2; // interms of 4x4 ps_part->u1_partheight = 4; ps_part->u1_pred_mode = PRED_L0; ps_part->u1_is_direct = 0; ps_part->u1_sub_mb_num = 0; ps_part++; ps_part->u1_partwidth = 2; ps_part->u1_partheight = 4; ps_part->u1_pred_mode = PRED_L0; ps_part->u1_is_direct = 0; ps_part->u1_sub_mb_num = 2; } /* store the part size to the mb params */ ps_mb_params->u1_mb_mc_mode = i4_part_size; /* store the sub partition size */ if(PRED_8x8 == i4_part_size) { UWORD8 u1_ctr; /* for P_MB sub part type is P_L0_8x8*/ ps_mb_params->u1_mb_type = P_8x8; ps_mb_part_info->i1_ref_idx[0][0] = ps_motion_pred[0].i1_ref_frame[0]; ps_mb_part_info->i1_ref_idx[0][1] = ps_motion_pred[2].i1_ref_frame[0]; ps_mb_part_info->i1_ref_idx[0][2] = ps_motion_pred[8].i1_ref_frame[0]; ps_mb_part_info->i1_ref_idx[0][3] = ps_motion_pred[10].i1_ref_frame[0]; if(2 == i4_listx) { ps_mb_part_info->i1_ref_idx[1][0] = ps_motion_pred[0].i1_ref_frame[1]; ps_mb_part_info->i1_ref_idx[1][1] = ps_motion_pred[2].i1_ref_frame[1]; ps_mb_part_info->i1_ref_idx[1][2] = ps_motion_pred[8].i1_ref_frame[1]; ps_mb_part_info->i1_ref_idx[1][3] = ps_motion_pred[10].i1_ref_frame[1]; } for(u1_ctr = 0; u1_ctr < 4; u1_ctr++) { *pu1_col_info++ = (PRED_8x8 << 6); ps_part->u1_partwidth = 2; // interms of 4x4 ps_part->u1_partheight = 2; ps_part->u1_pred_mode = PRED_L0; ps_part->u1_is_direct = 0; ps_part->u1_sub_mb_num = (u1_ctr & 0x01) * 2 + (u1_ctr >> 1) * 8; ps_part++; } } if(2 == i4_listx) { ps_part = (parse_part_params_t *) pv_part; pu1_col_info = ps_mb_part_info->u1_col_info; isvcd_interlyr_mbmode_pred_bmb(ps_ctxt, ps_motion_pred, i4_curr_mot_stride, i4_part_size, &ai4_sub_mb_mode[0], ps_mb_params, ps_part, pu1_col_info); } } /* end of mode derivation */ else { isvcd_populate_ref_idx(ps_mb_params, ps_svc_mb_params, ps_motion_pred, ps_mb_part_info, i4_listx); } /* non 16x16 mv mode derivation */ } } return i4_mb_mode; } /*****************************************************************************/ /* */ /* Function Name : isvcd_compute_scaled_offsets */ /* */ /* Description : this module does the projection of the current layer */ /* points (x,0) and (0,y) on to the reference layer and */ /* gets the 1/16 sample of the reference location */ /* x ranges from 0 - frame width */ /* y ranges from 0 - frame height */ /* this projection is done for LUMA only */ /* Inputs : ps_curr_lyr_slice_prms: pointer to current layer slice */ /* parameters */ /* ps_ref_lyr_slice_prms: pointer to ref layer slice prms */ /* pi2_offset_x : pointer to store x projected */ /* pi2_offset_y : pointer to store y projected */ /* Globals : none */ /* Processing : it store the projected values for those points in the */ /* crop window */ /* Outputs : projected locations */ /* Returns : none */ /* */ /* Issues : assumes that outside crop window no projection */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 06 09 2021 vijayakumar creation */ /* */ /*****************************************************************************/ WORD32 isvcd_compute_scaled_offsets(res_prms_t *ps_curr_res_prms, res_prms_t *ps_ref_res_prms, WORD16 *pi2_offset_x, WORD16 *pi2_offset_y, UWORD8 u1_level_idc) { WORD32 i4_offset_x, i4_offset_y; UWORD32 i4_scaled_ref_lyr_width; UWORD32 i4_scaled_ref_lyr_height; UWORD32 i4_ref_lyr_width; UWORD32 i4_ref_lyr_height; UWORD32 i4_shift_x, i4_shift_y; UWORD32 i4_scale_x, i4_scale_y; WORD32 i4_cntr; WORD32 i4_scale_add_x, i4_scale_add_y; WORD32 i4_curr_lyr_width, i4_curr_lyr_height; if((NULL == ps_curr_res_prms) || (NULL == ps_ref_res_prms) || (NULL == pi2_offset_x) || (NULL == pi2_offset_y)) { return NOT_OK; } /* initial calculation */ i4_offset_x = ps_curr_res_prms->s_ref_lyr_scaled_offset.i2_left; i4_offset_y = ps_curr_res_prms->s_ref_lyr_scaled_offset.i2_top; /* get the width and height */ i4_scaled_ref_lyr_width = ps_curr_res_prms->u2_scaled_ref_width; i4_scaled_ref_lyr_height = ps_curr_res_prms->u2_scaled_ref_height; i4_ref_lyr_width = ps_ref_res_prms->i4_res_width; i4_ref_lyr_height = ps_ref_res_prms->i4_res_height; i4_curr_lyr_width = ps_curr_res_prms->i4_res_width; i4_curr_lyr_height = ps_curr_res_prms->i4_res_height; /* derive shift x and y based on level idd */ if(u1_level_idc <= 30) { i4_shift_x = 16; i4_shift_y = 16; } else { i4_shift_x = 31 - isvcd_get_ceil_log2(i4_ref_lyr_width); i4_shift_y = 31 - isvcd_get_ceil_log2(i4_ref_lyr_height); } /* assert on max ranges of width and shift values */ if((i4_ref_lyr_width > H264_MAX_FRAME_WIDTH) || (i4_scaled_ref_lyr_width > H264_MAX_FRAME_WIDTH) || (i4_ref_lyr_height > H264_MAX_FRAME_HEIGHT) || (i4_scaled_ref_lyr_height > H264_MAX_FRAME_HEIGHT) || (i4_curr_lyr_width > H264_MAX_FRAME_WIDTH) || (i4_curr_lyr_height > H264_MAX_FRAME_HEIGHT)) { return NOT_OK; } /* calculate scale factor x and y */ i4_scale_x = (((UWORD32) i4_ref_lyr_width << i4_shift_x) + (i4_scaled_ref_lyr_width >> 1)) / i4_scaled_ref_lyr_width; i4_scale_y = (((UWORD32) i4_ref_lyr_height << i4_shift_y) + (i4_scaled_ref_lyr_height >> 1)) / i4_scaled_ref_lyr_height; /* calcualte the values to be added based on left and top offset */ i4_scale_add_x = (1 << (i4_shift_x - 1)) - (i4_offset_x * (WORD32) i4_scale_x); i4_scale_add_y = (1 << (i4_shift_y - 1)) - (i4_offset_y * (WORD32) i4_scale_y); /* derive the projected locations in the reference layer */ for(i4_cntr = 0; i4_cntr < i4_curr_lyr_width; i4_cntr++) { WORD32 i4_ref_x; i4_ref_x = (i4_cntr * i4_scale_x + i4_scale_add_x) >> i4_shift_x; *pi2_offset_x++ = (WORD16) i4_ref_x; } /* derive the projected locations in the reference layer */ for(i4_cntr = 0; i4_cntr < i4_curr_lyr_height; i4_cntr++) { WORD32 i4_ref_y; i4_ref_y = (i4_cntr * i4_scale_y + i4_scale_add_y) >> i4_shift_y; *pi2_offset_y++ = (WORD16) i4_ref_y; } return OK; } /*****************************************************************************/ /* */ /* Function Name : isvcd_comp_mode_mv_res_init */ /* */ /* Description : this function calculates the scale factors and initialise*/ /* the context structure */ /* */ /* Inputs : pv_comp_mode_mv_ctxt: handle to private structure */ /* ps_curr_lyr_res_prms: pointer to current resolution */ /* params */ /* pi2_ref_loc_x : pointer to buffer having the */ /* projected locations horz */ /* pi2_ref_loc_y : pointer to buffer having the */ /* projected location vertical */ /* Globals : none */ /* Processing : it calculates the scale factors and stores it */ /* */ /* Outputs : none */ /* Returns : none */ /* */ /* Issues : none */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 06 09 2021 vijayakumar creation */ /* */ /*****************************************************************************/ WORD32 isvcd_comp_mode_mv_res_init(void *pv_svc_dec) { /*! Flow of the module is as follows */ /*! 1. calculates the scale factors for dyadic cases */ /*! 2. calculaets the loop counts and part width and height based on dyadic scale factor */ /*! 2. calculate the MV scale factors */ /*! 3. initialises the default mv ped structure with deafult values */ mode_motion_ctxt_t *ps_ctxt; mode_motion_lyr_ctxt *ps_lyr_mem; dec_seq_params_t *ps_sps; svc_dec_lyr_struct_t *ps_svc_lyr_dec = (svc_dec_lyr_struct_t *) pv_svc_dec; dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec; svc_dec_lyr_struct_t *ps_svc_dec_ref_layer; WORD32 ret; WORD32 i4_scaled_ref_lyr_width; WORD32 i4_scaled_ref_lyr_height; WORD32 i4_ref_lyr_width; WORD32 i4_ref_lyr_height; res_prms_t *ps_curr_lyr_res_prms = &ps_svc_lyr_dec->s_res_prms; ps_svc_dec_ref_layer = ps_svc_lyr_dec->ps_dec_svc_ref_layer; if(NULL == ps_curr_lyr_res_prms) { return NOT_OK; } ps_ctxt = (mode_motion_ctxt_t *) ps_svc_lyr_dec->pv_mode_mv_sample_ctxt; ps_ctxt->u1_direct_8x8_inference_flag = ps_curr_lyr_res_prms->u1_direct_8x8_inference_flag; /* if called for base resolution store deafult values */ if(SVCD_TRUE == ps_svc_lyr_dec->u1_base_res_flag) { ps_ctxt->i4_res_id = -1; ps_ctxt->i4_ref_width = ps_curr_lyr_res_prms->i4_res_width; ps_ctxt->i4_ref_height = ps_curr_lyr_res_prms->i4_res_height; return OK; } /* call the function which populates the projected ref locations */ ps_sps = ps_dec->ps_cur_sps; /* store the res id appropriately */ ps_ctxt->i4_res_id = ps_svc_lyr_dec->u1_layer_id - 1; /* get the current layer ctxt */ ps_lyr_mem = &ps_ctxt->as_res_lyr_mem[ps_ctxt->i4_res_id]; /* store the current and reference res params to the context */ ps_lyr_mem->ps_curr_lyr_res_prms = ps_curr_lyr_res_prms; /* store the reference layer mv bank pointer */ ps_lyr_mem->pv_ref_mv_bank_l0 = ps_svc_dec_ref_layer->s_dec.s_cur_pic.ps_mv; /* store the reference layer mb mode pointer */ ps_lyr_mem->s_ref_mb_mode.pv_buffer = ps_svc_dec_ref_layer->ps_inter_lyr_mb_prms_frm_start; ps_lyr_mem->s_ref_mb_mode.i4_num_element_stride = ps_svc_dec_ref_layer->u2_inter_lyr_mb_prms_stride; ps_lyr_mem->s_ref_mb_mode.i4_element_size = sizeof(inter_lyr_mb_prms_t); /* check for recomputation of mapping required */ if(SVCD_TRUE == ps_curr_lyr_res_prms->u1_remap_req_flag) { res_prms_t s_ref_res_prms = {0}; /* store the reference layer resolution width and height */ s_ref_res_prms.i4_res_width = ps_ctxt->i4_ref_width; s_ref_res_prms.i4_res_height = ps_ctxt->i4_ref_height; /* call projection map calculation function */ ret = isvcd_compute_scaled_offsets(ps_curr_lyr_res_prms, &s_ref_res_prms, ps_lyr_mem->pi2_ref_loc_x, ps_lyr_mem->pi2_ref_loc_y, ps_sps->u1_level_idc); if(OK != ret) { return NOT_OK; } /* derive the scaling variables */ ps_lyr_mem->i4_offset_x = ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_left; ps_lyr_mem->i4_offset_y = ps_curr_lyr_res_prms->s_ref_lyr_scaled_offset.i2_top; /* get the width and heights */ i4_scaled_ref_lyr_width = ps_curr_lyr_res_prms->u2_scaled_ref_width; i4_scaled_ref_lyr_height = ps_curr_lyr_res_prms->u2_scaled_ref_height; i4_ref_lyr_width = ps_ctxt->i4_ref_width; i4_ref_lyr_height = ps_ctxt->i4_ref_height; /*store the reference layer width adn height */ ps_lyr_mem->i4_ref_width = ps_ctxt->i4_ref_width; ps_lyr_mem->i4_ref_height = ps_ctxt->i4_ref_height; if((i4_ref_lyr_width > H264_MAX_FRAME_WIDTH) || (i4_ref_lyr_width <= 0)) return NOT_OK; if((i4_scaled_ref_lyr_width > H264_MAX_FRAME_WIDTH) || (i4_scaled_ref_lyr_width <= 0)) return NOT_OK; if((i4_ref_lyr_height > H264_MAX_FRAME_HEIGHT) || (i4_ref_lyr_height <= 0)) return NOT_OK; if((i4_scaled_ref_lyr_height > H264_MAX_FRAME_HEIGHT) || (i4_scaled_ref_lyr_height <= 0)) return NOT_OK; /* derivation of variables for dyadic cases cropping should be MB aligned */ /* default values for flags */ ps_lyr_mem->pf_inter_lyr_pred = &isvcd_compute_interlyr_motion_mode; if(SVCD_TRUE == ps_curr_lyr_res_prms->u1_dyadic_flag) { ps_lyr_mem->pf_inter_lyr_pred = &isvcd_interlyr_motion_mode_pred_dyadic; } /* Store the Dyadic flag */ ps_lyr_mem->i4_dyadic_flag = ps_curr_lyr_res_prms->u1_dyadic_flag; /* derive the scaling factors for motion upscaling */ /* this is derived assuming no crop change flag is present */ ps_lyr_mem->i4_scale_mv_x = ((i4_scaled_ref_lyr_width << 16) + (i4_ref_lyr_width >> 1)) / i4_ref_lyr_width; ps_lyr_mem->i4_scale_mv_y = ((i4_scaled_ref_lyr_height << 16) + (i4_ref_lyr_height >> 1)) / i4_ref_lyr_height; } else { /* should take false value */ if(SVCD_FALSE != ps_curr_lyr_res_prms->u1_remap_req_flag) { return NOT_OK; } } /* store the current layer width and height to context */ ps_ctxt->i4_ref_width = ps_curr_lyr_res_prms->i4_res_width; ps_ctxt->i4_ref_height = ps_curr_lyr_res_prms->i4_res_height; return OK; }