Tvheadend

:

Option                           | Description

---------------------------------|------------

**All**                          | Include all information.

**Basic**                        | Limited information for low memory devices.

This setting can be overridden on a per-user basis, see [Access Entries](class/access).

:

Option                           | Description

---------------------------------|------------

**All**                          | Include all information.

**Basic**                        | Limited information for low memory devices.

**Basic Alternative (No Hash)**  | Limited information for low memory devices that don't correctly process tv channel names.

This setting can be overridden on a per-user basis, see [Access Entries](class/access).

  dst->aa_xmltv_output_format = src->aa_xmltv_output_format;

  dst->aa_htsp_output_format = src->aa_htsp_output_format;

  a->aa_xmltv_output_format = ae->ae_xmltv_output_format;

  a->aa_htsp_output_format = ae->ae_htsp_output_format;

static htsmsg_t *

access_entry_xmltv_output_format_enum ( void *p, const char *lang )

{

  static struct strtab

  xmltv_output_format_tab[] = {

    { N_("All"),                           ACCESS_XMLTV_OUTPUT_FORMAT_ALL },

    { N_("Basic"),                         ACCESS_XMLTV_OUTPUT_FORMAT_BASIC },

    { N_("Basic Alternative (No Hash)"),   ACCESS_XMLTV_OUTPUT_FORMAT_BASIC_NO_HASH },

  };

  return strtab2htsmsg(xmltv_output_format_tab, 1, lang);

}

static htsmsg_t *

access_entry_htsp_output_format_enum ( void *p, const char *lang )

{

  static struct strtab

  htsp_output_format_tab[] = {

    { N_("All"),                           ACCESS_HTSP_OUTPUT_FORMAT_ALL },

    { N_("Basic"),                         ACCESS_HTSP_OUTPUT_FORMAT_BASIC },

  };

  return strtab2htsmsg(htsp_output_format_tab, 1, lang);

}

PROP_DOC(xmltv_output_format)

PROP_DOC(htsp_output_format)

    {

      .type     = PT_INT,

      .id       = "xmltv_output_format",

      .name     = N_("Format for xmltv output"),

      .desc     = N_("Specify format for xmltv output."),

      .doc      = prop_doc_xmltv_output_format,

      .off      = offsetof(access_entry_t, ae_xmltv_output_format),

      .list     = access_entry_xmltv_output_format_enum,

      .opts     = PO_ADVANCED | PO_DOC_NLIST,

    },

    {

      .type     = PT_INT,

      .id       = "htsp_output_format",

      .name     = N_("Format for htsp output"),

      .desc     = N_("Specify format for htsp output."),

      .doc      = prop_doc_htsp_output_format,

      .off      = offsetof(access_entry_t, ae_htsp_output_format),

      .list     = access_entry_htsp_output_format_enum,

      .opts     = PO_ADVANCED | PO_DOC_NLIST,

    },

enum {

  ACCESS_XMLTV_OUTPUT_FORMAT_ALL = 0,

  ACCESS_XMLTV_OUTPUT_FORMAT_BASIC,

  ACCESS_XMLTV_OUTPUT_FORMAT_BASIC_NO_HASH,

};

enum {

  ACCESS_HTSP_OUTPUT_FORMAT_ALL = 0,

  ACCESS_HTSP_OUTPUT_FORMAT_BASIC,

};

  int ae_xmltv_output_format;

  int ae_htsp_output_format;

  uint32_t  aa_xmltv_output_format;

  uint32_t  aa_htsp_output_format;

channel_get_name ( const channel_t *ch, const char *blank )

  const idnode_list_mapping_t *ilm;

