Tvheadend

/*

 *  Tvheadend - MPEGTS multiplex

 *

 *  Copyright (C) 2013 Adam Sutton

 *

 *  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 "idnode.h"

#include "queue.h"

#include "input.h"

#include "subscriptions.h"

#include "streaming.h"

#include "channels.h"

#include "access.h"

#include "profile.h"

#include "dvb_charset.h"

#include <assert.h>

static void mpegts_mux_scan_timeout ( void *p );

static void mpegts_mux_do_stop ( mpegts_mux_t *mm, int delconf );

/* ****************************************************************************

 * Mux instance (input linkage)

 * ***************************************************************************/

const idclass_t mpegts_mux_instance_class =

{

  .ic_super      = &tvh_input_instance_class,

  .ic_class      = "mpegts_mux_instance",

  .ic_caption    = N_("MPEG-TS multiplex PHY"),

  .ic_perm_def   = ACCESS_ADMIN

};

void

mpegts_mux_instance_delete

  ( tvh_input_instance_t *tii )

{

  mpegts_mux_instance_t *mmi = (mpegts_mux_instance_t *)tii;

  idnode_save_check(&tii->tii_id, 1);

  idnode_unlink(&tii->tii_id);

  LIST_REMOVE(mmi, mmi_mux_link);

  LIST_REMOVE(tii, tii_input_link);

  pthread_mutex_destroy(&mmi->tii_stats_mutex);

  free(mmi);

}

mpegts_mux_instance_t *

mpegts_mux_instance_create0

  ( mpegts_mux_instance_t *mmi, const idclass_t *class, const char *uuid,

    mpegts_input_t *mi, mpegts_mux_t *mm )

{

  // TODO: does this need to be an idnode?

  if (idnode_insert(&mmi->tii_id, uuid, class, 0)) {

    free(mmi);

    return NULL;

  }

  pthread_mutex_init(&mmi->tii_stats_mutex, NULL);

  /* Setup links */

  mmi->mmi_mux   = mm;

  mmi->mmi_input = mi;

  /* Callbacks */

  mmi->tii_delete = mpegts_mux_instance_delete;

  mmi->tii_clear_stats = tvh_input_instance_clear_stats;

  LIST_INSERT_HEAD(&mm->mm_instances, mmi, mmi_mux_link);

  LIST_INSERT_HEAD(&mi->mi_mux_instances, (tvh_input_instance_t *)mmi, tii_input_link);

  return mmi;

}

static void

mpegts_mux_scan_active

  ( mpegts_mux_t *mm, const char *buf, mpegts_input_t *mi )

{

  int t;

  /* Setup scan */

  if (mm->mm_scan_state == MM_SCAN_STATE_PEND) {

    mpegts_network_scan_mux_active(mm);

    /* Get timeout */

    t = mpegts_input_grace(mi, mm);

    /* Setup timeout */

    mtimer_arm_rel(&mm->mm_scan_timeout, mpegts_mux_scan_timeout, mm, sec2mono(t));

  }

}

static int

mpegts_mux_keep_exists

  ( mpegts_input_t *mi )

{

  const mpegts_mux_instance_t *mmi;

  const service_t *s;

  const th_subscription_t *ths;

  int ret;

  lock_assert(&global_lock);

  if (!mi)

    return 0;

  ret = 0;

  LIST_FOREACH(mmi, &mi->mi_mux_active, mmi_active_link)

    LIST_FOREACH(ths, &mmi->mmi_mux->mm_raw_subs, ths_mux_link) {

      s = ths->ths_service;

      if (s && s->s_type == STYPE_RAW && !strcmp(ths->ths_title, "keep")) {

        ret = 1;

        break;

      }

    }

  return ret;

}

static int

mpegts_mux_subscribe_keep

  ( mpegts_mux_t *mm, mpegts_input_t *mi )

{

  char *s;

  int r;

  s = mi->mi_linked;

  mi->mi_linked = NULL;

  tvhtrace(LS_MPEGTS, "subscribe keep for '%s' (%p)", mi->mi_name, mm);

  r = mpegts_mux_subscribe(mm, mi, "keep", SUBSCRIPTION_PRIO_KEEP,

                           SUBSCRIPTION_ONESHOT | SUBSCRIPTION_MINIMAL);

  mi->mi_linked = s;

  return r;

}

