gst/gsttaglist.h

   1 /* GStreamer
   2  * Copyright (C) 2003 Benjamin Otte <in7y118@public.uni-hamburg.de>
   3  *
   4  * gsttaglist.h: Header for tag support
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19  * Boston, MA 02111-1307, USA.
  20  */
  21
  22
  23 #ifndef __GST_TAGLIST_H__
  24 #define __GST_TAGLIST_H__
  25
  26 #include <gst/gststructure.h>
  27 #include <gst/glib-compat.h>
  28
  29 G_BEGIN_DECLS
  30
  31 /**
  32  * GstTagMergeMode:
  33  * @GST_TAG_MERGE_UNDEFINED: undefined merge mode
  34  * @GST_TAG_MERGE_REPLACE_ALL: replace all tags (clear list and append)
  35  * @GST_TAG_MERGE_REPLACE: replace tags
  36  * @GST_TAG_MERGE_APPEND: append tags
  37  * @GST_TAG_MERGE_PREPEND: prepend tags
  38  * @GST_TAG_MERGE_KEEP: keep existing tags
  39  * @GST_TAG_MERGE_KEEP_ALL: keep all existing tags
  40  * @GST_TAG_MERGE_COUNT: the number of merge modes
  41  *
  42  * The different tag merging modes are basically replace, overwrite and append,
  43  * but they can be seen from two directions. Given two taglists: (A) the tags
  44  * already in the element and (B) the ones that are supplied to the element (
  45  * e.g. via gst_tag_setter_merge_tags() / gst_tag_setter_add_tags() or a
  46  * %GST_EVENT_TAG), how are these tags merged?
  47  * In the table below this is shown for the cases that a tag exists in the list
  48  * (A) or does not exists (!A) and combinations thereof.
  49  *
  50  * <table frame="all" colsep="1" rowsep="1">
  51  *   <title>merge mode</title>
  52  *   <tgroup cols='5' align='left'>
  53  *     <thead>
  54  *       <row>
  55  *         <entry>merge mode</entry>
  56  *         <entry>A + B</entry>
  57  *         <entry>A + !B</entry>
  58  *         <entry>!A + B</entry>
  59  *         <entry>!A + !B</entry>
  60  *       </row>
  61  *     </thead>
  62  *     <tbody>
  63  *       <row>
  64  *         <entry>REPLACE_ALL</entry>
  65  *         <entry>B</entry>
  66  *         <entry>-</entry>
  67  *         <entry>B</entry>
  68  *         <entry>-</entry>
  69  *       </row>
  70  *       <row>
  71  *         <entry>REPLACE</entry>
  72  *         <entry>B</entry>
  73  *         <entry>A</entry>
  74  *         <entry>B</entry>
  75  *         <entry>-</entry>
  76  *       </row>
  77  *       <row>
  78  *         <entry>APPEND</entry>
  79  *         <entry>A, B</entry>
  80  *         <entry>A</entry>
  81  *         <entry>B</entry>
  82  *         <entry>-</entry>
  83  *       </row>
  84  *       <row>
  85  *         <entry>PREPEND</entry>
  86  *         <entry>B, A</entry>
  87  *         <entry>A</entry>
  88  *         <entry>B</entry>
  89  *         <entry>-</entry>
  90  *       </row>
  91  *       <row>
  92  *         <entry>KEEP</entry>
  93  *         <entry>A</entry>
  94  *         <entry>A</entry>
  95  *         <entry>B</entry>
  96  *         <entry>-</entry>
  97  *       </row>
  98  *       <row>
  99  *         <entry>KEEP_ALL</entry>
 100  *         <entry>A</entry>
 101  *         <entry>A</entry>
 102  *         <entry>-</entry>
 103  *         <entry>-</entry>
 104  *       </row>
 105  *     </tbody>
 106  *   </tgroup>
 107  * </table>
 108  */
 109 typedef enum {
 110   GST_TAG_MERGE_UNDEFINED,
 111   GST_TAG_MERGE_REPLACE_ALL,
 112   GST_TAG_MERGE_REPLACE,
 113   GST_TAG_MERGE_APPEND,
 114   GST_TAG_MERGE_PREPEND,
 115   GST_TAG_MERGE_KEEP,
 116   GST_TAG_MERGE_KEEP_ALL,
 117   /* add more */
 118   GST_TAG_MERGE_COUNT
 119 } GstTagMergeMode;
 120
 121 #define GST_TAG_MODE_IS_VALID(mode)     (((mode) > GST_TAG_MERGE_UNDEFINED) && ((mode) < GST_TAG_MERGE_COUNT))
 122
 123 /**
 124  * GstTagFlag:
 125  * @GST_TAG_FLAG_UNDEFINED: undefined flag
 126  * @GST_TAG_FLAG_META: tag is meta data
 127  * @GST_TAG_FLAG_ENCODED: tag is encoded
 128  * @GST_TAG_FLAG_DECODED: tag is decoded
 129  * @GST_TAG_FLAG_COUNT: number of tag flags
 130  *
 131  * Extra tag flags used when registering tags.
 132  */
 133 typedef enum {
 134   GST_TAG_FLAG_UNDEFINED,
 135   GST_TAG_FLAG_META,
 136   GST_TAG_FLAG_ENCODED,
 137   GST_TAG_FLAG_DECODED,
 138   GST_TAG_FLAG_COUNT
 139 } GstTagFlag;
 140
 141 #define GST_TAG_FLAG_IS_VALID(flag)     (((flag) > GST_TAG_FLAG_UNDEFINED) && ((flag) < GST_TAG_FLAG_COUNT))
 142
 143 /**
 144  * GstTagList:
 145  *
 146  * Opaque #GstTagList data structure.
 147  */
 148 typedef GstStructure GstTagList;
 149 #define GST_TAG_LIST(x)       ((GstTagList *) (x))
 150 #define GST_IS_TAG_LIST(x)    ((x) != NULL && gst_is_tag_list (GST_TAG_LIST (x)))
 151 #define GST_TYPE_TAG_LIST     (gst_tag_list_get_type ())
 152
 153 /**
 154  * GstTagForeachFunc:
 155  * @list: the #GstTagList
 156  * @tag: a name of a tag in @list
 157  * @user_data: user data
 158  *
 159  * A function that will be called in gst_tag_list_foreach(). The function may
 160  * not modify the tag list.
 161  */
 162 typedef void (*GstTagForeachFunc) (const GstTagList * list,
 163                                    const gchar      * tag,
 164                                    gpointer           user_data);
 165
 166 /**
 167  * GstTagMergeFunc:
 168  * @dest: the destination #GValue
 169  * @src: the source #GValue
 170  *
 171  * A function for merging multiple values of a tag used when registering
 172  * tags.
 173  */
 174 typedef void (* GstTagMergeFunc) (GValue *dest, const GValue *src);
 175
 176 GType        gst_tag_list_get_type (void);
 177
 178 /* tag registration */
 179 void         gst_tag_register      (const gchar     * name,
 180                                     GstTagFlag        flag,
 181                                     GType             type,
 182                                     const gchar     * nick,
 183                                     const gchar     * blurb,
 184                                     GstTagMergeFunc   func);
 185
 186 /* some default merging functions */
 187 void      gst_tag_merge_use_first          (GValue * dest, const GValue * src);
 188 void      gst_tag_merge_strings_with_comma (GValue * dest, const GValue * src);
 189
 190 /* basic tag support */
 191 gboolean               gst_tag_exists          (const gchar * tag);
 192 GType                  gst_tag_get_type        (const gchar * tag);
 193 G_CONST_RETURN gchar * gst_tag_get_nick        (const gchar * tag);
 194 G_CONST_RETURN gchar * gst_tag_get_description (const gchar * tag);
 195 GstTagFlag             gst_tag_get_flag        (const gchar * tag);
 196 gboolean               gst_tag_is_fixed        (const gchar * tag);
 197
 198 /* tag lists */
 199 GstTagList * gst_tag_list_new               (void);
 200 gboolean     gst_is_tag_list                (gconstpointer p);
 201 GstTagList * gst_tag_list_copy              (const GstTagList * list);
 202 gboolean     gst_tag_list_is_empty          (const GstTagList * list);
 203 void         gst_tag_list_insert            (GstTagList       * into,
 204                                              const GstTagList * from,
 205                                              GstTagMergeMode    mode);
 206 GstTagList * gst_tag_list_merge             (const GstTagList * list1,
 207                                              const GstTagList * list2,
 208                                              GstTagMergeMode    mode);
 209 void         gst_tag_list_free              (GstTagList       * list);
 210 guint        gst_tag_list_get_tag_size      (const GstTagList * list,
 211                                              const gchar      * tag);
 212 void         gst_tag_list_add               (GstTagList       * list,
 213                                              GstTagMergeMode    mode,
 214                                              const gchar      * tag,
 215                                              ...) G_GNUC_NULL_TERMINATED;
 216 void         gst_tag_list_add_values        (GstTagList       * list,
 217                                              GstTagMergeMode    mode,
 218                                              const gchar      * tag,
 219                                              ...) G_GNUC_NULL_TERMINATED;
 220 void         gst_tag_list_add_valist        (GstTagList       * list,
 221                                              GstTagMergeMode    mode,
 222                                              const gchar      * tag,
 223                                              va_list        var_args);
 224 void         gst_tag_list_add_valist_values (GstTagList       * list,
 225                                              GstTagMergeMode    mode,
 226                                              const gchar      * tag,
 227                                              va_list            var_args);
 228 void         gst_tag_list_remove_tag        (GstTagList       * list,
 229                                              const gchar      * tag);
 230 void         gst_tag_list_foreach           (const GstTagList * list,
 231                                              GstTagForeachFunc  func,
 232                                              gpointer           user_data);
 233
 234 G_CONST_RETURN GValue *
 235              gst_tag_list_get_value_index   (const GstTagList * list,
 236                                              const gchar      * tag,
 237                                              guint              index);
 238 gboolean     gst_tag_list_copy_value        (GValue           * dest,
 239                                              const GstTagList * list,
 240                                              const gchar      * tag);
 241
 242 /* simplifications (FIXME: do we want them?) */
 243 gboolean     gst_tag_list_get_char          (const GstTagList * list,
 244                                              const gchar      * tag,
 245                                              gchar            * value);
 246 gboolean     gst_tag_list_get_char_index    (const GstTagList * list,
 247                                              const gchar      * tag,
 248                                              guint              index,
 249                                              gchar            * value);
 250 gboolean     gst_tag_list_get_uchar         (const GstTagList * list,
 251                                              const gchar      * tag,
 252                                              guchar           * value);
 253 gboolean     gst_tag_list_get_uchar_index   (const GstTagList * list,
 254                                              const gchar      * tag,
 255                                              guint              index,
 256                                              guchar           * value);
 257 gboolean     gst_tag_list_get_boolean       (const GstTagList * list,
 258                                              const gchar      * tag,
 259                                              gboolean         * value);
 260 gboolean     gst_tag_list_get_boolean_index (const GstTagList * list,
 261                                              const gchar      * tag,
 262                                              guint              index,
 263                                              gboolean         * value);
 264 gboolean     gst_tag_list_get_int           (const GstTagList * list,
 265                                              const gchar      * tag,
 266                                              gint             * value);
 267 gboolean     gst_tag_list_get_int_index     (const GstTagList * list,
 268                                              const gchar      * tag,
 269                                              guint              index,
 270                                              gint             * value);
 271 gboolean     gst_tag_list_get_uint          (const GstTagList * list,
 272                                              const gchar      * tag,
 273                                              guint            * value);
 274 gboolean     gst_tag_list_get_uint_index    (const GstTagList * list,
 275                                              const gchar      * tag,
 276                                              guint              index,
 277                                              guint            * value);
 278 gboolean     gst_tag_list_get_long          (const GstTagList * list,
 279                                              const gchar      * tag,
 280                                              glong            * value);
 281 gboolean     gst_tag_list_get_long_index    (const GstTagList * list,
 282                                              const gchar      * tag,
 283                                              guint              index,
 284                                              glong            * value);
 285 gboolean     gst_tag_list_get_ulong         (const GstTagList * list,
 286                                              const gchar      * tag,
 287                                              gulong           * value);
 288 gboolean     gst_tag_list_get_ulong_index   (const GstTagList * list,
 289                                              const gchar      * tag,
 290                                              guint              index,
 291                                              gulong           * value);
 292 gboolean     gst_tag_list_get_int64         (const GstTagList * list,
 293                                              const gchar      * tag,
 294                                              gint64           * value);
 295 gboolean     gst_tag_list_get_int64_index   (const GstTagList * list,
 296                                              const gchar      * tag,
 297                                              guint              index,
 298                                              gint64           * value);
 299 gboolean     gst_tag_list_get_uint64        (const GstTagList * list,
 300                                              const gchar      * tag,
 301                                              guint64          * value);
 302 gboolean     gst_tag_list_get_uint64_index  (const GstTagList * list,
 303                                              const gchar      * tag,
 304                                              guint              index,
 305                                              guint64          * value);
 306 gboolean     gst_tag_list_get_float         (const GstTagList * list,
 307                                              const gchar      * tag,
 308                                              gfloat           * value);
 309 gboolean     gst_tag_list_get_float_index   (const GstTagList * list,
 310                                              const gchar      * tag,
 311                                              guint              index,
 312                                              gfloat           * value);
 313 gboolean     gst_tag_list_get_double        (const GstTagList * list,
 314                                              const gchar      * tag,
 315                                              gdouble          * value);
 316 gboolean     gst_tag_list_get_double_index  (const GstTagList * list,
 317                                              const gchar      * tag,
 318                                              guint              index,
 319                                              gdouble          * value);
 320 gboolean     gst_tag_list_get_string        (const GstTagList * list,
 321                                              const gchar      * tag,
 322                                              gchar           ** value);
 323 gboolean     gst_tag_list_get_string_index  (const GstTagList * list,
 324                                              const gchar      * tag,
 325                                              guint              index,
 326                                              gchar           ** value);
 327 gboolean     gst_tag_list_get_pointer       (const GstTagList * list,
 328                                              const gchar      * tag,
 329                                              gpointer         * value);
 330 gboolean     gst_tag_list_get_pointer_index (const GstTagList * list,
 331                                              const gchar      * tag,
 332                                              guint              index,
 333                                              gpointer         * value);
 334 gboolean     gst_tag_list_get_date          (const GstTagList * list,
 335                                              const gchar      * tag,
 336                                              GDate           ** value);
 337 gboolean     gst_tag_list_get_date_index    (const GstTagList * list,
 338                                              const gchar      * tag,
 339                                              guint              index,
 340                                              GDate           ** value);
 341
 342 /* GStreamer core tags */
 343 /**
 344  * GST_TAG_TITLE:
 345  *
 346  * commonly used title (string)
 347  *
 348  * The title as it should be displayed, e.g. 'The Doll House'
 349  */
 350 #define GST_TAG_TITLE                  "title"
 351 /**
 352  * GST_TAG_TITLE_SORTNAME:
 353  *
 354  * commonly used title, as used for sorting (string)
 355  *
 356  * The title as it should be sorted, e.g. 'Doll House, The'
 357  *
 358  * Since: 0.10.15
 359  */
 360 #define GST_TAG_TITLE_SORTNAME         "title-sortname"
 361 /**
 362  * GST_TAG_ARTIST:
 363  *
 364  * person(s) responsible for the recording (string)
 365  *
 366  * The artist name as it should be displayed, e.g. 'Jimi Hendrix' or
 367  * 'The Guitar Heroes'
 368  */
 369 #define GST_TAG_ARTIST                 "artist"
 370 /**
 371  * GST_TAG_ARTIST_SORTNAME:
 372  *
 373  * person(s) responsible for the recording, as used for sorting (string)
 374  *
 375  * The artist name as it should be sorted, e.g. 'Hendrix, Jimi' or
 376  * 'Guitar Heroes, The'
 377  *
 378  * Since: 0.10.15
 379  */
 380 /* FIXME 0.11: change to "artist-sortname" */
 381 #define GST_TAG_ARTIST_SORTNAME        "musicbrainz-sortname"
 382 /**
 383  * GST_TAG_ALBUM:
 384  *
 385  * album containing this data (string)
 386  *
 387  * The album name as it should be displayed, e.g. 'The Jazz Guitar'
 388  */
 389 #define GST_TAG_ALBUM                  "album"
 390 /**
 391  * GST_TAG_ALBUM_SORTNAME:
 392  *
 393  * album containing this data, as used for sorting (string)
 394  *
 395  * The album name as it should be sorted, e.g. 'Jazz Guitar, The'
 396  *
 397  * Since: 0.10.15
 398  */
 399 #define GST_TAG_ALBUM_SORTNAME         "album-sortname"
 400 /**
 401  * GST_TAG_COMPOSER:
 402  *
 403  * person(s) who composed the recording (string)
 404  *
 405  * Since: 0.10.15
 406  */
 407 #define GST_TAG_COMPOSER               "composer"
 408 /**
 409  * GST_TAG_DATE:
 410  *
 411  * date the data was created (#GDate structure)
 412  */
 413 #define GST_TAG_DATE                   "date"
 414 /**
 415  * GST_TAG_GENRE:
 416  *
 417  * genre this data belongs to (string)
 418  */
 419 #define GST_TAG_GENRE                  "genre"
 420 /**
 421  * GST_TAG_COMMENT:
 422  *
 423  * free text commenting the data (string)
 424  */
 425 #define GST_TAG_COMMENT                "comment"
 426 /**
 427  * GST_TAG_EXTENDED_COMMENT:
 428  *
 429  * key/value text commenting the data (string)
 430  *
 431  * Must be in the form of 'key=comment' or
 432  * 'key[lc]=comment' where 'lc' is an ISO-639
 433  * language code.
 434  *
 435  * This tag is used for unknown Vorbis comment tags,
 436  * unknown APE tags and certain ID3v2 comment fields.
 437  *
 438  * Since: 0.10.10
 439  */
 440 #define GST_TAG_EXTENDED_COMMENT       "extended-comment"
 441 /**
 442  * GST_TAG_TRACK_NUMBER:
 443  *
 444  * track number inside a collection (unsigned integer)
 445  */
 446 #define GST_TAG_TRACK_NUMBER           "track-number"
 447 /**
 448  * GST_TAG_TRACK_COUNT:
 449  *
 450  * count of tracks inside collection this track belongs to (unsigned integer)
 451  */
 452 #define GST_TAG_TRACK_COUNT            "track-count"
 453 /**
 454  * GST_TAG_ALBUM_VOLUME_NUMBER:
 455  *
 456  * disc number inside a collection (unsigned integer)
 457  */
 458 #define GST_TAG_ALBUM_VOLUME_NUMBER    "album-disc-number"
 459 /**
 460  * GST_TAG_ALBUM_VOLUME_COUNT:
 461  *
 462  * count of discs inside collection this disc belongs to (unsigned integer)
 463  */
 464 #define GST_TAG_ALBUM_VOLUME_COUNT    "album-disc-count"
 465 /**
 466  * GST_TAG_LOCATION:
 467  *
 468  * Origin of media as a URI (location, where the original of the file or stream
 469  * is hosted) (string)
 470  */
 471 #define GST_TAG_LOCATION               "location"
 472 /**
 473  * GST_TAG_HOMEPAGE:
 474  *
 475  * Homepage for this media (i.e. artist or movie homepage) (string)
 476  *
 477  * Since: 0.10.23
 478  */
 479 #define GST_TAG_HOMEPAGE               "homepage"
 480 /**
 481  * GST_TAG_DESCRIPTION:
 482  *
 483  * short text describing the content of the data (string)
 484  */
 485 #define GST_TAG_DESCRIPTION            "description"
 486 /**
 487  * GST_TAG_VERSION:
 488  *
 489  * version of this data (string)
 490  */
 491 #define GST_TAG_VERSION                "version"
 492 /**
 493  * GST_TAG_ISRC:
 494  *
 495  * International Standard Recording Code - see http://www.ifpi.org/isrc/ (string)
 496  */
 497 #define GST_TAG_ISRC                   "isrc"
 498 /**
 499  * GST_TAG_ORGANIZATION:
 500  *
 501  * organization (string)
 502  */
 503 #define GST_TAG_ORGANIZATION           "organization"
 504 /**
 505  * GST_TAG_COPYRIGHT:
 506  *
 507  * copyright notice of the data (string)
 508  */
 509 #define GST_TAG_COPYRIGHT              "copyright"
 510 /**
 511  * GST_TAG_COPYRIGHT_URI:
 512  *
 513  * URI to location where copyright details can be found (string)
 514  *
 515  * Since: 0.10.14
 516  */
 517 #define GST_TAG_COPYRIGHT_URI          "copyright-uri"
 518 /**
 519  * GST_TAG_CONTACT:
 520  *
 521  * contact information (string)
 522  */
 523 #define GST_TAG_CONTACT                "contact"
 524 /**
 525  * GST_TAG_LICENSE:
 526  *
 527  * license of data (string)
 528  */
 529 #define GST_TAG_LICENSE                "license"
 530 /**
 531  * GST_TAG_LICENSE_URI:
 532  *
 533  * URI to location where license details can be found (string)
 534  *
 535  * Since: 0.10.14
 536  */
 537 #define GST_TAG_LICENSE_URI            "license-uri"
 538 /**
 539  * GST_TAG_PERFORMER:
 540  *
 541  * person(s) performing (string)
 542  */
 543 #define GST_TAG_PERFORMER              "performer"
 544 /**
 545  * GST_TAG_DURATION:
 546  *
 547  * length in GStreamer time units (nanoseconds) (unsigned 64-bit integer)
 548  */
 549 #define GST_TAG_DURATION               "duration"
 550 /**
 551  * GST_TAG_CODEC:
 552  *
 553  * codec the data is stored in (string)
 554  */
 555 #define GST_TAG_CODEC                  "codec"
 556 /**
 557  * GST_TAG_VIDEO_CODEC:
 558  *
 559  * codec the video data is stored in (string)
 560  */
 561 #define GST_TAG_VIDEO_CODEC            "video-codec"
 562 /**
 563  * GST_TAG_AUDIO_CODEC:
 564  *
 565  * codec the audio data is stored in (string)
 566  */
 567 #define GST_TAG_AUDIO_CODEC            "audio-codec"
 568 /**
 569  * GST_TAG_BITRATE:
 570  *
 571  * exact or average bitrate in bits/s (unsigned integer)
 572  */
 573 #define GST_TAG_BITRATE                "bitrate"
 574 /**
 575  * GST_TAG_NOMINAL_BITRATE:
 576  *
 577  * nominal bitrate in bits/s (unsigned integer)
 578  */
 579 #define GST_TAG_NOMINAL_BITRATE        "nominal-bitrate"
 580 /**
 581  * GST_TAG_MINIMUM_BITRATE:
 582  *
 583  * minimum bitrate in bits/s (unsigned integer)
 584  */
 585 #define GST_TAG_MINIMUM_BITRATE        "minimum-bitrate"
 586 /**
 587  * GST_TAG_MAXIMUM_BITRATE:
 588  *
 589  * maximum bitrate in bits/s (unsigned integer)
 590  */
 591 #define GST_TAG_MAXIMUM_BITRATE        "maximum-bitrate"
 592 /**
 593  * GST_TAG_SERIAL:
 594  *
 595  * serial number of track (unsigned integer)
 596  */
 597 #define GST_TAG_SERIAL                 "serial"
 598 /**
 599  * GST_TAG_ENCODER:
 600  *
 601  * encoder used to encode this stream (string)
 602  */
 603 #define GST_TAG_ENCODER                "encoder"
 604 /**
 605  * GST_TAG_ENCODER_VERSION:
 606  *
 607  * version of the encoder used to encode this stream (unsigned integer)
 608  */
 609 #define GST_TAG_ENCODER_VERSION        "encoder-version"
 610 /**
 611  * GST_TAG_TRACK_GAIN:
 612  *
 613  * track gain in db (double)
 614  */
 615 #define GST_TAG_TRACK_GAIN             "replaygain-track-gain"
 616 /**
 617  * GST_TAG_TRACK_PEAK:
 618  *
 619  * peak of the track (double)
 620  */
 621 #define GST_TAG_TRACK_PEAK             "replaygain-track-peak"
 622 /**
 623  * GST_TAG_ALBUM_GAIN:
 624  *
 625  * album gain in db (double)
 626  */
 627 #define GST_TAG_ALBUM_GAIN             "replaygain-album-gain"
 628 /**
 629  * GST_TAG_ALBUM_PEAK:
 630  *
 631  * peak of the album (double)
 632  */
 633 #define GST_TAG_ALBUM_PEAK             "replaygain-album-peak"
 634 /**
 635  * GST_TAG_REFERENCE_LEVEL:
 636  *
 637  * reference level of track and album gain values (double)
 638  *
 639  * Since: 0.10.12
 640  */
 641 #define GST_TAG_REFERENCE_LEVEL        "replaygain-reference-level"
 642 /**
 643  * GST_TAG_LANGUAGE_CODE:
 644  *
 645  * Language code (ISO-639-1) (string) of the content
 646  */
 647 #define GST_TAG_LANGUAGE_CODE          "language-code"
 648 /**
 649  * GST_TAG_IMAGE:
 650  *
 651  * image (buffer) (buffer caps should specify the content type and preferably
 652  * also set "image-type" field as #GstTagImageType)
 653  *
 654  * Since: 0.10.6
 655  */
 656 #define GST_TAG_IMAGE                  "image"
 657 /**
 658  * GST_TAG_PREVIEW_IMAGE:
 659  *
 660  * image that is meant for preview purposes, e.g. small icon-sized version
 661  * (buffer) (buffer caps should specify the content type)
 662  *
 663  * Since: 0.10.7
 664  */
 665 #define GST_TAG_PREVIEW_IMAGE          "preview-image"
 666
 667 /**
 668  * GST_TAG_ATTACHMENT:
 669  *
 670  * generic file attachment (buffer) (buffer caps should specify the content
 671  * type and if possible set "filename" to the file name of the
 672  * attachment)
 673  *
 674  * Since: 0.10.21
 675  */
 676 #define GST_TAG_ATTACHMENT             "attachment"
 677
 678 /**
 679  * GST_TAG_BEATS_PER_MINUTE:
 680  *
 681  * number of beats per minute in audio (double)
 682  *
 683  * Since: 0.10.12
 684  */
 685 #define GST_TAG_BEATS_PER_MINUTE       "beats-per-minute"
 686
 687 /**
 688  * GST_TAG_KEYWORDS:
 689  *
 690  * comma separated keywords describing the content (string).
 691  *
 692  * Since: 0.10.21
 693  */
 694 #define GST_TAG_KEYWORDS               "keywords"
 695
 696 /**
 697  * GST_TAG_GEO_LOCATION_NAME:
 698  *
 699  * human readable descriptive location of where the media has been recorded or
 700  * produced. (string).
 701  *
 702  * Since: 0.10.21
 703  */
 704 #define GST_TAG_GEO_LOCATION_NAME               "geo-location-name"
 705
 706 /**
 707  * GST_TAG_GEO_LOCATION_LATITUDE:
 708  *
 709  * geo latitude location of where the media has been recorded or produced in
 710  * degrees according to WGS84 (zero at the equator, negative values for southern
 711  * latitudes) (double).
 712  *
 713  * Since: 0.10.21
 714  */
 715 #define GST_TAG_GEO_LOCATION_LATITUDE               "geo-location-latitude"
 716
 717 /**
 718  * GST_TAG_GEO_LOCATION_LONGITUDE:
 719  *
 720  * geo longitude location of where the media has been recorded or produced in
 721  * degrees according to WGS84 (zero at the prime meridian in Greenwich/UK,
 722  * negative values for western longitudes). (double).
 723  *
 724  * Since: 0.10.21
 725  */
 726 #define GST_TAG_GEO_LOCATION_LONGITUDE               "geo-location-longitude"
 727
 728 /**
 729  * GST_TAG_GEO_LOCATION_ELEVATION:
 730  *
 731  * geo elevation of where the media has been recorded or produced in meters
 732  * according to WGS84 (zero is average sea level) (double).
 733  *
 734  * Since: 0.10.21
 735  */
 736 #define GST_TAG_GEO_LOCATION_ELEVATION               "geo-location-elevation"
 737
 738 G_END_DECLS
 739
 740 #endif /* __GST_TAGLIST_H__ */