// How button press/release events are handled:
//
// button -> interrupt -> input_append_code() -> inputq -> hijack_handle_button() -> playerq -> real_input_append_code()
//
// hijack.c::input_append_code() performs raw IR translations
// hijack.c::inputq[] holds translated buttons with timing information queued for hijack to examine
// hijack.c::hijack_handle_button() interprets buttons for hijack/menu functions
// hijack.c::playerq[] holds translated buttons with timing information queued for the Empeg player software
// empeg_input.c::real_input_append_code() feeds buttons to userland
//

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

static void sendButton (int fd, const char *st)
{
        int ret = write(fd, st, strlen(st));
        if (ret != strlen(st)) {
                fprintf(stderr, "write() returned %d instead of %d\n", ret, strlen(st));
                exit(-1);
        }
}

int main(int argc, char *argv[])
{
        char st[64];
        int fd;

        if (argc != 2) {
                fprintf(stderr, "Error: expected button name/value as only parameter\n");
                exit(-1);
        }

        fd = open("/proc/empeg_notify",O_RDWR);
        if (fd < 0) {
                perror("Failed to open /proc/empeg_notify for RDWR\n");
                exit(1);
        }
        sprintf(st, "BUTTONRAW=%s", argv[1]);
        sendButton(fd, st);
        usleep(250000);
        strcat(st, ".R");
        sendButton(fd, st);
        return 0;
}

// broadcastfb.c 
//
// Hiijack kernel adds /proc/empeg_screen.raw file.   Try reading this instead
//
// Verson 3.1
// Jonathan Andrews      ( j o n @ j o n s h o u s e . c o . u k )
//
// Last Changed 28 Jun 2013
//
// Always seems to send 38 frames per second, I think the empeg display is refreshed faster
// but its tricky to find a way to read it without corruption.
//
// Version 2 adds support for remote button presses via UDP port.
//
// Version 3 adds support for messages in the form 0x12345678, these are key press or
// consumer IR 4 byte (long int) represented as hex.
// These messages are sent to /proc/empeg_ir to proxy infra-red sequences or just button
// push/release events
//

#define PORT    4040
#define RXPORT  5050
#define DEST_ADDR "255.255.255.255"

unsigned char fbdata[32*64];                                            // 32 Rows of 64 Bytes = 2048 Bytes (2K)
#define TRUE 1
#define FALSE 0

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <sys/resource.h>
#include <errno.h>
// sockets related
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
int sockfd;
int rxsockfd;
int proc_buttonfd;
int proc_irfd;


#include <sched.h>
void set_realtime(void)
{
        struct sched_param sparam;
        sparam.sched_priority = sched_get_priority_max(SCHED_RR);
        sched_setscheduler(0, SCHED_FIFO, &sparam);
}


// Received UDP packet.
unsigned char ubuffer[512];