static void

mpegts_mux_subscribe_linked

  ( mpegts_input_t *mi, mpegts_mux_t *mm )

{

  mpegts_input_t *mi2 = mpegts_input_find(mi->mi_linked);

  mpegts_mux_instance_t *mmi2;

  mpegts_network_link_t *mnl2;

  mpegts_mux_t *mm2;

  char buf1[128], buf2[128];

  const char *serr = "All";

  int r = 0;

  tvhtrace(LS_MPEGTS, "subscribe linked");

  if (!mpegts_mux_keep_exists(mi) && (r = mpegts_mux_subscribe_keep(mm, mi))) {

    serr = "active1";

    goto fatal;

  }

  if (!mi2)

    return;

  if (mpegts_mux_keep_exists(mi2))

    return;

  mmi2 = LIST_FIRST(&mi2->mi_mux_active);

  if (mmi2) {

    if (!mpegts_mux_subscribe_keep(mmi2->mmi_mux, mi2))

      return;

    serr = "active2";

    goto fatal;

  }

  /* Try muxes within same network */

  LIST_FOREACH(mnl2, &mi2->mi_networks, mnl_mi_link)

    if (mnl2->mnl_network == mm->mm_network)

      LIST_FOREACH(mm2, &mnl2->mnl_network->mn_muxes, mm_network_link)

        if (!mm2->mm_active && MM_SCAN_CHECK_OK(mm) &&

            !LIST_EMPTY(&mm2->mm_services))

          if (!mpegts_mux_subscribe_keep(mm2, mi2))

            return;

  /* Try all other muxes */

  LIST_FOREACH(mnl2, &mi2->mi_networks, mnl_mi_link)

    if (mnl2->mnl_network != mm->mm_network)

      LIST_FOREACH(mm2, &mnl2->mnl_network->mn_muxes, mm_network_link)

        if (!mm2->mm_active && MM_SCAN_CHECK_OK(mm) &&

            !LIST_EMPTY(&mm2->mm_services))

          if (!mpegts_mux_subscribe_keep(mm2, mi2))

            return;

fatal:

  mi ->mi_display_name(mi,  buf1, sizeof(buf1));

  mi2->mi_display_name(mi2, buf2, sizeof(buf2));

  tvherror(LS_MPEGTS, "%s - %s - linked input cannot be started (%s: %i)", buf1, buf2, serr, r);

}

void

mpegts_mux_unsubscribe_linked

  ( mpegts_input_t *mi, service_t *t )

{

  th_subscription_t *ths, *ths_next;

  if (mi) {

    tvhtrace(LS_MPEGTS, "unsubscribing linked");

    for (ths = LIST_FIRST(&subscriptions); ths; ths = ths_next) {

      ths_next = LIST_NEXT(ths, ths_global_link);

      if (ths->ths_source == (tvh_input_t *)mi && !strcmp(ths->ths_title, "keep") &&

          ths->ths_service != t)

        subscription_unsubscribe(ths, UNSUBSCRIBE_FINAL);

    }

  }

}

int

mpegts_mux_instance_start

  ( mpegts_mux_instance_t **mmiptr, service_t *t, int weight )

{

  int r;

  char buf[256], buf2[256];

  mpegts_mux_instance_t *mmi = *mmiptr;

  mpegts_mux_t          * mm = mmi->mmi_mux;

  mpegts_input_t        * mi = mmi->mmi_input;

  mpegts_service_t      *  s;

  mpegts_mux_nice_name(mm, buf, sizeof(buf));

  /* Already active */

  if (mm->mm_active) {

    *mmiptr = mm->mm_active;

    tvhdebug(LS_MPEGTS, "%s - already active", buf);

    mpegts_mux_scan_active(mm, buf, (*mmiptr)->mmi_input);

    return 0;

  }

  /* Dead service check */

  LIST_FOREACH(s, &mm->mm_services, s_dvb_mux_link)

    s->s_dvb_check_seen = s->s_dvb_last_seen;

  mm->mm_tsid_checks = 0;

  /* Start */

  mi->mi_display_name(mi, buf2, sizeof(buf2));

  tvhinfo(LS_MPEGTS, "%s - tuning on %s", buf, buf2);

  if (mi->mi_linked)

    mpegts_mux_unsubscribe_linked(mi, t);

  r = mi->mi_warm_mux(mi, mmi);

  if (r) return r;

  r = mi->mi_start_mux(mi, mmi, weight);

  if (r) return r;

  /* Start */

  tvhdebug(LS_MPEGTS, "%s - started", buf);

  mi->mi_started_mux(mi, mmi);

  /* Event handler */

  mpegts_fire_event(mm, ml_mux_start);

  /* Link */

  mpegts_mux_scan_active(mm, buf, mi);

  if (mi->mi_linked)

    mpegts_mux_subscribe_linked(mi, mm);

  return 0;

}

