cinelerra/tunerserver.C

   1 #include <arpa/inet.h>
   2 #include "devicedvbinput.inc"
   3 #include <errno.h>
   4 #include <netdb.h>
   5 #include <netinet/in.h>
   6 #include <sys/socket.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include "renderfarm.inc"
  10 #include "renderfarmclient.h"
  11 #include "tunerserver.h"
  12 #include <unistd.h>
  13
  14
  15
  16
  17 TunerServer::TunerServer(RenderFarmClientThread *client)
  18 {
  19         this->client = client;
  20         device_number = 0;
  21         port = 0;
  22         audio_pid = 0;
  23         video_pid = 0;
  24         channel = 0;
  25         table = 0;
  26         is_busy = 0;
  27         temp = 0;
  28         temp_allocated = 0;
  29         connection_closed = 0;
  30 }
  31
  32
  33 TunerServer::~TunerServer()
  34 {
  35         delete [] temp;
  36 }
  37
  38
  39
  40 void TunerServer::main_loop()
  41 {
  42         int error = 0;
  43
  44 // Send status
  45         if(is_busy)
  46         {
  47                 error = client->write_int64(1);
  48                 return;
  49         }
  50         else
  51         {
  52                 error = client->write_int64(0);
  53         }
  54
  55         is_busy = 1;
  56         while(!error)
  57         {
  58                 error = 0;
  59
  60
  61
  62                 int64_t command = client->read_int64(&error);
  63
  64
  65
  66
  67 // Assume read error was connection closing.
  68                 if(error) break;
  69
  70 //printf("TunerServerThread::run 1 command=%d\n", command);
  71
  72                 switch(command)
  73                 {
  74                         case NETTUNE_SIGNAL:
  75                         {
  76                                 int current_power = 0;
  77                                 int current_lock = 0;
  78                                 error = get_signal_strength(&current_power, &current_lock);
  79                                 error = client->write_int64(error);
  80                                 if(!error)
  81                                         error = client->write_int64(current_power);
  82                                 if(!error)
  83                                         error = client->write_int64(current_lock);
  84                                 break;
  85                         }
  86
  87                         case NETTUNE_SET_TABLE:
  88                                 table = client->read_int64(&error);
  89                                 break;
  90
  91                         case NETTUNE_SET_CHANNEL:
  92                                 channel = client->read_int64(&error);
  93                                 break;
  94
  95                         case NETTUNE_SET_AUDIO_PID:
  96                                 audio_pid = client->read_int64(&error);
  97                                 break;
  98
  99                         case NETTUNE_SET_VIDEO_PID:
 100                                 video_pid = client->read_int64(&error);
 101                                 break;
 102
 103                         case NETTUNE_READ:
 104                         {
 105 // Get requested size
 106                                 int size = client->read_int64(&error);
 107                                 if(temp_allocated < size)
 108                                 {
 109                                         delete [] temp;
 110                                         temp = new unsigned char[size];
 111                                         temp_allocated = size;
 112                                 }
 113
 114 // Get number of bytes read and buffer
 115                                 int bytes_read = read_data(temp, size);
 116                                 error = client->write_int64(bytes_read);
 117                                 if(!error)
 118                                         error = client->write_socket((char*)temp, bytes_read);
 119                                 break;
 120                         }
 121
 122                         case NETTUNE_OPEN:
 123                         {
 124                                 printf("TunerServerThread::run audio_pid=0x%x video_pid=0x%x table=%d channel=%d\n",
 125                                         audio_pid,
 126                                         video_pid,
 127                                         table,
 128                                         channel);
 129                                 error = open_tuner();
 130                                 error = client->write_int64(error);
 131                                 break;
 132                         }
 133
 134
 135                         case NETTUNE_CLOSE:
 136                                 error = 1;
 137                                 break;
 138                 }
 139         }
 140
 141         printf("TunerServerThread::run: connection closed\n");
 142
 143         close_tuner();
 144         is_busy = 0;
 145 }
 146
 147 int TunerServer::get_channel()
 148 {
 149         return channel;
 150 }
 151
 152 int TunerServer::get_table()
 153 {
 154         return table;
 155 }
 156
 157 int TunerServer::get_audio_pid()
 158 {
 159         return audio_pid;
 160 }
 161
 162 int TunerServer::get_video_pid()
 163 {
 164         return video_pid;
 165 }
 166
 167 int TunerServer::get_device_number()
 168 {
 169         return device_number;
 170 }
 171
 172
 173 int TunerServer::open_tuner()
 174 {
 175         return 1;
 176 }
 177
 178 int TunerServer::close_tuner()
 179 {
 180         return 1;
 181 }
 182
 183
 184 int TunerServer::get_signal_strength(int *current_power, int *current_lock)
 185 {
 186         return 1;
 187 }
 188
 189 int TunerServer::read_data(unsigned char *data, int size)
 190 {
 191         return 0;
 192 }
 193
 194
 195
 196