Ticket #1133: 1133-v8.patch

File 1133-v8.patch, 33.1 KB (added by danielk, 15 years ago)

Some fixes

  • libs/libmythtv/cardutil.h

     
    7070
    7171    static int          GetCardID(const QString &videodevice,
    7272                                  QString hostname = QString::null);
     73    static uint         GetChildCardID(uint cardid);
     74    static uint         GetParentCardID(uint cardid);
    7375
    7476    static bool         IsCardTypePresent(const QString &strType);
    7577
     
    8183    static bool         GetVideoDevice(uint cardid, QString& device,
    8284                                       QString& vbi);
    8385    static QString      GetVideoDevice(uint cardid);
     86    static QString      GetVideoDevice(uint cardid, uint sourceid);
    8487
    8588    static QString      GetDefaultInput(uint cardid);
    8689    static QString      GetInputName(uint cardid, uint sourceid);
     
    9699                                      QString             device,
    97100                                      QString             cardtype,
    98101                                      QStringList        &inputLabels,
    99                                       vector<CardInput*> &cardInputs);
     102                                      vector<CardInput*> &cardInputs,
     103                                      int                 parentid = 0);
    100104    // DTV info
    101105    static bool         GetTimeouts(uint cardid,
    102106                                    uint &signal_timeout,
     
    119123  private:
    120124    static QStringList  probeV4LInputs(QString device);
    121125    static QStringList  probeDVBInputs(QString device, int diseqctype = -1);
     126    static QStringList  probeChildInputs(QString device);
    122127
    123128    static QStringList  fillDVBInputs(int dvb_diseqc_type);
    124129    static DiSEqCList   fillDVBInputsDiSEqC(int dvb_diseqc_type);
  • libs/libmythtv/videosource.h

     
    262262    DVBCardType        *cardtype;
    263263    SignalTimeout      *signal_timeout;
    264264    ChannelTimeout     *channel_timeout;
     265    TransButtonSetting *buttonAnalog;
    265266};
    266267
    267268class CaptureCardGroup: public VerticalConfigurationGroup,
     
    277278class CaptureCard: public ConfigurationWizard {
    278279    Q_OBJECT
    279280public:
    280     CaptureCard();
     281    CaptureCard(bool use_card_group = true);
    281282
    282283    int  getCardID(void) const { return id->intValue(); }
    283284
    284285    void loadByID(int id);
     286    void setParentID(int id);
    285287
    286288    static void fillSelections(SelectSetting* setting);
     289    static void fillSelections(SelectSetting* setting, bool no_children);
    287290
    288291    void load() {
    289292        ConfigurationWizard::load();
     
    291294
    292295public slots:
    293296    void DiSEqCPanel();
     297    void analogPanel();
    294298    void recorderOptionsPanel();
    295299
    296300private:
     
    306310        };
    307311    };
    308312
     313    class ParentID: public CCSetting
     314    {
     315      public:
     316        ParentID(const CaptureCard &parent) : CCSetting(parent, "parentid")
     317        {
     318            setValue("0");
     319            setVisible(false);
     320        }
     321    };
     322
    309323    class Hostname: public HostnameSetting, public CCSetting {
    310324    public:
    311325        Hostname(const CaptureCard& parent): CCSetting(parent, "hostname") {};
     
    313327
    314328private:
    315329    ID       *id;
     330    ParentID *parentid;
    316331};
    317332
    318333class CardInput;
     
    414429};
    415430
    416431class CardID;
     432class ChildID;
    417433class InputName;
    418434class SourceID;
    419435class DVBLNBChooser;
     
    436452    QString getSourceName(void) const;
    437453
    438454    void fillDiseqcSettingsInput(QString _pos, QString _port);
     455    void SetChildCardID(uint);
    439456
    440457    virtual void save();
    441458    virtual void save(QString /*destination*/) { save(); }
     
    465482
    466483    ID              *id;
    467484    CardID          *cardid;
     485    ChildID         *childid;
    468486    InputName       *inputname;
    469487    SourceID        *sourceid;
    470488    DVBLNBChooser   *lnbsettings;
  • libs/libmythtv/remoteencoder.h

     
    22#define REMOTEENCODER_H_
    33
    44#include <qstringlist.h>
    5 #include <pthread.h>
     5#include <qmutex.h>
    66#include <qmap.h>
    77
    88class ProgramInfo;
     
    7272    int recordernum;
    7373
    7474    QSocketDevice *controlSock;
    75     pthread_mutex_t lock;
     75    QMutex lock;
    7676
    7777    QString remotehost;
    7878    short remoteport;
     
    8181
    8282    bool backendError;
    8383    long long cachedFramesWritten;
    84     uint cachedTimeout;
     84    QMap<QString,uint> cachedTimeout;
    8585};
    8686
    8787#endif
  • libs/libmythtv/cardutil.cpp

     
    216216    return QString::null;
    217217}
    218218
     219QString CardUtil::GetVideoDevice(uint cardid, uint sourceid)
     220{
     221    QString device = QString::null;
     222
     223    MSqlQuery query(MSqlQuery::InitCon());
     224    query.prepare("SELECT videodevice "
     225                  "FROM capturecard, cardinput "
     226                  "WHERE sourceid         = :SOURCEID AND "
     227                  "      cardinput.cardid = :CARDID   AND "
     228                  "      ( ( cardinput.childcardid != '0' AND "
     229                  "          cardinput.childcardid  = capturecard.cardid ) OR "
     230                  "        ( cardinput.childcardid  = '0' AND "
     231                  "          cardinput.cardid       = capturecard.cardid ) )");
     232    query.bindValue(":CARDID", cardid);
     233    query.bindValue(":SOURCEID", sourceid);
     234
     235    if (!query.exec() || !query.isActive())
     236        MythContext::DBError("CardUtil::GetVideoDevice() 2", query);
     237    else if (query.next())
     238        device = query.value(0).toString();
     239
     240    return device;   
     241}
     242
    219243/** \fn CardUtil::GetCardID(const QString&, QString)
    220244 *  \brief Returns the cardid of the card that uses the specified
    221245 *         videodevice, and optionally a non-local hostname.
     
    244268    return -1;
    245269}
    246270
     271uint CardUtil::GetChildCardID(uint cardid)
     272{
     273    // check if child card definition does exist
     274    MSqlQuery query(MSqlQuery::InitCon());
     275    query.prepare(
     276        "SELECT cardid "
     277        "FROM capturecard "
     278        "WHERE parentid = :CARDID");
     279    query.bindValue(":CARDID", cardid);
     280
     281    int ret = 0;
     282    if (!query.exec() || !query.isActive())
     283        MythContext::DBError("CaptureCard::GetChildCardID()", query);
     284    else if (query.next())
     285        ret = query.value(0).toInt();
     286
     287    return ret;
     288}
     289
     290uint CardUtil::GetParentCardID(uint cardid)
     291{
     292    // check if child card definition does exists
     293    MSqlQuery query(MSqlQuery::InitCon());
     294    query.prepare(
     295        "SELECT parentid "
     296        "FROM capturecard "
     297        "WHERE cardid = :CARDID");
     298    query.bindValue(":CARDID", cardid);
     299
     300    int ret = 0;
     301    if (!query.exec() || !query.isActive())
     302        MythContext::DBError("CaptureCard::GetParentCardID()", query);
     303    else if (query.next())
     304        ret = query.value(0).toInt();
     305
     306    return ret;
     307}
     308
    247309/** \fn CardUtil::GetVideoDevice(uint, QString&, QString&)
    248310 *  \brief Returns the the video device associated with the card id
    249311 *  \param nCardID card id to check
     
    510572    else
    511573        ret += probeV4LInputs(device);
    512574
     575    ret += probeChildInputs(device);
     576
    513577    return ret;
    514578}
    515579
     
    567631    return ret;
    568632}
    569633
     634QStringList CardUtil::probeChildInputs(QString device)
     635{
     636    QStringList ret;
     637
     638    int cardid = CardUtil::GetCardID(device);
     639    if (cardid <= 0)
     640        return ret;
     641
     642    MSqlQuery query(MSqlQuery::InitCon());
     643    query.prepare("SELECT videodevice, cardtype "
     644                  "FROM capturecard "
     645                  "WHERE parentid = :CARDID");
     646    query.bindValue(":CARDID", cardid);
     647
     648    if (!query.exec() || !query.isActive())
     649        return ret;
     650
     651    while (query.next())
     652        ret += probeInputs(query.value(0).toString(),
     653                           query.value(1).toString());
     654
     655    return ret;
     656}
     657
    570658QValueList<DVBDiSEqCInput>
    571659CardUtil::fillDVBInputsDiSEqC(int dvb_diseqc_type)
    572660{
     
    677765    QString             device,
    678766    QString             cardtype,
    679767    QStringList        &inputLabels,
    680     vector<CardInput*> &cardInputs)
     768    vector<CardInput*> &cardInputs,
     769    int                 parentid)
    681770{
    682     int rcardid = cardid;
     771    int rcardid = (parentid) ? parentid : cardid;
    683772    QStringList inputs;
    684773
    685774    if (("FIREWIRE" == cardtype) || ("DBOX2" == cardtype))
     
    687776    else if ("DVB" != cardtype)
    688777        inputs += probeV4LInputs(device);
    689778
    690     QString dev_label = GetDeviceLabel(cardid, cardtype, device);
     779    QString dev_label = (parentid) ? " -> " : "";
     780    dev_label += GetDeviceLabel(cardid, cardtype, device);
    691781
    692782    QStringList::iterator it = inputs.begin();
    693783    for (; it != inputs.end(); ++it)
    694784    {
    695785        CardInput* cardinput = new CardInput(true);
    696786        cardinput->loadByInput(rcardid, (*it));
     787        cardinput->SetChildCardID((parentid) ? cardid : 0);
    697788        inputLabels.push_back(
    698789            dev_label + QString(" (%1) -> %2")
    699790            .arg(*it).arg(cardinput->getSourceName()));
     
    711802            CardInput* cardinput = new CardInput(true);
    712803            cardinput->loadByInput(rcardid, (*it).input);
    713804            cardinput->fillDiseqcSettingsInput((*it).position,(*it).port);
     805            cardinput->SetChildCardID((parentid) ? cardid : 0);
    714806            inputLabels.push_back(
    715807                dev_label + QString(" (%1) -> %2")
    716808                .arg((*it).input).arg(cardinput->getSourceName()));
    717809            cardInputs.push_back(cardinput);           
    718810        }
    719811    }
     812
     813    if (parentid)
     814        return;
     815
     816    MSqlQuery query(MSqlQuery::InitCon());
     817    query.prepare("SELECT cardid, videodevice, cardtype "
     818                  "FROM capturecard "
     819                  "WHERE parentid = :CARDID");
     820    query.bindValue(":CARDID", cardid);
     821
     822    if (!query.exec() || !query.isActive())
     823        return;
     824
     825    while (query.next())
     826    {
     827        GetCardInputs(query.value(0).toUInt(),
     828                      query.value(1).toString(),
     829                      query.value(2).toString(),
     830                      inputLabels, cardInputs, cardid);
     831    }
    720832}
  • libs/libmythtv/videosource.cpp

     
    10121012    TriggeredConfigurationGroup::triggerChanged(own);
    10131013}
    10141014
    1015 CaptureCard::CaptureCard()
     1015CaptureCard::CaptureCard(bool use_card_group)
    10161016{
    10171017    // must be first
    10181018    addChild(id = new ID());
    1019     addChild(new CaptureCardGroup(*this));
     1019    addChild(parentid = new ParentID(*this));
     1020    if (use_card_group)
     1021        addChild(new CaptureCardGroup(*this));
    10201022    addChild(new Hostname(*this));
    10211023}
    10221024
     1025void CaptureCard::setParentID(int id)
     1026{
     1027    parentid->setValue(QString::number(id));
     1028}
     1029
    10231030void CaptureCard::fillSelections(SelectSetting* setting)
    10241031{
     1032    CaptureCard::fillSelections(setting, false);
     1033}
     1034
     1035void CaptureCard::fillSelections(SelectSetting* setting, bool no_children)
     1036{
    10251037    MSqlQuery query(MSqlQuery::InitCon());
    1026     query.prepare(
     1038    QString qstr =
    10271039        "SELECT cardtype, videodevice, cardid, "
    10281040        "       firewire_port, firewire_node, "
    10291041        "       dbox2_port, dbox2_host, dbox2_httpport "
    10301042        "FROM capturecard "
    1031         "WHERE hostname = :HOSTNAME");
     1043        "WHERE hostname = :HOSTNAME";
     1044    if (no_children)
     1045        qstr += " AND parentid='0'";
     1046
     1047    query.prepare(qstr);
    10321048    query.bindValue(":HOSTNAME", gContext->GetHostName());
    10331049
    10341050    if (query.exec() && query.isActive() && query.size() > 0)
     
    11171133    };
    11181134};
    11191135
     1136class ChildID: public CISetting
     1137{
     1138  public:
     1139    ChildID(const CardInput &parent) : CISetting(parent, "childcardid")
     1140    {
     1141        setValue("0");
     1142        setVisible(false);
     1143    }
     1144};
     1145
    11201146class InputDisplayName: public LineEditSetting, public CISetting
    11211147{
    11221148  public:
     
    14251451
    14261452    addChild(group);
    14271453
     1454    childid = new ChildID(*this);
     1455    addChild(childid);
     1456
    14281457    setName("CardInput");
    14291458    connect(scan,     SIGNAL(pressed()), SLOT(channelScanner()));
    14301459    connect(srcfetch, SIGNAL(pressed()), SLOT(sourceFetch()));
     
    14371466    return sourceid->getSelectionLabel();
    14381467}
    14391468
     1469void CardInput::SetChildCardID(uint ccid)
     1470{
     1471    childid->setValue(QString::number(ccid));
     1472}
     1473
    14401474void CardInput::channelScanner(void)
    14411475{
    14421476    uint srcid = sourceid->getValue().toUInt();
     
    15951629    clearSelections();
    15961630    addSelection(QObject::tr("(New capture card)"), "0");
    15971631    addSelection(QObject::tr("(Delete all capture cards)"), "-1");
    1598     CaptureCard::fillSelections(this);
     1632    CaptureCard::fillSelections(this, true);
    15991633}
    16001634
    16011635MythDialog* CaptureCardEditor::dialogWidget(MythMainWindow* parent,
     
    16721706    {
    16731707        MSqlQuery query(MSqlQuery::InitCon());
    16741708
    1675         query.prepare("DELETE FROM capturecard WHERE cardid = :CARDID");
     1709        query.prepare("DELETE FROM capturecard "
     1710                      "WHERE cardid   = :CARDID OR "
     1711                      "      parentid = :CARDID");
    16761712        query.bindValue(":CARDID", getValue());
    16771713        if (!query.exec() || !query.isActive())
    16781714            MythContext::DBError("Deleting Capture Card", query);
     
    18131849    query.prepare(
    18141850        "SELECT cardid, videodevice, cardtype "
    18151851        "FROM capturecard "
    1816         "WHERE hostname = :HOSTNAME");
     1852        "WHERE hostname = :HOSTNAME AND "
     1853        "      parentid = '0'");
    18171854    query.bindValue(":HOSTNAME", gContext->GetHostName());
    18181855
    18191856    if (!query.exec() || !query.isActive() || !query.size())
     
    18941931            cardname->setValue(name);
    18951932            signal_timeout->setValue(500);
    18961933            channel_timeout->setValue(3000);
     1934
     1935            if (name.left(6) == "pcHDTV")
     1936                buttonAnalog->setVisible(true);
     1937
    18971938            break;
    18981939        default:
    18991940            fEnable = false;
     
    19792020    TransButtonSetting *buttonDiSEqC = new TransButtonSetting();
    19802021    buttonDiSEqC->setLabel(tr("DiSEqC"));
    19812022
     2023    buttonAnalog = new TransButtonSetting();
     2024    buttonAnalog->setLabel(tr("Analog Options"));
     2025    buttonAnalog->setVisible(false);
     2026
    19822027    TransButtonSetting *buttonRecOpt = new TransButtonSetting();
    19832028    buttonRecOpt->setLabel(tr("Recording Options"));   
    19842029
    19852030    HorizontalConfigurationGroup *advcfg =
    19862031        new HorizontalConfigurationGroup(false, false, true, true);
    19872032    advcfg->addChild(buttonDiSEqC);
     2033    advcfg->addChild(buttonAnalog);
    19882034    advcfg->addChild(buttonRecOpt);
    19892035    addChild(advcfg);
    19902036
     
    20002046            this,         SLOT(  probeCard   (const QString&)));
    20012047    connect(buttonDiSEqC, SIGNAL(pressed()),
    20022048            &parent,      SLOT(  DiSEqCPanel()));
     2049    connect(buttonAnalog, SIGNAL(pressed()),
     2050            &parent,      SLOT(  analogPanel()));
    20032051    connect(buttonRecOpt, SIGNAL(pressed()),
    20042052            &parent,      SLOT(  recorderOptionsPanel()));
    20052053    connect(diseqctype,   SIGNAL(valueChanged(const QString&)),
     
    20182066    }
    20192067}
    20202068
     2069void CaptureCard::analogPanel()
     2070{
     2071    reload();
     2072
     2073    uint    cardid       = getCardID();
     2074    uint    child_cardid = CardUtil::GetChildCardID(cardid);
     2075    QString devname = "Unknown";
     2076    QString dev = CardUtil::GetVideoDevice(cardid);
     2077    if (!dev.isEmpty())
     2078        devname = QString("[ DVB : %1 ]").arg(devname);
     2079
     2080    CaptureCard *card = new CaptureCard(false);
     2081    card->addChild(new V4LConfigurationGroup(*card));
     2082    if (child_cardid)
     2083        card->loadByID(child_cardid);
     2084    else
     2085        card->setParentID(cardid);
     2086    card->setLabel(tr("Analog Options for ") + devname);
     2087    card->exec();
     2088    delete card;
     2089}
     2090
    20212091void CaptureCard::recorderOptionsPanel()
    20222092{
    20232093    reload();
  • libs/libmythtv/remoteencoder.cpp

     
    1313RemoteEncoder::RemoteEncoder(int num, const QString &host, short port)
    1414    : recordernum(num),       controlSock(NULL),      remotehost(host),
    1515      remoteport(port),       lastchannel(""),        backendError(false),
    16       cachedFramesWritten(0), cachedTimeout(0)
     16      cachedFramesWritten(0)
    1717{
    18     pthread_mutex_init(&lock, NULL);
    1918}
    2019
    2120RemoteEncoder::~RemoteEncoder()
     
    4443
    4544void RemoteEncoder::SendReceiveStringList(QStringList &strlist)
    4645{
     46    QMutexLocker locker(&lock);
    4747    if (!controlSock)
    4848        return;
    4949
    50     pthread_mutex_lock(&lock);
    51 
    5250    backendError = false;
    5351
    5452    WriteStringList(controlSock, strlist);
     
    5856                "RemoteEncoder::SendReceiveStringList(): No response.");
    5957        backendError = true;
    6058    }
    61 
    62     pthread_mutex_unlock(&lock);
    6359}
    6460
    6561QSocketDevice *RemoteEncoder::openControlSocket(const QString &host, short port)
     
    407403    return retval;
    408404}
    409405
    410 uint RemoteEncoder::GetSignalLockTimeout(QString /*input*/)
     406uint RemoteEncoder::GetSignalLockTimeout(QString input)
    411407{
    412     if (cachedTimeout)
    413         return cachedTimeout;
     408    QMutexLocker locker(&lock);
    414409
     410    QMap<QString,uint>::const_iterator it = cachedTimeout.find(input);
     411    if (it != cachedTimeout.end())
     412        return *it;
     413
    415414    uint cardid  = recordernum;
    416415    uint timeout = 0xffffffff;
    417416    MSqlQuery query(MSqlQuery::InitCon());
    418     query.prepare("SELECT channel_timeout, cardtype "
    419                   "FROM capturecard "
    420                   "WHERE cardid = :CARDID");
     417    query.prepare(
     418        "SELECT channel_timeout, cardtype "
     419        "FROM cardinput, capturecard "
     420        "WHERE cardinput.inputname = :INNAME AND "
     421        "      cardinput.cardid    = :CARDID AND "
     422        "      ( ( cardinput.childcardid =  '0' AND "
     423        "          cardinput.cardid = capturecard.cardid) OR "
     424        "        ( cardinput.childcardid != '0' AND "
     425        "          cardinput.childcardid = capturecard.cardid) )");
     426    query.bindValue(":INNAME", input);
    421427    query.bindValue(":CARDID", cardid);
    422428    if (!query.exec() || !query.isActive())
    423429        MythContext::DBError("Getting timeout", query);
     
    430436            QString("GetSignalLockTimeout(%1): Set lock timeout to %2 ms")
    431437            .arg(cardid).arg(timeout));
    432438*/
    433     cachedTimeout = timeout;
     439    cachedTimeout[input] = timeout;
    434440    return timeout;
    435441}
    436442
  • libs/libmythtv/scanwizardhelpers.h

     
    204204  public:
    205205    enum Type
    206206    {
    207         Error_Open,
     207        Error_Open = 0,
    208208        Error_Probe,
    209209        FullScan_Analog,
    210210        FullScan_ATSC,
  • libs/libmythtv/scanwizard.cpp

     
    307307{
    308308    uint signal_timeout  = 1000;
    309309    uint channel_timeout = 40000;
    310     int  cardid  = parent->captureCard();
     310    int  ccardid = parent->captureCard();
     311    int  pcardid = CardUtil::GetParentCardID(ccardid);
     312    int  cardid  = (pcardid) ? pcardid : ccardid;
    311313    nScanType    = parent->scanType();
    312314    nVideoSource = parent->videoSource();
    313315    tunerthread_running = false;
     
    316318            QString("type(%1) src(%2) cardid(%3)")
    317319            .arg(nScanType).arg(nVideoSource).arg(cardid));
    318320
    319     CardUtil::GetTimeouts(cardid, signal_timeout, channel_timeout);
     321    CardUtil::GetTimeouts(ccardid, signal_timeout, channel_timeout);
    320322 
    321323    if (nScanType == ScanTypeSetting::FullScan_Analog)
    322324    {
     
    392394    {
    393395        nMultiplexToTuneTo = parent->paneSingle->GetMultiplex();
    394396
    395         QString device = CardUtil::GetVideoDevice(cardid);
     397        QString device = CardUtil::GetVideoDevice(cardid, nVideoSource);
    396398        if (device.isEmpty())
    397399            return;
    398400
    399401        QString cn, card_type;
    400         int nCardType = CardUtil::GetCardType(cardid, cn, card_type);
     402        int nCardType = CardUtil::GetCardType(ccardid, cn, card_type);
    401403        (void) nCardType;
    402404#ifdef USING_DVB
    403405        if (CardUtil::IsDVB(cardid))
  • libs/libmythtv/dbcheck.cpp

     
    1010#include "mythdbcon.h"
    1111
    1212/// This is the DB schema version expected by the running MythTV instance.
    13 const QString currentDatabaseVersion = "1124";
     13const QString currentDatabaseVersion = "1125";
    1414
    1515static bool UpdateDBVersionNumber(const QString &newnumber);
    1616static bool performActualUpdate(const QString updates[], QString version,
     
    20162016            return false;
    20172017    }
    20182018
     2019    if (dbver == "1124")
     2020    {
     2021        const QString updates[] = {
     2022"ALTER TABLE capturecard ADD parentid int(10) NOT NULL DEFAULT 0;",
     2023"ALTER TABLE cardinput ADD childcardid int(10) NOT NULL DEFAULT 0;",
     2024""
     2025};
     2026        if (!performActualUpdate(updates, "1125", dbver))
     2027            return false;
     2028    }
     2029
    20192030// Drop xvmc_buffer_settings table in 0.20
    20202031// Drop dvb_dmx_buf_size and dvb_pkt_buf_size columns of channel in 0.20
    20212032
  • libs/libmythtv/tv_rec.cpp

     
    29422942    return QString::null;
    29432943}
    29442944
    2945 /** \fn TVRec::SetInput(QString)
     2945/** \fn TVRec::SetInput(QString, uint)
    29462946 *  \brief Changes to the specified input.
    29472947 *
    29482948 *   You must call PauseRecorder(void) before calling this.
     
    32723272    }
    32733273}
    32743274
     3275/** \fn TVRec::TuningCheckForHWChange(const TuningRequest&,QString&,QString&)
     3276 *  \brief Returns cardid for device info row in capturecard if it changes.
     3277 */
     3278uint TVRec::TuningCheckForHWChange(const TuningRequest &request,
     3279                                   QString &channum,
     3280                                   QString &inputname)
     3281{
     3282    if (!channel)
     3283        return 0;
     3284
     3285    uint curCardID = 0, newCardID = 0;
     3286    channum   = request.channel;
     3287    inputname = request.input;
     3288
     3289    if (request.program)
     3290        request.program->GetChannel(channum, inputname);
     3291
     3292    if (!channum.isEmpty() && inputname.isEmpty())
     3293        channel->CheckChannel(channum, inputname);
     3294
     3295    if (!inputname.isEmpty())
     3296    {
     3297        int current_input = channel->GetCurrentInputNum();
     3298        int new_input     = channel->GetInputByName(inputname);
     3299        curCardID = channel->GetInputCardID(current_input);
     3300        newCardID = channel->GetInputCardID(new_input);
     3301        VERBOSE(VB_IMPORTANT, LOC<<"HW Tuner: "<<curCardID<<"->"<<newCardID);
     3302    }
     3303
     3304    if (curCardID != newCardID)
     3305    {   
     3306        if (channum.isEmpty())
     3307            channum = GetStartChannel(newCardID, inputname);
     3308        return newCardID;
     3309    }
     3310
     3311    return 0;
     3312}
     3313
    32753314/** \fn TVRec::TuningShutdowns(const TuningRequest&)
    32763315 *  \brief This shuts down anything that needs to be shut down
    32773316 *         before handling the passed in tuning request.
    32783317 */
    32793318void TVRec::TuningShutdowns(const TuningRequest &request)
    32803319{
     3320    QString channum, inputname;
     3321    uint newCardID = TuningCheckForHWChange(request, channum, inputname);
     3322
    32813323#ifdef USING_DVB_EIT
    32823324    if (!(request.flags & kFlagEITScan) && HasFlags(kFlagEITScannerRunning))
    32833325    {
     
    33063348
    33073349    // At this point any waits are canceled.
    33083350
    3309     if ((request.flags & kFlagNoRec))
     3351    if (newCardID || (request.flags & kFlagNoRec))
    33103352    {
    33113353        if (HasFlags(kFlagDummyRecorderRunning))
    33123354        {
     
    33313373        CloseChannel();
    33323374        // At this point the channel is shut down
    33333375    }
     3376   
     3377    // handle HW change for digital/analog cards
     3378    if (newCardID)
     3379    {
     3380        VERBOSE(VB_IMPORTANT, "Recreating channel...");
     3381        channel->Close();
     3382        delete channel;
     3383        channel = NULL;
    33343384
     3385        GetDevices(newCardID, genOpt, dvbOpt, fwOpt, dboxOpt);
     3386        genOpt.defaultinput = inputname;
     3387        CreateChannel(channum);
     3388        if (!(request.flags & kFlagNoRec))
     3389            channel->Open();
     3390    }
     3391
    33353392    if (ringBuffer && (request.flags & kFlagKillRingBuffer))
    33363393    {
    33373394        VERBOSE(VB_RECORD, LOC + "Tearing down RingBuffer");
     
    36473704            SetFlags(kFlagRingBufferReady);
    36483705        }
    36493706        else
    3650             ok = SwitchLiveTVRingBuffer(true, !had_dummyrec);
     3707            ok = SwitchLiveTVRingBuffer(true, !had_dummyrec && recorder);
    36513708        if (!ok)
    36523709        {
    36533710            VERBOSE(VB_IMPORTANT, LOC_ERR + "Failed to create RingBuffer 2");
     
    37383795    if (GetV4LChannel())
    37393796        channel->SetFd(recorder->GetVideoFd());
    37403797
    3741     SetFlags(kFlagRecorderRunning);
     3798    SetFlags(kFlagRecorderRunning | kFlagRingBufferReady);
    37423799
    37433800    if (!tvchain)
    37443801        autoRunJobs = init_jobs(rec, profile, runJobOnHostOnly,
  • libs/libmythtv/channelbase.h

     
    2525    InputBase() :
    2626        name(QString::null),            startChanNum(QString::null),
    2727        tuneToChannel(QString::null),   externalChanger(QString::null),
    28         sourceid(0),
     28        sourceid(0),                    cardid(0),
    2929        inputNumV4L(-1),
    3030        videoModeV4L1(0),               videoModeV4L2(0) {}
    3131
    3232    InputBase(QString _name,            QString _startChanNum,
    3333              QString _tuneToChannel,   QString _externalChanger,
    34               uint    _sourceid) :
     34              uint    _sourceid,        uint    _cardid) :
    3535        name(_name),                    startChanNum(_startChanNum),
    3636        tuneToChannel(_tuneToChannel),  externalChanger(_externalChanger),
    37         sourceid(_sourceid),
     37        sourceid(_sourceid),            cardid(_cardid),
    3838        inputNumV4L(-1),
    3939        videoModeV4L1(0),               videoModeV4L2(0) {}
    4040
     
    4646    QString tuneToChannel;   // for using a cable box & S-Video/Composite
    4747    QString externalChanger; // for using a cable box...
    4848    uint    sourceid;        // associated channel listings source
     49    uint    cardid;          // input card id
    4950    int     inputNumV4L;
    5051    int     videoModeV4L1;
    5152    int     videoModeV4L2;
     
    9596        { return inputs[GetNextInputNum()]->name; }
    9697    virtual QString GetNextInputStartChan(void)
    9798        { return inputs[GetNextInputNum()]->startChanNum; }
     99    virtual uint GetInputCardID(int inputNum) const;
    98100    virtual QStringList GetConnectedInputs(void) const;
    99101    virtual QString GetOrdering(void) const
    100102        { return channelorder; }
  • libs/libmythtv/tv_rec.h

     
    277277    bool TuningPMTCheck(void);
    278278    void TuningNewRecorder(void);
    279279    void TuningRestartRecorder(void);
     280    uint TuningCheckForHWChange(const TuningRequest&,
     281                                QString &channum,
     282                                QString &inputname);
    280283
    281284    void HandleStateChange(void);
    282285    void ChangeState(TVState nextState);
  • libs/libmythtv/scanwizardhelpers.cpp

     
    218218    clearSelections();
    219219
    220220    MSqlQuery query(MSqlQuery::InitCon());
    221 
    222     QString thequery = QString(
     221    query.prepare(
    223222        "SELECT DISTINCT cardtype, videodevice, capturecard.cardid "
    224223        "FROM capturecard, videosource, cardinput "
    225         "WHERE videosource.sourceid = %1 AND "
     224        "WHERE videosource.sourceid = :SOURCEID            AND "
    226225        "      cardinput.sourceid   = videosource.sourceid AND "
    227         "      cardinput.cardid     = capturecard.cardid AND "
    228         "      capturecard.cardtype in " CARDTYPES " AND "
    229         "      capturecard.hostname = '%2';")
    230         .arg(nSourceID).arg(gContext->GetHostName());
    231     query.prepare(thequery);
     226        "      capturecard.cardtype in " CARDTYPES "       AND "
     227        "      capturecard.hostname = :HOSTNAME            AND "
     228        "      ( ( cardinput.childcardid != '0' AND "
     229        "          cardinput.childcardid  = capturecard.cardid ) OR "
     230        "        ( cardinput.childcardid  = '0' AND "
     231        "          cardinput.cardid       = capturecard.cardid ) "
     232        "      )");
     233    query.bindValue(":SOURCEID", nSourceID);
     234    query.bindValue(":HOSTNAME", gContext->GetHostName());
    232235
    233     if (query.exec() && query.isActive() && query.size() > 0)
     236    if (!query.exec() || !query.isActive())
    234237    {
    235         while (query.next())
    236             addSelection("[ " + query.value(0).toString() + " : " +
    237                          query.value(1).toString() + " ]",
    238                          query.value(2).toString());
     238        MythContext::DBError("CaptureCardSetting::refresh()", query);
     239        return;
    239240    }
     241
     242    while (query.next())
     243    {
     244        addSelection("[ " + query.value(0).toString() + " : " +
     245                     query.value(1).toString() + " ]",
     246                     query.value(2).toString());
     247    }
    240248}
    241249
    242250void CaptureCardSetting::sourceID(const QString& str)
  • libs/libmythtv/channelbase.cpp

     
    169169    return ok;
    170170}
    171171
     172uint ChannelBase::GetInputCardID(int inputNum) const
     173{
     174    InputMap::const_iterator it = inputs.find(inputNum);
     175    if (it != inputs.end())
     176        return (*it)->cardid;
     177    return 0;   
     178}
     179
    172180bool ChannelBase::ChangeExternalChannel(const QString &channum)
    173181{
    174182    InputMap::const_iterator it = inputs.find(currentInputID);
     
    387395    if (GetDevice().isEmpty())
    388396        return -1;
    389397
    390     return CardUtil::GetCardID(GetDevice());
     398    int tmpcardid = CardUtil::GetCardID(GetDevice());
     399    if (tmpcardid > 0)
     400    {
     401        uint pcardid = CardUtil::GetParentCardID(tmpcardid);
     402        tmpcardid = (pcardid) ? pcardid : tmpcardid;
     403    }
     404    return tmpcardid;
    391405}
    392406
    393407/** \fn DVBChannel::InitializeInputs(void)
     
    410424        "SELECT cardinputid, "
    411425        "       inputname,   startchan, "
    412426        "       tunechan,    externalcommand, "
    413         "       sourceid "
     427        "       sourceid,    childcardid "
    414428        "FROM cardinput "
    415429        "WHERE cardid = :CARDID");
    416430    query.bindValue(":CARDID", cardid);
     
    431445
    432446    while (query.next())
    433447    {
     448        // If there is a childcardid use it instead of cardid
     449        uint inputcardid = query.value(6).toUInt();
     450        inputcardid = (inputcardid) ? inputcardid : cardid;
     451
    434452        inputs[query.value(0).toUInt()] = new InputBase(
    435453            query.value(1).toString(), query.value(2).toString(),
    436454            query.value(3).toString(), query.value(4).toString(),
    437             query.value(5).toUInt());
     455            query.value(5).toUInt(),   inputcardid);
    438456    }
    439457
    440458    // Set initial input to first connected input
     
    446464    for (it = inputs.begin(); it != inputs.end(); ++it)
    447465    {
    448466        VERBOSE(VB_CHANNEL, LOC + QString("Input #%1: '%2' schan(%3) "
    449                                           "sourceid(%4)")
     467                                          "sourceid(%4) ccid(%5)")
    450468                .arg(it.key()).arg((*it)->name).arg((*it)->startChanNum)
    451                 .arg((*it)->sourceid));
     469                .arg((*it)->sourceid).arg((*it)->cardid));
    452470    }
    453471    VERBOSE(VB_CHANNEL, LOC + QString("Current Input #%1: '%2'")
    454472            .arg(GetCurrentInputNum()).arg(GetCurrentInput()));
  • libs/libmythtv/analogscan.cpp

     
    8181    struct CHANLIST *flist   = NULL;
    8282    uint count               = 0;
    8383
    84     QString device = CardUtil::GetVideoDevice(cardid);
     84    QString device = CardUtil::GetVideoDevice(cardid, sourceid);
    8585    QString input  = CardUtil::GetInputName(cardid, sourceid);
    8686    if (device.isEmpty() || input.isEmpty())
    8787        goto do_scan_end;
  • programs/mythfrontend/statusbox.cpp

     
    739739    MSqlQuery query(MSqlQuery::InitCon());
    740740    query.prepare(
    741741        "SELECT cardid, cardtype, videodevice "
    742         "FROM capturecard ");
     742        "FROM capturecard "
     743        "WHERE parentid='0'");
     744
    743745    if (!query.exec() || !query.isActive())
    744746    {
    745747        MythContext::DBError("StatusBox::doTunerStatus()", query);
  • programs/mythbackend/main.cpp

     
    108108        }
    109109    }
    110110
    111     query.exec("SELECT cardid,hostname FROM capturecard ORDER BY cardid;");
     111    query.exec("SELECT cardid, hostname "
     112               "FROM capturecard "
     113               "WHERE parentid = '0' "
     114               "ORDER BY cardid");
    112115
    113116    if (query.isActive() && query.size())
    114117    {