int main(int argc, char *argv[])
{
#ifdef CONFIG_S390_PRNG
prng_seed(16);
#endif
return 0;
}
int decode_steg(char *file_input, char *file_output, unsigned char *key) {
FILE *fpi, *fpo;
unsigned char digest[16];
//clock_t c1, c2;
// Open files
if((fpi = fopen(file_input, "rb")) == NULL) {
fprintf(stderr, "Cannot open input file!\n");
return(-1);
}
if((fpo = fopen(file_output, "wb")) == NULL) {
fprintf(stderr, "Cannot open output file!\n");
return(-1);
}
// Get MD5 Checksum of key
MD5String(key, digest);
// Seed the PRNG with the md5 checksum of the key
prng_seed(digest);
// Decode
//c1 = clock();
decode_file(fpi, fpo);
//c2 = clock();
//printf("%f\n", get_speed(c1,c2));
//system("PAUSE");
// Close files
fclose(fpi);
fclose(fpo);
return(0);
}
int encode_steg(char *file_cont, char *file_data,
char *file_output, unsigned char *key)
{
FILE *fpc, *fpd, *fpo;
unsigned char digest[16];
unsigned long max_hide=0;
//clock_t c1, c2;
// Open files
if((fpc = fopen(file_cont, "rb")) == NULL) {
fprintf(stderr, "Cannot open container file!\n");
return(-1);
}
if((fpd = fopen(file_data, "rb")) == NULL) {
fprintf(stderr, "Cannot open data file!\n");
return(-1);
}
if((fpo = fopen(file_output, "wb")) == NULL) {
fprintf(stderr, "Cannot open output file!\n");
return(-1);
}
// Make sure the data will fit in the container
max_hide = get_max_hide(get_filesize(fpc)-STARTBYTE-(sizeof(struct stash_hdr)*8));
if(max_hide < get_filesize(fpd)) {
fprintf(stderr, "Error! Data file cannot fit in %s; %d bytes max!\n",
file_cont, (int)max_hide);
return(-1);
}
// Get MD5 Checksum of key
MD5String(key, digest);
// Seed the PRNG with the md5 checksum of the key
prng_seed(digest);
// Encode
//c1 = clock();
encode_file(fpc, fpd, fpo);
//c2 = clock();
//printf("%f\n", get_speed(c1,c2));
//system("PAUSE");
// Close files
fclose(fpc);
fclose(fpd);
fclose(fpo);
return(0);
}
void
ri (void)
{
char *random_devs[] = {"/dev/urandom",
"/dev/random",
0};
int i;
int fd;
int done = 0;
/* first, check if one of /dev/random, /dev/urandom or /dev/prandom */
for (i = 0; (!done) && random_devs[i]; i++) {
if ((fd = open (random_devs[i], O_RDONLY, 0600)) == -1) {
if (errno == ENOENT) {
continue;
}
else {
printf ("%s: trouble reading from %s\n",
getprogname (), random_devs[i]);
perror (getprogname ());
exit (-1);
}
}
else {
/* we found a random device; let's get some bytes from it */
ssize_t seed_len = 32;
char *seed = (char *) malloc (seed_len * sizeof (char));
int cur_bytes_read, bytes_read = 0;
bytes_read = 0;
do {
cur_bytes_read = read (fd, seed, seed_len - bytes_read);
bytes_read += cur_bytes_read;
} while ((bytes_read < seed_len) && (cur_bytes_read > 0));
if (bytes_read == seed_len) {
prng_seed (seed, seed_len);
done = 1;
}
else {
printf ("%s: trouble reading from %s\n",
getprogname (), random_devs[i]);
perror (getprogname ());
exit (-1);
}
bzero (seed, seed_len);
free (seed);
seed = NULL;
}
}
if (!done) {
/* no /dev/?random device */
/* quick'n dirty way to inialize the pseudorandom number generator */
struct {
int pid;
int time;
} rid;
rid.pid = getpid ();
rid.time = time (NULL);
prng_seed (&rid, sizeof (rid));
bzero (&rid, sizeof (rid));
}
}
void pgr_srand(int x)
{
prng_seed();
}
int pgr_rand(int start, int end)
{
return (int)((rand_r(prng_seed()) * 1.0 / RAND_MAX) * (end - start) + start + 0.5);
}
int joint_histogram(PyArrayObject* JH,
unsigned int clampI,
unsigned int clampJ,
PyArrayIterObject* iterI,
const PyArrayObject* imJ_padded,
const PyArrayObject* Tvox,
long interp)
{
const signed short* J=(signed short*)imJ_padded->data;
size_t dimJX=imJ_padded->dimensions[0]-2;
size_t dimJY=imJ_padded->dimensions[1]-2;
size_t dimJZ=imJ_padded->dimensions[2]-2;
signed short Jnn[8];
double W[8];
signed short *bufI, *bufJnn;
double *bufW;
signed short i, j;
size_t off;
size_t u2 = imJ_padded->dimensions[2];
size_t u3 = u2+1;
size_t u4 = imJ_padded->dimensions[1]*u2;
size_t u5 = u4+1;
size_t u6 = u4+u2;
size_t u7 = u6+1;
double wx, wy, wz, wxwy, wxwz, wywz;
double W0, W2, W3, W4;
int nn, nx, ny, nz;
double *H = (double*)PyArray_DATA(JH);
double Tx, Ty, Tz;
double *tvox = (double*)PyArray_DATA(Tvox);
void (*interpolate)(unsigned int, double*, unsigned int, const signed short*, const double*, int, void*);
void* interp_params = NULL;
prng_state rng;
/*
Check assumptions regarding input arrays. If it fails, the
function will return -1 without doing anything else.
iterI : assumed to iterate over a signed short encoded, possibly
non-contiguous array.
imJ_padded : assumed C-contiguous (last index varies faster) & signed
short encoded.
H : assumed C-contiguous.
Tvox : assumed C-contiguous:
either a 3x4=12-sized array (or bigger) for an affine transformation
or a 3xN array for a pre-computed transformation, with N equal
to the size of the array corresponding to iterI (no checking
done)
*/
if (PyArray_TYPE(iterI->ao) != NPY_SHORT) {
fprintf(stderr, "Invalid type for the array iterator\n");
return -1;
}
if ( (!PyArray_ISCONTIGUOUS(imJ_padded)) ||
(!PyArray_ISCONTIGUOUS(JH)) ||
(!PyArray_ISCONTIGUOUS(Tvox)) ) {
fprintf(stderr, "Some non-contiguous arrays\n");
return -1;
}
/* Reset the source image iterator */
PyArray_ITER_RESET(iterI);
/* Set interpolation method */
if (interp==0)
interpolate = &_pv_interpolation;
else if (interp>0)
interpolate = &_tri_interpolation;
else { /* interp < 0 */
interpolate = &_rand_interpolation;
prng_seed(-interp, &rng);
interp_params = (void*)(&rng);
}
/* Re-initialize joint histogram */
memset((void*)H, 0, clampI*clampJ*sizeof(double));
/* Looop over source voxels */
while(iterI->index < iterI->size) {
/* Source voxel intensity */
bufI = (signed short*)PyArray_ITER_DATA(iterI);
i = bufI[0];
/* Compute the transformed grid coordinates of current voxel */
Tx = *tvox; tvox++;
Ty = *tvox; tvox++;
Tz = *tvox; tvox++;
/* Test whether the current voxel is below the intensity
threshold, or the transformed point is completly outside
the reference grid */
if ((i>=0) &&
(Tx>-1) && (Tx<dimJX) &&
(Ty>-1) && (Ty<dimJY) &&
(Tz>-1) && (Tz<dimJZ)) {
/*
Nearest neighbor (floor coordinates in the padded
image, hence +1).
Notice that using the floor function doubles excetution time.
FIXME: see if we can replace this with assembler instructions.
*/
nx = FLOOR(Tx) + 1;
ny = FLOOR(Ty) + 1;
nz = FLOOR(Tz) + 1;
/* The convention for neighbor indexing is as follows:
*
* Floor slice Ceil slice
*
* 2----6 3----7 y
* | | | | ^
* | | | | |
* 0----4 1----5 ---> x
*/
/*** Trilinear interpolation weights.
Note: wx = nnx + 1 - Tx, where nnx is the location in
the NON-PADDED grid */
wx = nx - Tx;
wy = ny - Ty;
wz = nz - Tz;
wxwy = wx*wy;
wxwz = wx*wz;
wywz = wy*wz;
/*** Prepare buffers */
bufJnn = Jnn;
bufW = W;
/*** Initialize neighbor list */
off = nx*u4 + ny*u2 + nz;
nn = 0;
/*** Neighbor 0: (0,0,0) */
W0 = wxwy*wz;
APPEND_NEIGHBOR(off, W0);
/*** Neighbor 1: (0,0,1) */
APPEND_NEIGHBOR(off+1, wxwy-W0);
/*** Neighbor 2: (0,1,0) */
W2 = wxwz-W0;
APPEND_NEIGHBOR(off+u2, W2);
/*** Neightbor 3: (0,1,1) */
W3 = wx-wxwy-W2;
APPEND_NEIGHBOR(off+u3, W3);
/*** Neighbor 4: (1,0,0) */
W4 = wywz-W0;
APPEND_NEIGHBOR(off+u4, W4);
/*** Neighbor 5: (1,0,1) */
APPEND_NEIGHBOR(off+u5, wy-wxwy-W4);
/*** Neighbor 6: (1,1,0) */
APPEND_NEIGHBOR(off+u6, wz-wxwz-W4);
/*** Neighbor 7: (1,1,1) */
APPEND_NEIGHBOR(off+u7, 1-W3-wy-wz+wywz);
/* Update the joint histogram using the desired interpolation technique */
interpolate(i, H, clampJ, Jnn, W, nn, interp_params);
} /* End of IF TRANSFORMS INSIDE */
/* Update source index */
PyArray_ITER_NEXT(iterI);
} /* End of loop over voxels */
return 0;
}