int

mpegts_mux_instance_weight ( mpegts_mux_instance_t *mmi )

{

  int w = 0;

  const service_t *s;

  const th_subscription_t *ths;

  mpegts_mux_t *mm = mmi->mmi_mux;

  lock_assert(&mmi->mmi_input->mi_output_lock);

  /* Service subs */

  LIST_FOREACH(s, &mm->mm_transports, s_active_link)

    LIST_FOREACH(ths, &s->s_subscriptions, ths_service_link)

      w = MAX(w, ths->ths_weight);

  return w;

}

/* ****************************************************************************

 * Class definition

 * ***************************************************************************/

static htsmsg_t *

mpegts_mux_class_save ( idnode_t *self, char *filename, size_t fsize )

{

  mpegts_mux_t *mm = (mpegts_mux_t*)self;

  if (mm->mm_config_save)

    return mm->mm_config_save(mm, filename, fsize);

  return NULL;

}

static void

mpegts_mux_class_delete ( idnode_t *self )

{

  mpegts_mux_t *mm = (mpegts_mux_t*)self;

  if (mm->mm_delete) mm->mm_delete(mm, 1);

}

static const char *

mpegts_mux_class_get_title ( idnode_t *self, const char *lang )

{

  static __thread char buf[256];

  mpegts_mux_nice_name((mpegts_mux_t*)self, buf, sizeof(buf));

  return buf;

}

static const void *

mpegts_mux_class_get_num_svc ( void *ptr )

{

  static int n;

  mpegts_mux_t *mm = ptr;

  mpegts_service_t *s;

  n = 0;

  LIST_FOREACH(s, &mm->mm_services, s_dvb_mux_link)

    n++;

  return &n;

}

static const void *

mpegts_mux_class_get_num_chn ( void *ptr )

{

  static int n;

  mpegts_mux_t *mm = ptr;

  mpegts_service_t *s;

  idnode_list_mapping_t *ilm;

  n = 0;

  LIST_FOREACH(s, &mm->mm_services, s_dvb_mux_link)

    LIST_FOREACH(ilm, &s->s_channels, ilm_in1_link)

      n++;

  return &n;

}

static const void *

mpegts_mux_class_get_network ( void *ptr )

{

  static char buf[512], *s = buf;

  mpegts_mux_t *mm = ptr;

  if (mm && mm->mm_network && mm->mm_network->mn_display_name)

    mm->mm_network->mn_display_name(mm->mm_network, buf, sizeof(buf));

  else

    *buf = 0;

  return &s;

}

static const void *

mpegts_mux_class_get_network_uuid ( void *ptr )

{

  mpegts_mux_t *mm = ptr;

  if (mm && mm->mm_network)

    idnode_uuid_as_str(&mm->mm_network->mn_id, prop_sbuf);

  else

    prop_sbuf[0] = '\0';

  return &prop_sbuf_ptr;

}

static const void *

mpegts_mux_class_get_name ( void *ptr )

{

  static char buf[512], *s = buf;

  mpegts_mux_t *mm = ptr;

  if (mm && mm->mm_display_name)

    mm->mm_display_name(mm, buf, sizeof(buf));

  else

    *buf = 0;

  return &s;

}

static struct strtab

scan_state_tab[] = {

  { N_("IDLE"),   MM_SCAN_STATE_IDLE },

  { N_("PEND"),   MM_SCAN_STATE_PEND },

  { N_("ACTIVE"), MM_SCAN_STATE_ACTIVE },

};

