Ticket #2695: 2695-v1.patch

File 2695-v1.patch, 80.1 KB (added by danielk, 17 years ago)

Initial patch

  • libs/libmythtv/analogscan.h

     
    4848{
    4949   Q_OBJECT
    5050public:
    51     /**
    52       @brief constructs the Analog Scanner
    53       @param _sourceid the video source id
    54       @param _cardid the card id to perform the scan on
    55      */
    56     AnalogScan(unsigned _sourceid, unsigned _cardid);
     51    /// @brief constructs the Analog Scanner
     52    AnalogScan(uint _cardid, uint _sourceid, const QString &_inputname);
    5753
    58     ~AnalogScan();
    59 
    6054    /** @brief Stops the scanning thread running */
    6155    void stop();
    6256
    … …  
    7569    /** @brief signals the scan is complete */
    7670    void serviceScanComplete();
    7771
    78 protected:
     72  protected:
     73    uint    cardid;
     74    uint    sourceid;
     75    QString inputname;
     76
    7977    bool fRunning;
    8078    bool fStop;
     79    uint nTable;
    8180
    82     unsigned sourceid;
    83     unsigned cardid;
    84     unsigned nTable;
    85 
    8681    /** @brief adds a found channel to the database
    8782        @param name name of the channel
    8883        @param frequency freqency/frequencyid of the channel
    … …  
    10095    void doScan();
    10196    /** @brief Actual thread proc , calls doScan*/
    10297    static void *spawn(void *param);
     98
     99  private:
     100    ~AnalogScan();
    103101};
    104102#endif //ANALOGSCAN_H

  • libs/libmythtv/channeleditor.cpp

     
    1616
    1717#include "channelsettings.h"
    1818#include "transporteditor.h"
     19#include "sourceutil.h"
    1920
    2021#include "scanwizard.h"
    2122
    … …  
    261262    buttonScan = new TransButtonSetting();
    262263    buttonScan->setLabel(QObject::tr("Channel Scanner"));
    263264    buttonScan->setHelpText(QObject::tr("Starts the channel scanner."));
     265    buttonScan->setEnabled(SourceUtil::IsAnySourceScanable());
    264266
    265267    buttonTransportEditor = new TransButtonSetting();
    266268    buttonTransportEditor->setLabel(QObject::tr("Transport Editor"));
    … …  
    426428    }
    427429}
    428430
    429 void ChannelEditor::scan()
     431void ChannelEditor::scan(void)
    430432{
    431433#ifdef USING_BACKEND
    432     ScanWizard scanwizard;
    433     scanwizard.exec(false,true);
     434    int val = source->getValue().toInt();
     435    uint sourceid = (val > 0) ? val : 0;
     436    ScanWizard *scanwizard = new ScanWizard(sourceid);
     437    scanwizard->exec(false, true);
     438    scanwizard->deleteLater();
    434439
    435440    list->fillSelections();
    436441    list->setFocus();

  • libs/libmythtv/cardutil.h

     
    118118
    119119    static bool         IsCardTypePresent(const QString &strType);
    120120
     121/*
    121122    static QString      GetRawCardType(uint cardid, uint sourceid)
    122123        { return get_on_source("cardtype", cardid, sourceid).upper(); }
    123124    static QString      GetVideoDevice(uint cardid, uint sourceid)
    … …  
    126127        { return get_on_source("vbidevice", cardid, sourceid); }
    127128    static uint         GetDBOX2Port(uint cardid, uint sourceid)
    128129        { return get_on_source("dbox2_port", cardid, sourceid).toUInt(); }
    129     static uint         GetHDHRTuner(uint cardid, uint sourceid)
    130         { return get_on_source("dbox2_port", cardid, sourceid).toUInt(); }
     130*/
    131131
    132132    static QString      GetRawCardType(uint cardid, const QString &input)
    133133        { return get_on_input("cardtype", cardid, input).upper(); }
    … …  
    135135        { return get_on_input("videodevice", cardid, input); }
    136136    static QString      GetVBIDevice(uint cardid, const QString &input)
    137137        { return get_on_input("vbidevice", cardid, input); }
     138    static uint         GetHDHRTuner(uint cardid, const QString &input)
     139        { return get_on_input("dbox2_port", cardid, input).toUInt(); }
    138140
    139 
    140141    static int          GetValueInt(const QString &col, uint cid, uint sid)
    141142        { return get_on_source(col, cid, sid).toInt(); }
    142143    static bool         SetValue(const QString &col, uint cid,

  • libs/libmythtv/videosource.h

     
    591591    void channelScanner();
    592592    void sourceFetch();
    593593    void diseqcConfig();
     594    void SetSourceID(const QString &sourceid);
    594595
    595596  private:
    596597    class ID: public AutoIncrementDBSetting
    … …  
    600601        {
    601602            setVisible(false);
    602603            setName("CardInputID");
    603         };
    604         virtual QWidget* configWidget(ConfigurationGroup *cg, QWidget* parent,
    605                                       const char* widgetName = 0)
    606         {
    607             (void)cg; (void)parent; (void)widgetName;
    608             return NULL;
    609         };
     604        }
    610605    };
    611606
    612607    ID              *id;
    … …  
    615610    InputName       *inputname;
    616611    SourceID        *sourceid;
    617612    StartingChannel *startchan;
     613    TransButtonSetting *scan;
     614    TransButtonSetting *srcfetch;
    618615    DiSEqCDevSettings  settings;
    619616};
    620617

  • libs/libmythtv/scanwizardhelpers.h

     
    4040class ScanWizard;
    4141class OptionalTypeSetting;
    4242class VideoSourceSelector;
     43class OFDMPane;
     44class QPSKPane;
     45class DVBS2Pane;
     46class ATSCPane;
     47class QAMPane;
     48class STPane;
     49class DVBUtilsImportPane;
    4350
    4451/// Max range of the ScanProgressPopup progress bar
    4552#define PROGRESS_MAX  1000
    … …  
    8794        DVBSNR,
    8895        DVBSignalStrength,
    8996        DVBLock,
    90         TuneComplete
    9197    };
    92     enum TUNING
    93     {
    94         OK,
    95         ERROR_TUNE
    96     };
    9798
    9899    ScannerEvent(TYPE t) : QCustomEvent(t + QEvent::User) { ; }
    99100
    … …  
    105106
    106107    TYPE    eventType()       const { return (TYPE)(type()-QEvent::User); }
    107108
    108   protected:
     109  private:
     110    ~ScannerEvent() { }
     111
     112  private:
    109113    QString str;
    110114    int     intvalue;
    111115};
    … …  
    114118// Settings Below Here
    115119// ///////////////////////////////
    116120
    117 class MultiplexSetting : public ComboBoxSetting, public Storage
     121class MultiplexSetting : public ComboBoxSetting, public TransientStorage
    118122{
    119     Q_OBJECT
    120   protected:
    121     int nSourceID;
    122 
    123123  public:
    124     MultiplexSetting() : ComboBoxSetting(this), nSourceID(0)
     124    MultiplexSetting() : ComboBoxSetting(this), sourceid(0)
    125125        { setLabel(tr("Transport")); }
    126126
    127     virtual void load() { refresh(); }
    128     virtual void save() { ; }
    129     virtual void save(QString /*destination*/) { }
     127    virtual void load(void);
    130128
    131     void refresh();
    132   public slots:
    133     void sourceID(const QString& str);
     129    void SetSourceID(uint _sourceid);
     130
     131  protected:
     132    uint sourceid;
    134133};
    135134
    136135class IgnoreSignalTimeout : public CheckBoxSetting, public TransientStorage
    … …  
    146145    }
    147146};
    148147
    149 class CaptureCardSetting : public ComboBoxSetting, public Storage
     148class InputSelector : public ComboBoxSetting, public TransientStorage
    150149{
    151150    Q_OBJECT
    152   protected:
    153     int nSourceID;
    154151
    155152  public:
    156     CaptureCardSetting() : ComboBoxSetting(this), nSourceID(0)
    157     {
    158         setLabel(tr("Capture Card"));
    159     }
    160     virtual void load() { refresh(); }
    161     virtual void save() { ; }
    162     virtual void save(QString /*destination*/) { }
     153    InputSelector(uint _default_cardid, const QString &_default_inputname);
    163154
    164     void refresh();
     155    virtual void load(void);
    165156
     157    uint GetParentCardID(void) const;
     158    uint GetChildCardID(void) const;
     159    uint GetHWCardID(void) const
     160        { return GetChildCardID() ? GetChildCardID() : GetParentCardID(); }
     161
     162    QString GetInputName(void) const;
     163
     164    static bool Parse(const QString &cardids_inputname,
     165                      uint &parent_cardid,
     166                      uint &child_cardid,
     167                      QString &inputname);
     168
    166169  public slots:
    167     void sourceID(const QString& str);
     170    void SetSourceID(const QString &_sourceid);
     171
     172  private:
     173    uint    sourceid;
     174    uint    default_cardid;
     175    QString default_inputname;
    168176};
    169177
    170 class ScanCountry: public ComboBoxSetting, public TransientStorage
     178class ScanCountry : public ComboBoxSetting, public TransientStorage
    171179{
    172     Q_OBJECT
    173180  public:
    174181    enum Country
    175182    {
    … …  
    211218        DVBUtilsImport,
    212219    };
    213220
    214     ScanTypeSetting() : ComboBoxSetting(this), nCaptureCard(-1)
    215     {
    216         setLabel(QObject::tr("Scan Type"));
    217         refresh("");
    218     }
     221    ScanTypeSetting() : ComboBoxSetting(this), hw_cardid(0)
     222        { setLabel(QObject::tr("Scan Type")); }
     223
    219224  protected slots:
    220     void refresh(const QString&);
     225    void SetInput(const QString &cardids_inputname);
     226
    221227  protected:
    222     int nCaptureCard;
     228    uint    hw_cardid;
    223229};
    224230
    225231class ScanOptionalConfig : public TriggeredConfigurationGroup
    226232{
    227233    Q_OBJECT
     234
    228235  public:
    229     ScanOptionalConfig(ScanWizard* wizard, ScanTypeSetting* scanType);
     236    ScanOptionalConfig(ScanTypeSetting *_scan_type);
    230237
     238    QString GetATSCFormat(const QString&)    const;
     239    QString GetModulation(void)              const;
     240    QString GetFrequencyTable(void)          const;
     241    bool    DoIgnoreSignalTimeout(void)      const;
     242    QString GetFilename(void)                const;
     243    uint    GetMultiplex(void)               const;
     244    bool    DoDeleteChannels(void)           const;
     245    bool    DoRenameChannels(void)           const;
     246    QMap<QString,QString> GetStartChan(void) const;
     247
     248    void SetDefaultATSCFormat(const QString &atscFormat);
     249
     250  public slots:
     251    void SetSourceID(const QString&);
     252    void triggerChanged(const QString&);
     253
     254  private:
     255    ScanTypeSetting     *scanType;
    231256    ScanCountry         *country;
    232257    IgnoreSignalTimeout *ignoreSignalTimeoutAll;
    233 
    234   protected slots:
    235     void triggerChanged(const QString&);
     258    OFDMPane            *paneOFDM;
     259    QPSKPane            *paneQPSK;
     260    DVBS2Pane           *paneDVBS2;
     261    ATSCPane            *paneATSC;
     262    QAMPane             *paneQAM;
     263    STPane              *paneSingle;
     264    DVBUtilsImportPane  *paneDVBUtilsImport;
    236265};
    237266
    238 class ScanWizardScanType: public VerticalConfigurationGroup
     267class ScanWizardConfig: public VerticalConfigurationGroup
    239268{
    240     Q_OBJECT
    241     friend class ScanWizard;
    242 
    243269  public:
    244     ScanWizardScanType(ScanWizard *_parent, int sourceid);
     270    ScanWizardConfig(ScanWizard *_parent,
     271                     uint    default_sourceid,  uint default_cardid,
     272                     QString default_inputname, bool force_sourceid);
    245273
     274    uint    GetSourceID(void)     const;
     275    QString GetATSCFormat(void)   const;
     276    QString GetModulation(void)   const { return scanConfig->GetModulation(); }
     277    int     GetScanType(void)     const { return scanType->getValue().toInt();}
     278    uint    GetParentCardID(void) const { return input->GetParentCardID();    }
     279    uint    GetChildCardID(void)  const { return input->GetChildCardID();     }
     280    uint    GetHWCardID(void)     const { return input->GetHWCardID();        }
     281    QString GetInputName(void)    const { return input->GetInputName();       }
     282    QString GetFilename(void)     const { return scanConfig->GetFilename();   }
     283    uint    GetMultiplex(void)    const { return scanConfig->GetMultiplex();  }
     284    bool DoDeleteChannels(void) const { return scanConfig->DoDeleteChannels();}
     285    bool DoRenameChannels(void) const { return scanConfig->DoRenameChannels();}
     286    QString GetFrequencyTable(void) const
     287        { return scanConfig->GetFrequencyTable(); }
     288    QMap<QString,QString> GetStartChan(void) const
     289        { return scanConfig->GetStartChan(); }
     290    bool    DoIgnoreSignalTimeout(void) const
     291        { return scanConfig->DoIgnoreSignalTimeout(); }
     292
     293    void SetDefaultATSCFormat(const QString &atscFormat)
     294        { scanConfig->SetDefaultATSCFormat(atscFormat); }
     295
    246296  protected:
    247     ScanWizard          *parent;
    248     ScanOptionalConfig  *scanConfig;
    249     CaptureCardSetting  *capturecard;
    250297    VideoSourceSelector *videoSource;
     298    InputSelector       *input;
    251299    ScanTypeSetting     *scanType;
     300    ScanOptionalConfig  *scanConfig;
    252301};
    253302
    254303class LogList: public ListBoxSetting, public TransientStorage
    … …  
    553602        addChild(right);
    554603    }
    555604
    556     QString frequency()      { return pfrequency->getValue(); }
    557     QString bandwidth()      { return pbandwidth->getValue(); }
    558     QString inversion()      { return pinversion->getValue(); }
    559     QString constellation() { return pconstellation->getValue(); }
    560     QString coderate_lp()    { return pcoderate_lp->getValue(); }
    561     QString coderate_hp()    { return pcoderate_hp->getValue(); }
    562     QString trans_mode()     { return ptrans_mode->getValue(); }
    563     QString guard_interval() { return pguard_interval->getValue(); }
    564     QString hierarchy()      { return phierarchy->getValue(); }
     605    QString frequency(void)      const { return pfrequency->getValue();    }
     606    QString bandwidth(void)      const { return pbandwidth->getValue();    }
     607    QString inversion(void)      const { return pinversion->getValue();    }
     608    QString constellation(void)  const { return pconstellation->getValue(); }
     609    QString coderate_lp(void)    const { return pcoderate_lp->getValue();  }
     610    QString coderate_hp(void)    const { return pcoderate_hp->getValue();  }
     611    QString trans_mode(void)     const { return ptrans_mode->getValue();    }
     612    QString guard_interval(void) const { return pguard_interval->getValue(); }
     613    QString hierarchy(void)      const { return phierarchy->getValue();    }
    565614
    566615  protected:
    567616    ScanFrequency        *pfrequency;
    … …  
    574623    ScanGuardInterval    *pguard_interval;
    575624    ScanHierarchy        *phierarchy;
    576625};
    577 #ifdef FE_GET_EXTENDED_INFO
     626
    578627class DVBS2Pane : public HorizontalConfigurationGroup
    579628{
    580629  public:
    … …  
    610659    ScanPolarity   *ppolarity;
    611660    ScanModulation *pmodulation;
    612661};
    613 #endif
    614662
    615663class QPSKPane : public HorizontalConfigurationGroup
    616664{
    … …  
    631679        addChild(right);     
    632680    }
    633681
    634     QString frequency()  { return pfrequency->getValue(); }
    635     QString symbolrate() { return psymbolrate->getValue(); }
    636     QString inversion()  { return pinversion->getValue(); }
    637     QString fec()        { return pfec->getValue(); }
    638     QString polarity()   { return ppolarity->getValue(); }
     682    QString frequency(void)  const { return pfrequency->getValue(); }
     683    QString symbolrate(void) const { return psymbolrate->getValue(); }
     684    QString inversion(void)  const { return pinversion->getValue(); }
     685    QString fec(void)        const { return pfec->getValue();        }
     686    QString polarity(void)   const { return ppolarity->getValue();  }
    639687
    640688  protected:
    641689    ScanFrequency  *pfrequency;
    … …  
    664712        addChild(right);     
    665713    }
    666714
    667     QString frequency()  { return pfrequency->getValue(); }
    668     QString symbolrate() { return psymbolrate->getValue(); }
    669     QString inversion()  { return pinversion->getValue(); }
    670     QString fec()        { return pfec->getValue(); }
    671     QString modulation() { return pmodulation->getValue(); }
     715    QString frequency(void)  const { return pfrequency->getValue(); }
     716    QString symbolrate(void) const { return psymbolrate->getValue(); }
     717    QString inversion(void)  const { return pinversion->getValue(); }
     718    QString fec(void)        const { return pfec->getValue();        }
     719    QString modulation(void) const { return pmodulation->getValue(); }
    672720
    673721  protected:
    674722    ScanFrequency  *pfrequency;
    … …  
    691739
    692740    QString atscFreqTable(void)  const { return atsc_table->getValue();      }
    693741    QString atscModulation(void) const { return atsc_modulation->getValue(); }
    694     QString atscFormat(void)     const { return atsc_format->getValue();     }
     742    QString GetATSCFormat(void)  const { return atsc_format->getValue();     }
    695743    bool DoDeleteChannels(void) const
    696744        { return old_channel_treatment->getValue() == "delete"; }
    697745    bool DoRenameChannels(void) const
    698746        { return old_channel_treatment->getValue() == "rename"; }
    699747
    700     void SetDefaultFormat(QString d)
     748    void SetDefaultATSCFormat(const QString &d)
    701749    {
    702750        int val = atsc_format->getValueIndex(d);
    703751        atsc_format->setValue(val);
    … …  
    712760
    713761class STPane : public VerticalConfigurationGroup
    714762{
    715     Q_OBJECT
    716763  public:
    717764    STPane() :
    718765        VerticalConfigurationGroup(false, false, true, false),
    … …  
    727774        addChild(ignore_signal_timeout);
    728775    }
    729776
    730     QString atscFormat(void) const { return atsc_format->getValue(); }
     777    QString GetATSCFormat(void) const { return atsc_format->getValue(); }
    731778    bool DoDeleteChannels(void) const
    732779        { return old_channel_treatment->getValue() == "delete"; }
    733780    bool DoRenameChannels(void) const
    … …  
    737784    bool ignoreSignalTimeout(void) const
    738785        { return ignore_signal_timeout->getValue().toInt(); }
    739786
    740   public slots:
    741     void sourceID(const QString &str)
    742         { transport_setting->sourceID(str); }
     787    void SetDefaultATSCFormat(const QString &d)
     788    {
     789        int val = atsc_format->getValueIndex(d);
     790        atsc_format->setValue(val);
     791    }
    743792
     793    void SetSourceID(uint sourceid)
     794        { transport_setting->SetSourceID(sourceid); }
     795
    744796  protected:
    745797    MultiplexSetting        *transport_setting;
    746798    ScanATSCChannelFormat   *atsc_format;
    … …  
    777829    bool DoIgnoreSignalTimeout(void) const
    778830        { return ignore_signal_timeout->getValue().toInt(); }
    779831
     832    void SetDefaultATSCFormat(const QString &d)
     833    {
     834        int val = atsc_format->getValueIndex(d);
     835        atsc_format->setValue(val);
     836    }
     837
    780838  private:
    781839    TransLineEditSetting    *filename;
    782840    ScanATSCChannelFormat   *atsc_format;

  • libs/libmythtv/scanwizardscanner.cpp

     
    7171/// Percentage to set to after the first tune
    7272#define TUNED_PCT     3
    7373
    74 const QString ScanWizardScanner::strTitle(QObject::tr("Scanning"));
     74QString ScanWizardScanner::kTitle = QString::null;
    7575
     76// kTitel must be initialized after the Qt translation system is initialized...
     77static void init_statics(void)
     78{
     79    static QMutex lock;
     80    static bool do_init = true;
     81    QMutexLocker locker(&lock);
     82    if (do_init)
     83    {
     84        ScanWizardScanner::kTitle = ScanWizardScanner::tr("Scanning");
     85        do_init = false;
     86    }
     87}
     88
    7689void post_event(QObject *dest, ScannerEvent::TYPE type, int val)
    7790{
    7891    ScannerEvent* e = new ScannerEvent(type);
    … …  
    8093    QApplication::postEvent(dest, e);
    8194}
    8295
    83 DVBChannel *ScanWizardScanner::GetDVBChannel(void)
    84 {
    85 #ifdef USING_DVB
    86     return dynamic_cast<DVBChannel*>(channel);
    87 #else
    88     return NULL;
    89 #endif
    90 }
    91 
    92 Channel *ScanWizardScanner::GetChannel(void)
    93 {
    94 #ifdef USING_V4L
    95     return dynamic_cast<Channel*>(channel);
    96 #else
    97     return NULL;
    98 #endif
    99 }
    100 
    101 ScanWizardScanner::ScanWizardScanner(ScanWizard *_parent)
     96ScanWizardScanner::ScanWizardScanner(void)
    10297    : VerticalConfigurationGroup(false, true, false, false),
    103       parent(_parent),
    10498      log(new LogList()),
    10599      channel(NULL),                popupProgress(NULL),
    106100      scanner(NULL),                analogScanner(NULL),
    107101      freeboxScanner(NULL),
    108       nScanType(-1),
    109       nMultiplexToTuneTo(0),        nVideoSource(0),
    110102      frequency(0),                 modulation("8vsb")
    111103{
    112     setLabel(strTitle);
     104    init_statics();
     105
     106    setLabel(kTitle);
    113107    addChild(log);
    114108}
    115109
    116 void ScanWizardScanner::finish()
     110void ScanWizardScanner::Teardown()
    117111{
    118112    // Join the thread and close the channel
    119113    if (scanner)
    120114    {
    121         delete scanner;
     115        delete scanner; // TODO we should use deleteLater...
    122116        scanner = NULL;
    123117    }
    124118
    … …  
    132126    if (analogScanner)
    133127    {
    134128        analogScanner->stop();
    135         delete analogScanner;
     129        analogScanner->deleteLater();
    136130        analogScanner = NULL;
    137131    }
    138132#endif
    … …  
    141135    if (freeboxScanner)
    142136    {
    143137        freeboxScanner->Stop();
    144         delete freeboxScanner;
     138        freeboxScanner->deleteLater();
    145139        freeboxScanner = NULL;
    146140    }
    147141#endif
     142
     143    if (popupProgress)
     144    {
     145        delete popupProgress; // TODO we should use deleteLater...
     146        popupProgress = NULL;
     147    }
    148148}
    149149
    150150void ScanWizardScanner::customEvent(QCustomEvent *e)
    … …  
    160160    {
    161161        case ScannerEvent::ServiceScanComplete:
    162162            popupProgress->progress(PROGRESS_MAX);
    163             cancelScan();
     163            Teardown();
    164164            break;
    165165        case ScannerEvent::Update:
    166166            log->updateText(scanEvent->strValue());
    … …  
    181181        case ScannerEvent::DVBSignalStrength:
    182182            popupProgress->signalStrength(scanEvent->intValue());
    183183            break;
    184         case ScannerEvent::TuneComplete:
    185         {
    186             if (scanEvent->intValue() == ScannerEvent::OK)
    187             {
    188                 HandleTuneComplete();
    189             }
    190             else
    191             {
    192                 MythPopupBox::showOkPopup(gContext->GetMainWindow(),
    193                                           tr("ScanWizard"),
    194                                           tr("Error tuning to transport"));
    195                 cancelScan();
    196             }
    197         }
    198184    }
    199185}
    200186
    … …  
    273259    QApplication::postEvent(this, e);
    274260}
    275261
    276 void ScanWizardScanner::cancelScan()
    277 {
    278     finish();
    279     delete popupProgress;
    280     popupProgress = NULL;
    281 }
    282 
    283262// full scan of existing transports broken
    284263// existing transport scan broken
    285 void ScanWizardScanner::scan()
     264void ScanWizardScanner::Scan(
     265    int            scantype,
     266    uint           parent_cardid,
     267    const QString &inputname,
     268    uint           sourceid,
     269    bool           do_delete_channels,
     270    bool           do_rename_channels,
     271    bool           do_ignore_signal_timeout,
     272    // stuff needed for particular scans
     273    uint           mplexid /* TransportScan */,
     274    const QMap<QString,QString> &startChan /* NITAddScan */,
     275    const QString &mod /* FullScan */,
     276    const QString &tbl /* FullScan */,
     277    const QString &atsc_format /* any ATSC scan */)
    286278{
    287     int  ccardid = parent->captureCard();
    288     int  pcardid = CardUtil::GetParentCardID(ccardid);
    289     int  cardid  = (pcardid) ? pcardid : ccardid;
    290     nScanType    = parent->scanType();
    291     nVideoSource = parent->videoSource();
    292     bool do_scan = true;
    293     DTVTunerType parse_type = DTVTunerType::kTunerTypeUnknown;
     279    nVideoSource = sourceid;
     280    PreScanCommon(scantype, parent_cardid, inputname,
     281                  sourceid, do_ignore_signal_timeout);
    294282
    295     VERBOSE(VB_SIPARSER, LOC + "scan(): " +
    296             QString("type(%1) src(%2) cardid(%3)")
    297             .arg(nScanType).arg(nVideoSource).arg(cardid));
     283    VERBOSE(VB_SIPARSER, LOC + "HandleTuneComplete()");
    298284
    299     if (nScanType == ScanTypeSetting::FullScan_Analog)
     285    if (!scanner)
    300286    {
    301         do_scan = false;
    302         ScanAnalog(cardid, nVideoSource);
     287        VERBOSE(VB_SIPARSER, LOC + "HandleTuneComplete(): "
     288                "scanner does not exist...");
     289        return;
    303290    }
    304     else if (nScanType == ScanTypeSetting::DVBUtilsImport)
     291
     292    scanner->StartScanner();
     293
     294    popupProgress->status(tr("Scanning"));
     295    popupProgress->progress( (TUNED_PCT * PROGRESS_MAX) / 100 );
     296
     297    QString std = (ScanTypeSetting::FullScan_ATSC == scantype)? "atsc":"dvbt";
     298
     299    bool ok = false;
     300
     301    if (do_delete_channels && (ScanTypeSetting::TransportScan == scantype))
    305302    {
    306         ImportDVBUtils(nVideoSource, parent->nCardType, parent->filename());
     303        MSqlQuery query(MSqlQuery::InitCon());
     304        query.prepare("DELETE FROM channel "
     305                      "WHERE sourceid = :SOURCEID AND "
     306                      "      mplexid  = :MPLEXID");
     307        query.bindValue(":SOURCEID", sourceid);
     308        query.bindValue(":MPLEXID",  mplexid);
     309        query.exec();
    307310    }
    308     else if ((nScanType == ScanTypeSetting::FullScan_ATSC)     ||
    309              (nScanType == ScanTypeSetting::FullTransportScan) ||
    310              (nScanType == ScanTypeSetting::TransportScan)     ||
    311              (nScanType == ScanTypeSetting::FullScan_OFDM))
     311    else if (do_delete_channels)
    312312    {
    313         ;
     313        MSqlQuery query(MSqlQuery::InitCon());
     314        query.prepare("DELETE FROM channel "
     315                      "WHERE sourceid = :SOURCEID");
     316        query.bindValue(":SOURCEID", sourceid);
     317        query.exec();
     318
     319        if (ScanTypeSetting::TransportScan != scantype)
     320        {
     321            query.prepare("DELETE FROM dtv_multiplex "
     322                          "WHERE sourceid = :SOURCEID");
     323            query.bindValue(":SOURCEID", sourceid);
     324            query.exec();
     325        }
    314326    }
    315     else if (nScanType == ScanTypeSetting::NITAddScan_OFDM)
     327
     328    scanner->SetChannelFormat(atsc_format);
     329    scanner->SetRenameChannels(do_rename_channels);
     330
     331    if ((ScanTypeSetting::FullScan_ATSC == scantype) ||
     332        (ScanTypeSetting::FullScan_OFDM == scantype))
    316333    {
    317         OFDMPane *pane = parent->paneOFDM;
    318         startChan.clear();
    319         startChan["std"]            = "dvb";
    320         startChan["frequency"]      = pane->frequency();
    321         startChan["inversion"]      = pane->inversion();
    322         startChan["bandwidth"]      = pane->bandwidth();
    323         startChan["modulation"]     = "ofdm";
    324         startChan["coderate_hp"]    = pane->coderate_hp();
    325         startChan["coderate_lp"]    = pane->coderate_lp();
    326         startChan["constellation"]  = pane->constellation();
    327         startChan["trans_mode"]     = pane->trans_mode();
    328         startChan["guard_interval"] = pane->guard_interval();
    329         startChan["hierarchy"]      = pane->hierarchy();
     334        VERBOSE(VB_SIPARSER, LOC +
     335                "ScanTransports("<<std<<", "<<mod<<", "<<tbl<<")");
    330336
    331         parse_type = DTVTunerType::kTunerTypeOFDM;
     337        // HACK HACK HACK -- begin
     338        // if using QAM we may need additional time... (at least with HD-3000)
     339        if ((mod.left(3).lower() == "qam") &&
     340            (scanner->GetSignalTimeout() < 1000))
     341        {
     342            scanner->SetSignalTimeout(1000);
     343        }
     344        // HACK HACK HACK -- end
     345
     346        ok = scanner->ScanTransports(sourceid, std, mod, tbl);
    332347    }
    333     else if (nScanType == ScanTypeSetting::NITAddScan_QPSK)
     348    else if ((ScanTypeSetting::NITAddScan_OFDM == scantype) ||
     349             (ScanTypeSetting::NITAddScan_QPSK == scantype) ||
     350             (ScanTypeSetting::NITAddScan_QAM  == scantype))
    334351    {
    335         QPSKPane *pane = parent->paneQPSK;
    336         startChan.clear();
    337         startChan["std"]        = "dvb";
    338         startChan["frequency"]  = pane->frequency();
    339         startChan["inversion"]  = pane->inversion();
    340         startChan["symbolrate"] = pane->symbolrate();
    341         startChan["fec"]        = pane->fec();
    342         startChan["modulation"] = "qpsk";
    343         startChan["polarity"]   = pane->polarity();
     352        VERBOSE(VB_SIPARSER, LOC + "ScanTransports()");
    344353
    345         parse_type = DTVTunerType::kTunerTypeQPSK;
     354        ok = scanner->ScanTransportsStartingOn(sourceid, startChan);
    346355    }
    347     else if (nScanType == ScanTypeSetting::NITAddScan_QAM)
     356    else if (ScanTypeSetting::FullTransportScan == scantype)
    348357    {
    349         QAMPane *pane = parent->paneQAM;
    350         startChan.clear();
    351         startChan["std"]        = "dvb";
    352         startChan["frequency"]  = pane->frequency();
    353         startChan["inversion"]  = pane->inversion();
    354         startChan["symbolrate"] = pane->symbolrate();
    355         startChan["fec"]        = pane->fec();
    356         startChan["modulation"] = pane->modulation();
     358        VERBOSE(VB_SIPARSER, LOC + "ScanServicesSourceID("<<sourceid<<")");
    357359
    358         parse_type = DTVTunerType::kTunerTypeQAM;
     360        ok = scanner->ScanServicesSourceID(sourceid);
     361        if (ok)
     362        {
     363            post_event(this, ScannerEvent::ServicePct,
     364                       TRANSPORT_PCT);
     365        }
     366        else
     367        {
     368            MythPopupBox::showOkPopup(gContext->GetMainWindow(),
     369                                      tr("ScanWizard"),
     370                                      tr("Error tuning to transport"));
     371            Teardown();
     372        }
    359373    }
    360     else if (nScanType == ScanTypeSetting::IPTVImport)
     374    else if ((ScanTypeSetting::DVBUtilsImport == scantype) && channels.size())
    361375    {
    362         do_scan = false;
    363         ImportM3U(cardid, nVideoSource);
    364     }
    365     else
    366     {
    367         do_scan = false;
    368         VERBOSE(VB_SIPARSER, LOC_ERR + "scan(): " +
    369                 QString("type(%1) src(%2) cardid(%3) not handled")
    370                 .arg(nScanType).arg(nVideoSource).arg(cardid));
     376        ok = true;
    371377
    372         MythPopupBox::showOkPopup(
    373             gContext->GetMainWindow(), tr("ScanWizard"),
    374             "Programmer Error, see console");
    375     }
     378        VERBOSE(VB_SIPARSER, LOC + "ScanForChannels("<<sourceid<<")");
    376379
    377     DTVMultiplex tuning;
    378     if ((DTVTunerType::kTunerTypeUnknown != parse_type) &&
    379         !tuning.ParseTuningParams(
    380             parse_type,
    381             startChan["frequency"],      startChan["inversion"],
    382             startChan["symbolrate"],     startChan["fec"],
    383             startChan["polarity"],
    384             startChan["coderate_hp"],    startChan["coderate_lp"],
    385             startChan["constellation"],  startChan["trans_mode"],
    386             startChan["guard_interval"], startChan["hierarchy"],
    387             startChan["modulation"],     startChan["bandwidth"]))
     380        QString card_type = CardUtil::GetRawCardType(parent_cardid, inputname);
     381        QString sub_type  = card_type;
     382        if (card_type == "DVB")
     383        {
     384            QString device = CardUtil::GetVideoDevice(
     385                parent_cardid, inputname);
     386
     387            ok = !device.isEmpty();
     388            if (ok)
     389                sub_type = CardUtil::ProbeDVBType(device.toUInt()).upper();
     390        }
     391
     392        if (ok)
     393        {
     394            ok = scanner->ScanForChannels(sourceid, std,
     395                                          sub_type, channels);
     396        }
     397        if (ok)
     398        {
     399            post_event(this, ScannerEvent::ServicePct,
     400                       TRANSPORT_PCT);
     401        }
     402        else
     403        {
     404            MythPopupBox::showOkPopup(gContext->GetMainWindow(),
     405                                      tr("ScanWizard"),
     406                                      tr("Error tuning to transport"));
     407            Teardown();
     408        }
     409    }
     410    else if (ScanTypeSetting::TransportScan == scantype)
    388411    {
    389         MythPopupBox::showOkPopup(
    390             gContext->GetMainWindow(), tr("ScanWizard"),
    391             tr("Error parsing parameters"));
     412        VERBOSE(VB_SIPARSER, LOC + "ScanTransport("<<mplexid<<")");
    392413
    393         do_scan = false;
     414        ok = scanner->ScanTransport(mplexid);
    394415    }
    395416
    396     if (do_scan)
     417    if (!ok)
    397418    {
    398         PreScanCommon(cardid, nVideoSource);
    399         ScannerEvent* e = new ScannerEvent(ScannerEvent::TuneComplete);
    400         e->intValue(ScannerEvent::OK);
    401         QApplication::postEvent(this, e);
     419        VERBOSE(VB_IMPORTANT, "Failed to handle tune complete.");
    402420    }
    403421}
    404422
    … …  
    434452    }
    435453}
    436454
    437 void ScanWizardScanner::PreScanCommon(uint cardid, uint sourceid)
     455void ScanWizardScanner::PreScanCommon(int scantype,
     456                                      uint pcardid,
     457                                      const QString &inputname,
     458                                      uint sourceid,
     459                                      bool do_ignore_signal_timeout)
    438460{
     461    uint ccardid         = CardUtil::GetChildCardID(pcardid);
     462    uint hw_cardid       = (ccardid) ? ccardid : pcardid;
    439463    uint signal_timeout  = 1000;
    440464    uint channel_timeout = 40000;
    441     CardUtil::GetTimeouts(parent->captureCard(),
    442                           signal_timeout, channel_timeout);
     465    CardUtil::GetTimeouts(hw_cardid, signal_timeout, channel_timeout);
    443466
    444     nMultiplexToTuneTo = parent->paneSingle->GetMultiplex();
    445 
    446     QString device = CardUtil::GetVideoDevice(cardid, sourceid);
     467    QString device = CardUtil::GetVideoDevice(pcardid, inputname);
    447468    if (device.isEmpty())
     469    {
     470        VERBOSE(VB_IMPORTANT, "No Device");
    448471        return;
     472    }
    449473
    450     QString card_type = CardUtil::GetRawCardType(cardid, sourceid);
     474    QString card_type = CardUtil::GetRawCardType(pcardid, inputname);
    451475
    452476    if ("DVB" == card_type)
    453477    {
    … …  
    457481                         ("OFDM" == sub_type));
    458482
    459483        // Ugh, Some DVB drivers don't fully support signal monitoring...
    460         if (ScanTypeSetting::TransportScan == parent->scanType() ||
    461             ScanTypeSetting::FullTransportScan == parent->scanType())
     484        if ((ScanTypeSetting::TransportScan     == scantype) ||
     485            (ScanTypeSetting::FullTransportScan == scantype))
    462486        {
    463             signal_timeout = (parent->ignoreSignalTimeout()) ?
     487            signal_timeout = (do_ignore_signal_timeout) ?
    464488                channel_timeout * 10 : signal_timeout;
    465489        }
    466490
    … …  
    482506#ifdef USING_HDHOMERUN
    483507    if ("HDHOMERUN" == card_type)
    484508    {
    485         uint tuner = CardUtil::GetHDHRTuner(cardid, sourceid);
     509        uint tuner = CardUtil::GetHDHRTuner(pcardid, inputname);
    486510        channel = new HDHRChannel(NULL, device, tuner);
    487511    }
    488512#endif // USING_HDHOMERUN
    … …  
    494518    }
    495519
    496520    // explicitly set the cardid
    497     channel->SetCardID(cardid);
     521    channel->SetCardID(pcardid);
    498522
    499523    // If the backend is running this may fail...
    500524    if (!channel->Open())
    … …  
    503527        return;
    504528    }
    505529
    506     scanner = new SIScan(card_type, channel, parent->videoSource(),
     530    scanner = new SIScan(card_type, channel, sourceid,
    507531                         signal_timeout, channel_timeout);
    508532
    509533    scanner->SetForceUpdate(true);
    510534
    511     bool ftao = CardUtil::IgnoreEncrypted(cardid, channel->GetCurrentInput());
     535    bool ftao = CardUtil::IgnoreEncrypted(pcardid, inputname);
    512536    scanner->SetFTAOnly(ftao);
    513537
    514     bool tvo = CardUtil::TVOnly(cardid, channel->GetCurrentInput());
     538    bool tvo = CardUtil::TVOnly(pcardid, inputname);
    515539    scanner->SetTVOnly(tvo);
    516540
    517541    connect(scanner, SIGNAL(ServiceScanComplete(void)),
    … …  
    557581    popupProgress->exec(this);
    558582}
    559583
    560 void ScanWizardScanner::ScanAnalog(uint cardid, uint sourceid)
     584void ScanWizardScanner::ScanAnalog(
     585    uint cardid, const QString &inputname, uint sourceid)
    561586{
    562587#ifdef USING_V4L
    563588    //Create an analog scan object
    564     analogScanner    = new AnalogScan(sourceid, cardid);
     589    analogScanner = new AnalogScan(cardid, sourceid, inputname);
    565590    popupProgress = new ScanProgressPopup(this, false);
    566591
    567592    connect(analogScanner, SIGNAL(serviceScanComplete(void)),
    … …  
    579604        MythPopupBox::showOkPopup(gContext->GetMainWindow(),
    580605                                  tr("ScanWizard"),
    581606                                  tr("Error starting scan"));
    582         cancelScan();
     607        Teardown();
    583608    }
    584609#endif
    585610}
    586611
    587 void ScanWizardScanner::ImportM3U(uint cardid, uint sourceid)
     612void ScanWizardScanner::ImportM3U(uint cardid, const QString &inputname,
     613                                  uint sourceid)
    588614{
    589615#ifdef USING_IPTV
    590616    //Create an analog scan object
    591     freeboxScanner = new IPTVChannelFetcher(sourceid, cardid);
     617    freeboxScanner = new IPTVChannelFetcher(cardid, inputname, sourceid);
    592618    popupProgress  = new ScanProgressPopup(this, false);
    593619
    594620    connect(freeboxScanner, SIGNAL(ServiceScanComplete(void)),
    … …  
    606632        MythPopupBox::showOkPopup(gContext->GetMainWindow(),
    607633                                  tr("ScanWizard"),
    608634                                  tr("Error starting scan"));
    609         cancelScan();
     635        Teardown();
    610636    }
    611637#endif // USING_IPTV
    612638}
    613 
    614 void ScanWizardScanner::HandleTuneComplete(void)
    615 {
    616     VERBOSE(VB_SIPARSER, LOC + "HandleTuneComplete()");
    617 
    618     if (!scanner)
    619     {
    620         VERBOSE(VB_SIPARSER, LOC + "HandleTuneComplete(): "
    621                 "Waiting for scan to start.");
    622         MythTimer t;
    623         t.start();
    624         while (!scanner && t.elapsed() < 500)
    625             usleep(250);
    626         if (!scanner)
    627         {
    628             VERBOSE(VB_SIPARSER, LOC +
    629                     "HandleTuneComplete(): "
    630                     "scan() did not start scanner! Aborting.");
    631             return;
    632         }
    633         VERBOSE(VB_SIPARSER, LOC + "HandleTuneComplete(): "
    634                 "scan() has started scanner.");
    635         usleep(5000);
    636     }
    637 
    638     scanner->StartScanner();
    639 
    640     popupProgress->status(tr("Scanning"));
    641     popupProgress->progress( (TUNED_PCT * PROGRESS_MAX) / 100 );
    642 
    643     QString std     = "dvbt";
    644     QString mod     = "ofdm";
    645     QString country = parent->country();
    646     if (nScanType == ScanTypeSetting::FullScan_ATSC)
    647     {
    648         std     = "atsc";
    649         mod     = parent->paneATSC->atscModulation();
    650         country = parent->paneATSC->atscFreqTable();
    651     }
    652 
    653     bool ok = false;
    654 
    655     if ((nScanType == ScanTypeSetting::FullScan_ATSC) ||
    656         (nScanType == ScanTypeSetting::FullScan_OFDM))
    657     {
    658         VERBOSE(VB_SIPARSER, LOC +
    659                 "ScanTransports("<<std<<", "<<mod<<", "<<country<<")");
    660         scanner->SetChannelFormat(parent->paneATSC->atscFormat());
    661         if (parent->paneATSC->DoDeleteChannels())
    662         {
    663             MSqlQuery query(MSqlQuery::InitCon());
    664             query.prepare("DELETE FROM channel "
    665                           "WHERE sourceid = :SOURCEID");
    666             query.bindValue(":SOURCEID", nVideoSource);
    667             query.exec();
    668             query.prepare("DELETE FROM dtv_multiplex "
    669                           "WHERE sourceid = :SOURCEID");
    670             query.bindValue(":SOURCEID", nVideoSource);
    671             query.exec();
    672         }
    673         scanner->SetRenameChannels(parent->paneATSC->DoRenameChannels());
    674 
    675         // HACK HACK HACK -- begin
    676         // if using QAM we may need additional time... (at least with HD-3000)
    677         if ((mod.left(3).lower() == "qam") &&
    678             (scanner->GetSignalTimeout() < 1000))
    679         {
    680             scanner->SetSignalTimeout(1000);
    681         }
    682         // HACK HACK HACK -- end
    683 
    684         ok = scanner->ScanTransports(nVideoSource, std, mod, country);
    685     }
    686     else if ((nScanType == ScanTypeSetting::NITAddScan_OFDM) ||
    687              (nScanType == ScanTypeSetting::NITAddScan_QPSK) ||
    688              (nScanType == ScanTypeSetting::NITAddScan_QAM))
    689     {
    690         VERBOSE(VB_SIPARSER, LOC + "ScanTransports()");
    691         scanner->SetRenameChannels(false);
    692         ok = scanner->ScanTransportsStartingOn(nVideoSource, startChan);
    693     }
    694     else if (nScanType == ScanTypeSetting::FullTransportScan)
    695     {
    696         VERBOSE(VB_SIPARSER, LOC + "ScanServicesSourceID("<<nVideoSource<<")");
    697         scanner->SetRenameChannels(false);
    698         ok = scanner->ScanServicesSourceID(nVideoSource);
    699         if (ok)
    700         {
    701             post_event(this, ScannerEvent::ServicePct,
    702                        TRANSPORT_PCT);
    703         }
    704         else
    705         {
    706             post_event(this, ScannerEvent::TuneComplete,
    707                        ScannerEvent::ERROR_TUNE);
    708         }
    709     }
    710     else if (nScanType == ScanTypeSetting::DVBUtilsImport && channels.size())
    711     {
    712         ok = true;
    713 
    714         VERBOSE(VB_SIPARSER, LOC + "ScanForChannels("<<nVideoSource<<")");
    715 
    716         scanner->SetChannelFormat(parent->paneDVBUtilsImport->GetATSCFormat());
    717 
    718         if (parent->paneDVBUtilsImport->DoDeleteChannels())
    719         {
    720             MSqlQuery query(MSqlQuery::InitCon());
    721             query.prepare("DELETE FROM channel "
    722                           "WHERE sourceid = :SOURCEID");
    723             query.bindValue(":SOURCEID", nVideoSource);
    724             query.exec();
    725         }
    726 
    727         scanner->SetRenameChannels(
    728             parent->paneDVBUtilsImport->DoRenameChannels());
    729 
    730         int  ccardid = parent->captureCard();
    731         int  pcardid = CardUtil::GetParentCardID(ccardid);
    732         int  cardid  = (pcardid) ? pcardid : ccardid;
    733         QString card_type = CardUtil::GetRawCardType(cardid, nVideoSource);
    734         QString sub_type = card_type;
    735         if (card_type == "DVB")
    736         {
    737             QString device = CardUtil::GetVideoDevice(cardid, nVideoSource);
    738             ok = !device.isEmpty();
    739             if (ok)
    740                 sub_type = CardUtil::ProbeDVBType(device.toUInt()).upper();
    741         }
    742 
    743         if (ok)
    744         {
    745             ok = scanner->ScanForChannels(nVideoSource, std,
    746                                           sub_type, channels);
    747         }
    748         if (ok)
    749         {
    750             post_event(this, ScannerEvent::ServicePct,
    751                        TRANSPORT_PCT);
    752         }
    753         else
    754         {
    755             post_event(this, ScannerEvent::TuneComplete,
    756                        ScannerEvent::ERROR_TUNE);
    757         }
    758     }
    759     else if (nScanType == ScanTypeSetting::TransportScan)
    760     {
    761         VERBOSE(VB_SIPARSER, LOC + "ScanTransport("<<nMultiplexToTuneTo<<")");
    762         scanner->SetChannelFormat(parent->paneSingle->atscFormat());
    763 
    764         if (parent->paneSingle->DoDeleteChannels())
    765         {
    766             MSqlQuery query(MSqlQuery::InitCon());
    767             query.prepare("DELETE FROM channel "
    768                           "WHERE sourceid = :SOURCEID AND "
    769                           "      mplexid  = :MPLEXID");
    770             query.bindValue(":SOURCEID", nVideoSource);
    771             query.bindValue(":MPLEXID",  nMultiplexToTuneTo);
    772             query.exec();
    773         }
    774 
    775         scanner->SetRenameChannels(parent->paneSingle->DoRenameChannels());
    776         ok = scanner->ScanTransport(nMultiplexToTuneTo);
    777     }
    778 
    779     if (!ok)
    780     {
    781         VERBOSE(VB_IMPORTANT, "Failed to handle tune complete.");
    782     }
    783 }

  • libs/libmythtv/analogscan.cpp

     
    4545
    4646#include "analogscan.h"
    4747
    48 AnalogScan::AnalogScan(unsigned _sourceid, unsigned _cardid) :
    49     fRunning(false),
    50     fStop(false),
    51     sourceid(_sourceid),
    52     cardid(_cardid)
     48AnalogScan::AnalogScan(uint _cardid, uint _sourceid,
     49                       const QString &_inputname) :
     50    cardid(_cardid), sourceid(_sourceid),
     51    inputname(QDeepCopy<QString>(_inputname)),
     52    fRunning(false), fStop(false), nTable(0)
    5353{
    5454}
    5555
    … …  
    8484    struct CHANLIST *flist   = NULL;
    8585    uint count               = 0;
    8686
    87     QString device = CardUtil::GetVideoDevice(cardid, sourceid);
    88     QString input  = CardUtil::GetInputName(cardid, sourceid);
    89     if (device.isEmpty() || input.isEmpty())
     87    QString device = CardUtil::GetVideoDevice(cardid, inputname);
     88    if (device.isEmpty() || inputname.isEmpty())
    9089        goto do_scan_end;
    9190
    9291    VERBOSE(VB_SIPARSER, "AnalogScan::doScan() " +
    93             QString("dev(%1) input(%2)").arg(device).arg(input));
     92            QString("dev(%1) input(%2)").arg(device).arg(inputname));
    9493
    9594    channel = new Channel(NULL, device);
    9695    if (!channel->Open())
    … …  
    101100    for (uint i = 0; i < count && !fStop; i++, flist++)
    102101    {
    103102        unsigned frequency = flist->freq * 1000;
    104         channel->Tune(frequency, input, "analog", QString::null);
     103        channel->Tune(frequency, inputname, "analog", QString::null);
    105104        usleep(200000); /* 0.2 sec */
    106105        if (channel->IsTuned())
    107106        {

  • libs/libmythtv/scanwizard.h

     
    3737#include "mythwizard.h"
    3838#include "settings.h"
    3939
    40 class OFDMPane;
    41 class QPSKPane;
    42 class ATSCPane;
    43 class QAMPane;
    44 class STPane;
    45 class DVBUtilsImportPane;
    46 class ScanWizardScanType;
     40class ScanWizardConfig;
    4741class ScanWizardScanner;
    4842
    4943class ScanWizard : public QObject, public ConfigurationWizard
    5044{
    5145    Q_OBJECT
    52     friend class ScanWizardScanType;
    53     friend class ScanWizardScanner;
    54     friend class ScanOptionalConfig;
    5546
    5647  public:
    57     ScanWizard(int sourceid = -1);
     48    ScanWizard(uint    default_sourceid  = 0,
     49               uint    default_cardid    = 0,
     50               QString default_inputname = QString::null,
     51               bool    force_sourceid    = false);
    5852
    5953    MythDialog *dialogWidget(MythMainWindow *parent, const char *widgetName);
    6054
    6155  protected slots:
    62     void pageSelected(const QString &strTitle);
    63     void captureCard(const QString &device);
     56    void SetPage(const QString &pageTitle);
     57    void SetInput(const QString &cardid_inputname);
    6458
    65   signals:
    66     void cardTypeChanged(const QString&);
    67 
    6859  protected:
    69     uint videoSource(void) const;
    70     int captureCard(void) const;
    71     int scanType(void) const;
    72     bool ignoreSignalTimeout(void) const;
    73     QString country(void) const;
    74     QString filename(void) const;
     60    ~ScanWizard() { }
    7561
    76     OFDMPane     *paneOFDM;
    77     QPSKPane     *paneQPSK;
    78     ATSCPane     *paneATSC;
    79     QAMPane      *paneQAM;
    80     STPane       *paneSingle;
    81     DVBUtilsImportPane *paneDVBUtilsImport;
    82 
    83     int           nVideoDev;
    84     unsigned      nCardType;
    85     int           nCaptureCard;
    86     ScanWizardScanType *configPane;
    87     ScanWizardScanner  *scannerPane;
     62  protected:
     63    uint               lastHWCardID;
     64    uint               lastHWCardType;
     65    ScanWizardConfig  *configPane;
     66    ScanWizardScanner *scannerPane;
    8867};
    8968
    90 
    9169#endif // SCANWIZARD_H

  • libs/libmythtv/channeleditor.h

     
    2121    void del();
    2222    void edit();
    2323    void edit(int);
    24     void scan();
     24    void scan(void);
    2525    void transportEditor();
    2626    void deleteChannels();
    2727

  • libs/libmythtv/sourceutil.h

     
    1818                                        QString &passwd,  QString &lineupid);
    1919    static bool    IsEncoder(uint sourceid);
    2020    static bool    IsUnscanable(uint sourceid);
     21    static bool    IsAnySourceScanable(void);
    2122    static bool    UpdateChannelsFromListings(
    2223        uint sourceid, QString cardtype = QString::null);
    2324};

  • libs/libmythtv/videosource.cpp

     
    17071707    }
    17081708#endif
    17091709
    1710     TransButtonSetting *scan = new TransButtonSetting();
     1710    scan = new TransButtonSetting();
    17111711    scan->setLabel(tr("Scan for channels"));
    17121712    scan->setHelpText(
    17131713        tr("Use channel scanner to find channels for this input."));
    17141714
    1715     TransButtonSetting *srcfetch = new TransButtonSetting();
     1715    srcfetch = new TransButtonSetting();
    17161716    srcfetch->setLabel(tr("Fetch channels from listings source"));
    17171717    srcfetch->setHelpText(
    17181718        tr("This uses the listings data source to "
    … …  
    17351735    addChild(childid);
    17361736
    17371737    setName("CardInput");
     1738    SetSourceID("-1");
     1739
    17381740    connect(scan,     SIGNAL(pressed()), SLOT(channelScanner()));
    17391741    connect(srcfetch, SIGNAL(pressed()), SLOT(sourceFetch()));
    17401742    connect(sourceid, SIGNAL(valueChanged(const QString&)),
    17411743            startchan,SLOT(  SetSourceID (const QString&)));
     1744    connect(sourceid, SIGNAL(valueChanged(const QString&)),
     1745            this,     SLOT(  SetSourceID (const QString&)));
    17421746}
    17431747
     1748void CardInput::SetSourceID(const QString &sourceid)
     1749{
     1750    bool enable = (sourceid.toInt() > 0);
     1751    scan->setEnabled(enable);
     1752    srcfetch->setEnabled(enable);
     1753}
     1754
    17441755QString CardInput::getSourceName(void) const
    17451756{
    17461757    return sourceid->getSelectionLabel();
    … …  
    17551766{
    17561767    uint srcid = sourceid->getValue().toUInt();
    17571768    uint crdid = cardid->getValue().toUInt();
     1769    QString in = inputname->getValue();
    17581770
    17591771#ifdef USING_BACKEND
    17601772    uint num_channels_before = SourceUtil::GetChannelCount(srcid);
    17611773
    17621774    save(); // save info for scanner.
    17631775
    1764     QString cardtype = CardUtil::GetRawCardType(crdid, srcid);
     1776    QString cardtype = CardUtil::GetRawCardType(crdid, in);
    17651777    if (CardUtil::IsUnscanable(cardtype))
    17661778    {
    17671779        VERBOSE(VB_IMPORTANT, QString("Sorry, %1 cards do not "
    … …  
    17691781        return;
    17701782    }
    17711783
    1772     ScanWizard scanwizard(srcid);
    1773     scanwizard.exec(false,true);
     1784    ScanWizard *scanwizard = new ScanWizard(srcid, crdid, in, true);
     1785    scanwizard->exec(false, true);
     1786    scanwizard->deleteLater();
    17741787
    17751788    if (SourceUtil::GetChannelCount(srcid))
    17761789        startchan->SetSourceID(QString::number(srcid));       

  • libs/libmythtv/scanwizard.cpp

     
    3636#include "cardutil.h"
    3737#include "videosource.h"
    3838
    39 ScanWizard::ScanWizard(int sourceid)
    40     : paneOFDM(new OFDMPane()),     paneQPSK(new QPSKPane()),
    41       paneATSC(new ATSCPane()),     paneQAM(new QAMPane()),
    42       paneSingle(new STPane()),
    43       paneDVBUtilsImport(new DVBUtilsImportPane()),
    44 #ifdef FE_GET_EXTENDED_INFO
    45       paneDVBS2(new DVBS2Pane()),
    46 #endif
    47       nVideoDev(-1),                nCardType(CardUtil::ERROR_PROBE),
    48       nCaptureCard(-1),
    49       configPane(new ScanWizardScanType(this, sourceid)),
    50       scannerPane(new ScanWizardScanner(this))
     39#define LOC QString("SWiz: ")
     40#define LOC_ERR QString("SWiz, Error: ")
     41
     42ScanWizard::ScanWizard(uint    default_sourceid,  uint default_cardid,
     43                       QString default_inputname, bool force_sourceid) :
     44    lastHWCardID(0),
     45    lastHWCardType(CardUtil::ERROR_PROBE),
     46    configPane(new ScanWizardConfig(this,
     47                                    default_sourceid,  default_cardid,
     48                                    default_inputname, force_sourceid)),
     49    scannerPane(new ScanWizardScanner())
    5150{
    5251    addChild(configPane);
    5352    addChild(scannerPane);
    5453}
    5554
    56 MythDialog* ScanWizard::dialogWidget(MythMainWindow *parent,
    57                                      const char *widgetName)
     55MythDialog *ScanWizard::dialogWidget(MythMainWindow *parent, const char*)
    5856{
    59     MythWizard* wizard = (MythWizard*)
    60         ConfigurationWizard::dialogWidget(parent, widgetName);
     57    MythWizard *wizard = (MythWizard*)
     58        ConfigurationWizard::dialogWidget(parent, "ScanWizard");
    6159
    62     connect(wizard, SIGNAL(selected(    const QString&)),
    63             this,   SLOT(  pageSelected(const QString&)));
     60    connect(wizard, SIGNAL(selected(const QString&)),
     61            this,   SLOT(  SetPage( const QString&)));
    6462
    6563    return wizard;
    6664}
    6765
    68 void ScanWizard::pageSelected(const QString& strTitle)
     66void ScanWizard::SetPage(const QString &pageTitle)
    6967{
    70     if (strTitle == ScanWizardScanner::strTitle)
    71        scannerPane->scan();
    72 }
     68    VERBOSE(VB_SIPARSER, QString("SetPage(%1)").arg(pageTitle));
     69    if (pageTitle != ScanWizardScanner::kTitle)
     70        return;
    7371
    74 void ScanWizard::captureCard(const QString &str)
    75 {
    76     int new_cardid = str.toUInt();
    77     //Work out what kind of card we've got
    78     //We need to check against the last capture card so that we don't
    79     //try and probe a card which is already open by scan()
    80     if ((nCaptureCard != new_cardid) ||
    81         (nCardType == CardUtil::ERROR_OPEN))
    82     {
    83         nCaptureCard    = new_cardid;
    84         QString subtype = CardUtil::ProbeSubTypeName(nCaptureCard, 0);
    85         nCardType       = CardUtil::toCardType(subtype);
    86         QString fmt     = SourceUtil::GetChannelFormat(videoSource());
    87         paneATSC->SetDefaultFormat(fmt);
    88         emit cardTypeChanged(QString::number(nCardType));
    89     }
    90 }
     72    QMap<QString,QString> start_chan;
     73    DTVTunerType parse_type = DTVTunerType::kTunerTypeUnknown;
    9174
    92 uint ScanWizard::videoSource(void) const
    93 {
    94     return configPane->videoSource->getValue().toInt();
    95 }
     75    uint    pcardid   = configPane->GetParentCardID();
     76    QString inputname = configPane->GetInputName();
     77    uint    sourceid  = configPane->GetSourceID();
     78    int     scantype  = configPane->GetScanType();
     79    bool    do_scan   = true;
    9680
    97 int ScanWizard::captureCard(void) const
    98 {
    99     return configPane->capturecard->getValue().toInt();
    100 }
     81    VERBOSE(VB_SIPARSER, LOC + "SetPage(): " +
     82            QString("type(%1) pcardid(%2) inputname(%3)")
     83            .arg(scantype).arg(pcardid).arg(inputname));
    10184
    102 int ScanWizard::scanType(void) const
    103 {
    104     return configPane->scanType->getValue().toInt();
    105 }
     85    if (scantype == ScanTypeSetting::FullScan_Analog)
     86    {
     87        do_scan = false;
     88        scannerPane->ScanAnalog(pcardid, inputname, sourceid);
     89    }
     90    else if (scantype == ScanTypeSetting::DVBUtilsImport)
     91    {
     92        scannerPane->ImportDVBUtils(sourceid, lastHWCardType,
     93                                    configPane->GetFilename());
     94    }
     95    else if (scantype == ScanTypeSetting::NITAddScan_OFDM)
     96    {
     97        start_chan = configPane->GetStartChan();
     98        parse_type = DTVTunerType::kTunerTypeOFDM;
     99    }
     100    else if (scantype == ScanTypeSetting::NITAddScan_QPSK)
     101    {
     102        start_chan = configPane->GetStartChan();
     103        parse_type = DTVTunerType::kTunerTypeQPSK;
     104    }
     105    else if (scantype == ScanTypeSetting::NITAddScan_QAM)
     106    {
     107        start_chan = configPane->GetStartChan();
     108        parse_type = DTVTunerType::kTunerTypeQAM;
     109    }
     110    else if (scantype == ScanTypeSetting::IPTVImport)
     111    {
     112        do_scan = false;
     113        scannerPane->ImportM3U(pcardid, inputname, sourceid);
     114    }
     115    else if ((scantype == ScanTypeSetting::FullScan_ATSC)     ||
     116             (scantype == ScanTypeSetting::FullTransportScan) ||
     117             (scantype == ScanTypeSetting::TransportScan)     ||
     118             (scantype == ScanTypeSetting::FullScan_OFDM))
     119    {
     120        ;
     121    }
     122    else
     123    {
     124        do_scan = false;
     125        VERBOSE(VB_SIPARSER, LOC_ERR + "SetPage(): " +
     126                QString("type(%1) src(%2) pcardid(%3) not handled")
     127                .arg(scantype).arg(sourceid).arg(pcardid));
    106128
    107 bool ScanWizard::ignoreSignalTimeout(void) const
    108 {
    109     bool ts0 = (ScanTypeSetting::TransportScan == scanType());
    110     bool vl0 = paneSingle->ignoreSignalTimeout();
     129        MythPopupBox::showOkPopup(
     130            gContext->GetMainWindow(), tr("ScanWizard"),
     131            "Programmer Error, see console");
     132    }
    111133
    112     bool ts1 = (ScanTypeSetting::FullTransportScan == scanType());
    113     bool vl1 = (configPane->scanConfig->
    114                 ignoreSignalTimeoutAll->getValue().toInt());
     134    // Just verify what we get from the UI...
     135    DTVMultiplex tuning;
     136    if ((DTVTunerType::kTunerTypeUnknown != parse_type) &&
     137        !tuning.ParseTuningParams(
     138            parse_type,
     139            start_chan["frequency"],      start_chan["inversion"],
     140            start_chan["symbolrate"],     start_chan["fec"],
     141            start_chan["polarity"],
     142            start_chan["coderate_hp"],    start_chan["coderate_lp"],
     143            start_chan["constellation"],  start_chan["trans_mode"],
     144            start_chan["guard_interval"], start_chan["hierarchy"],
     145            start_chan["modulation"],     start_chan["bandwidth"]))
     146    {
     147        MythPopupBox::showOkPopup(
     148            gContext->GetMainWindow(), tr("ScanWizard"),
     149            tr("Error parsing parameters"));
    115150
    116     bool ts2 = (ScanTypeSetting::DVBUtilsImport == scanType());
    117     bool vl2 = paneDVBUtilsImport->DoIgnoreSignalTimeout();
     151        do_scan = false;
     152    }
    118153
    119     return (ts0) ? vl0 : ((ts1) ? vl1 : (ts2) ? vl2 : false);
     154    if (do_scan)
     155    {
     156        scannerPane->Scan(
     157            configPane->GetScanType(),       configPane->GetParentCardID(),
     158            configPane->GetInputName(),      configPane->GetSourceID(),
     159            configPane->DoDeleteChannels(),  configPane->DoRenameChannels(),
     160            configPane->DoIgnoreSignalTimeout(), configPane->GetMultiplex(),
     161            start_chan,                      configPane->GetModulation(),
     162            configPane->GetFrequencyTable(), configPane->GetATSCFormat());
     163    }
    120164}
    121165
    122 QString ScanWizard::country(void) const
     166void ScanWizard::SetInput(const QString &cardids_inputname)
    123167{
    124     return configPane->scanConfig->country->getValue();
    125 }
     168    uint pcardid, ccardid;
     169    QString inputname;
     170    if (!InputSelector::Parse(cardids_inputname, pcardid, ccardid, inputname))
     171        return;
    126172
    127 QString ScanWizard::filename(void) const
    128 {
    129     return paneDVBUtilsImport->GetFilename();
     173    uint hw_cardid = (ccardid) ? ccardid : pcardid;
     174
     175    // Work out what kind of card we've got
     176    // We need to check against the last capture card so that we don't
     177    // try and probe a card which is already open by scan()
     178    if ((lastHWCardID != hw_cardid) ||
     179        (lastHWCardType == CardUtil::ERROR_OPEN))
     180    {
     181        lastHWCardID    = hw_cardid;
     182        QString subtype = CardUtil::ProbeSubTypeName(hw_cardid, 0);
     183        lastHWCardType  = CardUtil::toCardType(subtype);
     184        configPane->SetDefaultATSCFormat(
     185            SourceUtil::GetChannelFormat(configPane->GetSourceID()));
     186    }
    130187}

  • libs/libmythtv/scanwizardscanner.h

     
    5656
    5757class ScanWizardScanner : public VerticalConfigurationGroup
    5858{
    59     friend class ScanWizard;
    6059    Q_OBJECT
     60
    6161  public:
    62     static const QString strTitle;
     62    ScanWizardScanner(void);
     63    virtual void deleteLater(void)
     64        { Teardown(); VerticalConfigurationGroup::deleteLater(); }
    6365
    64     ScanWizardScanner(ScanWizard *_parent);
    65     ~ScanWizardScanner() { finish(); }
     66    void Scan(int            scantype,
     67              uint           parent_cardid,
     68              const QString &inputname,
     69              uint           sourceid,
     70              bool           do_delete_channels,
     71              bool           do_rename_channels,
     72              bool           do_ignore_signal_timeout,
     73              // stuff needed for particular scans
     74              uint           mplexid,
     75              const QMap<QString,QString> &startChan,
     76              const QString &mod,
     77              const QString &tbl,
     78              const QString &atsc_format);
    6679
    67     void scan(void);
     80    void ImportDVBUtils(uint sourceid, int cardtype, const QString &file);
     81    void ImportM3U(     uint cardid, const QString &inputname, uint sourceid);
     82    void ScanAnalog(    uint cardid, const QString &inputname, uint sourceid);
    6883
    6984  protected slots:
    70     void cancelScan(void);
     85    void CancelScan(void) { Teardown(); }
    7186    void scanComplete(void);
    7287    void transportScanComplete(void);
    7388    void updateText(const QString& status);
    … …  
    8095    void serviceScanPctComplete(int pct);
    8196
    8297  protected:
    83     void ImportDVBUtils(uint sourceid, int cardtype, const QString &file);
    84     void ImportM3U(uint cardid, uint sourceid);
    85     void PreScanCommon(uint cardid, uint sourceid);
    86     void TunedScanCommon(uint cardid, uint sourceid, bool ok);
    87     void ScanAnalog(uint cardid, uint sourceid);
     98    ~ScanWizardScanner() { Teardown(); }
     99    void Teardown(void);
    88100
     101    void PreScanCommon(int scantype, uint cardid, const QString &inputname,
     102                       uint sourceid, bool do_ignore_signal_timeout);
     103
    89104    void dvbLock(int);
    90105    void dvbSNR(int);
    91106    void dvbSignalStrength(int);
    92     void finish(void);
    93     void HandleTuneComplete(void);
    94107    void customEvent(QCustomEvent *e);
    95108
    96     DVBChannel *GetDVBChannel(void);
    97     Channel    *GetChannel(void);
     109  public:
     110    static QString kTitle;
    98111
    99112  private:
    100     ScanWizard        *parent;
    101113    LogList           *log;
    102114    ChannelBase       *channel;
    103115    ScanProgressPopup *popupProgress;
    … …  
    106118    AnalogScan        *analogScanner;
    107119    IPTVChannelFetcher *freeboxScanner;
    108120
    109     int                nScanType;
    110     int                nMultiplexToTuneTo;
    111121    uint               nVideoSource;
    112122
    113123    // tranport info
    114124    uint               frequency;
    115125    QString            modulation;
    116     QMap<QString,QString> startChan;
    117126
    118127    // dvb-utils imported channels
    119128    DTVChannelList channels;

  • libs/libmythtv/iptv/iptvchannelfetcher.cpp

     
    2626                         QString       &channum,
    2727                         QString       &name);
    2828
    29 IPTVChannelFetcher::IPTVChannelFetcher(uint sourceid, uint cardid) :
    30     _sourceid(sourceid),   _cardid(cardid),
     29IPTVChannelFetcher::IPTVChannelFetcher(
     30    uint cardid, const QString &inputname, uint sourceid) :
     31    _cardid(cardid),       _inputname(QDeepCopy<QString>(inputname)),
     32    _sourceid(sourceid),
    3133    _chan_cnt(1),          _thread_running(false),
    3234    _stop_now(false),      _lock(false)
    3335{
    … …  
    9799    _thread_running = true;
    98100
    99101    // Step 1/4 : Get info from DB
    100     QString url = CardUtil::GetVideoDevice(_cardid, _sourceid);
     102    QString url = CardUtil::GetVideoDevice(_cardid, _inputname);
    101103
    102104    if (_stop_now || url.isEmpty())
    103105    {

  • libs/libmythtv/iptv/iptvchannelfetcher.h

     
    1818    friend void *run_scan_thunk(void *param);
    1919
    2020  public:
    21     IPTVChannelFetcher(uint sourceid, uint cardid);
    22     ~IPTVChannelFetcher();
     21    IPTVChannelFetcher(uint cardid, const QString &inputname, uint sourceid);
    2322
    2423    bool Scan(void);
    2524    void Stop(void);
    … …  
    3938    void ServiceScanComplete(void);
    4039
    4140  private:
     41    ~IPTVChannelFetcher();
    4242    void SetTotalNumChannels(uint val) { _chan_cnt = (val) ? val : 1; }
    4343    void SetNumChannelsParsed(uint);
    4444    void SetNumChannelsInserted(uint);
    … …  
    4646    void RunScan(void);
    4747
    4848  private:
     49    uint      _cardid;
     50    QString   _inputname;
    4951    uint      _sourceid;
    50     uint      _cardid;
    5152    uint      _chan_cnt;
    5253    bool      _thread_running;
    5354    bool      _stop_now;

  • libs/libmythtv/scanwizardhelpers.cpp

     
    3838#include "frequencies.h"
    3939#include "videosource.h"
    4040#include "cardutil.h"
     41#include "sourceutil.h"
    4142#include "scanwizardhelpers.h"
    4243#include "scanwizardscanner.h"
    4344#include "scanwizard.h"
    … …  
    113114    addChild(cancel);
    114115
    115116    connect(cancel, SIGNAL(pressed(void)),
    116             parent, SLOT(  cancelScan(void)));
     117            parent, SLOT(  CancelScan(void)));
    117118
    118119    //Seem to need to do this as the constructor doesn't seem enough
    119120    setUseLabel(false);
    … …  
    122123
    123124ScanProgressPopup::~ScanProgressPopup()
    124125{
     126    VERBOSE(VB_IMPORTANT, "~ScanProgressPopup()");
    125127}
    126128
    127129void ScanProgressPopup::signalToNoise(int value)
    … …  
    149151    dialog = (ConfigPopupDialogWidget*)
    150152        dialogWidget(gContext->GetMainWindow(), "ScanProgressPopup");
    151153    connect(dialog, SIGNAL(popupDone(void)),
    152             parent, SLOT(cancelScan(void)));
     154            parent, SLOT(  CancelScan(void)));
    153155    dialog->ShowPopup(this);
    154156}
    155157
    156 void MultiplexSetting::refresh()
     158void MultiplexSetting::load(void)
    157159{
    158160    clearSelections();
    159    
     161
     162    if (!sourceid)
     163        return;
     164
    160165    MSqlQuery query(MSqlQuery::InitCon());
    161166
    162167    query.prepare(
    … …  
    165170        "FROM dtv_multiplex "
    166171        "WHERE sourceid = :SOURCEID "
    167172        "ORDER by frequency, networkid, transportid");
    168     query.bindValue(":SOURCEID", nSourceID);
     173    query.bindValue(":SOURCEID", sourceid);
    169174
    170175    if (!query.exec() || !query.isActive() || query.size() <= 0)
    171176        return;
    … …  
    202207    }
    203208}
    204209
    205 void MultiplexSetting::sourceID(const QString& str)
     210void MultiplexSetting::SetSourceID(uint _sourceid)
    206211{
    207     nSourceID = str.toInt();
    208     refresh();
     212    sourceid = _sourceid;
     213    load();
    209214}
    210215
    211 void CaptureCardSetting::refresh()
     216InputSelector::InputSelector(
     217    uint _default_cardid, const QString &_default_inputname) :
     218    ComboBoxSetting(this), sourceid(0), default_cardid(_default_cardid),
     219    default_inputname(QDeepCopy<QString>(_default_inputname))
    212220{
     221    setLabel(tr("Input"));
     222}
     223
     224void InputSelector::load(void)
     225{
    213226    clearSelections();
    214227
     228    if (!sourceid)
     229        return;
     230
    215231    MSqlQuery query(MSqlQuery::InitCon());
    216 
    217     QString qstr =
    218         "SELECT DISTINCT cardtype, videodevice, capturecard.cardid "
    219         "FROM capturecard, videosource, cardinput "
    220         "WHERE videosource.sourceid = :SOURCEID            AND "
    221         "      cardinput.sourceid   = videosource.sourceid AND "
    222         "      capturecard.cardtype in ";
    223     qstr += card_types() + "       AND "
    224         "      capturecard.hostname = :HOSTNAME            AND "
     232    query.prepare(
     233        "SELECT capturecard.cardid, cardinput.childcardid, "
     234        "       cardtype, videodevice, inputname "
     235        "FROM capturecard, cardinput, videosource "
     236        "WHERE cardinput.sourceid = videosource.sourceid AND "
     237        "      hostname           = :HOSTNAME            AND "
     238        "      cardinput.sourceid = :SOURCEID            AND "
    225239        "      ( ( cardinput.childcardid != '0' AND "
    226240        "          cardinput.childcardid  = capturecard.cardid ) OR "
    227241        "        ( cardinput.childcardid  = '0' AND "
    228242        "          cardinput.cardid       = capturecard.cardid ) "
    229         "      )";
     243        "      )");
    230244
    231     query.prepare(qstr);
    232     query.bindValue(":SOURCEID", nSourceID);
    233245    query.bindValue(":HOSTNAME", gContext->GetHostName());
     246    query.bindValue(":SOURCEID", sourceid);
    234247
    235248    if (!query.exec() || !query.isActive())
    236249    {
    237         MythContext::DBError("CaptureCardSetting::refresh()", query);
     250        MythContext::DBError("InputSelector::load()", query);
    238251        return;
    239252    }
    240253
    241     while (query.next())
     254    uint which = 0, cnt = 0;
     255    for (; query.next(); cnt++)
    242256    {
    243         addSelection("[ " + query.value(0).toString() + " : " +
    244                      query.value(1).toString() + " ]",
    245                      query.value(2).toString());
     257        uint parent_cardid = query.value(0).toUInt();
     258        uint child_cardid  = query.value(1).toUInt();
     259        QString inputname  = query.value(4).toString();
     260
     261        QString desc = CardUtil::GetDeviceLabel(
     262            parent_cardid,
     263            query.value(2).toString(), query.value(3).toString());
     264
     265        if (child_cardid)
     266        {
     267            MSqlQuery query2(MSqlQuery::InitCon());
     268            query2.prepare(
     269                "SELECT cardtype, videodevice "
     270                "FROM capturecard "
     271                "WHERE cardid = :CARDID");
     272
     273            if (query2.next())
     274            {
     275                desc += " " + CardUtil::GetDeviceLabel(
     276                    child_cardid,
     277                    query2.value(0).toString(), query2.value(1).toString());
     278            }
     279        }
     280
     281        desc += QString(" (%1)").arg(inputname);
     282
     283        QString key = QString("%1:%2:%3")
     284            .arg(parent_cardid).arg(child_cardid).arg(inputname);
     285
     286        addSelection(desc, key);
     287
     288        which = (((default_cardid == parent_cardid) ||
     289                  (default_cardid == child_cardid)) &&
     290                 (default_inputname == inputname)) ? cnt : which;
    246291    }
     292
     293    if (cnt)
     294        setValue(which);
    247295}
    248296
    249 void CaptureCardSetting::sourceID(const QString& str)
     297void InputSelector::SetSourceID(const QString &_sourceid)
    250298{
    251     nSourceID = str.toInt();
    252     refresh();
     299    if (sourceid != _sourceid.toUInt())
     300    {
     301        sourceid = _sourceid.toUInt();
     302        load();
     303    }
    253304}
    254305
    255 void ScanTypeSetting::refresh(const QString& card)
     306uint InputSelector::GetParentCardID(void) const
    256307{
    257     int nCard = card.toInt();
     308    uint    parent_cardid = 0;
     309    uint    child_cardid  = 0;
     310    QString inputname     = QString::null;
     311
     312    Parse(getValue(), parent_cardid, child_cardid, inputname);
     313
     314    return parent_cardid;
     315}
     316
     317uint InputSelector::GetChildCardID(void) const
     318{
     319    uint    parent_cardid = 0;
     320    uint    child_cardid  = 0;
     321    QString inputname     = QString::null;
     322
     323    Parse(getValue(), parent_cardid, child_cardid, inputname);
     324
     325    return child_cardid;
     326}
     327
     328QString InputSelector::GetInputName(void) const
     329{
     330    uint    parent_cardid = 0;
     331    uint    child_cardid  = 0;
     332    QString inputname = QString::null;
     333
     334    Parse(getValue(), parent_cardid, child_cardid, inputname);
     335
     336    return inputname;
     337}
     338
     339bool InputSelector::Parse(const QString &cardids_inputname,
     340                          uint &parent_cardid,
     341                          uint &child_cardid,
     342                          QString &inputname)
     343{
     344    parent_cardid = 0;
     345    child_cardid  = 0;
     346    inputname     = QString::null;
     347
     348    int sep0 = cardids_inputname.find(':');
     349    if (sep0 < 1)
     350        return false;
     351
     352    QString child_cardid_inputname = cardids_inputname.mid(sep0 + 1);
     353    int sep1 = child_cardid_inputname.find(':');
     354    if (sep1 < 1)
     355        return false;
     356
     357    parent_cardid = cardids_inputname.left(sep0).toUInt();
     358    child_cardid  = child_cardid_inputname.left(sep1).toUInt();
     359    inputname     = child_cardid_inputname.mid(sep1 + 1);
     360
     361    return true;
     362}
     363
     364void ScanTypeSetting::SetInput(const QString &cardids_inputname)
     365{
     366    uint pcardid, ccardid;
     367    QString inputname;
     368    if (!InputSelector::Parse(cardids_inputname, pcardid, ccardid, inputname))
     369        return;
     370
     371    const uint new_cardid = ccardid ? ccardid : pcardid;
     372
    258373    // Only refresh if we really have to. If we do it too often
    259374    // Then we end up fighting the scan routine when we want to
    260375    // check the type of dvb card :/
    261     if (nCard == nCaptureCard)
     376    if (new_cardid == hw_cardid)
    262377        return;
    263378
    264     nCaptureCard    = nCard;
    265     QString subtype = CardUtil::ProbeSubTypeName(nCard, 0);
     379    hw_cardid       = new_cardid;
     380    QString subtype = CardUtil::ProbeSubTypeName(hw_cardid, 0);
    266381    int nCardType   = CardUtil::toCardType(subtype);
    267382    clearSelections();
    268383
    … …  
    350465    addSelection(QObject::tr("Spain"),          "es", country == ES);
    351466}
    352467
    353 ScanOptionalConfig::ScanOptionalConfig(ScanWizard *wizard,
    354                                        ScanTypeSetting *scanType) :
    355     TriggeredConfigurationGroup(false, false, true, true),
     468ScanOptionalConfig::ScanOptionalConfig(ScanTypeSetting *_scan_type) :
     469    TriggeredConfigurationGroup(false, false, true, true,
     470                                false, false, true, true),
     471    scanType(_scan_type),
    356472    country(new ScanCountry()),
    357     ignoreSignalTimeoutAll(new IgnoreSignalTimeout())
     473    ignoreSignalTimeoutAll(new IgnoreSignalTimeout()),
     474    paneOFDM(new OFDMPane()),     paneQPSK(new QPSKPane()),
     475    paneDVBS2(new DVBS2Pane()),   paneATSC(new ATSCPane()),
     476    paneQAM(new QAMPane()),       paneSingle(new STPane()),
     477    paneDVBUtilsImport(new DVBUtilsImportPane())
    358478{
    359479    setTrigger(scanType);
    360480
    … …  
    375495    addTarget(QString::number(ScanTypeSetting::Error_Probe),
    376496             new ErrorPane(QObject::tr("Failed to probe the card")));
    377497    addTarget(QString::number(ScanTypeSetting::NITAddScan_QAM),
    378               wizard->paneQAM);
     498              paneQAM);
    379499    addTarget(QString::number(ScanTypeSetting::NITAddScan_QPSK),
    380               wizard->paneQPSK);
     500              paneQPSK);
    381501    addTarget(QString::number(ScanTypeSetting::NITAddScan_OFDM),
    382               wizard->paneOFDM);
     502              paneOFDM);
    383503    addTarget(QString::number(ScanTypeSetting::FullScan_ATSC),
    384               wizard->paneATSC);
     504              paneATSC);
    385505    addTarget(QString::number(ScanTypeSetting::FullScan_OFDM),
    386506              country);
    387507    addTarget(QString::number(ScanTypeSetting::FullScan_Analog),
    388508              new BlankSetting());
    389509    addTarget(QString::number(ScanTypeSetting::TransportScan),
    390               wizard->paneSingle);
     510              paneSingle);
    391511    addTarget(QString::number(ScanTypeSetting::FullTransportScan),
    392512              scanAllTransports);
    393513    addTarget(QString::number(ScanTypeSetting::IPTVImport),
    394514              new BlankSetting());
    395515    addTarget(QString::number(ScanTypeSetting::DVBUtilsImport),
    396               wizard->paneDVBUtilsImport);
     516              paneDVBUtilsImport);
    397517}
    398518
    399519void ScanOptionalConfig::triggerChanged(const QString& value)
    … …  
    401521    TriggeredConfigurationGroup::triggerChanged(value);
    402522}
    403523
    404 ScanWizardScanType::ScanWizardScanType(ScanWizard *_parent, int sourceid) :
    405     VerticalConfigurationGroup(true, true, false, false),
    406     parent(_parent)
     524void ScanOptionalConfig::SetSourceID(const QString &sourceid)
    407525{
    408     setLabel(tr("Scan Type"));
    409     setUseLabel(false);
     526    paneSingle->SetSourceID(sourceid.toUInt());
     527}
    410528
    411     videoSource = new VideoSourceSelector(
    412         (sourceid < 0) ? 0 : sourceid, card_types(), false);
     529void ScanOptionalConfig::SetDefaultATSCFormat(const QString &atscFormat)
     530{
     531    paneATSC->SetDefaultATSCFormat(atscFormat);
     532    paneSingle->SetDefaultATSCFormat(atscFormat);
     533    paneDVBUtilsImport->SetDefaultATSCFormat(atscFormat);
     534}
    413535
    414     capturecard = new CaptureCardSetting();
     536QString ScanOptionalConfig::GetATSCFormat(const QString &dfl) const
     537{
     538    int     st =  scanType->getValue().toInt();
    415539
    416     HorizontalConfigurationGroup *h1 =
    417         new HorizontalConfigurationGroup(false,false,true,true);
    418     h1->addChild(videoSource);
    419     h1->addChild(capturecard);
    420     addChild(h1);
    421     scanType = new ScanTypeSetting();
     540    bool    ts0 = (ScanTypeSetting::FullScan_ATSC  == st);
     541    QString vl0 = paneATSC->GetATSCFormat();
     542
     543    bool    ts1 = (ScanTypeSetting::TransportScan  == st);
     544    QString vl1 = paneSingle->GetATSCFormat();
     545
     546    bool    ts2 = (ScanTypeSetting::DVBUtilsImport == st);
     547    QString vl2 = paneDVBUtilsImport->GetATSCFormat();
     548
     549    return (ts0) ? vl0 : ((ts1) ? vl1 : (ts2) ? vl2 : dfl);
     550}
     551
     552QString ScanOptionalConfig::GetModulation(void) const
     553{
     554    int     st =  scanType->getValue().toInt();
     555
     556    bool    ts0 = (ScanTypeSetting::FullScan_ATSC == st);
     557    QString vl0 = paneATSC->atscModulation();
     558
     559    bool    ts1 = (ScanTypeSetting::FullScan_OFDM == st);
     560    QString vl1 = "ofdm";
     561
     562    return (ts0) ? vl0 : ((ts1) ? vl1 : "ofdm");
     563}
     564
     565QString ScanOptionalConfig::GetFrequencyTable(void) const
     566{
     567    int     st =  scanType->getValue().toInt();
     568
     569    bool    ts0 = (ScanTypeSetting::FullScan_ATSC == st);
     570    QString vl0 = paneATSC->atscFreqTable();
     571
     572    bool    ts1 = (ScanTypeSetting::FullScan_OFDM == st);
     573    QString vl1 = country->getValue();
     574
     575    return (ts0) ? vl0 : ((ts1) ? vl1 : "vsb8");
     576}
     577
     578bool ScanOptionalConfig::DoIgnoreSignalTimeout(void) const
     579{
     580    int  st  = scanType->getValue().toInt();
     581
     582    bool ts0 = (ScanTypeSetting::TransportScan     == st);
     583    bool vl0 = paneSingle->ignoreSignalTimeout();
     584
     585    bool ts1 = (ScanTypeSetting::FullTransportScan == st);
     586    bool vl1 = (ignoreSignalTimeoutAll->getValue().toInt());
     587
     588    bool ts2 = (ScanTypeSetting::DVBUtilsImport    == st);
     589    bool vl2 = paneDVBUtilsImport->DoIgnoreSignalTimeout();
     590
     591    return (ts0) ? vl0 : ((ts1) ? vl1 : (ts2) ? vl2 : false);
     592}
     593
     594bool ScanOptionalConfig::DoDeleteChannels(void) const
     595{
     596    int  st  = scanType->getValue().toInt();
     597
     598    bool ts0 = (ScanTypeSetting::FullScan_ATSC  == st);
     599    bool vl0 = paneATSC->DoDeleteChannels();
     600
     601    bool ts1 = (ScanTypeSetting::TransportScan  == st);
     602    bool vl1 = paneSingle->DoDeleteChannels();
     603
     604    bool ts2 = (ScanTypeSetting::DVBUtilsImport == st);
     605    bool vl2 = paneDVBUtilsImport->DoDeleteChannels();
     606
     607    return (ts0) ? vl0 : ((ts1) ? vl1 : (ts2) ? vl2 : false);
     608}
     609
     610bool ScanOptionalConfig::DoRenameChannels(void) const
     611{
     612    int  st  = scanType->getValue().toInt();
     613
     614    bool ts0 = (ScanTypeSetting::FullScan_ATSC  == st);
     615    bool vl0 = paneATSC->DoRenameChannels();
     616
     617    bool ts1 = (ScanTypeSetting::TransportScan  == st);
     618    bool vl1 = paneSingle->DoRenameChannels();
     619
     620    bool ts2 = (ScanTypeSetting::DVBUtilsImport == st);
     621    bool vl2 = paneDVBUtilsImport->DoRenameChannels();
     622
     623    return (ts0) ? vl0 : ((ts1) ? vl1 : (ts2) ? vl2 : false);
     624}
     625
     626QString ScanOptionalConfig::GetFilename(void) const
     627{
     628    return paneDVBUtilsImport->GetFilename();
     629}
     630
     631uint ScanOptionalConfig::GetMultiplex(void) const
     632{
     633    int mplexid = paneSingle->GetMultiplex();
     634    return (mplexid <= 0) ? 0 : mplexid;
     635}
     636
     637QMap<QString,QString> ScanOptionalConfig::GetStartChan(void) const
     638{
     639    QMap<QString,QString> startChan;
     640
     641    int st = scanType->getValue().toInt();
     642    if (ScanTypeSetting::NITAddScan_OFDM == st)
     643    {
     644        const OFDMPane *pane = paneOFDM;
     645
     646        startChan["std"]            = "dvb";
     647        startChan["frequency"]      = pane->frequency();
     648        startChan["inversion"]      = pane->inversion();
     649        startChan["bandwidth"]      = pane->bandwidth();
     650        startChan["modulation"]     = "ofdm";
     651        startChan["coderate_hp"]    = pane->coderate_hp();
     652        startChan["coderate_lp"]    = pane->coderate_lp();
     653        startChan["constellation"]  = pane->constellation();
     654        startChan["trans_mode"]     = pane->trans_mode();
     655        startChan["guard_interval"] = pane->guard_interval();
     656        startChan["hierarchy"]      = pane->hierarchy();
     657    }
     658    else if (ScanTypeSetting::NITAddScan_QPSK == st)
     659    {
     660        const QPSKPane *pane = paneQPSK;
     661
     662        startChan["std"]        = "dvb";
     663        startChan["frequency"]  = pane->frequency();
     664        startChan["inversion"]  = pane->inversion();
     665        startChan["symbolrate"] = pane->symbolrate();
     666        startChan["fec"]        = pane->fec();
     667        startChan["modulation"] = "qpsk";
     668        startChan["polarity"]   = pane->polarity();
     669    }
     670    else if (ScanTypeSetting::NITAddScan_QAM == st)
     671    {
     672        const QAMPane *pane = paneQAM;
     673
     674        startChan["std"]        = "dvb";
     675        startChan["frequency"]  = pane->frequency();
     676        startChan["inversion"]  = pane->inversion();
     677        startChan["symbolrate"] = pane->symbolrate();
     678        startChan["fec"]        = pane->fec();
     679        startChan["modulation"] = pane->modulation();
     680    }
     681
     682    return startChan;
     683}
     684
     685ScanWizardConfig::ScanWizardConfig(
     686    ScanWizard *_parent,
     687    uint    default_sourceid,  uint default_cardid,
     688    QString default_inputname, bool force_sourceid) :
     689    VerticalConfigurationGroup(false, true, false, false),
     690    videoSource(new VideoSourceSelector(
     691                    default_sourceid, card_types(), false)),
     692    input(new InputSelector(default_cardid, default_inputname)),
     693    scanType(new ScanTypeSetting()),
     694    scanConfig(new ScanOptionalConfig(scanType))
     695{
     696    setLabel(tr("Scan Configuration"));
     697
     698    addChild(videoSource);
     699    addChild(input);
    422700    addChild(scanType);
    423     scanConfig = new ScanOptionalConfig(_parent,scanType);
    424701    addChild(scanConfig);
    425702
    426703    connect(videoSource, SIGNAL(valueChanged(const QString&)),
    427         _parent->paneSingle, SLOT(sourceID(const QString&)));
     704            scanConfig,  SLOT(  SetSourceID( const QString&)));
     705
    428706    connect(videoSource, SIGNAL(valueChanged(const QString&)),
    429         capturecard, SLOT(sourceID(const QString&)));
     707            input,       SLOT(  SetSourceID( const QString&)));
    430708
    431     //Setup signals to refill the scan types
    432     connect(capturecard, SIGNAL(valueChanged(const QString&)),
    433         scanType, SLOT(refresh(const QString&)));
     709    connect(input,       SIGNAL(valueChanged(const QString&)),
     710            scanType,    SLOT(  SetInput(    const QString&)));
    434711
    435     connect(capturecard, SIGNAL(valueChanged(const QString&)),
    436         parent, SLOT(captureCard(const QString&)));
     712    connect(input,      SIGNAL(valueChanged(const QString&)),
     713            _parent,     SLOT(  SetInput(    const QString&)));
    437714}
    438715
     716uint ScanWizardConfig::GetSourceID(void) const
     717{
     718    return videoSource->getValue().toInt();
     719}
     720
     721QString ScanWizardConfig::GetATSCFormat(void) const
     722{
     723    QString dfl = SourceUtil::GetChannelFormat(GetSourceID());
     724    return scanConfig->GetATSCFormat(dfl);
     725}
     726
    439727LogList::LogList() : ListBoxSetting(this), n(0)
    440728{
    441729    setSelectionMode(MythListBox::NoSelection);

  • libs/libmythtv/sourceutil.cpp

     
    157157    return types.empty() || unscanable;
    158158}
    159159
     160bool SourceUtil::IsAnySourceScanable(void)
     161{
     162    MSqlQuery query(MSqlQuery::InitCon());
     163    query.prepare("SELECT sourceid FROM videosource");
     164
     165    if (!query.exec() || !query.isActive())
     166    {
     167        MythContext::DBError("SourceUtil::IsAnySourceScanable", query);
     168        return false;
     169    }
     170
     171    while (query.next())
     172    {
     173        if (!IsUnscanable(query.value(0).toUInt()))
     174            return true;
     175    }
     176 
     177    return false;
     178}
     179
    160180bool SourceUtil::UpdateChannelsFromListings(uint sourceid, QString cardtype)
    161181{
    162182    QString cmd = "mythfilldatabase --only-update-channels ";