std::string CXBindingsCppHandlersGenerator::FindRealTypeFor( const std::string& typeBase )
{
std::string type = typeBase;
if( boost::algorithm::contains(type,":") ) {
type = after_first( type, ':' );
}
std::string realType;
std::string newType = type;
std::string oldType;
if( IsBaseType( type ) ) {
newType = GetBaseType(type);
oldType = type;
} else {
CXBindingsStringStringMap::iterator it = m_types.find( type );
while( it != m_types.end() && newType != oldType) {
oldType = newType;
newType = it->second;
it = m_types.find( newType );
}
if( newType != "enum" )
newType = "object";
}
realType = newType;
return realType;
}
AAFRESULT STDMETHODCALLTYPE
ImplAAFTypeDefRename::GetBaseValue (
ImplAAFPropertyValue * pInPropVal,
ImplAAFPropertyValue ** ppOutPropVal)
{
if (! pInPropVal) return AAFRESULT_NULL_PARAM;
if (! ppOutPropVal) return AAFRESULT_NULL_PARAM;
// Get the property value's embedded type and
// check if it's the same as the base type.
ImplAAFTypeDefSP pInPropType;
if( AAFRESULT_FAILED( pInPropVal->GetType( &pInPropType ) ) )
return AAFRESULT_BAD_TYPE;
ASSERTU (pInPropType);
if( (ImplAAFTypeDef *)pInPropType != this )
return AAFRESULT_BAD_TYPE;
aafUInt32 inBitsSize;
ImplAAFPropValDataSP pOutPVData;
ImplAAFPropValDataSP pvd;
ImplAAFTypeDefSP ptd;
AAFRESULT hr;
hr = GetBaseType (&ptd);
if (AAFRESULT_FAILED (hr)) return hr;
ASSERTU (ptd);
// aafUInt32 elementSize = ptd->PropValSize();
ASSERTU (pInPropVal);
pvd = dynamic_cast<ImplAAFPropValData*> (pInPropVal);
ASSERTU (pvd);
hr = pvd->GetBitsSize (&inBitsSize);
if (! AAFRESULT_SUCCEEDED (hr)) return hr;
pOutPVData = (ImplAAFPropValData *)CreateImpl(CLSID_AAFPropValData);
if (! pOutPVData) return AAFRESULT_NOMEMORY;
// Bobt: Hack bugfix! SmartPointer operator= will automatically
// AddRef; CreateImpl *also* will addref, so we've got one too
// many. Put us back to normal.
pOutPVData->ReleaseReference ();
ASSERTU (ptd);
hr = pOutPVData->Initialize (ptd);
if (AAFRESULT_FAILED(hr)) return hr;
hr = pOutPVData->AllocateFromPropVal (pvd,
0,
inBitsSize,
NULL);
if (AAFRESULT_FAILED(hr)) return hr;
ASSERTU (ppOutPropVal);
*ppOutPropVal = pOutPVData;
(*ppOutPropVal)->AcquireReference ();
ASSERTU (*ppOutPropVal);
return AAFRESULT_SUCCESS;
}
ImplAAFTypeDefSP ImplAAFTypeDefRename::BaseType () const
{
ImplAAFTypeDefSP result;
AAFRESULT hr = GetBaseType (&result);
ASSERTU (AAFRESULT_SUCCEEDED (hr));
ASSERTU (result);
return result;
}
int macroblock_layer_in_scalable_extension(const NAL *Nal, const PPS *Pps, RESIDU *Current_residu, RESIDU *BaseResidu,
const unsigned char *ai_pcData, int *position, const SLICE *ai_pstSlice,
DATA Tab_Block[], const VLC_TABLES *vlc, unsigned char aio_tiNon_zero_count_cache [ ],
unsigned char aio_tiSlice_table [ ], const short iMb_x, const short iMb_y,
int direct_8x8_inference_flag, int *last_QP)
{
int noSubMbPartSizeLessThan8x8;
int BaseModeFlag = 0;
const int iCurrMbAddr = iMb_x + iMb_y * (short)(ai_pstSlice -> mb_stride);
short intra4x4_pred_mode_cache[40];
DATA * aio_pstBlock = &Tab_Block[iCurrMbAddr];
//TODO
if( ai_pstSlice -> AdaptiveBaseModeFlag && Current_residu -> InCropWindow) {
Current_residu -> BaseModeFlag = BaseModeFlag = getNbits(ai_pcData, position, 1); //u(1)
}else if (ai_pstSlice -> DefaultBaseModeFlag){
Current_residu -> BaseModeFlag = BaseModeFlag = 1;
}
if(!BaseModeFlag){
int mb_type = read_ue(ai_pcData, position);
//According to the slice type and the macroblock type
//the parameters are adjusted
switch ( ai_pstSlice -> slice_type )
{
case EI :
#ifdef ERROR_DETECTION
//Error detection
if(ErrorsCheckMbType(mb_type, I_BL)){
return 1;
}
#endif
aio_pstBlock -> MbPartPredMode [0] = i_mb_type_info[mb_type] . type;
Current_residu -> MbType = i_mb_type_info[mb_type] . type;
Current_residu -> Cbp = i_mb_type_info[mb_type] . Cbp;
Current_residu -> Intra16x16PredMode = i_mb_type_info[mb_type] . pred_mode;
break ;
case EP :
if (mb_type < 5){
#ifdef ERROR_DETECTION
//Error detection
if(ErrorsCheckMbType(mb_type, P_BL)){
return 1;
}
#endif
aio_pstBlock -> NumMbPart = p_mb_type_info[mb_type] . partcount;
aio_pstBlock -> MbPartPredMode [0] = p_mb_type_info[mb_type] . type_0;
aio_pstBlock -> MbPartPredMode [1] = p_mb_type_info[mb_type] . type_1;
Current_residu -> MbType = p_mb_type_info[mb_type] . name;
Current_residu -> Mode = p_mb_type_info[mb_type] . Mode;
}
else {
mb_type -= 5;
#ifdef ERROR_DETECTION
//Error detection
if(ErrorsCheckMbType(mb_type, I_BL)){
return 1;
}
#endif
aio_pstBlock -> MbPartPredMode [0] = i_mb_type_info[mb_type] . type;
Current_residu -> MbType = i_mb_type_info[mb_type] . type;
Current_residu -> Cbp = i_mb_type_info[mb_type] . Cbp;
Current_residu -> Intra16x16PredMode = i_mb_type_info[mb_type] . pred_mode;
}
break ;
case EB :
if (mb_type < 23) {
#ifdef ERROR_DETECTION
//Error detection
if(ErrorsCheckMbType(mb_type, B_BL)){
return 1;
}
#endif
aio_pstBlock -> NumMbPart = b_mb_type_info[mb_type] . partcount;
aio_pstBlock -> MbPartPredMode [0] = b_mb_type_info[mb_type] . type_0;
aio_pstBlock -> MbPartPredMode [1] = b_mb_type_info[mb_type] . type_1;
Current_residu -> MbType = b_mb_type_info[mb_type] . name;
Current_residu -> Mode = b_mb_type_info[mb_type] . Mode;
}
else {
mb_type -= 23;
#ifdef ERROR_DETECTION
//Error detection
if(ErrorsCheckMbType(mb_type, I_BL)){
return 1;
}
#endif
aio_pstBlock -> MbPartPredMode [0] = i_mb_type_info[mb_type] . type;
Current_residu -> MbType = i_mb_type_info[mb_type] . type;
Current_residu -> Cbp = i_mb_type_info[mb_type] . Cbp;
Current_residu -> Intra16x16PredMode = i_mb_type_info[mb_type] . pred_mode;
}
break;
}
//Initialize base macroblock address
GetBaseMbAddr(Nal, aio_pstBlock, iMb_x << 4, iMb_y << 4);
}
else{
aio_pstBlock -> MbPartPredMode [0] = Current_residu -> MbType = GetBaseType(Nal, BaseResidu, aio_pstBlock, iMb_x, iMb_y);
}
//Updating the slice table in order to save in which slice each macroblock belong to
Current_residu -> SliceNum = aio_tiSlice_table [iCurrMbAddr] = ai_pstSlice -> slice_num ;
if ( !BaseModeFlag && Current_residu -> MbType == INTRA_PCM ) {
while ( !bytes_aligned(*position) ) {
getNbits(ai_pcData, position, 1);//pcm_alignment_zero_bit =
}
ParseIPCM(ai_pcData, position, Current_residu, aio_tiNon_zero_count_cache);
}
else {
//Updating the parameter in order to decode the VLC
fill_caches_svc( ai_pstSlice, Current_residu, BaseResidu, 0, aio_tiNon_zero_count_cache, aio_tiSlice_table,
aio_pstBlock, intra4x4_pred_mode_cache, iMb_x, iMb_y, Pps -> constrained_intra_pred_flag, Nal -> TCoeffPrediction);
if (!BaseModeFlag){
//Recovery of the motion vectors for the sub_macroblock
if ( !IS_I(Current_residu -> MbType) && (aio_pstBlock -> NumMbPart == 4)) {
int mbPartIdx;
if(sub_mb_pred_svc(ai_pcData, position, ai_pstSlice, aio_pstBlock, Current_residu)){
return 1;
}
noSubMbPartSizeLessThan8x8 = 0;
if ( direct_8x8_inference_flag ){
noSubMbPartSizeLessThan8x8 = 1;
}
for ( mbPartIdx = 0; mbPartIdx < 4; mbPartIdx ++){
if ( sub_mb_type_name[ai_pstSlice -> slice_type][Current_residu -> SubMbType[mbPartIdx]] != B_direct){
if ( sub_num_part[ai_pstSlice -> slice_type][Current_residu -> SubMbType[mbPartIdx]] > 1 )
noSubMbPartSizeLessThan8x8 = 0;
}
}
}
else
{
noSubMbPartSizeLessThan8x8 = 1;
if ( Pps -> transform_8x8_mode_flag && Current_residu -> MbType == INTRA_4x4 && getNbits(ai_pcData, position, 1)){
Current_residu -> MbType = Current_residu -> Transform8x8 = aio_pstBlock -> Transform8x8 = aio_pstBlock -> MbPartPredMode[0] = INTRA_8x8;
}
//Recovery of the prediction mode and the motion vectors for the macroblock
if(mb_pred_svc(ai_pcData, position, ai_pstSlice, aio_pstBlock, Current_residu, intra4x4_pred_mode_cache)){
return 1;
}
}
}
//Decoding process of the VLC
if( ai_pstSlice -> AdaptiveResidualPredictionFlag && ai_pstSlice -> slice_type != EI && (BaseModeFlag || ( !IS_I( Current_residu -> MbType) && Current_residu -> InCropWindow ))){
Current_residu -> ResidualPredictionFlag = getNbits(ai_pcData, position, 1);
}else{
Current_residu -> ResidualPredictionFlag = ai_pstSlice -> DefaultResidualPredictionFlag;
}
if ( BaseModeFlag || aio_pstBlock -> MbPartPredMode[0] != INTRA_16x16 ){
Current_residu -> Cbp = read_me_svc(ai_pcData, position, aio_pstBlock -> MbPartPredMode[0],Current_residu, iCurrMbAddr, ai_pstSlice, iMb_x);
if ( (Current_residu -> Cbp & 15) && Pps -> transform_8x8_mode_flag && (BaseModeFlag || (!IS_I(Current_residu -> MbType) &&
noSubMbPartSizeLessThan8x8 && ( Current_residu -> MbType == B_direct || direct_8x8_inference_flag))) &&
getNbits(ai_pcData, position, 1)){
Current_residu -> Transform8x8 = aio_pstBlock -> Transform8x8 = INTRA_8x8;
}
}
if ( Current_residu -> Cbp > 0 || (Current_residu -> MbType == INTRA_16x16)) {
int mb_qp_delta = read_se(ai_pcData, position);
residual(ai_pcData, position, Current_residu, vlc, aio_tiNon_zero_count_cache);
//In case of cbp is equal to zéro, we check if there is a DC level
if (Current_residu -> Cbp == 0 && aio_tiNon_zero_count_cache[0] != 0){
Current_residu -> Cbp = 15;
}
if ( Current_residu -> MbType == INTRA_16x16 && !(Current_residu -> Cbp & 15) && (Current_residu -> Cbp & 0x30) && aio_tiNon_zero_count_cache[0]){
Current_residu -> Cbp += 15;
}
#ifdef TI_OPTIM
*last_QP = Current_residu -> Qp = divide(*last_QP + mb_qp_delta + 52, 52) >> 8 ;
#else
*last_QP = Current_residu -> Qp = (*last_QP + mb_qp_delta + 52) % 52;
#endif
}else {
