static inline int32_t RVC_decoder__texture_Y__idct2d__rowpmul_2_0(ActorInstance_RVC_decoder__texture_Y__idct2d__row* thisActor, int32_t X){
int32_t Temp1;
int32_t ret;
Temp1 = (rshift(X, 9) - X);
ret = (rshift(Temp1, 2) - Temp1);
return ret;
}
//Actor functions
static inline int32_t RVC_decoder__texture_U__idct2d__rowpmul_1_0(ActorInstance_RVC_decoder__texture_U__idct2d__row* thisActor, int32_t X){
int32_t Temp1;
int32_t ret;
Temp1 = (rshift(X, 3) - rshift(X, 7));
ret = (X - Temp1);
return ret;
}
static inline int32_t RVC_decoder__texture_Y__idct2d__rowpmul_1_1(ActorInstance_RVC_decoder__texture_Y__idct2d__row* thisActor, int32_t X){
int32_t Temp1;
int32_t Temp2;
int32_t ret;
Temp1 = (rshift(X, 3) - rshift(X, 7));
Temp2 = (Temp1 - rshift(X, 11));
ret = (Temp1 + rshift(Temp2, 1));
return ret;
}
static inline int32_t RVC_decoder__texture_Y__idct2d__rowpmul_3_1(ActorInstance_RVC_decoder__texture_Y__idct2d__row* thisActor, int32_t X){
int32_t Temp1;
int32_t Temp2;
int32_t ret;
Temp1 = (X + rshift(X, 5));
Temp2 = rshift(Temp1, 2);
ret = (Temp1 - Temp2);
return ret;
}
/*
* Inverse A and output to B
*/
static void fieldInv(const uint32_t *A, const uint32_t *modulus, const uint32_t *reducer, uint32_t *B){
uint32_t u[8],v[8],x1[8],x2[8];
uint32_t tempm[8];
uint32_t tempm2[8];
setZero(tempm, 8);
setZero(tempm2, 8);
setZero(u, 8);
setZero(v, 8);
uint8_t t;
copy(A,u,arrayLength);
copy(modulus,v,arrayLength);
setZero(x1, 8);
setZero(x2, 8);
x1[0]=1;
/* While u !=1 and v !=1 */
while ((isOne(u) || isOne(v))==0) {
while(!(u[0]&1)) { /* While u is even */
rshift(u); /* divide by 2 */
if (!(x1[0]&1)) /*ifx1iseven*/
rshift(x1); /* Divide by 2 */
else {
fieldAddAndDivide(x1,modulus,reducer,tempm); /* tempm=x1+p */
copy(tempm,x1,arrayLength); /* x1=tempm */
//rshift(x1); /* Divide by 2 */
}
}
while(!(v[0]&1)) { /* While v is even */
rshift(v); /* divide by 2 */
if (!(x2[0]&1)) /*ifx1iseven*/
rshift(x2); /* Divide by 2 */
else
{
fieldAddAndDivide(x2,modulus,reducer,tempm); /* tempm=x1+p */
copy(tempm,x2,arrayLength); /* x1=tempm */
//rshift(x2); /* Divide by 2 */
}
}
t=sub(u,v,tempm,arrayLength); /* tempm=u-v */
if (t==0) { /* If u > 0 */
copy(tempm,u,arrayLength); /* u=u-v */
fieldSub(x1,x2,modulus,tempm); /* tempm=x1-x2 */
copy(tempm,x1,arrayLength); /* x1=x1-x2 */
} else {
sub(v,u,tempm,arrayLength); /* tempm=v-u */
copy(tempm,v,arrayLength); /* v=v-u */
fieldSub(x2,x1,modulus,tempm); /* tempm=x2-x1 */
copy(tempm,x2,arrayLength); /* x2=x2-x1 */
}
}
if (isOne(u)) {
copy(x1,B,arrayLength);
} else {
copy(x2,B,arrayLength);
}
}
static mrb_value
fix_rshift(mrb_state *mrb, mrb_value x)
{
mrb_int width;
mrb_value result;
fix_shift_get_width(mrb, &width);
if (width == 0) {
result = x;
}
else {
mrb_int val;
val = mrb_fixnum(x);
if (width < 0) {
result = lshift(mrb, val, -width);
}
else {
result = rshift(val, width);
}
}
return result;
}
value_t Bignum::lshift(Bignum *obj, intptr_t shift)
{
if(shift < 0)
return rshift(obj, -shift);
return obj->number.lshift(shift).to_value();
}
void iiwt_ref(SchroFrameData *p, int filter)
{
int16_t tmp1[100], *hi;
int16_t tmp2[100], *lo;
int16_t tmp3[100], *tmpbuf;
int16_t *data;
int i;
hi = tmp1 + 4;
lo = tmp2 + 4;
tmpbuf = tmp3 + 8;
for(i=0;i<p->width;i++){
data = OFFSET(p->data,i*sizeof(int16_t));
copy(tmpbuf, sizeof(int16_t), data, p->stride, p->height);
synth (tmpbuf, p->height, filter);
copy(data, p->stride, tmpbuf, sizeof(int16_t), p->height);
}
for(i=0;i<p->height;i++){
data = OFFSET(p->data,i*p->stride);
copy(hi, sizeof(int16_t), data, sizeof(int16_t), p->width/2);
copy(lo, sizeof(int16_t), data + p->width/2, sizeof(int16_t), p->width/2);
orc_interleave2_s16 (tmpbuf, hi, lo, p->width/2);
synth (tmpbuf, p->width, filter);
copy(data, sizeof(int16_t), tmpbuf, sizeof(int16_t), p->width);
}
rshift(p, filtershift[filter]);
}
// copy
ART_ACTION(action4__copy, ActorInstance_RVC_decoder__texture_V__IAP) {
int32_t ac;
int32_t h;
bool_t top_edge;
int32_t pred;
int32_t v;
int32_t index;
bool_t left_edge;
ART_ACTION_ENTER(action4__copy, 4);
ac = pinRead_int32_t(IN0_PQF_AC);
h = bitand(rshift(thisActor->count, 3), 7);
top_edge = (h == 0);
pred = ac;
v = bitand(thisActor->count, 7);
index = ((top_edge) ? (v):(bitor(h, 8)));
left_edge = (v == 0);
if ((thisActor->acpred_flag && ((thisActor->top && top_edge) || ((!(thisActor->top)) && left_edge)))) {
if ((thisActor->s_prev_quant == thisActor->s_quant)) {
pred = (pred + thisActor->buf[bitor(lshift(thisActor->pred_ptr, 4), index)]);
} else {
pred = (pred + RVC_decoder__texture_V__IAPdivroundnearest(thisActor, (thisActor->buf[bitor(lshift(thisActor->pred_ptr, 4), index)] * thisActor->s_prev_quant), thisActor->s_quant));
}
}
if ((left_edge || top_edge)) {
thisActor->buf[bitor(lshift(thisActor->ptr, 4), index)] = pred;
}
thisActor->count = (thisActor->count + 1);
pinWrite_int32_t(OUT0_QF_AC, pred);
ART_ACTION_EXIT(action4__copy, 4);
}
// read_mv
ART_ACTION(action4__read_mv, ActorInstance_RVC_decoder__motion_V__framebuf) {
int32_t x;
int32_t y;
int32_t flag_x;
int32_t flags;
int32_t flag_y;
ART_ACTION_ENTER(action4__read_mv, 4);
x = pinRead_int32_t(IN0_MV);
y = pinRead_int32_t(IN0_MV);
flag_x = (((bitand(x, 1) == 1)) ? (4):(0));
flags = ((lshift(bitand(x, 1), 2) + lshift(bitand(y, 1), 1)) + thisActor->vop_rounding_mode);
flag_y = (((bitand(y, 1) == 1)) ? (2):(0));
thisActor->mvx = rshift(x, 1);
thisActor->mvy = rshift(y, 1);
pinWrite_int32_t(OUT0_halfpel, flags);
ART_ACTION_EXIT(action4__read_mv, 4);
}
int main(int argc, char const *argv[])
{
time_t t;
srand((unsigned) time(&t));
int shift = rand() % 1000000;
printf("In parseval's theorem, LHS - RHS = %lf\n", parseval(argv[1],argv[2]));
rshift(argv[1],argv[3], shift);
return 0;
}
void
ocb::setkey (const void *key, u_int keylen)
{
k.setkey (key, keylen);
blkclear (&l[0]);
k.encipher_bytes (l[0].c);
rshift (&l[-1], l[0]);
for (u_int i = 0; i < l_size; i++)
lshift (&l[i+1], l[i]);
}
// start
ART_ACTION(action0__start, ActorInstance_RVC_decoder__motion_Y__interpolation) {
int32_t f;
ART_ACTION_ENTER(action0__start, 0);
f = pinRead_int32_t(IN1_halfpel);
thisActor->x = 0;
thisActor->y = 0;
thisActor->flags = rshift(f, 1);
thisActor->round = bitand(f, 1);
ART_ACTION_EXIT(action0__start, 0);
}
void encrypt_bit()
{
int i,j,x,x1,k,temp=0,s1,c,num[8],p2,sum;
/*randomization();*/
s1=0;
for(i=0; i<siz; i++)
{
for(j=0; j<siz; j++)
{
x=(int)mat[i][j];
temp=data[s1];
data[s1]=data[x];
data[x]=temp;
s1=s1+1;
x=0;
}
}
for(c=0; c<times; c++)
{
rshift(c);
bit_wise_xor();
/*printf("\n\n After XOR C= %d \n",c);
for(i=0;i<n;i++)
printf("%d ",data[i]);
getch();*/
}
for(i=0; i<256; i=i+8)
{
j=0;
k=0;
num[j]=data[i];
num[j+1]=data[i+1];
num[j+2]=data[i+2];
num[j+3]=data[i+3];
num[j+4]=data[i+4];
num[j+5]=data[i+5];
num[j+6]=data[i+6];
num[j+7]=data[i+7];
sum=0;
p2=1;
for(k=7; k>=0; k--)
{
if(num[k]!=0)
sum=sum+p2;
p2=p2*2;
}
fprintf(fp2,"%c",sum);
}
}
const char* StringStore::GetStringForID (ID id)
{
uint32 crc, binAndID;
UI64Split (id, crc, binAndID);
const uint binNumberMask = (1 << storageBinBits) - 1;
uint bin = rshift (binAndID, (32 - storageBinBits)) & (binNumberMask);
BinID binId = binAndID & (lshift (1, (32 - storageBinBits))-1);
return bins[bin].GetStringForID (currentCacheTime, binId, crc);
}
// read.intra
ART_ACTION(action5__read__intra, ActorInstance_RVC_decoder__texture_V__DCRecontruction__invpred) {
int32_t cmd;
int32_t qp;
int32_t a;
int32_t b;
int32_t c;
int32_t s;
int32_t dca;
bool_t ac;
int32_t dcc;
int32_t dcb;
int32_t horiz;
int32_t vert;
bool_t top;
int32_t U__5;
ART_ACTION_ENTER(action5__read__intra, 5);
c = pinRead_int32_t(IN3_C);
b = pinRead_int32_t(IN2_B);
a = pinRead_int32_t(IN1_A);
qp = pinRead_int32_t(IN5_QP);
cmd = pinRead_int32_t(IN0_BTYPE);
dca = thisActor->dc_buf[a];
ac = (bitand(cmd, ACPRED) != 0);
dcc = thisActor->dc_buf[c];
dcb = thisActor->dc_buf[b];
horiz = RVC_decoder__texture_V__DCRecontruction__invpredabs(thisActor, (dcb - dcc));
vert = RVC_decoder__texture_V__DCRecontruction__invpredabs(thisActor, (dca - dcb));
top = (vert < horiz);
thisActor->s_qp = qp;
thisActor->s_prev_qp = thisActor->s_qp;
thisActor->round = bitxor(bitand(thisActor->s_qp, 1), 1);
thisActor->scaler = ((((thisActor->s_qp > 0) && (thisActor->s_qp < 5))) ? (8):(((((thisActor->s_qp > 4) && (thisActor->s_qp < 25))) ? (rshift((thisActor->s_qp + 13), 1)):((thisActor->s_qp - 6)))));
thisActor->dc_pred = ((((top) ? (dcc):(dca)) + rshift(thisActor->scaler, 1)) / thisActor->scaler);
s = (((!(ac))) ? (0):(((top) ? (2):(1))));
thisActor->is_signed = (thisActor->scaler == 0);
if ((s == 2)) {
thisActor->s_prev_qp = thisActor->buf_qp[thisActor->cnt];
}
if (((s == 1) && (thisActor->cnt >= 1))) {
thisActor->s_prev_qp = thisActor->buf_qp[(thisActor->cnt - 1)];
}
thisActor->buf_qp[thisActor->cnt] = thisActor->s_qp;
U__5 = ((top) ? (c):(a));
pinWrite_int32_t(OUT1_PTR, U__5);
pinWrite_int32_t(OUT2_AC_PRED_DIR, s);
pinWrite_bool_t(OUT3_SIGNED, thisActor->is_signed);
pinWrite_int32_t(OUT4_QUANT, thisActor->s_qp);
pinWrite_int32_t(OUT5_PREV_QUANT, thisActor->s_prev_qp);
ART_ACTION_EXIT(action5__read__intra, 5);
}
void emit(int tt, unsigned int tval)
{
if(tt == UNKNOWN)
error("Unknown token");
else if(tt == DONE)
error("Unexpected end of expression");
else if(tt == NONE)
error("No token in expression");
else if(tt == EOS)
error("End of string in expression");
else if(tt == NUM)
push(tt, tval);
else if(tt == STRING) {
if(tval <= 0)
error("Unrecognized expression");
else
push(tt, tval);
}
else {
/* apply operator */
switch(tt) {
case 1: l_orr(); break;
case 2: l_and(); break;
case 3: b_orr(); break;
case 4: b_xor(); break;
case 5: b_and(); break;
case 6: l_equ(); break;
case 7: l_neq(); break;
case 8: l_leq(); break;
case 9: l_geq(); break;
case 10: l_ltt(); break;
case 11: l_gtt(); break;
case 12: lshift(); break;
case 13: l_rshift(); break;
case 14: rshift(); break;
case 15: plus(); break;
case 16: minus(); break;
case 17: multiply(); break;
case 18: divide(); break;
case 19: modulo(); break;
case 20: l_not(); break;
case 21: b_not(); break;
case 22: unaryminus(); break;
case 23: unaryplus(); break;
default:
error("Unknown operator");
}
}
}
static mrb_value
fix_lshift(mrb_state *mrb, mrb_value x)
{
mrb_int width, val;
fix_shift_get_width(mrb, &width);
if (width == 0) {
return x;
}
val = mrb_fixnum(x);
if (width < 0) {
return rshift(val, -width);
}
return lshift(mrb, val, width);
}
static int fieldAddAndDivide(const uint32_t *x, const uint32_t *modulus, const uint32_t *reducer, uint32_t* result){
uint32_t n = add(x, modulus, result, arrayLength);
rshift(result);
if(n){ //add prime if carry is still set!
result[7] |= 0x80000000;//add the carry
if (isGreater(result, modulus, arrayLength) == 1)
{
uint32_t tempas[8];
setZero(tempas, 8);
add(result, reducer, tempas, 8);
copy(tempas, result, arrayLength);
}
}
return 0;
}
gethex( CONST char **sp, FPI *fpi, Long *exp, Bigint **bp, int sign)
#endif
{
Bigint *b;
CONST unsigned char *decpt, *s0, *s, *s1;
int esign, havedig, irv, k, n, nbits, up;
ULong L, lostbits, *x;
Long e, e1;
#ifdef USE_LOCALE
unsigned char decimalpoint = *localeconv()->decimal_point;
#else
#define decimalpoint '.'
#endif
#ifndef __SYMBIAN32__
if (!hexdig['0'])
hexdig_init_D2A();
#endif //__SYMBIAN32__
havedig = 0;
s0 = *(CONST unsigned char **)sp + 2;
while(s0[havedig] == '0')
havedig++;
s0 += havedig;
s = s0;
decpt = 0;
if (!hexdig[*s]) {
if (*s == decimalpoint) {
decpt = ++s;
if (!hexdig[*s])
goto ret0;
}
else {
ret0:
*sp = (char*)s;
return havedig ? STRTOG_Zero : STRTOG_NoNumber;
}
while(*s == '0')
s++;
havedig = 1;
if (!hexdig[*s])
goto ret0;
s0 = s;
}
while(hexdig[*s])
s++;
if (*s == decimalpoint && !decpt) {
decpt = ++s;
while(hexdig[*s])
s++;
}
e = 0;
if (decpt)
e = -(((Long)(s-decpt)) << 2);
s1 = s;
switch(*s) {
case 'p':
case 'P':
esign = 0;
switch(*++s) {
case '-':
esign = 1;
/* no break */
case '+':
s++;
}
if ((n = hexdig[*s]) == 0 || n > 0x19) {
s = s1;
break;
}
e1 = n - 0x10;
while((n = hexdig[*++s]) !=0 && n <= 0x19)
e1 = 10*e1 + n - 0x10;
if (esign)
e1 = -e1;
e += e1;
}
*sp = (char*)s;
n = s1 - s0 - 1;
for(k = 0; n > 7; n >>= 1)
k++;
b = Balloc(k);
x = b->x;
n = 0;
L = 0;
while(s1 > s0) {
if (*--s1 == decimalpoint)
continue;
if (n == 32) {
*x++ = L;
L = 0;
n = 0;
}
L |= (hexdig[*s1] & 0x0f) << n;
n += 4;
}
*x++ = L;
b->wds = n = x - b->x;
n = 32*n - hi0bits(L);
nbits = fpi->nbits;
lostbits = 0;
x = b->x;
if (n > nbits) {
n -= nbits;
if (any_on(b,n)) {
lostbits = 1;
k = n - 1;
if (x[k>>kshift] & 1 << (k & kmask)) {
lostbits = 2;
if (k > 1 && any_on(b,k-1))
lostbits = 3;
}
}
rshift(b, n);
e += n;
}
void ecc_rshift(uint32_t* A)
{
rshift(A);
}
//Actor functions
static inline int32_t RVC_decoder__motion_Y__interpolationcompensate(ActorInstance_RVC_decoder__motion_Y__interpolation* thisActor, int32_t p00, int32_t p10, int32_t p01, int32_t p11){
return (((thisActor->flags == 0)) ? (p00):((((thisActor->flags == 1)) ? (rshift((((p00 + p01) + 1) - thisActor->round), 1)):((((thisActor->flags == 2)) ? (rshift((((p00 + p10) + 1) - thisActor->round), 1)):(rshift((((((p00 + p10) + p01) + p11) + 2) - thisActor->round), 2)))))));
}
g_ddfmt(char *buf, double *dd0, int ndig, size_t bufsize)
#endif
{
FPI fpi;
char *b, *s, *se;
ULong *L, bits0[4], *bits, *zx;
int bx, by, decpt, ex, ey, i, j, mode;
Bigint *x, *y, *z;
U *dd, ddx[2];
#ifdef Honor_FLT_ROUNDS /*{{*/
int Rounding;
#ifdef Trust_FLT_ROUNDS /*{{ only define this if FLT_ROUNDS really works! */
Rounding = Flt_Rounds;
#else /*}{*/
Rounding = 1;
switch(fegetround()) {
case FE_TOWARDZERO: Rounding = 0; break;
case FE_UPWARD: Rounding = 2; break;
case FE_DOWNWARD: Rounding = 3;
}
#endif /*}}*/
#else /*}{*/
#define Rounding FPI_Round_near
#endif /*}}*/
if (bufsize < 10 || bufsize < ndig + 8)
return 0;
dd = (U*)dd0;
L = dd->L;
if ((L[_0] & 0x7ff00000L) == 0x7ff00000L) {
/* Infinity or NaN */
if (L[_0] & 0xfffff || L[_1]) {
nanret:
return strcp(buf, "NaN");
}
if ((L[2+_0] & 0x7ff00000) == 0x7ff00000) {
if (L[2+_0] & 0xfffff || L[2+_1])
goto nanret;
if ((L[_0] ^ L[2+_0]) & 0x80000000L)
goto nanret; /* Infinity - Infinity */
}
infret:
b = buf;
if (L[_0] & 0x80000000L)
*b++ = '-';
return strcp(b, "Infinity");
}
if ((L[2+_0] & 0x7ff00000) == 0x7ff00000) {
L += 2;
if (L[_0] & 0xfffff || L[_1])
goto nanret;
goto infret;
}
if (dval(&dd[0]) + dval(&dd[1]) == 0.) {
b = buf;
#ifndef IGNORE_ZERO_SIGN
if (L[_0] & L[2+_0] & 0x80000000L)
*b++ = '-';
#endif
*b++ = '0';
*b = 0;
return b;
}
if ((L[_0] & 0x7ff00000L) < (L[2+_0] & 0x7ff00000L)) {
dval(&ddx[1]) = dval(&dd[0]);
dval(&ddx[0]) = dval(&dd[1]);
dd = ddx;
L = dd->L;
}
z = d2b(dval(&dd[0]), &ex, &bx);
if (dval(&dd[1]) == 0.)
goto no_y;
x = z;
y = d2b(dval(&dd[1]), &ey, &by);
if ( (i = ex - ey) !=0) {
if (i > 0) {
x = lshift(x, i);
ex = ey;
}
else
y = lshift(y, -i);
}
if ((L[_0] ^ L[2+_0]) & 0x80000000L) {
z = diff(x, y);
if (L[_0] & 0x80000000L)
z->sign = 1 - z->sign;
}
else {
z = sum(x, y);
if (L[_0] & 0x80000000L)
z->sign = 1;
}
Bfree(x);
Bfree(y);
no_y:
bits = zx = z->x;
for(i = 0; !*zx; zx++)
i += 32;
i += lo0bits(zx);
if (i) {
rshift(z, i);
ex += i;
}
fpi.nbits = z->wds * 32 - hi0bits(z->x[j = z->wds-1]);
if (fpi.nbits < 106) {
fpi.nbits = 106;
if (j < 3) {
for(i = 0; i <= j; i++)
bits0[i] = bits[i];
while(i < 4)
bits0[i++] = 0;
bits = bits0;
}
}
mode = 2;
if (ndig <= 0) {
if (bufsize < (int)(fpi.nbits * .301029995664) + 10) {
Bfree(z);
return 0;
}
mode = 0;
}
fpi.emin = 1-1023-53+1;
fpi.emax = 2046-1023-106+1;
fpi.rounding = Rounding;
fpi.sudden_underflow = 0;
i = STRTOG_Normal;
s = gdtoa(&fpi, ex, bits, &i, mode, ndig, &decpt, &se);
b = g__fmt(buf, s, se, decpt, z->sign, bufsize);
Bfree(z);
return b;
}
int
gethex( CONST char **sp, CONST FPI *fpi, Long *expt, Bigint **bp, int sign)
{
Bigint *b;
CONST unsigned char *decpt, *s0, *s, *s1;
int esign, havedig, irv, k, n, nbits, up, zret;
ULong L, lostbits, *x;
Long e, e1;
#ifdef USE_LOCALE
unsigned char decimalpoint = *localeconv()->decimal_point;
#else
#define decimalpoint '.'
#endif
if (!hexdig['0'])
hexdig_init_D2A();
havedig = 0;
s0 = *(CONST unsigned char **)sp + 2;
while(s0[havedig] == '0')
havedig++;
s0 += havedig;
s = s0;
decpt = 0;
zret = 0;
e = 0;
if (!hexdig[*s]) {
zret = 1;
if (*s != decimalpoint)
goto pcheck;
decpt = ++s;
if (!hexdig[*s])
goto pcheck;
while(*s == '0')
s++;
if (hexdig[*s])
zret = 0;
havedig = 1;
s0 = s;
}
while(hexdig[*s])
s++;
if (*s == decimalpoint && !decpt) {
decpt = ++s;
while(hexdig[*s])
s++;
}
if (decpt)
e = -(((Long)(s-decpt)) << 2);
pcheck:
s1 = s;
switch(*s) {
case 'p':
case 'P':
esign = 0;
switch(*++s) {
case '-':
esign = 1;
/* FALLTHROUGH */
case '+':
s++;
}
if ((n = hexdig[*s]) == 0 || n > 0x19) {
s = s1;
break;
}
e1 = n - 0x10;
while((n = hexdig[*++s]) !=0 && n <= 0x19)
e1 = 10*e1 + n - 0x10;
if (esign)
e1 = -e1;
e += e1;
}
*sp = __UNCONST(s);
if (zret)
return havedig ? STRTOG_Zero : STRTOG_NoNumber;
n = (int)(s1 - s0 - 1);
for(k = 0; n > 7; n = (unsigned int)n >> 1)
k++;
b = Balloc(k);
if (b == NULL)
return STRTOG_NoMemory;
x = b->x;
n = 0;
L = 0;
while(s1 > s0) {
if (*--s1 == decimalpoint)
continue;
if (n == 32) {
*x++ = L;
L = 0;
n = 0;
}
L |= (hexdig[*s1] & 0x0f) << n;
n += 4;
}
*x++ = L;
b->wds = n = (int)(x - b->x);
n = 32*n - hi0bits(L);
nbits = fpi->nbits;
lostbits = 0;
x = b->x;
if (n > nbits) {
n -= nbits;
if (any_on(b,n)) {
lostbits = 1;
k = n - 1;
if (x[(unsigned int)k>>kshift] & 1 << (k & kmask)) {
lostbits = 2;
if (k > 1 && any_on(b,k-1))
lostbits = 3;
}
}
rshift(b, n);
e += n;
}
static inline int32_t RVC_decoder__texture_Y__idct2d__rowpmul_2_1(ActorInstance_RVC_decoder__texture_Y__idct2d__row* thisActor, int32_t X){
return rshift(X, 1);
}
static Boolean
getImageData(int *w, int *h, int *type, int *nc, unsigned char *Red, unsigned char *Green, unsigned char *Blue)
{
XColor colors[MAX_COLORMAP_SIZE];
int colused[MAX_COLORMAP_SIZE];
int mapcols[MAX_COLORMAP_SIZE];
int red, green, blue;
int red_mask, green_mask, blue_mask;
int red_shift, green_shift, blue_shift;
int x, y, width, height;
Window cw;
static XImage *image;
int i, j;
int numcols;
int bytes_per_pixel, bit_order, byte_order;
int byte_inc;
int pix;
unsigned char *iptr, *rowptr, *dptr;
sleep(1); /* in case he'd like to click on something */
beep(); /* signal user */
if ( selectedRootArea( &x, &y, &width, &height, &cw ) == False )
return False;
image = XGetImage(tool_d, XDefaultRootWindow(tool_d),
x, y, width, height, AllPlanes, ZPixmap);
if (!image || !image->data) {
file_msg("Cannot capture %dx%d area - memory problems?",
width,height);
return False;
}
/* if we get here we got an image! */
*w = width = image->width;
*h = height = image->height;
if (tool_vclass == TrueColor) {
*type = IMAGE_RGB;
bytes_per_pixel = 3;
} else {
/* PseudoColor, get color table */
*type = IMAGE_PALETTE;
bytes_per_pixel = 1;
numcols = getCurrentColors(XDefaultRootWindow(tool_d), colors);
if ( numcols <= 0 ) { /* ought not to get here as capture button
should not appear for these displays */
file_msg("Cannot handle a display without a colormap.");
XDestroyImage( image );
return False;
}
}
iptr = rowptr = (unsigned char *) image->data;
dptr = data = (unsigned char *) malloc(height*width*bytes_per_pixel);
if ( !dptr ) {
file_msg("Insufficient memory to convert image.");
XDestroyImage(image);
return False;
}
if (tool_vclass == TrueColor) {
byte_order = image->byte_order; /* MSBFirst or LSBFirst */
bit_order = image->bitmap_bit_order; /* MSBFirst or LSBFirst */
red_mask = image->red_mask;
green_mask = image->green_mask;
blue_mask = image->blue_mask;
/* find how many bits we need to shift values */
red_shift = rshift(red_mask);
green_shift = rshift(green_mask);
blue_shift = rshift(blue_mask);
switch (image->bits_per_pixel) {
case 8: byte_inc = 1;
break;
case 16: byte_inc = 2;
break;
case 24: byte_inc = 3;
break;
case 32: byte_inc = 4;
break;
default: byte_inc = 4;
break;
}
for (i=0; i<image->height; i++) {
for (j=0; j<image->width; j++) {
if (byte_order == MSBFirst) {
switch (byte_inc) {
case 1:
pix = (unsigned char) *iptr;
break;
case 2:
pix = (unsigned short) (*iptr << 8);
pix += (unsigned char) *(iptr+1);
break;
case 3:
pix = (unsigned int) (*(iptr) << 16);
pix += (unsigned short) (*(iptr+1) << 8);
pix += (unsigned char) (*(iptr+2));
break;
case 4:
pix = (unsigned int) (*(iptr) << 24);
pix += (unsigned int) (*(iptr+1) << 16);
pix += (unsigned short) (*(iptr+2) << 8);
pix += (unsigned char) (*(iptr+3));
break;
}
} else {
/* LSBFirst */
switch (byte_inc) {
case 1:
pix = (unsigned char) *iptr;
break;
case 2:
pix = (unsigned char) *iptr;
pix += (unsigned short) (*(iptr+1) << 8);
break;
case 3:
pix = (unsigned char) *iptr;
pix += (unsigned short) (*(iptr+1) << 8);
pix += (unsigned int) (*(iptr+2) << 16);
break;
case 4:
pix = (unsigned char) *iptr;
pix += (unsigned short) (*(iptr+1) << 8);
pix += (unsigned int) (*(iptr+2) << 16);
pix += (unsigned int) (*(iptr+3) << 24);
break;
}
} /* if (byte_order ...) */
/* increment pixel pointer */
iptr += byte_inc;
/* now extract the red, green and blue values using the masks and shifting */
red = (pix & red_mask) >> red_shift;
green = (pix & green_mask) >> green_shift;
blue = (pix & blue_mask) >> blue_shift;
/* store in output data */
*(dptr++) = (unsigned char) red;
*(dptr++) = (unsigned char) green;
*(dptr++) = (unsigned char) blue;
} /* for (j=0; j<image->width ... */
/* advance to next scanline row */
rowptr += image->bytes_per_line;
iptr = rowptr;
} /* for (i=0; i<image->height ... */
} else if (tool_cells > 2) {
strtoIg(CONST char *s00, char **se, FPI *fpi, Long *exp, Bigint **B, int *rvp)
#endif
{
Bigint *b, *b1;
int i, nb, nw, nw1, rv, rv1, swap;
unsigned int nb1, nb11;
Long e1;
b = *B;
rv = strtodg(s00, se, fpi, exp, b->x);
if (rv == STRTOG_NoMemory)
return rv;
if (!(rv & STRTOG_Inexact)) {
B[1] = 0;
return *rvp = rv;
}
e1 = exp[0];
rv1 = rv ^ STRTOG_Inexact;
b1 = Balloc(b->k);
if (b1 == NULL)
return STRTOG_NoMemory;
Bcopy(b1, b);
nb = fpi->nbits;
nb1 = nb & 31;
nb11 = (nb1 - 1) & 31;
nw = b->wds;
nw1 = nw - 1;
if (rv & STRTOG_Inexlo) {
swap = 0;
b1 = increment(b1);
if (fpi->sudden_underflow
&& (rv & STRTOG_Retmask) == STRTOG_Zero) {
b1->x[0] = 0;
b1->x[nw1] = 1L << nb11;
rv1 += STRTOG_Normal - STRTOG_Zero;
rv1 &= ~STRTOG_Underflow;
goto swapcheck;
}
if (b1->wds > nw
|| nb1 && b1->x[nw1] & 1L << nb1) {
if (++e1 > fpi->emax)
rv1 = STRTOG_Infinite | STRTOG_Inexhi;
rshift(b1, 1);
}
else if ((rv & STRTOG_Retmask) == STRTOG_Denormal) {
if (b1->x[nw1] & 1L << nb11) {
rv1 += STRTOG_Normal - STRTOG_Denormal;
rv1 &= ~STRTOG_Underflow;
}
}
}
else {
swap = STRTOG_Neg;
if ((rv & STRTOG_Retmask) == STRTOG_Infinite) {
b1 = set_ones(b1, nb);
e1 = fpi->emax;
rv1 = STRTOG_Normal | STRTOG_Inexlo;
goto swapcheck;
}
decrement(b1);
if ((rv & STRTOG_Retmask) == STRTOG_Denormal) {
for(i = nw1; !b1->x[i]; --i)
if (!i) {
rv1 = STRTOG_Zero | STRTOG_Inexlo;
break;
}
goto swapcheck;
}
if (!(b1->x[nw1] & 1L << nb11)) {
if (e1 == fpi->emin) {
if (fpi->sudden_underflow)
rv1 += STRTOG_Zero - STRTOG_Normal;
else
rv1 += STRTOG_Denormal - STRTOG_Normal;
rv1 |= STRTOG_Underflow;
}
else {
b1 = lshift(b1, 1);
b1->x[0] |= 1;
--e1;
}
}
}
swapcheck:
if (swap ^ (rv & STRTOG_Neg)) {
rvp[0] = rv1;
rvp[1] = rv;
B[0] = b1;
B[1] = b;
exp[1] = exp[0];
exp[0] = e1;
}
else {
rvp[0] = rv;
rvp[1] = rv1;
B[1] = b1;
exp[1] = e1;
}
return rv;
}
void keyEvent(rdr::U32 keysym, bool down, bool jap)
{
vnclog.Print(LL_INTWARN, " keysym 0x%x",keysym);
if (keysym>=XK_dead_grave && keysym <=XK_dead_belowdot)// && down)
{
keysymDead=keysym;
vnclog.Print(LL_INTWARN, " ************** DEAD KEY");
//we have a dead key
//Record dead key
return;
}
if ((keysym >= 32 && keysym <= 126) ||
(keysym >= 160 && keysym <= 255))
{
if (keysymDead!=0 && down)
{
vnclog.Print(LL_INTWARN, " Compose dead 0x%x 0x%x",keysymDead,keysym);
switch (keysymDead)
{
case XK_dead_grave:
switch(keysym)
{
case XK_A: keysym=XK_Agrave;break;
case XK_E: keysym=XK_Egrave;break;
case XK_I: keysym=XK_Igrave;break;
case XK_O: keysym=XK_Ograve;break;
case XK_U: keysym=XK_Ugrave;break;
case XK_a: keysym=XK_agrave;break;
case XK_e: keysym=XK_egrave;break;
case XK_i: keysym=XK_igrave;break;
case XK_o: keysym=XK_ograve;break;
case XK_u: keysym=XK_ugrave;break;
}
case XK_dead_acute:
switch(keysym)
{
case XK_A: keysym=XK_Aacute;break;
case XK_E: keysym=XK_Eacute;break;
case XK_I: keysym=XK_Iacute;break;
case XK_O: keysym=XK_Oacute;break;
case XK_U: keysym=XK_Uacute;break;
case XK_a: keysym=XK_aacute;break;
case XK_e: keysym=XK_eacute;break;
case XK_i: keysym=XK_iacute;break;
case XK_o: keysym=XK_oacute;break;
case XK_u: keysym=XK_uacute;break;
case XK_y: keysym=XK_yacute;break;
case XK_Y: keysym=XK_Yacute;break;
}
case XK_dead_circumflex:
switch(keysym)
{
case XK_A: keysym=XK_Acircumflex;break;
case XK_E: keysym=XK_Ecircumflex;break;
case XK_I: keysym=XK_Icircumflex;break;
case XK_O: keysym=XK_Ocircumflex;break;
case XK_U: keysym=XK_Ucircumflex;break;
case XK_a: keysym=XK_acircumflex;break;
case XK_e: keysym=XK_ecircumflex;break;
case XK_i: keysym=XK_icircumflex;break;
case XK_o: keysym=XK_ocircumflex;break;
case XK_u: keysym=XK_ucircumflex;break;
}
case XK_dead_tilde:
switch(keysym)
{
case XK_A : keysym=XK_Ntilde;break;
case XK_O : keysym=XK_Otilde;break;
case XK_a : keysym=XK_atilde;break;
case XK_n : keysym=XK_ntilde;break;
case XK_o : keysym=XK_otilde;break;
}
case XK_dead_diaeresis:
switch(keysym)
{
case XK_A: keysym=XK_Adiaeresis;break;
case XK_E: keysym=XK_Ediaeresis;break;
case XK_I: keysym=XK_Idiaeresis;break;
case XK_O: keysym=XK_Odiaeresis;break;
case XK_U: keysym=XK_Udiaeresis;break;
case XK_a: keysym=XK_adiaeresis;break;
case XK_e: keysym=XK_ediaeresis;break;
case XK_i: keysym=XK_idiaeresis;break;
case XK_o: keysym=XK_odiaeresis;break;
case XK_u: keysym=XK_udiaeresis;break;
case XK_y: keysym=XK_ydiaeresis;break;
}
case XK_dead_cedilla:
switch(keysym)
{
case XK_C: keysym=XK_Ccedilla;break;
case XK_c: keysym=XK_ccedilla;break;
}
}
keysymDead=0;
vnclog.Print(LL_INTWARN, " Composed 0x%x",keysym);
}
// ordinary Latin-1 character
SHORT s = VkKeyScan(keysym);
// [v1.0.2-jp1 fix] yak!'s patch
// This break Other keyboards, we need an easy way of fixing this
if (jap)
{
if (keysym==XK_kana_WO) {
s = 0x0130;
} else if (keysym==XK_backslash) {
s = 0x00e2;
} else if (keysym==XK_yen) {
s = 0x00dc;
}
}
vnclog.Print(LL_INTWARN, " SHORT s %i",s);
if (s == -1)
{
if (down) {
vnclog.Print(LL_INTWARN, "down");
// not a single keypress - try synthesizing dead chars.
{
vnclog.Print(LL_INTWARN, " Found key");
//Lookup ascii representation
int ascii=0;
#if 0
// 11 Dec 2008 jdp disabled since the viewer is sending unicode now
for (ascii=0;ascii<256;ascii++)
{
if (keysym==ascii_to_x[ascii]) break;
}
#endif
ascii = keysym;
if (ascii <= 255)
{
rdr::U8 a0=ascii/100;
ascii=ascii%100;
rdr::U8 a1=ascii/10;
ascii=ascii%10;
rdr::U8 a2=ascii;
KeyStateModifier shift(VK_SHIFT);
KeyStateModifier lshift(VK_LSHIFT);
KeyStateModifier rshift(VK_RSHIFT);
if (vncService::IsWin95()) {
shift.release();
} else {
lshift.release();
rshift.release();
}
vnclog.Print(LL_INTWARN, " Simulating ALT+%d%d%d\n", a0, a1 ,a2);
keybd_event(VK_MENU,MapVirtualKey( VK_MENU, 0 ), 0 ,0);
/**
Pressing the Alt+NNN combinations without leading zero (for example, Alt+20, Alt+130, Alt+221)
will insert characters from the Extended ASCII (or MS DOS ASCII, or OEM) table. The character
glyphs contained by this table depend on the language of Windows. See the table below for the
list of characters that can be inserted through the Alt+NNN combinations (without leading zero)
in English Windows.
Pressing the Alt+0NNN combinations will insert the ANSI characters corresponding to the activate
keyboard layout. Please see Windows Character Map utility (charmap.exe) for the possible Alt+0NNN
combinations.
Finally, the Alt+00NNN combinations (two leading zeros) will insert Unicode characters. The Unicode
codes of characters are displayed in Charmap.
**/
// jdp 11 December 2008 - Need the leading 0!
keybd_event(VK_NUMPAD0, MapVirtualKey(VK_NUMPAD0, 0), 0, 0);
keybd_event(VK_NUMPAD0, MapVirtualKey(VK_NUMPAD0, 0),KEYEVENTF_KEYUP,0);
keybd_event(VK_NUMPAD0+a0, MapVirtualKey(VK_NUMPAD0+a0, 0), 0, 0);
keybd_event(VK_NUMPAD0+a0, MapVirtualKey(VK_NUMPAD0+a0, 0),KEYEVENTF_KEYUP,0);
keybd_event(VK_NUMPAD0+a1, MapVirtualKey(VK_NUMPAD0+a1, 0),0,0);
keybd_event(VK_NUMPAD0+a1, MapVirtualKey(VK_NUMPAD0+a1, 0),KEYEVENTF_KEYUP, 0);
keybd_event(VK_NUMPAD0+a2, MapVirtualKey(VK_NUMPAD0+a2, 0) ,0, 0);
keybd_event(VK_NUMPAD0+a2, MapVirtualKey(VK_NUMPAD0+a2, 0),KEYEVENTF_KEYUP, 0);
keybd_event(VK_MENU, MapVirtualKey( VK_MENU, 0 ),KEYEVENTF_KEYUP, 0);
return;
}
}
vnclog.Print(LL_INTWARN, "ignoring unrecognised Latin-1 keysym 0x%x",keysym);
}
return;
}
/*if (s == -1) {
vnclog.Print(LL_INTWARN, "ignoring unrecognised Latin-1 keysym %d\n",
keysym);
keybd_event( VK_MENU, MapVirtualKey(VK_MENU, 0),0, 0);
keybd_event( VK_MENU, MapVirtualKey(VK_MENU, 0),KEYEVENTF_KEYUP, 0);
return;
}*/
BYTE vkCode = LOBYTE(s);
// 18 March 2008 jdp
// Correct the keymask shift state to cope with the capslock state
BOOL capslockOn = (GetKeyState(VK_CAPITAL) & 1) != 0;
BYTE modifierState = HIBYTE(s);
modifierState = capslockOn ? modifierState ^ 1 : modifierState;
KeyStateModifier ctrl(VK_CONTROL);
KeyStateModifier alt(VK_MENU);
KeyStateModifier shift(VK_SHIFT);
KeyStateModifier lshift(VK_LSHIFT);
KeyStateModifier rshift(VK_RSHIFT);
if (down) {
if (modifierState & 2) ctrl.press();
if (modifierState & 4) alt.press();
if (modifierState & 1) {
shift.press();
} else {
// [v1.0.2-jp1 fix] Even if "SHIFT + SPACE" are pressed, "SHIFT" is valid
if (vkCode == 0x20){
}
else{
if (vncService::IsWin95()) {
shift.release();
} else {
lshift.release();
rshift.release();
}
}
}
}
vnclog.Print(LL_INTINFO,
"latin-1 key: keysym %d(0x%x) vkCode 0x%x down %d capslockOn %d\n",
keysym, keysym, vkCode, down, capslockOn);
doKeyboardEvent(vkCode, down ? 0 : KEYEVENTF_KEYUP);
} else {
// see if it's a recognised keyboard key, otherwise ignore it
if (vkMap.find(keysym) == vkMap.end()) {
vnclog.Print(LL_INTWARN, "ignoring unknown keysym %d\n",keysym);
return;
}
BYTE vkCode = vkMap[keysym];
DWORD flags = 0;
if (extendedMap[keysym]) flags |= KEYEVENTF_EXTENDEDKEY;
if (!down) flags |= KEYEVENTF_KEYUP;
// vnclog.Print(LL_INTINFO,
// "keyboard key: keysym %d(0x%x) vkCode 0x%x ext %d down %d\n",
// keysym, keysym, vkCode, extendedMap[keysym], down);
if (down && (vkCode == VK_DELETE) &&
((GetAsyncKeyState(VK_CONTROL) & 0x8000) != 0) &&
((GetAsyncKeyState(VK_MENU) & 0x8000) != 0) &&
vncService::IsWinNT())
{
vnclog.Print(LL_INTINFO,
"CAD\n");
// If running under Vista and started from Session0 in Application mode
if (vncService::VersionMajor()>=6 && vncService::RunningFromExternalService() )
{
vnclog.Print(LL_INTINFO,
"Vista and runnning as system -> CAD\n");
// Try to run the special Vista cad.exe file...
HANDLE ThreadHandle2;
DWORD dwTId;
ThreadHandle2 = CreateThread(NULL, 0, Cadthread, NULL, 0, &dwTId);
CloseHandle(ThreadHandle2);
}
else if (vncService::VersionMajor()>=6)
{
vnclog.Print(LL_INTINFO,
"Vista and runnning as user -> Taskmgr\n");
WinExec("taskmgr.exe", SW_SHOWNORMAL);
}
else if (vncService::VersionMajor()<6 && vncService::RunningFromExternalService() )
{
vnclog.Print(LL_INTINFO,
"Not Vista and runnning as system, use old method\n");
vncService::SimulateCtrlAltDel();
}
else if (vncService::VersionMajor()<6)
{
vnclog.Print(LL_INTINFO,
"Not Vista and runnning as user -> Taskmgr\n");
WinExec("taskmgr.exe", SW_SHOWNORMAL);
}
return;
}
if (vncService::IsWin95()) {
switch (vkCode) {
case VK_RSHIFT: vkCode = VK_SHIFT; break;
case VK_RCONTROL: vkCode = VK_CONTROL; break;
case VK_RMENU: vkCode = VK_MENU; break;
}
}
doKeyboardEvent(vkCode, flags);
}
}
gethex( CONST char **sp, FPI *fpi, Long *exp, Bigint **bp, int sign)
#endif
{
Bigint *b;
CONST unsigned char *decpt, *s0, *s, *s1;
int big, esign, havedig, irv, j, k, n, n0, nbits, up, zret;
ULong L, lostbits, *x;
Long e, e1;
#ifdef USE_LOCALE
int i;
#ifdef NO_LOCALE_CACHE
const unsigned char *decimalpoint = (unsigned char*)localeconv()->decimal_point;
#else
const unsigned char *decimalpoint;
static unsigned char *decimalpoint_cache;
if (!(s0 = decimalpoint_cache)) {
s0 = (unsigned char*)localeconv()->decimal_point;
if ((decimalpoint_cache = (char*)malloc(strlen(s0) + 1))) {
strcpy(decimalpoint_cache, s0);
s0 = decimalpoint_cache;
}
}
decimalpoint = s0;
#endif
#endif
if (!hexdig['0'])
hexdig_init_D2A();
*bp = 0;
havedig = 0;
s0 = *(CONST unsigned char **)sp + 2;
while(s0[havedig] == '0')
havedig++;
s0 += havedig;
s = s0;
decpt = 0;
zret = 0;
e = 0;
if (hexdig[*s])
havedig++;
else {
zret = 1;
#ifdef USE_LOCALE
for(i = 0; decimalpoint[i]; ++i) {
if (s[i] != decimalpoint[i])
goto pcheck;
}
decpt = s += i;
#else
if (*s != '.')
goto pcheck;
decpt = ++s;
#endif
if (!hexdig[*s])
goto pcheck;
while(*s == '0')
s++;
if (hexdig[*s])
zret = 0;
havedig = 1;
s0 = s;
}
while(hexdig[*s])
s++;
#ifdef USE_LOCALE
if (*s == *decimalpoint && !decpt) {
for(i = 1; decimalpoint[i]; ++i) {
if (s[i] != decimalpoint[i])
goto pcheck;
}
decpt = s += i;
#else
if (*s == '.' && !decpt) {
decpt = ++s;
#endif
while(hexdig[*s])
s++;
}/*}*/
if (decpt)
e = -(((Long)(s-decpt)) << 2);
pcheck:
s1 = s;
big = esign = 0;
switch(*s) {
case 'p':
case 'P':
switch(*++s) {
case '-':
esign = 1;
/* no break */
case '+':
s++;
}
if ((n = hexdig[*s]) == 0 || n > 0x19) {
s = s1;
break;
}
e1 = n - 0x10;
while((n = hexdig[*++s]) !=0 && n <= 0x19) {
if (e1 & 0xf8000000)
big = 1;
e1 = 10*e1 + n - 0x10;
}
if (esign)
e1 = -e1;
e += e1;
}
*sp = (char*)s;
if (!havedig)
*sp = (char*)s0 - 1;
if (zret)
return STRTOG_Zero;
if (big) {
if (esign) {
switch(fpi->rounding) {
case FPI_Round_up:
if (sign)
break;
goto ret_tiny;
case FPI_Round_down:
if (!sign)
break;
goto ret_tiny;
}
goto retz;
ret_tiny:
b = Balloc(0);
b->wds = 1;
b->x[0] = 1;
goto dret;
}
switch(fpi->rounding) {
case FPI_Round_near:
goto ovfl1;
case FPI_Round_up:
if (!sign)
goto ovfl1;
goto ret_big;
case FPI_Round_down:
if (sign)
goto ovfl1;
goto ret_big;
}
ret_big:
nbits = fpi->nbits;
n0 = n = nbits >> kshift;
if (nbits & kmask)
++n;
for(j = n, k = 0; j >>= 1; ++k);
*bp = b = Balloc(k);
b->wds = n;
for(j = 0; j < n0; ++j)
b->x[j] = ALL_ON;
if (n > n0)
b->x[j] = ULbits >> (ULbits - (nbits & kmask));
*exp = fpi->emin;
return STRTOG_Normal | STRTOG_Inexlo;
}
n = s1 - s0 - 1;
for(k = 0; n > 7; n >>= 1)
k++;
b = Balloc(k);
x = b->x;
n = 0;
L = 0;
#ifdef USE_LOCALE
for(i = 0; decimalpoint[i+1]; ++i);
#endif
while(s1 > s0) {
#ifdef USE_LOCALE
if (*--s1 == decimalpoint[i]) {
s1 -= i;
continue;
}
#else
if (*--s1 == '.')
continue;
#endif
if (n == 32) {
*x++ = L;
L = 0;
n = 0;
}
L |= (hexdig[*s1] & 0x0f) << n;
n += 4;
}
*x++ = L;
b->wds = n = x - b->x;
n = 32*n - hi0bits(L);
nbits = fpi->nbits;
lostbits = 0;
x = b->x;
if (n > nbits) {
n -= nbits;
if (any_on(b,n)) {
lostbits = 1;
k = n - 1;
if (x[k>>kshift] & 1 << (k & kmask)) {
lostbits = 2;
if (k > 0 && any_on(b,k))
lostbits = 3;
}
}
rshift(b, n);
e += n;
}
else if (n < nbits) {
static inline int32_t RVC_decoder__texture_V__DCRecontruction__invpreddc_scaler(ActorInstance_RVC_decoder__texture_V__DCRecontruction__invpred* thisActor){
return ((((thisActor->s_qp > 0) && (thisActor->s_qp < 5))) ? (8):(((((thisActor->s_qp > 4) && (thisActor->s_qp < 25))) ? (rshift((thisActor->s_qp + 13), 1)):((thisActor->s_qp - 6)))));
}