static struct strtab

scan_result_tab[] = {

 { N_("NONE"),         MM_SCAN_NONE },

 { N_("OK"),           MM_SCAN_OK   },

 { N_("FAIL"),         MM_SCAN_FAIL },

 { N_("OK (partial)"), MM_SCAN_PARTIAL },

 { N_("IGNORE"),       MM_SCAN_IGNORE },

};

int

mpegts_mux_class_scan_state_set ( void *o, const void *p )

{

  mpegts_mux_t *mm = o;

  int state = *(int*)p;

  /* Ignore */

  if (!mm->mm_is_enabled(mm))

    return 0;

  /* Start */

  if (state == MM_SCAN_STATE_PEND || state == MM_SCAN_STATE_ACTIVE) {

    /* No change */

    if (mm->mm_scan_state != MM_SCAN_STATE_IDLE)

      return 0;

    /* Start */

    mpegts_network_scan_queue_add(mm, SUBSCRIPTION_PRIO_SCAN_USER,

                                  SUBSCRIPTION_USERSCAN, 0);

  /* Stop */

  } else if (state == MM_SCAN_STATE_IDLE) {

    /* No change */

    if (mm->mm_scan_state == MM_SCAN_STATE_IDLE)

      return 0;

    /* Update */

    mpegts_network_scan_mux_cancel(mm, 0);

  /* Invalid */

  } else {

  }

  return 1;

}

static htsmsg_t *

mpegts_mux_class_scan_state_enum ( void *p, const char *lang )

{

  return strtab2htsmsg(scan_state_tab, 1, lang);

}

static htsmsg_t *

mpegts_mux_class_scan_result_enum ( void *p, const char *lang )

{

  return strtab2htsmsg(scan_result_tab, 1, lang);

}

static void

mpegts_mux_class_enabled_notify ( void *p, const char *lang )

{

  mpegts_mux_t *mm = p;

  if (!mm->mm_is_enabled(mm)) {

    mm->mm_stop(mm, 1, SM_CODE_MUX_NOT_ENABLED);

    mpegts_network_scan_mux_cancel(mm, 0);

    if (mm->mm_enabled == MM_IGNORE) {

      mpegts_mux_do_stop(mm, 1);

      mm->mm_scan_result = MM_SCAN_IGNORE;

    }

  }

}

static htsmsg_t *

mpegts_mux_enable_list ( void *o, const char *lang )

{

  static const struct strtab tab[] = {

    { N_("Ignore"),                   MM_IGNORE },

    { N_("Disable"),                  MM_DISABLE },

    { N_("Enable"),                   MM_ENABLE },

  };

  return strtab2htsmsg(tab, 1, lang);

}

static htsmsg_t *

mpegts_mux_epg_list ( void *o, const char *lang )

{

  static const struct strtab tab[] = {

    { N_("Disable"),                  MM_EPG_DISABLE },

    { N_("Enable (auto)"),            MM_EPG_ENABLE },

    { N_("Force (auto)"),             MM_EPG_FORCE },

    { N_("Only EIT"),                 MM_EPG_ONLY_EIT },

    { N_("Only PSIP (ATSC)"),         MM_EPG_ONLY_PSIP },

    { N_("Only UK Freesat"),          MM_EPG_ONLY_UK_FREESAT },

    { N_("Only UK Freeview"),         MM_EPG_ONLY_UK_FREEVIEW },

    { N_("Only Viasat Baltic"),       MM_EPG_ONLY_VIASAT_BALTIC },

    { N_("Only Bulsatcom 39E"),       MM_EPG_ONLY_BULSATCOM_39E },

    { N_("Only UK Cable"),	      MM_EPG_ONLY_UK_CABLE },

    { N_("Only OpenTV Sky UK"),       MM_EPG_ONLY_OPENTV_SKY_UK },

    { N_("Only OpenTV Sky Italia"),   MM_EPG_ONLY_OPENTV_SKY_ITALIA },

    { N_("Only OpenTV Sky Ausat"),    MM_EPG_ONLY_OPENTV_SKY_AUSAT },

  };

  return strtab2htsmsg(tab, 1, lang);

}

