MythTV: mpegdescriptors.cpp Source File

00001 // -*- Mode: c++ -*-
00002 // Copyright (c) 2005, Daniel Thor Kristjansson
00003 
00004 #include <limits.h>
00005 
00006 #include "sctedescriptors.h"
00007 #include "atscdescriptors.h"
00008 #include "dvbdescriptors.h"
00009 #include "mythmiscutil.h" // for xml_indent
00010 
00011 QMutex                RegistrationDescriptor::description_map_lock;
00012 bool                  RegistrationDescriptor::description_map_initialized = false;
00013 QMap<QString,QString> RegistrationDescriptor::description_map;
00014 
00015 desc_list_t MPEGDescriptor::Parse(
00016     const unsigned char *data, uint len)
00017 {
00018     desc_list_t tmp;
00019     uint off = 0;
00020     while (off < len)
00021     {
00022         tmp.push_back(data+off);
00023         MPEGDescriptor desc(data+off, len-off);
00024         if (!desc.IsValid())
00025         {
00026             tmp.pop_back();
00027             break;
00028         }
00029         off += desc.size();
00030     }
00031     return tmp;
00032 }
00033 
00034 desc_list_t MPEGDescriptor::ParseAndExclude(
00035     const unsigned char *data, uint len, int excluded_descid)
00036 {
00037     desc_list_t tmp;
00038     uint off = 0;
00039     while (off < len)
00040     {
00041         if ((data+off)[0] != excluded_descid)
00042             tmp.push_back(data+off);
00043         MPEGDescriptor desc(data+off, len-off);
00044         if (!desc.IsValid())
00045         {
00046             if ((data+off)[0] != excluded_descid)
00047                 tmp.pop_back();
00048             break;
00049         }
00050         off += desc.size();
00051     }
00052     return tmp;
00053 }
00054 
00055 #include "mythlogging.h"
00056 
00057 desc_list_t MPEGDescriptor::ParseOnlyInclude(
00058     const unsigned char *data, uint len, int excluded_descid)
00059 {
00060     desc_list_t tmp;
00061     uint off = 0;
00062     while (off < len)
00063     {
00064         if ((data+off)[0] == excluded_descid)
00065             tmp.push_back(data+off);
00066         MPEGDescriptor desc(data+off, len-off);
00067         if (!desc.IsValid())
00068         {
00069             if ((data+off)[0] == excluded_descid)
00070                 tmp.pop_back();
00071             break;
00072         }
00073         off += desc.size();
00074     }
00075     return tmp;
00076 }
00077 
00078 const unsigned char *MPEGDescriptor::Find(const desc_list_t &parsed,
00079                                           uint desc_tag)
00080 {
00081     desc_list_t::const_iterator it = parsed.begin();
00082     for (; it != parsed.end(); ++it)
00083     {
00084         if ((*it)[0] == desc_tag)
00085             return *it;
00086     }
00087     return NULL;
00088 }
00089 
00090 desc_list_t MPEGDescriptor::FindAll(const desc_list_t &parsed, uint desc_tag)
00091 {
00092     desc_list_t tmp;
00093     desc_list_t::const_iterator it = parsed.begin();
00094     for (; it != parsed.end(); ++it)
00095     {
00096         if ((*it)[0] == desc_tag)
00097             tmp.push_back(*it);
00098     }
00099     return tmp;
00100 }
00101 
00102 static uint maxPriority(const QMap<uint,uint> &langPrefs)
00103 {
00104     uint max_pri = 0;
00105     QMap<uint,uint>::const_iterator it = langPrefs.begin();
00106     for (; it != langPrefs.end(); ++it)
00107         max_pri = max(max_pri, *it);
00108     return max_pri;
00109 }
00110 
00111 const unsigned char *MPEGDescriptor::FindBestMatch(
00112     const desc_list_t &parsed, uint desc_tag, QMap<uint,uint> &langPrefs)
00113 {
00114     uint match_idx = 0;
00115     uint match_pri = UINT_MAX;
00116     int  unmatched_idx = -1;
00117 
00118     uint i = (desc_tag == DescriptorID::short_event) ? 0 : parsed.size();
00119     for (; i < parsed.size(); i++)
00120     {
00121         if (DescriptorID::short_event == parsed[i][0])
00122         {
00123             ShortEventDescriptor sed(parsed[i]);
00124             QMap<uint,uint>::const_iterator it =
00125                 langPrefs.find(sed.CanonicalLanguageKey());
00126 
00127             if ((it != langPrefs.end()) && (*it < match_pri))
00128             {
00129                 match_idx = i;
00130                 match_pri = *it;
00131             }
00132 
00133             if (unmatched_idx < 0)
00134                 unmatched_idx = i;
00135         }
00136     }
00137 
00138     if (match_pri != UINT_MAX)
00139         return parsed[match_idx];
00140 
00141     if ((desc_tag == DescriptorID::short_event) && (unmatched_idx >= 0))
00142     {
00143         ShortEventDescriptor sed(parsed[unmatched_idx]);
00144         langPrefs[sed.CanonicalLanguageKey()] = maxPriority(langPrefs) + 1;
00145         return parsed[unmatched_idx];
00146     }
00147 
00148     return NULL;
00149 }
00150 
00151 desc_list_t MPEGDescriptor::FindBestMatches(
00152     const desc_list_t &parsed, uint desc_tag, QMap<uint,uint> &langPrefs)
00153 {
00154     uint match_pri = UINT_MAX;
00155     int  match_key = 0;
00156     int  unmatched_idx = -1;
00157 
00158     uint i = (desc_tag == DescriptorID::extended_event) ? 0 : parsed.size();
00159     for (; i < parsed.size(); i++)
00160     {
00161         if (DescriptorID::extended_event == parsed[i][0])
00162         {
00163             ExtendedEventDescriptor eed(parsed[i]);
00164             QMap<uint,uint>::const_iterator it =
00165                 langPrefs.find(eed.CanonicalLanguageKey());
00166 
00167             if ((it != langPrefs.end()) && (*it < match_pri))
00168             {
00169                 match_key = eed.LanguageKey();
00170                 match_pri = *it;
00171             }
00172 
00173             if (unmatched_idx < 0)
00174                 unmatched_idx = i;
00175         }
00176     }
00177 
00178     if ((desc_tag == DescriptorID::extended_event) &&
00179         (match_key == 0) && (unmatched_idx >= 0))
00180     {
00181         ExtendedEventDescriptor eed(parsed[unmatched_idx]);
00182         langPrefs[eed.CanonicalLanguageKey()] = maxPriority(langPrefs) + 1;
00183         match_key = eed.LanguageKey();
00184     }
00185 
00186     desc_list_t tmp;
00187     if (match_pri == UINT_MAX)
00188         return tmp;
00189 
00190     for (uint i = 0; i < parsed.size(); i++)
00191     {
00192         if ((DescriptorID::extended_event == desc_tag) &&
00193             (DescriptorID::extended_event == parsed[i][0]))
00194         {
00195             ExtendedEventDescriptor eed(parsed[i]);
00196             if (eed.LanguageKey() == match_key)
00197                 tmp.push_back(parsed[i]);
00198         }
00199     }
00200 
00201     return tmp;
00202 }
00203 
00204 #define EMPTY_STR_16 "","","","", "","","","", "","","","", "","","","",
00205 
00206 const char *descriptor_tag_strings[256] =
00207 {
00208     /* 0x00 */ "",                      /* 0x01 */ "",
00209     /* 0x02 */ "Video",                 /* 0x03 */ "Audio",
00210     /* 0x04 */ "Hierarchy",             /* 0x05 */ "Registration",
00211     /* 0x06 */ "Data Stream Alignment", /* 0x07 */ "Target Background Grid",
00212     /* 0x08 */ "Video Window",          /* 0x09 */ "Conditional Access",
00213     /* 0x0A */ "ISO-639 Language",      /* 0x0B */ "System Clock",
00214     /* 0x0C */ "Multiplex Buffer Utilization", /* 0x0D */ "Copyright",
00215     /* 0x0E */ "Maximum Bitrate",       /* 0x0F */ "Private Data Indicator",
00216 
00217     /* 0x10 */ "Smooting Buffer",       /* 0x11 */ "STD",
00218     /* 0x12 */ "IBP",                   /* 0x13 */ "DSM-CC Carousel Identifier",
00219     /* 0x14 */ "DSM-CC Association Tag",
00220     /* 0x15 */ "DSM-CC Deferred Association Tag",
00221     /* 0x16 */ "Reserved(0x16)",        /* 0x17 */ "DSM-CC NPT Reference",
00222     /* 0x18 */ "DSM-CC NPT Endpoint",   /* 0x19 */ "DSM-CC Stream Mode",
00223     /* 0x1A */ "DSM-CC Stream Event",   /* 0x1B */ "MPEG-4 Video",
00224     /* 0x1C */ "MPEG-4 Audio",          /* 0x1D */ "IOD",
00225     /* 0x1E */ "SL",                    /* 0x1F */ "FMC",
00226     
00227     /* 0x20 */ "External ES ID",        /* 0x21 */ "Multimpex Code",
00228     /* 0x22 */ "FMX buffer Size",       /* 0x23 */ "Multiplex Buffer",
00229     /* 0x24 */ "Content Labeling",      /* 0x25 */ "Metadata Pointer",
00230     /* 0x26 */ "Metadata",              /* 0x27 */ "Metadata Std",
00231     /* 0x28 */ "AVC Video",             /* 0x29 */ "IPMP DRM",
00232     /* 0x2A */ "AVC Timing & HRD",      /* 0x2B */ "AAC Audio",
00233     /* 0x2C */ "Flex Mux Timing",       /* 0x2D */ "",
00234     /* 0x2E */ "",                      /* 0x2F */ "",
00235 
00236     /* 0x30-0x3F */ EMPTY_STR_16
00237 
00238     /* 0x40 */ "Network Name",          /* 0x41 */ "Service List",
00239     /* 0x42 */ "DVB Stuffing",          /* 0x43 */ "Satellite Delivery System",
00240     /* 0x44 */ "Cable Delivery System", /* 0x45 */ "VBI Data",
00241     /* 0x46 */ "VBI Teletext",          /* 0x47 */ "Bouquet Name",
00242     /* 0x48 */ "Service",               /* 0x49 */ "Country Availability",
00243     /* 0x4A */ "Linkage",               /* 0x4B */ "NVOD Reference",
00244     /* 0x4C */ "DVB Time-shifted Service",/* 0x4D */ "Short Event",
00245     /* 0x4E */ "Extended Event",        /* 0x4F */ "Time-shifted Event",
00246 
00247     /* 0x50 */ "Component",             /* 0x51 */ "Mosaic",
00248     /* 0x52 */ "Stream Identifier",
00249     /* 0x53 */ "Conditional Access Identifier",
00250     /* 0x54 */ "Content",               /* 0x55 */ "Parental Rating",
00251     /* 0x56 */ "Teletext",              /* 0x57 */ "Telephone",
00252     /* 0x58 */ "Local Time Offset",     /* 0x59 */ "Subtitling",
00253     /* 0x5A */ "Terrestrial Delivery System",
00254     /* 0x5B */ "Multilingual Network Name",
00255     /* 0x5C */ "Multilingual Bouquet Name",
00256     /* 0x5D */ "Multilingual Service Name",
00257     /* 0x5E */ "Multilingual Component",
00258     /* 0x5F */ "Private Data Specifier",
00259 
00260     /* 0x60 */ "Service Move",          /* 0x61 */ "Short Smoothing Buffer",
00261     /* 0x62 */ "Frequency List",        /* 0x63 */ "Partial Transport Stream",
00262     /* 0x64 */ "Data Broadcast",        /* 0x65 */ "Scrambling",
00263     /* 0x66 */ "Data Broadcast ID",     /* 0x67 */ "Transport Stream",
00264     /* 0x68 */ "DSNG",                  /* 0x69 */ "PDC",
00265     /* 0x6A */ "AC-3",                  /* 0x6B */ "Ancillary Data",
00266     /* 0x6C */ "Cell List",             /* 0x6D */ "Cell Frequency Link",
00267     /* 0x6E */ "Announcement Support",  /* 0x6F */ "Application Signalling",
00268 
00269     /* 0x70 */ "Adaptation Field Data", /* 0x71 */ "Service Identifier",
00270     /* 0x72 */ "Service Availability",  /* 0x73 */ "Default Authority",
00271     /* 0x74 */ "Related Content",       /* 0x75 */ "TVA ID",
00272     /* 0x76 */ "DVB Content Identifier",/* 0x77 */ "Time Slice FEC Identifier",
00273     /* 0x78 */ "ECM Repetition Rate",   /* 0x79 */ "DVB-S2 Delivery Identifier",
00274     /* 0x7A */ "E-AC-3",                /* 0x7B */ "DTS",
00275     /* 0x7C */ "AAC",                   /* 0x7D */ "",
00276     /* 0x7E */ "",                      /* 0x7F */ "",
00277 
00278     /* 0x80 */ "ATSC Stuffing",         /* 0x81 */ "AC-3 Audio",
00279     /* 0x82 */ "SCTE Frame Rate",       /* 0x83 */ "SCTE Extended Video",
00280     /* 0x84 */ "SCTE Component Name",   /* 0x85 */ "ATSC Program Identifier",
00281     /* 0x86 */ "Caption Service",       /* 0x87 */ "Content Advisory",
00282     /* 0x88 */ "ATSC CA Descriptor",    /* 0x89 */ "ATSC Descriptor Tag",
00283     /* 0x8A */ "SCTE CUE Identifier",   /* 0x8B */ "",
00284     /* 0x8C */ "TimeStamp",             /* 0x8D */ "",
00285     /* 0x8E */ "",                      /* 0x8F */ "",
00286 
00287     /* 0x90 */ "SCTE Frequency Spec",   /* 0x91 */ "SCTE Modulation Params",
00288     /* 0x92 */ "SCTE TSID",             /* 0x93 */ "SCTE Revision Detection",
00289     /* 0x94 */ "SCTE Two part channel", /* 0x95 */ "SCTE Channel Properties",
00290     /* 0x96 */ "SCTE Daylight Savings", /* 0x97 */ "SCTE AFD",
00291     /* 0x98 */ "", /* 0x99 */ "",
00292     /* 0x9A */ "", /* 0x9B */ "",
00293     /* 0x9C */ "", /* 0x9D */ "",
00294     /* 0x9E */ "", /* 0x9F */ "",
00295 
00296     /* 0xA0 */ "Extended Channel Name", /* 0xA1 */ "Service Location",
00297     /* 0xA2 */ "ATSC Time-shifted Service",/*0xA3*/"Component Name",
00298     /* 0xA4 */ "ATSC Data Service",     /* 0xA5 */ "ATSC PID Count",
00299     /* 0xA6 */ "ATSC Download",
00300     /* 0xA7 */ "ATSC Multiprotocol Encapsulation",
00301     /* 0xA8 */ "DCC Departing Request", /* 0xA9 */ "DCC Arriving Request",
00302     /* 0xAA */ "ATSC Restrictions Control",/*0xAB*/"ATSC Genre",
00303     /* 0xAC */ "SCTE MAC Address List", /* 0xAD */ "ATSC Private Information",
00304     /* 0xAE */ "ATSC Compatibility Wrap",/* 0xAF */"ATSC Broadcaster Policy",
00305 
00306     /* 0xB0 */ "", /* 0xB1 */ "",
00307     /* 0xB2 */ "", /* 0xB3 */ "",
00308     /* 0xB4 */ "", /* 0xB5 */ "",
00309     /* 0xB6 */ "ATSC Content ID", /* 0xB7 */ "",
00310     /* 0xB8 */ "", /* 0xB9 */ "",
00311     /* 0xBA */ "", /* 0xBB */ "",
00312     /* 0xBC */ "", /* 0xBD */ "",
00313     /* 0xBE */ "", /* 0xBF */ "",
00314 
00315     /* 0xC0-0xCF */ EMPTY_STR_16
00316     /* 0xD0-0xDF */ EMPTY_STR_16
00317     /* 0xE0-0xEF */ EMPTY_STR_16
00318     /* 0xF0-0xFF */ EMPTY_STR_16
00319 };
00320 
00321 static void comma_list_append(QString &str, QString extra)
00322 {
00323     if (str.isEmpty())
00324         str = extra;
00325     else
00326         str = str + ", " + extra;
00327 }
00328 
00329 QString MPEGDescriptor::DescriptorTagString(void) const
00330 {
00331     QString str = descriptor_tag_strings[DescriptorTag()];
00332 
00333     switch (DescriptorTag())
00334     {
00335         case PrivateDescriptorID::dvb_uk_channel_list: /* 0x83 */
00336             comma_list_append(str, "Possibly DVB UK Channel List");
00337             break;
00338         case PrivateDescriptorID::dish_event_rights: /* 0x87 */
00339             comma_list_append(str, "Possibly Dishnet Rights");
00340             break;
00341         case PrivateDescriptorID::dish_event_mpaa:   /*0x89 */
00342             comma_list_append(str, "Possibly Dishnet MPAA");
00343             break;
00344         case PrivateDescriptorID::dish_event_name:   /*0x91 */
00345             comma_list_append(str, "Possibly Dishnet EIT Name");
00346             break;
00347         case PrivateDescriptorID::dish_event_description: /* 0x92 */
00348             comma_list_append(str, "Possibly Dishnet EIT Description");
00349             break;
00350         case PrivateDescriptorID::dish_event_properties: /* 0x94 */
00351             comma_list_append(str, "Possibly Dishnet Properties");
00352             break;
00353         case PrivateDescriptorID::dish_event_vchip: /* 0x95 */
00354             comma_list_append(str, "Possibly Dishnet V-Chip");
00355             break;
00356         case PrivateDescriptorID::dish_event_tags: /* 0x96 */
00357             comma_list_append(str, "Possibly Dishnet Tag");
00358             break;
00359         case PrivateDescriptorID::premiere_content_order: /* 0xF0 */
00360             comma_list_append(str, "Possibly Premiere DE Content Order");
00361             break;
00362         case PrivateDescriptorID::premiere_parental_information: /* 0xF1 */
00363             comma_list_append(str, "Possibly Premiere DE Parental Information");
00364             break;
00365         case PrivateDescriptorID::premiere_content_transmission: /* 0xF2 */
00366             comma_list_append(str, "Possibly Premiere DE Content Transmission");
00367             break;
00368     }
00369 
00370     if (str.isEmpty())
00371         str = QString("Unknown(%1)").arg(DescriptorTag());
00372 
00373     return str;
00374 }
00375 
00376 #define SET_STRING(DESC_NAME) do { \
00377     if (IsValid()) { DESC_NAME d(_data, DescriptorLength()+2); \
00378     if (d.IsValid()) str = d.toString(); } } while (0)
00379 
00380 QString MPEGDescriptor::toString() const
00381 {
00382     QString str;
00383 
00384     if (DescriptorID::registration == DescriptorTag())
00385         SET_STRING(RegistrationDescriptor);
00386     else if (DescriptorID::iso_639_language == DescriptorTag())
00387         SET_STRING(ISO639LanguageDescriptor);
00388     else if (DescriptorID::avc_video == DescriptorTag())
00389         SET_STRING(AVCVideoDescriptor);
00390     else if (DescriptorID::ac3_audio_stream == DescriptorTag())
00391         SET_STRING(AudioStreamDescriptor);
00392     else if (DescriptorID::caption_service == DescriptorTag())
00393         SET_STRING(CaptionServiceDescriptor);
00394     else if (DescriptorID::extended_channel_name == DescriptorTag())
00395         SET_STRING(ExtendedChannelNameDescriptor);
00396     else if (DescriptorID::component_name == DescriptorTag())
00397         SET_STRING(ComponentNameDescriptor);
00398     else if (DescriptorID::conditional_access == DescriptorTag())
00399         SET_STRING(ConditionalAccessDescriptor);
00400     else if (DescriptorID::network_name == DescriptorTag())
00401         SET_STRING(NetworkNameDescriptor);
00402     //else if (DescriptorID::linkage == DescriptorTag())
00403     //    SET_STRING(LinkageDescriptor);
00404     else if (DescriptorID::adaptation_field_data == DescriptorTag())
00405         SET_STRING(AdaptationFieldDataDescriptor);
00406     //else if (DescriptorID::ancillary_data == DescriptorTag())
00407     //    SET_STRING(AncillaryDataDescriptor);
00408     else if (DescriptorID::cable_delivery_system == DescriptorTag())
00409         SET_STRING(CableDeliverySystemDescriptor);
00410     else if (DescriptorID::satellite_delivery_system == DescriptorTag())
00411         SET_STRING(SatelliteDeliverySystemDescriptor);
00412     else if (DescriptorID::terrestrial_delivery_system == DescriptorTag())
00413         SET_STRING(TerrestrialDeliverySystemDescriptor);
00414     else if (DescriptorID::frequency_list == DescriptorTag())
00415         SET_STRING(FrequencyListDescriptor);
00416     else if (DescriptorID::service == DescriptorTag())
00417         SET_STRING(ServiceDescriptor);
00418     else if (DescriptorID::stream_identifier == DescriptorTag())
00419         SET_STRING(StreamIdentifierDescriptor);
00420     else if (DescriptorID::default_authority == DescriptorTag())
00421         SET_STRING(DefaultAuthorityDescriptor);
00422     else if (DescriptorID::bouquet_name == DescriptorTag())
00423         SET_STRING(BouquetNameDescriptor);
00424     else if (DescriptorID::country_availability == DescriptorTag())
00425         SET_STRING(CountryAvailabilityDescriptor);
00426     else if (DescriptorID::service_list == DescriptorTag())
00427         SET_STRING(ServiceListDescriptor);
00428     else if (DescriptorID::scte_cue_identifier == DescriptorTag())
00429         SET_STRING(CueIdentifierDescriptor);
00430     else if (DescriptorID::scte_revision_detection == DescriptorTag())
00431         SET_STRING(RevisionDetectionDescriptor);
00433     else if (PrivateDescriptorID::dvb_uk_channel_list == DescriptorTag())
00434         SET_STRING(UKChannelListDescriptor);
00436     else if (IsValid())
00437     {
00438         str = QString("%1 Descriptor (0x%2) length(%3)")
00439             .arg(DescriptorTagString())
00440             .arg(DescriptorTag(),2,16,QChar('0'))
00441             .arg(DescriptorLength());
00442         //for (uint i=0; i<DescriptorLength(); i++)
00443         //    str.append(QString(" 0x%1").arg(int(_data[i+2]), 0, 16));
00444     }
00445     else
00446     {
00447         str = "Invalid Descriptor";
00448     }
00449     return str;
00450 }
00451 
00454 QString MPEGDescriptor::toStringXML(uint level) const
00455 {
00456     QString indent_0 = xml_indent(level);
00457     QString indent_1 = xml_indent(level+1);
00458     QString str;
00459 
00460     str += indent_0 + "<Descriptor>\n";
00461     str += indent_1 + QString("<Tag>0x%1</Tag>\n")
00462         .arg(DescriptorTag(),2,16,QChar('0'));
00463     str += indent_1 + QString("<Description>%1</Description>\n")
00464         .arg(DescriptorTagString(),0,16);
00465 
00466     str += indent_1 + "<Data>";
00467     for (uint i = 0; i < DescriptorLength(); i++)
00468     {
00469         if (((i%8) == 0) && i)
00470             str += "\n" + indent_1 + "      ";
00471         str += QString("0x%1 ").arg(_data[i+2],2,16,QChar('0'));
00472     }
00473 
00474     str += "\n" + indent_1 + "</Data>\n";
00475 
00476     str += indent_1 + "<Decoded>" + toString() + "</Decoded>\n";
00477 
00478     str += indent_0 + "</Descriptor>";
00479 
00480     return str;
00481 }
00482 
00483 void RegistrationDescriptor::InitializeDescriptionMap(void)
00484 {
00485     QMutexLocker locker(&description_map_lock);
00486     if (description_map_initialized)
00487         return;
00488 
00489     description_map["AC-3"] = "ATSC audio stream A/52";
00490     description_map["AVSV"] = "China A/V Working Group";
00491     description_map["BDC0"] = "Broadcast Data Corporation Software Data Service";
00492     description_map["BSSD"] = "SMPTE 302M-1998 Audio data as specified in (AES3)";
00493     description_map["CAPO"] = "SMPTE 315M-1999 Camera Positioning Information";
00494     description_map["CUEI"] = "SCTE 35 2003, Cable Digital Program Insertion Cueing Message";
00495     description_map["DDED"] = "LGEUS Digital Delivery with encryption and decryption";
00496     description_map["DISH"] = "EchoStar MPEG streams";
00497     description_map["DRA1"] = "Chinese EIS SJ/T11368-2006 DRA digital audio";
00498     description_map["DTS1"] = "DTS Frame size of 512 bytes";
00499     description_map["DTS2"] = "DTS Frame size of 1024 bytes";
00500     description_map["DTS3"] = "DTS Frame size of 2048";
00501     description_map["DVDF"] = "DVD compatible MPEG2-TS";
00502     description_map["ETV1"] = "CableLabs ETV info is present";
00503     description_map["GA94"] = "ATSC program ID A/53";
00504     description_map["GWKS"] = "GuideWorks EPG info";
00505     description_map["HDMV"] = "Blu-Ray A/V for read-only media (H.264 TS)";
00506     description_map["HDMX"] = "Matsushita-TS";
00507     description_map["KLVA"] = "SMPTE RP 217-2001 MXF KLV packets present";
00508     description_map["LU-A"] = "SMPTE RDD-11 HDSDI HD serial/video data";
00509     description_map["MTRM"] = "D-VHS compatible MPEG2-TS";
00510     description_map["NMR1"] = "Nielsen content identifier";
00511     description_map["PAUX"] = "Philips ES containing low-speed data";
00512     description_map["PMSF"] = "MPEG-TS stream modified by STB";
00513     description_map["PRMC"] = "Philips ES containing remote control data";
00514     description_map["SCTE"] = "SCTE 54 2003 Digital Video Service Multiplex and TS for Cable";
00515     description_map["SEN1"] = "ATSC Private Information identifies source of stream";
00516     description_map["SESF"] = "Blu-Ray A/V for ReWritable media (H.264 TS)";
00517     description_map["SPLC"] = "SMPTE Proposed 312M Splice Point compatible TS";
00518     description_map["SVMD"] = "SMPTE Proposed Video Metatdata Dictionary for MPEG2-TS";
00519     description_map["SZMI"] = "ATSC Private Info from Building B";
00520     description_map["TRIV"] = "ATSC Private Info from Triveni Digital";
00521     description_map["TSBV"] = "Toshiba self-encoded H.264 TS";
00522     description_map["TSHV"] = "Sony self-encoded MPEG-TS and private data";
00523     description_map["TSMV"] = "Sony self-encoded MPEG-TS and private data";
00524     description_map["TVG1"] = "TV Guide EPG Data";
00525     description_map["TVG2"] = "TV Guide EPG Data";
00526     description_map["TVG3"] = "TV Guide EPG Data";
00527     description_map["ULE1"] = "IETF RFC4326 compatible MPEG2-TS";
00528     description_map["VC-1"] = "SMPTE Draft RP 227 VC-1 Bitstream Transport Encodings";
00529 
00530     for (uint i = 0; i <= 99; i++)
00531     {
00532         description_map[QString("US%1").arg(i, 2, QLatin1Char('0'))] =
00533             "NIMA, Unspecified military application";
00534     }
00535 
00536     description_map_initialized = true;
00537 }
00538 
00539 QString RegistrationDescriptor::GetDescription(const QString &fmt)
00540 {
00541     InitializeDescriptionMap();
00542 
00543     QString ret = QString::null;
00544     {
00545         QMutexLocker locker(&description_map_lock);
00546         QMap<QString,QString>::const_iterator it = description_map.find(fmt);
00547         if (it != description_map.end())
00548             ret = *it;
00549     }
00550 
00551     if (!ret.isNull())
00552         ret.detach();
00553 
00554     return ret;
00555 }
00556 
00557 QString RegistrationDescriptor::toString() const
00558 {
00559     QString fmt = FormatIdentifierString();
00560     QString msg = QString("Registration Descriptor: '%1' ").arg(fmt);
00561 
00562     QString msg2 = GetDescription(fmt);
00563     if (msg2.isEmpty())
00564         msg2 = "Unknown, see http://www.smpte-ra.org/mpegreg/mpegreg.html";
00565 
00566     return msg + msg2;
00567 }
00568 
00569 QString ConditionalAccessDescriptor::toString() const
00570 {
00571     return QString("Conditional Access: sid(0x%1) pid(0x%2) data_size(%3)")
00572         .arg(SystemID(),0,16).arg(PID(),0,16).arg(DataSize());
00573 }
00574 
00575 QString ISO639LanguageDescriptor::toString() const
00576 {
00577     return QString("ISO-639 Language: code(%1) canonical(%2) eng(%3)")
00578         .arg(LanguageString()).arg(CanonicalLanguageString())
00579         .arg(iso639_key_toName(CanonicalLanguageKey()));
00580 }
00581 
00582 QString AVCVideoDescriptor::toString() const
00583 {
00584     return QString("AVC Video: IDC prof(%1) IDC level(%2) sets(%3%4%5) "
00585                    "compat(%6) still(%7) 24hr(%8) FramePacking(%9)")
00586         .arg(ProfileIDC()).arg(LevelIDC())
00587         .arg(ConstaintSet0()).arg(ConstaintSet1()).arg(ConstaintSet2())
00588         .arg(AVCCompatible()).arg(AVCStill()).arg(AVC24HourPicture())
00589         .arg(FramePackingSEINotPresentFlag());
00590 }