cinelerra-5.1/cinelerra/devicedvbinput.C

   1 // jam job dvb file testing
   2 //  1) define TEST_DATA as mpeg ts file "name.ts"
   3 //  2) mod record.C Record::resync(), comment out: record_channel->drain_audio()
   4 //  3) enable audio delay in audioidevice.C  AudioDevice::run_input, #if 0 <-> #if 1
   5 //#define TEST_DATA "/tmp/xx.ts"
   6
   7 /*
   8  * CINELERRA
   9  * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24  *
  25  */
  26
  27 #ifdef HAVE_DVB
  28 #include "chantables.h"
  29 #include "devicedvbinput.h"
  30 #include "devicempeginput.h"
  31 #include "recordconfig.h"
  32 #include "signalstatus.h"
  33
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <stdint.h>
  37 #include <unistd.h>
  38 #include <string.h>
  39 #include <errno.h>
  40 #include <fcntl.h>
  41 #include <linux/dvb/dmx.h>
  42 #include <linux/dvb/frontend.h>
  43 #include <sys/ioctl.h>
  44
  45
  46 DVBInputStatus::DVBInputStatus(DeviceDVBInput *dvb_input)
  47  : Thread(1, 0, 0)
  48 {
  49         this->dvb_input = dvb_input;
  50         signal_status = 0;
  51         done = 1;
  52 }
  53
  54 DVBInputStatus::~DVBInputStatus()
  55 {
  56         stop();
  57         if( signal_status ) signal_status->disconnect();
  58 }
  59
  60 void DVBInputStatus::stop()
  61 {
  62         if( done ) return;
  63         done = 1;
  64         Thread::cancel();
  65         Thread::join();
  66 }
  67
  68 void DVBInputStatus::start()
  69 {
  70         if( !done ) return;
  71         done = 0;
  72         Thread::start();
  73 }
  74
  75 void DVBInputStatus::lock_dvb()
  76 {
  77         Thread::disable_cancel();
  78         dvb_input->dvb_lock->lock("DVBInputStatus::lock_dvb");
  79 }
  80
  81 void DVBInputStatus::unlock_dvb()
  82 {
  83         dvb_input->dvb_lock->unlock();
  84         Thread::enable_cancel();
  85 }
  86
  87 void DVBInputStatus::run()
  88 {
  89         lock_dvb();
  90
  91         while( !done ) {
  92                 dvb_input->status_dev();
  93                 update();
  94                 unlock_dvb();
  95                 usleep(250000);
  96                 lock_dvb();
  97         }
  98
  99         unlock_dvb();
 100 }
 101
 102 void DVBInputStatus::update()
 103 {
 104         if( !signal_status ) return;
 105         signal_status->lock_window("DVBInputStatus::update");
 106         signal_status->update();
 107         signal_status->unlock_window();
 108 }
 109
 110
 111 DeviceDVBInput::DeviceDVBInput(const char *name, int no)
 112  : DeviceMPEGInput(name, no)
 113 {
 114         frontend_fd = -1;
 115         demux_fd = -1;
 116         dvb_fd = -1;
 117         reset_signal();
 118         dvb_locked = 0;
 119         dvb_lock = new Mutex("DeviceDVBInput::dvb_lock", 0);
 120         sprintf(frontend_path, "%s/frontend%d", name, no);
 121         sprintf(demux_path, "%s/demux%d", name, no);
 122         sprintf(dvb_path, "%s/dvr%d", name, no);
 123         dvb_input_status = new DVBInputStatus(this);
 124 }
 125
 126 DeviceMPEGInput *DeviceDVBInput::
 127 NewDVBInput(const char *name, int no)
 128 {
 129         return (DeviceMPEGInput *) new DeviceDVBInput(name, no);
 130 }
 131
 132 DeviceDVBInput::~DeviceDVBInput()
 133 {
 134         close_dev();
 135         delete dvb_input_status;
 136         delete dvb_lock;
 137         dvb_close(1);
 138 }
 139
 140
 141 DeviceMPEGInput* DeviceDVBInput::get_mpeg_input(VideoDevice *device)
 142 {
 143         DeviceMPEGInput* mpeg_device = get_mpeg_video(device, NewDVBInput,
 144                 device->in_config->dvb_in_adapter, device->in_config->dvb_in_device);
 145         if( !mpeg_device ) return 0;
 146         device->channel->has_subchan = 1;
 147         device->channel->has_scanning = 1;
 148         device->channel->use_frequency = 1;
 149         mpeg_device->set_device_number(0);
 150         Channel *input_src = device->new_input_source((char*)"input0");
 151         input_src->device_index = 0;
 152         input_src->tuner = 0;
 153         return mpeg_device;
 154 }
 155
 156 DeviceMPEGInput* DeviceDVBInput::get_mpeg_input(AudioDevice *device)
 157 {
 158         return get_mpeg_audio(device, NewDVBInput,
 159                 device->in_config->dvb_in_adapter, device->in_config->dvb_in_device);
 160 }
 161
 162
 163 int DeviceDVBInput::wait_signal(int ms, int trys)
 164 {
 165         Timer timer;
 166         for( int retry=trys; --retry>=0; ) {
 167                 timer.update();
 168                 if( !dvb_status() && has_signal() ) break;
 169                 int dt = ms - timer.get_difference();
 170                 if( dt > 0 ) Timer::delay(dt);
 171         }
 172         return has_signal() ? 0 : 1;
 173 }
 174
 175
 176 int DeviceDVBBuffer::read(int retries, int usec, int bsz)
 177 {
 178         while( --retries >= 0 ) {
 179                 struct timeval tv;  tv.tv_sec = 0;  tv.tv_usec = usec;
 180                 fd_set rd_fd;  FD_ZERO(&rd_fd);  FD_SET(fd, &rd_fd);
 181                 fd_set er_fd;  FD_ZERO(&er_fd);  FD_SET(fd, &er_fd);
 182                 int ret = select(fd+1, &rd_fd, 0, &er_fd, &tv);
 183                 if( ret < 0 ) break;
 184                 if( !ret ) continue;
 185                 if( !FD_ISSET(fd, &er_fd) ) {
 186                         select(0, 0, 0, 0, &tv);
 187                         continue;
 188                 }
 189                 if( !FD_ISSET(fd, &rd_fd) ) continue;
 190                 if( (ret=::read(fd, bfr, bsz)) > 0 )
 191                         return sz = ret;
 192         }
 193         return -1;
 194 }
 195
 196 int DeviceDVBInput::dvb_sync()
 197 {
 198         const int SYNC = 0x47, TS_BLKSZ = 188;
 199         const int BSZ = 100*TS_BLKSZ, XSZ = BSZ*5;
 200         DeviceDVBBuffer data(dvb_fd, BSZ);
 201
 202         int nsync = 0, xfr = 0;
 203         while( xfr < XSZ ) {
 204                 if( data.read(5, 200000, BSZ) < 0 ) break;
 205                 int ofs = 0;
 206                 while( ofs < data.size() ) {
 207                         nsync = 0;
 208                         int i = ofs;
 209                         while( i<data.size() && data[i]!=SYNC ) ++i;
 210                         if( i >= data.size() ) break;
 211                         ofs = i;
 212                         while( (ofs+=TS_BLKSZ)<data.size() && data[ofs]==SYNC ) {
 213                                 ++nsync;  i = ofs;
 214                         }
 215                 }
 216                 if( nsync >= 32 && (ofs-=data.size()) >= 0 ) {
 217                         while( ofs > 0 ) {
 218                                 if( data.read(5, 200000, ofs) < 0 ) return 1;
 219                                 ofs -= data.size();
 220                         }
 221                         return 0;
 222                 }
 223                 xfr += data.size();
 224         }
 225         return 1;
 226 }
 227
 228 // Return values: 0 = OK, 1 = unreported error, 2 = error reported to stderr
 229 int DeviceDVBInput::dvb_open()
 230 {
 231         int ret = 0;
 232 #ifndef TEST_DATA
 233 #ifdef HAVE_DVB
 234         if( frontend_fd < 0 &&
 235            (frontend_fd = ::open(frontend_path, O_RDWR)) < 0 ) {
 236                 fprintf(stderr, "DeviceDVBInput::dvb_open %s: %s\n",
 237                         frontend_path, strerror(errno));
 238                 ret = 2;
 239         }
 240         if( !ret && ioctl(frontend_fd, FE_GET_INFO, &fe_info) < 0 ) {
 241                 fprintf(stderr,
 242                         "DeviceDVBInput::dvb_open FE_GET_INFO: %s\n",
 243                         strerror(errno));
 244                 ret = 2;
 245         }
 246
 247         pwr_min = snr_min = 0;
 248         pwr_max = snr_max = 65535;
 249
 250 // Set frequency
 251         int index = -1, table = -1;
 252         if( !ret && (index = get_channel()) < 0 ) ret = 1;
 253         if( !ret && (table = get_channel_table()) < 0 ) ret = 1;
 254         if( !ret && table >= CHANLIST_SIZE ) ret = 1;
 255
 256         struct dvb_frontend_parameters frontend_param;
 257         if( !ret ) {
 258                 uint32_t frequency = chanlists[table].list[index].freq * 1000;
 259                 if( frequency < fe_info.frequency_min ||
 260                         frequency > fe_info.frequency_max )  {
 261                         fprintf(stderr,
 262                                 "DeviceDVBInput::dvb_open channel %s frequency %d out of range %d-%d\n",
 263                                 chanlists[table].list[index].name, frequency, fe_info.frequency_min, fe_info.frequency_max);
 264                          ret = 2;
 265                 }
 266                 memset(&frontend_param, 0, sizeof(frontend_param));
 267                 frontend_param.frequency = frequency;
 268         }
 269         if( !ret ) {
 270                 switch( table ) {
 271                 case NTSC_DVB:
 272                 case NTSC_BCAST:
 273                 case NTSC_HRC:
 274                 case NTSC_BCAST_JP:
 275                         frontend_param.u.vsb.modulation = VSB_8;
 276                         break;
 277                 case PAL_EUROPE:
 278                 case PAL_E_EUROPE:
 279                 case PAL_ITALY:
 280                 case PAL_NEWZEALAND:
 281                 case PAL_AUSTRALIA:
 282                 case PAL_IRELAND:
 283                 case CATV_DVB:
 284                 case NTSC_CABLE:
 285                 case NTSC_CABLE_JP:
 286                         frontend_param.u.vsb.modulation = QAM_AUTO;
 287                         break;
 288                 default:
 289                         fprintf(stderr,
 290                                 "DeviceDVBInput::dvb_open bad table index=%d\n", table);
 291                         ret = 2;
 292                         break;
 293                 }
 294         }
 295
 296         if( !ret && ioctl(frontend_fd, FE_SET_FRONTEND, &frontend_param) < 0 ) {
 297                 fprintf(stderr,
 298                         "DeviceDVBInput::dvb_open FE_SET_FRONTEND frequency=%d: %s\n",
 299                         frontend_param.frequency, strerror(errno));
 300                 ret = 2;
 301         }
 302
 303         if( !ret && wait_signal(333,3) ) {
 304                 fprintf(stderr,
 305                          "DeviceDVBInput::dvb_open: no signal, index=%d, channel %s, frequency=%d\n",
 306                         index, chanlists[table].list[index].name, frontend_param.frequency);
 307                 ret = 2;
 308         }
 309
 310         if( !ret && ioctl(frontend_fd, FE_GET_FRONTEND, &frontend_param) ) {
 311                 fprintf(stderr,
 312                         "DeviceDVBInput::dvb_open FE_GET_FRONTEND: %s\n",
 313                         strerror(errno));
 314                 ret = 2;
 315         }
 316         if( !ret ) { // goofy quirks
 317                 if( !strcmp("Samsung S5H1409 QAM/8VSB Frontend", fe_info.name) ) {
 318                         switch(frontend_param.u.vsb.modulation) {
 319                         case QAM_64:  snr_min = 200;  snr_max = 300;  break;
 320                         case QAM_256: snr_min = 260;  snr_max = 400;  break;
 321                         case VSB_8:   snr_min = 111;  snr_max = 300;  break;
 322                         default: break;
 323                         }
 324                         pwr_min = snr_min;  pwr_max = snr_max;
 325                 }
 326                 else if( !strcmp("Auvitek AU8522 QAM/8VSB Frontend", fe_info.name) ) {
 327                         switch(frontend_param.u.vsb.modulation) {
 328                         case QAM_64:  snr_min = 190;  snr_max = 290;  break;
 329                         case QAM_256: snr_min = 280;  snr_max = 400;  break;
 330                         case VSB_8:   snr_min = 115;  snr_max = 270;  break;
 331                         default: break;
 332                         }
 333                         pwr_min = snr_min;  pwr_max = snr_max;
 334                 }
 335         }
 336
 337         if( !ret && (demux_fd = ::open(demux_path, O_RDWR)) < 0 ) {
 338                 fprintf(stderr,
 339                         "DeviceDVBInput::dvb_open %s for video: %s\n",
 340                         demux_path,
 341                         strerror(errno));
 342                 ret = 2;
 343         }
 344
 345 // Setting exactly one PES filter to 0x2000 dumps the entire
 346 // transport stream.
 347         if( !ret ) {
 348                 struct dmx_pes_filter_params pesfilter;
 349                 memset(&pesfilter,0,sizeof(pesfilter));
 350                 pesfilter.pid = 0x2000;
 351                 pesfilter.input = DMX_IN_FRONTEND;
 352                 pesfilter.output = DMX_OUT_TS_TAP;
 353                 pesfilter.pes_type = DMX_PES_OTHER;
 354                 pesfilter.flags = DMX_IMMEDIATE_START;
 355                 if( ioctl(demux_fd, DMX_SET_PES_FILTER, &pesfilter) < 0 ) {
 356                         fprintf(stderr,
 357                 "DeviceDVBInput::dvb_open DMX_SET_PES_FILTER for raw: %s\n",
 358                                 strerror(errno));
 359                         ret = 1;
 360                 }
 361         }
 362 // Open transport stream for reading
 363         if( !ret && (dvb_fd = ::open(dvb_path, O_RDONLY+O_NONBLOCK)) < 0 ) {
 364                 fprintf(stderr, "DeviceDVBInput::dvb_open %s: %s\n",
 365                         dvb_path, strerror(errno));
 366                 ret = 1;
 367         }
 368 #else
 369         dvb_fd = -1;
 370         ret = 1;
 371 #endif
 372 #else
 373         dvb_fd = open(TEST_DATA,O_RDONLY);
 374         if( dvb_fd < 0 ) ret = 1;
 375 #endif
 376         reset_signal();
 377         dvb_locked = 0;
 378         if( !ret ) ret = dvb_sync();
 379         if( !ret ) ret = dvb_status();
 380         if( ret ) dvb_close();
 381         return ret;
 382 }
 383
 384
 385 void DeviceDVBInput::dvb_close(int fe)
 386 {
 387         if( dvb_fd >= 0 ) { ::close(dvb_fd); dvb_fd = -1; }
 388         if( demux_fd >= 0 ) { ::close(demux_fd); demux_fd = -1; }
 389         if( fe && frontend_fd >= 0 ) { ::close(frontend_fd); frontend_fd = -1; }
 390 }
 391
 392
 393 int DeviceDVBInput::dvb_status()
 394 {
 395 //note: this function can take > 500ms to execute  (slowww)
 396 #ifndef TEST_DATA
 397         int locked = 0;
 398         reset_signal();
 399 #ifdef HAVE_DVB
 400         int &fe = frontend_fd;
 401         if( fe < 0 ) return -1;
 402         fe_status_t st;  memset(&st, 0, sizeof(st));
 403         if( ioctl(fe, FE_READ_STATUS, &st) ) return 1;
 404         if( (st & FE_TIMEDOUT) != 0 ) return 1;
 405         signal_lck = (st & FE_HAS_LOCK) != 0 ? 1 : 0;
 406         signal_crr = (st & FE_HAS_CARRIER) != 0 ? 1 : 0;
 407         uint16_t power = 0;
 408         signal_pwr = ioctl(fe,FE_READ_SIGNAL_STRENGTH,&power) ? -1 :
 409                 drange(power, pwr_min, pwr_max);
 410         uint16_t ratio = 0;
 411         signal_snr = ioctl(fe, FE_READ_SNR, &ratio) ? -1 :
 412                 drange(ratio, snr_min, snr_max);
 413         uint32_t rate = 0;
 414         signal_ber = ioctl(fe, FE_READ_BER, &rate) ? -1 : rate;
 415         uint32_t errs = 0;
 416         signal_unc = ioctl(fe, FE_READ_UNCORRECTED_BLOCKS, &errs) ? -1 : errs;
 417         if( signal_lck && signal_ber >= 0 && signal_ber < 255 ) locked = 1;
 418         if( dvb_locked != locked ) {
 419                 printf(_("** %scarrier, dvb_locked %s\n"),
 420                          signal_crr ? "" : _("no "), locked ? _("lock") : _("lost") );
 421         }
 422 #endif
 423         dvb_locked = locked;
 424 #endif
 425         return 0;
 426 }
 427
 428 int DeviceDVBInput::drange(int v, int min, int max)
 429 {
 430         if( (v-=min) < 0 || (max-=min) <= 0 ) return 0;
 431         return v>max ? 65535U : (65535U * v) / max;
 432 }
 433
 434 void DeviceDVBInput::reset_signal()
 435 {
 436         signal_pwr = signal_crr = signal_lck =
 437         signal_snr = signal_ber = signal_unc = -1;
 438 }
 439
 440 int DeviceDVBInput::open_dev(int color_model)
 441 {
 442         int ret = 0;
 443         dvb_lock->lock("DeviceDVBInput::open_dev");
 444         if( dvb_fd < 0 ) {
 445                 ret = dvb_open();
 446                 if( ret == 1 ) {
 447                         printf("DeviceDVBInput::open_dev: adaptor %s open failed\n",
 448                                 dev_name);
 449                 }
 450         }
 451         if( !ret )
 452                 dvb_input_status->start();
 453         else
 454                 dvb_close();
 455         dvb_lock->unlock();
 456         return ret;
 457 }
 458
 459 void DeviceDVBInput::close_dev()
 460 {
 461         dvb_lock->lock("DeviceDVBInput::close_dev");
 462         dvb_input_status->stop();
 463         dvb_close();
 464         dvb_lock->unlock();
 465 }
 466
 467 int DeviceDVBInput::status_dev()
 468 {
 469         int result = 0;
 470 #ifndef TEST_DATA
 471         result = frontend_fd >= 0 ? dvb_status() : 1;
 472 #endif
 473         return result;
 474 }
 475
 476 void DeviceDVBInput::set_signal_status(SignalStatus *stat)
 477 {
 478         dvb_lock->lock("DeviceDVBInput::set_signal_status");
 479         if( dvb_input_status->signal_status )
 480                 dvb_input_status->signal_status->disconnect();
 481         dvb_input_status->signal_status = stat;
 482         if( stat ) stat->dvb_input = this;
 483         dvb_lock->unlock();
 484 }
 485
 486 #endif