static htsmsg_t *

mpegts_mux_ac3_list ( void *o, const char *lang )

{

  static const struct strtab tab[] = {

    { N_("Standard"),                 MM_AC3_STANDARD },

    { N_("AC-3 = descriptor 6"),      MM_AC3_PMT_06 },

    { N_("Ignore descriptor 5"),      MM_AC3_PMT_N05 },

  };

  return strtab2htsmsg(tab, 1, lang);

}

CLASS_DOC(mpegts_mux)

const idclass_t mpegts_mux_class =

{

  .ic_class      = "mpegts_mux",

  .ic_caption    = N_("MPEG-TS Multiplex"),

  .ic_event      = "mpegts_mux",

  .ic_doc        = tvh_doc_mpegts_mux_class,

  .ic_perm_def   = ACCESS_ADMIN,

  .ic_save       = mpegts_mux_class_save,

  .ic_delete     = mpegts_mux_class_delete,

  .ic_get_title  = mpegts_mux_class_get_title,

  .ic_properties = (const property_t[]){

    {

      .type     = PT_INT,

      .id       = "enabled",

      .name     = N_("Enabled"),

      .desc     = N_("Enable, disable or ignore the mux. "

                     "When the mux is marked as ignore, "

                     "all discovered services are removed."),

      .off      = offsetof(mpegts_mux_t, mm_enabled),

      .def.i    = MM_ENABLE,

      .list     = mpegts_mux_enable_list,

      .notify   = mpegts_mux_class_enabled_notify,

      .opts     = PO_DOC_NLIST

    },

    {

      .type     = PT_INT,

      .id       = "epg",

      .name     = N_("EPG scan"),

      .desc     = N_("The EPG grabber to use on the mux. "

                     "Enable (auto) is the recommended value."),

      .off      = offsetof(mpegts_mux_t, mm_epg),

      .def.i    = MM_EPG_ENABLE,

      .list     = mpegts_mux_epg_list,

      .opts     = PO_DOC_NLIST,

    },

    {

      .type     = PT_STR,

      .id       = "network",

      .name     = N_("Network"),

      .desc     = N_("The network the mux is on."),

      .opts     = PO_RDONLY | PO_NOSAVE,

      .get      = mpegts_mux_class_get_network,

    },

    {

      .type     = PT_STR,

      .id       = "network_uuid",

      .name     = N_("Network UUID"),

      .desc     = N_("The networks' universally unique identifier (UUID)."),

      .opts     = PO_RDONLY | PO_NOSAVE | PO_HIDDEN | PO_EXPERT,

      .get      = mpegts_mux_class_get_network_uuid,

    },

    {

      .type     = PT_STR,

      .id       = "name",

      .name     = N_("Name"),

      .desc     = N_("The name (or frequency) the mux is on."),

      .opts     = PO_RDONLY | PO_NOSAVE,

      .get      = mpegts_mux_class_get_name,

    },

    {

      .type     = PT_STR,

      .id       = "pnetwork_name",

      .name     = N_("Provider network name"),

      .desc     = N_("The provider's network name."),

      .off      = offsetof(mpegts_mux_t, mm_provider_network_name),

      .opts     = PO_RDONLY | PO_HIDDEN | PO_EXPERT,

    },

    {

      .type     = PT_U16,

      .id       = "onid",

      .name     = N_("Original network ID"),

      .desc     = N_("The provider's network ID."),

      .opts     = PO_RDONLY | PO_ADVANCED,

      .off      = offsetof(mpegts_mux_t, mm_onid),

    },

    {

      .type     = PT_U16,

      .id       = "tsid",

      .name     = N_("Transport stream ID"),

      .desc     = N_("The transport stream ID of the mux within the "

                     "network."),

      .opts     = PO_RDONLY | PO_ADVANCED,

      .off      = offsetof(mpegts_mux_t, mm_tsid),

    },

    {

      .type     = PT_STR,

      .id       = "cridauth",

      .name     = N_("CRID authority"),

      .desc     = N_("The Content reference identifier (CRID) authority."),

      .opts     = PO_RDONLY | PO_HIDDEN | PO_EXPERT,

      .off      = offsetof(mpegts_mux_t, mm_crid_authority),

    },

    {

      .type     = PT_INT,

      .id       = "scan_state",

      .name     = N_("Scan status"),

      .desc     = N_("The scan state. New muxes will automatically be "

                     "changed to the PEND state. You can change this to "

                     "ACTIVE to queue a scan of this mux."),

      .off      = offsetof(mpegts_mux_t, mm_scan_state),

      .set      = mpegts_mux_class_scan_state_set,

      .list     = mpegts_mux_class_scan_state_enum,

      .opts     = PO_NOSAVE | PO_SORTKEY | PO_DOC_NLIST,

    },

    {

      .type     = PT_INT,

      .id       = "scan_result",

      .name     = N_("Scan result"),

      .desc     = N_("The outcome of the last scan performed on this mux."),

      .off      = offsetof(mpegts_mux_t, mm_scan_result),

      .opts     = PO_RDONLY | PO_SORTKEY | PO_DOC_NLIST,

      .list     = mpegts_mux_class_scan_result_enum,

    },

    {

      .type     = PT_STR,

      .id       = "charset",

      .name     = N_("Character set"),

      .desc     = N_("The character set used on this mux. You should "

                     "not have to change this unless channel names, etc "

                     " appear garbled."),

      .off      = offsetof(mpegts_mux_t, mm_charset),

      .list     = dvb_charset_enum,

      .opts     = PO_ADVANCED | PO_DOC_NLIST,

    },

    {

      .type     = PT_INT,

      .id       = "num_svc",

      .name     = N_("# Services"),

      .desc     = N_("The total number of services found on this mux."),

      .opts     = PO_RDONLY | PO_NOSAVE,

      .get      = mpegts_mux_class_get_num_svc,

    },

    {

      .type     = PT_INT,

      .id       = "num_chn",

      .name     = N_("# Channels"),

      .desc     = N_("The number of services on the mux that are "

                     "mapped to channels."),

      .opts     = PO_RDONLY | PO_NOSAVE,

      .get      = mpegts_mux_class_get_num_chn,

    },

    {

       .type     = PT_BOOL,

       .id       = "tsid_zero",

       .name     = N_("Accept zero value for TSID"),

       .off      = offsetof(mpegts_mux_t, mm_tsid_accept_zero_value),

       .opts     = PO_ADVANCED

    },

    {

      .type     = PT_INT,

      .id       = "pmt_06_ac3",

      .name     = N_("AC-3 detection"),

      .desc     = N_("Use AC-3 detection on the mux."),

      .off      = offsetof(mpegts_mux_t, mm_pmt_ac3),

      .def.i    = MM_AC3_STANDARD,

      .list     = mpegts_mux_ac3_list,

      .opts     = PO_HIDDEN | PO_EXPERT | PO_DOC_NLIST,

    },

    {

      .type     = PT_BOOL,

      .id       = "eit_tsid_nocheck",

      .name     = N_("EIT - skip TSID check"),

      .desc     = N_("Skip TSID checking. For when providers use invalid "

                     "Transport Stream IDs."),

      .off      = offsetof(mpegts_mux_t, mm_eit_tsid_nocheck),

      .opts     = PO_HIDDEN | PO_EXPERT

    },

    {}

  }

};

