Cronocide/Descent3
1
0
Fork 0
mirror of https://github.com/kevinbentley/Descent3.git synced 2025-01-22 19:55:23 +00:00
Code Issues Packages Projects Releases Wiki Activity
db8aa64d2f
Descent3/lnxmvelib/mveasm.cpp

1631 lines
50 KiB
C++
Raw Blame History

/*
** mveasm.cpp
**
** Interplay Movie File (MVE) Player Library (32-Bit Linux Version)
** Written by Paul Allen Edelstein. Partial Linux port by Jeff Slutter.
**
** (c) 1997 Interplay Productions. All Rights Reserved.
** This file is confidential and consists of proprietary information
** of Interplay Productions. This file and associated libraries
** may not, in whole or in part, be disclosed to third parties,
** incorporated into any software product which is not being created
** for Interplay Productions, copied or duplicated in any form,
** without the prior written permission of Interplay Productions.
** Further, you may not reverse engineer, decompile or otherwise
** attempt to derive source code of this material.
**
*/
#include "mvelibl.h"
#include "mvelibi.h"
#include "byteswap.h"
// rcg07272000
// need this for SIGTRAP on non-Intel platforms. Intel uses int $3.
#if (!defined __i386__)
#include <signal.h>
#endif
extern uint8_t *nf_buf_cur;
extern uint8_t *nf_buf_prv;
extern unsigned nf_new_x;
extern unsigned nf_new_y;
extern unsigned nf_new_w;
extern unsigned nf_new_h;
extern uint8_t nf_fqty; // Number of fields
extern unsigned nf_new_row0; // SHEIGHT*width*2-width
extern unsigned nf_width; // wqty * SWIDTH
extern unsigned nf_new_line; // width - SWIDTH
extern unsigned nf_back_right; // (SHEIGHT-1)*width
extern int16_t snd_8to16[256];
void nfHPkDecomp(uint8_t *ops, uint8_t *comp, int x, int y, int w, int h);
void nfPkConfig(void);
unsigned sndDecompM16(uint16_t *dst, const uint8_t *src, unsigned len, unsigned prev);
unsigned sndDecompS16(uint16_t *dst, const uint8_t *src, unsigned len, unsigned prev);
void Trans16Blk(uint8_t *edi, uint8_t *idx);
void call_hnfxycshift(uint32_t eax, uint8_t **medi, uint8_t **mesi, int nfpk_back_right);
void call_hnfxypshift(uint32_t eax, uint8_t **medi, uint8_t **mesi, int nfpk_back_right,
int DiffBufPtrs);
void call_hnfshift(uint32_t meax, uint8_t **medi, uint8_t **mesi, int nfpk_back_right);
//--------------------------------------------------------------------
// Sound Management
//--------------------
// Decompresses a mono stream containing len samples
// (src is len bytes, dst is len*2 bytes)
// prev is the previous decompression state or zero.
// Returns new decompression state.
unsigned sndDecompM16(uint16_t *dst, const uint8_t *src, unsigned len, unsigned prev) {
uint32_t i, eax, ebx;
if (len == 0)
return prev;
eax = prev;
ebx = 0;
for (i = 0; i < len; i++) {
ebx = *src;
src++;
eax += snd_8to16[ebx];
*dst = eax & 0xFFFF;
dst++;
}
return eax;
}
// Decompresses a stereo stream containing len samples
// (src is len*2 bytes, dst is len*4 bytes)
// prev is the previous decompression state or zero
// (It encodes the 16-bit states of the two stereo channels
// in its low and high order 16-bit halves.)
// Returns new decompression state.
unsigned sndDecompS16(uint16_t *dst, const uint8_t *src, unsigned len, unsigned prev) {
unsigned re = 0;
uint32_t eax, edx, ebx, i;
if (len == 0) {
return prev;
}
eax = (prev & 0xFFFF);
edx = ((prev & 0xFFFF0000) >> 16);
ebx = 0;
for (i = 0; i < len; i++) {
ebx = *src;
src++;
eax += snd_8to16[ebx];
*dst = (eax & 0xFFFF);
dst++;
ebx = *src;
src++;
edx += snd_8to16[ebx];
*dst = (edx & 0xFFFF);
dst++;
}
return (eax & 0xFFFF) | ((edx & 0xFFFF) << 16);
}
struct tNextFrame {
uint8_t *comp;
uint8_t *tbuf;
int new_row, DiffBufPtrs, parms_sz;
unsigned x, y, w, h;
};
// NOTE: On exit ebx is nf_fqty
void NF_DECOMP_INIT(bool HI_COLOR_FLAG, tNextFrame *nf) {
nf->DiffBufPtrs = nf_buf_prv - nf_buf_cur;
if (HI_COLOR_FLAG) {
nf_new_x = nf->x << (LOG2_SWIDTH + 1);
nf_new_w = nf->w << (LOG2_SWIDTH + 1);
} else {
nf_new_x = nf->x << LOG2_SWIDTH;
nf_new_w = nf->w << LOG2_SWIDTH;
}
nf_new_y = (nf->y << LOG2_SHEIGHT) * nf_fqty;
nf_new_h = (nf->h << LOG2_SHEIGHT) * nf_fqty;
nf->new_row = nf_new_row0 - nf_new_w;
// Move to correct place in current buffer
nf->tbuf = nf_buf_cur;
if (nf->x || nf->y) {
nf->tbuf += nf_new_y * nf_width + nf_new_x;
}
}
//----------------------------------------------------------------------
// signed 8-bit y * nf_width
int32_t nfpk_ShiftY[256];
// Constant tables
// 8-bit -8:7 x nf_width + -8:7
int16_t nfpk_ShiftP1[256];
int16_t nfpk_ShiftP2[256];
// Constant tables
// mov eax, ebx/ecx
// EBX = 0
// ECX = 1
uint8_t nfhpk_mov4l[64];
// mov ds:[edi+0/4/8/12], ebx/edx/ecx/ebp
// EBX = 0
// EDX = 1
// ECX = 2
// EBP = 3
uint8_t nfhpk_mov8[1024];
// mov eax, ebx/edx/ecx/ebp
// EBX = 0
// EDX = 1
// ECX = 2
// EBP = 3
uint8_t nfhpk_mov4[1024];
class initme {
public:
initme() {
int x, y;
int m4, m3, m2, m1;
int8_t *ptr;
uint8_t *uptr;
// Do nfhpk_mov4l
uptr = nfhpk_mov4l;
for (m4 = 0; m4 < 2; m4++)
for (m3 = 0; m3 < 2; m3++)
for (m2 = 0; m2 < 2; m2++)
for (m1 = 0; m1 < 2; m1++) {
*uptr = m1;
uptr++;
*uptr = m2;
uptr++;
*uptr = m3;
uptr++;
*uptr = m4;
uptr++;
}
// Do nfhpk_mov8
uptr = nfhpk_mov8;
for (m4 = 0; m4 < 4; m4++)
for (m3 = 0; m3 < 4; m3++)
for (m2 = 0; m2 < 4; m2++)
for (m1 = 0; m1 < 4; m1++) {
*uptr = m1;
uptr++;
*uptr = m2;
uptr++;
*uptr = m3;
uptr++;
*uptr = m4;
uptr++;
}
// Do nfhpk_mov4
uptr = nfhpk_mov4;
for (m4 = 0; m4 < 4; m4++)
for (m3 = 0; m3 < 4; m3++)
for (m2 = 0; m2 < 4; m2++)
for (m1 = 0; m1 < 4; m1++) {
*uptr = m1;
uptr++;
*uptr = m2;
uptr++;
*uptr = m3;
uptr++;
*uptr = m4;
uptr++;
}
// do nfpk_ShiftP1
ptr = (int8_t *)nfpk_ShiftP1;
for (y = -8; y != 8; y++) {
for (x = -8; x != 8; x++) {
#ifdef OUTRAGE_BIG_ENDIAN
*(ptr) = y;
*(ptr + 1) = x;
#else
*(ptr) = x;
*(ptr + 1) = y;
#endif
ptr += 2;
}
}
// do nfpk_ShiftP2[]
ptr = (int8_t *)nfpk_ShiftP2;
for (y = 0; y != 8; y++) {
for (x = 8; x != 15; x++) {
#ifdef OUTRAGE_BIG_ENDIAN
*(ptr) = y;
*(ptr + 1) = x;
#else
*(ptr) = x;
*(ptr + 1) = y;
#endif
ptr += 2;
}
}
for (y = 8; y != 14; y++) {
for (x = -14; x != 0; x++) {
*(ptr) = x;
*(ptr + 1) = y;
ptr += 2;
}
for (x = 0; x != 15; x++) {
*(ptr) = x;
*(ptr + 1) = y;
ptr += 2;
}
}
for (x = -14; x != 0; x++) {
*(ptr) = x;
*(ptr + 1) = 14;
ptr += 2;
}
for (x = 0; x != 12; x++) {
*(ptr) = x;
*(ptr + 1) = 14;
ptr += 2;
}
}
};
initme _initme;
// nfPkConfig initializes tables used by nfPkDecomp
// which are dependent on screen size.
void nfPkConfig(void) {
// Build ShiftY table
int i, val, index;
val = 0;
index = 0;
for (i = 0; i < 128; i++) {
nfpk_ShiftY[index] = val;
index++;
val += nf_width;
}
val = nf_width;
val = val << 7;
val = -val;
for (i = 0; i < 128; i++) {
nfpk_ShiftY[index] = val;
index++;
val += nf_width;
}
}
extern uint16_t nf_trans16_lo[256];
extern uint16_t nf_trans16_hi[256];
// NOTE: EAX is destroyed after this call (actually the value of
// nf_trans16_hi[idx+1]
void Trans16(uint16_t *dst, uint16_t *idx, bool mask) {
*dst = nf_trans16_lo[*idx];
*dst |= nf_trans16_hi[*(idx + 1)];
}
// HiColor version
//
void nfHPkDecomp(uint8_t *ops, uint8_t *comp, unsigned x, unsigned y, unsigned w, unsigned h) {
tNextFrame nf;
nf.w = w;
nf.h = h;
nf.x = x;
nf.y = y;
int nfpk_back_right, wcnt;
uint8_t *bcomp;
uint8_t *esi, *edi;
uint8_t opcode;
NF_DECOMP_INIT(1, &nf);
nfpk_back_right = nf_back_right - SWIDTH * 2;
esi = comp;
edi = nf.tbuf;
uint16_t swapped = (*(uint16_t *)esi);
swapped = INTEL_SHORT(swapped);
bcomp = swapped + esi;
esi = esi + 2;
wcnt = w >> 1;
do {
wcnt--;
if (wcnt >= 0) {
opcode = *ops; // al == opcode
ops++;
bool first_opcode = true;
int opcode_to_use = opcode & 0xF;
do_next_opcode:
switch (opcode_to_use) {
case 0: {
// No change from previous buffer
call_hnfshift(nf.DiffBufPtrs, &edi, &esi, nfpk_back_right);
} break;
case 1: {
// No change (and copied to screen) (0)
edi += SWIDTH * 2;
} break;
case 2: {
uint32_t eax;
eax = *bcomp;
bcomp++;
eax = nfpk_ShiftP2[eax];
call_hnfxycshift(eax, &edi, &esi, nfpk_back_right);
} break;
case 3: {
// Near shift from newer part of current buffer
#ifdef OUTRAGE_BIG_ENDIAN
struct reg_word {
uint16_t hax, ax;
};
struct reg_byte {
int8_t hah, hal, ah, al;
};
#else
struct reg_word {
uint16_t ax, hax;
};
struct reg_byte {
int8_t al, ah, hal, hah;
};
#endif
union {
uint32_t eax;
reg_word word;
reg_byte byte;
} myeax;
myeax.eax = *bcomp;
bcomp++;
myeax.word.ax = nfpk_ShiftP2[myeax.eax];
myeax.byte.al = -myeax.byte.al;
myeax.byte.ah = -myeax.byte.ah;
call_hnfxycshift(myeax.eax, &edi, &esi, nfpk_back_right);
} break;
case 4: {
// Near shift from previous buffer
#ifdef OUTRAGE_BIG_ENDIAN
struct reg_word {
uint16_t hax, ax;
};
struct reg_byte {
int8_t hah, hal, ah, al;
};
#else
struct reg_word {
uint16_t ax, hax;
};
struct reg_byte {
int8_t al, ah, hal, hah;
};
#endif
union {
uint32_t eax;
reg_word word;
reg_byte byte;
} myeax;
myeax.eax = 0;
myeax.byte.al = *bcomp;
bcomp++;
myeax.word.ax = nfpk_ShiftP1[myeax.eax];
call_hnfxypshift(myeax.eax, &edi, &esi, nfpk_back_right, nf.DiffBufPtrs);
} break;
case 5: {
uint16_t swapper = *(uint16_t *)(esi);
uint32_t eax = INTEL_SHORT(swapper);
esi += 2;
call_hnfxypshift(eax, &edi, &esi, nfpk_back_right, nf.DiffBufPtrs);
} break;
case 6: {
// Far shift from current buffer
uint32_t val1, val2;
uint16_t swapper = *(uint16_t *)(esi);
val1 = INTEL_SHORT(swapper);
esi += 2;
val2 = ((val1 & 0xFF00) >> 8);
// sign extend al into eax, and multiply by two
if (val1 & 0x80) {
val1 = ((val1 & 0x7F) << 1);
val1 = (val1 & 0xFF) | 0xFFFFFF00;
} else {
val1 = ((val1 & 0x7F) << 1);
}
val1 += nfpk_ShiftY[val2];
call_hnfshift(val1, &edi, &esi, nfpk_back_right);
} break;
case 7: {
bool donf23 = false;
uint16_t val;
int rep_count, max_repcount;
val = *(uint16_t *)esi;
val = INTEL_SHORT(val);
if (val & 0x8000) {
donf23 = true;
}
if (!donf23) {
uint32_t colors[4];
max_repcount = 8;
uint32_t temp_color;
temp_color = nf_trans16_lo[*(esi + 2)] | nf_trans16_hi[*(esi + 3)];
temp_color = (nf_trans16_lo[*(esi + 0)] | nf_trans16_hi[*(esi + 1)]) | (temp_color << 16);
colors[2] = temp_color;
temp_color = ((temp_color & 0xFFFF0000) >> 16) | ((temp_color & 0xFFFF) << 16);
colors[0] = (temp_color & 0xFFFF0000) | (colors[2] & 0xFFFF);
colors[1] = temp_color;
colors[3] = (colors[2] & 0xFFFF0000) | (colors[1] & 0xFFFF);
for (rep_count = 0; rep_count < max_repcount; rep_count++) {
uint32_t w1, w2, w3, w4;
uint32_t color_idx;
int idx;
idx = rep_count + 4;
color_idx = *(uint32_t *)(nfhpk_mov8 + ((*(esi + idx)) * 4));
w1 = colors[color_idx & 0x000000FF];
w2 = colors[(color_idx & 0x0000FF00) >> 8];
w3 = colors[(color_idx & 0x00FF0000) >> 16];
w4 = colors[(color_idx & 0xFF000000) >> 24];
*(uint32_t *)(edi + 0) = w1;
*(uint32_t *)(edi + 4) = w2;
*(uint32_t *)(edi + 8) = w3;
*(uint32_t *)(edi + 12) = w4;
if (rep_count != (max_repcount - 1))
edi += nf_width;
}
esi += 12;
edi -= nfpk_back_right;
} else {
uint32_t colors[2];
max_repcount = 4;
uint32_t temp;
temp = nf_trans16_lo[*(esi)] | nf_trans16_hi[*(esi + 1)];
colors[0] = (temp << 16) | temp;
temp = nf_trans16_lo[*(esi + 2)] | nf_trans16_hi[*(esi + 3)];
colors[1] = (temp << 16) | temp;
for (rep_count = 0; rep_count < max_repcount; rep_count++) {
uint32_t w1, w2, w3, w4;
uint32_t color_idx;
int idx;
// 4l,4h,5l,5h (nibbles)
switch (rep_count) {
case 0:
idx = (*(esi + 4)) & 0xF;
break;
case 1:
idx = ((*(esi + 4)) >> 4);
break;
case 2:
idx = (*(esi + 5)) & 0xF;
break;
case 3:
idx = ((*(esi + 5)) >> 4);
break;
}
color_idx = *(uint32_t *)(nfhpk_mov4l + (idx * 4));
w1 = colors[color_idx & 0x000000FF];
w2 = colors[(color_idx & 0x0000FF00) >> 8];
w3 = colors[(color_idx & 0x00FF0000) >> 16];
w4 = colors[(color_idx & 0xFF000000) >> 24];
*(uint32_t *)(edi + 0) = w1;
*(uint32_t *)(edi + nf_width) = w1;
*(uint32_t *)(edi + 4) = w2;
*(uint32_t *)(edi + nf_width + 4) = w2;
*(uint32_t *)(edi + 8) = w3;
*(uint32_t *)(edi + nf_width + 8) = w3;
*(uint32_t *)(edi + 12) = w4;
*(uint32_t *)(edi + nf_width + 12) = w4;
if (rep_count != (max_repcount - 1))
edi = edi + nf_width * 2;
}
edi += nf_width;
edi -= nfpk_back_right;
esi += 6;
}
} break;
case 8: {
bool donf24 = false;
bool donf40 = false;
uint16_t val;
int rep_count, max_repcount;
val = *(uint16_t *)esi;
val = INTEL_SHORT(val);
if (val & 0x8000) {
val = *(uint16_t *)(esi + 8);
val = INTEL_SHORT(val);
if (val & 0x8000) {
donf40 = true;
} else {
donf24 = true;
}
}
if (!donf24 && !donf40) {
uint32_t colors[4];
max_repcount = 8;
uint32_t tempcolor;
tempcolor = nf_trans16_lo[*(esi + 2)] | nf_trans16_hi[*(esi + 3)];
tempcolor = (tempcolor << 16) | (nf_trans16_lo[*(esi + 0)] | nf_trans16_hi[*(esi + 1)]);
colors[2] = tempcolor;
tempcolor = ((tempcolor & 0xFFFF0000) >> 16) | ((tempcolor & 0xFFFF) << 16);
colors[0] = (tempcolor & 0xFFFF0000) | (colors[2] & 0xFFFF);
colors[1] = tempcolor;
colors[3] = (colors[2] & 0xFFFF0000) | (colors[1] & 0xFFFF);
for (rep_count = 0; rep_count < max_repcount; rep_count++) {
uint32_t w1, w2, w3, w4;
uint32_t color_idx;
int idx;
switch (rep_count) {
case 0:
idx = 4;
break;
case 1:
idx = 5;
break;
case 2:
idx = 10;
break;
case 3:
idx = 11;
break;
case 4:
idx = 16;
break;
case 5:
idx = 17;
break;
case 6:
idx = 22;
break;
case 7:
idx = 23;
break;
}
color_idx = *(uint32_t *)(nfhpk_mov8 + (*(esi + idx) * 4));
w1 = colors[color_idx & 0x000000FF];
w2 = colors[(color_idx & 0x0000FF00) >> 8];
w3 = colors[(color_idx & 0x00FF0000) >> 16];
w4 = colors[(color_idx & 0xFF000000) >> 24];
*(uint32_t *)(edi + 0) = w1;
*(uint32_t *)(edi + 4) = w2;
edi += nf_width;
*(uint32_t *)(edi + 0) = w3;
*(uint32_t *)(edi + 4) = w4;
if (rep_count != (max_repcount - 1))
edi += nf_width;
if (rep_count == 1) {
tempcolor = nf_trans16_lo[*(esi + 8)] | nf_trans16_hi[*(esi + 9)];
tempcolor = (tempcolor << 16) | (nf_trans16_lo[*(esi + 6)] | nf_trans16_hi[*(esi + 7)]);
colors[2] = tempcolor;
tempcolor = ((tempcolor & 0xFFFF0000) >> 16) | ((tempcolor & 0xFFFF) << 16);
colors[0] = (tempcolor & 0xFFFF0000) | (colors[2] & 0xFFFF);
colors[1] = tempcolor;
colors[3] = (colors[2] & 0xFFFF0000) | (colors[1] & 0xFFFF);
}
if (rep_count == 3) {
edi -= nf_width * 8 - 8;
tempcolor = nf_trans16_lo[*(esi + 14)] | nf_trans16_hi[*(esi + 15)];
tempcolor = (tempcolor << 16) | (nf_trans16_lo[*(esi + 12)] | nf_trans16_hi[*(esi + 13)]);
colors[2] = tempcolor;
tempcolor = ((tempcolor & 0xFFFF0000) >> 16) | ((tempcolor & 0xFFFF) << 16);
colors[0] = (tempcolor & 0xFFFF0000) | (colors[2] & 0xFFFF);
colors[1] = tempcolor;
colors[3] = (colors[2] & 0xFFFF0000) | (colors[1] & 0xFFFF);
}
if (rep_count == 5) {
tempcolor = nf_trans16_lo[*(esi + 20)] | nf_trans16_hi[*(esi + 21)];
tempcolor = (tempcolor << 16) | (nf_trans16_lo[*(esi + 18)] | nf_trans16_hi[*(esi + 19)]);
colors[2] = tempcolor;
tempcolor = ((tempcolor & 0xFFFF0000) >> 16) | ((tempcolor & 0xFFFF) << 16);
colors[0] = (tempcolor & 0xFFFF0000) | (colors[2] & 0xFFFF);
colors[1] = tempcolor;
colors[3] = (colors[2] & 0xFFFF0000) | (colors[1] & 0xFFFF);
}
}
esi += 24;
edi -= (8 + nfpk_back_right);
}
if (donf24) {
uint32_t colors[4];
max_repcount = 8;
uint32_t tempcolor;
tempcolor = nf_trans16_lo[*(esi + 2)] | nf_trans16_hi[*(esi + 3)];
tempcolor = (tempcolor << 16) | (nf_trans16_lo[*(esi + 0)] | nf_trans16_hi[*(esi + 1)]);
colors[2] = tempcolor;
tempcolor = ((tempcolor & 0xFFFF0000) >> 16) | ((tempcolor & 0xFFFF) << 16);
colors[0] = (tempcolor & 0xFFFF0000) | (colors[2] & 0xFFFF);
colors[1] = tempcolor;
colors[3] = (colors[2] & 0xFFFF0000) | (colors[1] & 0xFFFF);
for (rep_count = 0; rep_count < max_repcount; rep_count++) {
uint32_t w1, w2, w3, w4;
uint32_t color_idx;
int idx;
switch (rep_count) {
case 0:
idx = 4;
break;
case 1:
idx = 5;
break;
case 2:
idx = 6;
break;
case 3:
idx = 7;
break;
case 4:
idx = 12;
break;
case 5:
idx = 13;
break;
case 6:
idx = 14;
break;
case 7:
idx = 15;
break;
}
color_idx = *(uint32_t *)(nfhpk_mov8 + (*(esi + idx) * 4));
w1 = colors[color_idx & 0x000000FF];
w2 = colors[(color_idx & 0x0000FF00) >> 8];
w3 = colors[(color_idx & 0x00FF0000) >> 16];
w4 = colors[(color_idx & 0xFF000000) >> 24];
*(uint32_t *)(edi + 0) = w1;
*(uint32_t *)(edi + 4) = w2;
edi += nf_width;
*(uint32_t *)(edi + 0) = w3;
*(uint32_t *)(edi + 4) = w4;
if (rep_count != (max_repcount - 1))
edi += nf_width;
if (rep_count == 3) {
edi -= nf_width * 8 - 8;
tempcolor = nf_trans16_lo[*(esi + 10)] | nf_trans16_hi[*(esi + 11)];
tempcolor = (tempcolor << 16) | (nf_trans16_lo[*(esi + 8)] | nf_trans16_hi[*(esi + 9)]);
colors[2] = tempcolor;
tempcolor = ((tempcolor & 0xFFFF0000) >> 16) | ((tempcolor & 0xFFFF) << 16);
colors[0] = (tempcolor & 0xFFFF0000) | (colors[2] & 0xFFFF);
colors[1] = tempcolor;
colors[3] = (colors[2] & 0xFFFF0000) | (colors[1] & 0xFFFF);
}
}
esi += 16;
edi -= (8 + nfpk_back_right);
}
if (donf40) {
uint32_t colors[4];
max_repcount = 8;
uint32_t tempcolor;
tempcolor = nf_trans16_lo[*(esi + 2)] | nf_trans16_hi[*(esi + 3)];
tempcolor = (tempcolor << 16) | (nf_trans16_lo[*(esi + 0)] | nf_trans16_hi[*(esi + 1)]);
colors[2] = tempcolor;
tempcolor = ((tempcolor & 0xFFFF0000) >> 16) | ((tempcolor & 0xFFFF) << 16);
colors[0] = (tempcolor & 0xFFFF0000) | (colors[2] & 0xFFFF);
colors[1] = tempcolor;
colors[3] = (colors[2] & 0xFFFF0000) | (colors[1] & 0xFFFF);
for (rep_count = 0; rep_count < max_repcount; rep_count++) {
uint32_t w1, w2, w3, w4;
uint32_t color_idx;
int idx;
switch (rep_count) {
case 0:
idx = 4;
break;
case 1:
idx = 5;
break;
case 2:
idx = 6;
break;
case 3:
idx = 7;
break;
case 4:
idx = 12;
break;
case 5:
idx = 13;
break;
case 6:
idx = 14;
break;
case 7:
idx = 15;
break;
}
color_idx = *(uint32_t *)(nfhpk_mov8 + (*(esi + idx) * 4));
w1 = colors[color_idx & 0x000000FF];
w2 = colors[(color_idx & 0x0000FF00) >> 8];
w3 = colors[(color_idx & 0x00FF0000) >> 16];
w4 = colors[(color_idx & 0xFF000000) >> 24];
*(uint32_t *)(edi + 0) = w1;
*(uint32_t *)(edi + 4) = w2;
*(uint32_t *)(edi + 8) = w3;
*(uint32_t *)(edi + 12) = w4;
if (rep_count != (max_repcount - 1))
edi += nf_width;
if (rep_count == 3) {
tempcolor = nf_trans16_lo[*(esi + 10)] | nf_trans16_hi[*(esi + 11)];
tempcolor = (tempcolor << 16) | (nf_trans16_lo[*(esi + 8)] | nf_trans16_hi[*(esi + 9)]);
colors[2] = tempcolor;
tempcolor = ((tempcolor & 0xFFFF0000) >> 16) | ((tempcolor & 0xFFFF) << 16);
colors[0] = (tempcolor & 0xFFFF0000) | (colors[2] & 0xFFFF);
colors[1] = tempcolor;
colors[3] = (colors[2] & 0xFFFF0000) | (colors[1] & 0xFFFF);
}
}
esi += 16;
edi -= nfpk_back_right;
}
} break;
case 9: {
bool donf41 = false;
bool donf25 = false;
bool donf57 = false;
uint16_t val;
int rep_count, max_repcount;
val = *(uint16_t *)esi;
val = INTEL_SHORT(val);
if (val & 0x8000) {
val = *(uint16_t *)(esi + 4);
val = INTEL_SHORT(val);
if (val & 0x8000) {
donf57 = true;
} else {
donf41 = true;
}
} else {
val = *(uint16_t *)(esi + 4);
val = INTEL_SHORT(val);
if (val & 0x8000) {
donf25 = true;
}
}
if (donf57) {
uint16_t colors[4];
max_repcount = 8;
colors[0] = nf_trans16_lo[*(esi)] | nf_trans16_hi[*(esi + 1)];
colors[1] = nf_trans16_lo[*(esi + 2)] | nf_trans16_hi[*(esi + 3)];
colors[2] = nf_trans16_lo[*(esi + 4)] | nf_trans16_hi[*(esi + 5)];
colors[3] = nf_trans16_lo[*(esi + 6)] | nf_trans16_hi[*(esi + 7)];
for (rep_count = 0; rep_count < max_repcount; rep_count++) {
uint32_t w1, w2, w3, w4;
uint32_t color_idx;
int idx;
idx = rep_count + 8;
color_idx = *(uint32_t *)(nfhpk_mov4 + ((*(esi + idx)) * 4));
w1 = colors[color_idx & 0x000000FF];
w2 = colors[(color_idx & 0x0000FF00) >> 8];
w3 = colors[(color_idx & 0x00FF0000) >> 16];
w4 = colors[(color_idx & 0xFF000000) >> 24];
if (rep_count % 2) {
*(uint32_t *)(edi + 8) = (w1 & 0xFFFF) | ((w2 & 0xFFFF) << 16);
*(uint32_t *)(edi + nf_width + 8) = (w1 & 0xFFFF) | ((w2 & 0xFFFF) << 16);
*(uint32_t *)(edi + 12) = (w3 & 0xFFFF) | ((w4 & 0xFFFF) << 16);
*(uint32_t *)(edi + nf_width + 12) = (w3 & 0xFFFF) | ((w4 & 0xFFFF) << 16);
if (rep_count != (max_repcount - 1))
edi = edi + nf_width * 2;
} else {
*(uint32_t *)(edi + 0) = (w1 & 0xFFFF) | ((w2 & 0xFFFF) << 16);
*(uint32_t *)(edi + nf_width) = (w1 & 0xFFFF) | ((w2 & 0xFFFF) << 16);
*(uint32_t *)(edi + 4) = (w3 & 0xFFFF) | ((w4 & 0xFFFF) << 16);
*(uint32_t *)(edi + nf_width + 4) = (w3 & 0xFFFF) | ((w4 & 0xFFFF) << 16);
}
}
edi += nf_width;
esi += 16;
edi -= nfpk_back_right;
}
if (donf41) {
uint32_t colors[4];
max_repcount = 8;
colors[0] = nf_trans16_lo[*(esi)] | nf_trans16_hi[*(esi + 1)];
colors[0] = ((colors[0]) << 16) | colors[0];
colors[1] = nf_trans16_lo[*(esi + 2)] | nf_trans16_hi[*(esi + 3)];
colors[1] = ((colors[1]) << 16) | colors[1];
colors[2] = nf_trans16_lo[*(esi + 4)] | nf_trans16_hi[*(esi + 5)];
colors[2] = ((colors[2]) << 16) | colors[2];
colors[3] = nf_trans16_lo[*(esi + 6)] | nf_trans16_hi[*(esi + 7)];
colors[3] = ((colors[3]) << 16) | colors[3];
for (rep_count = 0; rep_count < max_repcount; rep_count++) {
uint32_t w1, w2, w3, w4;
uint32_t color_idx;
int idx;
idx = rep_count + 8;
color_idx = *(uint32_t *)(nfhpk_mov8 + (*(esi + idx) * 4));
w1 = colors[color_idx & 0x000000FF];
w2 = colors[(color_idx & 0x0000FF00) >> 8];
w3 = colors[(color_idx & 0x00FF0000) >> 16];
w4 = colors[(color_idx & 0xFF000000) >> 24];
*(uint32_t *)(edi + 0) = w1;
*(uint32_t *)(edi + 4) = w2;
*(uint32_t *)(edi + 8) = w3;
*(uint32_t *)(edi + 12) = w4;
if (rep_count != (max_repcount - 1))
edi += nf_width;
}
esi += 16;
edi -= nfpk_back_right;
}
if (donf25) {
uint32_t colors[4];
max_repcount = 4;
colors[0] = nf_trans16_lo[*(esi)] | nf_trans16_hi[*(esi + 1)];
colors[0] = ((colors[0]) << 16) | colors[0];
colors[1] = nf_trans16_lo[*(esi + 2)] | nf_trans16_hi[*(esi + 3)];
colors[1] = ((colors[1]) << 16) | colors[1];
colors[2] = nf_trans16_lo[*(esi + 4)] | nf_trans16_hi[*(esi + 5)];
colors[2] = ((colors[2]) << 16) | colors[2];
colors[3] = nf_trans16_lo[*(esi + 6)] | nf_trans16_hi[*(esi + 7)];
colors[3] = ((colors[3]) << 16) | colors[3];
for (rep_count = 0; rep_count < max_repcount; rep_count++) {
uint32_t w1, w2, w3, w4;
uint32_t color_idx;
int idx;
idx = rep_count + 8;
color_idx = *(uint32_t *)(nfhpk_mov4 + ((*(esi + idx)) * 4));
w1 = colors[color_idx & 0x000000FF];
w2 = colors[(color_idx & 0x0000FF00) >> 8];
w3 = colors[(color_idx & 0x00FF0000) >> 16];
w4 = colors[(color_idx & 0xFF000000) >> 24];
*(uint32_t *)(edi + 0) = w1;
*(uint32_t *)(edi + nf_width) = w1;
*(uint32_t *)(edi + 4) = w2;
*(uint32_t *)(edi + nf_width + 4) = w2;
*(uint32_t *)(edi + 8) = w3;
*(uint32_t *)(edi + nf_width + 8) = w3;
*(uint32_t *)(edi + 12) = w4;
*(uint32_t *)(edi + nf_width + 12) = w4;
if (rep_count != (max_repcount - 1))
edi = edi + nf_width * 2;
}
edi += nf_width;
esi += 12;
edi -= nfpk_back_right;
}
if (!donf25 && !donf41 && !donf57) {
uint16_t colors[4];
max_repcount = 16;
colors[0] = nf_trans16_lo[*(esi)] | nf_trans16_hi[*(esi + 1)];
colors[1] = nf_trans16_lo[*(esi + 2)] | nf_trans16_hi[*(esi + 3)];
colors[2] = nf_trans16_lo[*(esi + 4)] | nf_trans16_hi[*(esi + 5)];
colors[3] = nf_trans16_lo[*(esi + 6)] | nf_trans16_hi[*(esi + 7)];
for (rep_count = 0; rep_count < max_repcount; rep_count++) {
uint32_t w1, w2, w3, w4;
uint32_t color_idx;
int idx;
idx = rep_count + 8;
color_idx = *(uint32_t *)(nfhpk_mov4 + ((*(esi + idx)) * 4));
w1 = colors[color_idx & 0x000000FF];
w2 = colors[(color_idx & 0x0000FF00) >> 8];
w3 = colors[(color_idx & 0x00FF0000) >> 16];
w4 = colors[(color_idx & 0xFF000000) >> 24];
if (rep_count % 2) {
*(uint32_t *)(edi + 8) = (w1 & 0xFFFF) | ((w2 & 0xFFFF) << 16);
*(uint32_t *)(edi + 12) = (w3 & 0xFFFF) | ((w4 & 0xFFFF) << 16);
if (rep_count != (max_repcount - 1))
edi += nf_width;
} else {
*(uint32_t *)(edi + 0) = (w1 & 0xFFFF) | ((w2 & 0xFFFF) << 16);
*(uint32_t *)(edi + 4) = (w3 & 0xFFFF) | ((w4 & 0xFFFF) << 16);
}
}
esi += 24;
edi -= nfpk_back_right;
}
} break;
case 10: {
// 2x2 4x4x2 (32 bytes) or 2x1 4x8x2 (24 bytes) or 1x2 4x8x2 (24 bytes)
int val1;
int rep_count;
uint16_t colors[4];
bool do26 = false;
bool do42 = false;
uint16_t swapper = *(uint16_t *)esi;
val1 = INTEL_SHORT(swapper);
if (val1 & 0x8000) {
swapper = *(uint16_t *)(esi + 16);
val1 = INTEL_SHORT(swapper);
if (val1 & 0x8000) {
do42 = true;
} else {
do26 = true;
}
}
// Load bx,dx,cx,bp with four colors
colors[0] = nf_trans16_lo[*(esi)] | nf_trans16_hi[*(esi + 1)];
colors[1] = nf_trans16_lo[*(esi + 2)] | nf_trans16_hi[*(esi + 3)];
colors[2] = nf_trans16_lo[*(esi + 4)] | nf_trans16_hi[*(esi + 5)];
colors[3] = nf_trans16_lo[*(esi + 6)] | nf_trans16_hi[*(esi + 7)];
for (rep_count = 0; rep_count < 16; rep_count++) {
uint32_t w1, w2, w3, w4;
uint32_t color_idx;
int idx;
if (!do26 && !do42) {
switch (rep_count) {
case 0:
idx = 8;
break;
case 1:
idx = 9;
break;
case 2:
idx = 10;
break;
case 3:
idx = 11;
break;
case 4:
idx = 20;
break;
case 5:
idx = 21;
break;
case 6:
idx = 22;
break;
case 7:
idx = 23;
break;
case 8:
idx = 32;
break;
case 9:
idx = 33;
break;
case 10:
idx = 34;
break;
case 11:
idx = 35;
break;
case 12:
idx = 44;
break;
case 13:
idx = 45;
break;
case 14:
idx = 46;
break;
case 15:
idx = 47;
break;
}
} else {
switch (rep_count) {
case 0:
idx = 8;
break;
case 1:
idx = 9;
break;
case 2:
idx = 10;
break;
case 3:
idx = 11;
break;
case 4:
idx = 12;
break;
case 5:
idx = 13;
break;
case 6:
idx = 14;
break;
case 7:
idx = 15;
break;
case 8:
idx = 24;
break;
case 9:
idx = 25;
break;
case 10:
idx = 26;
break;
case 11:
idx = 27;
break;
case 12:
idx = 28;
break;
case 13:
idx = 29;
break;
case 14:
idx = 30;
break;
case 15:
idx = 31;
break;
}
}
color_idx = *(uint32_t *)(nfhpk_mov4 + (*(esi + idx) * 4));
w1 = colors[color_idx & 0x000000FF];
w2 = colors[(color_idx & 0x0000FF00) >> 8];
w3 = colors[(color_idx & 0x00FF0000) >> 16];
w4 = colors[(color_idx & 0xFF000000) >> 24];
if (!do42) {
*(uint32_t *)(edi + 0) = (w1 & 0xFFFF) | ((w2 & 0xFFFF) << 16);
*(uint32_t *)(edi + 4) = (w3 & 0xFFFF) | ((w4 & 0xFFFF) << 16);
if (rep_count != 15)
edi += nf_width;
} else {
if (rep_count % 2) {
*(uint32_t *)(edi + 8) = (w1 & 0xFFFF) | ((w2 & 0xFFFF) << 16);
*(uint32_t *)(edi + 12) = (w3 & 0xFFFF) | ((w4 & 0xFFFF) << 16);
if (rep_count != 15)
edi += nf_width;
} else {
*(uint32_t *)(edi + 0) = (w1 & 0xFFFF) | ((w2 & 0xFFFF) << 16);
*(uint32_t *)(edi + 4) = (w3 & 0xFFFF) | ((w4 & 0xFFFF) << 16);
}
}
if (rep_count == 3 && !do42 && !do26) {
// Load bx,dx,cx,bp with four colors
colors[0] = nf_trans16_lo[*(esi + 12)] | nf_trans16_hi[*(esi + 13)];
colors[1] = nf_trans16_lo[*(esi + 14)] | nf_trans16_hi[*(esi + 15)];
colors[2] = nf_trans16_lo[*(esi + 16)] | nf_trans16_hi[*(esi + 17)];
colors[3] = nf_trans16_lo[*(esi + 18)] | nf_trans16_hi[*(esi + 19)];
}
if (rep_count == 7) {
if (!do42 && !do26) {
edi -= nf_width * 8 - 8;
// Load bx,dx,cx,bp with four colors
colors[0] = nf_trans16_lo[*(esi + 24)] | nf_trans16_hi[*(esi + 25)];
colors[1] = nf_trans16_lo[*(esi + 26)] | nf_trans16_hi[*(esi + 27)];
colors[2] = nf_trans16_lo[*(esi + 28)] | nf_trans16_hi[*(esi + 29)];
colors[3] = nf_trans16_lo[*(esi + 30)] | nf_trans16_hi[*(esi + 31)];
}
if (do26) {
edi -= nf_width * 8 - 8;
// Load bx,dx,cx,bp with four colors
colors[0] = nf_trans16_lo[*(esi + 16)] | nf_trans16_hi[*(esi + 17)];
colors[1] = nf_trans16_lo[*(esi + 18)] | nf_trans16_hi[*(esi + 19)];
colors[2] = nf_trans16_lo[*(esi + 20)] | nf_trans16_hi[*(esi + 21)];
colors[3] = nf_trans16_lo[*(esi + 22)] | nf_trans16_hi[*(esi + 23)];
}
if (do42) {
// Load bx,dx,cx,bp with four colors
colors[0] = nf_trans16_lo[*(esi + 16)] | nf_trans16_hi[*(esi + 17)];
colors[1] = nf_trans16_lo[*(esi + 18)] | nf_trans16_hi[*(esi + 19)];
colors[2] = nf_trans16_lo[*(esi + 20)] | nf_trans16_hi[*(esi + 21)];
colors[3] = nf_trans16_lo[*(esi + 22)] | nf_trans16_hi[*(esi + 23)];
}
}
if (rep_count == 11 && !do42 && !do26) {
// Load bx,dx,cx,bp with four colors
colors[0] = nf_trans16_lo[*(esi + 36)] | nf_trans16_hi[*(esi + 37)];
colors[1] = nf_trans16_lo[*(esi + 38)] | nf_trans16_hi[*(esi + 39)];
colors[2] = nf_trans16_lo[*(esi + 40)] | nf_trans16_hi[*(esi + 41)];
colors[3] = nf_trans16_lo[*(esi + 42)] | nf_trans16_hi[*(esi + 43)];
}
}
if (!do42 && !do26) {
esi += 48;
} else {
esi += 32;
}
if (!do42) {
edi -= (8 + nfpk_back_right);
} else {
edi -= nfpk_back_right;
}
} break;
case 11: {
// 8x8x16 (128 bytes)
Trans16Blk(edi, esi);
edi += nf_width;
Trans16Blk(edi, esi + 16);
edi += nf_width;
Trans16Blk(edi, esi + 32);
edi += nf_width;
Trans16Blk(edi, esi + 48);
edi += nf_width;
Trans16Blk(edi, esi + 64);
edi += nf_width;
Trans16Blk(edi, esi + 80);
edi += nf_width;
Trans16Blk(edi, esi + 96);
edi += nf_width;
Trans16Blk(edi, esi + 112);
esi += 128;
edi -= nfpk_back_right;
} break;
case 12: {
// low 4x4x16 (32 bytes)
int i;
uint32_t eax, ebx;
for (i = 0; i < 4; i++) {
eax = *(uint8_t *)(esi + i * 8 + 0);
ebx = nf_trans16_lo[eax];
eax = *(uint8_t *)(esi + i * 8 + 1);
ebx |= nf_trans16_hi[eax];
eax = ((ebx & 0xFFFF) << 16) | (ebx & 0xFFFF);
*(uint32_t *)(edi + 0) = eax;
*(uint32_t *)(edi + nf_width) = eax;
eax = *(uint8_t *)(esi + i * 8 + 2);
ebx = nf_trans16_lo[eax];
eax = *(uint8_t *)(esi + i * 8 + 3);
ebx |= nf_trans16_hi[eax];
eax = ((ebx & 0xFFFF) << 16) | (ebx & 0xFFFF);
*(uint32_t *)(edi + 4) = eax;
*(uint32_t *)(edi + nf_width + 4) = eax;
eax = *(uint8_t *)(esi + i * 8 + 4);
ebx = nf_trans16_lo[eax];
eax = *(uint8_t *)(esi + i * 8 + 5);
ebx |= nf_trans16_hi[eax];
eax = ((ebx & 0xFFFF) << 16) | (ebx & 0xFFFF);
*(uint32_t *)(edi + 8) = eax;
*(uint32_t *)(edi + nf_width + 8) = eax;
eax = *(uint8_t *)(esi + i * 8 + 6);
ebx = nf_trans16_lo[eax];
eax = *(uint8_t *)(esi + i * 8 + 7);
ebx |= nf_trans16_hi[eax];
eax = ((ebx & 0xFFFF) << 16) | (ebx & 0xFFFF);
*(uint32_t *)(edi + 12) = eax;
*(uint32_t *)(edi + nf_width + 12) = eax;
if (i != 3)
edi = edi + nf_width * 2;
}
edi += nf_width;
edi -= nfpk_back_right;
esi += 32;
} break;
case 13: {
// 2x2 4x4x0 (8 bytes)
uint32_t temp, ebx, ecx;
temp = nf_trans16_lo[(*esi)] | nf_trans16_hi[(*(esi + 1))];
ebx = ((temp & 0xFFFF) << 16) | (temp & 0xFFFF);
temp = nf_trans16_lo[(*(esi + 2))] | nf_trans16_hi[(*(esi + 3))];
ecx = ((temp & 0xFFFF) << 16) | (temp & 0xFFFF);
*(uint32_t *)(edi + 0) = ebx;
*(uint32_t *)(edi + 4) = ebx;
*(uint32_t *)(edi + 8) = ecx;
*(uint32_t *)(edi + 12) = ecx;
*(uint32_t *)(edi + nf_width) = ebx;
*(uint32_t *)(edi + nf_width + 4) = ebx;
*(uint32_t *)(edi + nf_width + 8) = ecx;
*(uint32_t *)(edi + nf_width + 12) = ecx;
edi = edi + nf_width * 2;
*(uint32_t *)(edi + 0) = ebx;
*(uint32_t *)(edi + 4) = ebx;
*(uint32_t *)(edi + 8) = ecx;
*(uint32_t *)(edi + 12) = ecx;
*(uint32_t *)(edi + nf_width) = ebx;
*(uint32_t *)(edi + nf_width + 4) = ebx;
*(uint32_t *)(edi + nf_width + 8) = ecx;
*(uint32_t *)(edi + nf_width + 12) = ecx;
edi = edi + nf_width * 2;
temp = nf_trans16_lo[(*(esi + 4))] | nf_trans16_hi[(*(esi + 5))];
ebx = ((temp & 0xFFFF) << 16) | (temp & 0xFFFF);
temp = nf_trans16_lo[(*(esi + 6))] | nf_trans16_hi[(*(esi + 7))];
ecx = ((temp & 0xFFFF) << 16) | (temp & 0xFFFF);
*(uint32_t *)(edi + 0) = ebx;
*(uint32_t *)(edi + 4) = ebx;
*(uint32_t *)(edi + 8) = ecx;
*(uint32_t *)(edi + 12) = ecx;
*(uint32_t *)(edi + nf_width) = ebx;
*(uint32_t *)(edi + nf_width + 4) = ebx;
*(uint32_t *)(edi + nf_width + 8) = ecx;
*(uint32_t *)(edi + nf_width + 12) = ecx;
edi = edi + nf_width * 2;
*(uint32_t *)(edi + 0) = ebx;
*(uint32_t *)(edi + 4) = ebx;
*(uint32_t *)(edi + 8) = ecx;
*(uint32_t *)(edi + 12) = ecx;
*(uint32_t *)(edi + nf_width) = ebx;
*(uint32_t *)(edi + nf_width + 4) = ebx;
*(uint32_t *)(edi + nf_width + 8) = ecx;
*(uint32_t *)(edi + nf_width + 12) = ecx;
edi += nf_width;
edi -= nfpk_back_right;
esi += 8;
} break;
case 14: {
// 8x8x0 (2 bytes)
uint32_t ecx, ebx;
ecx = nf_trans16_lo[*(esi)] | nf_trans16_hi[*(esi + 1)];
esi += 2;
ebx = ((ecx & 0xFFFF) << 16) | (ecx & 0xFFFF);
*(uint32_t *)(edi + 0) = ebx;
*(uint32_t *)(edi + 4) = ebx;
*(uint32_t *)(edi + 8) = ebx;
*(uint32_t *)(edi + 12) = ebx;
edi += nf_width;
*(uint32_t *)(edi + 0) = ebx;
*(uint32_t *)(edi + 4) = ebx;
*(uint32_t *)(edi + 8) = ebx;
*(uint32_t *)(edi + 12) = ebx;
edi += nf_width;
*(uint32_t *)(edi + 0) = ebx;
*(uint32_t *)(edi + 4) = ebx;
*(uint32_t *)(edi + 8) = ebx;
*(uint32_t *)(edi + 12) = ebx;
edi += nf_width;
*(uint32_t *)(edi + 0) = ebx;
*(uint32_t *)(edi + 4) = ebx;
*(uint32_t *)(edi + 8) = ebx;
*(uint32_t *)(edi + 12) = ebx;
edi += nf_width;
*(uint32_t *)(edi + 0) = ebx;
*(uint32_t *)(edi + 4) = ebx;
*(uint32_t *)(edi + 8) = ebx;
*(uint32_t *)(edi + 12) = ebx;
edi += nf_width;
*(uint32_t *)(edi + 0) = ebx;
*(uint32_t *)(edi + 4) = ebx;
*(uint32_t *)(edi + 8) = ebx;
*(uint32_t *)(edi + 12) = ebx;
edi += nf_width;
*(uint32_t *)(edi + 0) = ebx;
*(uint32_t *)(edi + 4) = ebx;
*(uint32_t *)(edi + 8) = ebx;
*(uint32_t *)(edi + 12) = ebx;
edi += nf_width;
*(uint32_t *)(edi + 0) = ebx;
*(uint32_t *)(edi + 4) = ebx;
*(uint32_t *)(edi + 8) = ebx;
*(uint32_t *)(edi + 12) = ebx;
edi -= nfpk_back_right;
} break;
case 15: {
int i;
i = 0;
} break;
}
if (first_opcode) {
first_opcode = false;
opcode_to_use = (opcode >> 4);
goto do_next_opcode;
}
// go back up
continue;
} else {
edi += nf.new_row;
h--;
wcnt = w >> 1;
}
} while (h != 0);
}
void Trans16Blk(uint8_t *edi, uint8_t *idx) {
*((uint16_t *)(edi + 0)) = nf_trans16_lo[*(idx + 0)] | nf_trans16_hi[*(idx + 1)];
*((uint16_t *)(edi + 2)) = nf_trans16_lo[*(idx + 2)] | nf_trans16_hi[*(idx + 3)];
*((uint16_t *)(edi + 4)) = nf_trans16_lo[*(idx + 4)] | nf_trans16_hi[*(idx + 5)];
*((uint16_t *)(edi + 6)) = nf_trans16_lo[*(idx + 6)] | nf_trans16_hi[*(idx + 7)];
*((uint16_t *)(edi + 8)) = nf_trans16_lo[*(idx + 8)] | nf_trans16_hi[*(idx + 9)];
*((uint16_t *)(edi + 10)) = nf_trans16_lo[*(idx + 10)] | nf_trans16_hi[*(idx + 11)];
*((uint16_t *)(edi + 12)) = nf_trans16_lo[*(idx + 12)] | nf_trans16_hi[*(idx + 13)];
*((uint16_t *)(edi + 14)) = nf_trans16_lo[*(idx + 14)] | nf_trans16_hi[*(idx + 15)];
}
void call_hnfxycshift(uint32_t eax, uint8_t **medi, uint8_t **mesi, int nfpk_back_right) {
uint32_t ebx;
ebx = ((eax & 0xFF00) >> 8);
if (eax & 0x80) {
// we have to sign extend also
eax = ((eax & 0x7F) << 1);
eax = (eax & 0xFF) | 0xFFFFFF00;
} else {
eax = ((eax & 0x7F) << 1);
}
eax += nfpk_ShiftY[ebx];
call_hnfshift(eax, medi, mesi, nfpk_back_right);
}
void call_hnfxypshift(uint32_t eax, uint8_t **medi, uint8_t **mesi, int nfpk_back_right,
int DiffBufPtrs) {
uint32_t ebx;
ebx = ((eax & 0xFF00) >> 8);
if (eax & 0x80) {
// we have to sign extend also
eax = ((eax & 0x7F) << 1);
eax = (eax & 0xFF) | 0xFFFFFF00;
} else {
eax = ((eax & 0x7F) << 1);
}
eax += nfpk_ShiftY[ebx];
eax += DiffBufPtrs;
call_hnfshift(eax, medi, mesi, nfpk_back_right);
}
void call_hnfshift(uint32_t meax, uint8_t **medi, uint8_t **mesi, int nfpk_back_right) {
uint8_t *esi, *edi, *saved_esi;
int i;
edi = *medi;
saved_esi = esi = *mesi;
esi = edi + meax;
for (i = 0; i < 8; i++) {
#define HNFSHIFT_WRITEOUT(x) *(uint32_t *)(edi + x) = *(uint32_t *)(esi + x);
HNFSHIFT_WRITEOUT(0);
HNFSHIFT_WRITEOUT(4);
HNFSHIFT_WRITEOUT(8);
HNFSHIFT_WRITEOUT(12);
#undef HNFSHIFT_WRITEOUT
if (i != 7) {
esi += nf_width;
edi += nf_width;
}
}
edi -= nfpk_back_right;
esi = saved_esi;
*medi = edi;
*mesi = esi;
}
////////////////////////////////////////////////
// Non-Implemented Functions
////////////////////////////////////////////////
void nfHiColorDecomp(uint8_t *comp, unsigned x, unsigned y, unsigned w, unsigned h);
void nfHiColorDecompChg(uint16_t *chgs, uint16_t *parms, uint8_t *comp, unsigned x, unsigned y,
unsigned w, unsigned h);
void nfDecomp(uint8_t *comp, unsigned x, unsigned y, unsigned w, unsigned h);
void nfDecompChg(uint16_t *chgs, uint16_t *parms, uint8_t *comp, unsigned x, unsigned y, unsigned w,
unsigned h);
void nfPkPal(void);
void nfPkDecomp(uint8_t *ops, uint8_t *comp, unsigned x, unsigned y, unsigned w, unsigned h);
void nfPkDecompH(uint8_t *ops, uint8_t *comp, unsigned x, unsigned y, unsigned w, unsigned h);
void nfPkDecompD(uint8_t *ops, uint8_t *comp, unsigned x, unsigned y, unsigned w, unsigned h);
void mve_ShowFrameField(uint8_t *buf, unsigned bufw, unsigned bufh, unsigned sx, unsigned sy, unsigned w,
unsigned h, unsigned dstx, unsigned dsty, unsigned field);
void mve_ShowFrameFieldHi(uint8_t *buf, unsigned bufw, unsigned bufh, unsigned sx, unsigned sy, unsigned w,
unsigned h, unsigned dstx, unsigned dsty, unsigned field);
void mve_sfShowFrameChg(bool prvbuf, unsigned x, unsigned y, unsigned w, unsigned h, uint16_t *chgs,
unsigned dstx, unsigned dsty);
void mve_sfHiColorShowFrameChg(bool prvbuf, unsigned x, unsigned y, unsigned w, unsigned h, uint16_t *chgs,
unsigned dstx, unsigned dsty);
void mve_sfPkShowFrameChg(bool prvbuf, unsigned x, unsigned y, unsigned w, unsigned h, uint8_t *ops,
unsigned dstx, unsigned dsty);
void mve_sfPkHiColorShowFrameChg(bool prvbuf, unsigned x, unsigned y, unsigned w, unsigned h, uint8_t *ops,
unsigned dstx, unsigned dsty);
void MVE_SetPalette(uint8_t *p, unsigned start, unsigned count);
void palLoadCompPalette(uint8_t *buf);
void gfxMode(unsigned mode);
void gfxLoadCrtc(uint8_t *crtc, uint8_t chain4, uint8_t res);
void gfxGetCrtc(uint8_t *crtc);
void gfxVres(uint8_t misc, uint8_t *crtc);
void MVE_gfxWaitRetrace(int state);
void MVE_gfxSetSplit(unsigned line);
// rcg07272000
// need this on non-Intel platforms. Intel uses int $3.
#if (defined __i386__) || defined(__x86_64__)
#error
#define int3() __asm__ __volatile__("int $3")
#else
#define int3() raise(SIGTRAP)
#endif
void nfHiColorDecomp(uint8_t *comp, unsigned x, unsigned y, unsigned w, unsigned h) { int3(); }
void nfHiColorDecompChg(uint16_t *chgs, uint16_t *parms, uint8_t *comp, unsigned x, unsigned y,
unsigned w, unsigned h) {
int3();
}
void nfDecomp(uint8_t *comp, unsigned x, unsigned y, unsigned w, unsigned h) { int3(); }
void nfDecompChg(uint16_t *chgs, uint16_t *parms, uint8_t *comp, unsigned x, unsigned y, unsigned w,
unsigned h) {
int3();
}
void nfPkPal(void) { int3(); }
void nfPkDecomp(uint8_t *ops, uint8_t *comp, unsigned x, unsigned y, unsigned w, unsigned h) { int3(); }
void nfPkDecompH(uint8_t *ops, uint8_t *comp, unsigned x, unsigned y, unsigned w, unsigned h) { int3(); }
void nfPkDecompD(uint8_t *ops, uint8_t *comp, unsigned x, unsigned y, unsigned w, unsigned h) { int3(); }
void mve_ShowFrameField(uint8_t *buf, unsigned bufw, unsigned bufh, unsigned sx, unsigned sy, unsigned w,
unsigned h, unsigned dstx, unsigned dsty, unsigned field) {
int3();
}
void mve_ShowFrameFieldHi(uint8_t *buf, unsigned bufw, unsigned bufh, unsigned sx, unsigned sy, unsigned w,
unsigned h, unsigned dstx, unsigned dsty, unsigned field) {
int3();
}
void mve_sfShowFrameChg(bool prvbuf, unsigned x, unsigned y, unsigned w, unsigned h, uint16_t *chgs,
unsigned dstx, unsigned dsty) {
int3();
}
void mve_sfHiColorShowFrameChg(bool prvbuf, unsigned x, unsigned y, unsigned w, unsigned h, uint16_t *chgs,
unsigned dstx, unsigned dsty) {
int3();
}
void mve_sfPkShowFrameChg(bool prvbuf, unsigned x, unsigned y, unsigned w, unsigned h, uint8_t *ops,
unsigned dstx, unsigned dsty) {
int3();
}
void mve_sfPkHiColorShowFrameChg(bool prvbuf, unsigned x, unsigned y, unsigned w, unsigned h, uint8_t *ops,
unsigned dstx, unsigned dsty) {
int3();
}
void MVE_SetPalette(uint8_t *p, unsigned start, unsigned count) { int3(); }
void palLoadCompPalette(uint8_t *buf) { int3(); }
void gfxMode(unsigned mode) { int3(); }
void gfxLoadCrtc(uint8_t *crtc, uint8_t chain4, uint8_t res) { int3(); }
void gfxGetCrtc(uint8_t *crtc) { int3(); }
void gfxVres(uint8_t misc, uint8_t *crtc) { int3(); }
void MVE_gfxWaitRetrace(int state) { int3(); }
void MVE_gfxSetSplit(unsigned line) { int3(); }
Reference in New Issue View Git Blame Copy Permalink