/*

   dvbstream

   (C) Dave Chapman <dave@dchapman.com> 2001, 2002.

   (C) Rozhuk Ivan <rozhuk.im@gmail.com> 2016 - 2017

   Original authors: Nico, probably Arpi

   Some code based on dvbstream, 0.4.3-pre3 (CVS checkout),

   http://sourceforge.net/projects/dvbtools/

   Modified for use with MPlayer, for details see the changelog at

   http://svn.mplayerhq.hu/mplayer/trunk/

   $Id$

   Copyright notice:

   This file is part of mpv.

   mpv 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 2 of the License, or

   (at your option) any later version.

   mpv 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 mpv.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "config.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/ioctl.h>

#include <sys/time.h>

#include <poll.h>

#include <unistd.h>

#include <fcntl.h>

#include <errno.h>

#include "osdep/io.h"

#include "misc/ctype.h"

#include "osdep/timer.h"

#include "stream.h"

#include "common/tags.h"

#include "options/m_config.h"

#include "options/m_option.h"

#include "options/options.h"

#include "options/path.h"

#include "osdep/io.h"

#include "osdep/poll_wrapper.h"

#include "osdep/threads.h"

#include "dvbin.h"

#include "dvb_tune.h"

#if !HAVE_GPL

#error GPL only

#endif

#define CHANNEL_LINE_LEN 256

#define OPT_BASE_STRUCT dvb_opts_t

static dvb_state_t *global_dvb_state = NULL;

static mp_static_mutex global_dvb_state_lock = MP_STATIC_MUTEX_INITIALIZER;

const struct m_sub_options stream_dvb_conf = {

    .opts = (const m_option_t[]) {

        {"prog", OPT_STRING(cfg_prog), .flags = UPDATE_DVB_PROG},

        {"card", OPT_INT(cfg_devno), M_RANGE(0, MAX_ADAPTERS-1)},

        {"timeout", OPT_FLOAT(cfg_timeout), M_RANGE(0, FLT_MAX)},

        {"file", OPT_STRING(cfg_file), .flags = M_OPT_FILE},

        {"full-transponder", OPT_BOOL(cfg_full_transponder)},

        {"channel-switch-offset", OPT_INT(cfg_channel_switch_offset),

            .flags = UPDATE_DVB_PROG},

        {0}

    },

    .size = sizeof(dvb_opts_t),

    .defaults = &(const dvb_opts_t){

        .cfg_prog = NULL,

        .cfg_timeout = 30,

    },

};

void dvbin_close(stream_t *stream);

static fe_code_rate_t parse_fec(const char *cr)

{

    if (!strcmp(cr, "FEC_1_2")) {

        return FEC_1_2;

    } else if (!strcmp(cr, "FEC_2_3")) {

        return FEC_2_3;

    } else if (!strcmp(cr, "FEC_3_4")) {

        return FEC_3_4;

    } else if (!strcmp(cr, "FEC_4_5")) {

        return FEC_4_5;

    } else if (!strcmp(cr, "FEC_5_6")) {

        return FEC_5_6;

    } else if (!strcmp(cr, "FEC_6_7")) {

        return FEC_6_7;

    } else if (!strcmp(cr, "FEC_7_8")) {

        return FEC_7_8;

    } else if (!strcmp(cr, "FEC_8_9")) {

        return FEC_8_9;

    } else if (!strcmp(cr, "FEC_NONE")) {

        return FEC_NONE;

    }

    return FEC_NONE;

}

static fe_modulation_t parse_vdr_modulation(const char** modstring)

{

    static const struct { const char *s; fe_modulation_t v; } table[] = {

        { "16",  QAM_16 },

        { "32",  QAM_32 },

        { "64",  QAM_64 },

        { "128", QAM_128 },

        { "256", QAM_256 },

        { "998", QAM_AUTO },

        { "2",   QPSK },

        { "5",   PSK_8 },

        { "6",   APSK_16 },

        { "7",   APSK_32 },

        { "10",  VSB_8 },

        { "11",  VSB_16 },

        { "12",  DQPSK },

    };

    for (int i = 0; i < MP_ARRAY_SIZE(table); i++) {

        if (!strncmp(*modstring, table[i].s, strlen(table[i].s))) {

            *modstring += strlen(table[i].s);

            return table[i].v;

        }

    }

    return QAM_AUTO;

}

static void parse_vdr_par_string(const char *vdr_par_str, dvb_channel_t *ptr)

{

    //FIXME: There is more information in this parameter string, especially related

    // to non-DVB-S reception.

    if (!vdr_par_str[0])

        return;

    const char *vdr_par = &vdr_par_str[0];

    while (vdr_par && *vdr_par) {

        switch (mp_toupper(*vdr_par)) {

        case 'H':

            ptr->pol = 'H';

            vdr_par++;

            break;

        case 'V':

            ptr->pol = 'V';

            vdr_par++;

            break;

        case 'S':

            vdr_par++;

            ptr->is_dvb_x2 = *vdr_par == '1';

            vdr_par++;

            break;

        case 'P':

            vdr_par++;

            char *endptr = NULL;

            errno = 0;

            int n = strtol(vdr_par, &endptr, 10);

            if (!errno && endptr != vdr_par) {

                ptr->stream_id = n;

                vdr_par = endptr;

            }

            break;

        case 'I':

            vdr_par++;

            ptr->inv = (*vdr_par == '1') ? INVERSION_ON : INVERSION_OFF;

            vdr_par++;

            break;

        case 'M':

            vdr_par++;

            ptr->mod = parse_vdr_modulation(&vdr_par);

            break;

        default:

            vdr_par++;

        }

    }

}

static char *dvb_strtok_r(char *s, const char *sep, char **p)

{

    if (!s && !(s = *p))

        return NULL;

    /* Skip leading separators. */

    s += strspn(s, sep);

    /* s points at first non-separator, or end of string. */

    if (!*s)

        return *p = 0;

    /* Move *p to next separator. */

    *p = s + strcspn(s, sep);

    if (**p) {

        *(*p)++ = 0;

    } else {

        *p = 0;

    }

    return s;

}

