#define _LARGEFILE64_SOURCE
#define _LARGEFILE_SOURCE
#include <fcntl.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

#include <string>
#include <vector>

#define RATE 48000

#define XSIZE 256
#define YSIZE 240
//#define XSIZE 240
//#define YSIZE 160

#define CHANNELS  1

#define PICS_PER_LINE 2

#define PIXBYTES 3

#define FRAMESKIP 1

#define LASTFRAME 0x7FFFFFFF
//#define LASTFRAME 120

static FILE* Nfopen(const char* fn, const char* mode)
{
    unsigned BufSize = 1024*1024*2;
    int mask = O_RDONLY;
    int fd;
    FILE* fp;
    char* Buf = (char*)malloc(BufSize);
    
    if(*mode == 'r') mask = O_RDONLY;
    if(*mode == 'w') mask = O_WRONLY | O_TRUNC | O_CREAT;
    fd = open(fn, mask | O_LARGEFILE, 0644);
    fp = fdopen(fd, mode);
    
    setbuffer(fp, Buf, BufSize);
    
    return fp;
}

typedef struct { char Buf[XSIZE*YSIZE*PIXBYTES]; } frame;

int main(int argc, char **argv)
{
    --argc;
    
    if(argc != 5)
    {
        fprintf(stderr,
            "Usage: sidebyside NUMBER video%%d.raw audio%%d.raw VIDEO_OUT AUDIO_OUT\n"
            "Where %%d will be automatically substituted by stream number (1-N)\n");
        return -1;
    }
    
    unsigned N = atoi(argv[1]);
    std::string Vpat = argv[2];
    std::string Apat = argv[3];
    std::string Vout = argv[4];
    std::string Aout = argv[5];
    
    std::vector<FILE*> vin(N);
    std::vector<FILE*> ain(N);
    
    /*
    
    sidebyside 2 video%.raw audio%.raw video.raw audio.raw
    
     */
    
    const unsigned Lines = (N + PICS_PER_LINE-1) / PICS_PER_LINE;
     
    FILE* aout = Nfopen(Aout.c_str(), "wb");

    for(unsigned a=0; a<N; ++a)
    {
        char Buf[4096];
        snprintf(Buf, sizeof(Buf), Vpat.c_str(), a+1);
        vin[a] = Nfopen(Buf, "rb");

        snprintf(Buf, sizeof(Buf), Apat.c_str(), a+1);
        ain[a] = Nfopen(Buf, "rb");
    }
    
#if 1
    FILE* vout = Nfopen(Vout.c_str(), "wb");
    
    unsigned videoframeno=0;
    for(;;)
    {
        static unsigned line_counter = 0;
        if(line_counter != 0)
        {
            for(unsigned a=0; a<N; ++a)
                fseek(vin[a], sizeof(frame), SEEK_CUR);
            goto FrameDone;
        }
        
       /**/{/**/

        std::vector<frame> Bufs(N);
        static const unsigned char zerobuf[XSIZE*PIXBYTES] = {0};
        
        bool non_eof = false;
        for(unsigned a=0; a<N; ++a)
        {
            if(a==0 && videoframeno < 0) continue;
            fread(Bufs[a].Buf, 1, sizeof(frame), vin[a]);
            if(!feof(vin[a])) non_eof = true;
        }
        if(!non_eof) break;
        
        for(unsigned line=0; line<Lines; ++line)
        {
#if PICS_PER_LINE == 1
            fwrite(Bufs[line].Buf, 1, sizeof(frame), vout);
#else
            for(unsigned y=0; y<YSIZE; ++y)
            {
                for(unsigned column=0; column<PICS_PER_LINE; ++column)
                {
                    const unsigned objnum = line * PICS_PER_LINE + column;
                    if(objnum < N)
                        fwrite(Bufs[objnum].Buf + y*XSIZE*PIXBYTES, 1, XSIZE*PIXBYTES, vout);
                    else
                        fwrite(zerobuf, 1, XSIZE*PIXBYTES, vout);
                }
            }
#endif
        }
        
        ++videoframeno;
        
        #ifdef LASTFRAME
        if(videoframeno >= LASTFRAME) break;
        #endif

       /**/}/**/

    FrameDone:
        if(FRAMESKIP) line_counter = (line_counter+1)%FRAMESKIP;
    }

    for(unsigned a=0; a<N; ++a)
        fclose(vin[a]);
    fclose(vout);

#endif

    /**/
    /* Introduce a bit of drift in each channel */
    for(unsigned a=0; a<N; ++a)
        fseek(ain[a], 2*CHANNELS*(a*3), SEEK_CUR);
    /**/

    unsigned audioframeno=0;
    for(;;)
    {
        std::vector<short> Bufs(N*CHANNELS);

        bool non_eof = false;
        for(unsigned a=0; a<N; ++a)
        {
            if(a == 0 && audioframeno < 0*RATE/60) continue;
            fread(&Bufs[a*CHANNELS], 2, CHANNELS, ain[a]);
            if(!feof(ain[a])) non_eof = true;
        }
        if(!non_eof) break;
        
        short left=0, right=0;
        
#if CHANNELS == 2
        /*left  = Buf1[0] + Buf2[0];
        right = Buf1[1] + Buf2[1];*/
        
        for(unsigned a=0; a<N; ++a)
        {
            // rightness, leftness are -1..1
            double rightness = (int)(a*2 - N) / (double)N;
            double leftness  = -rightness;
            
            if(leftness > 0.0 && leftness < 0.3) leftness = 0.3;
            if(leftness <= 0.0 && leftness > -0.3) leftness = -0.3;
            if(rightness > 0.0 && rightness < 0.3) rightness = 0.3;
            if(rightness <= 0.0 && rightness > -0.3) rightness = -0.3;
            
            //lefts
            left  += Bufs[a*2+0] * std::max(-0.5, leftness);
            right += Bufs[a*2+0] * std::max(-0.5, rightness * 0.3);

            //rights
            left  += Bufs[a*2+1] * std::max(-0.5, leftness  * 0.3);
            right += Bufs[a*2+1] * std::max(-0.5, rightness);
        }
#else
        for(unsigned a=0; a<N; ++a)
        {
            // For N=1: -1
            // For N=2: -1, 1
            // For N=3, -1, 0, 1
        
            // rightness, leftness are -1..1
            double rightness = (int)(a*2 - (N-1)) / (double)(N-1);
            double leftness  = -rightness;
            
            if(leftness > 0.0 && leftness < 0.3) leftness = 0.3;
            if(leftness <= 0.0 && leftness > -0.3) leftness = -0.3;
            if(rightness > 0.0 && rightness < 0.3) rightness = 0.3;
            if(rightness <= 0.0 && rightness > -0.3) rightness = -0.3;
            
            left  += Bufs[a] * std::max(-0.5, leftness);
            right += Bufs[a] * std::max(-0.5, rightness);
        }
#endif
        
        fwrite(&left,  2, 1, aout);
        fwrite(&right, 2, 1, aout);
        
        ++audioframeno;

        #ifdef LASTFRAME
        if(audioframeno/(RATE/60) >= LASTFRAME) break;
        #endif
    }

    for(unsigned a=0; a<N; ++a)
        fclose(ain[a]);
    fclose(aout);
    return 0;
}