TMove CMyAI::ourNewTurn() { assert(!inEnemyTurn); TMove result; static CMyTimer *timer = CMyTimer::getInstance(); if (activeIsolatedMode || isIsolated(this->boardData, this->p1, this->p2)){ activeIsolatedMode = true; cout << "Isolated mode!" << endl; TPos p1, p2; p1 = CC(p_ai->GetMyPosition().x, p_ai->GetMyPosition().y); p2 = CC(p_ai->GetEnemyPosition().x, p_ai->GetEnemyPosition().y); static CBCO o1, o2; CBC::calculateBCs(this->boardData, &o1, p1); CBC::calculateBCs(this->boardData, &o2, p2); int n1, n2; n1 = o1.findLengthOfLongestPath(EXACT_AREA_BELOW_10); n2 = o2.findLengthOfLongestPath(EXACT_AREA_BELOW_10); if (abs(n1 - n2) < 4) { int _n1 = o1.findLengthOfLongestPath(EXACT); if (_n1 != TIMEOUT_POINTS) { n1 = _n1; int _n2 = o2.findLengthOfLongestPath(EXACT); if (_n2 != TIMEOUT_POINTS) n2 = _n2; } } cout << "\tEstimated length of our path " << n1 << endl; cout << "\tEstimated length of enemy path " << n2 << endl; if (n1 > n2) cout << "\t => It seems that we will f*****g WIN "; else cout << "\t => It seems that we will f*****g LOSE "; if (first == we) cout << "this easy game " << n1 - n2 << endl; else cout << "this hard game " << n1 - n2 << endl; p1 = CC(p_ai->GetMyPosition().x, p_ai->GetMyPosition().y); TMove estimateMove = CHeuristicBase::getFirstMove(boardData, p1, EXACT_AREA_BELOW_25, n1); TMove exactMove = CHeuristicBase::getFirstMove(boardData, p1, EXACT, n1); if (exactMove < 1 || exactMove > 4) result = estimateMove; else result = exactMove; result = estimateMove; } else { static bool followingMode = TRY_FOLLOWING && we != first; if (followingMode){ TPos u = MOVE(we == PLAYER_1 ? p1 : p2, getOpositeDirection(history.back())) != BLOCK_EMPTY; if (GET_BLOCK(boardData, u)) followingMode = false; } if (followingMode) { assert(history.size() % 2 == 1); for (unsigned int i = 0; i < history.size() - 1; i = i + 2){ if (history[i] != getOpositeDirection(history[i + 1])) { followingMode = false; break; } } } else{ followingMode = false; } pair<TMove, int> re = searcher.optimalMove(boardData, p1, p2, next, history); if (we == PLAYER_2) re.second = -re.second; if (!followingMode || re.first == getOpositeDirection(history.back())) { result = re.first; } else { if (re.second >= 0) result = re.first; else { result = getOpositeDirection(history.back()); cout << "\t===FOLLOWING ENEMY===\n"; } } } cout << "We take " << timer->getTimeInMs() << " ms\n"; return result; }
void GenerateAllCaps(const S_BOARD *pos, S_MOVELIST *list) { int pce = EMPTY; int side = pos->side; int sq = 0, t_sq = 0; int pceNum = 0; int dir = 0; int index = 0; int pceIndex = 0; ASSERT(CheckBoard(pos)); list->count = 0; if(side == WHITE) { for(pceNum = 0; pceNum < pos->pceNum[wP]; ++pceNum) { sq = pos->pList[wP][pceNum]; ASSERT(SqOnBoard(sq)); if(!SQOFFBOARD(sq + 9) && PieceCol[pos->pieces[sq + 9]] == BLACK) { AddWhitePawnCapMove(pos, sq, sq + 9, pos->pieces[sq + 9], list); } if(!SQOFFBOARD(sq + 11) && PieceCol[pos->pieces[sq + 11]] == BLACK) { AddWhitePawnCapMove(pos, sq, sq + 11, pos->pieces[sq + 11], list); } if(pos->enPas != NO_SQ) { if(sq + 9 == pos->enPas) { AddEnPassantMove(pos, MOVE(sq, sq + 9, EMPTY, EMPTY, MFLAGEP), list); } if(sq + 11 == pos->enPas) { AddEnPassantMove(pos, MOVE(sq, sq + 11, EMPTY, EMPTY, MFLAGEP), list); } } } } else { for(pceNum = 0; pceNum < pos->pceNum[bP]; ++pceNum) { sq = pos->pList[bP][pceNum]; ASSERT(SqOnBoard(sq)); if(!SQOFFBOARD(sq - 9) && PieceCol[pos->pieces[sq - 9]] == WHITE) { AddBlackPawnCapMove(pos, sq, sq - 9, pos->pieces[sq - 9], list); } if(!SQOFFBOARD(sq - 11) && PieceCol[pos->pieces[sq - 11]] == WHITE) { AddBlackPawnCapMove(pos, sq, sq - 11, pos->pieces[sq - 11], list); } if(pos->enPas != NO_SQ) { if(sq - 9 == pos->enPas) { AddEnPassantMove(pos, MOVE(sq, sq - 9, EMPTY, EMPTY, MFLAGEP), list); } if(sq - 11 == pos->enPas) { AddEnPassantMove(pos, MOVE(sq, sq - 11, EMPTY, EMPTY, MFLAGEP), list); } } } } pceIndex = LoopSlideIndex[side]; pce = LoopSlidePce[pceIndex++]; while(pce != 0) { ASSERT(PieceValid(pce)); for(pceNum = 0; pceNum < pos->pceNum[pce]; ++pceNum) { sq = pos->pList[pce][pceNum]; ASSERT(SqOnBoard(sq)); for(index = 0; index < NumDir[pce]; ++index) { dir = PceDir[pce][index]; t_sq = sq + dir; while(!SQOFFBOARD(t_sq)) { if(pos->pieces[t_sq] != EMPTY) { if(PieceCol[pos->pieces[t_sq]] == (side ^ 1)) { AddCaptureMove(pos, MOVE(sq, t_sq, pos->pieces[t_sq], EMPTY, 0), list); } break; } t_sq += dir; } } } pce = LoopSlidePce[pceIndex++]; } pceIndex = LoopNonSlideIndex[side]; pce = LoopNonSlidePce[pceIndex++]; while(pce != 0) { ASSERT(PieceValid(pce)); for(pceNum = 0; pceNum < pos->pceNum[pce]; ++pceNum) { sq = pos->pList[pce][pceNum]; ASSERT(SqOnBoard(sq)); for(index = 0; index < NumDir[pce]; ++index) { dir = PceDir[pce][index]; t_sq = sq + dir; if(SQOFFBOARD(t_sq)) continue; if(pos->pieces[t_sq] != EMPTY) { if(PieceCol[pos->pieces[t_sq]] == (side ^ 1)) { AddCaptureMove(pos, MOVE(sq, t_sq, pos->pieces[t_sq], EMPTY, 0), list); } continue; } } } pce = LoopNonSlidePce[pceIndex++]; } }
void DisassembleToken(DacpObjectData& tokenArray, DWORD token) { switch (TypeFromToken(token)) { default: printf("<unknown token type (token=%08x)>", token); break; case mdtTypeDef: { DWORD_PTR runtimeTypeHandle = GetObj(tokenArray, RidFromToken(token)); DWORD_PTR runtimeType = NULL; MOVE(runtimeType, runtimeTypeHandle + sizeof(DWORD_PTR)); int offset = GetObjFieldOffset(runtimeType, W("m_handle")); DWORD_PTR methodTable = NULL; MOVE(methodTable, runtimeType + offset); if (NameForMT_s(methodTable, g_mdName,mdNameLen)) { printf("%x \"%S\"", token, g_mdName); } else { printf("<invalid MethodTable>"); } } break; case mdtSignature: case mdtTypeRef: { printf ("%x (%p)", token, SOS_PTR(GetObj(tokenArray, RidFromToken(token)))); } break; case mdtFieldDef: { printf ("%x (%p)", token, SOS_PTR(GetObj(tokenArray, RidFromToken(token)))); } break; case mdtMethodDef: { CLRDATA_ADDRESS runtimeMethodHandle = GetObj(tokenArray, RidFromToken(token)); int offset = GetObjFieldOffset(runtimeMethodHandle, W("m_value")); TADDR runtimeMethodInfo = NULL; MOVE(runtimeMethodInfo, runtimeMethodHandle+offset); offset = GetObjFieldOffset(runtimeMethodInfo, W("m_handle")); TADDR methodDesc = NULL; MOVE(methodDesc, runtimeMethodInfo+offset); NameForMD_s((DWORD_PTR)methodDesc, g_mdName, mdNameLen); printf ("%x %S", token, g_mdName); } break; case mdtMemberRef: { printf ("%x (%p)", token, SOS_PTR(GetObj(tokenArray, RidFromToken(token)))); } break; case mdtString: { DWORD_PTR strObj = GetObj(tokenArray, RidFromToken(token)); printf ("%x \"", token); StringObjectContent (strObj, FALSE, 40); printf ("\""); } break; } }
static inline unsigned char *advance(unsigned char *pc) { if (SEND(pc)) { int count = 3; if (VAL_IS_FLOAT(SEND_ARG1(pc))) count += sizeof(meld_float); else if (VAL_IS_INT(SEND_ARG1(pc))) count += sizeof(meld_int); else if (VAL_IS_FIELD(SEND_ARG1(pc))) count += 2; else if (VAL_IS_REVERSE(SEND_ARG1(pc))) count += 2; else { assert(0); exit(1); } return pc+count; } else if(OP(pc)) { int count = 3; /* check v1 */ if (VAL_IS_FLOAT(OP_ARG1(pc))) count += sizeof(meld_float); else if (VAL_IS_INT(OP_ARG1(pc))) count += sizeof(meld_int); else if (VAL_IS_FIELD(OP_ARG1(pc))) count += 2; else if (VAL_IS_REVERSE(OP_ARG1(pc))) count += 2; else if (VAL_IS_REG(OP_ARG1(pc))) {} /* do nothing */ else { assert(0); exit(1); } /* check v2 */ if (VAL_IS_FLOAT(OP_ARG2(pc))) count += sizeof(meld_float); else if (VAL_IS_INT(OP_ARG2(pc))) count += sizeof(meld_int); else if (VAL_IS_FIELD(OP_ARG2(pc))) count += 2; else if (VAL_IS_REVERSE(OP_ARG2(pc))) count += 2; else if (VAL_IS_REG(OP_ARG2(pc))) {} /* do nothing */ else { printf("got value %c\n", OP_ARG2(pc)); assert(0); exit(1); } return pc+count; } else if(MOVE(pc)) { int count = 2; /* move src */ if (VAL_IS_FLOAT(MOVE_SRC(pc))) count += sizeof(meld_float); else if (VAL_IS_INT(MOVE_SRC(pc))) count += sizeof(meld_int); else if (VAL_IS_FIELD(MOVE_SRC(pc))) count += 2; else if (VAL_IS_REVERSE(MOVE_SRC(pc))) count += 2; else if (VAL_IS_TUPLE(MOVE_SRC(pc))) {} /* nothing */ else if(VAL_IS_REG(MOVE_SRC(pc))) {} /* nothing */ else if(VAL_IS_HOST(MOVE_SRC(pc))) {} /* nothing */ else { assert(0); exit(1); } /* move dst */ if (VAL_IS_FLOAT(MOVE_DST(pc))) count += sizeof(meld_float); else if (VAL_IS_INT(MOVE_DST(pc))) count += sizeof(meld_int); else if (VAL_IS_FIELD(MOVE_DST(pc))) count += 2; else if (VAL_IS_REVERSE(MOVE_DST(pc))) count += 2; else if (VAL_IS_REG(MOVE_DST(pc))) {} /* nothing */ else { assert(0); exit(1); } return pc+count; } else if(ITER(pc)) { pc += ITER_BASE; if(ITER_MATCH_NONE(pc)) pc += 2; else { unsigned char *old; while(1) { old = pc; if (VAL_IS_FLOAT(ITER_MATCH_VAL(pc))) pc += sizeof(meld_float); else if (VAL_IS_INT(ITER_MATCH_VAL(pc))) pc += sizeof(meld_int); else if (VAL_IS_FIELD(ITER_MATCH_VAL(pc))) pc += 2; else if (VAL_IS_REVERSE(ITER_MATCH_VAL(pc))) pc += 2; else { assert(0); exit(1); } pc += 2; if(ITER_MATCH_END(old)) break; } } return pc; } else if (ALLOC(pc)) { int count = 2; if (VAL_IS_INT(ALLOC_DST(pc))) count += sizeof(meld_int); else if (VAL_IS_FLOAT(ALLOC_DST(pc))) count += sizeof(meld_float); else if (VAL_IS_FIELD(ALLOC_DST(pc))) count += 2; else if (VAL_IS_REG(ALLOC_DST(pc))) {} /* nothing */ else if (VAL_IS_REVERSE(ALLOC_DST(pc))) { count += 2; assert(0); exit(1); } else { assert(0); exit(1); } return pc+count; } else if (CALL(pc)) { int numArgs = CALL_ARGS(pc); int i; for (i = 0, pc+=2; i < numArgs; i++, pc++) { if (VAL_IS_FLOAT(CALL_VAL(pc))) pc += sizeof(meld_float); else if (VAL_IS_INT(CALL_VAL(pc))) pc += sizeof(meld_int); else if (VAL_IS_FIELD(CALL_VAL(pc))) pc += 2; else if (VAL_IS_REVERSE(CALL_VAL(pc))) { pc += 2; assert(0); exit(1); } } return pc; } else if (IF(pc)) { return pc+IF_BASE; } else { return pc+1; } }
/* * * \brief Sine modulation of the time domain data of a subband. Performed in-place * */ static void sinMod (float *subband, HANDLE_SBR_QMF_FILTER_BANK qmfBank ) { int i, M; float wre, wim; float re1, im1, re2, im2; float accu1,accu2; COUNT_sub_start("sinMod"); INDIRECT(1); SHIFT(1); M = qmfBank->no_channels >> 1; PTR_INIT(6); /* pointers for subband[2 * i], subband[2 * M - 2 * i], qmfBank->sin_twiddle[i], qmfBank->cos_twiddle[i], qmfBank->sin_twiddle[M - 1 - i], qmfBank->cos_twiddle[M - 1 - i] */ MULT(1); /* M/2 */ LOOP(1); for (i = 0; i < M / 2; i++) { MOVE(4); re1 = subband[2 * i]; im2 = subband[2 * i + 1]; re2 = subband[2 * M - 2 - 2 * i]; im1 = subband[2 * M - 1 - 2 * i]; MOVE(2); wre = qmfBank->sin_twiddle[i]; wim = qmfBank->cos_twiddle[i]; MULT(1); MAC(1); accu1 = im1 * wim + re1 * wre; MULT(2); ADD(1); accu2 = im1 * wre - re1 * wim; MOVE(2); subband[2 * i + 1] = accu1; subband[2 * i] = accu2; MOVE(2); wre = qmfBank->sin_twiddle[M - 1 - i]; wim = qmfBank->cos_twiddle[M - 1 - i]; MULT(1); MAC(1); accu1 = im2 * wim + re2 * wre; MULT(2); ADD(1); accu2 = im2 * wre - re2 * wim; MOVE(2); subband[2 * M - 1 - 2 * i] = accu1; subband[2 * M - 2 - 2 * i] = accu2; } FUNC(2); sbrfft(subband, M); PTR_INIT(4); /* pointers for subband[2 * i], subband[2 * M - 2 * i], qmfBank->alt_sin_twiddle[i], qmfBank->sin_twiddle[M - 1 - i] */ MOVE(2); wim = qmfBank->alt_sin_twiddle[0]; wre = qmfBank->alt_sin_twiddle[M]; for (i = 0; i < M / 2; i++) { MOVE(4); re1 = subband[2 * i]; im1 = subband[2 * i + 1]; re2 = subband[2 * M - 2 - 2 * i]; im2 = subband[2 * M - 1 - 2 * i]; MULT(2); MAC(1); accu1 = -(re1 * wre + im1 * wim); MULT(2); ADD(1); accu2 = -(re1 * wim - im1 * wre); MOVE(2); subband[2 * M - 1 - 2 * i] = accu1; subband[2 * i] = accu2; MOVE(2); wim = qmfBank->alt_sin_twiddle[i + 1]; wre = qmfBank->alt_sin_twiddle[M - 1 - i]; MULT(2); MAC(1); accu1 = -(re2 * wim + im2 * wre); MULT(2); ADD(1); accu2 = -(re2 * wre - im2 * wim); MOVE(2); subband[2 * i + 1] = accu1; subband[2 * M - 2 - 2 * i] = accu2; } COUNT_sub_end(); }
static void inverseModulationLP (float *qmfReal, float *qmfReal2, HANDLE_SBR_QMF_FILTER_BANK synQmf ) { int i, L, M; float timeOut[2*NO_ACTUAL_SYNTHESIS_CHANNELS]; COUNT_sub_start("inverseModulationLP"); INDIRECT(1); L = synQmf->no_channels; MULT(1); STORE(1); M = L / 2; PTR_INIT(2); /* pointers for timeOut[], qmfReal[] */ INDIRECT(1); LOOP(1); for (i = 0; i < synQmf->usb; i++) { MOVE(1); timeOut[i + M] = qmfReal[i]; } INDIRECT(1); LOOP(1); for (i = synQmf->usb; i < L; i++) { MOVE(1); timeOut[i + M] = 0; } FUNC(3); dct2(timeOut+M, L, synQmf); MOVE(1); timeOut[3 * M] = 0; PTR_INIT(2); /* pointers for timeOut[i] timeOut[-i] */ LOOP(1); for (i = 1; i < M; i++) { MULT(1); STORE(1); timeOut[i + 3 * M] = - timeOut[3 * M - i]; } PTR_INIT(2); /* pointer for timeOut[i], timeOut[L-i] */ LOOP(1); for (i = 0; i < M; i++) { MOVE(1); timeOut[i] = timeOut[L - i]; } PTR_INIT(2); /* pointer for timeOut[], qmfReal[] */ LOOP(1); for (i = 0; i < L; i++) { MOVE(1); qmfReal[i] = timeOut[i]; } PTR_INIT(2); /* pointer for timeOut[], qmfReal2[] */ LOOP(1); for (i = 0; i < L; i++) { MOVE(1); qmfReal2[i] = timeOut[L+i]; } COUNT_sub_end(); }
void calcSfbPe(PE_CHANNEL_DATA *peChanData, const float *sfbEnergy, const float *sfbThreshold, const int sfbCnt, const int sfbPerGroup, const int maxSfbPerGroup) { int sfbGrp,sfb; float nLines; float ldThr, ldRatio; COUNT_sub_start("calcSfbPe"); INDIRECT(3); MOVE(3); peChanData->pe = 0.0f; peChanData->constPart = 0.0f; peChanData->nActiveLines = 0.0f; LOOP(1); for(sfbGrp = 0;sfbGrp < sfbCnt;sfbGrp+=sfbPerGroup){ PTR_INIT(8); /* pointers for sfbEnergy[] sfbThreshold[] peChanData->sfbLdEnergy[] peChanData->sfbNLines[] peChanData->sfbPe[] peChanData->sfbConstPart[] peChanData->sfbLdEnergy[] peChanData->sfbNActiveLines[] */ LOOP(1); for (sfb=0; sfb<maxSfbPerGroup; sfb++) { ADD(1); BRANCH(1); if (sfbEnergy[sfbGrp+sfb] > sfbThreshold[sfbGrp+sfb]) { TRANS(1); MULT(1); ldThr = (float)log(sfbThreshold[sfbGrp+sfb]) * LOG2_1; ADD(1); ldRatio = peChanData->sfbLdEnergy[sfbGrp+sfb] - ldThr; MOVE(1); nLines = peChanData->sfbNLines[sfbGrp+sfb]; ADD(1); BRANCH(1); if (ldRatio >= C1) { MULT(1); STORE(1); peChanData->sfbPe[sfbGrp+sfb] = nLines * ldRatio; MULT(1); STORE(1); peChanData->sfbConstPart[sfbGrp+sfb] = nLines*peChanData->sfbLdEnergy[sfbGrp+sfb]; } else { MULT(2); ADD(1); STORE(1); peChanData->sfbPe[sfbGrp+sfb] = nLines * (C2 + C3 * ldRatio); MULT(2); ADD(1); STORE(1); peChanData->sfbConstPart[sfbGrp+sfb] = nLines * (C2 + C3 * peChanData->sfbLdEnergy[sfbGrp+sfb]); MULT(1); nLines = nLines * C3; } MOVE(1); peChanData->sfbNActiveLines[sfbGrp+sfb] = nLines; } else { MOVE(3); peChanData->sfbPe[sfbGrp+sfb] = 0.0f; peChanData->sfbConstPart[sfbGrp+sfb] = 0.0f; peChanData->sfbNActiveLines[sfbGrp+sfb] = 0.0; } INDIRECT(3); ADD(3); STORE(3); peChanData->pe += peChanData->sfbPe[sfbGrp+sfb]; peChanData->constPart += peChanData->sfbConstPart[sfbGrp+sfb]; peChanData->nActiveLines += peChanData->sfbNActiveLines[sfbGrp+sfb]; } } COUNT_sub_end(); }
/* Perform dct type 4 */ static void dct4 (float *data, int L, HANDLE_SBR_QMF_FILTER_BANK qmfBank ) { int i, M, ld; float wim, wre; float re1, im1, re2, im2; struct dct4Twiddle *pTwiddle; const float cosPiBy8 = 0.92387953251129f; const float cosPi3By8 = 0.38268343236509f; MOVE(2); MOVE(1); i = 1; MULT(1); M = L / 2; MOVE(1); ld = -2; ADD(1); BRANCH(1); if (L > 2) { LOOP(1); while(i < L) { SHIFT(1); i <<= 1; ADD(1); ld++; } INDIRECT(1); PTR_INIT(1); pTwiddle = &qmfBank->pDct4Twiddle[ld]; MULT(1); /* M / 2 */ LOOP(1); PTR_INIT(6); /* pointers for data[2 * i], data[2 * M - 2 * i], pTwiddle->sin_twiddle[], pTwiddle->cos_twiddle[], pTwiddle->sin_twiddle[M - 1 - i], pTwiddle->cos_twiddle[M - 1 - i] */ for (i = 0; i < M / 2; i++) { MOVE(4); re1 = data[2 * i]; im2 = data[2 * i + 1]; re2 = data[2 * M - 2 - 2 * i]; im1 = data[2 * M - 1 - 2 * i]; MOVE(2); wim = pTwiddle->sin_twiddle[i]; wre = pTwiddle->cos_twiddle[i]; MULT(1); MAC(1); STORE(1); data[2 * i] = im1 * wim + re1 * wre; MULT(2); ADD(1); STORE(1); data[2 * i + 1] = im1 * wre - re1 * wim; MOVE(2); wim = pTwiddle->sin_twiddle[M - 1 - i]; wre = pTwiddle->cos_twiddle[M - 1 - i]; MULT(1); MAC(1); STORE(1); data[2 * M - 2 - 2 * i] = im2 * wim + re2 * wre; MULT(2); ADD(1); STORE(1); data[2 * M - 1 - 2 * i] = im2 * wre - re2 * wim; } ADD(1); BRANCH(1); if (M == 2) { MOVE(2); re1 = data[0]; im1 = data[1]; ADD(4); STORE(4); data[0] = re1 + data[2]; data[1] = im1 + data[3]; data[2] = re1 - data[2]; data[3] = im1 - data[3]; } else { FUNC(2); sbrfft(data,M); } INDIRECT(2); MOVE(2); wim = pTwiddle->alt_sin_twiddle[0]; wre = pTwiddle->alt_sin_twiddle[M]; PTR_INIT(4); /* pointers for data[2 * i], data[2 * M - 2 * i], pTwiddle->alt_sin_twiddle[i], pTwiddle->alt_sin_twiddle[M - 1 - i] */ LOOP(1); for (i = 0; i < M / 2; i++) { MOVE(4); re1 = data[2 * i]; im1 = data[2 * i + 1]; re2 = data[2 * M - 2 - 2 * i]; im2 = data[2 * M - 1 - 2 * i]; MULT(1); MAC(1); STORE(1); data[2 * i] = re1 * wre + im1 * wim; MULT(2); ADD(1); STORE(1); data[2 * M - 1 - 2 * i] = re1 * wim - im1 * wre; MOVE(2); wim = pTwiddle->alt_sin_twiddle[i + 1]; wre = pTwiddle->alt_sin_twiddle[M - 1 - i]; MULT(1); MAC(1); STORE(1); data[2 * M - 2 - 2 * i] = re2 * wim + im2 * wre; MULT(2); ADD(1); STORE(1); data[2 * i + 1] = re2 * wre - im2 * wim; } } else { /* 2-point transform */ MOVE(2); re1 = data[0]; re2 = data[1]; MULT(1); MAC(1); STORE(1); data[0] = re1 * cosPiBy8 + re2 * cosPi3By8; MULT(2); ADD(1); STORE(1); data[1] = re1 * cosPi3By8 - re2 * cosPiBy8; } }
void CShortBlock_FrequencyToTime(CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo, CAacDecoderChannelInfo *pAacDecoderChannelInfo, float outSamples[], const int stride) { int i; COverlapAddData *pOverlapAddData = &pAacDecoderStaticChannelInfo->OverlapAddData; const float *shortWindow = pAacDecoderStaticChannelInfo->pShortWindow[GetWindowShape(&pAacDecoderChannelInfo->IcsInfo)]; const float *shortWindowPrev = pAacDecoderStaticChannelInfo->pShortWindow[pOverlapAddData->WindowShape]; const float *longWindowPrev = pAacDecoderStaticChannelInfo->pLongWindow[pOverlapAddData->WindowShape]; float *pSpectralCoefficient = pAacDecoderChannelInfo->pSpectralCoefficient; FLC_sub_start("CShortBlock_FrequencyToTime"); INDIRECT(5); PTR_INIT(5); /* counting previous operations */ /* Inverse MDCT */ PTR_INIT(1); /* pSpectralCoefficient[i*Size02] */ LOOP(1); for (i=0; i<MaximumWindows; i++) { FUNC(1); CShortBlock_InverseTransform(&pSpectralCoefficient[i*Size02]); } /* Overlap & Add */ INDIRECT(1); BRANCH(2); switch(pOverlapAddData->WindowSequence) { case EightShortSequence: case LongStartSequence: PTR_INIT(2); /* outSamples[stride*i] pOverlapAddData->pOverlapBuffer[i] */ LOOP(1); for (i=0; i<Size07; i++) { MOVE(1); outSamples[stride*i] = pOverlapAddData->pOverlapBuffer[i]; } INDIRECT(2); PTR_INIT(3); FUNC(6); Lap1(&pSpectralCoefficient[0],&pOverlapAddData->pOverlapBuffer[Size07], &outSamples[stride*Size07],shortWindowPrev,Size01,stride); INDIRECT(1); PTR_INIT(3); FUNC(6); Lap1(&pSpectralCoefficient[Size02],&pSpectralCoefficient[0], &outSamples[stride*Size09],shortWindow,Size01,stride); INDIRECT(1); PTR_INIT(3); FUNC(6); Lap1(&pSpectralCoefficient[Size04],&pSpectralCoefficient[Size02], &outSamples[stride*Size11],shortWindow,Size01,stride); INDIRECT(1); PTR_INIT(3); FUNC(6); Lap1(&pSpectralCoefficient[Size06],&pSpectralCoefficient[Size04], &outSamples[stride*Size13],shortWindow,Size01,stride); PTR_INIT(3); FUNC(6); Lap2(&pSpectralCoefficient[Size08],&pSpectralCoefficient[Size06], pOverlapAddData->pOverlapBuffer,shortWindow,Size01,1); PTR_INIT(3); /* outSamples[stride*(Size15+i)] pOverlapAddData->pOverlapBuffer[i] pOverlapAddData->pOverlapBuffer[i+Size01] */ LOOP(1); for (i=0; i<Size01; i++) { MOVE(2); outSamples[stride*(Size15+i)] = pOverlapAddData->pOverlapBuffer[i]; pOverlapAddData->pOverlapBuffer[i] = pOverlapAddData->pOverlapBuffer[i+Size01]; } break; case OnlyLongSequence: case LongStopSequence: INDIRECT(1); FUNC(6); LongShortLapIllegal(pSpectralCoefficient,pOverlapAddData->pOverlapBuffer,outSamples, shortWindow,shortWindowPrev,longWindowPrev,stride); break; } PTR_INIT(3); FUNC(6); Lap2(&pSpectralCoefficient[Size10],&pSpectralCoefficient[Size08], &pOverlapAddData->pOverlapBuffer[Size01],shortWindow,Size01,1); PTR_INIT(3); FUNC(6); Lap2(&pSpectralCoefficient[Size12],&pSpectralCoefficient[Size10], &pOverlapAddData->pOverlapBuffer[Size03],shortWindow,Size01,1); PTR_INIT(3); FUNC(6); Lap2(&pSpectralCoefficient[Size14],&pSpectralCoefficient[Size12], &pOverlapAddData->pOverlapBuffer[Size05],shortWindow,Size01,1); PTR_INIT(2); /* pOverlapAddData->pOverlapBuffer[i+Size07] pSpectralCoefficient[Size14+i] */ LOOP(1); for (i=0; i<Size01; i++) { MOVE(1); pOverlapAddData->pOverlapBuffer[i+Size07] = pSpectralCoefficient[Size14+i]; } INDIRECT(1); PTR_INIT(1); FUNC(1); FUNC(1); STORE(2); pOverlapAddData->WindowShape = GetWindowShape(&pAacDecoderChannelInfo->IcsInfo); pOverlapAddData->WindowSequence = GetWindowSequence(&pAacDecoderChannelInfo->IcsInfo); FLC_sub_end(); }
int CShortBlock_ReadSectionData(HANDLE_BIT_BUF bs, CAacDecoderChannelInfo *pAacDecoderChannelInfo) { int top; int band; int group; char sect_cb; int sect_len; int sect_len_incr; int sect_esc_val = (1 << 3) - 1 ; char *pCodeBook = pAacDecoderChannelInfo->pCodeBook; int ErrorStatus = AAC_DEC_OK; FLC_sub_start("CShortBlock_ReadSectionData"); INDIRECT(1); PTR_INIT(1); MOVE(2); /* counting previous operation */ INDIRECT(1); PTR_INIT(1); FUNC(1); LOOP(1); for (group=0; group<GetWindowGroups(&pAacDecoderChannelInfo->IcsInfo); group++) { PTR_INIT(1); /* pCodeBook[] */ FUNC(1); LOOP(1); for (band=0; band<GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->IcsInfo); ) { MOVE(1); sect_len = 0 ; FUNC(2); sect_cb = (char) GetBits(bs,4) ; FUNC(2); sect_len_incr = GetBits(bs,3); LOOP(1); while (sect_len_incr == sect_esc_val) { ADD(1); sect_len += sect_esc_val; FUNC(2); sect_len_incr = GetBits(bs,3); } ADD(1); sect_len += sect_len_incr; ADD(1); top = band + sect_len; MULT(1); ADD(2); BRANCH(1); if (top + group*MaximumScaleFactorBandsShort > (MAX_WINDOWS * MAX_SFB_SHORT)) { FLC_sub_end(); return (AAC_DEC_DECODE_FRAME_ERROR); } LOOP(1); for (; band < top; band++) { MOVE(1); pCodeBook[group*MaximumScaleFactorBandsShort+band] = sect_cb; ADD(1); BRANCH(1); if (pCodeBook[group*MaximumScaleFactorBandsShort+band] == BOOKSCL) { FLC_sub_end(); return (AAC_DEC_INVALID_CODE_BOOK); } } } PTR_INIT(1); /* pCodeBook[] */ FUNC(1); LOOP(1); for ( ; band < GetScaleFactorBandsTotal(&pAacDecoderChannelInfo->IcsInfo); band++) { MOVE(1); pCodeBook[group*MaximumScaleFactorBandsShort+band] = ZERO_HCB; } } FLC_sub_end(); return (ErrorStatus); }
int CShortBlock_ReadSpectralData(HANDLE_BIT_BUF bs, CAacDecoderChannelInfo *pAacDecoderChannelInfo) { int i,index,step; int window,group,groupwin,groupoffset,band; int scfExp,scfMod; int *QuantizedCoef; char *pCodeBook = pAacDecoderChannelInfo->pCodeBook; short *pScaleFactor = pAacDecoderChannelInfo->pScaleFactor; float *pSpectralCoefficient = pAacDecoderChannelInfo->pSpectralCoefficient; const short *BandOffsets = GetScaleFactorBandOffsets(&pAacDecoderChannelInfo->IcsInfo); const CodeBookDescription *hcb; FLC_sub_start("CShortBlock_ReadSpectralData"); QuantizedCoef = (int*)pSpectralCoefficient; PTR_INIT(5); INDIRECT(4); FUNC(1); /* counting previous operations */ LOOP(1); for (window=0; window < MaximumWindows; window++) { PTR_INIT(1); /* pointer for QuantizedCoef[] */ LOOP(1); for (index=0; index < MaximumBinsShort; index++) { MOVE(1); QuantizedCoef[window*MaximumBinsShort+index] = 0; } } MOVE(1); groupoffset = 0; INDIRECT(1); FUNC(1); LOOP(1); for (group=0; group < GetWindowGroups(&pAacDecoderChannelInfo->IcsInfo); group++) { PTR_INIT(1); /* pointer for pCodeBook[] */ INDIRECT(1); FUNC(1); LOOP(1); for (band=0; band < GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->IcsInfo); band++) { PTR_INIT(1); hcb = &HuffmanCodeBooks[pCodeBook[group*MaximumScaleFactorBandsShort+band]]; INDIRECT(1); FUNC(1); LOOP(1); for (groupwin=0; groupwin < GetWindowGroupLength(&pAacDecoderChannelInfo->IcsInfo,group); groupwin++) { ADD(1); window = groupoffset + groupwin; ADD(4); LOGIC(3); BRANCH(1); if ( (pCodeBook[group*MaximumScaleFactorBandsShort+band] == ZERO_HCB) ||(pCodeBook[group*MaximumScaleFactorBandsShort+band] == INTENSITY_HCB) ||(pCodeBook[group*MaximumScaleFactorBandsShort+band] == INTENSITY_HCB2) ||(pCodeBook[group*MaximumScaleFactorBandsShort+band] == NOISE_HCB)) continue; MOVE(1); step = 0 ; PTR_INIT(2); /* pointer for BandOffsets[], QuantizedCoef[] */ LOOP(1); for (index=BandOffsets[band]; index < BandOffsets[band+1]; index+=step) { INDIRECT(1); FUNC(2); PTR_INIT(1); FUNC(3); step = CBlock_UnpackIndex(CBlock_DecodeHuffmanWord(bs,hcb->CodeBook),&QuantizedCoef[window*MaximumBinsShort+index],hcb); INDIRECT(1); BRANCH(1); if (hcb->Offset == 0) { PTR_INIT(1); /* pointer for QuantizedCoef[] */ LOOP(1); for (i=0; i < step; i++) { BRANCH(1); if (QuantizedCoef[window*MaximumBinsShort+index+i]) { FUNC(2); if (GetBits(bs,1)) /* sign bit */ { MULT(1); STORE(1); QuantizedCoef [window*MaximumBinsShort+index+i] = -QuantizedCoef [window*MaximumBinsShort+index+i]; } } } } ADD(1); BRANCH(1); if (pCodeBook[group*MaximumScaleFactorBandsShort+band] == ESCBOOK) { FUNC(2); STORE(1); QuantizedCoef[window*MaximumBinsShort+index] = CBlock_GetEscape(bs,QuantizedCoef[window*MaximumBinsShort+index]); FUNC(2); STORE(1); QuantizedCoef[window*MaximumBinsShort+index+1] = CBlock_GetEscape(bs,QuantizedCoef[window*MaximumBinsShort+index+1]); FUNC(1); FUNC(1); ADD(2); LOGIC(1); BRANCH(1); if (abs(QuantizedCoef[window*MaximumBinsShort+index]) > MAX_QUANTIZED_VALUE || abs(QuantizedCoef[window*MaximumBinsShort+index+1]) > MAX_QUANTIZED_VALUE) { FLC_sub_end(); return (AAC_DEC_DECODE_FRAME_ERROR); } } } } } INDIRECT(1); ADD(1); groupoffset += GetWindowGroupLength(&pAacDecoderChannelInfo->IcsInfo,group); } INDIRECT(1); FUNC(1); LOOP(1); for (window=0, group=0; group < GetWindowGroups(&pAacDecoderChannelInfo->IcsInfo); group++) { INDIRECT(1); FUNC(1); LOOP(1); for (groupwin=0; groupwin < GetWindowGroupLength(&pAacDecoderChannelInfo->IcsInfo,group); groupwin++, window++) { MOVE(1); index = 0; PTR_INIT(2); /* pointer for BandOffsets[], pScaleFactor */ INDIRECT(1); FUNC(1); LOOP(1) ; /* quantize & apply scalefactors */ for (band=0; band < GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->IcsInfo); band++) { /* scalefactor exponents and scalefactor mantissa for current band */ SHIFT(1); scfExp = pScaleFactor[group*MaximumScaleFactorBandsShort+band] >> 2; LOGIC(1); scfMod = pScaleFactor[group*MaximumScaleFactorBandsShort+band] & 3; PTR_INIT(2); /* pointer for QuantizedCoef[], pSpectralCoefficient */ LOOP(1); for (index=BandOffsets[band]; index < BandOffsets[band+1] ;index++) { ADD(1); FUNC(3); STORE(1); pSpectralCoefficient[window*MaximumBinsShort+index] = CBlock_Quantize(QuantizedCoef[window*MaximumBinsShort+index],scfMod,scfExp-6); } } PTR_INIT(1); /* pointer for pSpectralCoefficient */ LOOP(1); for (; index < MaximumBinsShort; index++) { MOVE(1); pSpectralCoefficient[window*MaximumBinsShort+index] = 0.0; } } } FLC_sub_end(); return (AAC_DEC_OK); }
void CShortBlock_ReadScaleFactorData(HANDLE_BIT_BUF bs, CAacDecoderChannelInfo *pAacDecoderChannelInfo, unsigned char global_gain) { int temp; int band; int group; int position = 0; int factor = global_gain; char *pCodeBook = pAacDecoderChannelInfo->pCodeBook; short *pScaleFactor = pAacDecoderChannelInfo->pScaleFactor; const CodeBookDescription *hcb = &HuffmanCodeBooks[BOOKSCL]; FLC_sub_start("CShortBlock_ReadScaleFactorData"); INDIRECT(3); PTR_INIT(3); MOVE(2); /* counting previous operations */ INDIRECT(1); PTR_INIT(1); FUNC(1); LOOP(1); for (group=0; group < GetWindowGroups(&pAacDecoderChannelInfo->IcsInfo); group++) { PTR_INIT(2); /* pCodeBook[] pScaleFactor[] */ for (band=0; band < GetScaleFactorBandsTransmitted(&pAacDecoderChannelInfo->IcsInfo); band++) { BRANCH(2); switch (pCodeBook[group*MaximumScaleFactorBandsShort+band]) { case ZERO_HCB: /* zero book */ MOVE(1); pScaleFactor[group*MaximumScaleFactorBandsShort+band] = 0; break; default: /* decode scale factor */ INDIRECT(1); FUNC(2); temp = CBlock_DecodeHuffmanWord(bs,hcb->CodeBook); ADD(2); factor += temp - 60; /* MIDFAC 1.5 dB */ ADD(1); STORE(1); pScaleFactor[group*MaximumScaleFactorBandsShort+band] = factor - 100; break; case INTENSITY_HCB: /* intensity steering */ case INTENSITY_HCB2: INDIRECT(1); FUNC(2); temp = CBlock_DecodeHuffmanWord(bs,hcb->CodeBook); ADD(2); position += temp - 60; ADD(1); STORE(1); pScaleFactor[group*MaximumScaleFactorBandsShort+band] = position - 100; break; case NOISE_HCB: /* PNS */ FUNC(5); CPns_Read(pAacDecoderChannelInfo, bs, hcb, global_gain, band, group); break; } } } FLC_sub_end(); }
TMove CMyAI::newTurn() { // update board first if (p_ai->GetBlock(p_ai->GetMyPosition()) == BLOCK_PLAYER_1){ we = PLAYER_1; p1 = p_ai->GetMyPosition().x + p_ai->GetMyPosition().y*MAP_SIZE; p2 = p_ai->GetEnemyPosition().x + p_ai->GetEnemyPosition().y*MAP_SIZE; next = p_ai->IsMyTurn() ? PLAYER_1 : PLAYER_2; } else { we = PLAYER_2; p2 = p_ai->GetMyPosition().x + p_ai->GetMyPosition().y*MAP_SIZE; p1 = p_ai->GetEnemyPosition().x + p_ai->GetEnemyPosition().y*MAP_SIZE; next = p_ai->IsMyTurn() ? PLAYER_2 : PLAYER_1; } auto newBoard = p_ai->GetBoard(); // update newBoard to boardData and players' positions for (int i = 0; i < BOARD_SIZE; i++){ boardData[i] = newBoard[i]; } if (!firstMoveIsOver) // assume this only run 1 { assert(boardData[0] == BLOCK_PLAYER_1 || boardData[120] == BLOCK_PLAYER_2); newGame(); } else{ // calculate history if (next == PLAYER_1) { for (int i = 1; i <= 4; i++){ if (MOVE(oP2, i) == p2) { history.push_back(i); break; } } } else { for (int i = 1; i <= 4; i++){ if (MOVE(oP1, i) == p1) { history.push_back(i); break; } } } } oP1 = p1; oP2 = p2; TMove m; if (we == next) { m = ourNewTurn(); if (m < 1 || m>4){ cout << "calculated move: " << (int)m << endl; system("pause"); } } else m = enemyNewTurn(); return m; }
void MoveGenerator::GenerateAllPawnMoves(Board *gameboard, MOVELIST *move_list) { side = gameboard->side_to_move; /* WHITE PAWN MOVES */ if (side == WHITE) { for (piece_number = 0; piece_number < gameboard->piece_number[WHITE_PAWN]; ++piece_number) { square = gameboard->piece_list[WHITE_PAWN][piece_number]; if (gameboard->pieces[square+10] == EMPTY) { AddWhitePawnMove(gameboard, square, square+10, move_list); if (rank_of[square] == RANK_2 && gameboard->pieces[square+20] == EMPTY) { AddQuietMove(gameboard, MOVE(square, (square+20), EMPTY, EMPTY, MOVEFLAGPAWNSTART), move_list); } } if(!SQUAREOFFBOARD(square + 9) && PieceColor[gameboard->pieces[square + 9]] == BLACK) { AddWhitePawnCapture(gameboard, square, square+9, gameboard->pieces[square + 9], move_list); } if(!SQUAREOFFBOARD(square + 11) && PieceColor[gameboard->pieces[square + 11]] == BLACK) { AddWhitePawnCapture(gameboard, square, square+11, gameboard->pieces[square + 11], move_list); } if(gameboard->en_passant_square != NO_SQUARE) { if(square + 9 == gameboard->en_passant_square) { AddEnPassantMove(gameboard, MOVE(square,square + 9,EMPTY,EMPTY,MOVEFLAGENPASSANT), move_list); } if(square + 11 == gameboard->en_passant_square) { AddEnPassantMove(gameboard, MOVE(square,square + 11,EMPTY,EMPTY,MOVEFLAGENPASSANT), move_list); } } } /* WHITE SIDE CASTLING */ if(gameboard->castle_permission & WHITE_KING_CASTLE) { if(gameboard->pieces[F1] == EMPTY && gameboard->pieces[G1] == EMPTY) { if(!IsSquareAttacked(E1,BLACK,gameboard) && !IsSquareAttacked(F1,BLACK,gameboard) ) { AddQuietMove(gameboard, MOVE(E1, G1, EMPTY, EMPTY, MOVEFLAGCASTLE), move_list); } } } if(gameboard->castle_permission & WHITE_QUEEN_CASTLE) { if(gameboard->pieces[D1] == EMPTY && gameboard->pieces[C1] == EMPTY && gameboard->pieces[B1] == EMPTY) { if(!IsSquareAttacked(E1,BLACK,gameboard) && !IsSquareAttacked(D1,BLACK,gameboard) ) { AddQuietMove(gameboard, MOVE(E1, C1, EMPTY, EMPTY, MOVEFLAGCASTLE), move_list); } } } } /* BLACK PAWN MOVES */ else { for(piece_number = 0; piece_number < gameboard->piece_number[BLACK_PAWN]; ++piece_number) { square = gameboard->piece_list[BLACK_PAWN][piece_number]; if(gameboard->pieces[square - 10] == EMPTY) { AddBlackPawnMove(gameboard, square, square-10, move_list); if(rank_of[square] == RANK_7 && gameboard->pieces[square - 20] == EMPTY) { AddQuietMove(gameboard, MOVE(square,(square-20),EMPTY,EMPTY,MOVEFLAGPAWNSTART),move_list); } } if(!SQUAREOFFBOARD(square - 9) && PieceColor[gameboard->pieces[square - 9]] == WHITE) { AddBlackPawnCapture(gameboard, square, square-9, gameboard->pieces[square - 9], move_list); } if(!SQUAREOFFBOARD(square - 11) && PieceColor[gameboard->pieces[square - 11]] == WHITE) { AddBlackPawnCapture(gameboard, square, square-11, gameboard->pieces[square - 11], move_list); } if(gameboard->en_passant_square != NO_SQUARE) { if(square - 9 == gameboard->en_passant_square) { AddEnPassantMove(gameboard, MOVE(square,square - 9,EMPTY,EMPTY,MOVEFLAGENPASSANT), move_list); } if(square - 11 == gameboard->en_passant_square) { AddEnPassantMove(gameboard, MOVE(square,square - 11,EMPTY,EMPTY,MOVEFLAGENPASSANT), move_list); } } } /* BLACK SIDE CASTLING */ if(gameboard->castle_permission & BLACK_KING_CASTLE) { if(gameboard->pieces[F8] == EMPTY && gameboard->pieces[G1] == EMPTY) { if(!IsSquareAttacked(E8,WHITE,gameboard) && !IsSquareAttacked(F8,WHITE,gameboard) ) { AddQuietMove(gameboard, MOVE(E8, G8, EMPTY, EMPTY, MOVEFLAGCASTLE), move_list); } } } if(gameboard->castle_permission & BLACK_QUEEN_CASTLE) { if(gameboard->pieces[D8] == EMPTY && gameboard->pieces[C1] == EMPTY && gameboard->pieces[B1] == EMPTY) { if(!IsSquareAttacked(E8,WHITE,gameboard) && !IsSquareAttacked(D8,WHITE,gameboard) ) { AddQuietMove(gameboard, MOVE(E8, C8, EMPTY, EMPTY, MOVEFLAGCASTLE), move_list); } } } } }
int InitElementBits(ELEMENT_BITS* elementBits, ELEMENT_INFO elInfo, int bitrateTot, int averageBitsTot, int staticBitsTot) { int error=0; COUNT_sub_start("InitElementBits"); MOVE(1); /* counting previous operation */ INDIRECT(1); BRANCH(2); switch(elInfo.nChannelsInEl) { case 1: MOVE(1); PTR_INIT(1); elementBits->chBitrate = bitrateTot; ADD(1); STORE(1); elementBits->averageBits = (averageBitsTot - staticBitsTot); MOVE(1); elementBits->maxBits = MAX_CHANNEL_BITS; ADD(1); STORE(1); elementBits->maxBitResBits = MAX_CHANNEL_BITS - averageBitsTot; LOGIC(1); ADD(1); STORE(1); elementBits->maxBitResBits -= (elementBits[0].maxBitResBits%8); MOVE(2); elementBits->bitResLevel = elementBits[0].maxBitResBits; elementBits->relativeBits = 1.0f; break; case 2: MULT(1); STORE(1); elementBits->chBitrate = (int)(bitrateTot*0.5f); ADD(1); STORE(1); elementBits->averageBits = (averageBitsTot - staticBitsTot); MULT(1); STORE(1); elementBits->maxBits = 2*MAX_CHANNEL_BITS; MULT(1); ADD(1); STORE(1); elementBits->maxBitResBits = 2*MAX_CHANNEL_BITS - averageBitsTot; LOGIC(1); ADD(1); STORE(1); elementBits->maxBitResBits -= (elementBits[0].maxBitResBits%8); MOVE(2); elementBits->bitResLevel = elementBits[0].maxBitResBits; elementBits->relativeBits = 1.0f; break; default: MOVE(2); error=1; } COUNT_sub_end(); return error; }
/* * * \brief Create QMF filter bank instance * * \return 0 if successful * */ int createCplxSynthesisQmfBank (HANDLE_SBR_QMF_FILTER_BANK h_sbrQmf, int noCols, int lsb, int usb, int chan, int bDownSample) { int L, qmfFilterStateSize; COUNT_sub_start("createCplxSynthesisQmfBank"); FUNC(2); LOOP(1); PTR_INIT(1); MOVE(1); STORE(sizeof(SBR_QMF_FILTER_BANK)); memset(h_sbrQmf,0,sizeof(SBR_QMF_FILTER_BANK)); BRANCH(1); if(bDownSample){ MOVE(2); L = NO_SYNTHESIS_CHANNELS_DOWN_SAMPLED; qmfFilterStateSize = QMF_FILTER_STATE_SYN_SIZE_DOWN_SAMPLED; } else{ MOVE(2); L = NO_SYNTHESIS_CHANNELS; qmfFilterStateSize = QMF_FILTER_STATE_SYN_SIZE; } PTR_INIT(1); h_sbrQmf->p_filter = sbr_qmf_64_640; MOVE(3); h_sbrQmf->no_channels = L; h_sbrQmf->qmf_filter_state_size = qmfFilterStateSize; h_sbrQmf->no_col = noCols; MOVE(1); h_sbrQmf->lsb = lsb; BRANCH(1); if(bDownSample){ MOVE(1); h_sbrQmf->usb = 32; } else{ MOVE(1); h_sbrQmf->usb = usb; } PTR_INIT(1); h_sbrQmf->pDct4Twiddle = dct4TwiddleTable; #ifndef LP_SBR_ONLY ADD(1); BRANCH(1); if(L == 32){ PTR_INIT(5); h_sbrQmf->cos_twiddle = sbr_cos_twiddle_L32; h_sbrQmf->sin_twiddle = sbr_sin_twiddle_L32; h_sbrQmf->alt_sin_twiddle = sbr_alt_sin_twiddle_L32; h_sbrQmf->t_cos = sbr_cos_twiddle_ds_L32; h_sbrQmf->t_sin = sbr_sin_twiddle_ds_L32; } else{ PTR_INIT(3); h_sbrQmf->cos_twiddle = sbr_cos_twiddle_L64; h_sbrQmf->sin_twiddle = sbr_sin_twiddle_L64; h_sbrQmf->alt_sin_twiddle = sbr_alt_sin_twiddle_L64; } #endif PTR_INIT(1); h_sbrQmf->FilterStatesSyn = &sbr_QmfStatesSynthesis[chan*qmfFilterStateSize]; FUNC(2); LOOP(1); PTR_INIT(1); MOVE(1); STORE(qmfFilterStateSize); memset(h_sbrQmf->FilterStatesSyn,0,qmfFilterStateSize*sizeof(float)); COUNT_sub_end(); return 0; }
void SplineResample(HANDLE_SPLINE_RESAMPLER hr, float* ioBuffer, int inSamples, int* outSamples, int ch) { int i, k, samplesOut, outIndex = 0; float alpha, alpha_2, alpha_3, coeff, accu; float *pos; int inIndex=0; float tmpOutSamples[MAX_ORDER+1]; int numTmpOutSamples = 0; COUNT_sub_start("Resample"); MOVE(3); /* counting previous operations */ PTR_INIT(10); /* hr->position[ch] hr->distance[ch] hr->quotient hr->remainder hr->L hr->invL hr->iirFilterCoeff_a hr->iirFilterCoeff_b tmpOutSamples[] ioBuffer[] */ /* special treatment for the first output samples: may need oldSamples */ LOOP(1); while (hr->position[ch] < 3){ MULT(3); alpha = hr->invL * hr->distance[ch]; alpha_2 = alpha * alpha; alpha_3 = alpha * alpha_2; ADD(2); MULT(1); MAC(1); coeff = (__1_6 * (1.0f - alpha_3) + 0.5f * (alpha_2 - alpha)); ADD(1); BRANCH(1); if (hr->position[ch] >= 3) { INDIRECT(1); MULT(1); accu = ioBuffer[hr->position[ch]-3] * coeff; } else { INDIRECT(1); MULT(1); accu = hr->oldSamples[hr->position[ch]][ch] * coeff; } MULT(1); ADD(2); coeff = (0.5f * alpha_3 - alpha_2 + __2_3); ADD(1); BRANCH(1); if (hr->position[ch] >= 2) { INDIRECT(1); MAC(1); accu += ioBuffer[hr->position[ch]-2] * coeff; } else { INDIRECT(1); MAC(1); accu += hr->oldSamples[hr->position[ch]+1][ch] * coeff; } ADD(3); MULT(1); coeff = (0.5f * (-alpha_3 + alpha_2 + alpha) + __1_6); ADD(1); BRANCH(1); if (hr->position[ch] >= 1) { INDIRECT(1); MAC(1); accu += ioBuffer[hr->position[ch]-1] * coeff; } else { INDIRECT(1); MAC(1); accu += hr->oldSamples[hr->position[ch]+2][ch] * coeff; } MULT(1); coeff = (__1_6 * alpha_3); MAC(1); accu += ioBuffer[hr->position[ch]] * coeff; MOVE(1); tmpOutSamples[numTmpOutSamples++] = accu; /* Update variables */ ADD(2); hr->position[ch] += hr->quotient; hr->distance[ch] += hr->remainder; ADD(1); BRANCH(1); if(hr->distance[ch] >= hr->L) { ADD(2); hr->distance[ch] -= hr->L; hr->position[ch] += 1; } } ADD(1); inIndex = hr->position[ch] - 3; assert (inIndex >=0); /* now we have to work up input buffer samples such long that we can start writing the output samples ... */ LOOP(1); while(numTmpOutSamples) { MULT(3); alpha = hr->invL * hr->distance[ch]; alpha_2 = alpha * alpha; alpha_3 = alpha * alpha_2; PTR_INIT(1); pos = &ioBuffer[inIndex]; ADD(2); MULT(1); MAC(1); coeff = (__1_6 * (1.0f - alpha_3) + 0.5f * (alpha_2 - alpha)); MULT(1); accu = *pos++ * coeff; ADD(2); MULT(1); coeff = (0.5f * alpha_3 - alpha_2 + __2_3); MAC(1); accu += *pos++ * coeff; ADD(3); MULT(1); coeff = (0.5f * (-alpha_3 + alpha_2 + alpha) + __1_6); MAC(1); accu += *pos++ * coeff; MULT(1); coeff = (__1_6 * alpha_3); MAC(1); accu += *pos++ * coeff; MOVE(1); tmpOutSamples[numTmpOutSamples++] = accu; assert (numTmpOutSamples <= MAX_ORDER+1); /* Update variables */ ADD(2); inIndex += hr->quotient; hr->distance[ch] += hr->remainder; ADD(1); BRANCH(1); if(hr->distance[ch] >= hr->L) { ADD(2); hr->distance[ch] -= hr->L; inIndex += 1; } /* write as many output samples as possible */ ADD(2); BRANCH(1); MOVE(1); samplesOut = min( (inIndex-outIndex), numTmpOutSamples ); PTR_INIT(1); /* tmpOutSamples[] */ LOOP(1); for ( i=0; i<samplesOut; i++ ) { MOVE(1); ioBuffer[outIndex++] = tmpOutSamples[i]; } PTR_INIT(1); /* tmpOutSamples[] */ ADD(1); LOOP(1); for ( k=0; k<numTmpOutSamples-samplesOut; k++) { MOVE(1); tmpOutSamples[k] = tmpOutSamples[samplesOut+k]; } ADD(1); numTmpOutSamples -= samplesOut; } /* now we can work directly on the i/o buffer */ ADD(1); LOOP(1); while(inIndex < inSamples - 3) { MULT(3); alpha = hr->invL * hr->distance[ch]; alpha_2 = alpha * alpha; alpha_3 = alpha * alpha_2; PTR_INIT(1); pos = &ioBuffer[inIndex]; ADD(2); MULT(1); MAC(1); coeff = (__1_6 * (1.0f - alpha_3) + 0.5f * (alpha_2 - alpha)); MULT(1); accu = *pos++ * coeff; MULT(1); ADD(2); coeff = (0.5f * alpha_3 - alpha_2 + __2_3); MAC(1); accu += *pos++ * coeff; MULT(1); ADD(3); coeff = (0.5f * (-alpha_3 + alpha_2 + alpha) + __1_6); MAC(1); accu += *pos++ * coeff; MULT(1); coeff = (__1_6 * alpha_3); MAC(1); accu += *pos++ * coeff; /* Update variables */ ADD(2); inIndex += hr->quotient; hr->distance[ch] += hr->remainder; ADD(1); BRANCH(1); if(hr->distance[ch] >= hr->L) { ADD(2); hr->distance[ch] -= hr->L; inIndex += 1; } assert(outIndex < inIndex); /* make sure that we can work inplace */ MOVE(1); ioBuffer[outIndex++] = accu; assert(outIndex <= inSamples); } MOVE(1); *outSamples = outIndex; ADD(2); STORE(1); hr->position[ch] = inIndex - (inSamples-3); if (hr->position[ch] < 0) { assert (hr->position[ch] >= 0); } /* update buffers */ ADD(1); BRANCH(1); if (inSamples > 3) { PTR_INIT(2); /* hr->oldSamples[][] ioBuffer[] */ LOOP(1); for (i=0; i<3; i++) { MOVE(1); hr->oldSamples[i][ch] = ioBuffer[inSamples-3+i]; } } /* Do the IIR filtering*/ PTR_INIT(1); /* ioBuffer[] */ MULT(2); ADD(1); STORE(1); ioBuffer[0] = hr->iirFilterCoeff_b*ioBuffer[0] - hr->oldSampleFilter[ch]*hr->iirFilterCoeff_a; LOOP(1); for(i=1; i < outIndex; i++){ MULT(2); ADD(1); STORE(1); ioBuffer[i] = hr->iirFilterCoeff_b*ioBuffer[i] - ioBuffer[i-1]*hr->iirFilterCoeff_a; } MOVE(1); hr->oldSampleFilter[ch] = ioBuffer[outIndex - 1]; COUNT_sub_end(); }
/* Perform dct type 2 */ static void dct2 (float *data, int L, HANDLE_SBR_QMF_FILTER_BANK qmfBank ) { int i, M, N; float s1, s2, s3, s4; float temp[16]; const float sqrtHalf = 0.70710678118655f; MOVE(1); MULT(1); M = L / 2; MULT(1); N = L / 4; ADD(1); BRANCH(1); if (L > 2) { PTR_INIT(4); /* pointers for data[i], data[i + M], data[M-1 - i], data[L-1 - i] */ LOOP(1); for(i = 0; i < N; i++) { MOVE(4); s1 = data[i]; s2 = data[i + M]; s3 = data[M-1 - i]; s4 = data[L-1 - i]; ADD(4); STORE(4); data[i] = (s1 + s4); data[i + M] = (s1 - s4); data[M-1 - i] = (s3 + s2); data[L-1 - i] = (s3 - s2); } FUNC(3); dct2(data, M, qmfBank); FUNC(3); dct4(data + M, M, qmfBank); PTR_INIT(2); /* pointers for data[2*i + M], temp[i] */ LOOP(1); for(i = 0; i < N; i++) { MOVE(1); temp[i] = data[2*i + M]; } PTR_INIT(2); /* pointers for data[L - 2*i], data[M - i] */ LOOP(1); for(i = 1; i < M; i++) { MOVE(1); data[L - 2*i] = data[M - i]; } PTR_INIT(2); /* pointers for data[4*i - 1], data[M-1 + 2*i] */ LOOP(1); for(i = 1; i < N; i++) { MOVE(1); data[4*i - 1] = data[M-1 + 2*i]; } PTR_INIT(2); /* pointers for data[4*i + 1], temp[i] */ LOOP(1); for(i = 0; i < N; i++) { MOVE(1); data[4*i + 1] = temp[i]; } } else { /* 2-point transform */ MOVE(1); s1 = data[0]; ADD(1); STORE(1); data[0] = (s1 + data[1]); ADD(1); MAC(1); STORE(1); data[1] = ((s1 - data[1]) * sqrtHalf); } }
void CreateSplineResampler(HANDLE_SPLINE_RESAMPLER* hr, int Fin, int Fout) { int i; COUNT_sub_start("CreateResampler"); PTR_INIT(1); STORE(1); *hr = &splineResamplerInstance; INDIRECT(2); MOVE(2); (*hr)->L = Fout; (*hr)->M = Fin; INDIRECT(1); DIV(1); STORE(1); (*hr)->invL = 1.0f/Fout; INDIRECT(2); MOVE(2); (*hr)->distance[0] = 0; (*hr)->distance[1] = 0; INDIRECT(2); DIV(2); STORE(2); (*hr)->remainder = Fin % Fout; (*hr)->quotient = Fin / Fout; INDIRECT(2); MOVE(2); (*hr)->position[0] = 0; (*hr)->position[1] = 0; PTR_INIT(2); /* (*hr)->oldSamples[i][0] (*hr)->oldSamples[i][1] */ LOOP(1); for (i=0; i<MAX_ORDER; i++) { MOVE(2); (*hr)->oldSamples[i][0] = 0; (*hr)->oldSamples[i][1] = 0; } BRANCH(2); switch(Fin){ case 22050: BRANCH(2); switch(Fout){ case 16000: INDIRECT(2); PTR_INIT(2); (*hr)->iirFilterCoeff_a = a_22_16; (*hr)->iirFilterCoeff_b = b_22_16; break; case 8000: INDIRECT(2); PTR_INIT(2); (*hr)->iirFilterCoeff_a = a_22_8; (*hr)->iirFilterCoeff_b = b_22_8; break; }; break; case 24000: BRANCH(2); switch(Fout){ case 16000: INDIRECT(2); PTR_INIT(2); (*hr)->iirFilterCoeff_a = a_24_16; (*hr)->iirFilterCoeff_b = b_24_16; break; case 8000: INDIRECT(2); PTR_INIT(2); (*hr)->iirFilterCoeff_a = a_24_8; (*hr)->iirFilterCoeff_b = b_24_8; break; }; break; default: INDIRECT(2); PTR_INIT(2); (*hr)->iirFilterCoeff_a = 0; (*hr)->iirFilterCoeff_b = 1; break; }; INDIRECT(2); MOVE(2); (*hr)->iirFilterCoeff_a = 0; (*hr)->iirFilterCoeff_b = 1; COUNT_sub_end(); }
/* * * \brief Perform complex-valued subband filtering of the time domain * data of timeIn and stores the real part of the subband * samples in rAnalysis, and the imaginary part in iAnalysis * */ void cplxAnalysisQmfFiltering ( const float *timeIn, float **qmfReal, #ifndef LP_SBR_ONLY float **qmfImag, #endif HANDLE_SBR_QMF_FILTER_BANK anaQmf, int bUseLP ) { int i, k; float analysisBuffer[NO_ANALYSIS_CHANNELS*2]; const float *ptr_pf; const float *ptr_states; const float *ptr_timeIn; int p; float accu; COUNT_sub_start("cplxAnalysisQmfFiltering"); PTR_INIT(1); ptr_timeIn = timeIn; INDIRECT(1); LOOP(1); for (i = 0; i < anaQmf->no_col; i++) { FUNC(2); LOOP(1); PTR_INIT(1); MOVE(1); STORE(2*NO_ANALYSIS_CHANNELS); memset (analysisBuffer, 0, 2*NO_ANALYSIS_CHANNELS * sizeof (float)); INDIRECT(2); PTR_INIT(2); ptr_pf = anaQmf->p_filter; ptr_states = anaQmf->FilterStatesAna; FUNC(2); LOOP(1); PTR_INIT(2); MOVE(1); STORE(NO_ANALYSIS_CHANNELS); memcpy(anaQmf->FilterStatesAna+(QMF_FILTER_STATE_ANA_SIZE-NO_ANALYSIS_CHANNELS),ptr_timeIn,NO_ANALYSIS_CHANNELS*sizeof(float)); COUNT_sub_start("AnalysisPolyphaseFiltering"); LOOP(1); PTR_INIT(1); for (k = 0; k < NO_ANALYSIS_CHANNELS; k++) { ptr_pf += NO_POLY * (QMF_ANA_FILTER_STRIDE - 1); MAC(1); accu=0; MOVE(1); for (p = 0; p < NO_POLY; p++) { accu += *ptr_pf++ * ptr_states[2*NO_ANALYSIS_CHANNELS * p]; MAC(1); } analysisBuffer[2*NO_ANALYSIS_CHANNELS - 1 - k] = accu; STORE(1); ptr_states++; } accu=0; MOVE(1); LOOP(1); PTR_INIT(1); for (p = 0; p < NO_POLY; p++) { accu += *ptr_pf++ * anaQmf->FilterStatesAna[2*NO_ANALYSIS_CHANNELS * p + 2*NO_ANALYSIS_CHANNELS-1]; MAC(1); } analysisBuffer[0] = accu; MOVE(1); ptr_pf -= NO_POLY * 2; PTR_INIT(1); LOOP(1); PTR_INIT(1); for (k = 0; k < NO_ANALYSIS_CHANNELS-1; k++){ ptr_pf -= NO_POLY * (QMF_ANA_FILTER_STRIDE - 1); PTR_INIT(1); accu=0; MOVE(1); for (p = 0; p < NO_POLY; p++) { accu += *--ptr_pf * ptr_states[2*NO_ANALYSIS_CHANNELS * p]; MAC(1); } analysisBuffer[NO_ANALYSIS_CHANNELS - 1 - k] = accu; STORE(1); ptr_states++; } COUNT_sub_end(); BRANCH(1); if (bUseLP) { FUNC(3); sbrForwardModulationLP (analysisBuffer, qmfReal[i], anaQmf); } #ifndef LP_SBR_ONLY else { FUNC(4); sbrForwardModulation (analysisBuffer, qmfReal[i], qmfImag[i], anaQmf); } #endif /* Shift filter states Should be realized with modulo adressing on a DSP instead of a true buffer shift */ /* FUNC(2); LOOP(1); PTR_INIT(2); MOVE(1); STORE(NO_ANALYSIS_CHANNELS); */ memmove(anaQmf->FilterStatesAna,anaQmf->FilterStatesAna+NO_ANALYSIS_CHANNELS,(QMF_FILTER_STATE_ANA_SIZE-NO_ANALYSIS_CHANNELS)*sizeof(float)); ptr_timeIn += NO_ANALYSIS_CHANNELS; } COUNT_sub_end(); }
int AacEncOpen ( struct AAC_ENCODER** phAacEnc, /* pointer to an encoder handle, initialized on return */ const AACENC_CONFIG config /* pre-initialized config struct */ ) { int error = 0; int profile = 1; ELEMENT_INFO* elInfo = NULL; struct AAC_ENCODER *hAacEnc ; COUNT_sub_start("AacEncOpen"); MOVE(2); /* counting previous operations */ PTR_INIT(1); hAacEnc = &aacEncoder; BRANCH(1); if (phAacEnc==0) { MOVE(1); error=1; } BRANCH(1); if (!error) { /* sanity checks on config structure */ PTR_INIT(1); ADD(7); LOGIC(9); DIV(1); error = (/* &config == 0 || */ phAacEnc == 0 || config.nChannelsIn < 1 || config.nChannelsIn > MAX_CHANNELS || config.nChannelsOut < 1 || config.nChannelsOut > MAX_CHANNELS || config.nChannelsIn < config.nChannelsOut || (config.bitRate!=0 && (config.bitRate / config.nChannelsOut < 8000 || config.bitRate / config.nChannelsOut > 160000))); } /* check sample rate */ BRANCH(1); if (!error) { BRANCH(2); switch (config.sampleRate) { case 8000: case 11025: case 12000: case 16000: case 22050: case 24000: case 32000: case 44100: case 48000: break; default: MOVE(1); error = 1; break; } } /* check if bit rate is not too high for sample rate */ BRANCH(1); if (!error) { MULT(2); ADD(1); BRANCH(1); if (config.bitRate > ((float)(MAX_CHANNEL_BITS-744)/FRAME_LEN_LONG* config.sampleRate*config.nChannelsOut)) { MOVE(1); error=1; } } BRANCH(1); if (!error) { INDIRECT(1); MOVE(1); hAacEnc->config = config; } BRANCH(1); if (!error) { INDIRECT(2); PTR_INIT(1); FUNC(2); error = InitElementInfo (config.nChannelsOut, &hAacEnc->elInfo); } BRANCH(1); if (!error) { INDIRECT(1); PTR_INIT(1); elInfo = &hAacEnc->elInfo; } /* allocate the Psy aud Psy Out structure */ BRANCH(1); if (!error) { INDIRECT(3); PTR_INIT(2); FUNC(2); FUNC(1); LOGIC(1); error = (PsyNew(&hAacEnc->psyKernel, elInfo->nChannelsInEl) || PsyOutNew(&hAacEnc->psyOut)); } BRANCH(1); if (!error) { int tnsMask=3; MOVE(1); /* counting previous operation */ INDIRECT(2); MOVE(1); hAacEnc->bandwidth90dB = (int)hAacEnc->config.bandWidth; INDIRECT(4); PTR_INIT(1); FUNC(6); error = psyMainInit(&hAacEnc->psyKernel, config.sampleRate, config.bitRate, elInfo->nChannelsInEl, tnsMask, hAacEnc->bandwidth90dB); } /* allocate the Q&C Out structure */ BRANCH(1); if (!error) { INDIRECT(2); PTR_INIT(1); FUNC(2); error = QCOutNew(&hAacEnc->qcOut, elInfo->nChannelsInEl); } /* allocate the Q&C kernel */ BRANCH(1); if (!error) { INDIRECT(1); PTR_INIT(1); FUNC(1); error = QCNew(&hAacEnc->qcKernel); } BRANCH(1); if (!error) { struct QC_INIT qcInit; INDIRECT(1); PTR_INIT(1); MOVE(1); qcInit.elInfo = &hAacEnc->elInfo; INDIRECT(1); MULT(1); STORE(1); qcInit.maxBits = MAX_CHANNEL_BITS * elInfo->nChannelsInEl; MOVE(1); qcInit.bitRes = qcInit.maxBits; MULT(1); DIV(1); STORE(1); qcInit.averageBits = (config.bitRate * FRAME_LEN_LONG) / config.sampleRate; MOVE(1); qcInit.padding.paddingRest = config.sampleRate; INDIRECT(1); MULT(2); DIV(1); qcInit.meanPe = 10.0f * FRAME_LEN_LONG * hAacEnc->bandwidth90dB/(config.sampleRate/2.0f); MULT(1); DIV(1); BRANCH(1); STORE(1); qcInit.maxBitFac = (float)((MAX_CHANNEL_BITS-744)*elInfo->nChannelsInEl) / (float)(qcInit.averageBits?qcInit.averageBits:1); MOVE(1); qcInit.bitrate = config.bitRate; INDIRECT(1); PTR_INIT(2); FUNC(2); error = QCInit(&hAacEnc->qcKernel, &qcInit); } /* init bitstream encoder */ BRANCH(1); if (!error) { INDIRECT(5); MOVE(4); hAacEnc->bseInit.nChannels = elInfo->nChannelsInEl; hAacEnc->bseInit.bitrate = config.bitRate; hAacEnc->bseInit.sampleRate = config.sampleRate; hAacEnc->bseInit.profile = profile; } /* common things */ BRANCH(1); if (!error) { INDIRECT(1); ADD(2); LOGIC(1); STORE(1); hAacEnc->downmix = (config.nChannelsIn==2 && config.nChannelsOut==1); INDIRECT(1); BRANCH(1); MOVE(1); hAacEnc->downmixFac = (hAacEnc->downmix) ? config.nChannelsIn : 1; } BRANCH(1); if(!error) { /* decide if stereo preprocessing should be activated */ ADD(3); DIV(1); MULT(1); LOGIC(2); BRANCH(1); if ( elInfo->elType == ID_CPE && (config.sampleRate <= 24000 && (config.bitRate/elInfo->nChannelsInEl*2) < 60000) ) { float scfUsedRatio = (float) hAacEnc->psyKernel.psyConfLong.sfbActive / hAacEnc->psyKernel.psyConfLong.sfbCnt ; DIV(1); /* counting previous operation */ FUNC(5); error = InitStereoPreProcessing(&(hAacEnc->stereoPrePro), elInfo->nChannelsInEl, config.bitRate, config.sampleRate, scfUsedRatio); } } BRANCH(1); if (error) { FUNC(1); AacEncClose(hAacEnc); MOVE(1); hAacEnc=0; } MOVE(1); *phAacEnc = hAacEnc; COUNT_sub_end(); return error; }
/* * * * \brief Perform complex-valued subband synthesis of the * low band and the high band and store the * time domain data in timeOut * */ void cplxSynthesisQmfFiltering( float **qmfReal, #ifndef LP_SBR_ONLY float **qmfImag, #endif float *timeOut, HANDLE_SBR_QMF_FILTER_BANK synQmf, int bUseLP, HANDLE_PS_DEC h_ps_dec, int active ) { int i, j; float *ptr_time_out; float *filterStates; float accu; int p; float qmfReal2[NO_ACTUAL_SYNTHESIS_CHANNELS]; float *imagSlot; int no_synthesis_channels; int qmf_filter_state_syn_size; float qmfRealTmp[NO_ACTUAL_SYNTHESIS_CHANNELS]; float qmfImagTmp[NO_ACTUAL_SYNTHESIS_CHANNELS]; int env; COUNT_sub_start("cplxSynthesisQmfFiltering"); MOVE(1); env = 0; FUNC(3); LOOP(1); PTR_INIT(1); MOVE(1); STORE(NO_ACTUAL_SYNTHESIS_CHANNELS); memset(qmfRealTmp,0,NO_ACTUAL_SYNTHESIS_CHANNELS*sizeof(float)); FUNC(3); LOOP(1); PTR_INIT(1); MOVE(1); STORE(NO_ACTUAL_SYNTHESIS_CHANNELS); memset(qmfImagTmp,0,NO_ACTUAL_SYNTHESIS_CHANNELS*sizeof(float)); INDIRECT(1); MOVE(1); no_synthesis_channels = synQmf->no_channels; INDIRECT(1); MOVE(1); qmf_filter_state_syn_size = synQmf->qmf_filter_state_size; INDIRECT(1); PTR_INIT(1); filterStates = synQmf->FilterStatesSyn; PTR_INIT(1); ptr_time_out = timeOut; INDIRECT(1); LOOP(1); for (i = 0; i < synQmf->no_col; i++) { const float *p_filter = synQmf->p_filter; INDIRECT(1); PTR_INIT(1); BRANCH(1); if (bUseLP) { PTR_INIT(1); imagSlot = qmfReal2; } #ifndef LP_SBR_ONLY else { PTR_INIT(1); imagSlot = *(qmfImag + i); } #endif #ifndef MONO_ONLY BRANCH(1); if(active){ ADD(1); INDIRECT(1); BRANCH(1); if(i == h_ps_dec-> aEnvStartStop[env]){ FUNC(3); INDIRECT(1); InitRotationEnvelope(h_ps_dec,env,synQmf->usb); env++; } FUNC(5); ApplyPsSlot(h_ps_dec, &qmfReal[i], &qmfImag[i], qmfRealTmp, qmfImagTmp); } #endif #ifndef LP_SBR_ONLY BRANCH(1); if(!bUseLP) { BRANCH(1); if(no_synthesis_channels == NO_SYNTHESIS_CHANNELS_DOWN_SAMPLED){ PTR_INIT(4); /* pointers for qmfReal[i][j], imagSlot[j], synQmf->cos_twiddle_ds[j], synQmf->sin_twiddle_ds[j] */ LOOP(1); for (j = 0; j < no_synthesis_channels; j++){ float temp; MOVE(1); temp = qmfReal[i][j]; MULT(1); MAC(1); STORE(1); qmfReal[i][j] = synQmf->t_cos[j] * qmfReal[i][j] + synQmf->t_sin[j] * imagSlot[j]; MULT(2); ADD(1); STORE(1); imagSlot[j] = synQmf->t_cos[j] * imagSlot[j] - synQmf->t_sin[j] * temp; } } PTR_INIT(2); /* pointers for qmfReal[i][j], imagSlot[j], */ INDIRECT(1); LOOP(1); for (j = 0; j < synQmf->usb; j++) { MULT(2); STORE(2); qmfReal[i][j] *= -1.0; imagSlot[j] *= -1.0; } } #endif BRANCH(1); if (bUseLP) { FUNC(3); inverseModulationLP (qmfReal[i], imagSlot, synQmf); } #ifndef LP_SBR_ONLY else { FUNC(3); inverseModulation (qmfReal[i], imagSlot, synQmf); } #endif BRANCH(1); if (bUseLP) { PTR_INIT(2); /* pointers for qmfReal[i][j], imagSlot[j], */ LOOP(1); for (j = 0; j < no_synthesis_channels; j++) { MULT(2); STORE(2); qmfReal[i][j] = qmfReal[i][j] * 0.0625f; imagSlot[j] = imagSlot[j] * 0.0625f; } } #ifndef LP_SBR_ONLY else { PTR_INIT(2); /* pointers for qmfReal[i][j], imagSlot[j], */ LOOP(1); for (j = 0; j < no_synthesis_channels; j++) { MULT(2); STORE(2); qmfReal[i][j] = qmfReal[i][j] * 0.03125f; imagSlot[j] = imagSlot[j] * 0.03125f; } } #endif COUNT_sub_start("SynthesisPolyphaseFiltering"); MULT(1); PTR_INIT(2); /* pointers for filterStates[p * 2*no_synthesis_channels + j], imagSlot[no_synthesis_channels -1 - j] */ LOOP(1); for (j = 0; j < no_synthesis_channels; j++){ float newSample; MOVE(1); newSample = imagSlot[no_synthesis_channels -1 - j]; if(no_synthesis_channels == 32){ p_filter += NO_POLY; } LOOP(1); for (p = 0; p < NO_POLY; p++) { MAC(1); STORE(1); accu = filterStates[p * 2*no_synthesis_channels + j] + (*p_filter++) * newSample; filterStates[p * 2*no_synthesis_channels + j] = accu; } } MULT(2); PTR_INIT(1); /* pointer for filterStates[p * 2*no_synthesis_channels + no_synthesis_channels + (no_synthesis_channels-1)] */ LOOP(1); for (p = 0; p < NO_POLY; p++) { MAC(1); STORE(1); accu = filterStates[p * 2*no_synthesis_channels + no_synthesis_channels + (no_synthesis_channels-1) ] + (*p_filter++) * qmfReal[i][0]; filterStates[p * 2*no_synthesis_channels + no_synthesis_channels + (no_synthesis_channels-1)] = accu; } MOVE(1); ptr_time_out[0] = accu; p_filter -= NO_POLY*2; MULT(2); PTR_INIT(2); /* pointers for filterStates[p * 2*no_synthesis_channels + no_synthesis_channels + j], qmfReal[no_synthesis_channels -1 - j] */ ADD(1); LOOP(1); for (j = 0; j < no_synthesis_channels-1; j++){ float newSample; MOVE(1); newSample = qmfReal[i][no_synthesis_channels -1 - j]; if(no_synthesis_channels == 32){ p_filter -= NO_POLY; } LOOP(1); for (p = 0; p < NO_POLY; p++) { MAC(1); STORE(1); accu = filterStates[p * 2*no_synthesis_channels + no_synthesis_channels + j] + (*--p_filter) * newSample; filterStates[p * 2*no_synthesis_channels + no_synthesis_channels + j] = accu; } MOVE(1); ptr_time_out[no_synthesis_channels - 1 - j] = accu; } ptr_time_out += no_synthesis_channels; /* Shift filter states Should be replaces by modulo operation if available */ /* FUNC(2); LOOP(1); PTR_INIT(2); MOVE(1); STORE((qmf_filter_state_syn_size - no_synthesis_channels)); */ memmove (filterStates + no_synthesis_channels, filterStates, (qmf_filter_state_syn_size - no_synthesis_channels) * sizeof (float)); /* FUNC(2); LOOP(1); PTR_INIT(1); MOVE(1); STORE(no_synthesis_channels); */ memset (filterStates, 0, no_synthesis_channels * sizeof (float)); BRANCH(1); if(active){ FUNC(2); LOOP(1); PTR_INIT(2); MOVE(1); STORE(no_synthesis_channels); memcpy(qmfReal[i],qmfRealTmp,sizeof(float)*no_synthesis_channels); #ifndef LP_SBR_ONLY FUNC(2); LOOP(1); PTR_INIT(2); MOVE(1); STORE(no_synthesis_channels); memcpy(qmfImag[i],qmfImagTmp,sizeof(float)*no_synthesis_channels); #endif } COUNT_sub_end(); } COUNT_sub_end(); }
int AacEncEncode(struct AAC_ENCODER *aacEnc, /*!< an encoder handle */ float *timeSignal, /*!< BLOCKSIZE*nChannels audio samples */ unsigned int timeInStride, const unsigned char *ancBytes, /*!< pointer to ancillary data bytes */ unsigned int *numAncBytes, /*!< number of ancillary Data Bytes */ unsigned int *outBytes, /*!< pointer to output buffer */ int *numOutBytes /*!< number of bytes in output buffer */ ) { ELEMENT_INFO* elInfo = &aacEnc->elInfo; int globUsedBits; int ancDataBytes, ancDataBytesLeft; COUNT_sub_start("AacEncEncode"); INDIRECT(2); PTR_INIT(1); FUNC(3); aacEnc->hBitStream = CreateBitBuffer(&aacEnc->bitStream, (unsigned char*) outBytes, (MAX_CHANNEL_BITS/8)*MAX_CHANNELS); INDIRECT(1); PTR_INIT(1); /* counting previous operation */ MOVE(2); ancDataBytes = ancDataBytesLeft = *numAncBytes; /* advance psychoacoustic */ LOGIC(1); BRANCH(1); if (elInfo->elType == ID_CPE) { PTR_INIT(1); FUNC(5); ApplyStereoPreProcess(&aacEnc->stereoPrePro, timeInStride, elInfo, timeSignal, FRAME_LEN_LONG); } INDIRECT(5); PTR_INIT(4); FUNC(9); psyMain(timeInStride, elInfo, timeSignal, &aacEnc->psyKernel.psyData[elInfo->ChannelIndex[0]], &aacEnc->psyKernel.tnsData[elInfo->ChannelIndex[0]], &aacEnc->psyKernel.psyConfLong, &aacEnc->psyKernel.psyConfShort, &aacEnc->psyOut.psyOutChannel[elInfo->ChannelIndex[0]], &aacEnc->psyOut.psyOutElement, aacEnc->psyKernel.pScratchTns); INDIRECT(3); PTR_INIT(1); FUNC(3); AdjustBitrate(&aacEnc->qcKernel, aacEnc->config.bitRate, aacEnc->config.sampleRate); PTR_INIT(4); /* aacEnc->qcKernel.elementBits aacEnc->qcKernel.adjThr.adjThrStateElem, aacEnc->psyOut.psyOutElement, aacEnc->qcOut.qcElement */ ADD(1); BRANCH(1); MOVE(1); /* min() */ INDIRECT(2); PTR_INIT(3); FUNC(9); QCMain( &aacEnc->qcKernel, elInfo->nChannelsInEl, &aacEnc->qcKernel.elementBits, &aacEnc->qcKernel.adjThr.adjThrStateElem, &aacEnc->psyOut.psyOutChannel[elInfo->ChannelIndex[0]], &aacEnc->psyOut.psyOutElement, &aacEnc->qcOut.qcChannel[elInfo->ChannelIndex[0]], &aacEnc->qcOut.qcElement, min(ancDataBytesLeft,ancDataBytes)); LOGIC(1); BRANCH(1); if ( elInfo->elType == ID_CPE ) { INDIRECT(1); PTR_INIT(2); FUNC(4); UpdateStereoPreProcess(&aacEnc->psyOut.psyOutChannel[elInfo->ChannelIndex[0]], &aacEnc->qcOut.qcElement, &aacEnc->stereoPrePro, aacEnc->psyOut.psyOutElement.weightMsLrPeRatio); } ADD(1); ancDataBytesLeft-=ancDataBytes; INDIRECT(2); PTR_INIT(2); FUNC(2); FinalizeBitConsumption( &aacEnc->qcKernel, &aacEnc->qcOut); INDIRECT(3); PTR_INIT(3); FUNC(7); WriteBitstream( aacEnc->hBitStream, *elInfo, &aacEnc->qcOut, &aacEnc->psyOut, &globUsedBits, ancBytes); INDIRECT(2); PTR_INIT(2); FUNC(2); UpdateBitres(&aacEnc->qcKernel, &aacEnc->qcOut); /* write out the bitstream */ INDIRECT(1); FUNC(1); DIV(1); STORE(1); *numOutBytes = GetBitsAvail(aacEnc->hBitStream)/8; /* assert this frame is not too large */ assert(*numOutBytes*8 <= MAX_CHANNEL_BITS * elInfo->nChannelsInEl); COUNT_sub_end(); return 0; }
void MsStereoProcessing(float *sfbEnergyLeft, float *sfbEnergyRight, const float *sfbEnergyMid, const float *sfbEnergySide, float *mdctSpectrumLeft, float *mdctSpectrumRight, float *sfbThresholdLeft, float *sfbThresholdRight, float *sfbSpreadedEnLeft, float *sfbSpreadedEnRight, int *msDigest, int *msMask, const int sfbCnt, const int sfbPerGroup, const int maxSfbPerGroup, const int *sfbOffset, float *weightMsLrPeRatio) { int sfb,sfboffs, j, cnt = 0; int msMaskTrueSomewhere = 0; int msMaskFalseSomewhere = 0; float sumMsLrPeRatio = 0; COUNT_sub_start("MsStereoProcessing"); MOVE(4); /* counting previous operations */ PTR_INIT(10); /* pointers for sfbThresholdLeft[sfb+sfboffs] sfbThresholdRight[sfb+sfboffs] sfbEnergyLeft[sfb+sfboffs] sfbEnergyRight[sfb+sfboffs] sfbEnergyMid[sfb+sfboffs] sfbEnergySide[sfb+sfboffs] sfbSpreadedEnLeft[sfb+sfboffs] sfbSpreadedEnRight[sfb+sfboffs] sfbOffset[sfb+sfboffs] msMask[sfb+sfboffs] */ LOOP(1); for(sfb=0; sfb<sfbCnt; sfb+=sfbPerGroup) { LOOP(1); for(sfboffs=0;sfboffs<maxSfbPerGroup;sfboffs++) { float pnlr,pnms,minThreshold; int useMS; ADD(1); BRANCH(1); MOVE(1); minThreshold=min(sfbThresholdLeft[sfb+sfboffs], sfbThresholdRight[sfb+sfboffs]); ADD(2); BRANCH(2); MOVE(2); /* max() */ DIV(2); MULT(1); pnlr = (sfbThresholdLeft[sfb+sfboffs]/ max(sfbEnergyLeft[sfb+sfboffs],sfbThresholdLeft[sfb+sfboffs]))* (sfbThresholdRight[sfb+sfboffs]/ max(sfbEnergyRight[sfb+sfboffs],sfbThresholdRight[sfb+sfboffs])); ADD(2); BRANCH(2); MOVE(2); /* max() */ DIV(2); MULT(1); pnms= (minThreshold/max(sfbEnergyMid[sfb+sfboffs],minThreshold))* (minThreshold/max(sfbEnergySide[sfb+sfboffs],minThreshold)); ADD(3); DIV(1); sumMsLrPeRatio += (pnlr + 1.0e-9f) / (pnms + 1.0e-9f) ; ADD(1); cnt++; ADD(1); useMS = (pnms >= pnlr); BRANCH(1); if(useMS){ MOVE(2); msMask[sfb+sfboffs] = 1; msMaskTrueSomewhere = 1; PTR_INIT(2); /* pointers for mdctSpectrumLeft[], mdctSpectrumRight[] */ LOOP(1); for(j=sfbOffset[sfb+sfboffs]; j<sfbOffset[sfb+sfboffs+1]; j++) { float tmp = mdctSpectrumLeft[j]; MOVE(1); /* counting operation above */ ADD(1); MULT(1); STORE(1); mdctSpectrumLeft[j] = 0.5f * (mdctSpectrumLeft[j] + mdctSpectrumRight[j]) ; ADD(1); MULT(1); STORE(1); mdctSpectrumRight[j] = 0.5f * (tmp - mdctSpectrumRight[j]) ; } MOVE(2); sfbThresholdLeft[sfb+sfboffs] = sfbThresholdRight[sfb+sfboffs] = minThreshold; MOVE(2); sfbEnergyLeft[sfb+sfboffs] = sfbEnergyMid[sfb+sfboffs]; sfbEnergyRight[sfb+sfboffs] = sfbEnergySide[sfb+sfboffs]; ADD(1); BRANCH(1); MOVE(1); /* min() */ MULT(1); STORE(2); sfbSpreadedEnLeft[sfb+sfboffs] = sfbSpreadedEnRight[sfb+sfboffs] = min(sfbSpreadedEnLeft[sfb+sfboffs], sfbSpreadedEnRight[sfb+sfboffs]) * 0.5f; }else { MOVE(2); msMask[sfb+sfboffs] = 0; msMaskFalseSomewhere = 1; } } } ADD(1); BRANCH(1); if(msMaskTrueSomewhere == 1) { ADD(1); BRANCH(1); if(msMaskFalseSomewhere == 1) { MOVE(1); *msDigest = SI_MS_MASK_SOME; } else { MOVE(1); *msDigest = SI_MS_MASK_ALL; } } else { MOVE(1); *msDigest = SI_MS_MASK_NONE; } ADD(1); BRANCH(1); MOVE(1); cnt = max (1,cnt); DIV(1); ADD(2); MULT(2); TRANS(1); STORE(1); *weightMsLrPeRatio = (float) (0.28 * atan( 0.37*(sumMsLrPeRatio/cnt-6.5) ) + 1.25); COUNT_sub_end(); }
void GenerateAllMoves(const S_BOARD *pos, S_MOVELIST *list) { int pce = EMPTY; int side = pos->side; int sq = 0, t_sq = 0; int pceNum = 0; int dir = 0; int index = 0; int pceIndex = 0; ASSERT(CheckBoard(pos)); list->count = 0; if(side == WHITE) { for(pceNum = 0; pceNum < pos->pceNum[wP]; ++pceNum) { sq = pos->pList[wP][pceNum]; ASSERT(SqOnBoard(sq)); if(pos->pieces[sq + 10] == EMPTY) { AddWhitePawnMove(pos, sq, sq + 10, list); if(RanksBrd[sq] == RANK_2 && pos->pieces[sq + 20] == EMPTY) { AddQuietMove(pos, MOVE(sq, (sq + 20), EMPTY, EMPTY, MFLAGPS), list); } } if(!SQOFFBOARD(sq + 9) && PieceCol[pos->pieces[sq + 9]] == BLACK) { AddWhitePawnCapMove(pos, sq, sq + 9, pos->pieces[sq + 9], list); } if(!SQOFFBOARD(sq + 11) && PieceCol[pos->pieces[sq + 11]] == BLACK) { AddWhitePawnCapMove(pos, sq, sq + 11, pos->pieces[sq + 11], list); } if(pos->enPas != NO_SQ) { if(sq + 9 == pos->enPas) { AddEnPassantMove(pos, MOVE(sq, sq + 9, EMPTY, EMPTY, MFLAGEP), list); } if(sq + 11 == pos->enPas) { AddEnPassantMove(pos, MOVE(sq, sq + 11, EMPTY, EMPTY, MFLAGEP), list); } } } if(pos->castlePerm & WKCA) { if(pos->pieces[F1] == EMPTY && pos->pieces[G1] == EMPTY) { if(!SqAttacked(E1, BLACK, pos) && !SqAttacked(F1, BLACK, pos)) { AddQuietMove(pos, MOVE(E1, G1, EMPTY, EMPTY, MFLAGCA), list); } } } if(pos->castlePerm & WQCA) { if(pos->pieces[D1] == EMPTY && pos->pieces[C1] == EMPTY && pos->pieces[B1] == EMPTY) { if(!SqAttacked(E1, BLACK, pos) && !SqAttacked(D1, BLACK, pos)) { AddQuietMove(pos, MOVE(E1, C1, EMPTY, EMPTY, MFLAGCA), list); } } } } else { for(pceNum = 0; pceNum < pos->pceNum[bP]; ++pceNum) { sq = pos->pList[bP][pceNum]; ASSERT(SqOnBoard(sq)); if(pos->pieces[sq - 10] == EMPTY) { AddBlackPawnMove(pos, sq, sq - 10, list); if(RanksBrd[sq] == RANK_7 && pos->pieces[sq - 20] == EMPTY) { AddQuietMove(pos, MOVE(sq, (sq - 20), EMPTY, EMPTY, MFLAGPS), list); } } if(!SQOFFBOARD(sq - 9) && PieceCol[pos->pieces[sq - 9]] == WHITE) { AddBlackPawnCapMove(pos, sq, sq - 9, pos->pieces[sq - 9], list); } if(!SQOFFBOARD(sq - 11) && PieceCol[pos->pieces[sq - 11]] == WHITE) { AddBlackPawnCapMove(pos, sq, sq - 11, pos->pieces[sq - 11], list); } if(pos->enPas != NO_SQ) { if(sq - 9 == pos->enPas) { AddEnPassantMove(pos, MOVE(sq, sq - 9, EMPTY, EMPTY, MFLAGEP), list); } if(sq - 11 == pos->enPas) { AddEnPassantMove(pos, MOVE(sq, sq - 11, EMPTY, EMPTY, MFLAGEP), list); } } } if(pos->castlePerm & BKCA) { if(pos->pieces[F8] == EMPTY && pos->pieces[G8] == EMPTY) { if(!SqAttacked(E8, WHITE, pos) && !SqAttacked(F8, WHITE, pos)) { AddQuietMove(pos, MOVE(E8, G8, EMPTY, EMPTY, MFLAGCA), list); } } } if(pos->castlePerm & BQCA) { if(pos->pieces[D8] == EMPTY && pos->pieces[C8] == EMPTY && pos->pieces[B8] == EMPTY) { if((!SqAttacked(E8, WHITE, pos)) && (!SqAttacked(D8, WHITE, pos))) { AddQuietMove(pos, MOVE(E8, C8, EMPTY, EMPTY, MFLAGCA), list); } } } } pceIndex = LoopSlideIndex[side]; pce = LoopSlidePce[pceIndex++]; while(pce != 0) { ASSERT(PieceValid(pce)); for(pceNum = 0; pceNum < pos->pceNum[pce]; ++pceNum) { sq = pos->pList[pce][pceNum]; ASSERT(SqOnBoard(sq)); for(index = 0; index < NumDir[pce]; ++index) { dir = PceDir[pce][index]; t_sq = sq + dir; while(!SQOFFBOARD(t_sq)) { if(pos->pieces[t_sq] != EMPTY) { if(PieceCol[pos->pieces[t_sq]] == (side ^ 1)) { AddCaptureMove(pos, MOVE(sq, t_sq, pos->pieces[t_sq], EMPTY, 0), list); } break; } AddQuietMove(pos, MOVE(sq, t_sq, EMPTY, EMPTY, 0), list); t_sq += dir; } } } pce = LoopSlidePce[pceIndex++]; } pceIndex = LoopNonSlideIndex[side]; pce = LoopNonSlidePce[pceIndex++]; while(pce != 0) { ASSERT(PieceValid(pce)); for(pceNum = 0; pceNum < pos->pceNum[pce]; ++pceNum) { sq = pos->pList[pce][pceNum]; ASSERT(SqOnBoard(sq)); for(index = 0; index < NumDir[pce]; ++index) { dir = PceDir[pce][index]; t_sq = sq + dir; if(SQOFFBOARD(t_sq)) continue; if(pos->pieces[t_sq] != EMPTY) { if(PieceCol[pos->pieces[t_sq]] == (side ^ 1)) { AddCaptureMove(pos, MOVE(sq, t_sq, pos->pieces[t_sq], EMPTY, 0), list); } continue; } AddQuietMove(pos, MOVE(sq, t_sq, EMPTY, EMPTY, 0), list); } } pce = LoopNonSlidePce[pceIndex++]; } }
static const char * aeabi_parse_arm_attributes(void *data, size_t length) { uint32_t sect_len; uint8_t *section = data; #define MOVE(len) do { \ assert(length >= (len)); \ section += (len); \ length -= (len); \ } while (0) if (length == 0 || *section != 'A') return (NULL); MOVE(1); /* Read the section length */ if (length < sizeof(sect_len)) return (NULL); memcpy(§_len, section, sizeof(sect_len)); /* * The section length should be no longer than the section it is within */ if (sect_len > length) return (NULL); MOVE(sizeof(sect_len)); /* Skip the vendor name */ while (length != 0) { if (*section == '\0') break; MOVE(1); } if (length == 0) return (NULL); MOVE(1); while (length != 0) { uint32_t tag_length; switch(*section) { case 1: /* Tag_File */ MOVE(1); if (length < sizeof(tag_length)) return (NULL); memcpy(&tag_length, section, sizeof(tag_length)); break; case 2: /* Tag_Section */ case 3: /* Tag_Symbol */ default: return (NULL); } /* At least space for the tag and size */ if (tag_length <= 5) return (NULL); tag_length--; /* Check the tag fits */ if (tag_length > length) return (NULL); #define MOVE_TAG(len) do { \ assert(tag_length >= (len)); \ MOVE(len); \ tag_length -= (len); \ } while(0) MOVE(sizeof(tag_length)); tag_length -= sizeof(tag_length); while (tag_length != 0) { uint8_t tag; assert(tag_length >= length); tag = *section; MOVE_TAG(1); /* * These tag values come from: * * Addenda to, and Errata in, the ABI for the * ARM Architecture. Release 2.08, section 2.3. */ if (tag == 6) { /* == Tag_CPU_arch */ uint8_t val; val = *section; /* * We don't support values that require * more than one byte. */ if (val & (1 << 7)) return (NULL); /* We have an ARMv4 or ARMv5 */ if (val <= 5) return ("arm"); else /* We have an ARMv6+ */ return ("armv6"); } else if (tag == 4 || tag == 5 || tag == 32 || tag == 65 || tag == 67) { while (*section != '\0' && length != 0) MOVE_TAG(1); if (tag_length == 0) return (NULL); /* Skip the last byte */ MOVE_TAG(1); } else if ((tag >= 7 && tag <= 31) || tag == 34 || tag == 36 || tag == 38 || tag == 42 || tag == 44 || tag == 64 || tag == 66 || tag == 68 || tag == 70) { /* Skip the uleb128 data */ while (*section & (1 << 7) && length != 0) MOVE_TAG(1); if (tag_length == 0) return (NULL); /* Skip the last byte */ MOVE_TAG(1); } else return (NULL); #undef MOVE_TAG } break; } return (NULL); #undef MOVE }
/* --------------------------------------------------------------------------- * moves a element by +-X and +-Y */ void MoveElementLowLevel (DataType *Data, ElementType *Element, Coord DX, Coord DY) { if (Data) r_delete_entry (Data->element_tree, (BoxType *)Element); ELEMENTLINE_LOOP (Element); { MOVE_LINE_LOWLEVEL (line, DX, DY); } END_LOOP; PIN_LOOP (Element); { if (Data) { r_delete_entry (Data->pin_tree, (BoxType *)pin); RestoreToPolygon (Data, PIN_TYPE, Element, pin); } MOVE_PIN_LOWLEVEL (pin, DX, DY); if (Data) { r_insert_entry (Data->pin_tree, (BoxType *)pin, 0); ClearFromPolygon (Data, PIN_TYPE, Element, pin); } } END_LOOP; PAD_LOOP (Element); { if (Data) { r_delete_entry (Data->pad_tree, (BoxType *)pad); RestoreToPolygon (Data, PAD_TYPE, Element, pad); } MOVE_PAD_LOWLEVEL (pad, DX, DY); if (Data) { r_insert_entry (Data->pad_tree, (BoxType *)pad, 0); ClearFromPolygon (Data, PAD_TYPE, Element, pad); } } END_LOOP; ARC_LOOP (Element); { MOVE_ARC_LOWLEVEL (arc, DX, DY); } END_LOOP; ELEMENTTEXT_LOOP (Element); { if (Data && Data->name_tree[n]) r_delete_entry (PCB->Data->name_tree[n], (BoxType *)text); MOVE_TEXT_LOWLEVEL (text, DX, DY); if (Data && Data->name_tree[n]) r_insert_entry (PCB->Data->name_tree[n], (BoxType *)text, 0); } END_LOOP; MOVE_BOX_LOWLEVEL (&Element->BoundingBox, DX, DY); MOVE_BOX_LOWLEVEL (&Element->VBox, DX, DY); MOVE (Element->MarkX, Element->MarkY, DX, DY); if (Data) r_insert_entry (Data->element_tree, (BoxType *)Element, 0); }