/* ****************************************************************************

 * Class methods

 * ***************************************************************************/

static void

mpegts_mux_display_name ( mpegts_mux_t *mm, char *buf, size_t len )

{

  snprintf(buf, len, "Multiplex [onid:%04X tsid:%04X]",

           mm->mm_onid, mm->mm_tsid);

}

static void

mpegts_mux_do_stop ( mpegts_mux_t *mm, int delconf )

{

  mpegts_mux_instance_t *mmi;

  th_subscription_t *ths;

  mpegts_service_t *s;

  /* Cancel scan */

  mpegts_network_scan_queue_del(mm);

  /* Remove instances */

  while ((mmi = LIST_FIRST(&mm->mm_instances))) {

    mmi->tii_delete((tvh_input_instance_t *)mmi);

  }

  /* Remove raw subscribers */

  while ((ths = LIST_FIRST(&mm->mm_raw_subs))) {

    subscription_unsubscribe(ths, 0);

  }

  /* Delete services */

  while ((s = LIST_FIRST(&mm->mm_services))) {

    service_destroy((service_t*)s, delconf);

  }

  /* Stop PID timer */

  mtimer_disarm(&mm->mm_update_pids_timer);

}

void

mpegts_mux_free ( mpegts_mux_t *mm )

{

  free(mm->mm_provider_network_name);

  free(mm->mm_crid_authority);

  free(mm->mm_charset);

  free(mm);

}

