void fb_rdc_basic(fb_t c, dv_t a) {
int j, k;
dig_t *tmpa;
dv_t r;
dv_null(r);
TRY {
dv_new(r);
tmpa = a + FB_DIGS;
/* First reduce the high part. */
for (int i = fb_bits(tmpa) - 1; i >= 0; i--) {
if (fb_get_bit(tmpa, i)) {
SPLIT(k, j, i - FB_BITS, FB_DIG_LOG);
if (k <= 0) {
fb_addd_low(tmpa + j, tmpa + j, fb_poly_get(), FB_DIGS);
} else {
r[FB_DIGS] = fb_lshb_low(r, fb_poly_get(), k);
fb_addd_low(tmpa + j, tmpa + j, r, FB_DIGS + 1);
}
}
}
for (int i = fb_bits(a) - 1; i >= FB_BITS; i--) {
if (fb_get_bit(a, i)) {
SPLIT(k, j, i - FB_BITS, FB_DIG_LOG);
if (k == 0) {
fb_addd_low(a + j, a + j, fb_poly_get(), FB_DIGS);
} else {
r[FB_DIGS] = fb_lshb_low(r, fb_poly_get(), k);
fb_addd_low(a + j, a + j, r, FB_DIGS + 1);
}
}
}
fb_copy(c, a);
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
fb_free(r);
}
}
int screen_shot(const char * path)
{
struct FB * fb = NULL;
fb = fb_create(1);
if (fb) {
save_bmp(path, fb_width(fb), fb_height(fb), fb_bits(fb), fb_bpp(fb));
fb_destory(fb);
}
return 0;
}
/**
* Detects an optimization based on the curve coefficients.
*
* @param opt - the resulting optimization.
* @param a - the curve coefficient.
*/
static void detect_opt(int *opt, fb_t a) {
if (fb_is_zero(a)) {
*opt = OPT_ZERO;
} else {
if (fb_cmp_dig(a, 1) == CMP_EQ) {
*opt = OPT_ONE;
} else {
if (fb_bits(a) <= FB_DIGIT) {
*opt = OPT_DIGIT;
} else {
*opt = OPT_NONE;
}
}
}
}
static int file_to_fb(const char * srcpath)
{
int ret = -1;
BMP_READ * bmp = NULL;
struct FB * fb = NULL;
int sw, sh;
int srcbpp, dstbpp;
void * pdata = NULL, * bmpdata = NULL;
RGB_CONVERT_FUN convert_func = NULL;
do
{
bmp = bmp_open(srcpath);
if (!bmp) {
break;
}
fb = fb_create(0);
if (!fb) {
break;
}
sw = bmp_width(bmp);
sh = bmp_height(bmp);
bmpdata = bmp_data(bmp);
srcbpp = bmp_bpp(bmp);
dstbpp = fb_bpp(fb);
convert_func = get_convert_func(srcbpp, dstbpp);
if (convert_func) {
pdata = convert_func(bmpdata, sw, sh);
bmpdata = pdata;
}
if (!bmp_forward(bmp)) {
line_reversal(bmpdata, sw, sh, dstbpp);
}
rgb_copy(bmpdata, fb_bits(fb), sw, sh, fb_width(fb), fb_height(fb), dstbpp);
ret = 0;
} while (0);
fb_destory(fb);
bmp_close(bmp);
if (pdata) {
free(pdata);
}
return ret;
}
void fb_mul_basic(fb_t c, const fb_t a, const fb_t b) {
int i;
dv_t s;
fb_t t;
dv_null(s);
fb_null(t);
TRY {
/* We need a temporary variable so that c can be a or b. */
fb_new(t);
dv_new(s);
fb_zero(t);
dv_zero(s + FB_DIGS, FB_DIGS);
fb_copy(s, b);
if (a[0] & 1) {
fb_copy(t, b);
}
for (i = 1; i < FB_BITS; i++) {
/* We are already shifting a temporary value, so this is more efficient
* than calling fb_lsh(). */
s[FB_DIGS] = fb_lsh1_low(s, s);
fb_rdc(s, s);
if (fb_get_bit(a, i)) {
fb_add(t, t, s);
}
}
if (fb_bits(t) > FB_BITS) {
fb_poly_add(c, t);
} else {
fb_copy(c, t);
}
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
fb_free(t);
fb_free(s);
}
}
int savePic(const char *filePath)
{
int w = g_fb.vi.xres_virtual, h = g_fb.vi.yres, depth = g_fb.vi.bits_per_pixel;
//convert pixel data
uint8_t *rgb24;
rgb24 = (uint8_t *) malloc(w * h * 4);
int i=0;
for (;i<w*h;i++)
{
uint32_t pixel32 = ((uint32_t *)fb_bits(&g_fb))[i];
// in rgb24 color max is 2^8 per channel
if (g_fb.vi.blue.offset == 0) {
rgb24[3*i+0] = (pixel32 & 0x000000FF); //Blue
rgb24[3*i+1] = (pixel32 & 0x0000FF00) >> 8; //Green
rgb24[3*i+2] = (pixel32 & 0x00FF0000) >> 16; //Red
} else {
static int fb_to_file(const char * dstpath, int output_rgb)
{
int ret = -1;
int w, h;
int srcbpp, dstbpp;
void * pdata = NULL, * fbdata = NULL;
RGB_CONVERT_FUN convert_func = NULL;
struct FB * fb = NULL;
do
{
fb = fb_create(1);
if (!fb) {
break;
}
w = fb_width(fb);
h = fb_height(fb);
fbdata = fb_bits(fb);
srcbpp = fb_bpp(fb);
dstbpp = g_rgbbpp[output_rgb];
convert_func = get_convert_func(srcbpp, dstbpp);
if (convert_func) {
pdata = convert_func(fbdata, w, h);
fbdata = pdata;
}
ret = save_bmp(dstpath, w, h, fbdata, dstbpp);
} while (0);
if (pdata) {
free(pdata);
}
fb_destory(fb);
return ret;
}
void fb_invn_low(dig_t *c, const dig_t *a) {
int j, d, lu, lv, lt, l1, l2, bu, bv;
align dig_t _u[2 * FB_DIGS], _v[2 * FB_DIGS];
align dig_t _g1[2 * FB_DIGS], _g2[2 * FB_DIGS];
dig_t *t = NULL, *u = NULL, *v = NULL, *g1 = NULL, *g2 = NULL, carry;
dv_zero(_g1, FB_DIGS + 1);
dv_zero(_g2, FB_DIGS + 1);
u = _u;
v = _v;
g1 = _g1;
g2 = _g2;
/* u = a, v = f, g1 = 1, g2 = 0. */
dv_copy(u, a, FB_DIGS);
dv_copy(v, fb_poly_get(), FB_DIGS);
g1[0] = 1;
lu = lv = FB_DIGS;
l1 = l2 = 1;
bu = fb_bits(u);
bv = FB_BITS + 1;
j = bu - bv;
/* While (u != 1). */
while (1) {
/* If j < 0 then swap(u, v), swap(g1, g2), j = -j. */
if (j < 0) {
t = u;
u = v;
v = t;
lt = lu;
lu = lv;
lv = lt;
t = g1;
g1 = g2;
g2 = t;
lt = l1;
l1 = l2;
l2 = lt;
j = -j;
}
SPLIT(j, d, j, FB_DIG_LOG);
/* u = u + v * z^j. */
if (j > 0) {
carry = fb_lsha_low(u + d, v, j, lv);
u[d + lv] ^= carry;
} else {
fb_addd_low(u + d, u + d, v, lv);
}
/* g1 = g1 + g2 * z^j. */
if (j > 0) {
carry = fb_lsha_low(g1 + d, g2, j, l2);
l1 = (l2 + d >= l1 ? l2 + d : l1);
if (carry) {
g1[d + l2] ^= carry;
l1 = (l2 + d >= l1 ? l1 + 1 : l1);
}
} else {
fb_addd_low(g1 + d, g1 + d, g2, l2);
l1 = (l2 + d > l1 ? l2 + d : l1);
}
while (u[lu - 1] == 0)
lu--;
while (v[lv - 1] == 0)
lv--;
if (lu == 1 && u[0] == 1)
break;
/* j = deg(u) - deg(v). */
lt = util_bits_dig(u[lu - 1]) - util_bits_dig(v[lv - 1]);
j = ((lu - lv) << FB_DIG_LOG) + lt;
}
/* Return g1. */
fb_copy(c, g1);
}