static bool parse_pid_string(struct mp_log *log, char *pid_string,

                             dvb_channel_t *ptr)

{

    if (!pid_string[0])

        return false;

    int pcnt = 0;

    /* These tokens also catch vdr-style PID lists.

     * They can contain 123=deu@3,124=eng+jap@4;125

     * 3 and 4 are codes for codec type, =langLeft+langRight is allowed,

     * and ; may separate a dolby channel.

     * With the numChars-test and the full token-list, all is handled

     * gracefully.

     */

    const char *tokens = "+,;";

    char *pidPart;

    char *savePtr = NULL;

    pidPart = dvb_strtok_r(pid_string, tokens, &savePtr);

    while (pidPart != NULL) {

        if (ptr->pids_cnt >= DMX_FILTER_SIZE - 1) {

            mp_verbose(log, "Maximum number of PIDs for one channel "

                            "reached, ignoring further ones!\n");

            break;

        }

        int numChars = 0;

        int pid = 0;

        pcnt += sscanf(pidPart, "%d%n", &pid, &numChars);

        if (numChars > 0) {

            ptr->pids[ptr->pids_cnt] = pid;

            ptr->pids_cnt++;

        }

        pidPart = dvb_strtok_r(NULL, tokens, &savePtr);

    }

    return pcnt > 0;

}

static dvb_channels_list_t *dvb_get_channels(struct mp_log *log,

                                           dvb_channels_list_t *list_add,

                                           int cfg_full_transponder,

                                           char *filename,

                                           unsigned int frontend,

                                           int delsys, unsigned int delsys_mask)

