Tvheadend

#include "tvheadend.h"

static inline void

msleep(uint32_t msec)

int

diseqc_send_msg(int fe_fd, __u8 framing_byte, __u8 address, __u8 cmd,

                    __u8 data_1,  __u8 data_2, __u8 data_3, __u8 msg_len)

  struct dvb_diseqc_master_cmd message;

#if DISEQC_TRACE

  tvhlog(LOG_DEBUG, "diseqc", "sending %X %X %X %X %X %X",

         framing_byte, address, cmd, data_1, data_2, data_3);

#endif

  message.msg[0] = framing_byte;

  message.msg[1] = address;

  message.msg[2] = cmd;

  message.msg[3] = data_1;

  message.msg[4] = data_2;

  message.msg[5] = data_3;

  message.msg_len = msg_len;

  return ioctl(fe_fd, FE_DISEQC_SEND_MASTER_CMD, &message);

}

int

diseqc_setup(int fe_fd, int lnb_num, int voltage, int band,

              uint32_t version, uint32_t repeats)

{

  int i = (lnb_num % 4) * 4 + voltage * 2 + (band ? 1 : 0);

  int j = lnb_num / 4;

  int k, err;

#if DISEQC_TRACE

  tvhlog(LOG_DEBUG, "diseqc",

        "fe_fd %i, lnb_num %i, voltage %i, band %i, version %i, repeats %i",

        fe_fd, lnb_num, voltage, band, version, repeats);

#endif

  /* verify lnb number and diseqc data */

  if(lnb_num < 0 || lnb_num >=64 || i < 0 || i >= 16 || j < 0 || j >= 16)

    return -1;

  /* turn off continuous tone */

  if ((err = ioctl(fe_fd, FE_SET_TONE, SEC_TONE_OFF)))

  /* set lnb voltage */

  if ((err = ioctl(fe_fd, FE_SET_VOLTAGE,

                    (i/2) % 2 ? SEC_VOLTAGE_18 : SEC_VOLTAGE_13)))

  msleep(15);

  if (repeats == 0) { /* uncommited msg, wait 15ms, commited msg */

    if ((err = diseqc_send_msg(fe_fd, 0xE0, 0x10, 0x39, 0xF0 | j, 0, 0, 4)))

      return err;

    if ((err = diseqc_send_msg(fe_fd, 0xE0, 0x10, 0x38, 0xF0 | i, 0, 0, 4)))

      return err;

  } else { /* commited msg, 25ms, uncommited msg, 25ms, commited msg, etc */

    if ((err = diseqc_send_msg(fe_fd, 0xE0, 0x10, 0x38, 0xF0 | i, 0, 0, 4)))

      return err;

    for (k = 0; k < repeats; k++) {

      msleep(25);

      if ((err = diseqc_send_msg(fe_fd, 0xE0, 0x10, 0x39, 0xF0 | j, 0, 0, 4)))

        return err;

      msleep(25);

      if ((err = diseqc_send_msg(fe_fd, 0xE1, 0x10, 0x38, 0xF0 | i, 0, 0, 4)))

  }

  /* set toneburst */

  if ((err = ioctl(fe_fd, FE_DISEQC_SEND_BURST,

                    (i/4) % 2 ? SEC_MINI_B : SEC_MINI_A)))

  /* set continuous tone */

  if ((err = ioctl(fe_fd, FE_SET_TONE, i % 2 ? SEC_TONE_ON : SEC_TONE_OFF)))

    return err;

  return 0;

diseqc_voltage_off(int fe_fd)

  return ioctl(fe_fd, FE_SET_VOLTAGE, SEC_VOLTAGE_OFF);

int diseqc_send_msg(int fe_fd, __u8 framing_byte, __u8 address, __u8 cmd,

                    __u8 data_1, __u8 data_2, __u8 data_3, __u8 msg_len);

int diseqc_setup(int fe_fd, int lnb_num, int voltage, int band,

                  uint32_t version, uint32_t repeats);

int diseqc_voltage_off(int fe_fd);

#include "dvb_charset.h"

dvb_init(uint32_t adapter_mask, const char *rawfile)

  dvb_charset_init();

  dvb_adapter_init(adapter_mask, rawfile);

#include "psi.h"

struct service;

struct th_dvb_table;

struct th_dvb_mux_instance;

  int sc_port;                   // diseqc switchport (0 - 63)

  uint16_t tdmi_signal;

  uint32_t tdmi_ber, tdmi_unc;

  float tdmi_unc_avg;

  float tdmi_snr;

  int tdmi_num_tables;

  uint32_t tdmi_network_id;

  char *tdmi_default_authority;

  struct th_subscription_list tdmi_subscriptions;

/**

 * When in raw mode we need to enqueue raw TS packet

 * to a different thread because we need to hold

 * global_lock when doing delivery of the tables

 */

TAILQ_HEAD(dvb_table_feed_queue, dvb_table_feed);

typedef struct dvb_table_feed {

  TAILQ_ENTRY(dvb_table_feed) dtf_link;

  uint8_t dtf_tsb[188];

} dvb_table_feed_t;

  uint32_t tda_idleclose;

  uint32_t tda_diseqc_repeats;

  int32_t  tda_full_mux_rx;

  int tda_snr_valid;

  struct th_dvb_mux_instance_list tda_mux_list;

  void (*tda_open_service)(struct th_dvb_adapter *tda, struct service *s);

  void (*tda_close_service)(struct th_dvb_adapter *tda, struct service *s);

  void (*tda_open_table)(struct th_dvb_mux_instance *tdmi, struct th_dvb_table *s);

  void (*tda_close_table)(struct th_dvb_mux_instance *tdmi, struct th_dvb_table *s);

  int tda_rawmode;

  // Full mux streaming, protected via the delivery mutex

  streaming_pad_t tda_streaming_pad;

  struct dvb_table_feed_queue tda_table_feed;

  pthread_cond_t tda_table_feed_cond;  // Bound to tda_delivery_mutex

  // PIDs that needs to be requeued and processed as tables

  uint8_t tda_table_filter[8192];

  th_dvb_mux_instance_t *tdt_tdmi;

  int tdt_table;

  int tdt_mask;

  int tdt_destroyed;

  int tdt_refcount;

  psi_section_t tdt_sect; // Manual reassembly

void dvb_init(uint32_t adapter_mask, const char *rawfile);

void dvb_adapter_init(uint32_t adapter_mask, const char *rawfile);

void dvb_adapter_set_idleclose(th_dvb_adapter_t *tda, int on);

void dvb_adapter_set_diseqc_repeats(th_dvb_adapter_t *tda,

                                    unsigned int repeats);

void dvb_adapter_set_full_mux_rx(th_dvb_adapter_t *tda, int r);

void dvb_input_filtered_setup(th_dvb_adapter_t *tda);

void dvb_input_raw_setup(th_dvb_adapter_t *tda);

				      uint16_t onid, uint16_t tsid, const char *network,

void dvb_mux_set_onid(th_dvb_mux_instance_t *tdmi, uint16_t onid);

th_dvb_mux_instance_t *dvb_mux_find

  (th_dvb_adapter_t *tda, const char *netname, uint16_t onid, uint16_t tsid,

   int enabled );

void dvb_service_load(th_dvb_mux_instance_t *tdmi, const char *tdmi_identifier);

struct service *dvb_service_find(th_dvb_mux_instance_t *tdmi,

struct service *dvb_service_find2(th_dvb_mux_instance_t *tdmi,

struct service *dvb_service_find3

  (th_dvb_adapter_t *tda, th_dvb_mux_instance_t *tdmi,

   const char *netname, uint16_t onid, uint16_t tsid, uint16_t sid,

   int enabled, int epgprimary);

void dvb_service_notify(struct service *t);

void dvb_service_notify_by_adapter(th_dvb_adapter_t *tda);

htsmsg_t *dvb_service_build_msg(struct service *t);

void tdt_add(th_dvb_mux_instance_t *tdmi, int table, int mask,

	     const char *name, int flags, int pid);

int dvb_pidx11_callback

  (th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,

   uint8_t tableid, void *opaque);

void dvb_table_dispatch(uint8_t *sec, int r, th_dvb_table_t *tdt);

void dvb_table_release(th_dvb_table_t *tdt);

/**

 * Raw demux

 */

struct th_subscription;

struct th_subscription *dvb_subscription_create_from_tdmi(th_dvb_mux_instance_t *tdmi,

							  const char *name,

							  streaming_target_t *st);

  streaming_pad_init(&tda->tda_streaming_pad);

  htsmsg_add_u32(m, "idleclose", tda->tda_idleclose);

  htsmsg_add_u32(m, "sidtochan", tda->tda_sidtochan);

  htsmsg_add_u32(m, "diseqc_repeats", tda->tda_diseqc_repeats);

  htsmsg_add_s32(m, "full_mux_rx", tda->tda_full_mux_rx);

dvb_adapter_set_idleclose(th_dvb_adapter_t *tda, int on)

{

  if(tda->tda_idleclose == on)

    return;

  lock_assert(&global_lock);

  tvhlog(LOG_NOTICE, "dvb", "Adapter \"%s\" idle fd close set to: %s",

	 tda->tda_displayname, on ? "On" : "Off");

  tda->tda_idleclose = on;

  tda_save(tda);

}

/**

 *

 */

void

 * sets the number of diseqc repeats to perform

 */

void

dvb_adapter_set_diseqc_repeats(th_dvb_adapter_t *tda, unsigned int repeats)

{

  if(tda->tda_diseqc_repeats == repeats)

    return;

  lock_assert(&global_lock);

  tvhlog(LOG_NOTICE, "dvb", "Adapter \"%s\" DiSEqC repeats set to: %i",

         tda->tda_displayname, repeats);

  tda->tda_diseqc_repeats = repeats;

  tda_save(tda);

}

/**

void

dvb_adapter_set_full_mux_rx(th_dvb_adapter_t *tda, int on)

{

  const char* label[] = { "Auto", "Off", "On" };

  if (on < -1) on = -1;

  if (on >  1) on = 1;

  if(tda->tda_full_mux_rx == on)

    return;

  lock_assert(&global_lock);

  tvhlog(LOG_NOTICE, "dvb",

         "Adapter \"%s\" disabled full MUX receive set to: %s",

	 tda->tda_displayname, label[on+1]);

  tda->tda_full_mux_rx = on;

  tda_save(tda);

}

/**

 *

 */

/**

 * Return 1 if an adapter is capable of receiving a full mux

 */

static int

check_full_stream(th_dvb_adapter_t *tda)

{

  struct dmx_pes_filter_params dmx_param;

  int r;

  if(tda->tda_full_mux_rx != -1)

    return tda->tda_full_mux_rx;

  if(tda->tda_hostconnection == HOSTCONNECTION_USB12)

    return 0; // Don't even bother, device <-> host interface is too slow

  if(tda->tda_hostconnection == HOSTCONNECTION_USB480)

    return 0; // USB in general appears to have CPU loading issues?

  int fd = tvh_open(tda->tda_demux_path, O_RDWR, 0);

  if(fd == -1)

    return 0;

  memset(&dmx_param, 0, sizeof(dmx_param));

  dmx_param.pid = 0x2000;

  dmx_param.input = DMX_IN_FRONTEND;

  dmx_param.output = DMX_OUT_TS_TAP;

  dmx_param.pes_type = DMX_PES_OTHER;

  dmx_param.flags = DMX_IMMEDIATE_START;

  r = ioctl(fd, DMX_SET_PES_FILTER, &dmx_param);

  close(fd);

  return !r;

}

  tda->tda_full_mux_rx = -1;

  if (tda->tda_idlescan || !tda->tda_idleclose)

    tda->tda_fe_fd = fe;

  else

  if(!strcmp(tda->tda_fe_info->name, "Sony CXD2820R (DVB-T/T2)"))

    tda->tda_snr_valid = 1;

	 "Found adapter %s (%s) via %s%s", path, tda->tda_fe_info->name,

	 hostconnection2str(tda->tda_hostconnection),

         tda->tda_snr_valid ? ", Reports valid SNR values" : "");

  gtimer_arm(&tda->tda_mux_scanner_timer, dvb_adapter_mux_scanner, tda, 1);

}

/**

 *

 */

static void

tda_add_from_file(const char *filename)

{

  int i, r;

  th_dvb_adapter_t *tda;

  char buf[400];

  tda = tda_alloc();

  tda->tda_adapter_num = -1;

  tda->tda_fe_fd       = -1;

  tda->tda_dvr_pipe[0] = -1;

  tda->tda_type = -1;

  snprintf(buf, sizeof(buf), "%s", filename);

  r = strlen(buf);

  for(i = 0; i < r; i++)

    if(!isalnum((int)buf[i]))

      buf[i] = '_';

  tda->tda_identifier = strdup(buf);

  tda->tda_autodiscovery = 0;

  tda->tda_idlescan = 0;

  tda->tda_sat = 0;

  tda->tda_full_mux_rx = 1;

  /* Come up with an initial displayname, user can change it and it will

     be overridden by any stored settings later on */

  tda->tda_displayname = strdup(filename);

  TAILQ_INSERT_TAIL(&dvb_adapters, tda, tda_global_link);

/**

 * Initiliase input

 */

static void tda_init_input (th_dvb_adapter_t *tda)

{

  if(tda->tda_type == -1 || check_full_stream(tda)) {

    tvhlog(LOG_INFO, "dvb", "Adapter %s will run in full mux mode", tda->tda_rootpath);

    dvb_input_raw_setup(tda);

  } else {

    tvhlog(LOG_INFO, "dvb", "Adapter %s will run in filtered mode", tda->tda_rootpath);

    dvb_input_filtered_setup(tda);

  }

}

/**

 *

 */

    int err = pipe(tda->tda_dvr_pipe);

    assert(err != -1);

    fcntl(tda->tda_dvr_pipe[0], F_SETFD, fcntl(tda->tda_dvr_pipe[0], F_GETFD) | FD_CLOEXEC);

    fcntl(tda->tda_dvr_pipe[0], F_SETFL, fcntl(tda->tda_dvr_pipe[0], F_GETFL) | O_NONBLOCK);

    fcntl(tda->tda_dvr_pipe[1], F_SETFD, fcntl(tda->tda_dvr_pipe[1], F_GETFD) | FD_CLOEXEC);

  /* Don't stop/close */

  if (!tda->tda_idleclose) return;

    int err = write(tda->tda_dvr_pipe[1], "", 1);

    assert(err != -1);

dvb_adapter_init(uint32_t adapter_mask, const char *rawfile)

  uint32_t u32;

  /* Initialise hardware */

  /* Initialise rawts test file */

  if(rawfile)

    tda_add_from_file(rawfile);

  /* Load configuration */

      htsmsg_get_u32(c, "idleclose", &tda->tda_idleclose);

      htsmsg_get_u32(c, "sidtochan", &tda->tda_sidtochan);

      htsmsg_get_u32(c, "diseqc_repeats", &tda->tda_diseqc_repeats);

      if (htsmsg_get_s32(c, "full_mux_rx", &tda->tda_full_mux_rx))

        if (!htsmsg_get_u32(c, "disable_full_mux_rx", &u32) && u32)

          tda->tda_full_mux_rx = 0;

  TAILQ_FOREACH(tda, &dvb_adapters, tda_global_link) {

    tda_init_input(tda);

    if(tda->tda_sat)

      dvb_satconf_init(tda);

}

  if(tda->tda_mux_current != NULL &&

     LIST_FIRST(&tda->tda_mux_current->tdmi_subscriptions) != NULL)

    return; // Someone is doing full mux dump

  int fd, i, r, c, efd, nfds, dmx = -1;

  char path[256];

  snprintf(path, sizeof(path), "%s/dvr0", tda->tda_rootpath);

  fd = tvh_open(path, O_RDONLY | O_NONBLOCK, 0);

    tvhlog(LOG_ALERT, "dvb", "Unable to open %s -- %s", path, strerror(errno));

  if(tda->tda_rawmode) {

    // Receive unfiltered raw transport stream

    dmx = tvh_open(tda->tda_demux_path, O_RDWR, 0);

    if(dmx == -1) {

      tvhlog(LOG_ALERT, "dvb", "Unable to open %s -- %s", 

	     tda->tda_demux_path, strerror(errno));

      close(fd);

      return NULL;

    }

    struct dmx_pes_filter_params dmx_param;

    memset(&dmx_param, 0, sizeof(dmx_param));

    dmx_param.pid = 0x2000;

    dmx_param.input = DMX_IN_FRONTEND;

    dmx_param.output = DMX_OUT_TS_TAP;

    dmx_param.pes_type = DMX_PES_OTHER;

    dmx_param.flags = DMX_IMMEDIATE_START;

    if(ioctl(dmx, DMX_SET_PES_FILTER, &dmx_param)) {

      tvhlog(LOG_ERR, "dvb",

	     "Unable to configure demuxer \"%s\" for all PIDs -- %s",

	     tda->tda_demux_path, strerror(errno));

      close(dmx);

      close(fd);

      return NULL;

    }

  }

  memset(&ev, 0, sizeof(ev));

  r = i = 0;

    c = read(fd, tsb+r, sizeof(tsb)-r);

    if (c < 0) {

      if (errno == EAGAIN || errno == EINTR)

        continue;

      else if (errno == EOVERFLOW) {

        tvhlog(LOG_WARNING, "dvb", "\"%s\" read() EOVERFLOW",

               tda->tda_identifier);

        continue;

      } else {

        // TODO: should we try to recover?

        tvhlog(LOG_ERR, "dvb", "\"%s\" read() error %d",

               tda->tda_identifier, errno);

        break;

      }

    }

    r += c;

    /* not enough data */

    if (r < 188) continue;

    int wakeup_table_feed = 0;  // Just wanna wakeup once

    if(LIST_FIRST(&tda->tda_streaming_pad.sp_targets) != NULL) {

      streaming_message_t sm;

      pktbuf_t *pb = pktbuf_alloc(tsb, r);

      memset(&sm, 0, sizeof(sm));

      sm.sm_type = SMT_MPEGTS;

      sm.sm_data = pb;

      streaming_pad_deliver(&tda->tda_streaming_pad, &sm);

      pktbuf_ref_dec(pb);

    }

    /* Process */

    while (r >= 188) {

      /* sync */

      if (tsb[i] == 0x47) {

	      int pid = (tsb[i+1] & 0x1f) << 8 | tsb[i+2];

	      if(tda->tda_table_filter[pid]) {

	        if(!(tsb[i+1] & 0x80)) { // Only dispatch to table parser if not error

	          dvb_table_feed_t *dtf = malloc(sizeof(dvb_table_feed_t));

	          memcpy(dtf->dtf_tsb, tsb + i, 188);

	          TAILQ_INSERT_TAIL(&tda->tda_table_feed, dtf, dtf_link);

	          wakeup_table_feed = 1;

	        }

	      } else {

        i += 188;

        r -= 188;

      /* no sync */

      } else {

        tvhlog(LOG_DEBUG, "dvb", "\"%s\" ts sync lost", tda->tda_identifier);

        if (ts_resync(tsb, &r, &i)) break;

        tvhlog(LOG_DEBUG, "dvb", "\"%s\" ts sync found", tda->tda_identifier);

    if(wakeup_table_feed)

      pthread_cond_signal(&tda->tda_table_feed_cond);

    /* reset buffer */

    if (r) memmove(tsb, tsb+i, r);

    i = 0;

  if(dmx != -1)

    close(dmx);

    th_dvb_mux_instance_t *tdmi = tda->tda_mux_current;

    htsmsg_add_u32(m, "signal", MIN(tdmi->tdmi_signal * 100 / 65535, 100));

    htsmsg_add_u32(m, "snr", tdmi->tdmi_snr);

    htsmsg_add_u32(m, "ber", tdmi->tdmi_ber);

    htsmsg_add_u32(m, "unc", tdmi->tdmi_unc);

    htsmsg_add_u32(m, "uncavg", tdmi->tdmi_unc_avg);

  if (tda->tda_fe_fd == -1) return;

/*

 *  tvheadend, charset list

 *  Copyright (C) 2012 Mariusz Białończyk

 *

 *  This program is free software: you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation, either version 3 of the License, or

 *  (at your option) any later version.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#include <string.h>

#include "tvheadend.h"

#include "settings.h"

#include "dvb/dvb_charset.h"

/*

 * Process a file

 */

static void _charset_load_file()

{

  htsmsg_t *l, *e;

  htsmsg_field_t *f;

  dvb_charset_t *enc;

  const char *charset;

  uint32_t tsid, onid, sid;

  int i = 0;

  l = hts_settings_load("charset");

  if (l)

  {

    HTSMSG_FOREACH(f, l) {

      if ((e = htsmsg_get_map_by_field(f))) {

        tsid = onid = sid = 0;

        htsmsg_get_u32(e, "onid", &onid);

        htsmsg_get_u32(e, "tsid", &tsid);

        htsmsg_get_u32(e, "sid",  &sid);

        charset = htsmsg_get_str(e, "charset");

        if (tsid == 0 || onid == 0 || !charset)

          continue;

        enc = calloc(1, sizeof(dvb_charset_t));

        if (enc)

        {

          enc->onid    = onid;

          enc->tsid    = tsid;

          enc->sid     = sid;

          enc->charset = strdup(charset);

          LIST_INSERT_HEAD(&dvb_charset_list, enc, link);

          i++;

        }

      }

    };

    htsmsg_destroy(l);

  };

  if (i > 0)

    tvhlog(LOG_INFO, "charset", "%d entries loaded", i);

}

/*

 * Initialise the charset list

 */

void dvb_charset_init ( void )

{

  _charset_load_file();

}

/*

 * Find default charset

 */

const char *dvb_charset_find

  ( uint16_t onid, uint16_t tsid, uint16_t sid )

{

  dvb_charset_t *ret = NULL, *enc;

  LIST_FOREACH(enc, &dvb_charset_list, link) {

    if (onid == enc->onid && tsid == enc->tsid) {

      if (sid == enc->sid) {

         ret = enc;

        break;

      } else if (!enc->sid) {

        ret = enc;

      }

    }

  }

  return ret ? ret->charset : NULL;

}

/*

 *  tvheadend, dvb charset config

 *  Copyright (C) 2012 Mariusz Białończyk

 *

 *  This program is free software: you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation, either version 3 of the License, or

 *  (at your option) any later version.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef __TVH_DVB_CHARSET_H__

#define __TVH_DVB_CHARSET_H__

typedef struct dvb_charset {

  LIST_ENTRY(dvb_charset) link;

 uint16_t onid;

 uint16_t tsid;

 uint16_t sid;

 const char *charset;

} dvb_charset_t;

LIST_HEAD(,dvb_charset) dvb_charset_list;

void dvb_charset_init ( void );

const char *dvb_charset_find

  (uint16_t onid, uint16_t tsid, uint16_t sid);

#endif /* __TVH_DVB_CHARSET_H__ */