int
main(int argc, char *argv[]) {
struct cmdlineInfo cmdline;
struct pam pam;
sample ** pixels; /* pixel data */
unsigned int hsamples; /* horizontal samples used */
unsigned int hstep; /* horizontal step size */
unsigned int vstep; /* vertical step size */
float angle;
pgm_init(&argc, argv); /* initialize netpbm system */
parseCommandLine(argc, argv, &cmdline);
readRelevantPixels(cmdline.inputFilename, cmdline.hstep, cmdline.vstep,
&hstep, &vstep, &pixels, &pam, &hsamples);
replacePixelValuesWithScaledDiffs(&pam, pixels, hsamples, cmdline.dstep);
getAngle(&pam, pixels, hstep, vstep, hsamples,
cmdline.maxangle, cmdline.astep, cmdline.qmin,
cmdline.fast, cmdline.verbose, &angle);
/* report the result on stdout */
printf("%.2f\n", angle);
freePixels(pixels, pam.height);
return 0;
}
int main(int argc, char* argv[])
{
FILE *in;
int **image;
double **image_i;
double **image_d;
int c;
int N;
int coeff_start = 5000, wm_length = 10000;
double wm_alpha = 0.2;
int width, height;
pgm_init(&argc, argv); wm_init2();
while ((c = getopt(argc, argv, "a:s:l:")) != EOF) {
switch (c) {
case 'a':
wm_alpha = atof(optarg);
break;
case 's':
coeff_start = atoi(optarg);
break;
case 'l':
wm_length = atoi(optarg);
break;
}
}
argc -= optind;
argv += optind;
in = stdin;
open_image(in, &width, &height);
image = imatrix(height, width);
load_image(image, in, width, height);
if (height == width)
N = height;
else {
fprintf(stderr, "Cannot Proccess non-square images!\n");
exit( -11);
}
image_i = dmatrix(height, width);
image_d = dmatrix(height, width);
if (image_d == NULL) {
fprintf(stderr, "Unable to allocate the double array\n");
exit(1);
}
matrix_i2d(image, image_i, N);
hartley(image_i, image_d, N);
read_watermark(image_d, N, coeff_start, wm_length, wm_alpha);
freematrix_d(image_i, height);
freematrix_d(image_d, height);
fclose(in);
exit(EXIT_SUCCESS);
}
int main(int argc, char* argv[])
{
FILE *in;
int **image_i;
double *image_f = NULL;
int N;
int c;
int coeff_start = 5000, wm_length = 10000;
double wm_alpha = 0.2;
pgm_init(&argc, argv); wm_init2();
while ((c = getopt(argc, argv, "a:s:l:")) != EOF) {
switch (c) {
case 'a':
wm_alpha = atof(optarg);
break;
case 's':
coeff_start = atoi(optarg);
break;
case 'l':
wm_length = atoi(optarg);
break;
}
}
argc -= optind;
argv += optind;
in = stdin;
open_image(in, &width, &height);
image_i = imatrix(height, width);
load_image(image_i, in, width, height);
if (height == width)
N = height;
else {
fprintf(stderr, "Cannot Proccess non-square images!\n");
exit( -11);
}
initialize_constants();
image_f = (double *)calloc(N * N, sizeof(double));
if (image_f == NULL) {
printf("Unable to allocate the float array\n");
exit(1);
}
put_image_from_int_2_double(image_i, image_f, N);
fct2d(image_f, N, N);
read_watermark(image_f, N, coeff_start, wm_length, wm_alpha);
fclose(in);
freematrix(image_i, height);
free(image_f);
exit(EXIT_SUCCESS);
}
void *zmq_init (int io_threads_)
{
if (io_threads_ < 0) {
errno = EINVAL;
return NULL;
}
#if defined ZMQ_HAVE_OPENPGM
// Init PGM transport. Ensure threading and timer are enabled. Find PGM
// protocol ID. Note that if you want to use gettimeofday and sleep for
// openPGM timing, set environment variables PGM_TIMER to "GTOD" and
// PGM_SLEEP to "USLEEP".
pgm_error_t *pgm_error = NULL;
const bool ok = pgm_init (&pgm_error);
if (ok != TRUE) {
// Invalid parameters don't set pgm_error_t
zmq_assert (pgm_error != NULL);
if (pgm_error->domain == PGM_ERROR_DOMAIN_TIME && (
pgm_error->code == PGM_ERROR_FAILED)) {
// Failed to access RTC or HPET device.
pgm_error_free (pgm_error);
errno = EINVAL;
return NULL;
}
// PGM_ERROR_DOMAIN_ENGINE: WSAStartup errors or missing WSARecvMsg.
zmq_assert (false);
}
#endif
#ifdef ZMQ_HAVE_WINDOWS
// Intialise Windows sockets. Note that WSAStartup can be called multiple
// times given that WSACleanup will be called for each WSAStartup.
// We do this before the ctx constructor since its embedded mailbox_t
// object needs Winsock to be up and running.
WORD version_requested = MAKEWORD (2, 2);
WSADATA wsa_data;
int rc = WSAStartup (version_requested, &wsa_data);
zmq_assert (rc == 0);
zmq_assert (LOBYTE (wsa_data.wVersion) == 2 &&
HIBYTE (wsa_data.wVersion) == 2);
#endif
// Create 0MQ context.
zmq::ctx_t *ctx = new (std::nothrow) zmq::ctx_t ((uint32_t) io_threads_);
alloc_assert (ctx);
return (void*) ctx;
}
int main(void)
{
graph_t g;
node_t n0, n1, n2;
edge_t e0_1, e1_2;
pthread_t t0, t1, t2;
edge_attr_t mq_attr, fifo_attr;
memset(&mq_attr, 0, sizeof(mq_attr));
mq_attr.nr_produce = sizeof(msg_t);
mq_attr.nr_consume = sizeof(msg_t);
mq_attr.nr_threshold = sizeof(msg_t);
mq_attr.mq_maxmsg = 10;
mq_attr.type = pgm_mq_edge;
fifo_attr = mq_attr;
#ifdef TEST_INCREMENTAL_PRODUCTION
fifo_attr.nr_produce /= 2;
#endif
fifo_attr.type = pgm_fifo_edge;
CheckError(pgm_init("/tmp/graphs", 1));
CheckError(pgm_init_graph(&g, "demo"));
CheckError(pgm_init_node(&n0, g, "n0"));
CheckError(pgm_init_node(&n1, g, "n1"));
CheckError(pgm_init_node(&n2, g, "n2"));
CheckError(pgm_init_edge(&e0_1, n0, n1, "e0_1", &fifo_attr));
CheckError(pgm_init_edge(&e1_2, n1, n2, "e1_2", &mq_attr));
pthread_barrier_init(&init_barrier, 0, 3);
pthread_create(&t0, 0, thread, &g);
pthread_create(&t1, 0, thread, &g);
pthread_create(&t2, 0, thread, &g);
pthread_join(t0, 0);
pthread_join(t1, 0);
pthread_join(t2, 0);
CheckError(pgm_destroy_graph(g));
CheckError(pgm_destroy());
return 0;
}
void *zmq_init (int app_threads_, int io_threads_, int flags_)
{
// There should be at least a single application thread managed
// by the dispatcher. There's no need for I/O threads if 0MQ is used
// only for inproc messaging
if (app_threads_ < 1 || io_threads_ < 0 ||
app_threads_ > 63 || io_threads_ > 63) {
errno = EINVAL;
return NULL;
}
#if defined ZMQ_HAVE_OPENPGM
// Unfortunately, OpenPGM doesn't support refcounted init/shutdown, thus,
// let's fail if it was initialised beforehand.
zmq_assert (!pgm_supported ());
// Init PGM transport. Ensure threading and timer are enabled. Find PGM
// protocol ID. Note that if you want to use gettimeofday and sleep for
// openPGM timing, set environment variables PGM_TIMER to "GTOD" and
// PGM_SLEEP to "USLEEP".
GError *pgm_error = NULL;
int rc = pgm_init (&pgm_error);
if (rc != TRUE) {
if (pgm_error->domain == PGM_IF_ERROR && (
pgm_error->code == PGM_IF_ERROR_INVAL ||
pgm_error->code == PGM_IF_ERROR_XDEV ||
pgm_error->code == PGM_IF_ERROR_NODEV ||
pgm_error->code == PGM_IF_ERROR_NOTUNIQ ||
pgm_error->code == PGM_IF_ERROR_ADDRFAMILY ||
pgm_error->code == PGM_IF_ERROR_FAMILY ||
pgm_error->code == PGM_IF_ERROR_NODATA ||
pgm_error->code == PGM_IF_ERROR_NONAME ||
pgm_error->code == PGM_IF_ERROR_SERVICE)) {
g_error_free (pgm_error);
errno = EINVAL;
return NULL;
}
zmq_assert (false);
}
#endif
// Create 0MQ context.
zmq::dispatcher_t *dispatcher = new (std::nothrow) zmq::dispatcher_t (
app_threads_, io_threads_, flags_);
zmq_assert (dispatcher);
return (void*) dispatcher;
}
int
main (
int argc,
char *argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
if (!pgm_init (&pgm_err)) {
fprintf (stderr, "Unable to start PGM engine: %s\n", pgm_err->message);
pgm_error_free (pgm_err);
return EXIT_FAILURE;
}
pgm_sock_t* sock = NULL;
const char* network = argv[1];
int udp_encap_port = 7510;
int xxx = 0;
char buf[4196];
memset(buf, 0, 4196);
sock = create_sock(network, udp_encap_port);
int p_status = pthread_create (&nak_thread, NULL, &nak_routine, sock);
if ((sock != NULL) && (p_status == 0))
{
do {
sprintf(buf, "%d", xxx);
const int status = pgm_send (sock, buf, 4196, NULL);
if (PGM_IO_STATUS_NORMAL != status) {
fprintf (stderr, "pgm_send() failed.\n");
}
xxx ++;
usleep(10*1000);
} while(1);
}
/* cleanup */
if (sock) {
pgm_close (sock, TRUE);
sock = NULL;
}
pgm_shutdown();
return EXIT_SUCCESS;
}
// TODO: app_threads and flags parameters are not used anymore...
// Reflect this in the API/ABI.
void *zmq_init (int /*app_threads_*/, int io_threads_, int /*flags_*/)
{
if (io_threads_ < 0) {
errno = EINVAL;
return NULL;
}
#if defined ZMQ_HAVE_OPENPGM
// Unfortunately, OpenPGM doesn't support refcounted init/shutdown, thus,
// let's fail if it was initialised beforehand.
zmq_assert (!pgm_supported ());
// Init PGM transport. Ensure threading and timer are enabled. Find PGM
// protocol ID. Note that if you want to use gettimeofday and sleep for
// openPGM timing, set environment variables PGM_TIMER to "GTOD" and
// PGM_SLEEP to "USLEEP".
GError *pgm_error = NULL;
int rc = pgm_init (&pgm_error);
if (rc != TRUE) {
if (pgm_error->domain == PGM_IF_ERROR && (
pgm_error->code == PGM_IF_ERROR_INVAL ||
pgm_error->code == PGM_IF_ERROR_XDEV ||
pgm_error->code == PGM_IF_ERROR_NODEV ||
pgm_error->code == PGM_IF_ERROR_NOTUNIQ ||
pgm_error->code == PGM_IF_ERROR_ADDRFAMILY ||
pgm_error->code == PGM_IF_ERROR_FAMILY ||
pgm_error->code == PGM_IF_ERROR_NODATA ||
pgm_error->code == PGM_IF_ERROR_NONAME ||
pgm_error->code == PGM_IF_ERROR_SERVICE)) {
g_error_free (pgm_error);
errno = EINVAL;
return NULL;
}
zmq_assert (false);
}
#endif
// Create 0MQ context.
zmq::ctx_t *ctx = new (std::nothrow) zmq::ctx_t ((uint32_t) io_threads_);
zmq_assert (ctx);
return (void*) ctx;
}
bool zmq::initialize_network ()
{
#if defined ZMQ_HAVE_OPENPGM
// Init PGM transport. Ensure threading and timer are enabled. Find PGM
// protocol ID. Note that if you want to use gettimeofday and sleep for
// openPGM timing, set environment variables PGM_TIMER to "GTOD" and
// PGM_SLEEP to "USLEEP".
pgm_error_t *pgm_error = NULL;
const bool ok = pgm_init (&pgm_error);
if (ok != TRUE) {
// Invalid parameters don't set pgm_error_t
zmq_assert (pgm_error != NULL);
if (pgm_error->domain == PGM_ERROR_DOMAIN_TIME
&& (pgm_error->code == PGM_ERROR_FAILED)) {
// Failed to access RTC or HPET device.
pgm_error_free (pgm_error);
errno = EINVAL;
return false;
}
// PGM_ERROR_DOMAIN_ENGINE: WSAStartup errors or missing WSARecvMsg.
zmq_assert (false);
}
#endif
#ifdef ZMQ_HAVE_WINDOWS
// Intialise Windows sockets. Note that WSAStartup can be called multiple
// times given that WSACleanup will be called for each WSAStartup.
WORD version_requested = MAKEWORD (2, 2);
WSADATA wsa_data;
int rc = WSAStartup (version_requested, &wsa_data);
zmq_assert (rc == 0);
zmq_assert (LOBYTE (wsa_data.wVersion) == 2
&& HIBYTE (wsa_data.wVersion) == 2);
#endif
return true;
}
void *zmq_init (int io_threads_)
{
if (io_threads_ < 0) {
errno = EINVAL;
return NULL;
}
#if defined ZMQ_HAVE_OPENPGM
// Init PGM transport. Ensure threading and timer are enabled. Find PGM
// protocol ID. Note that if you want to use gettimeofday and sleep for
// openPGM timing, set environment variables PGM_TIMER to "GTOD" and
// PGM_SLEEP to "USLEEP".
pgm_error_t *pgm_error = NULL;
const bool rc = pgm_init (&pgm_error);
if (rc != TRUE) {
// Invalid parameters don't set pgm_error_t
zmq_assert (pgm_error != NULL);
if (pgm_error->domain == PGM_ERROR_DOMAIN_TIME && (
pgm_error->code == PGM_ERROR_FAILED)) {
// Failed to access RTC or HPET device.
pgm_error_free (pgm_error);
errno = EINVAL;
return NULL;
}
// PGM_ERROR_DOMAIN_ENGINE: WSAStartup errors or missing WSARecvMsg.
zmq_assert (false);
}
#endif
// Create 0MQ context.
zmq::ctx_t *ctx = new (std::nothrow) zmq::ctx_t ((uint32_t) io_threads_);
zmq_assert (ctx);
return (void*) ctx;
}
int main()
{
int fd=inotify_init();
int in=inotify_add_watch(fd,"/dev/shm",IN_CLOSE_WRITE);
char buf[BUF_LEN];
pgm_init();
fft_init();
if (!glfwInit())
exit(EXIT_FAILURE);
GLFWwindow* window = glfwCreateWindow(width[0]+width[1], (int)fmax(2*height[0],2*height[1]),
"gig-e-camera", NULL, NULL);
glfwMakeContextCurrent(window);
const int n_tex=4;
GLuint texture[n_tex];
glGenTextures( n_tex, texture );
int i;
for(i=0;i<n_tex;i++){
glBindTexture( GL_TEXTURE_2D, texture[i] );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
GL_NEAREST );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
glTexImage2D(GL_TEXTURE_2D,0,GL_LUMINANCE,width[i/2],height[i/2],0,
GL_LUMINANCE,GL_UNSIGNED_SHORT,0);
}
glEnable(GL_TEXTURE_2D);
while (1){
int len, i = 0;
len = read (fd, buf, BUF_LEN);
if(len<=0)
printf("error\n");
while (i < len) {
struct inotify_event *event;
event = (struct inotify_event *) &buf[i];
printf ("wd=%d mask=%u cookie=%u len=%u ",
event->wd, event->mask,
event->cookie, event->len);
if (event->len)
printf ("name=%s\n", event->name);
else
printf("\n");
i += EVENT_SIZE + event->len;
}
{
int i;
fft_fill(); fft_run();
for(i=0;i<2;i++){
glBindTexture( GL_TEXTURE_2D, texture[2*i] );
glTexSubImage2D(GL_TEXTURE_2D,0,0,0,width[i],height[i],GL_LUMINANCE,GL_UNSIGNED_SHORT,kspace[i]);
glBindTexture( GL_TEXTURE_2D, texture[2*i+1] );
glTexSubImage2D(GL_TEXTURE_2D,0,0,0,width[i],height[i],GL_LUMINANCE,GL_UNSIGNED_SHORT,image[i]);
}
{
int win_width,win_height;
glfwGetFramebufferSize(window, &win_width, &win_height);
glViewport(0, 0, win_width, win_height);
}
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, width[0]+width[1], 0,fmax(2*height[0],2*height[1]), 1.f, -1.f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glColor3f(1.f,1.f,1.f);
draw_quad(texture[0],0,0,width[0],height[0]);
draw_quad(texture[1],0,height[0],width[0],height[0]);
draw_quad(texture[2],width[0],0,width[1],height[1]);
draw_quad(texture[3],width[0],height[1],width[1],height[1]);
glfwSwapBuffers(window);
}
}
glfwTerminate();
}
int
main (
int argc,
char* argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
log_init ();
g_message ("enonblocksyncrecvmsgv");
if (!pgm_init (&pgm_err)) {
g_error ("Unable to start PGM engine: %s", pgm_err->message);
pgm_error_free (pgm_err);
return EXIT_FAILURE;
}
/* parse program arguments */
const char* binary_name = strrchr (argv[0], '/');
int c;
while ((c = getopt (argc, argv, "s:n:p:lh")) != -1)
{
switch (c) {
case 'n': g_network = optarg; break;
case 's': g_port = atoi (optarg); break;
case 'p': g_udp_encap_port = atoi (optarg); break;
case 'l': g_multicast_loop = TRUE; break;
case 'h':
case '?': usage (binary_name);
}
}
/* setup signal handlers */
signal (SIGSEGV, on_sigsegv);
signal (SIGINT, on_signal);
signal (SIGTERM, on_signal);
#ifdef SIGHUP
signal (SIGHUP, SIG_IGN);
#endif
if (!on_startup ()) {
g_error ("startup failed");
return EXIT_FAILURE;
}
/* incoming message buffer, iov_len must be less than SC_IOV_MAX */
const long iov_len = 8;
const long ev_len = 1;
g_message ("Using iov_len %li ev_len %li", iov_len, ev_len);
struct pgm_msgv_t msgv[iov_len];
struct epoll_event events[ev_len]; /* wait for maximum 1 event */
/* epoll file descriptor */
const int efd = epoll_create (IP_MAX_MEMBERSHIPS);
if (efd < 0) {
g_error ("epoll_create failed errno %i: \"%s\"", errno, strerror(errno));
return EXIT_FAILURE;
}
const int retval = pgm_epoll_ctl (g_sock, efd, EPOLL_CTL_ADD, EPOLLIN);
if (retval < 0) {
g_error ("pgm_epoll_ctl failed.");
return EXIT_FAILURE;
}
/* dispatch loop */
g_message ("entering PGM message loop ... ");
do {
struct timeval tv;
int timeout;
size_t len;
const int status = pgm_recvmsgv (g_sock,
msgv,
iov_len,
0,
&len,
&pgm_err);
switch (status) {
case PGM_IO_STATUS_NORMAL:
on_msgv (msgv, len);
break;
case PGM_IO_STATUS_TIMER_PENDING:
{
socklen_t optlen = sizeof (tv);
pgm_getsockopt (g_sock, IPPROTO_PGM, PGM_TIME_REMAIN, &tv, &optlen);
}
goto block;
case PGM_IO_STATUS_RATE_LIMITED:
{
socklen_t optlen = sizeof (tv);
pgm_getsockopt (g_sock, IPPROTO_PGM, PGM_RATE_REMAIN, &tv, &optlen);
}
/* fall through */
case PGM_IO_STATUS_WOULD_BLOCK:
/* poll for next event */
block:
timeout = PGM_IO_STATUS_WOULD_BLOCK == status ? -1 : ((tv.tv_sec * 1000) + (tv.tv_usec / 1000));
epoll_wait (efd, events, G_N_ELEMENTS(events), timeout /* ms */);
break;
default:
if (pgm_err) {
g_warning ("%s", pgm_err->message);
pgm_error_free (pgm_err);
pgm_err = NULL;
}
if (PGM_IO_STATUS_ERROR == status)
break;
}
} while (!g_quit);
g_message ("message loop terminated, cleaning up.");
/* cleanup */
close (efd);
if (g_sock) {
g_message ("closing PGM socket.");
pgm_close (g_sock, TRUE);
g_sock = NULL;
}
g_message ("PGM engine shutdown.");
pgm_shutdown ();
g_message ("finished.");
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
int saca_pgm();
FILE *fd;
FILE *fd1;
int cols, rows, i, j, bucle, carpeta, nresultados;
float carac[11];
gray maxval;
gray **imagen;
gray **imagen1;
struct dirent **resultados=NULL;
// inicializamos todas las variables
pgm_init(&argc, argv);
nresultados=0;
printf("Haciendo magia...\n");
fd = fopen(filepatron, "r");
if (fd == NULL ) {
pm_error("error: no puedo abrir los ficheros");
exit(-1);
}
imagen = pgm_readpgm(fd, &cols, &rows, &maxval);
if (imgpatron == NULL ) {
pm_error("error: no puedo leer las imagenes");
exit(-1);
}
// abrimos el fichero de imagen en modo lectura
fd1 = fopen(argv[1], "r");
if (fd1 == NULL ) {
pm_error("error: no puedo abrir los ficheros");
exit(-1);
}
// leemos la imagen
imagen1 = pgm_readpgm(fd1, &cols, &rows, &maxval);
if (imagen == NULL ) {
pm_error("error: no puedo leer las imagenes");
exit(-1);
}
//*******************************************************************//
//en 'imagen' tenemos la foto a analizar para el fichero clasificador//
//*******************************************************************//
for(i=0; i<rows;i++){
for(j=0; j<cols; j++){
//Retiramos fondo por division
imagen[i][j] = MIN(255, 255*((float)imagen[i][j]/(float)imgpatron[i][j]) );
//Aplicamos umbral
if(imagen[i][j] <= 210)
imagen[i][j] = 0;
else
imagen[i][j] = 255;
}
}
// <----- falta erosionar y dilatar!!!
/* dilate */
pgm_dilate(imagen, cols, rows, 2);
/* erode */
pgm_erode(imagen, cols, rows, 2);
pgm_writepgm(stdout, imagen, cols, rows, 255, 0);
fclose(fd);
//Liberamos la memoria de la imagen, para cargar otra
pgm_freearray(imagen, rows);
printf("Fin de la magia...\n");
fclose(patron);
exit(0);
}
int
main (
int argc,
char* argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
#ifndef _WIN32
puts ("いちごのショートケーキ");
#else
puts ("ichigo no shōtokēki");
#endif
if (!pgm_init (&pgm_err)) {
fprintf (stderr, "Unable to start PGM engine: %s\n", pgm_err->message);
pgm_error_free (pgm_err);
return EXIT_FAILURE;
}
/* parse program arguments */
#ifdef _WIN32
const char* binary_name = strrchr (argv[0], '\\');
#else
const char* binary_name = strrchr (argv[0], '/');
#endif
if (NULL == binary_name) binary_name = argv[0];
else binary_name++;
int c;
while ((c = getopt (argc, argv, "s:n:p:f:K:N:lih")) != -1)
{
switch (c) {
case 'n': network = optarg; break;
case 's': port = atoi (optarg); break;
case 'p': udp_encap_port = atoi (optarg); break;
case 'f': use_fec = TRUE; break;
case 'K': rs_k = atoi (optarg); break;
case 'N': rs_n = atoi (optarg); break;
case 'l': use_multicast_loop = TRUE; break;
case 'i':
pgm_if_print_all();
return EXIT_SUCCESS;
case 'h':
case '?': usage (binary_name);
}
}
if (use_fec && ( !rs_n || !rs_k )) {
fprintf (stderr, "Invalid Reed-Solomon parameters RS(%d,%d).\n", rs_n, rs_k);
usage (binary_name);
}
/* setup signal handlers */
#ifdef SIGHUP
signal (SIGHUP, SIG_IGN);
#endif
#ifndef _WIN32
int e = pipe (terminate_pipe);
assert (0 == e);
signal (SIGINT, on_signal);
signal (SIGTERM, on_signal);
#else
terminateEvent = WSACreateEvent ();
SetConsoleCtrlHandler ((PHANDLER_ROUTINE)on_console_ctrl, TRUE);
setvbuf (stdout, (char *) NULL, _IONBF, 0);
#endif /* !_WIN32 */
if (!on_startup()) {
fprintf (stderr, "Startup failed\n");
return EXIT_FAILURE;
}
/* dispatch loop */
#ifndef _WIN32
int fds, read_fd = async_get_socket (async);
fd_set readfds;
#else
DWORD cEvents = 2;
WSAEVENT waitEvents[ 2 ];
DWORD dwEvents;
waitEvents[0] = terminateEvent;
waitEvents[1] = async_get_event (async);
#endif /* !_WIN32 */
puts ("Entering PGM message loop ... ");
do {
char buffer[4096];
struct pgm_sockaddr_t from;
socklen_t fromlen = sizeof (from);
const ssize_t len = async_recvfrom (async,
buffer,
sizeof(buffer),
&from,
&fromlen);
if (len >= 0) {
on_data (buffer, len, &from);
} else {
#ifndef _WIN32
fds = MAX(terminate_pipe[0], read_fd) + 1;
FD_ZERO(&readfds);
FD_SET(terminate_pipe[0], &readfds);
FD_SET(read_fd, &readfds);
fds = select (fds, &readfds, NULL, NULL, NULL);
#else
dwEvents = WSAWaitForMultipleEvents (cEvents, waitEvents, FALSE, WSA_INFINITE, FALSE);
switch (dwEvents) {
case WSA_WAIT_EVENT_0+1: WSAResetEvent (waitEvents[1]); break;
default: break;
}
#endif /* _WIN32 */
}
} while (!is_terminated);
puts ("Message loop terminated, cleaning up.");
/* cleanup */
#ifndef _WIN32
close (terminate_pipe[0]);
close (terminate_pipe[1]);
#else
WSACloseEvent (terminateEvent);
#endif /* !_WIN32 */
if (async) {
puts ("Destroying asynchronous queue.");
async_destroy (async);
async = NULL;
}
if (sock) {
puts ("Closing PGM socket.");
pgm_close (sock, TRUE);
sock = NULL;
}
puts ("PGM engine shutdown.");
pgm_shutdown ();
puts ("finished.");
return EXIT_SUCCESS;
}
int
main (
int argc,
char* argv[]
)
{
pgm_error_t* pgm_err = NULL;
#ifdef CONFIG_WITH_HTTP
gboolean enable_http = FALSE;
#endif
#ifdef CONFIG_WITH_SNMP
gboolean enable_snmpx = FALSE;
#endif
setlocale (LC_ALL, "");
/* pre-initialise PGM messages module to add hook for GLib logging */
pgm_messages_init();
log_init ();
g_message ("pgmrecv");
if (!pgm_init (&pgm_err)) {
g_error ("Unable to start PGM engine: %s", (pgm_err && pgm_err->message) ? pgm_err->message : "(null)");
pgm_error_free (pgm_err);
pgm_messages_shutdown();
return EXIT_FAILURE;
}
g_thread_init (NULL);
/* parse program arguments */
const char* binary_name = strrchr (argv[0], '/');
static struct option long_options[] = {
{ "network", required_argument, NULL, 'n' },
{ "service", required_argument, NULL, 's' },
{ "port", required_argument, NULL, 'p' },
{ "enable-loop", no_argument, NULL, 'l' },
#ifdef CONFIG_WITH_HTTP
{ "enable-http", no_argument, NULL, 'H' },
#endif
#ifdef CONFIG_WITH_SNMP
{ "enable-snmp", no_argument, NULL, 'S' },
#endif
{ "list", no_argument, NULL, 'i' },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
int c;
while ((c = getopt_long (argc, argv, "a:s:n:p:lih"
#ifdef CONFIG_WITH_HTTP
"H"
#endif
#ifdef CONFIG_WITH_SNMP
"S"
#endif
, long_options, NULL)) != -1)
{
switch (c) {
case 'n': g_network = optarg; break;
case 'a': g_source = optarg; break;
case 's': g_port = atoi (optarg); break;
case 'p': g_udp_encap_port = atoi (optarg); break;
case 'l': g_multicast_loop = TRUE; break;
#ifdef CONFIG_WITH_HTTP
case 'H': enable_http = TRUE; break;
#endif
#ifdef CONFIG_WITH_SNMP
case 'S': enable_snmpx = TRUE; break;
#endif
case 'i':
pgm_if_print_all();
pgm_messages_shutdown();
return EXIT_SUCCESS;
case 'h':
case '?':
pgm_messages_shutdown();
usage (binary_name);
}
}
#ifdef CONFIG_WITH_HTTP
if (enable_http) {
if (!pgm_http_init (PGM_HTTP_DEFAULT_SERVER_PORT, &pgm_err)) {
g_error ("Unable to start HTTP interface: %s", pgm_err->message);
pgm_error_free (pgm_err);
pgm_shutdown();
pgm_messages_shutdown();
return EXIT_FAILURE;
}
}
#endif
#ifdef CONFIG_WITH_SNMP
if (enable_snmpx) {
if (!pgm_snmp_init (&pgm_err)) {
g_error ("Unable to start SNMP interface: %s", pgm_err->message);
pgm_error_free (pgm_err);
#ifdef CONFIG_WITH_HTTP
if (enable_http)
pgm_http_shutdown ();
#endif
pgm_shutdown ();
pgm_messages_shutdown();
return EXIT_FAILURE;
}
}
#endif
g_loop = g_main_loop_new (NULL, FALSE);
g_quit = FALSE;
/* setup signal handlers */
signal (SIGSEGV, on_sigsegv);
#ifdef SIGHUP
signal (SIGHUP, SIG_IGN);
#endif
#ifdef G_OS_UNIX
const int e = pipe (g_quit_pipe);
g_assert (0 == e);
pgm_signal_install (SIGINT, on_signal, g_loop);
pgm_signal_install (SIGTERM, on_signal, g_loop);
#else
g_quit_event = CreateEvent (NULL, TRUE, FALSE, TEXT("QuitEvent"));
SetConsoleCtrlHandler ((PHANDLER_ROUTINE)on_console_ctrl, TRUE);
setvbuf (stdout, (char *) NULL, _IONBF, 0);
#endif
/* delayed startup */
g_message ("scheduling startup.");
g_timeout_add (0, (GSourceFunc)on_startup, NULL);
/* dispatch loop */
g_message ("entering main event loop ... ");
g_main_loop_run (g_loop);
g_message ("event loop terminated, cleaning up.");
/* cleanup */
g_quit = TRUE;
#ifdef G_OS_UNIX
const char one = '1';
const size_t writelen = write (g_quit_pipe[1], &one, sizeof(one));
g_assert (sizeof(one) == writelen);
g_thread_join (g_thread);
close (g_quit_pipe[0]);
close (g_quit_pipe[1]);
#else
WSASetEvent (g_quit_event);
g_thread_join (g_thread);
WSACloseEvent (g_quit_event);
#endif
g_main_loop_unref (g_loop);
g_loop = NULL;
if (g_sock) {
g_message ("closing PGM socket.");
pgm_close (g_sock, TRUE);
g_sock = NULL;
}
#ifdef CONFIG_WITH_HTTP
if (enable_http)
pgm_http_shutdown();
#endif
#ifdef CONFIG_WITH_SNMP
if (enable_snmpx)
pgm_snmp_shutdown();
#endif
g_message ("PGM engine shutdown.");
pgm_shutdown();
g_message ("finished.");
pgm_messages_shutdown();
return EXIT_SUCCESS;
}
int
main (
int argc,
char* argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
log_init ();
g_message ("blocksyncrecv");
if (!pgm_init (&pgm_err)) {
g_error ("Unable to start PGM engine: %s", pgm_err->message);
pgm_error_free (pgm_err);
return EXIT_FAILURE;
}
/* parse program arguments */
const char* binary_name = strrchr (argv[0], '/');
int c;
while ((c = getopt (argc, argv, "s:n:p:lh")) != -1)
{
switch (c) {
case 'n': g_network = optarg; break;
case 's': g_port = atoi (optarg); break;
case 'p': g_udp_encap_port = atoi (optarg); break;
case 'l': g_multicast_loop = TRUE; break;
case 'h':
case '?': usage (binary_name);
}
}
/* setup signal handlers */
signal(SIGSEGV, on_sigsegv);
#ifdef SIGHUP
signal(SIGHUP, SIG_IGN);
#endif
#ifdef G_OS_UNIX
signal(SIGINT, on_signal);
signal(SIGTERM, on_signal);
#else
SetConsoleCtrlHandler ((PHANDLER_ROUTINE)on_console_ctrl, TRUE);
setvbuf (stdout, (char *) NULL, _IONBF, 0);
#endif
on_startup();
/* dispatch loop */
g_message ("entering PGM message loop ... ");
do {
char buffer[4096];
size_t len;
struct pgm_sockaddr_t from;
socklen_t fromlen = sizeof(from);
const int status = pgm_recvfrom (g_sock,
buffer,
sizeof(buffer),
0,
&len,
&from,
&fromlen,
&pgm_err);
if (PGM_IO_STATUS_NORMAL == status)
on_data (buffer, len, &from);
else {
if (pgm_err) {
g_warning ("%s", pgm_err->message);
pgm_error_free (pgm_err);
pgm_err = NULL;
}
if (PGM_IO_STATUS_ERROR == status)
break;
}
} while (!g_quit);
g_message ("message loop terminated, cleaning up.");
/* cleanup */
if (g_sock) {
g_message ("closing PGM socket.");
pgm_close (g_sock, TRUE);
g_sock = NULL;
}
g_message ("PGM engine shutdown.");
pgm_shutdown ();
g_message ("finished.");
return EXIT_SUCCESS;
}
int
main (
int argc,
char *argv[]
)
{
pgm_error_t* err = NULL;
/* pre-initialise PGM messages module to add hook for GLib logging */
pgm_messages_init();
log_init ();
g_message ("app");
if (!pgm_init (&err)) {
g_error ("Unable to start PGM engine: %s", (err && err->message) ? err->message : "(null)");
pgm_error_free (err);
pgm_messages_shutdown();
return EXIT_FAILURE;
}
/* parse program arguments */
#ifdef _WIN32
const char* binary_name = strrchr (argv[0], '\\');
#else
const char* binary_name = strrchr (argv[0], '/');
#endif
if (NULL == binary_name) binary_name = argv[0];
else binary_name++;
int c;
while ((c = getopt (argc, argv, "s:n:h")) != -1)
{
switch (c) {
case 'n': g_network = optarg; break;
case 's': g_port = atoi (optarg); break;
case 'h':
case '?':
pgm_messages_shutdown();
usage (binary_name);
}
}
g_loop = g_main_loop_new (NULL, FALSE);
/* setup signal handlers */
#ifndef _WIN32
signal (SIGSEGV, on_sigsegv);
signal (SIGHUP, SIG_IGN);
pgm_signal_install (SIGINT, on_signal, g_loop);
pgm_signal_install (SIGTERM, on_signal, g_loop);
#else
SetConsoleCtrlHandler ((PHANDLER_ROUTINE)on_console_ctrl, TRUE);
setvbuf (stdout, (char *) NULL, _IONBF, 0);
#endif /* !_WIN32 */
/* delayed startup */
g_message ("scheduling startup.");
g_timeout_add (0, (GSourceFunc)on_startup, NULL);
/* dispatch loop */
g_message ("entering main event loop ... ");
g_main_loop_run (g_loop);
g_message ("event loop terminated, cleaning up.");
/* cleanup */
g_main_loop_unref(g_loop);
g_loop = NULL;
if (g_sessions) {
g_message ("destroying sessions.");
g_hash_table_foreach_remove (g_sessions, (GHRFunc)destroy_session, NULL);
g_hash_table_unref (g_sessions);
g_sessions = NULL;
}
if (g_stdin_channel) {
puts ("unbinding stdin.");
g_io_channel_unref (g_stdin_channel);
g_stdin_channel = NULL;
}
g_message ("PGM engine shutdown.");
pgm_shutdown();
g_message ("finished.");
pgm_messages_shutdown();
return EXIT_SUCCESS;
}
int
main(int argc, char *argv[]) {
struct cmdlineInfo cmdline;
FILE* ifP;
pgm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
srand(cmdline.randomseedSpec ? cmdline.randomseed : pm_randseed());
ifP = pm_openr(cmdline.inputFilespec);
if (cmdline.halftone == QT_HILBERT)
doHilbert(ifP, cmdline.clumpSize);
else {
struct converter converter;
struct pam graypam;
struct pam bitpam;
tuplen * grayrow;
tuple * bitrow;
int row;
pnm_readpaminit(ifP, &graypam, PAM_STRUCT_SIZE(tuple_type));
bitpam = makeOutputPam(graypam.width, graypam.height);
pnm_writepaminit(&bitpam);
switch (cmdline.halftone) {
case QT_FS:
converter = createFsConverter(&graypam, cmdline.threshval);
break;
case QT_ATKINSON:
converter = createAtkinsonConverter(&graypam, cmdline.threshval);
break;
case QT_THRESH:
converter = createThreshConverter(&graypam, cmdline.threshval);
break;
case QT_DITHER8:
converter = createClusterConverter(&graypam, DT_REGULAR, 8);
break;
case QT_CLUSTER:
converter = createClusterConverter(&graypam,
DT_CLUSTER,
cmdline.clusterRadius);
break;
case QT_HILBERT:
pm_error("INTERNAL ERROR: halftone is QT_HILBERT where it "
"shouldn't be.");
break;
}
grayrow = pnm_allocpamrown(&graypam);
bitrow = pnm_allocpamrow(&bitpam);
for (row = 0; row < graypam.height; ++row) {
pnm_readpamrown(&graypam, grayrow);
converter.convertRow(&converter, row, grayrow, bitrow);
pnm_writepamrow(&bitpam, bitrow);
}
pnm_freepamrow(bitrow);
pnm_freepamrow(grayrow);
if (converter.destroy)
converter.destroy(&converter);
}
pm_close(ifP);
return 0;
}
int
main (
int argc,
char* argv[]
)
{
int e;
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
log_init ();
g_message ("syncrecv");
if (!pgm_init (&pgm_err)) {
g_error ("Unable to start PGM engine: %s", pgm_err->message);
pgm_error_free (pgm_err);
return EXIT_FAILURE;
}
/* parse program arguments */
const char* binary_name = strrchr (argv[0], '/');
int c;
while ((c = getopt (argc, argv, "s:n:p:lh")) != -1)
{
switch (c) {
case 'n': g_network = optarg; break;
case 's': g_port = atoi (optarg); break;
case 'p': g_udp_encap_port = atoi (optarg); break;
case 'l': g_multicast_loop = TRUE; break;
case 'h':
case '?': usage (binary_name);
}
}
g_quit = FALSE;
#ifdef G_OS_UNIX
e = pipe (g_quit_pipe);
#else
e = _pipe (g_quit_pipe, 4096, _O_BINARY | _O_NOINHERIT);
#endif
g_assert (0 == e);
/* setup signal handlers */
signal(SIGSEGV, on_sigsegv);
signal(SIGINT, on_signal);
signal(SIGTERM, on_signal);
#ifdef SIGHUP
signal(SIGHUP, SIG_IGN);
#endif
if (!on_startup()) {
g_error ("startup failed");
exit(1);
}
/* dispatch loop */
g_message ("entering PGM message loop ... ");
do {
struct timeval tv;
int timeout;
int n_fds = 2;
struct pollfd fds[ 1 + n_fds ];
char buffer[4096];
gsize len;
pgm_tsi_t from;
const int status = pgm_recvfrom (g_transport,
buffer,
sizeof(buffer),
0,
&len,
&from,
&pgm_err);
switch (status) {
case PGM_IO_STATUS_NORMAL:
on_data (buffer, len, &from);
break;
case PGM_IO_STATUS_TIMER_PENDING:
pgm_transport_get_timer_pending (g_transport, &tv);
goto block;
case PGM_IO_STATUS_RATE_LIMITED:
pgm_transport_get_rate_remaining (g_transport, &tv);
case PGM_IO_STATUS_WOULD_BLOCK:
/* poll for next event */
block:
timeout = PGM_IO_STATUS_WOULD_BLOCK == status ? -1 : ((tv.tv_sec * 1000) + (tv.tv_usec / 1000));
memset (fds, 0, sizeof(fds));
fds[0].fd = g_quit_pipe[0];
fds[0].events = POLLIN;
pgm_transport_poll_info (g_transport, &fds[1], &n_fds, POLLIN);
poll (fds, 1 + n_fds, timeout /* ms */);
break;
default:
if (pgm_err) {
g_warning ("%s", pgm_err->message);
pgm_error_free (pgm_err);
pgm_err = NULL;
}
if (PGM_IO_STATUS_ERROR == status)
break;
}
} while (!g_quit);
g_message ("message loop terminated, cleaning up.");
/* cleanup */
close (g_quit_pipe[0]);
close (g_quit_pipe[1]);
if (g_transport) {
g_message ("destroying transport.");
pgm_transport_destroy (g_transport, TRUE);
g_transport = NULL;
}
g_message ("PGM engine shutdown.");
pgm_shutdown ();
g_message ("finished.");
return EXIT_SUCCESS;
}
int
main (
int argc,
char *argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
puts ("PGM daytime service");
if (!pgm_init (&pgm_err)) {
fprintf (stderr, "Unable to start PGM engine: %s\n", pgm_err->message);
pgm_error_free (pgm_err);
return EXIT_FAILURE;
}
/* parse program arguments */
#ifdef _WIN32
const char* binary_name = strrchr (argv[0], '\\');
#else
const char* binary_name = strrchr (argv[0], '/');
#endif
if (NULL == binary_name) binary_name = argv[0];
else binary_name++;
static struct option long_options[] = {
{ "network", required_argument, NULL, 'n' },
{ "service", required_argument, NULL, 's' },
{ "port", required_argument, NULL, 'p' },
{ "speed-limit", required_argument, NULL, 'r' },
{ "enable-pgmcc", no_argument, NULL, 'c' },
{ "enable-loop", no_argument, NULL, 'l' },
{ "enable-fec", required_argument, NULL, 'f' },
{ "list", no_argument, NULL, 'i' },
{ "help", no_argument, NULL, 'h' },
{ NULL, 0, NULL, 0 }
};
int c;
while ((c = getopt_long (argc, argv, "s:n:p:r:cf:N:K:P:lih", long_options, NULL)) != -1)
{
switch (c) {
case 'n': network = optarg; break;
case 's': port = atoi (optarg); break;
case 'p': udp_encap_port = atoi (optarg); break;
case 'r': max_rte = atoi (optarg); break;
case 'c': use_pgmcc = TRUE; break;
case 'f':
use_fec = TRUE;
switch (optarg[0]) {
case 'p':
case 'P':
proactive_packets = 1;
break;
case 'b':
case 'B':
proactive_packets = 1;
case 'o':
case 'O':
use_ondemand_parity = TRUE;
break;
}
break;
case 'N': rs_n = atoi (optarg); break;
case 'K': rs_k = atoi (optarg); break;
case 'P': proactive_packets = atoi (optarg); break;
case 'l': use_multicast_loop = TRUE; break;
case 'i':
pgm_if_print_all();
return EXIT_SUCCESS;
case 'h':
case '?':
usage (binary_name);
}
}
if (use_fec && ( !rs_n || !rs_k )) {
fprintf (stderr, "Invalid Reed-Solomon parameters RS(%d,%d).\n", rs_n, rs_k);
usage (binary_name);
}
/* setup signal handlers */
#ifdef SIGHUP
signal (SIGHUP, SIG_IGN);
#endif
#ifndef _WIN32
int e = pipe (terminate_pipe);
assert (0 == e);
const int flags = fcntl (terminate_pipe[0], F_GETFL);
fcntl (terminate_pipe[0], F_SETFL, flags | O_NONBLOCK);
signal (SIGINT, on_signal);
signal (SIGTERM, on_signal);
#else
terminateEvent = WSACreateEvent();
SetConsoleCtrlHandler ((PHANDLER_ROUTINE)on_console_ctrl, TRUE);
setvbuf (stdout, (char *) NULL, _IONBF, 0);
#endif /* !_WIN32 */
if (!on_startup()) {
fprintf (stderr, "Startup failed\n");
return EXIT_FAILURE;
}
/* service loop */
do {
time_t now;
time (&now);
const struct tm* time_ptr = localtime(&now);
#ifndef _WIN32
char s[1024];
const size_t slen = strftime (s, sizeof(s), TIME_FORMAT, time_ptr);
const int status = pgm_send (sock, s, slen + 1, NULL);
#else
char s[1024];
const size_t slen = strftime (s, sizeof(s), TIME_FORMAT, time_ptr);
wchar_t ws[1024];
size_t wslen = MultiByteToWideChar (CP_ACP, 0, s, slen, ws, 1024);
char us[1024];
size_t uslen = WideCharToMultiByte (CP_UTF8, 0, ws, wslen + 1, us, sizeof(us), NULL, NULL);
const int status = pgm_send (sock, us, uslen + 1, NULL);
#endif
if (PGM_IO_STATUS_NORMAL != status) {
fprintf (stderr, "pgm_send() failed.\n");
}
#ifndef _WIN32
sleep (1);
#else
Sleep (1 * 1000);
#endif
} while (!is_terminated);
/* cleanup */
puts ("Waiting for NAK thread.");
#ifndef _WIN32
pthread_join (nak_thread, NULL);
close (terminate_pipe[0]);
close (terminate_pipe[1]);
#else
WaitForSingleObject (nak_thread, INFINITE);
CloseHandle (nak_thread);
WSACloseEvent (terminateEvent);
#endif /* !_WIN32 */
if (sock) {
puts ("Closing PGM sock.");
pgm_close (sock, TRUE);
sock = NULL;
}
puts ("PGM engine shutdown.");
pgm_shutdown();
puts ("finished.");
return EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
FILE *in = stdin;
FILE *out = stdout;
FILE *sig = NULL;
char output_name[MAXPATHLEN] = "(stdout)";
char input_name[MAXPATHLEN] = "(stdin)";
char signature_name[MAXPATHLEN];
int i, c, w;
int row;
int n;
double alpha = 0.0;
double beta = 0.0;
int filter = 0;
int method = -1;
int level = 0;
char filter_name[MAXPATHLEN] = "";
int verbose = 0;
gray **image;
Image_tree dwts;
gray maxval;
int rows, cols, format;
double *watermark;
progname = argv[0];
pgm_init(&argc, argv); wm_init();
while ((c = getopt(argc, argv, "a:b:e:f:F:h?o:s:v:")) != EOF) {
switch (c) {
case 'a':
alpha = atof(optarg);
if (alpha <= 0.0) {
fprintf(stderr, "%s: alpha factor %f out of range\n", progname, alpha);
exit(1);
}
break;
case 'b':
beta = atof(optarg);
if (beta <= 0.0) {
fprintf(stderr, "%s: beta factor %f out of range\n", progname, beta);
exit(1);
}
break;
case 'e':
method = atoi(optarg);
if (method < 0) {
fprintf(stderr, "%s: wavelet filtering method %d out of range\n", progname, method);
exit(1);
}
break;
case 'f':
filter = atoi(optarg);
if (filter <= 0) {
fprintf(stderr, "%s: filter number %d out of range\n", progname, filter);
exit(1);
}
break;
case 'F':
strcpy(filter_name, optarg);
break;
case 'h':
case '?':
usage();
break;
case 'o':
if ((out = fopen(optarg, "wb")) == NULL) {
fprintf(stderr, "%s: unable to open output file %s\n", progname, optarg);
exit(1);
}
strcpy(output_name, optarg);
break;
case 's':
if ((sig = fopen(optarg, "r")) == NULL) {
fprintf(stderr, "%s: unable to open signature file %s\n", progname, optarg);
exit(1);
}
strcpy(signature_name, optarg);
break;
case 'v':
verbose = atoi(optarg);
if (verbose < 0) {
fprintf(stderr, "%s: verbosity level %d out of range\n", progname, verbose);
exit(1);
}
break;
}
}
argc -= optind;
argv += optind;
if (argc > 1) {
usage();
exit(1);
}
if (argc == 1 && *argv[0] != '-') {
if ((in = fopen(argv[0], "rb")) == NULL) {
fprintf(stderr, "%s: unable to open input file %s\n", progname, argv[0]);
exit(1);
}
else
strcpy(input_name, argv[0]);
}
if (sig) {
char line[32];
fgets(line, sizeof(line), sig);
if (strspn(line, "WGSG") >= 4) {
fscanf(sig, "%d\n", &n);
if (alpha == 0.0)
fscanf(sig, "%lf\n", &alpha);
else
fscanf(sig, "%*f\n");
if (beta == 0.0)
fscanf(sig, "%lf\n", &beta);
else
fscanf(sig, "%*f\n");
if (method < 0)
fscanf(sig, "%d\n", &method);
else
fscanf(sig, "%*d\n");
if (filter == 0)
fscanf(sig, "%d\n", &filter);
else
fscanf(sig, "%*d\n");
if (!strcmp(filter_name, ""))
fscanf(sig, "%[^\n\r]\n", filter_name);
else
fscanf(sig, "%*[^\n\r]\n");
}
else {
fprintf(stderr, "%s: invalid signature file %s\n", progname, signature_name);
exit(1);
}
}
else {
fprintf(stderr, "%s: signature file not specified, use -s file option\n", progname);
exit(1);
}
watermark = malloc(n * sizeof(double));
for (i = 0; i < n; i++)
fscanf(sig, "%lf\n", &watermark[i]);
fclose(sig);
pgm_readpgminit(in, &cols, &rows, &maxval, &format);
image = pgm_allocarray(cols, rows);
for (row = 0; row < rows; row++)
pgm_readpgmrow(in, image[row], cols, maxval, format);
fclose(in);
// complete decomposition
level = find_deepest_level(cols, rows) - 1;
// wavelet transform
init_dwt(cols, rows, filter_name, filter, level, method);
#ifdef POLLEN_STUFF
#include "pollen_stuff.c"
#endif
#ifdef PARAM_STUFF
#include "param_stuff.c"
#endif
dwts = fdwt(image);
// build tree for subband selection, calculate subband thresholds
init_subbands(dwts);
set_subbands_type_beta(HORIZONTAL, beta);
set_subbands_type_beta(VERTICAL, beta);
calc_subbands_threshold();
w = 0;
while (w < n) {
Subband_data s;
// select subband with max. threshold
s = select_subband();
if (verbose > 1)
fprintf(stderr, "%s: selected subband %s%d, T=%lf, beta=%lf\n", progname, subband_name(s->type), s->level, s->T, s->beta);
// watermark significant coefficients and set them selected
// check is entire signature has been embedded
c = select_subband_coeff(s);
do {
double p;
if (c < 0)
// no more significant coefficients in subband
break;
p = get_subband_coeff(s, c);
if (p < s->Cmax) {
if (verbose > 2)
fprintf(stderr, "%s: embedding sig. coeff. #%d (= %lf)\n into %s%d coeff. #%d\n",
progname, w, watermark[w], subband_name(s->type), s->level, c);
p = p + alpha * s->beta * s->T * watermark[w];
set_subband_coeff(s, c, p);
w++;
}
mark_subband_coeff(s, c);
// select next significant coefficient
c = select_subband_coeff_from(s, c);
} while (w < n);
// update subband threshold
s->T /= 2.0;
}
free_subbands();
free(watermark);
idwt(dwts, image);
pgm_writepgminit(out, cols, rows, maxval, 0);
for (row = 0; row < rows; row++)
pgm_writepgmrow(out, image[row], cols, maxval, 0);
fclose(out);
pgm_freearray(image, rows);
exit(0);
}
int
main (
int argc,
char *argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
/* pre-initialise PGM messages module to add hook for GLib logging */
pgm_messages_init();
log_init();
if (!pgm_init (&pgm_err)) {
g_error ("Unable to start PGM engine: %s", pgm_err->message);
pgm_error_free (pgm_err);
pgm_messages_shutdown();
return EXIT_FAILURE;
}
/* parse program arguments */
const char* binary_name = strrchr (argv[0], '/');
int c;
while ((c = getopt (argc, argv, "s:n:p:r:f:K:N:lih")) != -1)
{
switch (c) {
case 'n':
g_network = optarg;
break;
case 's':
g_port = atoi (optarg);
break;
case 'p':
g_udp_encap_port = atoi (optarg);
break;
case 'r':
g_max_rte = atoi (optarg);
break;
case 'f':
g_fec = TRUE;
break;
case 'K':
g_k = atoi (optarg);
break;
case 'N':
g_n = atoi (optarg);
break;
case 'l':
g_multicast_loop = TRUE;
break;
case 'i':
pgm_if_print_all();
pgm_messages_shutdown();
return EXIT_SUCCESS;
case 'h':
case '?':
pgm_messages_shutdown();
usage (binary_name);
}
}
if (g_fec && ( !g_k || !g_n )) {
pgm_messages_shutdown();
g_error ("Invalid Reed-Solomon parameters RS(%d, %d).", g_n, g_k);
usage (binary_name);
}
/* setup signal handlers */
signal (SIGSEGV, on_sigsegv);
#ifdef SIGHUP
signal (SIGHUP, SIG_IGN);
#endif
if (create_pgm_socket())
{
while (optind < argc) {
const int status = pgm_send (g_sock, argv[optind], strlen(argv[optind]) + 1, NULL);
if (PGM_IO_STATUS_NORMAL != status) {
g_warning ("pgm_send failed.");
}
optind++;
}
}
/* cleanup */
if (g_sock) {
pgm_close (g_sock, TRUE);
g_sock = NULL;
}
pgm_shutdown();
pgm_messages_shutdown();
return EXIT_SUCCESS;
}
int zmq::pgm_socket_t::open_transport ()
{
// Can not open transport before destroying old one.
zmq_assert (transport == NULL);
// Zero counter used in msgrecv.
nbytes_rec = 0;
nbytes_processed = 0;
pgm_msgv_processed = 0;
// TODO: Converting bool to int? Not nice.
int pgm_ok = true;
GError *pgm_error = NULL;
// Init PGM transport.
// Ensure threading enabled, ensure timer enabled and find PGM protocol id.
//
// Note that if you want to use gettimeofday and sleep for openPGM timing,
// set environment variables PGM_TIMER to "GTOD"
// and PGM_SLEEP to "USLEEP".
int rc = pgm_init ();
if (rc != 0) {
errno = EINVAL;
return -1;
}
// PGM transport GSI.
pgm_gsi_t gsi;
std::string gsi_base;
if (options.identity.size () > 0) {
// Create gsi from identity string.
gsi_base = options.identity;
} else {
// Generate random gsi.
gsi_base = uuid_t ().to_string ();
}
rc = pgm_gsi_create_from_string (&gsi, gsi_base.c_str (), -1);
if (rc != pgm_ok) {
errno = EINVAL;
return -1;
}
//zmq_log (1, "Transport GSI: %s, %s(%i)\n", pgm_print_gsi (&gsi),
// __FILE__, __LINE__);
struct pgm_transport_info_t *res = NULL;
if (!pgm_if_get_transport_info (network, NULL, &res, &pgm_error)) {
errno = EINVAL;
return -1;
}
res->ti_gsi = gsi;
res->ti_dport = port_number;
// If we are using UDP encapsulation update gsr or res.
if (udp_encapsulation) {
res->ti_udp_encap_ucast_port = port_number;
res->ti_udp_encap_mcast_port = port_number;
}
if (!pgm_transport_create (&transport, res, &pgm_error)) {
pgm_if_free_transport_info (res);
// TODO: tranlate errors from glib into errnos.
errno = EINVAL;
return -1;
}
pgm_if_free_transport_info (res);
// Common parameters for receiver and sender.
// Set maximum transport protocol data unit size (TPDU).
rc = pgm_transport_set_max_tpdu (transport, pgm_max_tpdu);
if (rc != pgm_ok) {
errno = EINVAL;
return -1;
}
// Set maximum number of network hops to cross.
rc = pgm_transport_set_hops (transport, 16);
if (rc != pgm_ok) {
errno = EINVAL;
return -1;
}
// Set nonblocking send/recv sockets.
if (!pgm_transport_set_nonblocking (transport, true)) {
errno = EINVAL;
return -1;
}
if (receiver) {
// Receiver transport.
// Set transport->can_send_data = FALSE.
// Note that NAKs are still generated by the transport.
rc = pgm_transport_set_recv_only (transport, true, false);
zmq_assert (rc == pgm_ok);
if (options.rcvbuf) {
rc = pgm_transport_set_rcvbuf (transport, (int) options.rcvbuf);
if (rc != pgm_ok)
return -1;
}
// Set NAK transmit back-off interval [us].
rc = pgm_transport_set_nak_bo_ivl (transport, 50 * 1000);
zmq_assert (rc == pgm_ok);
// Set timeout before repeating NAK [us].
rc = pgm_transport_set_nak_rpt_ivl (transport, 200 * 1000);
zmq_assert (rc == pgm_ok);
// Set timeout for receiving RDATA.
rc = pgm_transport_set_nak_rdata_ivl (transport, 200 * 1000);
zmq_assert (rc == pgm_ok);
// Set retries for NAK without NCF/DATA (NAK_DATA_RETRIES).
rc = pgm_transport_set_nak_data_retries (transport, 5);
zmq_assert (rc == pgm_ok);
// Set retries for NCF after NAK (NAK_NCF_RETRIES).
rc = pgm_transport_set_nak_ncf_retries (transport, 2);
zmq_assert (rc == pgm_ok);
// Set timeout for removing a dead peer [us].
rc = pgm_transport_set_peer_expiry (transport, 5 * 8192 * 1000);
zmq_assert (rc == pgm_ok);
// Set expiration time of SPM Requests [us].
rc = pgm_transport_set_spmr_expiry (transport, 25 * 1000);
zmq_assert (rc == pgm_ok);
// Set the size of the receive window.
// Data rate is in [B/s]. options.rate is in [kb/s].
if (options.rate <= 0) {
errno = EINVAL;
return -1;
}
rc = pgm_transport_set_rxw_max_rte (transport,
options.rate * 1000 / 8);
if (rc != pgm_ok) {
errno = EINVAL;
return -1;
}
// Recovery interval [s].
if (options.recovery_ivl <= 0) {
errno = EINVAL;
return -1;
}
rc = pgm_transport_set_rxw_secs (transport, options.recovery_ivl);
if (rc != pgm_ok) {
errno = EINVAL;
return -1;
}
} else {
// Sender transport.
// Set transport->can_recv = FALSE, waiting_pipe will not be read.
rc = pgm_transport_set_send_only (transport, TRUE);
zmq_assert (rc == pgm_ok);
if (options.sndbuf) {
rc = pgm_transport_set_sndbuf (transport, (int) options.sndbuf);
if (rc != pgm_ok)
return -1;
}
// Set the size of the send window.
// Data rate is in [B/s] options.rate is in [kb/s].
if (options.rate <= 0) {
errno = EINVAL;
return -1;
}
rc = pgm_transport_set_txw_max_rte (transport,
options.rate * 1000 / 8);
if (rc != pgm_ok) {
errno = EINVAL;
return -1;
}
// Recovery interval [s].
if (options.recovery_ivl <= 0) {
errno = EINVAL;
return -1;
}
rc = pgm_transport_set_txw_secs (transport, options.recovery_ivl);
if (rc != pgm_ok) {
errno = EINVAL;
return -1;
}
// Set interval of background SPM packets [us].
rc = pgm_transport_set_ambient_spm (transport, 8192 * 1000);
zmq_assert (rc == pgm_ok);
// Set intervals of data flushing SPM packets [us].
guint spm_heartbeat[] = {4 * 1000, 4 * 1000, 8 * 1000, 16 * 1000,
32 * 1000, 64 * 1000, 128 * 1000, 256 * 1000, 512 * 1000,
1024 * 1000, 2048 * 1000, 4096 * 1000, 8192 * 1000};
rc = pgm_transport_set_heartbeat_spm (transport, spm_heartbeat,
G_N_ELEMENTS(spm_heartbeat));
zmq_assert (rc == pgm_ok);
}
// Enable multicast loopback.
if (options.use_multicast_loop) {
rc = pgm_transport_set_multicast_loop (transport, true);
zmq_assert (rc == pgm_ok);
}
// Bind a transport to the specified network devices.
if (!pgm_transport_bind (transport, &pgm_error)) {
// TODO: tranlate errors from glib into errnos.
return -1;
}
return 0;
}
int
main (
int argc,
char* argv[]
)
{
pgm_error_t* pgm_err = NULL;
setlocale (LC_ALL, "");
#ifndef _WIN32
puts ("プリン プリン");
#else
_putws (L"プリン プリン");
#endif
if (!pgm_init (&pgm_err)) {
fprintf (stderr, "Unable to start PGM engine: %s\n", pgm_err->message);
pgm_error_free (pgm_err);
return EXIT_FAILURE;
}
/* parse program arguments */
const char* binary_name = strrchr (argv[0], '/');
int c;
while ((c = getopt (argc, argv, "s:n:p:f:K:N:lih")) != -1)
{
switch (c) {
case 'n': network = optarg; break;
case 's': port = atoi (optarg); break;
case 'p': udp_encap_port = atoi (optarg); break;
case 'f': use_fec = TRUE; break;
case 'K': rs_k = atoi (optarg); break;
case 'N': rs_n = atoi (optarg); break;
case 'l': use_multicast_loop = TRUE; break;
case 'i':
pgm_if_print_all();
return EXIT_SUCCESS;
case 'h':
case '?': usage (binary_name);
}
}
if (use_fec && ( !rs_n || !rs_k )) {
fprintf (stderr, "Invalid Reed-Solomon parameters RS(%d,%d).\n", rs_n, rs_k);
usage (binary_name);
}
/* setup signal handlers */
#ifdef SIGHUP
signal (SIGHUP, SIG_IGN);
#endif
#ifndef _WIN32
int e = pipe (terminate_pipe);
assert (0 == e);
signal (SIGINT, on_signal);
signal (SIGTERM, on_signal);
#else
terminate_event = CreateEvent (NULL, TRUE, FALSE, TEXT("TerminateEvent"));
SetConsoleCtrlHandler ((PHANDLER_ROUTINE)on_console_ctrl, TRUE);
#endif /* !_WIN32 */
if (!on_startup()) {
fprintf (stderr, "Startup failed\n");
return EXIT_FAILURE;
}
/* dispatch loop */
#ifndef _WIN32
int fds;
fd_set readfds;
#else
int n_handles = 3, recv_sock, pending_sock;
HANDLE waitHandles[ 3 ];
DWORD dwTimeout, dwEvents;
WSAEVENT recvEvent, pendingEvent;
recvEvent = WSACreateEvent ();
pgm_getsockopt (sock, PGM_RECV_SOCK, &recv_sock, sizeof(recv_sock));
WSAEventSelect (recv_sock, recvEvent, FD_READ);
pendingEvent = WSACreateEvent ();
pgm_getsockopt (sock, PGM_PENDING_SOCK, &pending_sock, sizeof(pending_sock));
WSAEventSelect (pending_sock, pendingEvent, FD_READ);
waitHandles[0] = terminate_event;
waitHandles[1] = recvEvent;
waitHandles[2] = pendingEvent;
#endif /* !_WIN32 */
puts ("Entering PGM message loop ... ");
do {
struct timeval tv;
char buffer[4096];
size_t len;
pgm_tsi_t from;
const int status = pgm_recvfrom (sock,
buffer,
sizeof(buffer),
0,
&len,
&from,
&pgm_err);
switch (status) {
case PGM_IO_STATUS_NORMAL:
on_data (buffer, len, &from);
break;
case PGM_IO_STATUS_TIMER_PENDING:
pgm_getsockopt (sock, PGM_TIME_REMAIN, &tv, sizeof(tv));
goto block;
case PGM_IO_STATUS_RATE_LIMITED:
pgm_getsockopt (sock, PGM_RATE_REMAIN, &tv, sizeof(tv));
case PGM_IO_STATUS_WOULD_BLOCK:
/* select for next event */
block:
#ifndef _WIN32
fds = terminate_pipe[0] + 1;
FD_ZERO(&readfds);
FD_SET(terminate_pipe[0], &readfds);
pgm_select_info (sock, &readfds, NULL, &fds);
fds = select (fds, &readfds, NULL, NULL, PGM_IO_STATUS_WOULD_BLOCK == status ? NULL : &tv);
#else
dwTimeout = PGM_IO_STATUS_WOULD_BLOCK == status ? INFINITE : (DWORD)((tv.tv_sec * 1000) + (tv.tv_usec / 1000));
dwEvents = WaitForMultipleObjects (n_handles, waitHandles, FALSE, dwTimeout);
switch (dwEvents) {
case WAIT_OBJECT_0+1: WSAResetEvent (recvEvent); break;
case WAIT_OBJECT_0+2: WSAResetEvent (pendingEvent); break;
default: break;
}
#endif /* !_WIN32 */
break;
default:
if (pgm_err) {
fprintf (stderr, "%s\n", pgm_err->message);
pgm_error_free (pgm_err);
pgm_err = NULL;
}
if (PGM_IO_STATUS_ERROR == status)
break;
}
} while (!is_terminated);
puts ("Message loop terminated, cleaning up.");
/* cleanup */
#ifndef _WIN32
close (terminate_pipe[0]);
close (terminate_pipe[1]);
#else
WSACloseEvent (recvEvent);
WSACloseEvent (pendingEvent);
CloseHandle (terminate_event);
#endif /* !_WIN32 */
if (sock) {
puts ("Destroying PGM socket.");
pgm_close (sock, TRUE);
sock = NULL;
}
puts ("PGM engine shutdown.");
pgm_shutdown ();
puts ("finished.");
return EXIT_SUCCESS;
}
int
main(int argc, char *argv[])
{
struct Record /* A SPOT image is broken up into */
{ /* records with the following fields */
long record; /* The record number (1, 2, 3...) */
unsigned char sub1; /* Record sub type 1 */
unsigned char type; /* The record type */
unsigned char sub2; /* Record sub type 2 */
unsigned char sub3; /* Record sub type 3 */
long length; /* Record length in bytes */
} arecord;
pgm_init( &argc, argv );
switch (argc)
{
case 7:
Color= -(atoi(argv[1])); /* Get the color to extract */
argv++;
case 6:
Firstcol = atoi(argv[1]); /* Get the rectangle to extract */
Firstline = atoi(argv[2]);
Lastcol = atoi(argv[3]);
Lastline = atoi(argv[4]);
argv += 4;
goto openfile; /* Yuk, a goto! */
case 3:
Color= -(atoi(argv[1])); /* Get the color to extract */
argv++;
case 2:
openfile:
spotfile = fopen(argv[1], "rb"); /* Open the input file */
if (spotfile == NULL) { perror("fopen"); exit(1); }
break;
default:
usage();
}
while (1) /* Get a record */
{
if (pm_readbiglong (spotfile, &arecord.record) == -1)
break;
arecord.sub1 = fgetc (spotfile);
arecord.type = fgetc (spotfile);
arecord.sub2 = fgetc (spotfile);
arecord.sub3 = fgetc (spotfile);
if (pm_readbiglong (spotfile, &arecord.length) == -1)
pm_error ("EOF / read error reading a record");
arecord.length -= 12; /* Subtract header size as well */
if (arecord.type == 0355 && arecord.sub1 == 0355)
arecord.length = get_image(arecord.length);
else if (arecord.type == 0300 && arecord.sub1 == 077)
arecord.length = get_imghdr(arecord.length);
#ifdef DEBUG
else
fprintf(stderr,
"Rcrd %3d, type %03o, stype %03o %03o %03o, length %d\n",
arecord.record, arecord.type, arecord.sub1, arecord.sub2,
(int) arecord.sub3 & 0xff, arecord.length);
#endif
/* Seek to next record */
fseek(spotfile, arecord.length, 1);
}
exit (0);
}
int
main(int argc,
char * argv[]) {
struct cmdlineInfo cmdline;
FILE * ifP;
int cols, rows;
int median;
enum medianMethod medianMethod;
pgm_init(&argc, argv);
parseCommandLine(argc, argv, &cmdline);
ifP = pm_openr(cmdline.inputFileName);
ccolso2 = cmdline.width / 2;
crowso2 = cmdline.height / 2;
pgm_readpgminit(ifP, &cols, &rows, &maxval, &format);
pgm_writepgminit(stdout, cols, rows, maxval, forceplain);
/* Allocate space for number of rows in mask size. */
grays = pgm_allocarray(cols, cmdline.height);
grayrow = pgm_allocrow(cols);
/* Read in and write out initial rows that won't get changed. */
for (row = 0; row < cmdline.height - 1; ++row) {
pgm_readpgmrow(ifP, grays[row], cols, maxval, format);
/* Write out the unchanged row. */
if (row < crowso2)
pgm_writepgmrow(stdout, grays[row], cols, maxval, forceplain);
}
median = (cmdline.height * cmdline.width) / 2;
/* Choose which sort to run. */
if (cmdline.type == MEDIAN_UNSPECIFIED) {
if ((maxval / ((cmdline.width * cmdline.height) - 1)) < cmdline.cutoff)
medianMethod = HISTOGRAM_SORT_MEDIAN;
else
medianMethod = SELECT_MEDIAN;
} else
medianMethod = cmdline.type;
switch (medianMethod) {
case SELECT_MEDIAN:
selectMedian(ifP, cmdline.width, cmdline.height, cols, rows, median);
break;
case HISTOGRAM_SORT_MEDIAN:
histogramSortMedian(ifP, cmdline.width, cmdline.height,
cols, rows, median);
break;
case MEDIAN_UNSPECIFIED:
pm_error("INTERNAL ERROR: median unspecified");
}
pm_close(ifP);
pm_close(stdout);
pgm_freearray(grays, cmdline.height);
pgm_freerow(grayrow);
return 0;
}
int zmq::pgm_socket_t::init (bool udp_encapsulation_, const char *network_)
{
// Can not open transport before destroying old one.
zmq_assert (transport == NULL);
// Parse port number.
const char *port_delim = strchr (network_, ':');
if (!port_delim) {
errno = EINVAL;
return -1;
}
uint16_t port_number = atoi (port_delim + 1);
char network [256];
if (port_delim - network_ >= (int) sizeof (network) - 1) {
errno = EINVAL;
return -1;
}
memset (network, '\0', sizeof (network));
memcpy (network, network_, port_delim - network_);
// Zero counter used in msgrecv.
nbytes_rec = 0;
nbytes_processed = 0;
pgm_msgv_processed = 0;
GError *pgm_error = NULL;
// Init PGM transport.
// Ensure threading enabled, ensure timer enabled and find PGM protocol id.
//
// Note that if you want to use gettimeofday and sleep for openPGM timing,
// set environment variables PGM_TIMER to "GTOD"
// and PGM_SLEEP to "USLEEP".
int rc = pgm_init ();
if (rc != 0) {
errno = EINVAL;
return -1;
}
// PGM transport GSI.
pgm_gsi_t gsi;
std::string gsi_base;
if (options.identity.size () > 0) {
// Create gsi from identity string.
gsi_base = options.identity;
} else {
// Generate random gsi.
gsi_base = uuid_t ().to_string ();
}
rc = pgm_gsi_create_from_string (&gsi, gsi_base.c_str (), -1);
if (rc != TRUE) {
errno = EINVAL;
return -1;
}
struct pgm_transport_info_t *res = NULL;
if (!pgm_if_get_transport_info (network, NULL, &res, &pgm_error)) {
if (pgm_error->domain == PGM_IF_ERROR && (
pgm_error->code == PGM_IF_ERROR_INVAL ||
pgm_error->code == PGM_IF_ERROR_XDEV ||
pgm_error->code == PGM_IF_ERROR_NODEV ||
pgm_error->code == PGM_IF_ERROR_NOTUNIQ ||
pgm_error->code == PGM_IF_ERROR_ADDRFAMILY ||
pgm_error->code == PGM_IF_ERROR_FAMILY ||
pgm_error->code == PGM_IF_ERROR_NODATA ||
pgm_error->code == PGM_IF_ERROR_NONAME ||
pgm_error->code == PGM_IF_ERROR_SERVICE)) {
errno = EINVAL;
g_error_free (pgm_error);
return -1;
}
zmq_assert (false);
}
res->ti_gsi = gsi;
res->ti_dport = port_number;
// If we are using UDP encapsulation update gsr or res.
if (udp_encapsulation_) {
res->ti_udp_encap_ucast_port = port_number;
res->ti_udp_encap_mcast_port = port_number;
}
if (!pgm_transport_create (&transport, res, &pgm_error)) {
if (pgm_error->domain == PGM_TRANSPORT_ERROR && (
pgm_error->code == PGM_TRANSPORT_ERROR_INVAL ||
pgm_error->code == PGM_TRANSPORT_ERROR_PERM ||
pgm_error->code == PGM_TRANSPORT_ERROR_NODEV)) {
pgm_if_free_transport_info (res);
g_error_free (pgm_error);
errno = EINVAL;
return -1;
}
zmq_assert (false);
}
pgm_if_free_transport_info (res);
// Common parameters for receiver and sender.
// Set maximum transport protocol data unit size (TPDU).
rc = pgm_transport_set_max_tpdu (transport, pgm_max_tpdu);
if (rc != TRUE) {
errno = EINVAL;
return -1;
}
// Set maximum number of network hops to cross.
rc = pgm_transport_set_hops (transport, 16);
if (rc != TRUE) {
errno = EINVAL;
return -1;
}
// Set nonblocking send/recv sockets.
if (!pgm_transport_set_nonblocking (transport, true)) {
errno = EINVAL;
return -1;
}
if (receiver) {
// Receiver transport.
// Note that NAKs are still generated by the transport.
rc = pgm_transport_set_recv_only (transport, true, false);
zmq_assert (rc == TRUE);
if (options.rcvbuf) {
rc = pgm_transport_set_rcvbuf (transport, (int) options.rcvbuf);
if (rc != TRUE)
return -1;
}
// Set NAK transmit back-off interval [us].
rc = pgm_transport_set_nak_bo_ivl (transport, 50 * 1000);
zmq_assert (rc == TRUE);
// Set timeout before repeating NAK [us].
rc = pgm_transport_set_nak_rpt_ivl (transport, 200 * 1000);
zmq_assert (rc == TRUE);
// Set timeout for receiving RDATA.
rc = pgm_transport_set_nak_rdata_ivl (transport, 200 * 1000);
zmq_assert (rc == TRUE);
// Set retries for NAK without NCF/DATA (NAK_DATA_RETRIES).
rc = pgm_transport_set_nak_data_retries (transport, 5);
zmq_assert (rc == TRUE);
// Set retries for NCF after NAK (NAK_NCF_RETRIES).
rc = pgm_transport_set_nak_ncf_retries (transport, 2);
zmq_assert (rc == TRUE);
// Set timeout for removing a dead peer [us].
rc = pgm_transport_set_peer_expiry (transport, 5 * 8192 * 1000);
zmq_assert (rc == TRUE);
// Set expiration time of SPM Requests [us].
rc = pgm_transport_set_spmr_expiry (transport, 25 * 1000);
zmq_assert (rc == TRUE);
// Set the size of the receive window.
// Data rate is in [B/s]. options.rate is in [kb/s].
if (options.rate <= 0) {
errno = EINVAL;
return -1;
}
rc = pgm_transport_set_rxw_max_rte (transport,
options.rate * 1000 / 8);
if (rc != TRUE) {
errno = EINVAL;
return -1;
}
// Recovery interval [s].
if (options.recovery_ivl <= 0) {
errno = EINVAL;
return -1;
}
rc = pgm_transport_set_rxw_secs (transport, options.recovery_ivl);
if (rc != TRUE) {
errno = EINVAL;
return -1;
}
} else {
// Sender transport.
// Waiting pipe won't be read.
rc = pgm_transport_set_send_only (transport, TRUE);
zmq_assert (rc == TRUE);
if (options.sndbuf) {
rc = pgm_transport_set_sndbuf (transport, (int) options.sndbuf);
if (rc != TRUE)
return -1;
}
// Set the size of the send window.
// Data rate is in [B/s] options.rate is in [kb/s].
if (options.rate <= 0) {
errno = EINVAL;
return -1;
}
rc = pgm_transport_set_txw_max_rte (transport,
options.rate * 1000 / 8);
if (rc != TRUE) {
errno = EINVAL;
return -1;
}
// Recovery interval [s].
if (options.recovery_ivl <= 0) {
errno = EINVAL;
return -1;
}
rc = pgm_transport_set_txw_secs (transport, options.recovery_ivl);
if (rc != TRUE) {
errno = EINVAL;
return -1;
}
// Set interval of background SPM packets [us].
rc = pgm_transport_set_ambient_spm (transport, 8192 * 1000);
zmq_assert (rc == TRUE);
// Set intervals of data flushing SPM packets [us].
guint spm_heartbeat[] = {4 * 1000, 4 * 1000, 8 * 1000, 16 * 1000,
32 * 1000, 64 * 1000, 128 * 1000, 256 * 1000, 512 * 1000,
1024 * 1000, 2048 * 1000, 4096 * 1000, 8192 * 1000};
rc = pgm_transport_set_heartbeat_spm (transport, spm_heartbeat,
G_N_ELEMENTS(spm_heartbeat));
zmq_assert (rc == TRUE);
}
// Enable multicast loopback.
if (options.use_multicast_loop) {
rc = pgm_transport_set_multicast_loop (transport, true);
zmq_assert (rc == TRUE);
}
// Bind a transport to the specified network devices.
if (!pgm_transport_bind (transport, &pgm_error)) {
if (pgm_error->domain == PGM_IF_ERROR && (
pgm_error->code == PGM_IF_ERROR_INVAL ||
pgm_error->code == PGM_IF_ERROR_XDEV ||
pgm_error->code == PGM_IF_ERROR_NODEV ||
pgm_error->code == PGM_IF_ERROR_NOTUNIQ ||
pgm_error->code == PGM_IF_ERROR_ADDRFAMILY ||
pgm_error->code == PGM_IF_ERROR_FAMILY ||
pgm_error->code == PGM_IF_ERROR_NODATA ||
pgm_error->code == PGM_IF_ERROR_NONAME ||
pgm_error->code == PGM_IF_ERROR_SERVICE)) {
g_error_free (pgm_error);
errno = EINVAL;
return -1;
}
zmq_assert (false);
}
// For receiver transport preallocate pgm_msgv array.
// TODO: ?
if (receiver) {
zmq_assert (in_batch_size > 0);
size_t max_tsdu_size = get_max_tsdu_size ();
pgm_msgv_len = (int) in_batch_size / max_tsdu_size;
if ((int) in_batch_size % max_tsdu_size)
pgm_msgv_len++;
zmq_assert (pgm_msgv_len);
pgm_msgv = (pgm_msgv_t*) malloc (sizeof (pgm_msgv_t) * pgm_msgv_len);
}
return 0;
}
int main(int argc, char **argv) {
int ncmds, i;
const char *tmp;
pgm_error_t *pgm_err = NULL;
/* FIXME */
signal(SIGPIPE, SIG_IGN);
setup_signal_handlers();
cmds = table_new(cmpstr, hashmurmur2, NULL, NULL);
ncmds = sizeof commands / sizeof (struct cmd);
for (i = 0; i < ncmds; ++i) {
struct cmd *cmd = commands + i;
table_insert(cmds, cmd->name, cmd);
}
if (argc != 2 && argc != 3)
usage();
else if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))
usage();
else if (argc == 3 && strcmp(argv[1], "-f"))
usage();
if (argc == 2 && daemon(1, 0) == -1)
fprintf(stderr, "Error daemonizing: %s\n", strerror(errno));
/* FIXME */
if (init_logger("/var/log/xcb/xcb-dp2.log", __LOG_DEBUG) == -1) {
fprintf(stderr, "Error initializing logger\n");
exit(1);
}
cfg_path = argc == 2 ? argv[1] : argv[2];
if ((cfg = config_load(cfg_path)) == NULL)
exit(1);
if ((tmp = variable_retrieve(cfg, "general", "log_level"))) {
if (!strcasecmp(tmp, "info"))
set_logger_level(__LOG_INFO);
else if (!strcasecmp(tmp, "notice"))
set_logger_level(__LOG_NOTICE);
else if (!strcasecmp(tmp, "warning"))
set_logger_level(__LOG_WARNING);
}
/* FIXME */
if (addms)
times = table_new(cmpstr, hashmurmur2, kfree, vfree);
clients_to_close = dlist_new(NULL, NULL);
clients = dlist_new(NULL, NULL);
monitors = dlist_new(NULL, NULL);
tp = thrpool_new(16, 512, 200, NULL);
if (!pgm_init(&pgm_err)) {
xcb_log(XCB_LOG_ERROR, "Error starting PGM engine: %s", pgm_err->message);
pgm_error_free(pgm_err);
goto err;
}
/* FIXME */
if (NEW(pgm_send_cfg) == NULL) {
xcb_log(XCB_LOG_ERROR, "Error allocating memory for PGM cfg");
goto err;
}
pgm_send_cfg->network = NULL;
pgm_send_cfg->port = 0;
init_pgm_send_cfg(pgm_send_cfg);
if (pgm_send_cfg->network == NULL) {
xcb_log(XCB_LOG_ERROR, "PGM network can't be NULL");
goto err;
}
if (pgm_send_cfg->port == 0) {
xcb_log(XCB_LOG_ERROR, "PGM port can't be zero");
goto err;
}
if ((pgm_sender = pgmsock_create(pgm_send_cfg->network, pgm_send_cfg->port, PGMSOCK_SENDER)) == NULL)
goto err;
/* FIXME */
if ((el = create_event_loop(1024 + 1000)) == NULL) {
xcb_log(XCB_LOG_ERROR, "Error creating event loop");
goto err;
}
create_time_event(el, 1, server_cron, NULL, NULL);
if ((tmp = variable_retrieve(cfg, "general", "udp_port")) && strcmp(tmp, "")) {
if ((udpsock = net_udp_server(NULL, atoi(tmp), neterr, sizeof neterr)) == -1) {
xcb_log(XCB_LOG_ERROR, "Opening port '%s': %s", tmp, neterr);
goto err;
}
if (net_nonblock(udpsock, neterr, sizeof neterr) == -1) {
xcb_log(XCB_LOG_ERROR, "Setting port '%s' nonblocking: %s", tmp, neterr);
goto err;
}
}
if ((tmp = variable_retrieve(cfg, "general", "tcp_port")) && strcmp(tmp, ""))
if ((tcpsock = net_tcp_server(NULL, atoi(tmp), neterr, sizeof neterr)) == -1) {
xcb_log(XCB_LOG_ERROR, "Opening port '%s': %s", tmp, neterr);
goto err;
}
if (udpsock > 0 && create_file_event(el, udpsock, EVENT_READABLE, read_quote, NULL) == -1) {
xcb_log(XCB_LOG_ERROR, "Unrecoverable error creating udpsock '%d' file event", udpsock);
goto err;
}
if (tcpsock > 0 && create_file_event(el, tcpsock, EVENT_READABLE, tcp_accept_handler, NULL) == -1) {
xcb_log(XCB_LOG_ERROR, "Unrecoverable error creating tcpsock '%d' file event", tcpsock);
goto err;
}
xcb_log(XCB_LOG_NOTICE, "Server dispatcher started");
start_event_loop(el, ALL_EVENTS);
delete_event_loop(el);
pgm_shutdown();
return 0;
err:
close_logger();
exit(1);
}
void zmq::pgm_socket_t::open_transport (void)
{
zmq_log (1, "Opening PGM: network %s, port %i, udp encaps. %s, %s(%i)\n",
network, port_number, udp_encapsulation ? "yes" : "no",
__FILE__, __LINE__);
// Can not open transport before destroying old one.
assert (g_transport == NULL);
// Set actual_tsi and prev_tsi to zeros.
memset (&tsi, '\0', sizeof (pgm_tsi_t));
memset (&retired_tsi, '\0', sizeof (pgm_tsi_t));
// Zero counter used in msgrecv.
nbytes_rec = 0;
nbytes_processed = 0;
pgm_msgv_processed = 0;
// Init PGM transport.
// Note that if you want to use gettimeofday and sleep for openPGM timing,
// set environment variables PGM_TIMER to "GTOD"
// and PGM_SLEEP to "USLEEP".
pgm_init ();
pgm_gsi_t gsi;
int rc = pgm_create_md5_gsi (&gsi);
assert (rc == 0);
struct group_source_req recv_gsr, send_gsr;
gsize recv_len = 1;
rc = pgm_if_parse_transport (network, AF_INET, &recv_gsr,
&recv_len, &send_gsr);
assert (rc == 0);
assert (recv_len == 1);
// If we are using UDP encapsulation update send_gsr & recv_gsr
// structures. Note that send_gsr & recv_gsr has to be updated after
// pgm_if_parse_transport call.
if (udp_encapsulation) {
// Use the same port for UDP encapsulation.
((struct sockaddr_in*)&send_gsr.gsr_group)->sin_port =
g_htons (port_number);
((struct sockaddr_in*)&recv_gsr.gsr_group)->sin_port =
g_htons (port_number);
}
rc = pgm_transport_create (&g_transport, &gsi, 0, port_number, &recv_gsr,
1, &send_gsr);
errno_assert (rc == 0);
// Common parameters for receiver and sender.
// Set maximum transport protocol data unit size (TPDU).
rc = pgm_transport_set_max_tpdu (g_transport, pgm_max_tpdu);
assert (rc == 0);
// Set maximum number of network hops to cross.
rc = pgm_transport_set_hops (g_transport, 16);
assert (rc == 0);
// Receiver transport.
if (receiver) {
// When using UDP-encapsulation enables socket address sharing via
// SO_REUSEADDR to allow multiple applications to bind to the same
// UDP port.
if (udp_encapsulation) {
rc = pgm_transport_set_multicast_loop (g_transport, TRUE);
assert (rc == 0);
}
// Set transport->may_close_on_failure to true,
// after data los recvmsgv returns -1 errno set to ECONNRESET.
rc = pgm_transport_set_close_on_failure (g_transport, TRUE);
assert (rc == 0);
// Set transport->can_send_data = FALSE.
// Note that NAKs are still generated by the transport.
rc = pgm_transport_set_recv_only (g_transport, false);
assert (rc == 0);
// Set NAK transmit back-off interval [us].
rc = pgm_transport_set_nak_bo_ivl (g_transport, 50*1000);
assert (rc ==0);
// Set timeout before repeating NAK [us].
rc = pgm_transport_set_nak_rpt_ivl (g_transport, 200*1000);
assert (rc == 0);
// Set timeout for receiving RDATA.
rc = pgm_transport_set_nak_rdata_ivl (g_transport, 200*1000);
assert (rc == 0);
// Set retries for NAK without NCF/DATA (NAK_DATA_RETRIES).
rc = pgm_transport_set_nak_data_retries (g_transport, 5);
assert (rc == 0);
// Set retries for NCF after NAK (NAK_NCF_RETRIES).
rc = pgm_transport_set_nak_ncf_retries (g_transport, 2);
assert (rc == 0);
// Set timeout for removing a dead peer [us].
rc = pgm_transport_set_peer_expiry (g_transport, 5*8192*1000);
assert (rc == 0);
// Set expiration time of SPM Requests [us].
rc = pgm_transport_set_spmr_expiry (g_transport, 25*1000);
assert (rc == 0);
if (pgm_window_size > 0) {
// Set receive window size in sequence numbers.
rc = pgm_transport_set_rxw_sqns (g_transport, pgm_window_size);
assert (rc == 0);
} else {
// Set the size of the receive window size by max
// data rate in bytes per second.
assert (pgm_max_rte > 0);
rc = pgm_transport_set_rxw_max_rte (g_transport, pgm_max_rte);
assert (rc ==0);
// Set receive window size in seconds.
assert (pgm_secs > 0);
rc = pgm_transport_set_rxw_secs (g_transport, pgm_secs);
assert (rc == 0);
}
// Sender transport.
} else {
// Set transport->can_recv = FALSE, waiting_pipe wont not be read.
rc = pgm_transport_set_send_only (g_transport, TRUE);
assert (rc == 0);
int to_preallocate = 0;
if (pgm_window_size > 0) {
// Set send window size in sequence numbers.
rc = pgm_transport_set_txw_sqns (g_transport, pgm_window_size);
assert (rc == 0);
// Preallocate full window.
to_preallocate = pgm_window_size;
} else {
// Set the size of the send window size by
// data rate in bytes per second.
assert (pgm_max_rte > 0);
rc = pgm_transport_set_txw_max_rte (g_transport, pgm_max_rte);
assert (rc ==0);
// Set send window size in seconds.
assert (pgm_secs > 0);
rc = pgm_transport_set_txw_secs (g_transport, pgm_secs);
assert (rc == 0);
// Preallocate full transmit window. For simplification always
// worst case is used (40 bytes ipv6 header and 20 bytes UDP
// encapsulation).
to_preallocate = pgm_secs * pgm_max_rte / (pgm_max_tpdu - 40 - 20);
}
rc = pgm_transport_set_txw_preallocate (g_transport, to_preallocate);
assert (rc == 0);
zmq_log (1, "Preallocated %i slices in TX window. %s(%i)\n",
to_preallocate, __FILE__, __LINE__);
// Set interval of background SPM packets [us].
rc = pgm_transport_set_ambient_spm (g_transport, 8192 * 1000);
assert (rc == 0);
// Set intervals of data flushing SPM packets [us].
guint spm_heartbeat[] = {4 * 1000, 4 * 1000, 8 * 1000, 16 * 1000,
32 * 1000, 64 * 1000, 128 * 1000, 256 * 1000, 512 * 1000,
1024 * 1000, 2048 * 1000, 4096 * 1000, 8192 * 1000};
rc = pgm_transport_set_heartbeat_spm (g_transport, spm_heartbeat,
G_N_ELEMENTS(spm_heartbeat));
assert (rc == 0);
}
// Bind a transport to the specified network devices.
rc = pgm_transport_bind (g_transport);
assert (rc == 0);
}
int main(int argc, char *argv[]) {
FILE *in = stdin;
FILE *out = stdout;
FILE *sig = NULL;
char output_name[MAXPATHLEN] = "(stdout)";
char input_name[MAXPATHLEN] = "(stdin)";
char signature_name[MAXPATHLEN];
int c;
int row, col;
int n;
double quality = 0.0;
int filter = 0;
int method = -1;
int level = 0;
char filter_name[MAXPATHLEN] = "";
int seed;
int verbose = 0;
gray **image;
Image_tree dwts;
gray maxval;
int rows, cols, colors, format;
progname = argv[0];
pgm_init(&argc, argv);
#ifdef __EMX__
_fsetmode(in, "b");
_fsetmode(out, "b");
#endif
while ((c = getopt(argc, argv, "e:f:F:h?l:o:q:s:v:")) != EOF) {
switch (c) {
case 'e':
method = atoi(optarg);
if (method < 0) {
fprintf(stderr, "%s: wavelet filtering method %d out of range\n", progname, method);
exit(1);
}
break;
case 'f':
filter = atoi(optarg);
if (filter <= 0) {
fprintf(stderr, "%s: filter number %d out of range\n", progname, filter);
exit(1);
}
break;
case 'F':
strcpy(filter_name, optarg);
break;
case 'h':
case '?':
usage();
break;
case 'l':
level = atoi(optarg);
if (level < 1) {
fprintf(stderr, "%s: embedding level out of range\n", progname);
exit(1);
}
break;
case 'o':
if ((out = fopen(optarg, "wb")) == NULL) {
fprintf(stderr, "%s: unable to open output file %s\n", progname, optarg);
exit(1);
}
strcpy(output_name, optarg);
break;
case 'q':
quality = atoi(optarg);
if (quality <= 0) {
fprintf(stderr, "%s: quality factor %d out of range\n", progname, quality);
exit(1);
}
break;
case 's':
if ((sig = fopen(optarg, "r")) == NULL) {
fprintf(stderr, "%s: unable to open signature file %s\n", progname, optarg);
exit(1);
}
strcpy(signature_name, optarg);
break;
case 'v':
verbose = atoi(optarg);
if (verbose < 0) {
fprintf(stderr, "%s: verbosity level %d out of range\n", progname, verbose);
exit(1);
}
break;
}
}
argc -= optind;
argv += optind;
if (argc > 1) {
usage();
exit(1);
}
if (argc == 1 && *argv[0] != '-')
if ((in = fopen(argv[0], "rb")) == NULL) {
fprintf(stderr, "%s: unable to open input file %s\n", progname, argv[0]);
exit(1);
}
else
strcpy(input_name, argv[0]);
if (sig) {
char line[32];
fgets(line, sizeof(line), sig);
if (strspn(line, "KDSG") >= 4) {
fscanf(sig, "%d\n", &n);
if (quality == 0.0)
fscanf(sig, "%lf\n", &quality);
else
fscanf(sig, "%*f\n");
if (method < 0)
fscanf(sig, "%d\n", &method);
else
fscanf(sig, "%*d\n");
if (filter == 0)
fscanf(sig, "%d\n", &filter);
else
fscanf(sig, "%*d\n");
if (!strcmp(filter_name, ""))
fscanf(sig, "%[^\n\r]\n", filter_name);
else
fscanf(sig, "%*[^\n\r]\n");
if (level == 0)
fscanf(sig, "%d\n", &level);
else
fscanf(sig, "%*d\n");
fscanf(sig, "%d\n", &seed);
srandom(seed);
n_signature = NBITSTOBYTES(nbit_signature);
fread(signature, sizeof(char), n_signature, sig);
fscanf(sig, "\n");
}
else {
fprintf(stderr, "%s: invalid signature file %s\n", progname, signature_name);
exit(1);
}
fclose(sig);
}
else {
fprintf(stderr, "%s: signature file not specified, use -s file option\n", progname);
exit(1);
}
pgm_readpgminit(in, &cols, &rows, &maxval, &format);
image = pgm_allocarray(cols, rows);
for (row = 0; row < rows; row++)
pgm_readpgmrow(in, image[row], cols, maxval, format);
fclose(in);
// check watermark dimensions and decomposition level
// decomposition of image
init_dwt(cols, rows, filter_name, filter, level, method);
#ifdef POLLEN_STUFF
{
double alpha, beta;
char *alpha_str = getenv("POLLEN_ALPHA"), *beta_str = getenv("POLLEN_BETA");
if (alpha_str && beta_str) {
alpha = atof(alpha_str);
beta = atof(beta_str);
if (alpha < -M_PI || alpha >= M_PI) {
fprintf(stderr, "%s: pollen - alpha %f out of range\n", progname, alpha);
exit(1);
}
if (beta < -M_PI || beta >= M_PI) {
fprintf(stderr, "%s: pollen - beta %f out of range\n", progname, beta);
exit(1);
}
if (verbose > 7)
fprintf(stderr, "%s: pollen - alpha %f, beta %f\n", progname, alpha, beta);
dwt_pollen_filter(alpha, beta);
}
}
#endif
dwts = fdwt(image);
// create 'image' from binary watermark
// decomposition of watermark
init_dwt(cols, rows, filter_name, filter, 1, method);
// dwts = fdwt(watermark);
// calculate mean value of image and set alpha
// setup of contrast sensitivity matrix
// segment detail images at each level
// calculate DFT of each segment
// compute salience for each segment
// calculate gamma or each detail image
// embed watermark
// reconstruction of watermarked image
idwt(dwts, image);
pgm_writepgminit(out, cols, rows, maxval, 0);
for (row = 0; row < rows; row++)
pgm_writepgmrow(out, image[row], cols, maxval, 0);
fclose(out);
pgm_freearray(image, rows);
exit(0);
}