{

    dvb_channels_list_t *list = list_add;

    if (!filename)

        return list;

    const char *cbl_conf =

        "%d:%255[^:]:%d:%255[^:]:%255[^:]:%255[^:]:%255[^:]\n";

    const char *sat_conf = "%d:%c:%d:%d:%255[^:]:%255[^:]\n";

    const char *ter_conf =

        "%d:%255[^:]:%255[^:]:%255[^:]:%255[^:]:%255[^:]:%255[^:]:%255[^:]:%255[^:]:%255[^:]:%255[^:]\n";

    const char *atsc_conf = "%d:%255[^:]:%255[^:]:%255[^:]\n";

    const char *vdr_conf =

        "%d:%255[^:]:%255[^:]:%d:%255[^:]:%255[^:]:%255[^:]:%*255[^:]:%d:%*d:%*d:%*d\n%n";

    mp_verbose(log, "Reading config file %s for type %s\n",

               filename, get_dvb_delsys(delsys));

    FILE *f = fopen(filename, "r");

    if (!f) {

        mp_fatal(log, "Can't open file %s\n", filename);

        return list;

    }

    if (!list)

        list = talloc_zero(NULL, dvb_channels_list_t);

    while (!feof(f)) {

        char line[CHANNEL_LINE_LEN];

        if (!fgets(line, CHANNEL_LINE_LEN, f))

            continue;

        if (line[0] == '#' || strlen(line) == 0)

            continue;

        dvb_channel_t chn = {0};

        dvb_channel_t *ptr = &chn;

        char tmp_lcr[256], tmp_hier[256], inv[256], bw[256], cr[256], mod[256],

            transm[256], gi[256], vpid_str[256], apid_str[256], tpid_str[256],

            vdr_par_str[256], vdr_loc_str[256];

        vpid_str[0] = apid_str[0] = tpid_str[0] = 0;

        vdr_loc_str[0] = vdr_par_str[0] = 0;

        tmp_lcr[0] = tmp_hier[0] = inv[0] = bw[0] = 0;

        cr[0] = mod[0] = transm[0] = gi[0] = 0;

        char *colon = strchr(line, ':');

        if (!colon)

            continue;

        int k = colon - line;

        if (!k)

            continue;

        // In some modern VDR-style configs, channel name also has bouquet after ;.

        // Parse that off, we ignore it.

        char *bouquet_sep = strchr(line, ';');

        {

            int namelen = k;

            if (bouquet_sep && bouquet_sep < colon)

                namelen = bouquet_sep - line;

            ptr->name = talloc_strndup(list, line, namelen);

        }

        k++;

        ptr->pids_cnt = 0;

        ptr->freq = 0;

        ptr->service_id = -1;

        ptr->is_dvb_x2 = false;

        ptr->frontend = frontend;

        ptr->delsys = delsys;

        ptr->diseqc = 0;

        ptr->stream_id = NO_STREAM_ID_FILTER;

        ptr->inv = INVERSION_AUTO;

        ptr->bw = BANDWIDTH_AUTO;

        ptr->cr = FEC_AUTO;

        ptr->cr_lp = FEC_AUTO;

        ptr->mod = QAM_AUTO;

        ptr->hier = HIERARCHY_AUTO;

        ptr->gi = GUARD_INTERVAL_AUTO;

        ptr->trans = TRANSMISSION_MODE_AUTO;

        // Check if VDR-type channels.conf-line - then full line is consumed by the scan.

        int fields, num_chars = 0;

        fields = sscanf(&line[k], vdr_conf,

                        &ptr->freq, vdr_par_str, vdr_loc_str, &ptr->srate,

                        vpid_str, apid_str, tpid_str, &ptr->service_id,

                        &num_chars);

        bool is_vdr_conf = (num_chars == strlen(&line[k]));

        // Special case: DVB-T style ZAP config also has 13 columns.

        // Most columns should have non-numeric content, but some channel list generators insert 0

        // if a value is not used. However, INVERSION_* should always set after frequency.

        if (is_vdr_conf && !strncmp(vdr_par_str, "INVERSION_", 10)) {

            is_vdr_conf = false;

        }

        if (is_vdr_conf) {

            // Modulation parsed here, not via old xine-parsing path.

            mod[0] = '\0';

            // It's a VDR-style config line.

            parse_vdr_par_string(vdr_par_str, ptr);

            // Frequency in VDR-style config files is in MHz for DVB-S,

            // and may be in MHz, kHz or Hz for DVB-C and DVB-T.

            // General rule to get useful units is to multiply by 1000 until value is larger than 1000000.

            while (ptr->freq < 1000000U) {

                ptr->freq *= 1000U;

            }

            // Symbol rate in VDR-style config files is divided by 1000.

            ptr->srate *= 1000U;

            switch (delsys) {

            case SYS_DVBT:

            case SYS_DVBT2:

                /* Fix delsys value. */

                if (ptr->is_dvb_x2) {

                    ptr->delsys = delsys = SYS_DVBT2;

                } else {

                    ptr->delsys = delsys = SYS_DVBT;

                }

                if (!DELSYS_IS_SET(delsys_mask, delsys))

                    continue; /* Skip channel. */

                mp_verbose(log, "VDR, %s, NUM: %d, NUM_FIELDS: %d, NAME: %s, "

                           "FREQ: %d, SRATE: %d, T2: %s\n",

                           get_dvb_delsys(delsys),

                           list->NUM_CHANNELS, fields,

                           ptr->name, ptr->freq, ptr->srate,

                           (delsys == SYS_DVBT2) ? "yes" : "no");

                break;

            case SYS_DVBC_ANNEX_A:

            case SYS_DVBC_ANNEX_C:

            case SYS_ATSC:

            case SYS_DVBC_ANNEX_B:

            case SYS_ISDBT:

                mp_verbose(log, "VDR, %s, NUM: %d, NUM_FIELDS: %d, NAME: %s, "

                           "FREQ: %d, SRATE: %d\n",

                           get_dvb_delsys(delsys),

                           list->NUM_CHANNELS, fields,

                           ptr->name, ptr->freq, ptr->srate);

                break;

            case SYS_DVBS:

            case SYS_DVBS2:

                /* Fix delsys value. */

                if (ptr->is_dvb_x2) {

                    ptr->delsys = delsys = SYS_DVBS2;

                } else {

                    ptr->delsys = delsys = SYS_DVBS;

                }

                if (!DELSYS_IS_SET(delsys_mask, delsys))

                    continue; /* Skip channel. */

                if (vdr_loc_str[0]) {

                    // In older vdr config format, this field contained the DISEQc information.

                    // If it is numeric, assume that's it.

                    int diseqc_info = 0;

                    int valid_digits = 0;

                    if (sscanf(vdr_loc_str, "%d%n", &diseqc_info,

                               &valid_digits) == 1)

                    {

                        if (valid_digits == strlen(vdr_loc_str)) {

                            ptr->diseqc = (unsigned int)diseqc_info;

                            if (ptr->diseqc > 4)

                                continue;

                            if (ptr->diseqc > 0)

                                ptr->diseqc--;

                        }

                    }

                }

                mp_verbose(log, "VDR, %s, NUM: %d, NUM_FIELDS: %d, NAME: %s, "

                           "FREQ: %d, SRATE: %d, POL: %c, DISEQC: %d, S2: %s, "

                           "StreamID: %d, SID: %d\n",

                           get_dvb_delsys(delsys),

                           list->NUM_CHANNELS,

                           fields, ptr->name, ptr->freq, ptr->srate, ptr->pol,

                           ptr->diseqc, (delsys == SYS_DVBS2) ? "yes" : "no",

                           ptr->stream_id, ptr->service_id);

                break;

            default:

                break;

            }

        } else {

            // ZAP style channel config file.

            switch (delsys) {

            case SYS_DVBT:

            case SYS_DVBT2:

            case SYS_ISDBT:

                fields = sscanf(&line[k], ter_conf,

                                &ptr->freq, inv, bw, cr, tmp_lcr, mod,

                                transm, gi, tmp_hier, vpid_str, apid_str);

                mp_verbose(log, "%s, NUM: %d, NUM_FIELDS: %d, NAME: %s, FREQ: %d\n",

                           get_dvb_delsys(delsys), list->NUM_CHANNELS,

                           fields, ptr->name, ptr->freq);

                break;

            case SYS_DVBC_ANNEX_A:

            case SYS_DVBC_ANNEX_C:

                fields = sscanf(&line[k], cbl_conf,

                                &ptr->freq, inv, &ptr->srate,

                                cr, mod, vpid_str, apid_str);

                mp_verbose(log, "%s, NUM: %d, NUM_FIELDS: %d, NAME: %s, FREQ: %d, "

                           "SRATE: %d\n",

                           get_dvb_delsys(delsys),

                           list->NUM_CHANNELS, fields, ptr->name,

                           ptr->freq, ptr->srate);

                break;

            case SYS_ATSC:

            case SYS_DVBC_ANNEX_B:

                fields = sscanf(&line[k], atsc_conf,

                                &ptr->freq, mod, vpid_str, apid_str);

                mp_verbose(log, "%s, NUM: %d, NUM_FIELDS: %d, NAME: %s, FREQ: %d\n",

                           get_dvb_delsys(delsys), list->NUM_CHANNELS,

                           fields, ptr->name, ptr->freq);

                break;

            case SYS_DVBS:

            case SYS_DVBS2:

                fields = sscanf(&line[k], sat_conf,

                                &ptr->freq, &ptr->pol, &ptr->diseqc, &ptr->srate,

                                vpid_str,

                                apid_str);

                ptr->pol = mp_toupper(ptr->pol);

                ptr->freq *= 1000U;

                ptr->srate *= 1000U;

                if (ptr->diseqc > 4)

                    continue;

                if (ptr->diseqc > 0)

                    ptr->diseqc--;

                mp_verbose(log, "%s, NUM: %d, NUM_FIELDS: %d, NAME: %s, FREQ: %d, "

                           "SRATE: %d, POL: %c, DISEQC: %d\n",

                           get_dvb_delsys(delsys),

                           list->NUM_CHANNELS, fields, ptr->name, ptr->freq,

                           ptr->srate, ptr->pol, ptr->diseqc);

                break;

            default:

                break;

            }

        }

        if (parse_pid_string(log, vpid_str, ptr))

            fields++;

        if (parse_pid_string(log, apid_str, ptr))

            fields++;

                 /* If we do not know the service_id, PMT can not be extracted.

                    Teletext decoding will fail without PMT. */

        if (ptr->service_id != -1) {

            if (parse_pid_string(log, tpid_str, ptr))

                fields++;

        }

        if (fields < 2 || ptr->pids_cnt == 0 || ptr->freq == 0 ||

            strlen(ptr->name) == 0)

            continue;

        /* Add some PIDs which are mandatory in DVB,

         * and contain human-readable helpful data. */

        /* This is the STD, the service description table.

         * It contains service names and such, ffmpeg decodes it. */

        ptr->pids[ptr->pids_cnt] = 0x0011;

        ptr->pids_cnt++;

        /* This is the EIT, which contains EPG data.

         * ffmpeg can not decode it (yet), but e.g. VLC

         * shows what was recorded. */

        ptr->pids[ptr->pids_cnt] = 0x0012;

        ptr->pids_cnt++;

        if (ptr->service_id != -1) {

            /* We have the PMT-PID in addition.

               This will be found later, when we tune to the channel.

               Push back here to create the additional demux. */

            ptr->pids[ptr->pids_cnt] = -1;       // Placeholder.

            ptr->pids_cnt++;

        }

        bool has8192 = false, has0 = false;

        for (int cnt = 0; cnt < ptr->pids_cnt; cnt++) {

            if (ptr->pids[cnt] == 8192)

                has8192 = true;

            if (ptr->pids[cnt] == 0)

                has0 = true;

        }

        /* 8192 is the pseudo-PID for full TP dump,

           enforce that if requested. */

        if (!has8192 && cfg_full_transponder)

            has8192 = 1;

        if (has8192) {

            ptr->pids[0] = 8192;

            ptr->pids_cnt = 1;

        } else if (!has0) {

            ptr->pids[ptr->pids_cnt] = 0;               //PID 0 is the PAT

            ptr->pids_cnt++;

        }

        mp_verbose(log, " PIDS: ");

        for (int cnt = 0; cnt < ptr->pids_cnt; cnt++)

            mp_verbose(log, " %d ", ptr->pids[cnt]);

        mp_verbose(log, "\n");

        switch (delsys) {

        case SYS_DVBT:

        case SYS_DVBT2:

        case SYS_ISDBT:

        case SYS_DVBC_ANNEX_A:

        case SYS_DVBC_ANNEX_C:

            if (!strcmp(inv, "INVERSION_ON")) {

                ptr->inv = INVERSION_ON;

            } else if (!strcmp(inv, "INVERSION_OFF")) {

                ptr->inv = INVERSION_OFF;

            }

            ptr->cr = parse_fec(cr);

        }

        switch (delsys) {

        case SYS_DVBT:

        case SYS_DVBT2:

        case SYS_ISDBT:

        case SYS_DVBC_ANNEX_A:

        case SYS_DVBC_ANNEX_C:

        case SYS_ATSC:

        case SYS_DVBC_ANNEX_B:

            if (!strcmp(mod, "QAM_128")) {

                ptr->mod = QAM_128;

            } else if (!strcmp(mod, "QAM_256")) {

                ptr->mod = QAM_256;

            } else if (!strcmp(mod, "QAM_64")) {

                ptr->mod = QAM_64;

            } else if (!strcmp(mod, "QAM_32")) {

                ptr->mod = QAM_32;

            } else if (!strcmp(mod, "QAM_16")) {

                ptr->mod = QAM_16;

            } else if (!strcmp(mod, "VSB_8") || !strcmp(mod, "8VSB")) {

                ptr->mod = VSB_8;

            } else if (!strcmp(mod, "VSB_16") || !strcmp(mod, "16VSB")) {

                ptr->mod = VSB_16;

            }

        }

        /* Modulation defines real delsys for ATSC:

           Terrestrial (VSB) is SYS_ATSC, Cable (QAM) is SYS_DVBC_ANNEX_B. */

        if (delsys == SYS_ATSC || delsys == SYS_DVBC_ANNEX_B) {

            if (ptr->mod == VSB_8 || ptr->mod == VSB_16) {

                delsys = SYS_ATSC;

            } else {

                delsys = SYS_DVBC_ANNEX_B;

            }

            if (!DELSYS_IS_SET(delsys_mask, delsys))

                continue; /* Skip channel. */

            mp_verbose(log, "Switched to delivery system for ATSC: %s (guessed from modulation)\n",

                       get_dvb_delsys(delsys));

        }

        switch (delsys) {

        case SYS_DVBT:

        case SYS_DVBT2:

        case SYS_ISDBT:

            if (!strcmp(bw, "BANDWIDTH_5_MHZ")) {

                ptr->bw = BANDWIDTH_5_MHZ;

            } else if (!strcmp(bw, "BANDWIDTH_6_MHZ")) {

                ptr->bw = BANDWIDTH_6_MHZ;

            } else if (!strcmp(bw, "BANDWIDTH_7_MHZ")) {

                ptr->bw = BANDWIDTH_7_MHZ;

            } else if (!strcmp(bw, "BANDWIDTH_8_MHZ")) {

                ptr->bw = BANDWIDTH_8_MHZ;

            } else if (!strcmp(bw, "BANDWIDTH_10_MHZ")) {

                ptr->bw = BANDWIDTH_10_MHZ;

            }

            if (!strcmp(transm, "TRANSMISSION_MODE_2K")) {

                ptr->trans = TRANSMISSION_MODE_2K;

            } else if (!strcmp(transm, "TRANSMISSION_MODE_8K")) {

                ptr->trans = TRANSMISSION_MODE_8K;

            } else if (!strcmp(transm, "TRANSMISSION_MODE_AUTO")) {

                ptr->trans = TRANSMISSION_MODE_AUTO;

            }

            if (!strcmp(gi, "GUARD_INTERVAL_1_32")) {

                ptr->gi = GUARD_INTERVAL_1_32;

            } else if (!strcmp(gi, "GUARD_INTERVAL_1_16")) {

                ptr->gi = GUARD_INTERVAL_1_16;

            } else if (!strcmp(gi, "GUARD_INTERVAL_1_8")) {

                ptr->gi = GUARD_INTERVAL_1_8;

            } else if (!strcmp(gi, "GUARD_INTERVAL_1_4")) {

                ptr->gi = GUARD_INTERVAL_1_4;

            }

            ptr->cr_lp = parse_fec(tmp_lcr);

            if (!strcmp(tmp_hier, "HIERARCHY_1")) {

                ptr->hier = HIERARCHY_1;

            } else if (!strcmp(tmp_hier, "HIERARCHY_2")) {

                ptr->hier = HIERARCHY_2;

            } else if (!strcmp(tmp_hier, "HIERARCHY_4")) {

                ptr->hier = HIERARCHY_4;

            } else if (!strcmp(tmp_hier, "HIERARCHY_NONE")) {

                ptr->hier = HIERARCHY_NONE;

            }

        }

        MP_TARRAY_APPEND(list, list->channels, list->NUM_CHANNELS, *ptr);

    }

    fclose(f);

    if (list->NUM_CHANNELS == 0)

        TA_FREEP(&list);

    return list;

}