int main(int argc, char *argv[])
{
  struct sockaddr_in sendaddr;
  struct sockaddr_in recvaddr;
  int numbytes;
  int broadcast=1;
  int allon;
  int allblack;
  int limit;
  int flags;
  int j,i,fd;
  int res;
  caddr_t dmap;
  int addr_len;
  long ircode=0;
  char st[1024];


  set_realtime();                                                                       // Marking as realtime gives more FPS but some clashing with player
  // nice myself to higher priority
  setpriority(PRIO_PROCESS,0,-20);                                                      // Give this process a CPU boost, same nice as pulse


  // Setup receiving UDP socket
  if((rxsockfd = socket(PF_INET,SOCK_DGRAM,0)) == -1)
  {
        perror("rx sockfd");
        exit(1);
  }
  // Setuop socket, specify listening interfaces etc
  recvaddr.sin_family = AF_INET;
  recvaddr.sin_port = htons(RXPORT);
  recvaddr.sin_addr.s_addr = INADDR_ANY;
  memset(recvaddr.sin_zero,'\0',sizeof (recvaddr.sin_zero));
 
  // Put socket in non blcoking mode
  flags = fcntl(rxsockfd, F_GETFL);                                          // Get the sockets flags
  flags |= O_NONBLOCK;                                                            // Set NONBLOCK flag
  if (fcntl(rxsockfd, F_SETFL, flags) == -1)                                     // Write flags back
  {
        perror("error,fcnctl failed - could not set socket to nonblocking");
        exit(1);
  }
  if(bind(rxsockfd, (struct sockaddr*) &recvaddr, sizeof recvaddr) == -1)
  {
        perror("bind");
        exit(1);
  }

  printf("Listening on UDP port %d\n",RXPORT);  
  fflush(stdout);

  // Setup sending UDP socket
  if((sockfd = socket(PF_INET,SOCK_DGRAM,0)) == -1)
  {
        perror("sockfd");
        exit(1);
  }
  if((setsockopt(sockfd,SOL_SOCKET,SO_BROADCAST,&broadcast,sizeof broadcast)) == -1)
  {
        perror("setsockopt - SO_SOCKET ");
        exit(1);
  }
  sendaddr.sin_family = AF_INET;
  sendaddr.sin_port = htons(PORT);
  sendaddr.sin_addr.s_addr = inet_addr(DEST_ADDR);
  memset(sendaddr.sin_zero,'\0',sizeof(sendaddr.sin_zero));
  printf("Sending packets on UDP port %d\n",PORT);  
  fflush(stdout);


  // Open hijack kernel version of framebuffer
  fd = open("/proc/empeg_screen.raw", O_RDWR);
  if (fd == -1)
       perror("open /proc/empeg_screen.raw failed");


  // Open /proc/empeg_notify so we can push button presses into it
  proc_buttonfd=open("/proc/empeg_notify",O_RDWR);
  if (proc_buttonfd < 2)
  {
        perror("Failed to open /proc/empeg_notify for RDWR\n");
        exit(1);
  }


  //proc_irfd=open("/proc/empeg_ir",O_WRONLY);
  //if (proc_irfd < 2)
  //{
        //perror("Failed to open /proc/empeg_ir\n");
        //exit(1);
  //}


  while (1)
  {
if (0) {
        lseek(fd,0,SEEK_SET);
        read(fd,fbdata,sizeof(fbdata));                                                         // Read data from framebuffer

        numbytes = sendto(sockfd, &fbdata, sizeof(fbdata), 0, (struct sockaddr *)&sendaddr, sizeof(sendaddr));
        //numbytes = sendto(sockfd, dmap, 2048, 0, (struct sockaddr *)&sendaddr, sizeof(sendaddr));     // direct from FB data
        if (numbytes<=0)
        {
                perror("sendto error");
                exit(1);
        }
        else
        {
                //printf("Sent %d bytes\n",numbytes);
                //fflush(stdout);
        }

        // Receive text and send it to empeg player to process.
        addr_len=sizeof(recvaddr);
        numbytes = recvfrom (rxsockfd, (char*)ubuffer, sizeof(ubuffer)-2, 0, (struct sockaddr *) &recvaddr, &addr_len);
        ubuffer[numbytes]=0;                                                                    // terminate actual string
        ubuffer[sizeof(ubuffer)-1]=0;                                                           // ensure buffer is always 0 terminated
} else {
        sleep(5);
        strcpy(ubuffer, "0x0020DF11");
        numbytes = strlen(ubuffer);
}
        if (numbytes > 0)
        {
                printf("Got %d bytes from receiving UDP socket [%s]\n",numbytes,ubuffer);
                fflush(stdout);

                // If message starts 0x and is 0x12345678 long then its an IR code
                if ( (ubuffer[0]=='0') & (ubuffer[1]=='x') )
                {
                        if (strlen(ubuffer)==10)                                                // sequence is 0x12345678
                        {
                                sprintf(st,"BUTTONRAW=%s",ubuffer);
                                res=write(proc_buttonfd,st,strlen(st));                         // write text to /proc/empeg_notify file 
                                printf("sent %s, result %d\n",st,res);
                                fflush(stdout);

                                usleep(250000);
                                strcat(st,".R");
                                res=write(proc_buttonfd,st,strlen(st));                         // write text to /proc/empeg_notify file 
                                printf("sent %s, result %d\n",st,res);
                                fflush(stdout);
                        }
                }
                else
                        write(proc_buttonfd,ubuffer,strlen(ubuffer));                           // write text to /proc/empeg_notify file 
        }
        usleep(5000);                                                                           // works well, 38 frames/second
  }
  close(fd);
}