gst-libs/gst/pbutils/descriptions.c

   1 /* GStreamer Plugins Base utils library source/sink/codec description support
   2  * Copyright (C) 2006 Tim-Philipp Müller <tim centricular net>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /**
  21  * SECTION:gstpbutilsdescriptions
  22  * @short_description: Provides human-readable descriptions for caps/codecs
  23  * and encoder, decoder, URI source and URI sink elements
  24  *
  25  * <refsect2>
  26  * <para>
  27  * The above functions provide human-readable strings for media formats
  28  * and decoder/demuxer/depayloader/encoder/muxer/payloader elements for use
  29  * in error dialogs or other messages shown to users.
  30  * </para>
  31  * <para>
  32  * gst_pb_utils_add_codec_description_to_tag_list() is a utility function
  33  * for demuxer and decoder elements to add audio/video codec tags from a
  34  * given (fixed) #GstCaps.
  35  * </para>
  36  * </refsect2>
  37  */
  38
  39 #ifdef HAVE_CONFIG_H
  40 # include "config.h"
  41 #endif
  42
  43 #include "gst/gst-i18n-plugin.h"
  44
  45 #include <gst/audio/audio.h>
  46 #include <gst/video/video.h>
  47
  48 #include "pbutils.h"
  49 #include "pbutils-private.h"
  50
  51 #include <string.h>
  52
  53 typedef enum
  54 {
  55   FLAG_CONTAINER = (1 << 0),    /* format is a container format (muxed)             */
  56   FLAG_SYSTEMSTREAM = (1 << 1)  /* match record only if caps have systemstream=true */
  57 } FormatFlags;
  58
  59 typedef struct
  60 {
  61   const gchar *type;
  62   const gchar *desc;
  63   FormatFlags flags;
  64 } FormatInfo;
  65
  66 static const FormatInfo formats[] = {
  67   /* container/tag formats with static descriptions */
  68   {"application/gxf", "General Exchange Format (GXF)", FLAG_CONTAINER},
  69   {"application/ogg", "Ogg", FLAG_CONTAINER},
  70   {"application/mxf", "Material eXchange Format (MXF)", FLAG_CONTAINER},
  71   {"application/vnd.rn-realmedia", "Realmedia", FLAG_CONTAINER},
  72   {"application/x-annodex", "Ogg", FLAG_CONTAINER},
  73   {"application/x-id3", N_("ID3 tag"), FLAG_CONTAINER},
  74   {"application/x-ape", N_("APE tag"), FLAG_CONTAINER},
  75   {"application/x-apetag", N_("APE tag"), FLAG_CONTAINER},
  76   {"application/x-icy", N_("ICY internet radio"), FLAG_CONTAINER},
  77   {"application/x-3gp", "3GP", FLAG_CONTAINER},
  78   {"application/x-pn-realaudio", "RealAudio", FLAG_CONTAINER},
  79   {"application/x-yuv4mpeg", "Y4M", FLAG_CONTAINER},
  80   {"multipart/x-mixed-replace", "Multipart", FLAG_CONTAINER},
  81   {"video/x-fli", "FLI/FLC/FLX Animation", FLAG_CONTAINER},
  82   {"video/x-flv", "Flash", FLAG_CONTAINER},
  83   {"video/x-matroska", "Matroska", FLAG_CONTAINER},
  84   {"video/webm", "WebM", FLAG_CONTAINER},
  85   {"video/x-ms-asf", "Advanced Streaming Format (ASF)", FLAG_CONTAINER},
  86   {"video/x-msvideo", "Audio Video Interleave (AVI)", FLAG_CONTAINER},
  87   {"video/x-quicktime", "Quicktime", FLAG_CONTAINER},
  88   {"video/quicktime", "Quicktime", FLAG_CONTAINER},
  89   {"video/mj2", "Motion JPEG 2000", FLAG_CONTAINER},
  90
  91   /* audio formats with static descriptions */
  92   {"audio/x-ac3", "AC-3 (ATSC A/52)", 0},
  93   {"audio/ac3", "AC-3 (ATSC A/52)", 0},
  94   {"audio/x-private-ac3", "DVD AC-3 (ATSC A/52)", 0},
  95   {"audio/x-private1-ac3", "DVD AC-3 (ATSC A/52)", 0},
  96   {"audio/x-alaw", "A-Law", 0},
  97   {"audio/amr", "Adaptive Multi Rate (AMR)", 0},
  98   {"audio/AMR", "Adaptive Multi Rate (AMR)", 0},
  99   {"audio/AMR-WB", "Adaptive Multi Rate WideBand (AMR-WB)", 0},
 100   {"audio/iLBC-sh", "Internet Low Bitrate Codec (iLBC)", 0},
 101   {"audio/ms-gsm", "MS GSM", 0},
 102   {"audio/qcelp", "QCELP", 0},
 103   {"audio/aiff", "Audio Interchange File Format (AIFF)", 0},
 104   {"audio/x-aiff", "Audio Interchange File Format (AIFF)", 0},
 105   {"audio/x-alac", N_("Apple Lossless Audio (ALAC)"), 0},
 106   {"audio/x-amr-nb-sh", "Adaptive Multi Rate NarrowBand (AMR-NB)", 0},
 107   {"audio/x-amr-wb-sh", "Adaptive Multi Rate WideBand (AMR-WB)", 0},
 108   {"audio/x-au", "Sun .au", 0},
 109   {"audio/x-celt", "Constrained Energy Lapped Transform (CELT)", 0},
 110   {"audio/x-cinepak", "Cinepak Audio", 0},
 111   {"audio/x-dpcm", "DPCM", 0},
 112   {"audio/x-dts", "DTS", 0},
 113   {"audio/x-private1-dts", "DTS", 0},
 114   {"audio/x-dv", "DV Audio", 0},
 115   {"audio/x-flac", N_("Free Lossless Audio Codec (FLAC)"), 0},
 116   {"audio/x-gsm", "GSM", 0},
 117   {"audio/x-iec958", "S/PDIF IEC958", 0},       /* TODO: check description */
 118   {"audio/x-iLBC", "Internet Low Bitrate Codec (iLBC)", 0},
 119   {"audio/x-ircam", "Berkeley/IRCAM/CARL", 0},
 120   {"audio/x-lpcm", "LPCM", 0},
 121   {"audio/x-private1-lpcm", "DVD LPCM", 0},
 122   {"audio/x-m4a", "MPEG-4 AAC", FLAG_CONTAINER},
 123   {"audio/x-mod", "Module Music Format (MOD)", 0},
 124   {"audio/x-mulaw", "Mu-Law", 0},
 125   {"audio/x-musepack", "Musepack (MPC)", 0},
 126   {"audio/x-nellymoser", "Nellymoser Asao", 0},
 127   {"audio/x-nist", "Sphere NIST", 0},
 128   {"audio/x-nsf", "Nintendo NSF", 0},
 129   {"audio/x-paris", "Ensoniq PARIS", 0},
 130   {"audio/x-qdm", "QDesign Music (QDM)", 0},
 131   {"audio/x-qdm2", "QDesign Music (QDM) 2", 0},
 132   {"audio/x-ralf-mpeg4-generic", "Real Audio Lossless (RALF)", 0},
 133   {"audio/x-sds", "SDS", 0},
 134   {"audio/x-shorten", "Shorten Lossless", 0},
 135   {"audio/x-sid", "Sid", 0},
 136   {"audio/x-sipro", "Sipro/ACELP.NET Voice", 0},
 137   {"audio/x-siren", "Siren", 0},
 138   {"audio/x-spc", "SNES-SPC700 Sound File Data", 0},
 139   {"audio/x-speex", "Speex", 0},
 140   {"audio/x-svx", "Amiga IFF / SVX8 / SV16", 0},
 141   {"audio/x-tta", N_("Lossless True Audio (TTA)"), 0},
 142   {"audio/x-ttafile", N_("Lossless True Audio (TTA)"), 0},
 143   {"audio/x-vnd.sony.atrac3", "Sony ATRAC3", 0},
 144   {"audio/x-vorbis", "Vorbis", 0},
 145   {"audio/x-voc", "SoundBlaster VOC", 0},
 146   {"audio/x-w64", "Sonic Foundry Wave64", 0},
 147   {"audio/x-wav", "WAV", 0},
 148   {"audio/x-wavpack", "Wavpack", 0},
 149   {"audio/x-wavpack-correction", "Wavpack", 0},
 150   {"audio/x-wms", N_("Windows Media Speech"), 0},
 151   {"audio/x-voxware", "Voxware", 0},
 152
 153
 154   /* video formats with static descriptions */
 155   {"video/sp5x", "Sunplus JPEG 5.x", 0},
 156   {"video/vivo", "Vivo", 0},
 157   {"video/x-3ivx", "3ivx", 0},
 158   {"video/x-4xm", "4X Techologies Video", 0},
 159   {"video/x-apple-video", "Apple video", 0},
 160   {"video/x-aasc", "Autodesk Animator", 0},
 161   {"video/x-camtasia", "TechSmith Camtasia", 0},
 162   {"video/x-cdxa", "RIFF/CDXA (VCD)", 0},
 163   {"video/x-cinepak", "Cinepak Video", 0},
 164   {"video/x-cirrus-logic-accupak", "Cirrus Logipak AccuPak", 0},
 165   {"video/x-compressed-yuv", N_("CYUV Lossless"), 0},
 166   {"video/x-dirac", "Dirac", 0},
 167   {"video/x-dnxhd", "Digital Nonlinear Extensible High Definition (DNxHD)", 0},
 168   /* FIXME 0.11: rename to subpicture/x-dvd or so */
 169   {"video/x-dvd-subpicture", "DVD subpicture", 0},
 170   {"video/x-ffv", N_("FFMpeg v1"), 0},
 171   {"video/x-flash-screen", "Flash Screen Video", 0},
 172   {"video/x-flash-video", "Sorenson Spark Video", 0},
 173   {"video/x-h261", "H.261", 0},
 174   {"video/x-huffyuv", "Huffyuv", 0},
 175   {"video/x-intel-h263", "Intel H.263", 0},
 176   {"video/x-jpeg", "Motion JPEG", 0},
 177   /* { "video/x-jpeg-b", "", 0 }, does this actually exist? */
 178   {"video/x-loco", "LOCO Lossless", 0},
 179   {"video/x-mimic", "MIMIC", 0},
 180   {"video/x-mjpeg", "Motion-JPEG", 0},
 181   {"video/x-mjpeg-b", "Motion-JPEG format B", 0},
 182   {"video/mpegts", "MPEG-2 Transport Stream", FLAG_CONTAINER},
 183   {"video/x-mng", "Multiple Image Network Graphics (MNG)", 0},
 184   {"video/x-mszh", N_("Lossless MSZH"), 0},
 185   {"video/x-msvideocodec", "Microsoft Video 1", 0},
 186   {"video/x-mve", "Interplay MVE", FLAG_CONTAINER},
 187   {"video/x-nut", "NUT", FLAG_CONTAINER},
 188   {"video/x-nuv", "MythTV NuppelVideo (NUV)", FLAG_CONTAINER},
 189   {"video/x-qdrw", "Apple QuickDraw", 0},
 190   {"video/x-smc", "Apple SMC", 0},
 191   {"video/x-smoke", "Smoke", 0},
 192   {"video/x-tarkin", "Tarkin", 0},
 193   {"video/x-theora", "Theora", 0},
 194   {"video/x-rle", N_("Run-length encoding"), 0},
 195   {"video/x-ultimotion", "IBM UltiMotion", 0},
 196   {"video/x-vcd", "VideoCD (VCD)", 0},
 197   {"video/x-vmnc", "VMWare NC", 0},
 198   {"video/x-vp3", "On2 VP3", 0},
 199   {"video/x-vp5", "On2 VP5", 0},
 200   {"video/x-vp6", "On2 VP6", 0},
 201   {"video/x-vp6-flash", "On2 VP6/Flash", 0},
 202   {"video/x-vp6-alpha", "On2 VP6 with alpha", 0},
 203   {"video/x-vp7", "On2 VP7", 0},
 204   {"video/x-vp8", "VP8", 0},
 205   {"video/x-xvid", "XVID MPEG-4", 0},
 206   {"video/x-zlib", "Lossless zlib video", 0},
 207   {"video/x-zmbv", "Zip Motion Block video", 0},
 208
 209   /* image formats with static descriptions */
 210   {"image/bmp", "BMP", 0},
 211   {"image/x-bmp", "BMP", 0},
 212   {"image/x-MS-bmp", "BMP", 0},
 213   {"image/gif", "GIF", 0},
 214   {"image/jpeg", "JPEG", 0},
 215   {"image/jng", "JPEG Network Graphics (JNG)", 0},
 216   {"image/png", "PNG", 0},
 217   {"image/pbm", "Portable BitMap (PBM)", 0},
 218   {"image/ppm", "Portable PixMap (PPM)", 0},
 219   {"image/svg+xml", "Scalable Vector Graphics (SVG)", 0},
 220   {"image/tiff", "TIFF", 0},
 221   {"image/x-cmu-raster", "CMU Raster Format", 0},
 222   {"image/x-degas", "DEGAS", 0},
 223   {"image/x-icon", "ICO", 0},
 224   {"image/x-j2c", "JPEG 2000", 0},
 225   {"image/x-jpc", "JPEG 2000", 0},
 226   {"image/jp2", "JPEG 2000", 0},
 227   {"image/x-pcx", "PCX", 0},
 228   {"image/x-xcf", "XFC", 0},
 229   {"image/x-pixmap", "XPM", 0},
 230   {"image/x-portable-anymap", "Portable AnyMap (PAM)", 0},
 231   {"image/x-portable-graymap", "Portable GrayMap (PGM)", 0},
 232   {"image/x-xpixmap", "XPM", 0},
 233   {"image/x-quicktime", "QuickTime Image Format (QTIF)", 0},
 234   {"image/x-sun-raster", "Sun Raster Format (RAS)", 0},
 235   {"image/x-tga", "TGA", 0},
 236   {"image/vnd.wap.wbmp", "Wireless Bitmap", 0},
 237
 238   /* subtitle formats with static descriptions */
 239   {"application/x-ass", "ASS", 0},
 240   {"application/x-subtitle-sami", N_("Sami subtitle format"), 0},
 241   {"application/x-subtitle-tmplayer", N_("TMPlayer subtitle format"), 0},
 242   {"application/x-kate", "Kate", 0},
 243   {"subtitle/x-kate", N_("Kate subtitle format"), 0},
 244   {"subpicture/x-dvb", "DVB subtitles", 0},
 245   /* add variant field to typefinder? { "application/x-subtitle", N_("subtitle"), 0}, */
 246
 247   /* non-audio/video/container formats */
 248   {"hdv/aux-v", "HDV AUX-V", 0},
 249   {"hdv/aux-a", "HDV AUX-A", 0},
 250
 251   /* formats with dynamic descriptions */
 252   {"audio/mpeg", NULL, 0},
 253   {"audio/x-adpcm", NULL, 0},
 254   {"audio/x-mace", NULL, 0},
 255   {"audio/x-pn-realaudio", NULL, 0},
 256   {"audio/x-raw", NULL, 0},
 257   {"audio/x-wma", NULL, 0},
 258   {"video/mpeg", NULL, FLAG_CONTAINER | FLAG_SYSTEMSTREAM},
 259   {"video/mpeg", NULL, 0},
 260   {"video/x-asus", NULL, 0},
 261   {"video/x-ati-vcr", NULL, 0},
 262   {"video/x-divx", NULL, 0},
 263   {"video/x-dv", "Digital Video (DV) System Stream",
 264       FLAG_CONTAINER | FLAG_SYSTEMSTREAM},
 265   {"video/x-dv", "Digital Video (DV)", 0},
 266   {"video/x-h263", NULL, 0},
 267   {"video/x-h264", NULL, 0},
 268   {"video/x-indeo", NULL, 0},
 269   {"video/x-msmpeg", NULL, 0},
 270   {"video/x-pn-realvideo", NULL, 0},
 271 #if 0
 272   /* do these exist? are they used anywhere? */
 273   {"video/x-pn-multirate-realvideo", NULL, 0},
 274   {"audio/x-pn-multirate-realaudio", NULL, 0},
 275   {"audio/x-pn-multirate-realaudio-live", NULL, 0},
 276 #endif
 277   {"video/x-truemotion", NULL, 0},
 278   {"video/x-raw", NULL, 0},
 279   {"video/x-svq", NULL, 0},
 280   {"video/x-wmv", NULL, 0},
 281   {"video/x-xan", NULL, 0}
 282 };
 283
 284 /* returns static descriptions and dynamic ones (such as video/x-raw),
 285  * or NULL if caps aren't known at all */
 286 static gchar *
 287 format_info_get_desc (const FormatInfo * info, const GstCaps * caps)
 288 {
 289   const GstStructure *s;
 290
 291   g_assert (info != NULL);
 292
 293   if (info->desc != NULL)
 294     return g_strdup (_(info->desc));
 295
 296   s = gst_caps_get_structure (caps, 0);
 297
 298   if (strcmp (info->type, "video/x-raw") == 0) {
 299     gchar *ret = NULL;
 300     const gchar *str = 0;
 301     GstVideoFormat format;
 302     const GstVideoFormatInfo *finfo;
 303
 304     str = gst_structure_get_string (s, "format");
 305     format = gst_video_format_from_string (str);
 306     if (format == GST_VIDEO_FORMAT_UNKNOWN)
 307       return g_strdup (_("Uncompressed video"));
 308
 309     finfo = gst_video_format_get_info (format);
 310
 311     if (GST_VIDEO_FORMAT_INFO_IS_GRAY (finfo)) {
 312       ret = g_strdup (_("Uncompressed gray"));
 313     } else if (GST_VIDEO_FORMAT_INFO_IS_YUV (finfo)) {
 314       const gchar *layout;
 315       const gchar *subs;
 316       gint w_sub, h_sub;
 317
 318       w_sub = GST_VIDEO_FORMAT_INFO_W_SUB (finfo, 1);
 319       h_sub = GST_VIDEO_FORMAT_INFO_H_SUB (finfo, 1);
 320
 321       if (GST_VIDEO_FORMAT_INFO_N_PLANES (finfo) == 1) {
 322         layout = "planar";
 323       } else {
 324         layout = "packed";
 325       }
 326
 327       if (w_sub == 1 && h_sub == 1) {
 328         subs = "4:4:4";
 329       } else if (w_sub == 2 && h_sub == 1) {
 330         subs = "4:2:2";
 331       } else if (w_sub == 2 && h_sub == 2) {
 332         subs = "4:2:0";
 333       } else if (w_sub == 4 && h_sub == 1) {
 334         subs = "4:1:1";
 335       } else {
 336         subs = "";
 337       }
 338       ret = g_strdup_printf (_("Uncompressed %s YUV %s"), layout, subs);
 339     } else if (GST_VIDEO_FORMAT_INFO_IS_RGB (finfo)) {
 340       gboolean alpha, palette;
 341       gint bits;
 342
 343       alpha = GST_VIDEO_FORMAT_INFO_HAS_ALPHA (finfo);
 344       palette = GST_VIDEO_FORMAT_INFO_HAS_PALETTE (finfo);
 345       bits = GST_VIDEO_FORMAT_INFO_BITS (finfo);
 346
 347       ret = g_strdup_printf (_("Uncompressed %s%d-bit %s"),
 348           palette ? "palettized " : "", bits, alpha ? "RGBA" : "RGB");
 349     } else {
 350       ret = g_strdup (_("Uncompressed video"));
 351     }
 352     return ret;
 353   } else if (strcmp (info->type, "video/x-h263") == 0) {
 354     const gchar *variant, *ret;
 355
 356     variant = gst_structure_get_string (s, "variant");
 357     if (variant == NULL)
 358       ret = "H.263";
 359     else if (strcmp (variant, "itu") == 0)
 360       ret = "ITU H.26n";        /* why not ITU H.263? (tpm) */
 361     else if (strcmp (variant, "lead") == 0)
 362       ret = "Lead H.263";
 363     else if (strcmp (variant, "microsoft") == 0)
 364       ret = "Microsoft H.263";
 365     else if (strcmp (variant, "vdolive") == 0)
 366       ret = "VDOLive";
 367     else if (strcmp (variant, "vivo") == 0)
 368       ret = "Vivo H.263";
 369     else if (strcmp (variant, "xirlink") == 0)
 370       ret = "Xirlink H.263";
 371     else {
 372       GST_WARNING ("Unknown H263 variant '%s'", variant);
 373       ret = "H.263";
 374     }
 375     return g_strdup (ret);
 376   } else if (strcmp (info->type, "video/x-h264") == 0) {
 377     const gchar *variant, *ret;
 378
 379     variant = gst_structure_get_string (s, "variant");
 380     if (variant == NULL)
 381       ret = "H.264";
 382     else if (strcmp (variant, "itu") == 0)
 383       ret = "ITU H.264";
 384     else if (strcmp (variant, "videosoft") == 0)
 385       ret = "Videosoft H.264";
 386     else if (strcmp (variant, "lead") == 0)
 387       ret = "Lead H.264";
 388     else {
 389       GST_WARNING ("Unknown H264 variant '%s'", variant);
 390       ret = "H.264";
 391     }
 392     return g_strdup (ret);
 393   } else if (strcmp (info->type, "video/x-divx") == 0) {
 394     gint ver = 0;
 395
 396     if (!gst_structure_get_int (s, "divxversion", &ver) || ver <= 2) {
 397       GST_WARNING ("Unexpected DivX version in %" GST_PTR_FORMAT, caps);
 398       return g_strdup ("DivX MPEG-4");
 399     }
 400     return g_strdup_printf (_("DivX MPEG-4 Version %d"), ver);
 401   } else if (strcmp (info->type, "video/x-msmpeg") == 0) {
 402     gint ver = 0;
 403
 404     if (!gst_structure_get_int (s, "msmpegversion", &ver) ||
 405         ver < 40 || ver > 49) {
 406       GST_WARNING ("Unexpected msmpegversion in %" GST_PTR_FORMAT, caps);
 407       return g_strdup ("Microsoft MPEG-4 4.x");
 408     }
 409     return g_strdup_printf ("Microsoft MPEG-4 4.%d", ver % 10);
 410   } else if (strcmp (info->type, "video/x-truemotion") == 0) {
 411     gint ver = 0;
 412
 413     gst_structure_get_int (s, "trueversion", &ver);
 414     switch (ver) {
 415       case 1:
 416         return g_strdup_printf ("Duck TrueMotion 1");
 417       case 2:
 418         return g_strdup_printf ("TrueMotion 2.0");
 419       default:
 420         GST_WARNING ("Unexpected trueversion in %" GST_PTR_FORMAT, caps);
 421         break;
 422     }
 423     return g_strdup_printf ("TrueMotion");
 424   } else if (strcmp (info->type, "video/x-xan") == 0) {
 425     gint ver = 0;
 426
 427     if (!gst_structure_get_int (s, "wcversion", &ver) || ver < 1) {
 428       GST_WARNING ("Unexpected wcversion in %" GST_PTR_FORMAT, caps);
 429       return g_strdup ("Xan Wing Commander");
 430     }
 431     return g_strdup_printf ("Xan Wing Commander %u", ver);
 432   } else if (strcmp (info->type, "video/x-indeo") == 0) {
 433     gint ver = 0;
 434
 435     if (!gst_structure_get_int (s, "indeoversion", &ver) || ver < 2) {
 436       GST_WARNING ("Unexpected indeoversion in %" GST_PTR_FORMAT, caps);
 437       return g_strdup ("Intel Indeo");
 438     }
 439     return g_strdup_printf ("Intel Indeo %u", ver);
 440   } else if (strcmp (info->type, "audio/x-wma") == 0) {
 441     gint ver = 0;
 442
 443     gst_structure_get_int (s, "wmaversion", &ver);
 444     switch (ver) {
 445       case 1:
 446       case 2:
 447       case 3:
 448         return g_strdup_printf ("Windows Media Audio %d", ver + 6);
 449       default:
 450         break;
 451     }
 452     GST_WARNING ("Unexpected wmaversion in %" GST_PTR_FORMAT, caps);
 453     return g_strdup ("Windows Media Audio");
 454   } else if (strcmp (info->type, "video/x-wmv") == 0) {
 455     gint ver = 0;
 456
 457     gst_structure_get_int (s, "wmvversion", &ver);
 458     switch (ver) {
 459       case 1:
 460       case 2:
 461       case 3:
 462         return g_strdup_printf ("Windows Media Video %d", ver + 6);
 463       default:
 464         break;
 465     }
 466     GST_WARNING ("Unexpected wmvversion in %" GST_PTR_FORMAT, caps);
 467     return g_strdup ("Windows Media Video");
 468   } else if (strcmp (info->type, "audio/x-mace") == 0) {
 469     gint ver = 0;
 470
 471     gst_structure_get_int (s, "maceversion", &ver);
 472     if (ver == 3 || ver == 6) {
 473       return g_strdup_printf ("MACE-%d", ver);
 474     } else {
 475       GST_WARNING ("Unexpected maceversion in %" GST_PTR_FORMAT, caps);
 476       return g_strdup ("MACE");
 477     }
 478   } else if (strcmp (info->type, "video/x-svq") == 0) {
 479     gint ver = 0;
 480
 481     gst_structure_get_int (s, "svqversion", &ver);
 482     if (ver == 1 || ver == 3) {
 483       return g_strdup_printf ("Sorensen Video %d", ver);
 484     } else {
 485       GST_WARNING ("Unexpected svqversion in %" GST_PTR_FORMAT, caps);
 486       return g_strdup ("Sorensen Video");
 487     }
 488   } else if (strcmp (info->type, "video/x-asus") == 0) {
 489     gint ver = 0;
 490
 491     gst_structure_get_int (s, "asusversion", &ver);
 492     if (ver == 1 || ver == 2) {
 493       return g_strdup_printf ("Asus Video %d", ver);
 494     } else {
 495       GST_WARNING ("Unexpected asusversion in %" GST_PTR_FORMAT, caps);
 496       return g_strdup ("Asus Video");
 497     }
 498   } else if (strcmp (info->type, "video/x-ati-vcr") == 0) {
 499     gint ver = 0;
 500
 501     gst_structure_get_int (s, "vcrversion", &ver);
 502     if (ver == 1 || ver == 2) {
 503       return g_strdup_printf ("ATI VCR %d", ver);
 504     } else {
 505       GST_WARNING ("Unexpected acrversion in %" GST_PTR_FORMAT, caps);
 506       return g_strdup ("ATI VCR");
 507     }
 508   } else if (strcmp (info->type, "audio/x-adpcm") == 0) {
 509     const GValue *layout_val;
 510
 511     layout_val = gst_structure_get_value (s, "layout");
 512     if (layout_val != NULL && G_VALUE_HOLDS_STRING (layout_val)) {
 513       const gchar *layout;
 514
 515       if ((layout = g_value_get_string (layout_val))) {
 516         gchar *layout_upper, *ret;
 517
 518         if (strcmp (layout, "swf") == 0)
 519           return g_strdup ("Shockwave ADPCM");
 520         if (strcmp (layout, "microsoft") == 0)
 521           return g_strdup ("Microsoft ADPCM");
 522         if (strcmp (layout, "quicktime") == 0)
 523           return g_strdup ("Quicktime ADPCM");
 524         if (strcmp (layout, "westwood") == 0)
 525           return g_strdup ("Westwood ADPCM");
 526         if (strcmp (layout, "yamaha") == 0)
 527           return g_strdup ("Yamaha ADPCM");
 528         /* FIXME: other layouts: sbpro2, sbpro3, sbpro4, ct, g726, ea,
 529          * adx, xa, 4xm, smjpeg, dk4, dk3, dvi */
 530         layout_upper = g_ascii_strup (layout, -1);
 531         ret = g_strdup_printf ("%s ADPCM", layout_upper);
 532         g_free (layout_upper);
 533         return ret;
 534       }
 535     }
 536     return g_strdup ("ADPCM");
 537   } else if (strcmp (info->type, "audio/mpeg") == 0) {
 538     gint ver = 0, layer = 0;
 539
 540     gst_structure_get_int (s, "mpegversion", &ver);
 541
 542     switch (ver) {
 543       case 1:
 544         gst_structure_get_int (s, "layer", &layer);
 545         switch (layer) {
 546           case 1:
 547           case 2:
 548           case 3:
 549             return g_strdup_printf ("MPEG-1 Layer %d (MP%d)", layer, layer);
 550           default:
 551             break;
 552         }
 553         GST_WARNING ("Unexpected MPEG-1 layer in %" GST_PTR_FORMAT, caps);
 554         return g_strdup ("MPEG-1 Audio");
 555       case 4:
 556         return g_strdup ("MPEG-4 AAC");
 557       default:
 558         break;
 559     }
 560     GST_WARNING ("Unexpected audio mpegversion in %" GST_PTR_FORMAT, caps);
 561     return g_strdup ("MPEG Audio");
 562   } else if (strcmp (info->type, "audio/x-pn-realaudio") == 0) {
 563     gint ver = 0;
 564
 565     gst_structure_get_int (s, "raversion", &ver);
 566     switch (ver) {
 567       case 1:
 568         return g_strdup ("RealAudio 14k4bps");
 569       case 2:
 570         return g_strdup ("RealAudio 28k8bps");
 571       case 8:
 572         return g_strdup ("RealAudio G2 (Cook)");
 573       default:
 574         break;
 575     }
 576     GST_WARNING ("Unexpected raversion in %" GST_PTR_FORMAT, caps);
 577     return g_strdup ("RealAudio");
 578   } else if (strcmp (info->type, "video/x-pn-realvideo") == 0) {
 579     gint ver = 0;
 580
 581     gst_structure_get_int (s, "rmversion", &ver);
 582     switch (ver) {
 583       case 1:
 584         return g_strdup ("RealVideo 1.0");
 585       case 2:
 586         return g_strdup ("RealVideo 2.0");
 587       case 3:
 588         return g_strdup ("RealVideo 3.0");
 589       case 4:
 590         return g_strdup ("RealVideo 4.0");
 591       default:
 592         break;
 593     }
 594     GST_WARNING ("Unexpected rmversion in %" GST_PTR_FORMAT, caps);
 595     return g_strdup ("RealVideo");
 596   } else if (strcmp (info->type, "video/mpeg") == 0) {
 597     gboolean sysstream;
 598     gint ver = 0;
 599
 600     if (!gst_structure_get_boolean (s, "systemstream", &sysstream) ||
 601         !gst_structure_get_int (s, "mpegversion", &ver) || ver < 1 || ver > 4) {
 602       GST_WARNING ("Missing fields in mpeg video caps %" GST_PTR_FORMAT, caps);
 603     } else {
 604       if (sysstream) {
 605         return g_strdup_printf ("MPEG-%d System Stream", ver);
 606       } else {
 607         return g_strdup_printf ("MPEG-%d Video", ver);
 608       }
 609     }
 610     return g_strdup ("MPEG Video");
 611   } else if (strcmp (info->type, "audio/x-raw") == 0) {
 612     gint depth = 0;
 613     gboolean is_float;
 614     const gchar *str;
 615     GstAudioFormat format;
 616     const GstAudioFormatInfo *finfo;
 617
 618     str = gst_structure_get_string (s, "format");
 619     format = gst_audio_format_from_string (str);
 620     if (format == GST_AUDIO_FORMAT_UNKNOWN)
 621       return g_strdup (_("Uncompressed audio"));
 622
 623     finfo = gst_audio_format_get_info (format);
 624     depth = GST_AUDIO_FORMAT_INFO_DEPTH (finfo);
 625     is_float = GST_AUDIO_FORMAT_INFO_IS_FLOAT (finfo);
 626
 627     return g_strdup_printf (_("Raw %d-bit %s audio"), depth,
 628         is_float ? "floating-point" : "PCM");
 629   }
 630   return NULL;
 631 }
 632
 633 /* returns format info structure, will return NULL for dynamic media types! */
 634 static const FormatInfo *
 635 find_format_info (const GstCaps * caps)
 636 {
 637   const GstStructure *s;
 638   const gchar *media_type;
 639   guint i;
 640
 641   s = gst_caps_get_structure (caps, 0);
 642   media_type = gst_structure_get_name (s);
 643
 644   for (i = 0; i < G_N_ELEMENTS (formats); ++i) {
 645     if (strcmp (media_type, formats[i].type) == 0) {
 646       gboolean is_sys = FALSE;
 647
 648       if ((formats[i].flags & FLAG_SYSTEMSTREAM) == 0)
 649         return &formats[i];
 650
 651       /* this record should only be matched if the systemstream field is set */
 652       if (gst_structure_get_boolean (s, "systemstream", &is_sys) && is_sys)
 653         return &formats[i];
 654     }
 655   }
 656
 657   return NULL;
 658 }
 659
 660 static gboolean
 661 caps_are_rtp_caps (const GstCaps * caps, const gchar * media, gchar ** format)
 662 {
 663   const GstStructure *s;
 664   const gchar *str;
 665
 666   g_assert (media != NULL && format != NULL);
 667
 668   s = gst_caps_get_structure (caps, 0);
 669   if (!gst_structure_has_name (s, "application/x-rtp"))
 670     return FALSE;
 671   if (!gst_structure_has_field_typed (s, "media", G_TYPE_STRING))
 672     return FALSE;
 673   str = gst_structure_get_string (s, "media");
 674   if (str == NULL || !g_str_equal (str, media))
 675     return FALSE;
 676   str = gst_structure_get_string (s, "encoding-name");
 677   if (str == NULL || *str == '\0')
 678     return FALSE;
 679
 680   if (strcmp (str, "X-ASF-PF") == 0) {
 681     *format = g_strdup ("Windows Media");
 682   } else if (g_str_has_prefix (str, "X-")) {
 683     *format = g_strdup (str + 2);
 684   } else {
 685     *format = g_strdup (str);
 686   }
 687
 688   return TRUE;
 689 }
 690
 691 /**
 692  * gst_pb_utils_get_source_description:
 693  * @protocol: the protocol the source element needs to handle, e.g. "http"
 694  *
 695  * Returns a localised string describing a source element handling the protocol
 696  * specified in @protocol, for use in error dialogs or other messages to be
 697  * seen by the user. Should never return NULL unless @protocol is invalid.
 698  *
 699  * This function is mainly for internal use, applications would typically
 700  * use gst_missing_plugin_message_get_description() to get a description of
 701  * a missing feature from a missing-plugin message.
 702  *
 703  * Returns: a newly-allocated description string, or NULL on error. Free
 704  *          string with g_free() when not needed any longer.
 705  */
 706 gchar *
 707 gst_pb_utils_get_source_description (const gchar * protocol)
 708 {
 709   gchar *proto_uc, *ret;
 710
 711   g_return_val_if_fail (protocol != NULL, NULL);
 712
 713   if (strcmp (protocol, "cdda") == 0)
 714     return g_strdup (_("Audio CD source"));
 715
 716   if (strcmp (protocol, "dvd") == 0)
 717     return g_strdup (_("DVD source"));
 718
 719   if (strcmp (protocol, "rtsp") == 0)
 720     return g_strdup (_("Real Time Streaming Protocol (RTSP) source"));
 721
 722   /* TODO: what about mmst, mmsu, mmsh? */
 723   if (strcmp (protocol, "mms") == 0)
 724     return g_strdup (_("Microsoft Media Server (MMS) protocol source"));
 725
 726   /* make protocol uppercase */
 727   proto_uc = g_ascii_strup (protocol, -1);
 728
 729   /* TODO: find out how to add a comment for translators to the source code
 730    * (and tell them to make the first letter uppercase below if they move
 731    * the protocol to the middle or end of the string) */
 732   ret = g_strdup_printf (_("%s protocol source"), proto_uc);
 733
 734   g_free (proto_uc);
 735
 736   return ret;
 737 }
 738
 739 /**
 740  * gst_pb_utils_get_sink_description:
 741  * @protocol: the protocol the sink element needs to handle, e.g. "http"
 742  *
 743  * Returns a localised string describing a sink element handling the protocol
 744  * specified in @protocol, for use in error dialogs or other messages to be
 745  * seen by the user. Should never return NULL unless @protocol is invalid.
 746  *
 747  * This function is mainly for internal use, applications would typically
 748  * use gst_missing_plugin_message_get_description() to get a description of
 749  * a missing feature from a missing-plugin message.
 750  *
 751  * Returns: a newly-allocated description string, or NULL on error. Free
 752  *          string with g_free() when not needed any longer.
 753  */
 754 gchar *
 755 gst_pb_utils_get_sink_description (const gchar * protocol)
 756 {
 757   gchar *proto_uc, *ret;
 758
 759   g_return_val_if_fail (protocol != NULL, NULL);
 760
 761   /* make protocol uppercase */
 762   proto_uc = g_ascii_strup (protocol, -1);
 763
 764   /* TODO: find out how to add a comment for translators to the source code
 765    * (and tell them to make the first letter uppercase below if they move
 766    * the protocol to the middle or end of the string) */
 767   ret = g_strdup_printf ("%s protocol sink", proto_uc);
 768
 769   g_free (proto_uc);
 770
 771   return ret;
 772 }
 773
 774 /**
 775  * gst_pb_utils_get_decoder_description:
 776  * @caps: the (fixed) #GstCaps for which an decoder description is needed
 777  *
 778  * Returns a localised string describing an decoder for the format specified
 779  * in @caps, for use in error dialogs or other messages to be seen by the user.
 780  * Should never return NULL unless @factory_name or @caps are invalid.
 781  *
 782  * This function is mainly for internal use, applications would typically
 783  * use gst_missing_plugin_message_get_description() to get a description of
 784  * a missing feature from a missing-plugin message.
 785  *
 786  * Returns: a newly-allocated description string, or NULL on error. Free
 787  *          string with g_free() when not needed any longer.
 788  */
 789 gchar *
 790 gst_pb_utils_get_decoder_description (const GstCaps * caps)
 791 {
 792   gchar *str, *ret;
 793   GstCaps *tmp;
 794
 795   g_return_val_if_fail (caps != NULL, NULL);
 796   g_return_val_if_fail (GST_IS_CAPS (caps), NULL);
 797
 798   tmp = copy_and_clean_caps (caps);
 799
 800   g_return_val_if_fail (gst_caps_is_fixed (tmp), NULL);
 801
 802   /* special-case RTP caps */
 803   if (caps_are_rtp_caps (tmp, "video", &str)) {
 804     ret = g_strdup_printf (_("%s video RTP depayloader"), str);
 805   } else if (caps_are_rtp_caps (tmp, "audio", &str)) {
 806     ret = g_strdup_printf (_("%s audio RTP depayloader"), str);
 807   } else if (caps_are_rtp_caps (tmp, "application", &str)) {
 808     ret = g_strdup_printf (_("%s RTP depayloader"), str);
 809   } else {
 810     const FormatInfo *info;
 811
 812     str = gst_pb_utils_get_codec_description (tmp);
 813     info = find_format_info (tmp);
 814     if (info != NULL && (info->flags & FLAG_CONTAINER) != 0) {
 815       ret = g_strdup_printf (_("%s demuxer"), str);
 816     } else {
 817       ret = g_strdup_printf (_("%s decoder"), str);
 818     }
 819   }
 820
 821   g_free (str);
 822   gst_caps_unref (tmp);
 823
 824   return ret;
 825 }
 826
 827 /**
 828  * gst_pb_utils_get_encoder_description:
 829  * @caps: the (fixed) #GstCaps for which an encoder description is needed
 830  *
 831  * Returns a localised string describing an encoder for the format specified
 832  * in @caps, for use in error dialogs or other messages to be seen by the user.
 833  * Should never return NULL unless @factory_name or @caps are invalid.
 834  *
 835  * This function is mainly for internal use, applications would typically
 836  * use gst_missing_plugin_message_get_description() to get a description of
 837  * a missing feature from a missing-plugin message.
 838  *
 839  * Returns: a newly-allocated description string, or NULL on error. Free
 840  *          string with g_free() when not needed any longer.
 841  */
 842 gchar *
 843 gst_pb_utils_get_encoder_description (const GstCaps * caps)
 844 {
 845   gchar *str, *ret;
 846   GstCaps *tmp;
 847
 848   g_return_val_if_fail (caps != NULL, NULL);
 849   g_return_val_if_fail (GST_IS_CAPS (caps), NULL);
 850   tmp = copy_and_clean_caps (caps);
 851   g_return_val_if_fail (gst_caps_is_fixed (tmp), NULL);
 852
 853   /* special-case RTP caps */
 854   if (caps_are_rtp_caps (tmp, "video", &str)) {
 855     ret = g_strdup_printf (_("%s video RTP payloader"), str);
 856   } else if (caps_are_rtp_caps (tmp, "audio", &str)) {
 857     ret = g_strdup_printf (_("%s audio RTP payloader"), str);
 858   } else if (caps_are_rtp_caps (tmp, "application", &str)) {
 859     ret = g_strdup_printf (_("%s RTP payloader"), str);
 860   } else {
 861     const FormatInfo *info;
 862
 863     str = gst_pb_utils_get_codec_description (tmp);
 864     info = find_format_info (tmp);
 865     if (info != NULL && (info->flags & FLAG_CONTAINER) != 0) {
 866       ret = g_strdup_printf (_("%s muxer"), str);
 867     } else {
 868       ret = g_strdup_printf (_("%s encoder"), str);
 869     }
 870   }
 871
 872   g_free (str);
 873   gst_caps_unref (tmp);
 874
 875   return ret;
 876 }
 877
 878 /**
 879  * gst_pb_utils_get_element_description:
 880  * @factory_name: the name of the element, e.g. "giosrc"
 881  *
 882  * Returns a localised string describing the given element, for use in
 883  * error dialogs or other messages to be seen by the user. Should never
 884  * return NULL unless @factory_name is invalid.
 885  *
 886  * This function is mainly for internal use, applications would typically
 887  * use gst_missing_plugin_message_get_description() to get a description of
 888  * a missing feature from a missing-plugin message.
 889  *
 890  * Returns: a newly-allocated description string, or NULL on error. Free
 891  *          string with g_free() when not needed any longer.
 892  */
 893 gchar *
 894 gst_pb_utils_get_element_description (const gchar * factory_name)
 895 {
 896   gchar *ret;
 897
 898   g_return_val_if_fail (factory_name != NULL, NULL);
 899
 900   ret = g_strdup_printf (_("GStreamer element %s"), factory_name);
 901   if (ret && g_str_has_prefix (ret, factory_name))
 902     *ret = g_ascii_toupper (*ret);
 903
 904   return ret;
 905 }
 906
 907 /**
 908  * gst_pb_utils_add_codec_description_to_tag_list:
 909  * @taglist: a #GstTagList
 910  * @codec_tag: a GStreamer codec tag such as #GST_TAG_AUDIO_CODEC,
 911  *             #GST_TAG_VIDEO_CODEC or #GST_TAG_CODEC
 912  * @caps: the (fixed) #GstCaps for which a codec tag should be added.
 913  *
 914  * Adds a codec tag describing the format specified by @caps to @taglist.
 915  *
 916  * Returns: TRUE if a codec tag was added, FALSE otherwise.
 917  */
 918 gboolean
 919 gst_pb_utils_add_codec_description_to_tag_list (GstTagList * taglist,
 920     const gchar * codec_tag, const GstCaps * caps)
 921 {
 922   const FormatInfo *info;
 923   gchar *desc;
 924
 925   g_return_val_if_fail (taglist != NULL, FALSE);
 926   g_return_val_if_fail (GST_IS_TAG_LIST (taglist), FALSE);
 927   g_return_val_if_fail (codec_tag != NULL, FALSE);
 928   g_return_val_if_fail (gst_tag_exists (codec_tag), FALSE);
 929   g_return_val_if_fail (gst_tag_get_type (codec_tag) == G_TYPE_STRING, FALSE);
 930   g_return_val_if_fail (caps != NULL, FALSE);
 931   g_return_val_if_fail (GST_IS_CAPS (caps), FALSE);
 932
 933   info = find_format_info (caps);
 934   if (info == NULL)
 935     return FALSE;
 936
 937   desc = format_info_get_desc (info, caps);
 938   gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, codec_tag, desc, NULL);
 939   g_free (desc);
 940
 941   return TRUE;
 942 }
 943
 944 /**
 945  * gst_pb_utils_get_codec_description:
 946  * @caps: the (fixed) #GstCaps for which an format description is needed
 947  *
 948  * Returns a localised (as far as this is possible) string describing the
 949  * media format specified in @caps, for use in error dialogs or other messages
 950  * to be seen by the user. Should never return NULL unless @caps is invalid.
 951  *
 952  * Also see the convenience function
 953  * gst_pb_utils_add_codec_description_to_tag_list().
 954  *
 955  * Returns: a newly-allocated description string, or NULL on error. Free
 956  *          string with g_free() when not needed any longer.
 957  */
 958 gchar *
 959 gst_pb_utils_get_codec_description (const GstCaps * caps)
 960 {
 961   const FormatInfo *info;
 962   gchar *str, *comma;
 963   GstCaps *tmp;
 964
 965   g_return_val_if_fail (caps != NULL, NULL);
 966   g_return_val_if_fail (GST_IS_CAPS (caps), NULL);
 967   tmp = copy_and_clean_caps (caps);
 968   g_return_val_if_fail (gst_caps_is_fixed (tmp), NULL);
 969
 970   info = find_format_info (tmp);
 971
 972   if (info) {
 973     str = format_info_get_desc (info, tmp);
 974   } else {
 975     str = gst_caps_to_string (tmp);
 976
 977     /* cut off everything after the media type, if there is anything */
 978     if ((comma = strchr (str, ','))) {
 979       *comma = '\0';
 980       g_strchomp (str);
 981       /* we could do something more elaborate here, like taking into account
 982        * audio/, video/, image/ and application/ prefixes etc. */
 983     }
 984
 985     GST_WARNING ("No description available for media type: %s", str);
 986   }
 987   gst_caps_unref (tmp);
 988
 989   return str;
 990 }
 991
 992 #if 0
 993 void
 994 gst_pb_utils_list_all (void)
 995 {
 996   gint i;
 997
 998   g_print ("static const gchar *caps_strings[] = { ");
 999
1000   for (i = 0; i < G_N_ELEMENTS (formats); ++i) {
1001     if (formats[i].desc != NULL)
1002       g_print ("  \"%s\", ", formats[i].type);
1003   }
1004   g_print ("\n#if 0\n");
1005   for (i = 0; i < G_N_ELEMENTS (formats); ++i) {
1006     if (formats[i].desc == NULL)
1007       g_print ("  \"%s\", \n", formats[i].type);
1008   }
1009   g_print ("\n#endif\n");
1010 }
1011 #endif