static int dvb_streaming_read(stream_t *stream, void *buffer, int size)

{

    dvb_priv_t *priv = stream->priv;

    dvb_state_t *state = priv->state;

    int pos = 0;

    int tries = state->retry;

    const int fd = state->dvr_fd;

    MP_TRACE(stream, "dvb_streaming_read(%d)\n", size);

    struct pollfd pfds[1];

    pfds[0].fd = fd;

    pfds[0].events = POLLIN | POLLPRI;

    while (pos < size) {

        int rk = read(fd, (char *)buffer + pos, (size - pos));

        if (rk <= 0) {

            if (pos || tries == 0)

                break;

            tries--;

            if (mp_poll(pfds, 1, MP_TIME_S_TO_NS(2)) <= 0) {

                MP_ERR(stream, "dvb_streaming_read: failed with "

                        "errno %d when reading %d bytes\n", errno, size - pos);

                errno = 0;

                break;

            }

            continue;

        }

        pos += rk;

        MP_TRACE(stream, "got %d bytes\n", pos);

    }

    if (!pos)

        MP_ERR(stream, "dvb_streaming_read: returning 0 bytes\n");

    // Check if config parameters have been updated.

    dvb_update_config(stream);

    return pos;

}

int dvb_set_channel(stream_t *stream, unsigned int adapter, unsigned int n)

