#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <getopt.h>

#define TRUE        1
#define FALSE       0
#define WHITE     200
#define BLACK     158
#define WmB        35
#define NOISELEVEL 20

static int syncing    = TRUE;
static int messages   = TRUE;

/*****************************************************************************/
static int noisedetect (unsigned char *buf, int len) {
    int i, nc=0, average=0, av=0;
    average=buf[0];
    for (nc=0, i=1; i<len; i++) {
        int x=buf[i]-buf[i-1];
        if (x<0) x=-x;
        if (x>NOISELEVEL);
            nc++;
        av+=x;
        average+=buf[i];
        }
    average/=i;
    av/=i;
    if (average<80 && av>10 && nc>len/4)
        return 1;
    return 0;
}

/*****************************************************************************/
static int syncpicIR (unsigned char *buf, int len) {
    int i, x;
    for (i=264; i<len; i++) {
        x=262; if (buf[i-x]>BLACK || (buf[i-x+11]-buf[i-x])<WmB) continue;
        x=240; if (buf[i-x]>BLACK || (buf[i-x+11]-buf[i-x])<WmB) continue;
        x=217; if (buf[i-x]>BLACK || (buf[i-x+11]-buf[i-x])<WmB) continue;
        x=195; if (buf[i-x]>BLACK || (buf[i-x+11]-buf[i-x])<WmB) continue;
        x=172; if (buf[i-x]>BLACK || (buf[i-x+11]-buf[i-x])<WmB) continue;
        x=148; if (buf[i-x]>BLACK || (buf[i-x+11]-buf[i-x])<WmB) continue;
        x=128; if (buf[i-x]>BLACK || (buf[i-x+11]-buf[i-x])<WmB) continue;
        x=105; if (buf[i-x]>BLACK || (buf[i-x+11]-buf[i-x])<WmB) continue;
        x= 82; if (buf[i-x]>BLACK || (buf[i-x+11]-buf[i-x])<WmB) continue;
        x= 60; if (buf[i-x]>BLACK || (buf[i-x+11]-buf[i-x])<WmB) continue;
        x= 37; if (buf[i-x]>BLACK || (buf[i-x+11]-buf[i-x])<WmB) continue;
        x= 14; if (buf[i-x]>BLACK || (buf[i-x+11]-buf[i-x])<WmB) continue;
        return i;
        }
    return i;
}

/*****************************************************************************/
static int syncpic   (unsigned char *buf) {
    int x=0, y=0;
    if (!syncing)
        return 0;
    x = syncpicIR(&buf[0],16384);
    if (x<16384) {
        syncing=FALSE;
        if (messages) {fprintf (stderr, "Synced x=%1i, y=%1i\n",x,y);}
        return x;
        }
    if (x>=16384) return 16384;
    if (messages) {fprintf (stderr,"Pokus o sync\n");}
    y = syncpicIR(&buf[y],16384-x);
    if (y<2800 || y>2960)
        return 16384;
    if (messages) {fprintf (stderr, "Synced x=%1i, y=%1i\n",x,y);}
    syncing=FALSE;
    return x+y;
}

/*****************************************************************************/
static void usage (void) {
    fprintf (stderr,"Usage:\n"
       "       -k           - invert picture (satellite pass South -> North)\n"
       "       -r ROWS      - number of rows (default taken from picture)\n"
       "       -n           - noise detect off\n"
       "       -s           - syncing off\n"
       "       -q           - messages off\n");
    exit (1);
}

/*****************************************************************************/
static void FlushPicture (unsigned char *picture, int cols, int rows, int invert) {
    int row, col;
    unsigned char *picpos=picture;
    printf ("P5 %1i %1i 255\n",cols,rows);
    if (messages) {fprintf (stderr,"Picture %1ix%1i\n",cols,rows);}
    if (invert) {
        unsigned char b[1440];
        col=0;
        for (picpos+=cols*rows-1; picpos>=picture; picpos--) {
            b[col]=*picpos;
            if (++col>=cols) {
                fwrite (b,cols,1,stdout);
                col=0;
                }
            }
        }
    if (!invert) {
        for (row=0; row<rows; row++) {
            fwrite (picpos,cols,1,stdout);
            picpos+=cols;
            }
        return;
        }
}

/*****************************************************************************/
static int noisedetectinpic (char *bufpos, int len) {
    static nline=0;
    static cline=0;
    if (noisedetect(bufpos,len)) {
        if (++nline>10) {
            return 1;
            }
       }
    if (++cline > 10) {
        cline=0;
        nline=0;
        }
    return 0;
}

/*****************************************************************************/
int main (int argc, char **argv) {
    int COLS        = 1440;
    int ROWS        = 1800;
    int invert      = FALSE;
    int ndetect     = TRUE;
    int  x=0, i=0, col=0, row=0, u=0, p;
    unsigned char *picture, *picpos, *bufpos;
    unsigned char buf[16384];
    while ( (i=getopt (argc, argv, "r:nskq")) != EOF) {
        switch (i) {
            case 'r': ROWS=atol(optarg);           break;
            case 'n': ndetect=FALSE;               break;
            case 's': syncing=FALSE;               break;
            case 'k': invert=TRUE;                 break;
            case 'q': messages=FALSE;              break;
            default:  usage();                     break;
            }
        }
    picture = (unsigned char *) malloc (COLS*(ROWS+1));
    picpos  = picture;
    /***********************/
    while ( 0 < (p=read (0, buf, 2880)) ) {
        u+=2800;
        row++; 
        if (!noisedetect(buf,p))
            break;
        }
    if (p<=0) {
        fprintf (stderr,"There is no signal in the data!\n");
        return 1;
        }
    if (messages) {fprintf (stderr,"Signal appeared, row=%1i (offset=%1i).\n",u/2801,u);}
    /***********************/
    u=0, row=0;
    while ( 0 < (p=read (0, buf, 16384)) ) {
        for (i=syncpic(buf), bufpos=buf+i; i<p; i++, u++, bufpos++) {
            x+=*bufpos;
            if (!(u%2)) {
                int sum=x/2;
                x=0;
                *picpos++=sum;
                if (++col==COLS) {
                    col=0; row++; 
                    i++; bufpos++;
                    if (sum>128) {i++; bufpos++;}
                    if (i<13500 && row>200 && ndetect && noisedetectinpic(bufpos,720)) {
                        if (messages) {fprintf (stderr,"Noise detected. Row=%1i\n",row);}
                        goto TheEnd;
                        }
                    }
                if (row>=ROWS) {
                    goto TheEnd;
                    }
                }
            }
        }
    /***********************/
    if (messages) {fprintf (stderr,"\nUnexpected end of file. Row=%1i\n",row);}
TheEnd:
    FlushPicture (picture, COLS, row, invert);
    free (picture);
    return 0;
}