const char *channel_get_name ( const channel_t *ch, const char *blank );

  const int of = htsp->htsp_granted_access->aa_htsp_output_format;

  /* For basic format, we want to skip the large text fields

   * and go straight to doing the low-overhead fields.

   */

  if (of != ACCESS_HTSP_OUTPUT_FORMAT_BASIC) {

    if (htsp->htsp_version < 32) {

      if ((str = epg_broadcast_get_description(e, lang))) {

        htsmsg_add_str(out, "description", str);

        if ((str = epg_broadcast_get_summary(e, lang)))

          htsmsg_add_str(out, "summary", str);

        if ((str = epg_broadcast_get_subtitle(e, lang)))

          htsmsg_add_str(out, "subtitle", str);

      } else if ((str = epg_broadcast_get_summary(e, lang))) {

        htsmsg_add_str(out, "description", str);

        if ((str = epg_broadcast_get_subtitle(e, lang)))

          htsmsg_add_str(out, "subtitle", str);

      } else if ((str = epg_broadcast_get_subtitle(e, lang))) {

        htsmsg_add_str(out, "description", str);

      }

    } else {

      if ((str = epg_broadcast_get_summary(e, lang)))

        htsmsg_add_str(out, "summary", str);

      if ((str = epg_broadcast_get_description(e, lang)))

        htsmsg_add_str(out, "description", str);

    if (e->credits)

      htsmsg_add_msg(out, "credits", htsmsg_copy(e->credits));

    if (e->category)

      string_list_serialize(e->category, out, "category");

    if (e->keyword)

      string_list_serialize(e->keyword, out, "keyword");

  }

                'channel_tag,xmltv_output_format,htsp_output_format,comment';

/** Determine name to use for the channel based on the

 * user's settings. This is done because some TVs have

 * broken parsers that require a "user readable" name

 * for the channel.

 *

 * @param buf Buffer that is used if we return an idnode.

 *

 * @return Buffer containing the name. This might not

 * be the same as the passed in temporary buffer.

 *

 */

static const char *

http_xmltv_channel_get_name(const http_connection_t *hc,

                            const channel_t *ch,

                            char *buf,

                            size_t buf_len)

{

  const int of = hc->hc_access->aa_xmltv_output_format;

  if (of == ACCESS_XMLTV_OUTPUT_FORMAT_BASIC_NO_HASH)

    return channel_get_name(ch, idnode_uuid_as_str(&ch->ch_id, buf));

  else

    return idnode_uuid_as_str(&ch->ch_id, buf);

}

http_xmltv_channel_add(http_connection_t *hc, htsbuf_queue_t *hq, int flags, const char *hostpath, channel_t *ch)

  htsbuf_qprintf(hq, "<channel id=\"");

  htsbuf_append_and_escape_xml(hq, http_xmltv_channel_get_name(hc, ch, ubuf, sizeof ubuf));

  htsbuf_qprintf(hq, "\">\n  <display-name>");

/// Output a start tag for the tag and include a lang="xx" _only_ if we

/// have more than one language. This avoids outputting lots of tags for

/// the common case of only having one language, so is useful for very low

/// memory devices.

#define HTTP_XMLTV_OUTPUT_START_TAG_WITH_LANG(hq,rb_tree,lang_str,tag)  \

  do {                                                                  \

    htsbuf_qprintf(hq, "  <%s", tag);                                   \

    if (rb_tree->entries != 1)                                          \

      htsbuf_qprintf(hq, " lang=\"%s\"", lang_str->lang);               \

    htsbuf_append_str(hq,">");                                          \

  } while(0)

/** Output long description fields of the programme which are

 * not output for basic/limited devices.

http_xmltv_programme_one_long(const http_connection_t *hc,

                              htsbuf_queue_t *hq, const char *hostpath,

                              const channel_t *ch, const epg_broadcast_t *ebc)

      /* Ignore empty sub-titles */

      if (!strempty(lse->str)) {

          HTTP_XMLTV_OUTPUT_START_TAG_WITH_LANG(hq, ebc->subtitle, lse, "sub-title");

          htsbuf_append_and_escape_xml(hq, lse->str);

          htsbuf_append_str(hq, "</sub-title>\n");

        }

      HTTP_XMLTV_OUTPUT_START_TAG_WITH_LANG(hq, ebc->description, lse, "desc");

      HTTP_XMLTV_OUTPUT_START_TAG_WITH_LANG(hq, ebc->summary, lse, "desc");

}

/*

 *

 */

static void

http_xmltv_programme_one(const http_connection_t *hc,

                         htsbuf_queue_t *hq, const char *hostpath,

                         const channel_t *ch, const epg_broadcast_t *ebc)

{

  epg_episode_num_t epnum;

  char start[32], stop[32], ubuf[UUID_HEX_SIZE];

  lang_str_ele_t *lse;

  const int of = hc->hc_access->aa_xmltv_output_format;

  if (ebc->title == NULL) return;

  http_xmltv_time(start, ebc->start);

  http_xmltv_time(stop, ebc->stop);

  htsbuf_qprintf(hq, "<programme start=\"%s\" stop=\"%s\" channel=\"",

                 start, stop);

  htsbuf_append_and_escape_xml(hq, http_xmltv_channel_get_name(hc, ch, ubuf, sizeof ubuf));

  htsbuf_qprintf(hq, "\">\n");

  RB_FOREACH(lse, ebc->title, link) {

    HTTP_XMLTV_OUTPUT_START_TAG_WITH_LANG(hq, ebc->title, lse, "title");

    htsbuf_append_and_escape_xml(hq, lse->str);

    htsbuf_append_str(hq, "</title>\n");

  }

  /* Basic formats are for low-memory devices that

   * only want very basic information.

   */

  if (of != ACCESS_XMLTV_OUTPUT_FORMAT_BASIC &&

      of != ACCESS_XMLTV_OUTPUT_FORMAT_BASIC_NO_HASH) {

    http_xmltv_programme_one_long(hc, hq, hostpath, ch, ebc);

  }

http_xmltv_programme_add(const http_connection_t *hc, htsbuf_queue_t *hq, const char *hostpath, channel_t *ch)

    http_xmltv_programme_one(hc, hq, hostpath, ch, ebc);

  http_xmltv_channel_add(hc, &hc->hc_reply, flags, hostpath, channel);

  http_xmltv_programme_add(hc, &hc->hc_reply, hostpath, channel);

    http_xmltv_channel_add(hc, &hc->hc_reply, flags, hostpath, ch);

    http_xmltv_programme_add(hc, &hc->hc_reply, hostpath, ch);

    http_xmltv_channel_add(hc, &hc->hc_reply, flags, hostpath, ch);

    http_xmltv_programme_add(hc, &hc->hc_reply, hostpath, ch);