| /* |
| * Copyright (C) 2008 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. |
| */ |
| |
| /* ---- includes ----------------------------------------------------------- */ |
| |
| #include "b_BasicEm/Functions.h" |
| #include "b_BasicEm/Math.h" |
| #include "b_BitFeatureEm/Sequence.h" |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| /* ========================================================================= */ |
| /* */ |
| /* ---- \ghd{ auxiliary functions } ---------------------------------------- */ |
| /* */ |
| /* ========================================================================= */ |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| /* ========================================================================= */ |
| /* */ |
| /* ---- \ghd{ constructor / destructor } ----------------------------------- */ |
| /* */ |
| /* ========================================================================= */ |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| void bbf_Sequence_init( struct bbs_Context* cpA, |
| struct bbf_Sequence* ptrA ) |
| { |
| bbs_memset16( ptrA->ftrPtrArrE, 0, bbs_SIZEOF16( ptrA->ftrPtrArrE ) ); |
| |
| bbf_Feature_init( cpA, &ptrA->baseE ); |
| ptrA->baseE.typeE = ( uint32 )bbf_FT_SEQUENCE; |
| ptrA->baseE.vpActivityE = bbf_Sequence_activity; |
| ptrA->sizeE = 0; |
| bbs_Int32Arr_init( cpA, &ptrA->thrArrE ); |
| bbs_UInt16Arr_init( cpA, &ptrA->wgtArrE ); |
| bbs_UInt16Arr_init( cpA, &ptrA->dataArrE ); |
| } |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| void bbf_Sequence_exit( struct bbs_Context* cpA, |
| struct bbf_Sequence* ptrA ) |
| { |
| uint16 iL; |
| for( iL = 0; iL < ptrA->sizeE; iL++ ) bbf_featureExit( cpA, ptrA->ftrPtrArrE[ iL ] ); |
| |
| bbs_memset16( ptrA->ftrPtrArrE, 0, bbs_SIZEOF16( ptrA->ftrPtrArrE ) ); |
| bbf_Feature_exit( cpA, &ptrA->baseE ); |
| ptrA->sizeE = 0; |
| bbs_Int32Arr_exit( cpA, &ptrA->thrArrE ); |
| bbs_UInt16Arr_exit( cpA, &ptrA->wgtArrE ); |
| bbs_UInt16Arr_exit( cpA, &ptrA->dataArrE ); |
| } |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| /* ========================================================================= */ |
| /* */ |
| /* ---- \ghd{ operators } -------------------------------------------------- */ |
| /* */ |
| /* ========================================================================= */ |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| void bbf_Sequence_copy( struct bbs_Context* cpA, |
| struct bbf_Sequence* ptrA, |
| const struct bbf_Sequence* srcPtrA ) |
| { |
| bbs_ERROR0( "bbf_Sequence_copy:\n Function is not available" ); |
| } |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| flag bbf_Sequence_equal( struct bbs_Context* cpA, |
| const struct bbf_Sequence* ptrA, |
| const struct bbf_Sequence* srcPtrA ) |
| { |
| bbs_ERROR0( "bbf_Sequence_equal:\n Function is not available" ); |
| return TRUE; |
| } |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| /* ========================================================================= */ |
| /* */ |
| /* ---- \ghd{ query functions } -------------------------------------------- */ |
| /* */ |
| /* ========================================================================= */ |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| /* ========================================================================= */ |
| /* */ |
| /* ---- \ghd{ modify functions } ------------------------------------------- */ |
| /* */ |
| /* ========================================================================= */ |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| /* ========================================================================= */ |
| /* */ |
| /* ---- \ghd{ I/O } -------------------------------------------------------- */ |
| /* */ |
| /* ========================================================================= */ |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| uint32 bbf_Sequence_memSize( struct bbs_Context* cpA, |
| const struct bbf_Sequence* ptrA ) |
| { |
| uint16 iL; |
| uint32 memSizeL = bbs_SIZEOF16( uint32 ) + |
| bbs_SIZEOF16( uint32 ); /* version */ |
| |
| memSizeL += bbf_Feature_memSize( cpA, &ptrA->baseE ); |
| memSizeL += bbs_SIZEOF16( ptrA->sizeE ); |
| memSizeL += bbs_Int32Arr_memSize( cpA, &ptrA->thrArrE ); |
| memSizeL += bbs_UInt16Arr_memSize( cpA, &ptrA->wgtArrE ); |
| for( iL = 0; iL < ptrA->sizeE; iL++ ) memSizeL += bbf_featureMemSize( cpA, ptrA->ftrPtrArrE[ iL ] ); |
| return memSizeL; |
| } |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| uint32 bbf_Sequence_memWrite( struct bbs_Context* cpA, |
| const struct bbf_Sequence* ptrA, |
| uint16* memPtrA ) |
| { |
| uint16 iL; |
| uint32 memSizeL = bbf_Sequence_memSize( cpA, ptrA ); |
| memPtrA += bbs_memWrite32( &memSizeL, memPtrA ); |
| memPtrA += bbs_memWriteUInt32( bbf_SEQUENCE_VERSION, memPtrA ); |
| memPtrA += bbf_Feature_memWrite( cpA, &ptrA->baseE, memPtrA ); |
| memPtrA += bbs_memWrite32( &ptrA->sizeE, memPtrA ); |
| memPtrA += bbs_Int32Arr_memWrite( cpA, &ptrA->thrArrE, memPtrA ); |
| memPtrA += bbs_UInt16Arr_memWrite( cpA, &ptrA->wgtArrE, memPtrA ); |
| for( iL = 0; iL < ptrA->sizeE; iL++ ) memPtrA += bbf_featureMemWrite( cpA, ptrA->ftrPtrArrE[ iL ], memPtrA ); |
| return memSizeL; |
| } |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| uint32 bbf_Sequence_memRead( struct bbs_Context* cpA, |
| struct bbf_Sequence* ptrA, |
| const uint16* memPtrA, |
| struct bbs_MemTbl* mtpA ) |
| { |
| uint16 iL; |
| uint32 memSizeL, versionL; |
| struct bbs_MemTbl memTblL = *mtpA; |
| struct bbs_MemSeg* espL = bbs_MemTbl_fastestSegPtr( cpA, &memTblL, 0 ); |
| if( bbs_Context_error( cpA ) ) return 0; |
| memPtrA += bbs_memRead32( &memSizeL, memPtrA ); |
| memPtrA += bbs_memReadVersion32( cpA, &versionL, bbf_SEQUENCE_VERSION, memPtrA ); |
| memPtrA += bbf_Feature_memRead( cpA, &ptrA->baseE, memPtrA ); |
| memPtrA += bbs_memRead32( &ptrA->sizeE, memPtrA ); |
| |
| if( ptrA->sizeE > bbf_SEQUENCE_MAX_SIZE ) |
| { |
| bbs_ERROR0( "bbf_Sequence_memRead:\n Sequence size exceeds bbf_SEQUENCE_MAX_SIZE" ); |
| return 0; |
| } |
| |
| memPtrA += bbs_Int32Arr_memRead( cpA, &ptrA->thrArrE, memPtrA, espL ); |
| |
| if( versionL >= 101 ) memPtrA += bbs_UInt16Arr_memRead( cpA, &ptrA->wgtArrE, memPtrA, espL ); |
| |
| /* check features & allocate data buffer */ |
| { |
| const uint16* memPtrL = memPtrA; |
| uint32 dataSizeL = 0; |
| for( iL = 0; iL < ptrA->sizeE; iL++ ) |
| { |
| enum bbf_FeatureType typeL = ( enum bbf_FeatureType )bbs_memPeek32( memPtrL + 4 ); |
| dataSizeL += bbf_featureSizeOf16( cpA, typeL ); |
| memPtrL += bbs_memPeek32( memPtrL ); |
| } |
| bbs_UInt16Arr_create( cpA, &ptrA->dataArrE, dataSizeL, espL ); |
| } |
| |
| /* load features & initialize pointers */ |
| { |
| uint16* dataPtrL = ptrA->dataArrE.arrPtrE; |
| for( iL = 0; iL < ptrA->sizeE; iL++ ) |
| { |
| enum bbf_FeatureType typeL = ( enum bbf_FeatureType )bbs_memPeek32( memPtrA + 4 ); |
| ptrA->ftrPtrArrE[ iL ] = ( struct bbf_Feature* )dataPtrL; |
| bbf_featureInit( cpA, ptrA->ftrPtrArrE[ iL ], typeL ); |
| memPtrA += bbf_featureMemRead( cpA, ptrA->ftrPtrArrE[ iL ], memPtrA, &memTblL ); |
| dataPtrL += bbf_featureSizeOf16( cpA, typeL ); |
| } |
| } |
| |
| /* if( memSizeL != bbf_Sequence_memSize( cpA, ptrA ) ) |
| { |
| bbs_ERR0( bbs_ERR_CORRUPT_DATA, "uint32 bbf_Sequence_memRead( struct bem_ScanGradientMove* ptrA, const uint16* memPtrA ):\n" |
| "size mismatch" ); |
| return 0; |
| } |
| */ |
| |
| return memSizeL; |
| } |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| /* ========================================================================= */ |
| /* */ |
| /* ---- \ghd{ exec functions } --------------------------------------------- */ |
| /* */ |
| /* ========================================================================= */ |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| int32 bbf_Sequence_activity( const struct bbf_Feature* ptrA, const uint32* patchA ) |
| { |
| const struct bbf_Sequence* ptrL = ( struct bbf_Sequence* )ptrA; |
| |
| count_t iL; |
| |
| int32 sizeL = ptrL->sizeE; |
| |
| /* 12.20 */ |
| int32 actSumL = ( -sizeL ) << 20; |
| |
| if( sizeL == 0 ) return 0x10000000; /* 1.0 in 4.28 format */ |
| |
| if( ptrL->wgtArrE.sizeE == 0 ) |
| { |
| for( iL = 0; iL < ptrL->sizeE; iL++ ) |
| { |
| /* 4.28 */ |
| int32 actL = ptrL->ftrPtrArrE[ iL ]->vpActivityE( ptrL->ftrPtrArrE[ iL ], patchA ) - ptrL->thrArrE.arrPtrE[ iL ]; |
| actSumL += ( actL >> 8 ); |
| if( actL < 0 ) return ( actSumL / sizeL ) << 7; /* return 4.28 */ |
| } |
| } |
| else |
| { |
| for( iL = 0; iL < ptrL->sizeE; iL++ ) |
| { |
| /* 4.28 */ |
| int32 actL = ptrL->ftrPtrArrE[ iL ]->vpActivityE( ptrL->ftrPtrArrE[ iL ], patchA ) - ptrL->thrArrE.arrPtrE[ iL ]; |
| int32 wgtL = ptrL->wgtArrE.arrPtrE[ iL ]; |
| actL = ( actL >> 16 ) * wgtL + ( ( ( int32 )( actL & 0x0000FFFF ) * wgtL ) >> 16 ); |
| actSumL += ( actL >> 8 ); |
| if( actL < 0 ) return ( actSumL / sizeL ) << 7; /* return 4.28 */ |
| } |
| } |
| |
| actSumL += sizeL << 20; |
| |
| /* positive activity: ] 0, 1 ] */ |
| return ( actSumL / sizeL ) << 7; /* return 4.28 */ |
| } |
| |
| /* ------------------------------------------------------------------------- */ |
| |
| /* ========================================================================= */ |
| |