void

mpegts_mux_delete ( mpegts_mux_t *mm, int delconf )

{

  char buf[256];

  idnode_save_check(&mm->mm_id, delconf);

  mpegts_mux_nice_name(mm, buf, sizeof(buf));

  tvhinfo(LS_MPEGTS, "%s (%p) - deleting", buf, mm);

  /* Stop */

  mm->mm_stop(mm, 1, SM_CODE_ABORTED);

  /* Remove from network */

  LIST_REMOVE(mm, mm_network_link);

  /* Real stop */

  mpegts_mux_do_stop(mm, delconf);

  /* Free memory */

  idnode_save_check(&mm->mm_id, 1);

  idnode_unlink(&mm->mm_id);

  mpegts_mux_release(mm);

}

static htsmsg_t *

mpegts_mux_config_save ( mpegts_mux_t *mm, char *filename, size_t fsize )

{

  return NULL;

}

static int

mpegts_mux_is_enabled ( mpegts_mux_t *mm )

{

  return mm->mm_enabled == MM_ENABLE;

}

static int

mpegts_mux_is_epg ( mpegts_mux_t *mm )

{

  return mm->mm_epg;

}

static void

mpegts_mux_create_instances ( mpegts_mux_t *mm )

{

}

static int

mpegts_mux_has_subscribers ( mpegts_mux_t *mm, const char *name )

{

  mpegts_mux_instance_t *mmi = mm->mm_active;

  if (mmi) {

    if (mmi->mmi_input->mi_has_subscription(mmi->mmi_input, mm)) {

      tvhtrace(LS_MPEGTS, "%s - keeping mux", name);

      return 1;

    }

  }

  return 0;

}

static void

mpegts_mux_stop ( mpegts_mux_t *mm, int force, int reason )

{

  char buf[256], buf2[256], *s;

  mpegts_mux_instance_t *mmi = mm->mm_active, *mmi2;

  mpegts_input_t *mi = NULL, *mi2;

  mpegts_pid_t *mp;

  mpegts_pid_sub_t *mps;

  mpegts_mux_nice_name(mm, buf, sizeof(buf));

  if (!force && mpegts_mux_has_subscribers(mm, buf))

    return;

  /* Stop possible recursion */

  if (!mmi) return;

  tvhdebug(LS_MPEGTS, "%s - stopping mux%s", buf, force ? " (forced)" : "");

  mi = mmi->mmi_input;

  assert(mi);

  /* Linked input */

  if (mi->mi_linked) {

    mi2 = mpegts_input_find(mi->mi_linked);

    if (mi2 && (mmi2 = LIST_FIRST(&mi2->mi_mux_active)) != NULL) {

      mpegts_mux_nice_name(mmi2->mmi_mux, buf2, sizeof(buf2));

      if (mmi2 && !mpegts_mux_has_subscribers(mmi2->mmi_mux, buf2)) {

        s = mi2->mi_linked;

        mi2->mi_linked = NULL;

        mpegts_mux_unsubscribe_linked(mi2, NULL);

        mi2->mi_linked = s;

      } else {

        if (!force) {

          tvhtrace(LS_MPEGTS, "%s - keeping subscribed (linked tuner active)", buf);

          return;

        }

      }

    }

  }

  if (mm->mm_active != mmi)

    return;

  mi->mi_stopping_mux(mi, mmi);

  mi->mi_stop_mux(mi, mmi);

  mi->mi_stopped_mux(mi, mmi);

  assert(mm->mm_active == NULL);

  /* Flush all tables */

  tvhtrace(LS_MPEGTS, "%s - flush tables", buf);

  mpegts_table_flush_all(mm);

  tvhtrace(LS_MPEGTS, "%s - mi=%p", buf, (void *)mi);