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