{

    dvb_priv_t *priv = stream->priv;

    dvb_state_t *state = priv->state;

    mp_assert(adapter < state->adapters_count);

    int devno = state->adapters[adapter].devno;

    dvb_channels_list_t *new_list = state->adapters[adapter].list;

    mp_assert(n < new_list->NUM_CHANNELS);

    dvb_channel_t *channel = &(new_list->channels[n]);

    if (state->is_on) {  //the fds are already open and we have to stop the demuxers

        /* Remove all demuxes. */

        dvb_fix_demuxes(priv, 0);

        state->retry = 0;

        // empty both the stream's and driver's buffer

        char buf[4096];

        while (dvb_streaming_read(stream, buf, sizeof(buf)) > 0) {}

        if (state->cur_adapter != adapter ||

            state->cur_frontend != channel->frontend) {

            dvbin_close(stream);

            if (!dvb_open_devices(priv, devno, channel->frontend, channel->pids_cnt)) {

                MP_ERR(stream, "dvb_set_channel: couldn't open devices of adapter "

                    "%d\n", devno);

                return 0;

            }

        } else {

            // close all demux_fds with pos > pids required for the new channel

            // or open other demux_fds if we have too few

            if (!dvb_fix_demuxes(priv, channel->pids_cnt))

                return 0;

        }

    } else {

        if (!dvb_open_devices(priv, devno, channel->frontend, channel->pids_cnt)) {

            MP_ERR(stream, "dvb_set_channel: couldn't open devices of adapter "

                    "%d\n", devno);

            return 0;

        }

    }

    state->retry = 5;

    new_list->current = n;

    MP_VERBOSE(stream, "dvb_set_channel: new channel name=\"%s\", adapter: %d, "

               "channel: %d\n", channel->name, devno, n);

    if (channel->freq != state->last_freq) {

        if (!dvb_tune(priv, channel->delsys, channel->freq,

                      channel->pol, channel->srate, channel->diseqc,

                      channel->stream_id, channel->inv,

                      channel->mod, channel->gi,

                      channel->trans, channel->bw, channel->cr, channel->cr_lp,

                      channel->hier, priv->opts->cfg_timeout))

            return 0;

    }

    state->is_on = true;

    state->last_freq = channel->freq;

    state->cur_adapter = adapter;

    state->cur_frontend = channel->frontend;

    if (channel->service_id != -1) {

        /* We need the PMT-PID in addition.

           If it has not yet beem resolved, do it now. */

        for (int i = 0; i < channel->pids_cnt; i++) {

            if (channel->pids[i] == -1) {

                MP_VERBOSE(stream, "dvb_set_channel: PMT-PID for service %d "

                           "not resolved yet, parsing PAT...\n",

                           channel->service_id);

                int pmt_pid = dvb_get_pmt_pid(priv, adapter, channel->service_id);

                MP_VERBOSE(stream, "found PMT-PID: %d\n", pmt_pid);

                channel->pids[i] = pmt_pid;

                break;

            }

        }

    }

    // sets demux filters and restart the stream

    for (int i = 0; i < channel->pids_cnt; i++) {

        if (channel->pids[i] == -1) {

            // In case PMT was not resolved, skip it here.

            MP_ERR(stream, "dvb_set_channel: PMT-PID not found, "

                           "teletext decoding may fail.\n");

            continue;

        }

        if (!dvb_set_ts_filt(priv, state->demux_fds[i], channel->pids[i],

                             DMX_PES_OTHER))

            return 0;

    }

    return 1;

}

