Ticket #5443: 5443-recording-profiles-v1.patch

File 5443-recording-profiles-v1.patch, 28.6 KB (added by danielk, 17 years ago)

Adds recording profiles (not finished, only respects 'high' resolution bitrates.)

  • configure

     
    158158  echo "  --disable-hdhomerun      disable support for HDHomeRun boxes"
    159159  echo "  --disable-v4l            disable Video4Linux support"
    160160  echo "  --disable-ivtv           disable ivtv support (PVR-x50) req. v4l support"
     161  echo "  --disable-hdpvr          disable HD-PVR support"
    161162  echo "  --disable-dvb            disable DVB support"
    162163  echo "  --dvb-path=HDRLOC        location of directory containing"
    163164  echo "                           'linux/dvb/frontend.h', not the"
    … …  
    892893    hdhomerun
    893894    iptv
    894895    ivtv
     896    hdpvr
    895897    joystick_menu
    896898    libfftw3
    897899    lirc
    … …  
    10491051firewire_deps="backend"
    10501052iptv_deps="backend"
    10511053ivtv_deps="backend v4l"
     1054hdpvr_deps="backend v4l"
    10521055hdhomerun_deps="backend"
    10531056opengl_deps="GL_gl_h"
    10541057opengl_deps_any="windows x11"
    … …  
    11811184hdhomerun="yes"
    11821185iptv="yes"
    11831186ivtv="yes"
     1187hdpvr="yes"
    11841188joystick_menu="default"
    11851189lamemp3="yes"
    11861190lirc="yes"
    … …  
    16181622    enable  darwin
    16191623    disable dvb
    16201624    disable ivtv
     1625    disable hdpvr
    16211626    ldver=$(ld -v 2>&1 | sed -e s/^[^-]*-//)
    16221627    osxver=$(uname -r | cut -c 1)
    16231628    if [[ ${ldver%.*} -lt "82" && ${osxver} = "9" && ${arch} = "x86_32" ]]; then
    … …  
    16481653    disable dv1394
    16491654    disable dvb
    16501655    disable ivtv
     1656    disable hdpvr
    16511657    enable  memalign_hack
    16521658    disable network
    16531659    enable opengl
    … …  
    30173023if enabled backend; then
    30183024  echo "Video4Linux sup.          ${v4l-no}"
    30193025  echo "ivtv support              ${ivtv-no}"
     3026  echo "hdpvr support             ${hdpvr-no}"
    30203027  echo "FireWire support          ${firewire-no}"
    30213028  echo "DVB support               ${dvb-no} [$dvb_path]"
    30223029  echo "DBox2 support             ${dbox2-no}"

  • libs/libmythtv/cardutil.h

     
    5353        FIREWIRE  = 9,
    5454        HDHOMERUN = 10,
    5555        FREEBOX   = 11,
     56        HDPVR     = 12,
    5657    };
    5758
    5859    static enum CARD_TYPES toCardType(const QString &name)
    … …  
    8182            return HDHOMERUN;
    8283        if ("FREEBOX" == name)
    8384            return FREEBOX;
     85        if ("HDPVR" == name)
     86            return HDPVR;
    8487        return ERROR_UNKNOWN;
    8588    }
    8689
    … …  
    9598    static bool         IsUnscanable(const QString &rawtype)
    9699    {
    97100        return
    98             (rawtype == "FIREWIRE")  || (rawtype == "DBOX2");
     101            (rawtype == "FIREWIRE")  || (rawtype == "DBOX2") ||
     102            (rawtype == "HDPVR");
    99103    }
    100104
    101105    static bool         IsEITCapable(const QString &rawtype)
    … …  
    119123
    120124    static bool         IsTuningAnalog(const QString &rawtype)
    121125    {
    122         return (rawtype == "V4L");
     126        return
     127            (rawtype == "V4L")    || (rawtype == "MPEG") ||
     128            (rawtype == "HDPVR");
    123129    }
    124130
    125131    /// Convenience function for GetCardIDs(const QString&, QString, QString)
    … …  
    146152        { return get_on_cardid("cardtype", cardid).upper(); }
    147153    static QString      GetVideoDevice(uint cardid)
    148154        { return get_on_cardid("videodevice", cardid); }
     155    static QString      GetAudioDevice(uint cardid)
     156        { return get_on_cardid("audiodevice", cardid); }
    149157    static QString      GetVBIDevice(uint cardid)
    150158        { return get_on_cardid("vbidevice", cardid); }
    151159    static uint         GetHDHRTuner(uint cardid)
    … …  
    193201
    194202    static QString      ProbeSubTypeName(uint cardid);
    195203
    196     static QStringList  probeInputs(QString device,
    197                                     QString cardtype = QString::null);
     204    static QStringList  ProbeVideoInputs(QString device,
     205                                         QString cardtype = QString::null);
     206    static QStringList  ProbeAudioInputs(QString device,
     207                                         QString cardtype = QString::null);
    198208    static void         GetCardInputs(uint                cardid,
    199209                                      const QString      &device,
    200210                                      const QString      &cardtype,
    … …  
    239249                                   uint32_t &version);
    240250    static bool         GetV4LInfo(int videofd, QString &card, QString &driver)
    241251        { uint32_t dummy; return GetV4LInfo(videofd, card, driver, dummy); }
    242     static InputNames   probeV4LInputs(int videofd, bool &ok);
     252    static InputNames   ProbeV4LVideoInputs(int videofd, bool &ok);
     253    static InputNames   ProbeV4LAudioInputs(int videofd, bool &ok);
    243254
    244255  private:
    245     static QStringList  probeV4LInputs(QString device);
    246     static QStringList  probeDVBInputs(QString device);
     256    static QStringList  ProbeV4LVideoInputs(QString device);
     257    static QStringList  ProbeV4LAudioInputs(QString device);
     258    static QStringList  ProbeDVBInputs(QString device);
    247259};
    248260
    249261#endif //_CARDUTIL_H_

  • libs/libmythtv/videosource.h

     
    367367    }
    368368};
    369369
     370class TunerCardAudioInput : public ComboBoxSetting, public CaptureCardDBStorage
     371{
     372    Q_OBJECT
     373  public:
     374    TunerCardAudioInput(const CaptureCard &parent,
     375                        QString dev  = QString::null,
     376                        QString type = QString::null);
     377
     378  public slots:
     379    void fillSelections(const QString &device);
     380
     381  private:
     382    QString last_device;
     383    QString last_cardtype;
     384};
     385
    370386class DVBAudioDevice : public LineEditSetting, public CaptureCardDBStorage
    371387{
    372388    Q_OBJECT
    … …  
    453469    TunerCardInput    *input;
    454470};
    455471
     472class HDPVRConfigurationGroup: public VerticalConfigurationGroup
     473{
     474   Q_OBJECT
     475
     476  public:
     477    HDPVRConfigurationGroup(CaptureCard &parent);
     478
     479  public slots:
     480    void probeCard(const QString &device);
     481
     482  private:
     483    CaptureCard         &parent;
     484    TransLabelSetting   *cardinfo;
     485    TunerCardInput      *videoinput;
     486    TunerCardAudioInput *audioinput;
     487};
     488
    456489class DVBCardNum;
    457490class DVBInput;
    458491class DVBCardName;

  • libs/libmythtv/libmythtv.pro

     
    477477    using_ivtv:SOURCES += mpegrecorder.cpp
    478478    using_ivtv:DEFINES += USING_IVTV
    479479
     480    # Support for HD-PVR on Linux
     481    using_hdpvr:HEADERS *= mpegrecorder.h
     482    using_hdpvr:SOURCES *= mpegrecorder.cpp
     483    using_hdpvr:DEFINES += USING_HDPVR
     484
    480485    # Support for Linux DVB drivers
    481486    using_dvb {
    482487        # Basic DVB types

  • libs/libmythtv/dbcheck.cpp

     
    1616#define MINIMUM_DBMS_VERSION 5
    1717
    1818/// This is the DB schema version expected by the running MythTV instance.
    19 const QString currentDatabaseVersion = "1221";
     19const QString currentDatabaseVersion = "1222";
    2020
    2121static bool UpdateDBVersionNumber(const QString &newnumber);
    2222static bool performActualUpdate(
    … …  
    42924292            return false;
    42934293    }
    42944294
     4295    if (dbver == "1221")
     4296    {
     4297        const char *updates[] = {
     4298"INSERT INTO profilegroups SET name = 'HD-PVR Recorders', "
     4299"  cardtype = 'HDPVR', is_default = 1;",
     4300"INSERT INTO recordingprofiles SET name = 'Default',      profilegroup = 13;",
     4301"INSERT INTO recordingprofiles SET name = 'Live TV',      profilegroup = 13;",
     4302"INSERT INTO recordingprofiles SET name = 'High Quality', profilegroup = 13;",
     4303"INSERT INTO recordingprofiles SET name = 'Low Quality',  profilegroup = 13;",
     4304NULL
     4305};
     4306        if (!performActualUpdate(updates, "1222", dbver))
     4307            return false;
     4308    }
     4309
    42954310    return true;
    42964311}
    42974312

  • libs/libmythtv/scanwizardscanner.cpp

     
    510510#endif
    511511
    512512#ifdef USING_V4L
    513     if (("V4L" == card_type) || ("MPEG" == card_type))
     513    if (("V4L" == card_type) || ("MPEG" == card_type) ||
     514        ("HDPVR" == card_type))
     515    {
    514516        channel = new V4LChannel(NULL, device);
     517    }
    515518#endif
    516519
    517520#ifdef USING_HDHOMERUN

  • libs/libmythtv/mpegrecorder.h

     
    104104    int audtype, audsamplerate, audbitratel1, audbitratel2, audbitratel3;
    105105    int audvolume;
    106106    unsigned int language; ///< 0 is Main Lang; 1 is SAP Lang; 2 is Dual
     107    unsigned int low_mpeg4avgbitrate;
     108    unsigned int low_mpeg4peakbitrate;
     109    unsigned int medium_mpeg4avgbitrate;
     110    unsigned int medium_mpeg4peakbitrate;
     111    unsigned int high_mpeg4avgbitrate;
     112    unsigned int high_mpeg4peakbitrate;
    107113
    108114    // Input file descriptors
    109115    int chanfd;

  • libs/libmythtv/signalmonitor.cpp

     
    9393
    9494#ifdef USING_V4L
    9595    if ((cardtype.upper() == "V4L") ||
    96         (cardtype.upper() == "MPEG"))
     96        (cardtype.upper() == "MPEG") ||
     97        (cardtype.upper() == "HDPVR"))
    9798    {
    9899        V4LChannel *chan = dynamic_cast<V4LChannel*>(channel);
    99100        if (chan)

  • libs/libmythtv/v4lchannel.cpp

     
    279279    int videomode_v4l2 = format_to_mode(fmt.upper(), 2);
    280280
    281281    bool ok = false;
    282     InputNames v4l_inputs = CardUtil::probeV4LInputs(videofd, ok);
     282    InputNames v4l_inputs = CardUtil::ProbeV4LVideoInputs(videofd, ok);
    283283
    284284    // Insert info from hardware
    285285    uint valid_cnt = 0;

  • libs/libmythtv/cardutil.cpp

     
    14171417    return !card.isEmpty();
    14181418}
    14191419
    1420 InputNames CardUtil::probeV4LInputs(int videofd, bool &ok)
     1420InputNames CardUtil::ProbeV4LVideoInputs(int videofd, bool &ok)
    14211421{
    14221422    (void) videofd;
    14231423
    … …  
    14821482    return list;
    14831483}
    14841484
     1485InputNames CardUtil::ProbeV4LAudioInputs(int videofd, bool &ok)
     1486{
     1487    (void) videofd;
     1488
     1489    InputNames list;
     1490    ok = false;
     1491
     1492#ifdef USING_V4L
     1493    bool usingv4l2 = hasV4L2(videofd);
     1494
     1495    // V4L v2 query
     1496    struct v4l2_audio ain;
     1497    bzero(&ain, sizeof(ain));
     1498    while (usingv4l2 && (ioctl(videofd, VIDIOC_ENUMAUDIO, &ain) >= 0))
     1499    {
     1500        QString input((char *)ain.name);
     1501        list[ain.index] = input;
     1502        ain.index++;
     1503    }
     1504    if (ain.index)
     1505    {
     1506        ok = true;
     1507        return list;
     1508    }
     1509
     1510    ok = true;
     1511#else // if !USING_V4L
     1512    list[-1] += QObject::tr(
     1513        "ERROR, Compile with V4L support to query audio inputs");
     1514#endif // !USING_V4L
     1515    return list;
     1516}
     1517
    14851518InputNames CardUtil::GetConfiguredDVBInputs(uint cardid)
    14861519{
    14871520    InputNames list;
    … …  
    15021535    return list;
    15031536}
    15041537
    1505 QStringList CardUtil::probeInputs(QString device, QString cardtype)
     1538QStringList CardUtil::ProbeVideoInputs(QString device, QString cardtype)
    15061539{
    15071540    QStringList ret;
    15081541
    … …  
    15141547        ret += "MPEG2TS";
    15151548    }
    15161549    else if ("DVB" == cardtype)
    1517         ret += probeDVBInputs(device);
     1550        ret += ProbeDVBInputs(device);
    15181551    else
    1519         ret += probeV4LInputs(device);
     1552        ret += ProbeV4LVideoInputs(device);
    15201553
    15211554    return ret;
    15221555}
    15231556
    1524 QStringList CardUtil::probeV4LInputs(QString device)
     1557QStringList CardUtil::ProbeAudioInputs(QString device, QString cardtype)
    15251558{
     1559    VERBOSE(VB_IMPORTANT, QString("ProbeAudioInputs(%1,%2)").arg(device).arg(cardtype));
     1560    QStringList ret;
     1561
     1562    if ("HDPVR" == cardtype)
     1563        ret += ProbeV4LAudioInputs(device);
     1564
     1565    return ret;
     1566}
     1567
     1568QStringList CardUtil::ProbeV4LVideoInputs(QString device)
     1569{
    15261570    bool ok;
    15271571    QStringList ret;
    15281572    int videofd = open(device.ascii(), O_RDWR);
    … …  
    15321576                           "to probe its inputs.").arg(device);
    15331577        return ret;
    15341578    }
    1535     InputNames list = CardUtil::probeV4LInputs(videofd, ok);
     1579    InputNames list = CardUtil::ProbeV4LVideoInputs(videofd, ok);
    15361580    close(videofd);
    15371581
    15381582    if (!ok)
    … …  
    15511595    return ret;
    15521596}
    15531597
    1554 QStringList CardUtil::probeDVBInputs(QString device)
     1598QStringList CardUtil::ProbeV4LAudioInputs(QString device)
    15551599{
     1600    VERBOSE(VB_IMPORTANT, QString("ProbeV4LAudioInputs(%1)").arg(device));
     1601
     1602    bool ok;
    15561603    QStringList ret;
     1604    int videofd = open(device.ascii(), O_RDWR);
     1605    if (videofd < 0)
     1606    {
     1607        VERBOSE(VB_IMPORTANT, QString("ProbeAudioInputs() -> couldn't open device"));
     1608        ret += QObject::tr("Could not open '%1' "
     1609                           "to probe its inputs.").arg(device);
     1610        return ret;
     1611    }
     1612    InputNames list = CardUtil::ProbeV4LAudioInputs(videofd, ok);
     1613    close(videofd);
    15571614
     1615    if (!ok)
     1616    {
     1617        ret += list[-1];
     1618        return ret;
     1619    }
     1620
     1621    InputNames::iterator it;
     1622    for (it = list.begin(); it != list.end(); ++it)
     1623    {
     1624        if (it.key() >= 0)
     1625            ret += *it;
     1626    }
     1627
     1628    return ret;
     1629}
     1630
     1631QStringList CardUtil::ProbeDVBInputs(QString device)
     1632{
     1633    QStringList ret;
     1634
    15581635#ifdef USING_DVB
    15591636    uint cardid = CardUtil::GetFirstCardID(device);
    15601637    if (!cardid)
    … …  
    16391716        inputs += "MPEG2TS";
    16401717    }
    16411718    else if ("DVB" != cardtype)
    1642         inputs += probeV4LInputs(device);
     1719        inputs += ProbeV4LVideoInputs(device);
    16431720
    16441721    QString dev_label = GetDeviceLabel(cardid, cardtype, device);
    16451722

  • libs/libmythtv/videosource.cpp

     
    15211521    input(new TunerCardInput(parent))
    15221522{
    15231523    VideoDevice *device =
    1524         new VideoDevice(parent, 0, 15, QString::null, "(ivtv|hdpvr)");
     1524        new VideoDevice(parent, 0, 15, QString::null, "ivtv");
    15251525
    15261526    cardinfo->setLabel(tr("Probed info"));
    15271527
    … …  
    15531553    input->fillSelections(device);
    15541554}
    15551555
     1556HDPVRConfigurationGroup::HDPVRConfigurationGroup(CaptureCard &a_parent) :
     1557    VerticalConfigurationGroup(false, true, false, false),
     1558    parent(a_parent), cardinfo(new TransLabelSetting()),
     1559    videoinput(new TunerCardInput(parent)),
     1560    audioinput(new TunerCardAudioInput(parent, QString::null, "HDPVR"))
     1561{
     1562    VideoDevice *device =
     1563        new VideoDevice(parent, 0, 15, QString::null, "hdpvr");
     1564
     1565    cardinfo->setLabel(tr("Probed info"));
     1566
     1567    addChild(device);
     1568    addChild(cardinfo);
     1569    addChild(videoinput);
     1570    addChild(audioinput);
     1571
     1572    connect(device, SIGNAL(valueChanged(const QString&)),
     1573            this,   SLOT(  probeCard(   const QString&)));
     1574
     1575    probeCard(device->getValue());
     1576}
     1577
     1578void HDPVRConfigurationGroup::probeCard(const QString &device)
     1579{
     1580    QString cn = tr("Failed to open"), ci = cn, dn = QString::null;
     1581
     1582    int videofd = open(device.ascii(), O_RDWR);
     1583    if (videofd >= 0)
     1584    {
     1585        if (!CardUtil::GetV4LInfo(videofd, cn, dn))
     1586            ci = cn = tr("Failed to probe");
     1587        else if (!dn.isEmpty())
     1588            ci = cn + "  [" + dn + "]";
     1589        close(videofd);
     1590    }
     1591
     1592    cardinfo->setValue(ci);
     1593    videoinput->fillSelections(device);
     1594    audioinput->fillSelections(device);
     1595}
     1596
    15561597CaptureCardGroup::CaptureCardGroup(CaptureCard &parent) :
    15571598    TriggeredConfigurationGroup(true, true, false, false)
    15581599{
    … …  
    15691610# ifdef USING_IVTV
    15701611    addTarget("MPEG",      new MPEGConfigurationGroup(parent));
    15711612# endif // USING_IVTV
     1613# ifdef USING_HDPVR
     1614    addTarget("HDPVR",     new HDPVRConfigurationGroup(parent));
     1615# endif // USING_HDPVR
    15721616#endif // USING_V4L
    15731617
    15741618#ifdef USING_DVB
    … …  
    17551799    setting->addSelection(
    17561800        QObject::tr("MPEG-2 encoder card (PVR-x50, PVR-500)"), "MPEG");
    17571801# endif // USING_IVTV
     1802# ifdef USING_HDPVR
     1803    setting->addSelection(
     1804        QObject::tr("H.264 encoder card (HD-PVR)"), "HDPVR");
     1805# endif // USING_HDPVR
    17581806#endif // USING_V4L
    17591807
    17601808#ifdef USING_DVB
    … …  
    29653013
    29663014    last_device = device;
    29673015    QStringList inputs =
    2968         CardUtil::probeInputs(device, last_cardtype);
     3016        CardUtil::ProbeVideoInputs(device, last_cardtype);
    29693017
    29703018    for (QStringList::iterator i = inputs.begin(); i != inputs.end(); ++i)
    29713019        addSelection(*i);
    29723020}
    29733021
     3022TunerCardAudioInput::TunerCardAudioInput(const CaptureCard &parent,
     3023                                         QString dev, QString type) :
     3024    ComboBoxSetting(this), CaptureCardDBStorage(this, parent, "audiodevice"),
     3025    last_device(dev), last_cardtype(type)
     3026{
     3027    setLabel(QObject::tr("Audio input"));
     3028    int cardid = parent.getCardID();
     3029    if (cardid <= 0)
     3030        return;
     3031
     3032    last_cardtype = CardUtil::GetRawCardType(cardid);
     3033    last_device   = CardUtil::GetAudioDevice(cardid);
     3034}
     3035
     3036void TunerCardAudioInput::fillSelections(const QString &device)
     3037{
     3038    clearSelections();
     3039
     3040    if (device.isEmpty())
     3041        return;
     3042
     3043    last_device = device;
     3044    QStringList inputs =
     3045        CardUtil::ProbeAudioInputs(device, last_cardtype);
     3046
     3047    for (uint i = 0; i < inputs.size(); i++)
     3048    {
     3049        addSelection(inputs[i], QString::number(i),
     3050                     last_device == QString::number(i));
     3051    }
     3052}
     3053
    29743054class DVBExtra : public ConfigurationWizard
    29753055{
    29763056  public:

  • libs/libmythtv/mpegrecorder.cpp

     
    9393    audbitratel1(14),         audbitratel2(14),
    9494    audbitratel3(10),
    9595    audvolume(80),            language(0),
     96    low_mpeg4avgbitrate(4500),    low_mpeg4peakbitrate(6000),
     97    medium_mpeg4avgbitrate(9000), medium_mpeg4peakbitrate(13500),
     98    high_mpeg4avgbitrate(13500),  high_mpeg4peakbitrate(20200),
    9699    // Input file descriptors
    97100    chanfd(-1),               readfd(-1),
    98101    // TS packet handling
    … …  
    178181    }
    179182    else if (opt == "mpeg2audvolume")
    180183        audvolume = value;
     184    else if (opt.right(16) == "_mpeg4avgbitrate")
     185    {
     186        if (opt.left(3) == "low")
     187            low_mpeg4avgbitrate = value;
     188        else if (opt.left(6) == "medium")
     189            medium_mpeg4avgbitrate = value;
     190        else if (opt.left(4) == "high")
     191            high_mpeg4avgbitrate = value;
     192        else
     193            RecorderBase::SetOption(opt, value);
     194    }
     195    else if (opt.right(17) == "_mpeg4peakbitrate")
     196    {
     197        if (opt.left(3) == "low")
     198            low_mpeg4peakbitrate = value;
     199        else if (opt.left(6) == "medium")
     200            medium_mpeg4peakbitrate = value;
     201        else if (opt.left(4) == "high")
     202            high_mpeg4peakbitrate = value;
     203        else
     204            RecorderBase::SetOption(opt, value);
     205    }
    181206    else
    182207        RecorderBase::SetOption(opt, value);
    183208}
    … …  
    274299        SetOption("videodevice", videodev);
    275300    }
    276301
     302    SetOption("audiodevice", audiodev);
     303
    277304    SetOption("tvformat", gContext->GetSetting("TVFormat"));
    278305    SetOption("vbiformat", gContext->GetSetting("VbiFormat"));
    279306
    … …  
    679706
    680707        add_ext_ctrl(ext_ctrls, V4L2_CID_MPEG_STREAM_TYPE,
    681708                     streamtype_ivtv_to_v4l2(GetFilteredStreamType()));
     709
    682710    }
     711    else
     712    {
     713        maxbitrate = high_mpeg4peakbitrate;
     714        bitrate    = high_mpeg4avgbitrate;
     715    }
    683716
    684717    add_ext_ctrl(ext_ctrls, V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
    685718                 maxbitrate * 1000);
    … …  
    732765        _keyframedist = ext_ctrl.value;
    733766    }
    734767
     768    bool ok;
     769    int audioinput = audiodevice.toUInt(&ok);
     770    if (ok)
     771    {
     772        struct v4l2_audio ain;
     773        bzero(&ain, sizeof(ain));
     774        ain.index = audioinput;
     775        if (ioctl(chanfd, VIDIOC_ENUMAUDIO, &ain) < 0)
     776        {
     777            VERBOSE(VB_IMPORTANT, LOC_WARN +
     778                    "Unable to get audio input.");
     779        }
     780        else
     781        {
     782            ain.index = audioinput;
     783            if (ioctl(chanfd, VIDIOC_S_AUDIO, &ain) < 0)
     784            {
     785                VERBOSE(VB_IMPORTANT, LOC_WARN +
     786                        "Unable to set audio input.");
     787            }
     788        }
     789    }
     790
    735791    return true;
    736792}
    737793

  • libs/libmythtv/tv_rec.cpp

     
    209209        CloseChannel();
    210210        init_run = true;
    211211#endif
    212         if (genOpt.cardtype != "MPEG")
     212        if ((genOpt.cardtype != "MPEG") && (genOpt.cardtype != "HDPVR"))
    213213            rbFileExt = "nuv";
    214214    }
    215215
    … …  
    952952 *  \brief Allocates and initializes the RecorderBase instance.
    953953 *
    954954 *  Based on the card type, one of the possible recorders are started.
    955  *  If the card type is "MPEG" a MpegRecorder is started,
     955 *  If the card type is "MPEG" or "HDPVR" a MpegRecorder is started,
    956956 *  if the card type is "HDHOMERUN" a HDHRRecorder is started,
    957957 *  if the card type is "FIREWIRE" a FirewireRecorder is started,
    958958 *  if the card type is "DVB" a DVBRecorder is started,
    … …  
    970970        recorder = new MpegRecorder(this);
    971971#endif // USING_IVTV
    972972    }
     973    if (genOpt.cardtype == "HDPVR")
     974    {
     975#ifdef USING_HDPVR
     976        recorder = new MpegRecorder(this);
     977#endif // USING_HDPVR
     978    }
    973979    else if (genOpt.cardtype == "FIREWIRE")
    974980    {
    975981#ifdef USING_FIREWIRE
    … …  
    25762582    long long bitrate;
    25772583    if (genOpt.cardtype == "MPEG")
    25782584        bitrate = 10080000LL; // use DVD max bit rate
     2585    if (genOpt.cardtype == "HDPVR")
     2586        bitrate = 20200000LL; // Peek bit rate for HD-PVR
    25792587    else if (genOpt.cardtype == "DBOX2")
    25802588        bitrate = 10080000LL; // use DVD max bit rate
    25812589    else if (!CardUtil::IsEncoder(genOpt.cardtype))

  • libs/libmythtv/recordingprofile.cpp

     
    652652    };
    653653};
    654654
    655 class MPEG2bitrate : public SliderSetting, public CodecParamStorage
     655class AverageBitrate : public SliderSetting, public CodecParamStorage
    656656{
    657657  public:
    658     MPEG2bitrate(const RecordingProfile &parent) :
    659         SliderSetting(this, 1000, 16000, 100),
    660         CodecParamStorage(this, parent, "mpeg2bitrate")
     658    AverageBitrate(const RecordingProfile &parent,
     659                   QString setting = "mpeg2bitrate",
     660                   uint min_br = 1000, uint max_br = 16000,
     661                   uint default_br = 4500, uint increment = 100,
     662                   QString label = QString::null) :
     663        SliderSetting(this, min_br, max_br, increment),
     664        CodecParamStorage(this, parent, setting)
    661665    {
    662 
    663         setLabel(QObject::tr("Bitrate"));
    664         setValue(4500);
    665         setHelpText(QObject::tr("Bitrate in kilobits/second.  2200Kbps is "
    666                     "approximately 1 Gigabyte per hour."));
     666        if (label.isEmpty())
     667            label = QObject::tr("Avg. Bitrate");
     668        setLabel(label);
     669        setValue(default_br);
     670        setHelpText(QObject::tr(
     671                        "Average bit rate in kilobits/second. "
     672                        "2200Kbps is approximately 1 Gigabyte per hour."));
    667673    };
    668674};
    669675
    670 class MPEG2maxBitrate : public SliderSetting, public CodecParamStorage
     676class PeakBitrate : public SliderSetting, public CodecParamStorage
    671677{
    672678  public:
    673     MPEG2maxBitrate(const RecordingProfile &parent) :
    674         SliderSetting(this, 1000, 16000, 100),
    675         CodecParamStorage(this, parent, "mpeg2maxbitrate")
     679    PeakBitrate(const RecordingProfile &parent,
     680                QString setting = "mpeg2maxbitrate",
     681                uint min_br = 1000, uint max_br = 16000,
     682                uint default_br = 6000, uint increment = 100,
     683                QString label = QString::null) :
     684        SliderSetting(this, min_br, max_br, increment),
     685        CodecParamStorage(this, parent, setting)
    676686    {
    677 
    678         setLabel(QObject::tr("Max. Bitrate"));
    679         setValue(6000);
    680         setHelpText(QObject::tr("Maximum Bitrate in kilobits/second.  "
     687        if (label.isEmpty())
     688            label = QObject::tr("Max. Bitrate");
     689        setLabel(label);
     690        setValue(default_br);
     691        setHelpText(QObject::tr("Maximum bit rate in kilobits/second. "
    681692                    "2200Kbps is approximately 1 Gigabyte per hour."));
    682693    };
    683694};
    … …  
    819830
    820831        params = new VerticalConfigurationGroup(false);
    821832        params->setLabel(QObject::tr("MPEG-2 Parameters"));
    822         params->addChild(new MPEG2bitrate(parent));
     833        params->addChild(new AverageBitrate(parent));
    823834        params->addChild(new ScaleBitrate(parent));
    824835        //params->addChild(new MPEG4MaxQuality(parent));
    825836        //params->addChild(new MPEG4MinQuality(parent));
    … …  
    843854        params->setLabel(QObject::tr("MPEG-2 Hardware Encoder"));
    844855        params->addChild(new MPEG2streamType(parent));
    845856        params->addChild(new MPEG2aspectRatio(parent));
    846         params->addChild(new MPEG2bitrate(parent));
    847         params->addChild(new MPEG2maxBitrate(parent));
     857        params->addChild(new AverageBitrate(parent));
     858        params->addChild(new PeakBitrate(parent));
    848859
    849860        addTarget("MPEG-2 Hardware Encoder", params);
     861
     862        params = new VerticalConfigurationGroup(false);
     863        params->setLabel(QObject::tr("MPEG-4 AVC Hardware Encoder"));
     864        ConfigurationGroup *h0 = new HorizontalConfigurationGroup(
     865            true, false, true, true);
     866        h0->setLabel(QObject::tr("Low Resolution"));
     867        h0->addChild(new AverageBitrate(parent, "low_mpeg4avgbitrate",
     868                                        1000, 13500, 4500, 500));
     869        h0->addChild(new PeakBitrate(parent, "low_mpeg4peakbitrate",
     870                                     1100, 20200, 6000, 500));
     871        params->addChild(h0);
     872        ConfigurationGroup *h1 = new HorizontalConfigurationGroup(
     873            true, false, true, true);
     874        h1->setLabel(QObject::tr("Medium Resolution"));
     875        h1->addChild(new AverageBitrate(parent, "medium_mpeg4avgbitrate",
     876                                        1000, 13500, 9000, 500));
     877        h1->addChild(new PeakBitrate(parent, "medium_mpeg4peakbitrate",
     878                                     1100, 20200, 11000, 500));
     879        params->addChild(h1);
     880        ConfigurationGroup *h2 = new HorizontalConfigurationGroup(
     881            true, false, true, true);
     882        h2->setLabel(QObject::tr("High Resolution"));
     883        h2->addChild(new AverageBitrate(parent, "high_mpeg4avgbitrate",
     884                                        1000, 13500, 13500, 500));
     885        h2->addChild(new PeakBitrate(parent, "high_mpeg4peakbitrate",
     886                                     1100, 20200, 20200, 500));
     887        params->addChild(h2);
     888        addTarget("MPEG-4 AVC Hardware Encoder", params);
    850889    }
    851890
    852891    void selectCodecs(QString groupType)
    853892    {
    854893        if (!groupType.isNull())
    855894        {
    856             if (groupType == "MPEG")
     895            if (groupType == "HDPVR")
     896               codecName->addSelection("MPEG-4 AVC Hardware Encoder");
     897            else if (groupType == "MPEG")
    857898               codecName->addSelection("MPEG-2 Hardware Encoder");
    858899            else if (groupType == "MJPEG")
    859900                codecName->addSelection("Hardware MJPEG");
    … …  
    12101251    if (isEncoder)
    12111252    {
    12121253        QString tvFormat = gContext->GetSetting("TVFormat");
    1213         addChild(new ImageSize(*this, tvFormat, profileName));
     1254        if (type.upper() != "HDPVR")
     1255            addChild(new ImageSize(*this, tvFormat, profileName));
    12141256
    12151257        videoSettings = new VideoCompressionSettings(*this, profileName);
    12161258        addChild(videoSettings);
    12171259
    1218         audioSettings = new AudioCompressionSettings(*this, profileName);
    1219         addChild(audioSettings);
     1260        if (type.upper() != "HDPVR")
     1261        {
     1262            audioSettings = new AudioCompressionSettings(*this, profileName);
     1263            addChild(audioSettings);
     1264        }
    12201265
    12211266        if (!profileName.isEmpty() && profileName.left(11) == "Transcoders")
    12221267        {

  • libs/libmythtv/scanwizardhelpers.cpp

     
    5959# ifdef USING_IVTV
    6060    cardTypes += ",'MPEG'";
    6161# endif // USING_IVTV
     62# ifdef USING_HDPVR
     63    cardTypes += ",'HDPVR'";
     64# endif // USING_HDPVR
    6265#endif // USING_V4L
    6366
    6467#ifdef USING_IPTV