static boolean
makered(int edge, boolean lastok)
/* Colour WHITE edge RED, return success.
lastok indicates if it is ok to add the final red edge */
{
int w1,w2,f1,f2;
w1 = v1[edge];
w2 = v2[edge];
if (reddeg[w1] == 2 || reddeg[w2] == 2) return FALSE;
f1 = redfarend[w1];
f2 = redfarend[w2];
if (f1 == w2 && !lastok) return FALSE;
SETVAL(colour[edge],RED);
SETVAL(reddeg[w1],reddeg[w1]+1);
SETVAL(reddeg[w2],reddeg[w2]+1);
SETVAL(redfarend[f1],f2);
SETVAL(redfarend[f2],f1);
PUSH(w1);
PUSH(w2);
PUSH(f1);
// PUSH(f2); not sure this one is needed
return TRUE;
}
R_API int r_anal_var_add (RAnal *a, ut64 addr, int scope, int delta, char kind, const char *type, int size, const char *name) {
char key[128], key2[128], val[128];
if (!kind) kind ='v';
switch (kind) {
case 'a':
case 'r':
case 'v':
break;
default:
eprintf ("Invalid var kind '%c'\n", kind);
return R_FALSE;
}
if (scope>0) {
// local
SETKEY("fcn.0x%"PFMT64x".%c", addr, kind);
SETVAL("var.0x%"PFMT64x".%c.%d.%d", addr, kind, scope, delta);
sdb_array_add (DB, key, val, 0);
strcpy (key, val);
SETVAL("%s,%d,%s", type, size, name);
sdb_set (DB, key, val, 0);
#if 0
fcn.0x80480.a=1.8,1.16
fcn.0x80480.a.1.8=type,size,name
fcn.0x80480.a.1.16=type,size,name
#endif
SETKEY("var.0x%"PFMT64x".%d.%d", addr, scope, delta);
// TODO: link to function
// fcn.<addr>.kind+=var.0x%"PFMT64x"..
} else {
// global
snprintf (key, sizeof(key), "var.0x%"PFMT64x, addr);
}
sdb_array_add (DB, key, val, 0);
return R_TRUE;
}
/* Expand group-4 data */
void
g4expand(struct pagenode *pn, drawfunc df)
{
int RunLength; /* Length of current run */
int a0; /* reference element */
int b1; /* next change on previous line */
int lastx = pn->size.width();/* copy line width to register */
pixnum *run0, *run1; /* run length arrays */
pixnum *thisrun, *pa, *pb; /* pointers into runs */
t16bits *sp; /* pointer into compressed data */
t32bits BitAcc; /* bit accumulator */
int BitsAvail; /* # valid bits in BitAcc */
int LineNum; /* line number */
int EOLcnt;
struct tabent *TabEnt;
sp = pn->data;
BitAcc = 0;
BitsAvail = 0;
/* allocate space for 2 runlength arrays */
run0 = (pixnum *) malloc(2 * ((lastx+5)&~1) * sizeof(pixnum));
run1 = run0 + ((lastx+5)&~1);
run1[0] = lastx; /* initial reference line */
run1[1] = 0;
for (LineNum = 0; LineNum < pn->rowsperstrip; ) {
#ifdef DEBUG_FAX
printf("\nBitAcc=%08lX, BitsAvail = %d\n", BitAcc, BitsAvail);
printf("-------------------- %d\n", LineNum);
fflush(stdout);
#endif
RunLength = 0;
if (LineNum & 1) {
pa = run1;
pb = run0;
}
else {
pa = run0;
pb = run1;
}
thisrun = pa;
a0 = 0;
b1 = *pb++;
expand2d(EOFB);
if (a0 < lastx) {
if ((pa - run0) & 1)
SETVAL(0);
SETVAL(lastx - a0);
}
SETVAL(0); /* imaginary change at end of line for reference */
(*df)(thisrun, LineNum++, pn);
continue;
EOFB:
NeedBits(13);
if (GetBits(13) != 0x1001 && verbose)
kError() << "Bad RTC\n";
break;
}
free(run0);
}
void SampleModel::drawUpperLeftLeg() {
glPushMatrix();
glTranslated(-0.9, -UPPER_TORSO_RADIUS - LOWER_TORSO_HEIGHT, 0);
glRotated(VAL(LEFTKNEE), -1.0, 0.0, 0.0);
glRotated(VAL(LEFTLEGX), -1.0, 0, 0);
glRotated(VAL(LEFTLEGZ), 0.0, 0, 1.0);
if (animate){
glRotated(animUpperLegAngle, 1.0, 0, 0);
SETVAL(LEFTKNEE, 0);
SETVAL(LEFTLEGX, 0);
SETVAL(LEFTLEGZ, 0);
}
glTranslated(0, -0.7, 0);
glRotated(90, 1.0, 0.0, 0.0);
glTranslated(0, 0, -0.6);
if (VAL(TEXTURESKIN)) {
drawTextureCylinder(1.2, 0.35, 0.35);
glTranslated(0, 0, 1.25);
drawTextureSphere(0.3);
}
else {
drawCylinder(1.2, 0.35, 0.35);
glTranslated(0, 0, 1.25);
drawSphere(0.3);
}
}
/* Expand tiff modified huffman data (g3-1d without EOLs) */
void
MHexpand(struct pagenode *pn, drawfunc df)
{
int a0; /* reference element */
int lastx; /* copy line width to register */
t32bits BitAcc; /* bit accumulator */
int BitsAvail; /* # valid bits in BitAcc */
int RunLength; /* Length of current run */
t16bits *sp; /* pointer into compressed data */
pixnum *pa; /* pointer into new line */
int EOLcnt; /* number of consecutive EOLs */
int LineNum; /* line number */
pixnum *runs; /* list of run lengths */
struct tabent *TabEnt;
sp = pn->data;
BitAcc = 0;
BitsAvail = 0;
lastx = pn->size.width();
runs = (pixnum *) malloc(lastx * sizeof(pixnum));
for (LineNum = 0; LineNum < pn->rowsperstrip; ) {
#ifdef DEBUG_FAX
printf("\nBitAcc=%08lX, BitsAvail = %d\n", BitAcc, BitsAvail);
printf("-------------------- %d\n", LineNum);
fflush(stdout);
#endif
RunLength = 0;
pa = runs;
a0 = 0;
EOLcnt = 0;
if (BitsAvail & 7) /* skip to byte boundary */
ClrBits(BitsAvail & 7);
expand1d();
if (RunLength)
SETVAL(0);
if (a0 != lastx) {
if (verbose)
kWarning() << "Line " << LineNum << ": length is "
<< a0 << " (expected "<< lastx << ")\n";
while (a0 > lastx)
a0 -= *--pa;
if (a0 < lastx) {
if ((pa - runs) & 1)
SETVAL(0);
SETVAL(lastx - a0);
}
}
(*df)(runs, LineNum++, pn);
}
free(runs);
}
void setRelease(configuration* _config, const char* _release)
{
assert(_config != NULL);
assert(_release != NULL);
SETVAL(_config->release, _release);
}
void setRemoteAddress(configuration* _config, const char* _address)
{
assert(_config != NULL);
assert(_address != NULL);
SETVAL(_config->remote_addr, _address);
}
void setGroup(configuration* _config, const char* _group)
{
assert(_config != NULL);
assert(_group != NULL);
SETVAL(_config->group, _group);
}
void SampleModel::drawLeftFoot() {
if (animate) {
glRotated(-animLowerLegAngle, 1.0, 0, 0);
SETVAL(LEFTKNEE,0);
}
// Undo Transformations
glTranslated(0, 0, 0.7);
glRotated(-90, 1.0, 0.0, 0.0);
glRotated(-VAL(LEFTKNEE) * 2, 1.0, 0.0, 0.0);
glTranslated(0.9, UPPER_TORSO_RADIUS + LOWER_TORSO_HEIGHT + 0.7 + 0.7 + 0.7, 0);
glTranslated(-0.9 - 0.2, -UPPER_TORSO_RADIUS - LOWER_TORSO_HEIGHT - 0.7 - 0.7 - 1.3, 0.4);
glTranslated(0, 0, -VAL(LEFTKNEE) / 50);
glRotated(30, 0.0, -1.0, 0.0);
glTranslated(0, 0, -0.3);
if (animate)
glRotated(animLeftFootAngle, 1.0, 0, 0);
if (VAL(TEXTURESKIN))
drawTextureCylinder(0.6, 0.25, 0.1);
else drawCylinder(0.6, 0.25, 0.1);
glPopMatrix();
}
void setUser(configuration* _config, const char* _user)
{
assert(_config != NULL);
assert(_user != NULL);
SETVAL(_config->user, _user);
}
void setInterfaceAddress(configuration* _config, const char* _address)
{
assert(_config != NULL);
assert(_address != NULL);
SETVAL(_config->interface_addr, _address);
_config->interface_addr_set = 1;
}
void setLogFilename(configuration* _config, const char* _filename)
{
assert(_config != NULL);
assert(_filename != NULL);
SETVAL(_config->log_filename, _filename);
_config->log_filename_set = 1;
}
void setBatteryScript(configuration* _config, const char* _script)
{
assert(_config != NULL);
assert(_script != NULL);
SETVAL(_config->battery_script, _script);
_config->battery_script_set = 1;
}
Widget* Alert::createDialog(const GUI::WidgetFactory& f)
{
GUI::SerialContainer* btns;
GUI::Window* win=f.window(title,
f.column(GUI::Contents(
f.text(text),
btns=f.buttonRow(GUI::Contents(
f.button(btn1, SETVAL(1)))
)
))
);
if(numButtons>1)
btns->add(f.button(btn2, SETVAL(2)));
if(numButtons==3)
btns->add(f.button(btn3, SETVAL(3)));
return win;
}
void SampleModel::drawLowerRightLeg(){
if (animate) {
glRotated(animLowerLegAngle, 1.0, 0, 0);
SETVAL(RIGHTKNEE, 0);
}
//Undo transformations
glTranslated(0, 0, -1.25);
glTranslated(0, 0, 0.6);
glRotated(-90, 1.0, 0.0, 0.0);
glTranslated(0, 0.7, 0);
glRotated(-VAL(RIGHTKNEE), -1.0, 0.0, 0.0);
glTranslated(-0.9, UPPER_TORSO_RADIUS + LOWER_TORSO_HEIGHT, 0);
glTranslated(0.9, -UPPER_TORSO_RADIUS - LOWER_TORSO_HEIGHT - 0.7 - 0.7 - 0.7, 0);
glRotated(VAL(RIGHTKNEE) * 2, 1.0, 0.0, 0.0);
glRotated(90, 1.0, 0.0, 0.0);
glTranslated(0, 0, -0.7);
if (VAL(TEXTURESKIN))
drawTextureCylinder(1.4, 0.35, 0.25);
else drawCylinder(1.4, 0.35, 0.25);
}
void restoreMood() {
SETVAL(XPOS, 0);
SETVAL(YPOS, 0);
SETVAL(ZPOS, 0);
SETVAL(SPIDER_ROTATE_Z, 0);
SETVAL(BODY_ROTATE_Z, 0);
SETVAL(LEFT_TOOTH_ROTATE_Y, -90);
SETVAL(RIGHT_TOOTH_ROTATE_Y, -90);
SETVAL(LEFT_ANTENNA_ROTATE_Y, -75);
SETVAL(LEFT_ANTENNA_ROTATE_X, -30);
SETVAL(LEFT_ANTENNA_UPPER_ROTATE_Y, -30);
SETVAL(LEFT_ANTENNA_UPPER_ROTATE_X, 45);
SETVAL(RIGHT_ANTENNA_ROTATE_Y, -105);
SETVAL(RIGHT_ANTENNA_ROTATE_X, -30);
SETVAL(RIGHT_ANTENNA_UPPER_ROTATE_Y, 30);
SETVAL(RIGHT_ANTENNA_UPPER_ROTATE_X, 45);
SETVAL(LEFT_LEG_1_1_ROTATE_Y, -60);
SETVAL(LEFT_LEG_1_1_ROTATE_X, -30);
SETVAL(LEFT_LEG_1_2_ROTATE_Y, -40);
SETVAL(LEFT_LEG_1_2_ROTATE_X, 50);
SETVAL(LEFT_LEG_1_3_ROTATE_Y, -20);
SETVAL(LEFT_LEG_1_3_ROTATE_X, 20);
SETVAL(LEFT_LEG_2_1_ROTATE_Y, -30);
SETVAL(LEFT_LEG_2_1_ROTATE_X, -25);
SETVAL(LEFT_LEG_2_2_ROTATE_Y, -30);
SETVAL(LEFT_LEG_2_2_ROTATE_X, 40);
SETVAL(LEFT_LEG_2_3_ROTATE_Y, -20);
SETVAL(LEFT_LEG_2_3_ROTATE_X, 30);
SETVAL(LEFT_LEG_3_1_ROTATE_Y, 20);
SETVAL(LEFT_LEG_3_1_ROTATE_X, -30);
SETVAL(LEFT_LEG_3_2_ROTATE_Y, 20);
SETVAL(LEFT_LEG_3_2_ROTATE_X, 50);
SETVAL(LEFT_LEG_3_3_ROTATE_Y, 20);
SETVAL(LEFT_LEG_3_3_ROTATE_X, 40);
SETVAL(LEFT_LEG_4_1_ROTATE_Y, 60);
SETVAL(LEFT_LEG_4_1_ROTATE_X, -20);
SETVAL(LEFT_LEG_4_2_ROTATE_Y, 20);
SETVAL(LEFT_LEG_4_2_ROTATE_X, 40);
SETVAL(LEFT_LEG_4_3_ROTATE_Y, 20);
SETVAL(LEFT_LEG_4_3_ROTATE_X, 20);
SETVAL(RIGHT_LEG_1_1_ROTATE_Y, -120);
SETVAL(RIGHT_LEG_1_1_ROTATE_X, -30);
SETVAL(RIGHT_LEG_1_2_ROTATE_Y, 40);
SETVAL(RIGHT_LEG_1_2_ROTATE_X, 50);
SETVAL(RIGHT_LEG_1_3_ROTATE_Y, 20);
SETVAL(RIGHT_LEG_1_3_ROTATE_X, 20);
SETVAL(RIGHT_LEG_2_1_ROTATE_Y, -150);
SETVAL(RIGHT_LEG_2_1_ROTATE_X, -25);
SETVAL(RIGHT_LEG_2_2_ROTATE_Y, 30);
SETVAL(RIGHT_LEG_2_2_ROTATE_X, 40);
SETVAL(RIGHT_LEG_2_3_ROTATE_Y, 20);
SETVAL(RIGHT_LEG_2_3_ROTATE_X, 30);
SETVAL(RIGHT_LEG_3_1_ROTATE_Y, 160);
SETVAL(RIGHT_LEG_3_1_ROTATE_X, -30);
SETVAL(RIGHT_LEG_3_2_ROTATE_Y, -20);
SETVAL(RIGHT_LEG_3_2_ROTATE_X, 50);
SETVAL(RIGHT_LEG_3_3_ROTATE_Y, -20);
SETVAL(RIGHT_LEG_3_3_ROTATE_X, 40);
SETVAL(RIGHT_LEG_4_1_ROTATE_Y, 120);
SETVAL(RIGHT_LEG_4_1_ROTATE_X, -20);
SETVAL(RIGHT_LEG_4_2_ROTATE_Y, -20);
SETVAL(RIGHT_LEG_4_2_ROTATE_X, 40);
SETVAL(RIGHT_LEG_4_3_ROTATE_Y, -20);
SETVAL(RIGHT_LEG_4_3_ROTATE_X, 20);
SETVAL(SPINNERET_ROTATE_Y, 90);
SETVAL(SPINNERET_ROTATE_X, 0);
}
void animate() {
SETVAL(XPOS, VAL(XPOS) + 1);
}
/* Expand group-3 1-dimensional data */
void
g31expand(struct pagenode *pn, drawfunc df)
{
int a0; /* reference element */
int lastx; /* copy line width to register */
t32bits BitAcc; /* bit accumulator */
int BitsAvail; /* # valid bits in BitAcc */
int RunLength; /* Length of current run */
t16bits *sp; /* pointer into compressed data */
pixnum *pa; /* pointer into new line */
int EOLcnt; /* number of consecutive EOLs */
int LineNum; /* line number */
pixnum *runs; /* list of run lengths */
struct tabent *TabEnt;
sp = pn->data;
BitAcc = 0;
BitsAvail = 0;
lastx = pn->size.width();
runs = (pixnum *) malloc(lastx * sizeof(pixnum));
EOLcnt = 0;
for (LineNum = 0; LineNum < pn->rowsperstrip; ) {
#ifdef DEBUG_FAX
fprintf(stderr,"\nBitAcc=%08lX, BitsAvail = %d\n", BitAcc, BitsAvail);
fprintf(stderr,"-------------------- %d\n", LineNum);
fflush(stderr);
#endif
if (EOLcnt == 0)
while (!EndOfData(pn)) {
/* skip over garbage after a coding error */
NeedBits(11);
if (GetBits(11) == 0)
break;
ClrBits(1);
}
for (EOLcnt = 1; !EndOfData(pn); EOLcnt++) {
/* we have seen 11 zeros, which implies EOL,
skip possible fill bits too */
while (1) {
NeedBits(8);
if (GetBits(8))
break;
ClrBits(8);
}
while (GetBits(1) == 0)
ClrBits(1);
ClrBits(1); /* the eol flag */
NeedBits(11);
if (GetBits(11))
break;
ClrBits(11);
}
if (EOLcnt > 1 && EOLcnt != 6 && verbose) {
kError() << "Line " << LineNum << ": bad RTC (" << EOLcnt << " EOLs)\n";
}
if (EOLcnt >= 6 || EndOfData(pn)) {
free(runs);
return;
}
RunLength = 0;
pa = runs;
a0 = 0;
EOLcnt = 0;
expand1d();
if (RunLength)
SETVAL(0);
if (a0 != lastx) {
if (verbose)
kWarning() << "Line " << LineNum << ": length is "
<< a0 << " (expected "<< lastx << ")\n";
while (a0 > lastx)
a0 -= *--pa;
if (a0 < lastx) {
if ((pa - runs) & 1)
SETVAL(0);
SETVAL(lastx - a0);
}
}
(*df)(runs, LineNum++, pn);
}
free(runs);
}
void setMood() {
if (VAL(MOOD) != 0) {
restoreMood();
if (VAL(MOOD) == 2) { // attack
SETVAL(YPOS, 0.8f);
SETVAL(BODY_ROTATE_Z, -40);
SETVAL(LEFT_ANTENNA_ROTATE_Y, -90);
SETVAL(LEFT_ANTENNA_ROTATE_X, 0);
SETVAL(LEFT_ANTENNA_UPPER_ROTATE_Y, 0);
SETVAL(LEFT_ANTENNA_UPPER_ROTATE_X, 60);
SETVAL(RIGHT_ANTENNA_ROTATE_Y, -90);
SETVAL(RIGHT_ANTENNA_ROTATE_X, 0);
SETVAL(RIGHT_ANTENNA_UPPER_ROTATE_Y, 0);
SETVAL(RIGHT_ANTENNA_UPPER_ROTATE_X, 60);
SETVAL(LEFT_LEG_1_1_ROTATE_Y, -60);
SETVAL(LEFT_LEG_1_1_ROTATE_X, -60);
SETVAL(LEFT_LEG_1_2_ROTATE_Y, -40);
SETVAL(LEFT_LEG_1_2_ROTATE_X, 50);
SETVAL(LEFT_LEG_1_3_ROTATE_Y, -50);
SETVAL(LEFT_LEG_1_3_ROTATE_X, 20);
SETVAL(LEFT_LEG_2_1_ROTATE_Y, 0);
SETVAL(LEFT_LEG_2_1_ROTATE_X, 5);
SETVAL(LEFT_LEG_2_2_ROTATE_Y, 0);
SETVAL(LEFT_LEG_2_2_ROTATE_X, 70);
SETVAL(LEFT_LEG_2_3_ROTATE_Y, -20);
SETVAL(LEFT_LEG_2_3_ROTATE_X, 0);
SETVAL(LEFT_LEG_3_1_ROTATE_Y, 40);
SETVAL(LEFT_LEG_3_1_ROTATE_X, -30);
SETVAL(LEFT_LEG_3_2_ROTATE_Y, -10);
SETVAL(LEFT_LEG_3_2_ROTATE_X, 50);
SETVAL(LEFT_LEG_3_3_ROTATE_Y, -10);
SETVAL(LEFT_LEG_3_3_ROTATE_X, 70);
SETVAL(LEFT_LEG_4_1_ROTATE_Y, 60);
SETVAL(LEFT_LEG_4_1_ROTATE_X, -50);
SETVAL(LEFT_LEG_4_2_ROTATE_Y, 20);
SETVAL(LEFT_LEG_4_2_ROTATE_X, 40);
SETVAL(LEFT_LEG_4_3_ROTATE_Y, -10);
SETVAL(LEFT_LEG_4_3_ROTATE_X, 50);
SETVAL(RIGHT_LEG_1_1_ROTATE_Y, -120);
SETVAL(RIGHT_LEG_1_1_ROTATE_X, -60);
SETVAL(RIGHT_LEG_1_2_ROTATE_Y, 40);
SETVAL(RIGHT_LEG_1_2_ROTATE_X, 50);
SETVAL(RIGHT_LEG_1_3_ROTATE_Y, 20);
SETVAL(RIGHT_LEG_1_3_ROTATE_X, 50);
SETVAL(RIGHT_LEG_2_1_ROTATE_Y, -180);
SETVAL(RIGHT_LEG_2_1_ROTATE_X, 5);
SETVAL(RIGHT_LEG_2_2_ROTATE_Y, 0);
SETVAL(RIGHT_LEG_2_2_ROTATE_X, 70);
SETVAL(RIGHT_LEG_2_3_ROTATE_Y, 20);
SETVAL(RIGHT_LEG_2_3_ROTATE_X, 0);
SETVAL(RIGHT_LEG_3_1_ROTATE_Y, 140);
SETVAL(RIGHT_LEG_3_1_ROTATE_X, -30);
SETVAL(RIGHT_LEG_3_2_ROTATE_Y, 10);
SETVAL(RIGHT_LEG_3_2_ROTATE_X, 50);
SETVAL(RIGHT_LEG_3_3_ROTATE_Y, 10);
SETVAL(RIGHT_LEG_3_3_ROTATE_X, 70);
SETVAL(RIGHT_LEG_4_1_ROTATE_Y, 120);
SETVAL(RIGHT_LEG_4_1_ROTATE_X, -50);
SETVAL(RIGHT_LEG_4_2_ROTATE_Y, -20);
SETVAL(RIGHT_LEG_4_2_ROTATE_X, 40);
SETVAL(RIGHT_LEG_4_3_ROTATE_Y, 10);
SETVAL(RIGHT_LEG_4_3_ROTATE_X, 50);
SETVAL(SPINNERET_ROTATE_Y, -15);
} else if (VAL(MOOD) == 3) { // dead
SETVAL(SPIDER_ROTATE_Z, -180);
SETVAL(LEFT_ANTENNA_ROTATE_X, 0);
SETVAL(LEFT_ANTENNA_UPPER_ROTATE_X, 60);
SETVAL(RIGHT_ANTENNA_ROTATE_X, 0);
SETVAL(RIGHT_ANTENNA_UPPER_ROTATE_X, 60);
SETVAL(LEFT_LEG_1_1_ROTATE_X, 0);
SETVAL(LEFT_LEG_1_2_ROTATE_X, 80);
SETVAL(LEFT_LEG_1_3_ROTATE_X, 50);
SETVAL(LEFT_LEG_2_1_ROTATE_X, 5);
SETVAL(LEFT_LEG_2_2_ROTATE_X, 70);
SETVAL(LEFT_LEG_2_3_ROTATE_X, 60);
SETVAL(LEFT_LEG_3_1_ROTATE_X, 0);
SETVAL(LEFT_LEG_3_2_ROTATE_X, 80);
SETVAL(LEFT_LEG_3_3_ROTATE_X, 70);
SETVAL(LEFT_LEG_4_1_ROTATE_X, 10);
SETVAL(LEFT_LEG_4_2_ROTATE_X, 70);
SETVAL(LEFT_LEG_4_3_ROTATE_X, 50);
SETVAL(RIGHT_LEG_1_1_ROTATE_X, 0);
SETVAL(RIGHT_LEG_1_2_ROTATE_X, 80);
SETVAL(RIGHT_LEG_1_3_ROTATE_X, 50);
SETVAL(RIGHT_LEG_2_1_ROTATE_X, 5);
SETVAL(RIGHT_LEG_2_2_ROTATE_X, 70);
SETVAL(RIGHT_LEG_2_3_ROTATE_X, 60);
SETVAL(RIGHT_LEG_3_1_ROTATE_X, 0);
SETVAL(RIGHT_LEG_3_2_ROTATE_X, 80);
SETVAL(RIGHT_LEG_3_3_ROTATE_X, 70);
SETVAL(RIGHT_LEG_4_1_ROTATE_X, 10);
SETVAL(RIGHT_LEG_4_2_ROTATE_X, 70);
SETVAL(RIGHT_LEG_4_3_ROTATE_X, 50);
}
}
}
/* Expand group-3 2-dimensional data */
void
g32expand(struct pagenode *pn, drawfunc df)
{
int RunLength; /* Length of current run */
int a0; /* reference element */
int b1; /* next change on previous line */
int lastx = pn->size.width();/* copy line width to register */
pixnum *run0, *run1; /* run length arrays */
pixnum *thisrun, *pa, *pb; /* pointers into runs */
t16bits *sp; /* pointer into compressed data */
t32bits BitAcc; /* bit accumulator */
int BitsAvail; /* # valid bits in BitAcc */
int EOLcnt; /* number of consecutive EOLs */
int refline = 0; /* 1D encoded reference line */
int LineNum; /* line number */
struct tabent *TabEnt;
sp = pn->data;
BitAcc = 0;
BitsAvail = 0;
/* allocate space for 2 runlength arrays */
run0 = (pixnum *) malloc(2 * ((lastx+5)&~1) * sizeof(pixnum));
run1 = run0 + ((lastx+5)&~1);
run1[0] = lastx;
run1[1] = 0;
EOLcnt = 0;
for (LineNum = 0; LineNum < pn->rowsperstrip; ) {
#ifdef DEBUG_FAX
printf("\nBitAcc=%08lX, BitsAvail = %d\n", BitAcc, BitsAvail);
printf("-------------------- %d\n", LineNum);
fflush(stdout);
#endif
if (EOLcnt == 0)
while (!EndOfData(pn)) {
/* skip over garbage after a coding error */
NeedBits(11);
if (GetBits(11) == 0)
break;
ClrBits(1);
}
for (EOLcnt = 1; !EndOfData(pn); EOLcnt++) {
/* we have seen 11 zeros, which implies EOL,
skip possible fill bits too */
while (1) {
NeedBits(8);
if (GetBits(8))
break;
ClrBits(8);
}
while (GetBits(1) == 0)
ClrBits(1);
ClrBits(1); /* the eol flag */
NeedBits(12);
refline = GetBits(1); /* 1D / 2D flag */
ClrBits(1);
if (GetBits(11))
break;
ClrBits(11);
}
if (EOLcnt > 1 && EOLcnt != 6 && verbose)
kError() << "Line " << LineNum << ": bad RTC (" << EOLcnt << " EOLs)\n";
if (EOLcnt >= 6 || EndOfData(pn)) {
free(run0);
return;
}
if (LineNum == 0 && refline == 0 && verbose)
kDebug() << "First line is 2-D encoded\n";
RunLength = 0;
if (LineNum & 1) {
pa = run1;
pb = run0;
}
else {
pa = run0;
pb = run1;
}
thisrun = pa;
EOLcnt = 0;
a0 = 0;
b1 = *pb++;
if (refline) {
expand1d();
}
else {
expand2d(EOL2);
}
if (RunLength)
SETVAL(0);
if (a0 != lastx) {
if (verbose)
kWarning() << "Line " << LineNum << ": length is "
<< a0 << " (expected "<< lastx << ")\n";
while (a0 > lastx)
a0 -= *--pa;
if (a0 < lastx) {
if ((pa - run0) & 1)
SETVAL(0);
SETVAL(lastx - a0);
}
}
SETVAL(0); /* imaginary change at end of line for reference */
(*df)(thisrun, LineNum++, pn);
}
free(run0);
}
