Ticket #4308: eit_component_parsing.diff

File eit_component_parsing.diff, 25.2 KB (added by Janne Grunau, 13 years ago)
  • libs/libmythtv/eit.cpp

    old new  
    1111#include "mythdbcon.h"
    1212#include "eit.h"
    1313#include "dvbdescriptors.h"
     14#include "programinfo.h" // for subtitle types and audio and video properties
    1415
    1516DBPerson::DBPerson(Role _role, const QString &_name) :
    1617    role(_role), name(QDeepCopy<QString>(_name))
     
    132133        "SELECT title,          subtitle,      description, "
    133134        "       category,       category_type, "
    134135        "       starttime,      endtime, "
    135         "       closecaptioned, subtitled,     stereo,      hdtv, "
     136        "       closecaptioned,     stereo,      hdtv, "
    136137        "       partnumber,     parttotal, "
    137138        "       syndicatedepisodenumber, "
    138139        "       airdate,        originalairdate, "
     
    167168                     category_type,
    168169                     query.value(5).toDateTime(), query.value(6).toDateTime(),
    169170                     fixup,
    170                      query.value(7).toBool(),     query.value(8).toBool(),
    171                      query.value(9).toBool(),     query.value(10).toBool(),
    172                      QString::fromUtf8(query.value(16).toString()),
    173                      QString::fromUtf8(query.value(17).toString())
     171                     query.value(7).toUInt(),
     172                     query.value(8).toUInt(),
     173                     query.value(9).toUInt(),
     174                     QString::fromUtf8(query.value(15).toString()),
     175                     QString::fromUtf8(query.value(16).toString())
    174176                     );
    175177
    176         prog.partnumber = query.value(11).toUInt();
    177         prog.parttotal  = query.value(12).toUInt();
     178        prog.partnumber = query.value(10).toUInt();
     179        prog.parttotal  = query.value(11).toUInt();
    178180        prog.syndicatedepisodenumber =
    179                           QString::fromUtf8(query.value(13).toString());
    180         prog.airdate    = query.value(14).toString();
    181         prog.originalairdate = query.value(15).toDate();
     181                          QString::fromUtf8(query.value(12).toString());
     182        prog.airdate    = query.value(13).toString();
     183        prog.originalairdate = query.value(14).toDate();
    182184
    183         prog.previouslyshown = query.value(16).toBool();
     185        prog.previouslyshown = query.value(17).toBool();
    184186
    185187        programs.push_back(prog);
    186188        count++;
     
    326328
    327329    QString lcattype = myth_category_type_to_string(tmp);
    328330
    329     bool lcc        = IsCaptioned() | match.IsCaptioned();
    330     bool lstereo    = IsStereo()    | match.IsStereo();
    331     bool lsubtitled = IsSubtitled() | match.IsSubtitled();
    332     bool lhdtv      = IsHDTV()      | match.IsHDTV();
     331    unsigned char lsubtype = subtitleType | match.subtitleType;
     332    unsigned char laudio   = audioProps   | match.audioProps;
     333    unsigned char lvideo   = videoProps   | match.videoProps;
    333334
    334335    uint lpartnumber =
    335336        (!partnumber && match.partnumber) ? match.partnumber : partnumber;
     
    349350        "    description    = :DESC, "
    350351        "    category       = :CAT,       category_type = :CATTYPE, "
    351352        "    starttime      = :STARTTIME, endtime       = :ENDTIME, "
    352         "    closecaptioned = :CC,        subtitled     = :SUBTITLED, "
     353        "    closecaptioned = :CC, "
    353354        "    stereo         = :STEREO,    hdtv          = :HDTV, "
    354355        "    partnumber     = :PARTNO,    parttotal     = :PARTTOTAL, "
    355356        "    syndicatedepisodenumber = :SYNDICATENO, "
     
    369370    query.bindValue(":CATTYPE",     lcattype.utf8());
    370371    query.bindValue(":STARTTIME",   starttime);
    371372    query.bindValue(":ENDTIME",     endtime);
    372     query.bindValue(":CC",          lcc);
    373     query.bindValue(":SUBTITLED",   lsubtitled);
    374     query.bindValue(":STEREO",      lstereo);
    375     query.bindValue(":HDTV",        lhdtv);
     373    query.bindValue(":CC",          lsubtype);
     374    query.bindValue(":STEREO",      laudio);
     375    query.bindValue(":HDTV",        lvideo);
    376376    query.bindValue(":PARTNO",      lpartnumber);
    377377    query.bindValue(":PARTTOTAL",   lparttotal);
    378378    query.bindValue(":SYNDICATENO", lsyndicatedepisodenumber.utf8());
     
    504504        "  chanid,         title,          subtitle,        description, "
    505505        "  category,       category_type, "
    506506        "  starttime,      endtime, "
    507         "  closecaptioned, subtitled,      stereo,          hdtv, "
     507        "  closecaptioned,      stereo,          hdtv, "
    508508        "  partnumber,     parttotal, "
    509509        "  syndicatedepisodenumber, "
    510510        "  airdate,        originalairdate,listingsource, "
     
    513513        " :CHANID,        :TITLE,         :SUBTITLE,       :DESCRIPTION, "
    514514        " :CATEGORY,      :CATTYPE, "
    515515        " :STARTTIME,     :ENDTIME, "
    516         " :CC,            :SUBTITLED,     :STEREO,         :HDTV, "
     516        " :CC,            :STEREO,         :HDTV, "
    517517        " :PARTNUMBER,    :PARTTOTAL, "
    518518        " :SYNDICATENO, "
    519519        " :AIRDATE,       :ORIGAIRDATE,   :LSOURCE, "
     
    529529    query.bindValue(":CATTYPE",     cattype.utf8());
    530530    query.bindValue(":STARTTIME",   starttime);
    531531    query.bindValue(":ENDTIME",     endtime);
    532     query.bindValue(":CC",          IsCaptioned());
    533     query.bindValue(":SUBTITLED",   IsSubtitled());
    534     query.bindValue(":STEREO",      IsStereo());
    535     query.bindValue(":HDTV",        IsHDTV());
     532    query.bindValue(":CC",          subtitleType);
     533    query.bindValue(":STEREO",      audioProps);
     534    query.bindValue(":HDTV",        videoProps);
    536535    query.bindValue(":PARTNUMBER",  partnumber);
    537536    query.bindValue(":PARTTOTAL",   parttotal);
    538537    query.bindValue(":SYNDICATENO", syndicatedepisodenumber.utf8());
  • libs/libmythtv/eit.h

    old new  
    5858            const QString   &_category,  uint             _category_type,
    5959            const QDateTime &_start,     const QDateTime &_end,
    6060            uint             _fixup,
    61             bool             _captioned, bool _subtitled,
    62             bool             _stereo,    bool _hdtv,
     61            unsigned char    _subtitleType,
     62            unsigned char    _audioProps,
     63            unsigned char    _videoProps,
    6364            const QString   &_seriesId,  const QString   &_programId) :
    6465        title(_title),           subtitle(_subtitle),
    6566        description(_desc),
     
    7071        chanid(_chanid),
    7172        partnumber(0),           parttotal(0),
    7273        syndicatedepisodenumber(QString::null),
    73         fixup(_fixup),           flags(0),
     74        fixup(_fixup),
     75        subtitleType(_subtitleType),
     76        audioProps(_audioProps), videoProps(_videoProps),
    7477        category_type(_category_type),
    7578        seriesId(_seriesId),
    7679        programId(_programId),
    7780        previouslyshown(false)
    7881    {
    79         flags |= (_captioned) ? kCaptioned : 0;
    80         flags |= (_subtitled) ? kSubtitled : 0;
    81         flags |= (_stereo)    ? kStereo    : 0;
    82         flags |= (_hdtv)      ? kHDTV      : 0;
    8382    }
    8483
    8584    DBEvent(uint             _chanid,
    8685            const QString   &_title,     const QString   &_desc,
    8786            const QDateTime &_start,     const QDateTime &_end,
    8887            uint             _fixup,
    89             bool             _captioned, bool             _stereo) :
     88            unsigned char    _subtitleType,
     89            unsigned char    _audioProps,
     90            unsigned char    _videoProps) :
    9091        title(_title),           subtitle(QString::null),
    9192        description(_desc),
    9293        category(QString::null),
     
    9697        chanid(_chanid),
    9798        partnumber(0),           parttotal(0),
    9899        syndicatedepisodenumber(QString::null),
    99         fixup(_fixup),           flags(0),
     100        fixup(_fixup),
     101        subtitleType(_subtitleType),
     102        audioProps(_audioProps), videoProps(_videoProps),
    100103        category_type(0/*kCategoryNone*/), previouslyshown(false)
    101104    {
    102         flags |= (_captioned) ? kCaptioned : 0;
    103         flags |= (_stereo)    ? kStereo    : 0;
    104105    }
    105106
    106107    ~DBEvent() { if (credits) delete credits; }
     
    109110
    110111    uint UpdateDB(MSqlQuery &query, int match_threshold) const;
    111112
    112     bool IsCaptioned(void) const { return flags & kCaptioned; }
    113     bool IsSubtitled(void) const { return flags & kSubtitled; }
    114     bool IsStereo(void)    const { return flags & kStereo;    }
    115     bool IsHDTV(void)      const { return flags & kHDTV;      }
    116113    bool HasCredits(void)  const { return credits;            }
    117114
    118115  private:
     
    139136    uint16_t      parttotal;
    140137    QString       syndicatedepisodenumber;
    141138    uint32_t      fixup;
    142     unsigned char flags;
     139    unsigned char subtitleType;
     140    unsigned char audioProps;
     141    unsigned char videoProps;
    143142    unsigned char category_type;
    144143    QString       seriesId;
    145144    QString       programId;
    146145    bool          previouslyshown;
    147 
    148     static const unsigned char kCaptioned = 0x1;
    149     static const unsigned char kSubtitled = 0x2;
    150     static const unsigned char kStereo    = 0x4;
    151     static const unsigned char kHDTV      = 0x8;
    152146};
    153147
    154148#endif // _EIT_H_
  • libs/libmythtv/eithelper.cpp

    old new  
    1919#include "dishdescriptors.h"
    2020#include "premieredescriptors.h"
    2121#include "util.h"
     22#include "programinfo.h" // for subtitle types and audio and video properties
    2223
    2324const uint EITHelper::kChunkSize = 20;
    2425EITCache *EITHelper::eitcache = new EITCache();
     
    279280}
    280281
    281282static inline void parse_dvb_component_descriptors(desc_list_t list,
    282                                                    bool &hdtv,
    283                                                    bool &stereo,
    284                                                    bool &subtitled)
     283                                                   unsigned char &subtitle_type,
     284                                                   unsigned char &audio_properties,
     285                                                   unsigned char &video_properties)
    285286{
    286287    desc_list_t components =
    287288        MPEGDescriptor::FindAll(list, DescriptorID::component);
    288289    for (uint j = 0; j < components.size(); j++)
    289290    {
    290291        ComponentDescriptor component(components[j]);
    291         hdtv      |= component.IsHDTV();
    292         stereo    |= component.IsStereo();
    293         subtitled |= component.IsReallySubtitled();
     292        video_properties |= component.VideoProperties();
     293        audio_properties |= component.AudioProperties();
     294        subtitle_type    |= component.SubtitleType();
    294295    }
    295296}
    296297
     
    327328        QString description   = QString::null;
    328329        QString category      = QString::null;
    329330        MythCategoryType category_type = kCategoryNone;
    330         bool hdtv = false, stereo = false, subtitled = false;
     331        unsigned char subtitle_type, audio_props, video_props;
    331332
    332333        // Parse descriptors
    333334        desc_list_t list = MPEGDescriptor::Parse(
     
    358359                                        title, subtitle, description);
    359360        }
    360361
    361         parse_dvb_component_descriptors(list, hdtv, stereo, subtitled);
     362        parse_dvb_component_descriptors(list, subtitle_type, audio_props,
     363                                        video_props);
    362364
    363365        const unsigned char *content_data =
    364366            MPEGDescriptor::Find(list, DescriptorID::content);
     
    395397                                     title,     subtitle,      description,
    396398                                     category,  category_type,
    397399                                     starttime, endtime,       fix,
    398                                      false,     subtitled,
    399                                      stereo,    hdtv,
     400                                     subtitle_type,
     401                                     audio_props,
     402                                     video_props,
    400403                                     seriesId,  programId);
    401404        db_events.enqueue(event);
    402405    }
     
    415418    QString description   = QString::null;
    416419    QString category      = QString::null;
    417420    MythCategoryType category_type = kCategoryNone;
    418     bool hdtv = false, stereo = false, subtitled = false;
     421    unsigned char subtitle_type, audio_props, video_props;
    419422
    420423    // Parse descriptors
    421424    desc_list_t list = MPEGDescriptor::Parse(
     
    424427    parse_dvb_event_descriptors(list, fix, languagePreferences,
    425428                                title, subtitle, description);
    426429
    427     parse_dvb_component_descriptors(list, hdtv, stereo, subtitled);
     430    parse_dvb_component_descriptors(list, subtitle_type, audio_props,
     431                                    video_props);
    428432
    429433    const unsigned char *content_data =
    430434        MPEGDescriptor::Find(list, DescriptorID::content);
     
    495499                                         title,     subtitle,      description,
    496500                                         category,  category_type,
    497501                                         starttime, endtime,       fix,
    498                                          false,     subtitled,
    499                                          stereo,    hdtv,
     502                                         subtitle_type,
     503                                         audio_props,
     504                                         video_props,
    500505                                         "",  "");
    501506            db_events.enqueue(event);
    502507        }
     
    547552    QDateTime endtime = starttime.addSecs(event.length);
    548553
    549554    desc_list_t list = MPEGDescriptor::Parse(event.desc, event.desc_length);
    550     bool captioned = MPEGDescriptor::Find(list, DescriptorID::caption_service);
    551     bool stereo = false;
     555    unsigned char subtitle_type =
     556        MPEGDescriptor::Find(list, DescriptorID::caption_service) ?
     557        SUB_HARDHEAR : SUB_UNKNOWN;
     558    unsigned char audio_properties = AUD_UNKNOWN;
     559    unsigned char video_properties = VID_UNKNOWN;
    552560
    553561    uint atsc_key = (atsc_major << 16) | atsc_minor;
    554562
     
    556564    db_events.enqueue(new DBEvent(chanid, QDeepCopy<QString>(event.title),
    557565                                  QDeepCopy<QString>(ett),
    558566                                  starttime, endtime,
    559                                   fixup[atsc_key], captioned, stereo));
     567                                  fixup[atsc_key], subtitle_type,
     568                                  audio_properties, video_properties));
    560569}
    561570
    562571uint EITHelper::GetChanID(uint atsc_major, uint atsc_minor)
  • libs/libmythtv/mpeg/dvbdescriptors.h

    old new  
    1010#include <qstring.h>
    1111#include "mythcontext.h"
    1212#include "mpegdescriptors.h"
     13#include "../programinfo.h" // for subtitle types and audio and video properties
    1314
    1415using namespace std;
    1516
     
    333334    //
    334335    // for (i=0; i<N; i++) { text_char 8 }
    335336
    336     bool IsVideo(void)    const { return 0x1 == StreamContent(); }
    337     bool IsAudio(void)    const { return 0x2 == StreamContent(); }
     337    bool IsVideo(void) const
     338    {
     339        return 0x1 == StreamContent() ||
     340               0x5 == StreamContent();
     341    }
     342    bool IsAudio(void) const
     343    {
     344        switch(StreamContent())
     345        {
     346            case 0x02:
     347            case 0x04:
     348            case 0x06:
     349            case 0x07:
     350                return true;
     351            default:
     352                return false;
     353        }
     354    }
    338355    bool IsSubtitle(void) const { return 0x3 == StreamContent(); }
    339356
    340     bool IsHDTV(void) const
     357    unsigned char VideoProperties(void) const
    341358    {
    342         return IsVideo() && 0x9 <= ComponentType() && ComponentType() <= 0x10;
     359        if (0x1 == StreamContent())
     360            return MPEG2Properties();
     361        if (0x5 == StreamContent())
     362            return VID_AVC || AVCProperties();
     363
     364        return VID_UNKNOWN;
    343365    }
    344366
    345     bool IsStereo(void) const
     367    unsigned char MPEG2Properties(void) const
    346368    {
    347         return IsAudio() &&
    348             ((0x3 == ComponentType()) || (0x5 == ComponentType()));
     369        switch(ComponentType())
     370        {
     371            case 0x2 ... 0x4:
     372            case 0x6 ... 0x8:
     373                return VID_WIDESCREEN;
     374            case 0x09:
     375            case 0x0D:
     376                return VID_HDTV;
     377            case 0x0A ... 0x0C:
     378            case 0x0E ... 0x10:
     379                return VID_WIDESCREEN | VID_HDTV;
     380            default:
     381                return VID_UNKNOWN;
     382        }
    349383    }
    350384
    351     bool IsReallySubtitled(void) const
     385    unsigned char AVCProperties(void) const
     386    {
     387        switch(ComponentType())
     388        {
     389            case 0x3 ... 0x4:
     390            case 0x7 ... 0x8:
     391                return VID_WIDESCREEN;
     392            case 0x0B ... 0x0C:
     393            case 0x0F ... 0x10:
     394                return VID_WIDESCREEN | VID_HDTV;
     395            default:
     396                return VID_UNKNOWN;
     397        }
     398    }
     399
     400    unsigned char AudioProperties(void) const
     401    {
     402        switch (StreamContent())
     403        {
     404            case 0x2:
     405                return MP2Properties();
     406            case 0x04:
     407                return AC3Properties();
     408            case 0x06:
     409                return HEAACProperties();
     410            default:
     411                return AUD_UNKNOWN;
     412        }
     413    }
     414
     415    unsigned char MP2Properties(void) const
     416    {
     417        switch (ComponentType())
     418        {
     419            case 0x1:
     420                return AUD_MONO;
     421            case 0x3:
     422                return AUD_STEREO;
     423            case 0x5:
     424                return AUD_SURROUND;
     425            case 0x40:
     426                return AUD_VISUALIMPAIR;
     427            case 0x41:
     428                return AUD_HARDHEAR;
     429            default:
     430                return AUD_UNKNOWN;
     431        }
     432    }
     433
     434    unsigned char AC3Properties(void) const
     435    {
     436        unsigned char properties = AUD_UNKNOWN;
     437
     438        switch (ComponentType() & 0x7)
     439        {
     440            case 0x0:
     441                properties |= AUD_MONO;
     442                break;
     443            case 0x2:
     444                properties |= AUD_STEREO;
     445                break;
     446            case 0x3:
     447                properties |= AUD_DOLBY;
     448                break;
     449            case 0x4 ... 0x5:
     450                properties |= AUD_SURROUND;
     451                break;
     452        }
     453
     454        if ((ComponentType() >> 3) & 0x7 == 0x2)
     455            properties |= AUD_VISUALIMPAIR;
     456
     457        if ((ComponentType() >> 3) & 0x7 == 0x3)
     458            properties |= AUD_HARDHEAR;
     459
     460        return properties;
     461    }
     462
     463    unsigned char HEAACProperties(void) const
     464    {
     465        switch (ComponentType())
     466        {
     467            case 0x1:
     468                return AUD_MONO;
     469            case 0x3:
     470            case 0x43:
     471                return AUD_STEREO;
     472            case 0x5:
     473                return AUD_SURROUND;
     474            case 0x40:
     475            case 0x44:
     476                return AUD_VISUALIMPAIR;
     477            case 0x41:
     478            case 0x45:
     479                return AUD_HARDHEAR;
     480            default:
     481                return AUD_UNKNOWN;
     482        }
     483    }
     484
     485    unsigned char SubtitleType(void) const
    352486    {
    353487        if (!IsSubtitle())
    354             return false;
     488            return SUB_UNKNOWN;
     489
    355490        switch (ComponentType())
    356491        {
    357492            case 0x1:
    358493            case 0x3:
    359494            case 0x10 ... 0x13:
     495                return SUB_NORMAL;
    360496            case 0x20 ... 0x23:
    361                 return true;
     497                return SUB_HARDHEAR;
    362498            default:
    363                 return false;
     499                return SUB_UNKNOWN;
    364500        }
    365501    }
    366502
    367     QString toString() const { return QString("ComponentDescriptor(stub)"); }
     503        QString toString() const { return QString("ComponentDescriptor(stream_content: 0x%1, "
     504                                                  "component_type: 0x%2)").arg(StreamContent(), 0, 16)
     505                .arg(ComponentType(), 0, 16); }
    368506};
    369507
    370508typedef enum
  • libs/libmythtv/programinfo.h

    old new  
    6262    AUD_STEREO        = 0x01,
    6363    AUD_MONO          = 0x02,
    6464    AUD_SURROUND      = 0x04,
    65     AUD_DOLBY         = 0x08
     65    AUD_DOLBY         = 0x08,
     66    AUD_HARDHEAR      = 0x10,
     67    AUD_VISUALIMPAIR  = 0x20,
    6668};
    6769
    6870enum VideoProps {
    6971    VID_UNKNOWN       = 0x00, // For backwards compatibility do not change 0 or 1
    7072    VID_HDTV          = 0x01,
    71     VID_WIDESCREEN    = 0x02
     73    VID_WIDESCREEN    = 0x02,
     74    VID_AVC           = 0x04,
    7275};
    7376
    7477enum SubtitleTypes {
  • libs/libmythtv/eitfixup.cpp

    old new  
    22#include "mythcontext.h"
    33#include "dvbdescriptors.h" // for MythCategoryType
    44
     5#include "programinfo.h" // for subtitle types and audio and video properties
     6
    57/*------------------------------------------------------------------------
    68 * Event Fix Up Scripts - Turned on by entry in dtv_privatetype table
    79 *------------------------------------------------------------------------*/
     
    117119    }
    118120
    119121    if (kFixHDTV & event.fixup)
    120         event.flags |= DBEvent::kHDTV;
     122        event.videoProps |= VID_HDTV;
    121123
    122124    if (kFixBell & event.fixup)
    123125        FixBellExpressVu(event);
     
    237239    position = event.description.find("(CC)");
    238240    if (position != -1)
    239241    {
    240         event.flags |= DBEvent::kCaptioned;
     242        event.subtitleType |= SUB_HARDHEAR;
    241243        event.description = event.description.replace("(CC)", "");
    242244    }
    243245
     
    245247    position = event.description.find("(Stereo)");
    246248    if (position != -1)
    247249    {
    248         event.flags |= DBEvent::kStereo;
     250        event.audioProps |= AUD_STEREO;
    249251        event.description = event.description.replace("(Stereo)", "");
    250252    }
    251253
     
    261263    if (position != -1)
    262264    {
    263265        event.title = event.title.replace(m_bellPPVTitleHD, "");
    264         event.flags |= DBEvent::kHDTV;
     266        event.videoProps |= VID_HDTV;
    265267    }
    266268
    267269    // Check for subtitle "All Day (... Eastern)" in the subtitle
     
    347349    position1 = event.description.find(m_ukSubtitle);
    348350    if (position1 != -1)
    349351    {
    350         event.flags |= DBEvent::kSubtitled;
     352        event.subtitleType |= SUB_NORMAL;
    351353        event.description.remove(m_ukSubtitle);
    352354    }
    353355
     
    545547        for (it = captures.begin(); it != captures.end(); ++it)
    546548        {
    547549            if (*it == "S")
    548                 event.flags |= DBEvent::kSubtitled;
     550                event.subtitleType |= SUB_NORMAL;
    549551        }
    550552    }
    551553    else if ((position1 = tmpUKCC.search(event.subtitle)) != -1)
     
    554556        for (it = captures.begin(); it != captures.end(); ++it)
    555557        {
    556558            if (*it == "S")
    557                 event.flags |= DBEvent::kSubtitled;
     559                event.subtitleType |= SUB_NORMAL;
    558560        }
    559561
    560562        // We remove [AD,S] from the subtitle.
     
    790792    int position = event.description.find(m_comHemTT);
    791793    if (position != -1)
    792794    {
    793         event.flags |= DBEvent::kSubtitled;
     795        event.subtitleType |= SUB_NORMAL;
    794796    }
    795797
    796798    // Try to findout if this is a rerun and if so the date.
     
    917919    position = event.description.find(m_mcaCC);
    918920    if (position > 0)
    919921    {
    920         event.flags |= DBEvent::kCaptioned;
     922        event.subtitleType |= SUB_HARDHEAR;
    921923        event.description.replace(m_mcaCC, "");
    922924    }
    923925
     
    925927    position = event.description.find(m_mcaDD);
    926928    if ((position > 0) && (position > (int) (event.description.length() - 7)))
    927929    {
    928         event.flags |= DBEvent::kStereo;
     930        event.audioProps |= AUD_STEREO;
    929931        dd = true;
    930932        event.description.replace(m_mcaDD, "");
    931933    }
     
    10811083    position = event.description.find(m_Stereo);
    10821084    if (position != -1)
    10831085    {
    1084         event.flags |= DBEvent::kStereo;
     1086        event.audioProps |= AUD_STEREO;
    10851087        event.description = event.description.replace(m_Stereo, "");
    10861088    }
    10871089}
     
    12141216    int position;
    12151217    if ((position = fullinfo.find(m_nlStereo)) != -1)
    12161218    {
    1217         event.flags |= DBEvent::kStereo;
     1219        event.audioProps |= AUD_STEREO;
    12181220        fullinfo = fullinfo.replace("stereo", ".");
    12191221    }
    12201222   
     
    12331235    // Get teletext subtitle info
    12341236    if ((position = fullinfo.find(m_nlTxt)) != -1)
    12351237    {
    1236         event.flags |= DBEvent::kSubtitled;
     1238        event.subtitleType |= SUB_NORMAL;
    12371239        fullinfo = fullinfo.replace("txt", ".");
    12381240    }
    12391241   
    12401242    // Get HDTV information
    12411243    if ((position = event.title.find(m_nlHD)) != -1)
    12421244    {
    1243         event.flags |= DBEvent::kHDTV;
     1245        event.videoProps |= VID_HDTV;
    12441246        event.title = event.title.replace(m_nlHD, "");
    12451247    }
    12461248