static int dvbin_stream_control(struct stream *s, int cmd, void *arg)

{

    dvb_priv_t *priv = s->priv;

    dvb_state_t *state = priv->state;

    if (state->cur_adapter >= state->adapters_count)

        return STREAM_ERROR;

    dvb_channels_list_t *list = state->adapters[state->cur_adapter].list;

    switch (cmd) {

    case STREAM_CTRL_GET_METADATA: {

        struct mp_tags *metadata = talloc_zero(NULL, struct mp_tags);

        char *progname = list->channels[list->current].name;

        mp_tags_set_str(metadata, "title", progname);

        *(struct mp_tags **)arg = metadata;

        return STREAM_OK;

    }

    }

    return STREAM_UNSUPPORTED;

}

void dvbin_close(stream_t *stream)

{

    dvb_priv_t *priv = stream->priv;

    dvb_state_t *state = priv->state;

    if (state->switching_channel && state->is_on) {

        // Prevent state destruction, reset channel-switch.

        state->switching_channel = false;

        mp_mutex_lock(&global_dvb_state_lock);

        global_dvb_state->stream_used = false;

        mp_mutex_unlock(&global_dvb_state_lock);

        return;

    }

    for (int i = state->demux_fds_cnt - 1; i >= 0; i--) {

        state->demux_fds_cnt--;

        close(state->demux_fds[i]);

    }

    close(state->dvr_fd);

    close(state->fe_fd);

    state->fe_fd = state->dvr_fd = -1;

    state->is_on = false;

    state->cur_adapter = -1;

    state->cur_frontend = -1;

    mp_mutex_lock(&global_dvb_state_lock);

    TA_FREEP(&global_dvb_state);

    mp_mutex_unlock(&global_dvb_state_lock);

}

static int dvb_streaming_start(stream_t *stream, char *progname)

{

    dvb_priv_t *priv = stream->priv;

    dvb_state_t *state = priv->state;

    if (!progname)

        return 0;