From 9e31b57dc37cb94761ab3aa98018c6f9bc496e0c Mon Sep 17 00:00:00 2001 From: Edgard Lima Date: Fri, 25 Jan 2008 17:45:28 +0000 Subject: [PATCH] Add lot of documentation. Original commit message from CVS: Add lot of documentation. --- ChangeLog | 30 + ext/metadata/TODO | 9 + ext/metadata/gstbasemetadata.c | 4 +- ext/metadata/metadata.c | 180 +++-- ext/metadata/metadata.h | 23 +- ext/metadata/metadataexif.c | 437 ++++++---- ext/metadata/metadataexif.h | 4 + ext/metadata/metadataiptc.c | 390 ++++++--- ext/metadata/metadataiptc.h | 4 + ext/metadata/metadataparsejpeg.c | 307 ++++++- ext/metadata/metadataparsejpeg.h | 18 +- ext/metadata/metadataparsepng.c | 276 ++++++- ext/metadata/metadataparsepng.h | 16 +- ext/metadata/metadataparseutil.c | 72 ++ ext/metadata/metadataparseutil.h | 8 + ext/metadata/metadatatags.c | 86 +- ext/metadata/metadatatags.h | 16 + ext/metadata/metadatatypes.c | 90 +++ ext/metadata/metadatatypes.h | 22 +- ext/metadata/metadataxmp.c | 753 ++++++++++++------ ext/metadata/metadataxmp.h | 12 +- ext/metadata/test/Makefile | 16 - tests/icles/Makefile.am | 20 +- .../test => tests/icles}/metadata_editor.c | 2 +- .../icles/metadata_editor.glade | 0 25 files changed, 2116 insertions(+), 679 deletions(-) delete mode 100644 ext/metadata/test/Makefile rename {ext/metadata/test => tests/icles}/metadata_editor.c (99%) rename ext/metadata/test/MetadataEditorMain.glade => tests/icles/metadata_editor.glade (100%) diff --git a/ChangeLog b/ChangeLog index c8c6bada2b..cd642e9e4e 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,33 @@ +2008-01-25 Edgard Lima + + * ext/metadata/TODO: + * ext/metadata/gstbasemetadata.c: + * ext/metadata/metadata.c: + * ext/metadata/metadata.h: + * ext/metadata/metadataexif.c: + * ext/metadata/metadataexif.h: + * ext/metadata/metadataiptc.c: + * ext/metadata/metadataiptc.h: + * ext/metadata/metadataparsejpeg.c: + * ext/metadata/metadataparsejpeg.h: + * ext/metadata/metadataparsepng.c: + * ext/metadata/metadataparsepng.h: + * ext/metadata/metadataparseutil.c: + * ext/metadata/metadataparseutil.h: + * ext/metadata/metadatatags.c: + * ext/metadata/metadatatags.h: + * ext/metadata/metadatatypes.c: + * ext/metadata/metadatatypes.h: + * ext/metadata/metadataxmp.c: + * ext/metadata/metadataxmp.h: + * ext/metadata/test/Makefile: + * ext/metadata/test/MetadataEditorMain.glade: + * ext/metadata/test/metadata_editor.c: + * tests/icles/Makefile.am: + * tests/icles/metadata_editor.c: + * tests/icles/metadata_editor.glade: + Add lot of documentation. + 2008-01-25 Zaheer Abbas Merali * sys/dvb/gstdvbsrc.c: diff --git a/ext/metadata/TODO b/ext/metadata/TODO index c6f837f537..5aa151692d 100644 --- a/ext/metadata/TODO +++ b/ext/metadata/TODO @@ -26,3 +26,12 @@ OPEN ISSUES: KNOWN BUGS +1- gst-launch-0.10 filesrc location=BlueSquare.png ! metadatademux ! metadatamux ! pngdec ! ffmpegcolorspace ! freeze ! xvimagesink + +the following pipelines work fine: + +gst-launch-0.10 filesrc location=BlueSquare.png ! metadatamux ! metadatademux ! pngdec ! ffmpegcolorspace ! freeze ! xvimagesink +gst-launch-0.10 filesrc location=BlueSquare.png ! metadatademux ! metadatamux ! queue ! pngdec ! ffmpegcolorspace ! freeze ! xvimagesink +gst-launch-0.10 filesrc location=BlueSquare.png ! ! metadatamux ! pngdec ! ffmpegcolorspace ! freeze ! xvimagesink +gst-launch-0.10 filesrc location=BlueSquare.png ! metadatademux ! ! pngdec ! ffmpegcolorspace ! freeze ! xvimagesink + diff --git a/ext/metadata/gstbasemetadata.c b/ext/metadata/gstbasemetadata.c index 011cd5baca..6d82660746 100644 --- a/ext/metadata/gstbasemetadata.c +++ b/ext/metadata/gstbasemetadata.c @@ -1291,7 +1291,7 @@ gst_base_metadata_init (GstBaseMetadata * filter, GstBaseMetadataClass * gclass) gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad); gst_element_add_pad (GST_ELEMENT (filter), filter->srcpad); - metadataparse_xmp_init (); + metadata_xmp_init (); /* init members */ gst_base_metadata_init_members (filter); @@ -1307,7 +1307,7 @@ gst_base_metadata_dispose (GObject * object) gst_base_metadata_dispose_members (filter); - metadataparse_xmp_dispose (); + metadata_xmp_dispose (); G_OBJECT_CLASS (parent_class)->dispose (object); } diff --git a/ext/metadata/metadata.c b/ext/metadata/metadata.c index fa5409ca6c..3ce891d91f 100644 --- a/ext/metadata/metadata.c +++ b/ext/metadata/metadata.c @@ -41,32 +41,67 @@ * Boston, MA 02111-1307, USA. */ +/* + * SECTION: metadata + * @short_description: This module provides high-level functions to parse files + * + * This module find out the stream type (JPEG or PNG), and provide functions to + * the caller to know where are the metadata chunks and where should it be + * written, as well, it gives the caller the metedata chunk to be written and + * also gets a metadata chunk and wraps it according the strem type + * specification. + * + * + * + * #metadata_init must be called before any other function in this module and + * must be paired with a call to #metadata_dispose. #metadata_parse is used to + * parse the stream (find the metadata chunks and the place it should be + * written to. And #metadata_lazy_update is used by muxers to wrap the metadata + * chunk according the stream type specification. Actually after indentify the + * stream type, the real jog of parsing is delivered to speciallized module. + * See, #metadata[mux/parse][jpeg/png].[c/h] files. + * + * + * + * Last reviewed on 2008-01-24 (0.10.15) + */ + +/* + * includes + */ + #include #include "metadata.h" /* - *static declarations + * static helper functions declaration */ static MetadataParsingReturn -metadata_parse_none (MetaData * meta_data, const guint8 * buf, - guint32 * bufsize, guint8 ** next_start, guint32 * next_size); +metadata_parse_none (MetaData * meta_data, const guint8 * data, + guint32 * data_size, guint8 ** next_start, guint32 * next_size); /* * extern functions implementations */ /* - * Init metadata handle vars. - * This function must becalled before any other function from this module. - * This functoin must not be called twice without call 'metadata_dispose' + * metadata_init: + * @meta_data: [in] metadata handler to be inited + * @options: [in] which types of metadata will be processed (EXIF, IPTC and/or + * XMP) and how it will be handled (DEMUXING or MUXING). Look at #MetaOptions + * to see the available options. + * + * Init metadata handle. + * This function must be called before any other function from this module. + * This function must not be called twice without call to #metadata_dispose * beteween them. - * meta_data [in]: metadata handler to be inited - * parse [in]: pass TRUE for demuxing and FALSE for muxing - * options [in]: which types of metadata will be processed (EXIF, IPTC and/or XMP). - * Look at 'MetaOptions' to see the available options. + * @see_also: #metadata_dispose #metadata_parse + * + * Returns: nothing */ + void metadata_init (MetaData ** meta_data, const MetaOptions options) { @@ -89,7 +124,8 @@ metadata_init (MetaData ** meta_data, const MetaOptions options) if ((*meta_data)->options & META_OPT_DEMUX) { /* when parsing we will probably strip only 3 chunk (exif, iptc and xmp) so we use 4 just in case there is more than one chunk of them. - But this is just for convinience, 'cause the chunk_array incriases dinamically */ + But this is just for convinience, 'cause the chunk_array increases + dinamically */ metadata_chunk_array_init (&(*meta_data)->strip_chunks, 4); /* at most 1 chunk will be injected (JPEG JFIF) */ metadata_chunk_array_init (&(*meta_data)->inject_chunks, 1); @@ -103,9 +139,15 @@ metadata_init (MetaData ** meta_data, const MetaOptions options) } /* - * Dispose medadata handler data. - * Call this function to free any resource allocated by 'metadata_init' + * metadata_dispose: + * @meta_data: [in] metadata handler to be freed + * + * Call this function to free any resource allocated by #metadata_init + * @see_also: #metadata_init + * + * Returns: nothing */ + void metadata_dispose (MetaData ** meta_data) { @@ -151,27 +193,41 @@ metadata_dispose (MetaData ** meta_data) } + /* - * meta_data [in]: metata handle - * buf [in]: data to be parsed - * bufsize [in]: size of data in bytes - * next_offset [out]: number of bytes to jump from the begining of 'buf' in the next call. - * i.e, 0 (zero) mean that in the next call to function "buf" must have the same - * data (probably resized, see 'size') - * size [out]: number of minimal bytes in buf for the next call to this function - * return: - * META_PARSING_ERROR - * META_PARSING_DONE - * META_PARSING_NEED_MORE_DATA (look 'next_offset' and 'size') - * when this function returns 0 you have strip and inject chunks ready to use - * If you change the contents of strip and inject chunks, you have to call - * 'metadata_lazy_update' (this is the case when muxing) - * see MetaData->strip_chunks and MetaData->inject_chunks + * metadata_parse: + * @meta_data: [in] metadata handle + * @buf: [in] data to be parsed + * @buf_size: [in] size of @buf in bytes + * @next_offset: [out] number of bytes to jump from the begining of @buf in + * the next call. i.e, 0 (zero) mean that in the next call this function @buf + * must have the same data (probably resized, see @next_size) + * @next_size: [out] number of minimal bytes in @buf for the next call to this + * function + * + * This function is used to parse the stream step-by-step incrementaly, which + * means, discover the stream type and find the metadata chunks + * (#META_OPT_DEMUX), or point out where metadata chunks should be written + * (#META_OPT_MUX). It is important to notice that there could be both strip + * and inject chunks in both demuxing and muxing modes. + * @see_also: #metadata_init #META_DATA_STRIP_CHUNKS #META_DATA_INJECT_CHUNKS + * + * Returns: + * + * %META_PARSING_ERROR + * + * %META_PARSING_DONE if parse has finished. Now strip and + * inject chunks has been found + * + * %META_PARSING_NEED_MORE_DATA if this function should be + * called again (look @next_offset and @next_size) + * + * */ MetadataParsingReturn metadata_parse (MetaData * meta_data, const guint8 * buf, - guint32 bufsize, guint32 * next_offset, guint32 * next_size) + guint32 buf_size, guint32 * next_offset, guint32 * next_size) { int ret = META_PARSING_DONE; @@ -180,7 +236,7 @@ metadata_parse (MetaData * meta_data, const guint8 * buf, if (meta_data->state == STATE_NULL) { ret = - metadata_parse_none (meta_data, buf, &bufsize, &next_start, next_size); + metadata_parse_none (meta_data, buf, &buf_size, &next_start, next_size); if (ret == META_PARSING_DONE) meta_data->state = STATE_READING; else @@ -192,24 +248,24 @@ metadata_parse (MetaData * meta_data, const guint8 * buf, if (G_LIKELY (meta_data->options & META_OPT_DEMUX)) ret = metadataparse_jpeg_parse (&meta_data->format_data.jpeg_parse, - (guint8 *) buf, &bufsize, meta_data->offset_orig, &next_start, + (guint8 *) buf, &buf_size, meta_data->offset_orig, &next_start, next_size); else ret = metadatamux_jpeg_parse (&meta_data->format_data.jpeg_mux, - (guint8 *) buf, &bufsize, meta_data->offset_orig, &next_start, + (guint8 *) buf, &buf_size, meta_data->offset_orig, &next_start, next_size); break; case IMG_PNG: if (G_LIKELY (meta_data->options & META_OPT_DEMUX)) ret = metadataparse_png_parse (&meta_data->format_data.png_parse, - (guint8 *) buf, &bufsize, meta_data->offset_orig, &next_start, + (guint8 *) buf, &buf_size, meta_data->offset_orig, &next_start, next_size); else ret = metadatamux_png_parse (&meta_data->format_data.png_mux, - (guint8 *) buf, &bufsize, meta_data->offset_orig, &next_start, + (guint8 *) buf, &buf_size, meta_data->offset_orig, &next_start, next_size); break; default: @@ -232,13 +288,24 @@ done: } /* - * This function must be called after 'metadata_parse' and after the element has modified the 'segments'. + * metadata_lazy_update: + * @meta_data: [in] metata handle + * + * This function must be called after #metadata_parse and after the element + * has modified the segments (chunks) + * Data written to #META_DATA_INJECT_CHUNKS will be properly wrapped * This function is really importante in case o muxing 'cause: - * 1- 'cause gives the oportunity to muxers to wrapper new segments with apropriate bytes - * ex: in case of JPEG it can wrap the EXIF chunk (created using tags) with chunk id and chunk size - * 2- 'cause gives the oportunity to muxer to decide if some chunks should still be striped/injected - * ex: if there is no EXIF chunk to be inserted, the muxer decides to not strip JFIF anymore - * see MetaData->strip_chunks and MetaData->inject_chunks + * 1- 'cause gives the oportunity to muxers to wrapper new segments with + * apropriate bytes + * ex: in case of JPEG it can wrap the EXIF chunk (created using tags) with + * chunk id and chunk size + * 2- 'cause gives the oportunity to muxer to decide if some chunks should + * still be striped/injected + * ex: if there is no EXIF chunk to be inserted, the muxer decides to not + * strip JFIF anymore + * @see_also: #metadata_parse #META_DATA_INJECT_CHUNKS + * + * Returns: nothing */ void @@ -266,15 +333,38 @@ metadata_lazy_update (MetaData * meta_data) /* - * static functions implementation + * static helper functions implementation */ /* - * Find out the type of the stream + * metadata_parse_none: + * @meta_data: [in] metata handle + * @buf: [in] data to be parsed + * @buf_size: [in] size of @buf in bytes + * @next_offset: [out] number of bytes to jump from the begining of @buf in + * the next call. i.e, 0 (zero) mean that in the next call this function @buf + * must have the same data (probably resized, see @next_size) + * @next_size: [out] number of minimal bytes in @buf for the next call to this + * function + * + * Parse the fisrt bytes of the stream to identify the stream type + * @see_also: metadata_parse + * + * Returns: + * + * %META_PARSING_ERROR none of the alloed strem types (JPEG, + * PNG) has been identified + * + * %META_PARSING_DONE if the stream type has been identified + * + * %META_PARSING_NEED_MORE_DATA if this function should be + * called again (look @next_offset and @next_size) + * + * */ static MetadataParsingReturn metadata_parse_none (MetaData * meta_data, const guint8 * buf, - guint32 * bufsize, guint8 ** next_start, guint32 * next_size) + guint32 * buf_size, guint8 ** next_start, guint32 * next_size) { int ret = META_PARSING_ERROR; @@ -292,7 +382,7 @@ metadata_parse_none (MetaData * meta_data, const guint8 * buf, */ /* we need at least 3 bytes to see if it is JPEG */ - if (*bufsize < 3) { + if (*buf_size < 3) { *next_size = 3; ret = META_PARSING_NEED_MORE_DATA; goto done; @@ -319,7 +409,7 @@ metadata_parse_none (MetaData * meta_data, const guint8 * buf, } /* we need at least 8 bytes to see if it is PNG */ - if (*bufsize < 8) { + if (*buf_size < 8) { *next_size = 8; ret = META_PARSING_NEED_MORE_DATA; goto done; diff --git a/ext/metadata/metadata.h b/ext/metadata/metadata.h index 2f14471a6a..6e08ae7f04 100644 --- a/ext/metadata/metadata.h +++ b/ext/metadata/metadata.h @@ -44,6 +44,10 @@ #ifndef __METADATA_H__ #define __METADATA_H__ +/* + * includes + */ + #include #include "metadatatypes.h" @@ -54,16 +58,19 @@ G_BEGIN_DECLS -/* *INDENT-OFF* */ +/* + * enum and types + */ +/* *INDENT-OFF* */ typedef enum _tag_MetaOptions { META_OPT_EXIF = (1 << 0), META_OPT_IPTC = (1 << 1), META_OPT_XMP = (1 << 2), META_OPT_PARSE_ONLY = (1 << 3), /* only makes sense with META_OPT_DEMUX */ - META_OPT_DEMUX = (1 << 4), - META_OPT_MUX = (1 << 5), + META_OPT_DEMUX = (1 << 4), /* to operates in demuxing mode */ + META_OPT_MUX = (1 << 5), /* to operates in muxing mode */ META_OPT_ALL = (1 << 6) - 1 } MetaOptions; /* *INDENT-ON* */ @@ -104,18 +111,26 @@ typedef struct _tag_MetaData } MetaData; +/* + * defines and macros + */ + #define META_DATA_IMG_TYPE(p) (p)->img_type #define META_DATA_STRIP_CHUNKS(p) (p)->strip_chunks #define META_DATA_INJECT_CHUNKS(p) (p)->inject_chunks +/* + * external function prototypes + */ + extern void metadata_init (MetaData ** meta_data, const MetaOptions options); extern void metadata_dispose (MetaData ** meta_data); extern MetadataParsingReturn metadata_parse (MetaData * meta_data, const guint8 * buf, - guint32 bufsize, guint32 * next_offset, guint32 * next_size); + guint32 buf_size, guint32 * next_offset, guint32 * next_size); extern void metadata_lazy_update (MetaData * meta_data); diff --git a/ext/metadata/metadataexif.c b/ext/metadata/metadataexif.c index 76dee2a701..39948a6f20 100644 --- a/ext/metadata/metadataexif.c +++ b/ext/metadata/metadataexif.c @@ -41,23 +41,52 @@ * Boston, MA 02111-1307, USA. */ +/* + * SECTION: metadataexif + * @short_description: This module provides functions to extract tags from + * EXIF metadata chunks and create EXIF chunks from metadata tags. + * @see_also: #metadatatags.[c/h] + * + * If libexif isn't available at compilation time, only the whole chunk + * (#METADATA_TAG_MAP_WHOLECHUNK) tags is created. It means that individual + * tags aren't mapped. + * + * Last reviewed on 2008-01-24 (0.10.15) + */ + +/* + * includes + */ + #include "metadataexif.h" #include "metadataparseutil.h" #include "metadatatags.h" +/* + * defines + */ + GST_DEBUG_CATEGORY (gst_metadata_exif_debug); #define GST_CAT_DEFAULT gst_metadata_exif_debug +/* + * Implementation when libexif isn't available at compilation time + */ + #ifndef HAVE_EXIF +/* + * extern functions implementations + */ + + void metadataparse_exif_tag_list_add (GstTagList * taglist, GstTagMergeMode mode, GstAdapter * adapter, MetadataTagMapping mapping) { if (mapping & METADATA_TAG_MAP_WHOLECHUNK) { - GST_LOG - ("EXIF not defined, here I should send just one tag as whole chunk"); + GST_LOG ("EXIF not defined, sending just one tag as whole chunk"); metadataparse_util_tag_list_add_chunk (taglist, mode, GST_TAG_EXIF, adapter); } @@ -73,11 +102,23 @@ metadatamux_exif_create_chunk_from_tag_list (guint8 ** buf, guint32 * size, #else /* ifndef HAVE_EXIF */ +/* + * Implementation when libexif is available at compilation time + */ + +/* + * includes + */ + #include #include #include #include +/* + * enum and types + */ + typedef struct _tag_MEUserData { GstTagList *taglist; @@ -92,10 +133,9 @@ typedef struct _tag_MapIntStr const gchar *str; } MapIntStr; -static void -exif_data_foreach_content_func (ExifContent * content, void *callback_data); - -static void exif_content_foreach_entry_func (ExifEntry * entry, void *); +/* + * defines and static global vars + */ /* *INDENT-OFF* */ static MapIntStr mappedTags[] = { @@ -131,41 +171,47 @@ static MapIntStr mappedTags[] = { }; /* *INDENT-ON* */ -static const gchar * -metadataparse_exif_get_tag_from_exif (ExifTag exif, GType * type) -{ - int i = 0; +/* + * static helper functions declaration + */ - while (mappedTags[i].exif) { - if (exif == mappedTags[i].exif) { - *type = gst_tag_get_type (mappedTags[i].str); - break; - } - ++i; - } - - return mappedTags[i].str; - -} +static const gchar *metadataparse_exif_get_tag_from_exif (ExifTag exif, + GType * type); static ExifTag -metadataparse_exif_get_exif_from_tag (const gchar * tag, GType * type, - ExifIfd * ifd) -{ - int i = 0; +metadatamux_exif_get_exif_from_tag (const gchar * tag, GType * type, + ExifIfd * ifd); - while (mappedTags[i].exif) { - if (0 == strcmp (mappedTags[i].str, tag)) { - *type = gst_tag_get_type (tag); - *ifd = mappedTags[i].ifd; - break; - } - ++i; - } +static void +metadataparse_exif_data_foreach_content_func (ExifContent * content, + void *callback_data); - return mappedTags[i].exif; +static void +metadataparse_exif_content_foreach_entry_func (ExifEntry * entry, + void *user_data); -} +static void +metadatamux_exif_for_each_tag_in_list (const GstTagList * list, + const gchar * tag, gpointer user_data); + +/* + * extern functions implementations + */ + +/* + * metadataparse_exif_tag_list_add: + * @taglist: tag list in which extracted tags will be added + * @mode: tag list merge mode + * @adapter: contains the EXIF metadata chunk + * @mapping: if is to extract individual tags and/or the whole chunk. + * + * This function gets a EXIF chunk (@adapter) and extract tags from it + * and the add to @taglist. + * Note: The EXIF chunk (@adapetr) must NOT be wrapped by any bytes specific + * to any file format + * + * Returns: nothing + */ void metadataparse_exif_tag_list_add (GstTagList * taglist, GstTagMergeMode mode, @@ -195,8 +241,8 @@ metadataparse_exif_tag_list_add (GstTagList * taglist, GstTagMergeMode mode, goto done; } - exif_data_foreach_content (exif, exif_data_foreach_content_func, - (void *) &user_data); + exif_data_foreach_content (exif, + metadataparse_exif_data_foreach_content_func, (void *) &user_data); done: @@ -207,44 +253,178 @@ done: } +/* + * metadatamux_exif_create_chunk_from_tag_list: + * @buf: buffer that will have the created EXIF chunk + * @size: size of the buffer that will be created + * @taglist: list of tags to be added to EXIF chunk + * + * Get tags from @taglist, create a EXIF chunk based on it and save to @buf. + * Note: The EXIF chunk is NOT wrapped by any bytes specific to any file format + * + * Returns: nothing + */ + +void +metadatamux_exif_create_chunk_from_tag_list (guint8 ** buf, guint32 * size, + const GstTagList * taglist) +{ + ExifData *ed = NULL; + GstBuffer *exif_chunk = NULL; + const GValue *val = NULL; + + if (!(buf && size)) + goto done; + if (*buf) { + g_free (*buf); + *buf = NULL; + } + *size = 0; + + val = gst_tag_list_get_value_index (taglist, GST_TAG_EXIF, 0); + if (val) { + exif_chunk = gst_value_get_buffer (val); + if (exif_chunk) { + ed = exif_data_new_from_data (GST_BUFFER_DATA (exif_chunk), + GST_BUFFER_SIZE (exif_chunk)); + } + } + + if (!ed) { + ed = exif_data_new (); + exif_data_set_data_type (ed, EXIF_DATA_TYPE_COMPRESSED); + exif_data_fix (ed); + } + + gst_tag_list_foreach (taglist, metadatamux_exif_for_each_tag_in_list, ed); + + exif_data_save_data (ed, buf, size); + + +done: + + if (ed) + exif_data_unref (ed); + + return; +} + + +/* + * static helper functions implementation + */ + +/* + * metadataparse_exif_get_tag_from_exif: + * @exif: EXIF tag to look for + * @type: the type of the GStreamer tag mapped to @exif + * + * This returns the GStreamer tag mapped to an EXIF tag. + * + * Returns: + * + * The GStreamer tag mapped to the @exif + * + * %NULL if there is no mapped GST tag for @exif + * + * + */ + +static const gchar * +metadataparse_exif_get_tag_from_exif (ExifTag exif, GType * type) +{ + int i = 0; + + while (mappedTags[i].exif) { + if (exif == mappedTags[i].exif) { + *type = gst_tag_get_type (mappedTags[i].str); + break; + } + ++i; + } + + return mappedTags[i].str; + +} + +/* + * metadatamux_exif_get_exif_from_tag: + * @tag: GST tag to look for + * @type: the type of the GStreamer @tag + * @ifd: the place into EXIF chunk @exif belongs to. + * + * This returns thet EXIF tag mapped to an GStreamer @tag. + * + * Returns: + * + * The EXIF tag mapped to the GST @tag + * + * 0 if there is no mapped EXIF tag for GST @tag + * + * + */ + +static ExifTag +metadatamux_exif_get_exif_from_tag (const gchar * tag, GType * type, + ExifIfd * ifd) +{ + int i = 0; + + while (mappedTags[i].exif) { + if (0 == strcmp (mappedTags[i].str, tag)) { + *type = gst_tag_get_type (tag); + *ifd = mappedTags[i].ifd; + break; + } + ++i; + } + + return mappedTags[i].exif; + +} + +/* + * metadataparse_exif_data_foreach_content_func: + * @content: EXIF structure from libexif containg a IFD + * @user_data: pointer to #MEUserData + * + * This function designed to be called for each EXIF IFD in a EXIF chunk. This + * function gets calls another function for each tag into @content. Then all + * tags into a EXIF chunk can be extracted to a tag list in @user_data. + * @see_also: #metadataparse_exif_tag_list_add + * #metadataparse_exif_content_foreach_entry_func + * + * Returns: nothing + */ + static void -exif_data_foreach_content_func (ExifContent * content, void *user_data) +metadataparse_exif_data_foreach_content_func (ExifContent * content, + void *user_data) { ExifIfd ifd = exif_content_get_ifd (content); GST_LOG ("\n Content %p: %s (ifd=%d)", content, exif_ifd_get_name (ifd), ifd); - exif_content_foreach_entry (content, exif_content_foreach_entry_func, - user_data); + exif_content_foreach_entry (content, + metadataparse_exif_content_foreach_entry_func, user_data); } -#if 0 -static gboolean -exif_fast_mdc (glong n, glong d, gulong * m) -{ - gboolean ret = FALSE; - - static const int a[] = - { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 39, 41, 43, 47, 49, 53, 0 }; - int i = 0; - - *m = 1; - - while (a[i] <= n && a[i] <= d) { - while ((n % a[i] == 0) && (d % a[i]) == 0) { - *m *= a[i]; - ret = TRUE; - } - ++i; - } - - return ret; - -} -#endif +/* + * metadataparse_exif_content_foreach_entry_func: + * @entry: EXIF structure from libexif having a EXIF tag + * @user_data: pointer to #MEUserData + * + * This function designed to be called for each EXIF tag in a EXIF IFD. This + * function gets the EXIF tag from @entry and then add to the tag list + * in @user_data by using a merge mode also specified in @user_data + * @see_also: #metadataparse_exif_data_foreach_content_func + * + * Returns: nothing + */ static void -exif_content_foreach_entry_func (ExifEntry * entry, void *user_data) +metadataparse_exif_content_foreach_entry_func (ExifEntry * entry, + void *user_data) { char buf[2048]; MEUserData *meudata = (MEUserData *) user_data; @@ -390,76 +570,22 @@ done: } /* + * metadatamux_exif_for_each_tag_in_list: + * @list: GStreamer tag list from which @tag belongs to + * @tag: GStreamer tag to be added to the EXIF chunk + * @user_data: pointer to #ExifData in which the tag will be added * + * This function designed to be called for each tag in GST tag list. This + * function adds get the tag value from tag @list and then add it to the EXIF + * chunk by using #ExifData and related functions from libexif + * @see_also: #metadatamux_exif_create_chunk_from_tag_list + * + * Returns: nothing */ -static ExifRational -float_to_rational (gfloat f) -{ - ExifRational r; - int i = 6; /* precision */ - - r.denominator = 1; - - while (i--) { - if (f == floorf (f)) { - break; - } - f *= 10.0f; - r.denominator *= 10; - } - - r.numerator = f; - - if (!(r.numerator & 0x1 || r.denominator & 0x1)) { - /* divide both by 2 */ - r.numerator >>= 1; - r.denominator >>= 1; - } - if (r.numerator % 5 == 0 && r.denominator % 5 == 0) { - r.numerator /= 5; - r.denominator /= 5; - } - - return r; - -} - -static ExifSRational -float_to_srational (gfloat f) -{ - ExifSRational sr; - int i = 6; /* precision */ - - sr.denominator = 1; - - while (i--) { - if (f == floorf (f)) { - break; - } - f *= 10.0f; - sr.denominator *= 10; - } - - sr.numerator = f; - - if (!(sr.numerator & 0x1 || sr.denominator & 0x1)) { - /* divide both by 2 */ - sr.numerator >>= 1; - sr.denominator >>= 1; - } - if (sr.numerator % 5 == 0 && sr.denominator % 5 == 0) { - sr.numerator /= 5; - sr.denominator /= 5; - } - - return sr; - -} - static void -metadataexif_for_each_tag_in_list (const GstTagList * list, const gchar * tag, - gpointer user_data) +metadatamux_exif_for_each_tag_in_list (const GstTagList * list, + const gchar * tag, gpointer user_data) { ExifData *ed = (ExifData *) user_data; ExifTag exif_tag; @@ -468,7 +594,7 @@ metadataexif_for_each_tag_in_list (const GstTagList * list, const gchar * tag, ExifIfd ifd; const ExifByteOrder byte_order = exif_data_get_byte_order (ed); - exif_tag = metadataparse_exif_get_exif_from_tag (tag, &type, &ifd); + exif_tag = metadatamux_exif_get_exif_from_tag (tag, &type, &ifd); if (!exif_tag) goto done; @@ -505,7 +631,9 @@ metadataexif_for_each_tag_in_list (const GstTagList * list, const gchar * tag, entry->tag == EXIF_TAG_Y_RESOLUTION) { ExifEntry *unit_entry = NULL; - if ((unit_entry = exif_data_get_entry (ed, EXIF_TAG_RESOLUTION_UNIT))) { + unit_entry = exif_data_get_entry (ed, EXIF_TAG_RESOLUTION_UNIT); + + if (unit_entry) { ExifShort vsh = exif_get_short (unit_entry->data, byte_order); if (vsh != 2) /* inches */ @@ -568,48 +696,5 @@ done: } -void -metadatamux_exif_create_chunk_from_tag_list (guint8 ** buf, guint32 * size, - const GstTagList * taglist) -{ - ExifData *ed = NULL; - GstBuffer *exif_chunk = NULL; - const GValue *val = NULL; - - if (!(buf && size)) - goto done; - if (*buf) { - g_free (*buf); - *buf = NULL; - } - *size = 0; - - val = gst_tag_list_get_value_index (taglist, GST_TAG_EXIF, 0); - if (val) { - exif_chunk = gst_value_get_buffer (val); - if (exif_chunk) { - ed = exif_data_new_from_data (GST_BUFFER_DATA (exif_chunk), - GST_BUFFER_SIZE (exif_chunk)); - } - } - - if (!ed) { - ed = exif_data_new (); - exif_data_set_data_type (ed, EXIF_DATA_TYPE_COMPRESSED); - exif_data_fix (ed); - } - - gst_tag_list_foreach (taglist, metadataexif_for_each_tag_in_list, ed); - - exif_data_save_data (ed, buf, size); - - -done: - - if (ed) - exif_data_unref (ed); - - return; -} #endif /* else (ifndef HAVE_EXIF) */ diff --git a/ext/metadata/metadataexif.h b/ext/metadata/metadataexif.h index 71cd6511ea..8f1d8a21fc 100644 --- a/ext/metadata/metadataexif.h +++ b/ext/metadata/metadataexif.h @@ -50,6 +50,10 @@ G_BEGIN_DECLS +/* + * external function prototypes + */ + extern void metadataparse_exif_tag_list_add (GstTagList * taglist, GstTagMergeMode mode, GstAdapter * adapter, MetadataTagMapping mapping); diff --git a/ext/metadata/metadataiptc.c b/ext/metadata/metadataiptc.c index 0b040ede5f..3138837201 100644 --- a/ext/metadata/metadataiptc.c +++ b/ext/metadata/metadataiptc.c @@ -41,23 +41,51 @@ * Boston, MA 02111-1307, USA. */ +/* + * SECTION: metadataiptc + * @short_description: This module provides functions to extract tags from + * IPTC metadata chunks and create IPTC chunks from metadata tags. + * @see_also: #metadatatags.[c/h] + * + * If libiptcdata isn't available at compilation time, only the whole chunk + * (#METADATA_TAG_MAP_WHOLECHUNK) tags is created. It means that individual + * tags aren't mapped. + * + * Last reviewed on 2008-01-24 (0.10.15) + */ + +/* + * includes + */ + #include "metadataiptc.h" #include "metadataparseutil.h" #include "metadatatags.h" +/* + * defines + */ + GST_DEBUG_CATEGORY (gst_metadata_iptc_debug); #define GST_CAT_DEFAULT gst_metadata_iptc_debug +/* + * Implementation when libiptcdata isn't available at compilation time + */ + #ifndef HAVE_IPTC +/* + * extern functions implementations + */ + void metadataparse_iptc_tag_list_add (GstTagList * taglist, GstTagMergeMode mode, GstAdapter * adapter, MetadataTagMapping mapping) { if (mapping & METADATA_TAG_MAP_WHOLECHUNK) { - GST_LOG - ("IPTC not defined, here I should send just one tag as whole chunk"); + GST_LOG ("IPTC not defined, sending just one tag as whole chunk"); metadataparse_util_tag_list_add_chunk (taglist, mode, GST_TAG_IPTC, adapter); } @@ -74,11 +102,23 @@ metadatamux_iptc_create_chunk_from_tag_list (guint8 ** buf, guint32 * size, #else /* ifndef HAVE_IPTC */ +/* + * Implementation when libiptcdata is available at compilation time + */ + +/* + * includes + */ + #include #include #include #include +/* + * enum and types + */ + typedef struct _tag_MEUserData { GstTagList *taglist; @@ -92,56 +132,62 @@ typedef struct _tag_MapIntStr const gchar *str; } MapIntStr; -static void -iptc_data_foreach_dataset_func (IptcDataSet * dataset, void *user_data); +/* + * defines and static global vars + */ /* *INDENT-OFF* */ static MapIntStr mappedTags[] = { - {IPTC_RECORD_APP_2, IPTC_TAG_OBJECT_NAME, /*ASCII*/ GST_TAG_TITLE /*STRING*/}, - {IPTC_RECORD_APP_2, IPTC_TAG_BYLINE, /*ASCII*/ GST_TAG_COMPOSER /*STRING*/}, - {IPTC_RECORD_APP_2, IPTC_TAG_CAPTION, /*ASCII*/ GST_TAG_DESCRIPTION /*STRING*/}, - {IPTC_RECORD_APP_2, IPTC_TAG_COPYRIGHT_NOTICE, /*ASCII*/ GST_TAG_COPYRIGHT /*STRING*/}, + {IPTC_RECORD_APP_2, IPTC_TAG_OBJECT_NAME, /*ASCII*/ + GST_TAG_TITLE /*STRING*/}, + {IPTC_RECORD_APP_2, IPTC_TAG_BYLINE, /*ASCII*/ + GST_TAG_COMPOSER /*STRING*/}, + {IPTC_RECORD_APP_2, IPTC_TAG_CAPTION, /*ASCII*/ + GST_TAG_DESCRIPTION /*STRING*/}, + {IPTC_RECORD_APP_2, IPTC_TAG_COPYRIGHT_NOTICE, /*ASCII*/ + GST_TAG_COPYRIGHT /*STRING*/}, {0, 0, NULL} }; /* *INDENT-ON* */ -static const gchar * -metadataparse_iptc_get_tag_from_iptc (IptcTag iptc, GType * type, - IptcRecord * record) -{ - int i = 0; +/* + * static helper functions declaration + */ - while (mappedTags[i].iptc) { - if (iptc == mappedTags[i].iptc) { - *type = gst_tag_get_type (mappedTags[i].str); - *record = mappedTags[i].record; - break; - } - ++i; - } +static const gchar *metadataparse_iptc_get_tag_from_iptc (IptcTag iptc, + GType * type, IptcRecord * record); - return mappedTags[i].str; - -} static IptcTag -metadataparse_iptc_get_iptc_from_tag (const gchar * tag, GType * type, - IptcRecord * record) -{ - int i = 0; +metadatamux_iptc_get_iptc_from_tag (const gchar * tag, GType * type, + IptcRecord * record); - while (mappedTags[i].iptc) { - if (0 == strcmp (mappedTags[i].str, tag)) { - *type = gst_tag_get_type (tag); - *record = mappedTags[i].record; - break; - } - ++i; - } +static void +metadataparse_iptc_data_foreach_dataset_func (IptcDataSet * dataset, + void *user_data); - return mappedTags[i].iptc; +static void +metadatamux_iptc_for_each_tag_in_list (const GstTagList * list, + const gchar * tag, gpointer user_data); -} +/* + * extern functions implementations + */ + +/* + * metadataparse_iptc_tag_list_add: + * @taglist: tag list in which extracted tags will be added + * @mode: tag list merge mode + * @adapter: contains the IPTC metadata chunk + * @mapping: if is to extract individual tags and/or the whole chunk. + * + * This function gets a IPTC chunk (@adapter) and extract tags form it + * and then add to @taglist. + * Note: The IPTC chunk (@adapetr) must NOT be wrapped by any bytes specific + * to any file format + * + * Returns: nothing + */ void metadataparse_iptc_tag_list_add (GstTagList * taglist, GstTagMergeMode mode, @@ -171,8 +217,8 @@ metadataparse_iptc_tag_list_add (GstTagList * taglist, GstTagMergeMode mode, goto done; } - iptc_data_foreach_dataset (iptc, iptc_data_foreach_dataset_func, - (void *) &user_data); + iptc_data_foreach_dataset (iptc, + metadataparse_iptc_data_foreach_dataset_func, (void *) &user_data); done: @@ -183,79 +229,17 @@ done: } -static void -iptc_data_foreach_dataset_func (IptcDataSet * dataset, void *user_data) -{ - - char buf[1024]; - MEUserData *meudata = (MEUserData *) user_data; - GType type; - IptcRecord record; - const gchar *tag = - metadataparse_iptc_get_tag_from_iptc (dataset->tag, &type, &record); - const gchar *value = iptc_dataset_get_as_str (dataset, buf, 1024); - - if (!tag) - goto done; - - gst_tag_list_add (meudata->taglist, meudata->mode, tag, value, NULL); - -done: - - GST_LOG ("name -> %s", iptc_tag_get_name (dataset->record, dataset->tag)); - GST_LOG ("title -> %s", iptc_tag_get_title (dataset->record, dataset->tag)); - GST_LOG ("description -> %s", iptc_tag_get_description (dataset->record, - dataset->tag)); - GST_LOG ("value = %s", value); - GST_LOG ("record = %d", dataset->record); - - return; - -} - - -static void -metadataiptc_for_each_tag_in_list (const GstTagList * list, const gchar * tag, - gpointer user_data) -{ - IptcData *iptc = (IptcData *) user_data; - IptcTag iptc_tag; - IptcRecord record; - GType type; - IptcDataSet *dataset = NULL; - gboolean new_dataset = FALSE; - gchar *tag_value = NULL; - - iptc_tag = metadataparse_iptc_get_iptc_from_tag (tag, &type, &record); - - if (!iptc_tag) - goto done; - - dataset = iptc_data_get_dataset (iptc, record, iptc_tag); - - if (!dataset) { - dataset = iptc_dataset_new (); - new_dataset = TRUE; - } - - iptc_dataset_set_tag (dataset, record, iptc_tag); - - if (gst_tag_list_get_string (list, tag, &tag_value)) { - iptc_dataset_set_data (dataset, tag_value, strlen (tag_value), - IPTC_DONT_VALIDATE); - g_free (tag_value); - tag_value = NULL; - } - - - if (new_dataset) - iptc_data_add_dataset (iptc, dataset); - -done: - - if (dataset) - iptc_dataset_unref (dataset); -} +/* + * metadatamux_iptc_create_chunk_from_tag_list: + * @buf: buffer that will have the created IPTC chunk + * @size: size of the buffer that will be created + * @taglist: list of tags to be added to IPTC chunk + * + * Get tags from @taglist, create a IPTC chunk based on it and save to @buf. + * Note: The IPTC chunk is NOT wrapped by any bytes specific to any file format + * + * Returns: nothing + */ void metadatamux_iptc_create_chunk_from_tag_list (guint8 ** buf, guint32 * size, @@ -286,7 +270,7 @@ metadatamux_iptc_create_chunk_from_tag_list (guint8 ** buf, guint32 * size, iptc = iptc_data_new (); } - gst_tag_list_foreach (taglist, metadataiptc_for_each_tag_in_list, iptc); + gst_tag_list_foreach (taglist, metadatamux_iptc_for_each_tag_in_list, iptc); iptc_data_save (iptc, buf, size); @@ -299,4 +283,182 @@ done: return; } +/* + * static helper functions implementation + */ + +/* + * metadataparse_iptc_get_tag_from_iptc: + * @iptc: IPTC tag to look for + * @type: the type of the GStreamer tag mapped to @iptc + * @record: the place into IPTC chunk @iptc belongs to. + * + * This returns the GStreamer tag mapped to an IPTC tag. + * + * Returns: + * + * The GStreamer tag mapped to the @iptc + * + * %NULL if there is no mapped GST tag for @iptc + * + * + */ + +static const gchar * +metadataparse_iptc_get_tag_from_iptc (IptcTag iptc, GType * type, + IptcRecord * record) +{ + int i = 0; + + while (mappedTags[i].iptc) { + if (iptc == mappedTags[i].iptc) { + *type = gst_tag_get_type (mappedTags[i].str); + *record = mappedTags[i].record; + break; + } + ++i; + } + + return mappedTags[i].str; + +} + +/* + * metadatamux_iptc_get_iptc_from_tag: + * @tag: GST tag to look for + * @type: the type of the GStreamer @tag + * @record: the place into IPTC chunk @iptc belongs to. + * + * This returns thet IPTC tag mapped to an GStreamer @tag. + * + * Returns: + * + * The IPTC tag mapped to the GST @tag + * + * 0 if there is no mapped IPTC tag for GST @tag + * + * + */ + +static IptcTag +metadatamux_iptc_get_iptc_from_tag (const gchar * tag, GType * type, + IptcRecord * record) +{ + int i = 0; + + while (mappedTags[i].iptc) { + if (0 == strcmp (mappedTags[i].str, tag)) { + *type = gst_tag_get_type (tag); + *record = mappedTags[i].record; + break; + } + ++i; + } + + return mappedTags[i].iptc; + +} + +/* + * metadataparse_iptc_data_foreach_dataset_func: + * @dataset: IPTC structure from libiptcdata having IPTC tag + * @user_data: pointer to #MEUserData + * + * This function designed to be called for each IPTC tag in a IPTC chunk. This + * function gets the IPTC tag from @dataset and then add to the tag list + * in @user_data by using a merge mode also specified in @user_data + * @see_also: #metadataparse_iptc_tag_list_add + * + * Returns: nothing + */ + +static void +metadataparse_iptc_data_foreach_dataset_func (IptcDataSet * dataset, + void *user_data) +{ + + char buf[1024]; + MEUserData *meudata = (MEUserData *) user_data; + GType type; + IptcRecord record; + const gchar *tag = + metadataparse_iptc_get_tag_from_iptc (dataset->tag, &type, &record); + const gchar *value = iptc_dataset_get_as_str (dataset, buf, 1024); + + if (!tag) + goto done; + + gst_tag_list_add (meudata->taglist, meudata->mode, tag, value, NULL); + +done: + + GST_LOG ("name -> %s", iptc_tag_get_name (dataset->record, dataset->tag)); + GST_LOG ("title -> %s", iptc_tag_get_title (dataset->record, dataset->tag)); + GST_LOG ("description -> %s", iptc_tag_get_description (dataset->record, + dataset->tag)); + GST_LOG ("value = %s", value); + GST_LOG ("record = %d", dataset->record); + + return; + +} + +/* + * metadatamux_iptc_for_each_tag_in_list: + * @list: GStreamer tag list from which @tag belongs to + * @tag: GStreamer tag to be added to the IPTC chunk + * @user_data: pointer to #IptcData in which the tag will be added + * + * This function designed to be called for each tag in GST tag list. This + * function adds get the tag value from tag @list and then add it to the IPTC + * chunk by using #IptcData and related functions from libiptcdata + * @see_also: #metadatamux_iptc_create_chunk_from_tag_list + * + * Returns: nothing + */ + +static void +metadatamux_iptc_for_each_tag_in_list (const GstTagList * list, + const gchar * tag, gpointer user_data) +{ + IptcData *iptc = (IptcData *) user_data; + IptcTag iptc_tag; + IptcRecord record; + GType type; + IptcDataSet *dataset = NULL; + gboolean new_dataset = FALSE; + gchar *tag_value = NULL; + + iptc_tag = metadatamux_iptc_get_iptc_from_tag (tag, &type, &record); + + if (!iptc_tag) + goto done; + + dataset = iptc_data_get_dataset (iptc, record, iptc_tag); + + if (!dataset) { + dataset = iptc_dataset_new (); + new_dataset = TRUE; + } + + iptc_dataset_set_tag (dataset, record, iptc_tag); + + if (gst_tag_list_get_string (list, tag, &tag_value)) { + iptc_dataset_set_data (dataset, tag_value, strlen (tag_value), + IPTC_DONT_VALIDATE); + g_free (tag_value); + tag_value = NULL; + } + + + if (new_dataset) + iptc_data_add_dataset (iptc, dataset); + +done: + + if (dataset) + iptc_dataset_unref (dataset); +} + + #endif /* else (ifndef HAVE_IPTC) */ diff --git a/ext/metadata/metadataiptc.h b/ext/metadata/metadataiptc.h index 0fa0a4d7e7..e13bb0ca77 100644 --- a/ext/metadata/metadataiptc.h +++ b/ext/metadata/metadataiptc.h @@ -50,6 +50,10 @@ G_BEGIN_DECLS +/* + * external function prototypes + */ + extern void metadataparse_iptc_tag_list_add (GstTagList * taglist, GstTagMergeMode mode, GstAdapter * adapter, MetadataTagMapping mapping); diff --git a/ext/metadata/metadataparsejpeg.c b/ext/metadata/metadataparsejpeg.c index 3c2719da5e..ce6a161c1a 100644 --- a/ext/metadata/metadataparsejpeg.c +++ b/ext/metadata/metadataparsejpeg.c @@ -41,14 +41,62 @@ * Boston, MA 02111-1307, USA. */ -#include "metadataparsejpeg.h" +/* + * SECTION: metadataparsejpeg + * @short_description: This module provides functions to parse JPEG files + * + * This module parses a JPEG stream finding metadata chunks, and marking them + * to be removed from the stream and saving them in a adapter. + * + * + * + * #metadataparse_jpeg_init must be called before any other function in this + * module and must be paired with a call to #metadataparse_jpeg_dispose. + * #metadataparse_jpeg_parse is used to parse the stream (find the metadata + * chunks and the place it should be written to. + * #metadataparse_jpeg_lazy_update do nothing. + * + * + * This module tries to find metadata chunk until it reaches the "start of scan + * image". So if the metadata chunk, which could be EXIF, XMP or IPTC (inside + * Photoshop), is after the "start of scan image" it will not be found. This is + * 'cause of performance reason and 'cause we believe that files with metadata + * chunk after the "scan of image" chunk are very bad practice, so we don't + * worry about them. + * + * + * If it is working in non-parse_only mode, and the first chunk is a EXIF + * instead of a JFIF chunk, the EXIF chunk will be marked for removal and a new + * JFIF chunk will be create and marked to be injected as the first chunk. + * + * + * + * Last reviewed on 2008-01-24 (0.10.15) + */ + +/* + * includes + */ #include +#include "metadataparsejpeg.h" + #ifdef HAVE_IPTC #include #endif +/* + * defines and macros + */ + +/* returns the current byte, advance to the next one and decrease the size */ +#define READ(buf, size) ( (size)--, *((buf)++) ) + +/* + * static helper functions declaration + */ + static MetadataParsingReturn metadataparse_jpeg_reading (JpegParseData * jpeg_data, guint8 ** buf, guint32 * bufsize, const guint32 offset, const guint8 * step_buf, @@ -72,13 +120,30 @@ static MetadataParsingReturn metadataparse_jpeg_jump (JpegParseData * jpeg_data, guint8 ** buf, guint32 * bufsize, guint8 ** next_start, guint32 * next_size); -#define READ(buf, size) ( (size)--, *((buf)++) ) +/* + * extern functions implementations + */ -void -metadataparse_jpeg_lazy_update (JpegParseData * jpeg_data) -{ - /* nothing to do */ -} +/* + * metadataparse_jpeg_init: + * @jpeg_data: [in] jpeg data handler to be inited + * @exif_adpt: where to create/write an adapter to hold the EXIF chunk found + * @iptc_adpt: where to create/write an adapter to hold the IPTC chunk found + * @xmp_adpt: where to create/write an adapter to hold the XMP chunk found + * @strip_chunks: Array of chunks (offset and size) marked for removal + * @inject_chunks: Array of chunks (offset, data, size) marked for injection + * @parse_only: TRUE if it should only find the chunks and write then to the + * adapter (@exif_adpt, @iptc_adpt, @xmp_adpt). Or FALSE if should also put + * them on @strip_chunks. + * + * Init jpeg data handle. + * This function must be called before any other function from this module. + * This function must not be called twice without call to + * #metadataparse_jpeg_dispose beteween them. + * @see_also: #metadataparse_jpeg_dispose #metadataparse_jpeg_parse + * + * Returns: nothing + */ void metadataparse_jpeg_init (JpegParseData * jpeg_data, GstAdapter ** exif_adpt, @@ -100,6 +165,17 @@ metadataparse_jpeg_init (JpegParseData * jpeg_data, GstAdapter ** exif_adpt, } +/* + * metadataparse_jpeg_dispose: + * @jpeg_data: [in] jpeg data handler to be freed + * + * Call this function to free any resource allocated by + * #metadataparse_jpeg_init + * @see_also: #metadataparse_jpeg_init + * + * Returns: nothing + */ + void metadataparse_jpeg_dispose (JpegParseData * jpeg_data) { @@ -108,6 +184,42 @@ metadataparse_jpeg_dispose (JpegParseData * jpeg_data) jpeg_data->xmp_adapter = NULL; } +/* + * metadata_parse: + * @jpeg_data: [in] jpeg data handle + * @buf: [in] data to be parsed + * @bufsize: [in] size of @buf in bytes + * @offset: is the offset where @buf starts from the beginnig of the whole + * stream + * @next_start: is a pointer after @buf which indicates where @buf should start + * on the next call to this function. It means, that after returning, this + * function has consumed *@next_start - @buf bytes. Which also means + * that @offset should also be incremanted by (*@next_start - @buf) for the + * next time. + * @next_size: [out] number of minimal bytes in @buf for the next call to this + * function + * + * This function is used to parse a JPEG stream step-by-step incrementally. + * Basically this function works like a state machine, that will run in a loop + * while there is still bytes in @buf to be read or it has finished parsing. + * If the it hasn't parsed yet and there is no more data in @buf, then the + * current state is saved and a indication will be make about the buffer to + * be passed by the caller function. + * @see_also: #metadataparse_jpeg_init + * + * Returns: + * + * %META_PARSING_ERROR + * + * %META_PARSING_DONE if parse has finished. Now strip and + * inject chunks has been found + * + * %META_PARSING_NEED_MORE_DATA if this function should be + * called again (look @next_start and @next_size) + * + * + */ + MetadataParsingReturn metadataparse_jpeg_parse (JpegParseData * jpeg_data, guint8 * buf, guint32 * bufsize, const guint32 offset, guint8 ** next_start, @@ -118,10 +230,19 @@ metadataparse_jpeg_parse (JpegParseData * jpeg_data, guint8 * buf, guint8 mark[2] = { 0x00, 0x00 }; const guint8 *step_buf = buf; + /* step_buf holds where buf starts. this const value will be passed to + the nested parsing function, so those function knows how far they from + the initial buffer. This is not related to the beginning of the whole + stream, it is just related to the buf passed in this step to this + function */ + *next_start = buf; if (jpeg_data->state == JPEG_PARSE_NULL) { + /* only the first time this function is called it will verify the stream + type to be sure it is a JPEG */ + if (*bufsize < 2) { *next_size = (buf - *next_start) + 2; ret = META_PARSING_NEED_MORE_DATA; @@ -184,6 +305,68 @@ done: } +/* + * metadataparse_jpeg_lazy_update: + * @jpeg_data: [in] jpeg data handle + * + * This function do nothing + * @see_also: metadata_lazy_update + * + * Returns: nothing + */ + +void +metadataparse_jpeg_lazy_update (JpegParseData * jpeg_data) +{ + /* nothing to do */ +} + +/* + * static helper functions implementation + */ + +/* + * metadataparse_jpeg_reading: + * @jpeg_data: [in] jpeg data handle + * @buf: [in] data to be parsed. @buf will increment during the parsing step. + * So it will hold the next byte to be read inside a parsing function or on + * the next nested parsing function. And so, @bufsize will decrement. + * @bufsize: [in] size of @buf in bytes. This value will decrement during the + * parsing for the same reason that @buf will advance. + * @offset: is the offset where @step_buf starts from the beginnig of the + * stream + * @step_buf: holds the pointer to the buffer passed to + * #metadataparse_jpeg_parse. It means that any point inside this function + * the offset (related to the beginning of the whole stream) after the last + * byte read so far is "(*buf - step_buf) + offset" + * @next_start: is a pointer after @step_buf which indicates where the next + * call to #metadataparse_jpeg_parse should start on the next call to this + * function. It means, that after return, this function has + * consumed *@next_start - @buf bytes. Which also means that @offset should + * also be incremanted by (*@next_start - @buf) for the next time. + * @next_size: [out] number of minimal bytes in @buf for the next call to this + * function + * + * This function is used to parse a JPEG stream step-by-step incrementally. + * If this function finds a EXIF, IPTC or XMP chunk (or a chunk that should be + * jumped), then it changes the state of the parsing process so that the + * remaing parsing can be done by another more specialized function. + * @see_also: #metadataparse_jpeg_init #metadataparse_jpeg_exif + * #metadataparse_jpeg_iptc #metadataparse_jpeg_xmp #metadataparse_jpeg_jump + * + * Returns: + * + * %META_PARSING_ERROR + * + * %META_PARSING_DONE if parse has finished. Now strip and + * inject chunks has been found. Or some chunk has been found and should be + * held or jumped. + * + * %META_PARSING_NEED_MORE_DATA if this function should be + * called again (look @next_start and @next_size) + * + * + */ /* look for markers */ static MetadataParsingReturn @@ -218,7 +401,8 @@ metadataparse_jpeg_reading (JpegParseData * jpeg_data, guint8 ** buf, ret = META_PARSING_DONE; jpeg_data->state = JPEG_PARSE_DONE; goto done; - } else if (mark[1] == 0xDA) { /* start of scan, lets not look behinf of this */ + } else if (mark[1] == 0xDA) { + /* start of scan image, lets not look behind of this */ ret = META_PARSING_DONE; jpeg_data->state = JPEG_PARSE_DONE; goto done; @@ -264,7 +448,9 @@ metadataparse_jpeg_reading (JpegParseData * jpeg_data, guint8 ** buf, if (!jpeg_data->parse_only) { memset (&chunk, 0x00, sizeof (MetadataChunk)); - chunk.offset_orig = (*buf - step_buf) + offset - 4; /* maker + size */ + + chunk.offset_orig = (*buf - step_buf) + offset - 4; /* 4 == maker + size */ + chunk.size = chunk_size + 2; /* chunk size plus app marker */ chunk.type = MD_CHUNK_EXIF; @@ -276,15 +462,15 @@ metadataparse_jpeg_reading (JpegParseData * jpeg_data, guint8 ** buf, if (!jpeg_data->jfif_found) { /* only inject if no JFIF has been found */ - static const guint8 segment[] = { 0xff, 0xe0, 0x00, 0x10, - 0x4a, 0x46, 0x49, 0x46, 0x00, - 0x01, 0x02, - 0x00, 0x00, 0x01, 0x00, 0x01, - 0x00, 0x00 - }; - if (!jpeg_data->parse_only) { + static const guint8 segment[] = { 0xff, 0xe0, 0x00, 0x10, + 0x4a, 0x46, 0x49, 0x46, 0x00, + 0x01, 0x02, + 0x00, 0x00, 0x01, 0x00, 0x01, + 0x00, 0x00 + }; + memset (&chunk, 0x00, sizeof (MetadataChunk)); chunk.offset_orig = 2; chunk.size = 18; @@ -321,7 +507,7 @@ metadataparse_jpeg_reading (JpegParseData * jpeg_data, guint8 ** buf, MetadataChunk chunk; memset (&chunk, 0x00, sizeof (MetadataChunk)); - chunk.offset_orig = (*buf - step_buf) + offset - 4; /* maker + size */ + chunk.offset_orig = (*buf - step_buf) + offset - 4; /* 4 == maker + size */ chunk.size = chunk_size + 2; /* chunk size plus app marker */ chunk.type = MD_CHUNK_XMP; @@ -344,7 +530,9 @@ metadataparse_jpeg_reading (JpegParseData * jpeg_data, guint8 ** buf, } } #ifdef HAVE_IPTC - else if (mark[1] == 0xED) { /* may be it is photoshop and may be there is iptc */ + else if (mark[1] == 0xED) { + /* may be it is photoshop and may be there is iptc */ + if (chunk_size >= 16) { /* size2 "Photoshop 3.0" */ if (*bufsize < 14) { @@ -361,7 +549,7 @@ metadataparse_jpeg_reading (JpegParseData * jpeg_data, guint8 ** buf, MetadataChunk chunk; memset (&chunk, 0x00, sizeof (MetadataChunk)); - chunk.offset_orig = (*buf - step_buf) + offset - 4; /* maker + size */ + chunk.offset_orig = (*buf - step_buf) + offset - 4; /* 4 == maker + size */ chunk.size = chunk_size + 2; /* chunk size plus app marker */ chunk.type = MD_CHUNK_IPTC; @@ -400,6 +588,43 @@ done: } +/* + * metadataparse_jpeg_exif: + * @jpeg_data: [in] jpeg data handle + * @buf: [in] data to be parsed + * @bufsize: [in] size of @buf in bytes + * @next_start: look at #metadataparse_jpeg_reading + * @next_size: look at #metadataparse_jpeg_reading + * NOTE: To have a explanation of each parameters of this function look at + * the documentation of #metadataparse_jpeg_reading + * + * This function saves the EXIF chunk to @jpeg_data->exif_adapter and makes the + * parsing process point to the next buffer after the EXIF chunk. + * This function will be called by the parsing process 'cause at some point + * #metadataparse_jpeg_reading found out the EXIF chunk, skipped the JPEG + * wrapper bytes and changed the state of parsing process to JPEG_PARSE_EXIF. + * Which just happens if @jpeg_data->parse_only is FALSE and there is a EXIF + * chunk into the stream and @jpeg_data->exif_adapter is not NULL. + * This function will just be called once even if there is more than one EXIF + * chunk in the stream. This function do it by setting @jpeg_data->exif_adapter + * to NULL. + * After this function has completely parsed (hold) the chunk, it changes the + * parsing state back to JPEG_PARSE_READING which makes + * #metadataparse_jpeg_reading to be called again + * @see_also: #metadataparse_util_hold_chunk #metadataparse_jpeg_reading + * + * Returns: + * + * %META_PARSING_ERROR + * + * %META_PARSING_DONE if the chunk bas been completely hold + * + * %META_PARSING_NEED_MORE_DATA if this function should be + * called again (look @next_start and @next_size) + * + * + */ + static MetadataParsingReturn metadataparse_jpeg_exif (JpegParseData * jpeg_data, guint8 ** buf, guint32 * bufsize, guint8 ** next_start, guint32 * next_size) @@ -419,6 +644,15 @@ metadataparse_jpeg_exif (JpegParseData * jpeg_data, guint8 ** buf, } +/* + * metadataparse_jpeg_iptc: + * + * Look at #metadataparse_jpeg_exif. This function has the same behavior as + * that. The only difference is that this function also cut out others + * PhotoShop data and only holds IPTC data in it. + * + */ + #ifdef HAVE_IPTC static MetadataParsingReturn metadataparse_jpeg_iptc (JpegParseData * jpeg_data, guint8 ** buf, @@ -443,6 +677,7 @@ metadataparse_jpeg_iptc (JpegParseData * jpeg_data, guint8 ** buf, size = gst_adapter_available (*jpeg_data->iptc_adapter); buf = gst_adapter_peek (*jpeg_data->iptc_adapter, size); + /* FIXME: currently we are trhowing away others PhotoShop data */ res = iptc_jpeg_ps3_find_iptc (buf, size, &iptc_len); if (res < 0) { @@ -473,6 +708,14 @@ metadataparse_jpeg_iptc (JpegParseData * jpeg_data, guint8 ** buf, } #endif +/* + * metadataparse_jpeg_xmp: + * + * Look at #metadataparse_jpeg_exif. This function has the same behavior as + * that. + * + */ + static MetadataParsingReturn metadataparse_jpeg_xmp (JpegParseData * jpeg_data, guint8 ** buf, guint32 * bufsize, guint8 ** next_start, guint32 * next_size) @@ -490,6 +733,32 @@ metadataparse_jpeg_xmp (JpegParseData * jpeg_data, guint8 ** buf, return ret; } +/* + * metadataparse_jpeg_jump: + * @jpeg_data: [in] jpeg data handle + * @buf: [in] data to be parsed + * @bufsize: [in] size of @buf in bytes + * @next_start: look at #metadataparse_jpeg_reading + * @next_size: look at #metadataparse_jpeg_reading + * NOTE: To have a explanation of each parameters of this function look at + * the documentation of #metadataparse_jpeg_reading + * + * This function just makes a chunk we are not interested in to be jumped. + * This is done basically by incrementing @next_start and @buf, + * and decreasing @bufsize and setting the next parsing state properly. + * @see_also: #metadataparse_jpeg_reading #metadataparse_util_jump_chunk + * + * Returns: + * + * %META_PARSING_DONE if bytes has been skiped and there is + * still data in @buf + * + * %META_PARSING_NEED_MORE_DATA if the skiped bytes end at + * some point after @buf + @bufsize + * + * + */ + static MetadataParsingReturn metadataparse_jpeg_jump (JpegParseData * jpeg_data, guint8 ** buf, guint32 * bufsize, guint8 ** next_start, guint32 * next_size) diff --git a/ext/metadata/metadataparsejpeg.h b/ext/metadata/metadataparsejpeg.h index e00095d94d..5f85d8f896 100644 --- a/ext/metadata/metadataparsejpeg.h +++ b/ext/metadata/metadataparsejpeg.h @@ -44,12 +44,20 @@ #ifndef __METADATAPARSE_JPEG_H__ #define __METADATAPARSE_JPEG_H__ +/* + * includes + */ + #include #include "metadatatypes.h" G_BEGIN_DECLS +/* + * enum and types + */ + typedef enum _tag_JpegParseState { JPEG_PARSE_NULL, @@ -79,6 +87,9 @@ typedef struct _tag_JpegParseData gboolean jfif_found; } JpegParseData; +/* + * external function prototypes + */ extern void metadataparse_jpeg_init (JpegParseData * jpeg_data, GstAdapter ** exif_adpt, @@ -88,11 +99,12 @@ metadataparse_jpeg_init (JpegParseData * jpeg_data, GstAdapter ** exif_adpt, extern void metadataparse_jpeg_dispose (JpegParseData * jpeg_data); -extern void metadataparse_jpeg_lazy_update (JpegParseData * jpeg_data); - extern MetadataParsingReturn metadataparse_jpeg_parse (JpegParseData * jpeg_data, guint8 * buf, - guint32 * bufsize, const guint32 offset, guint8 ** next_start, guint32 * next_size); + guint32 * bufsize, const guint32 offset, guint8 ** next_start, + guint32 * next_size); + +extern void metadataparse_jpeg_lazy_update (JpegParseData * jpeg_data); G_END_DECLS #endif /* __METADATAPARSE_JPEG_H__ */ diff --git a/ext/metadata/metadataparsepng.c b/ext/metadata/metadataparsepng.c index a5de4dbede..b5a8e7756f 100644 --- a/ext/metadata/metadataparsepng.c +++ b/ext/metadata/metadataparsepng.c @@ -41,10 +41,45 @@ * Boston, MA 02111-1307, USA. */ +/* + * SECTION: metadataparsepng + * @short_description: This module provides functions to parse PNG files + * + * This module parses a PNG stream finding XMP metadata chunks, and marking + * them to be removed from the stream and saving the XMP chunk in a adapter. + * + * + * + * #metadataparse_png_init must be called before any other function in this + * module and must be paired with a call to #metadataparse_png_dispose. + * #metadataparse_png_parse is used to parse the stream (find the metadata + * chunks and the place it should be written to. + * #metadataparse_png_lazy_update do nothing. + * + * + * + * Last reviewed on 2008-01-24 (0.10.15) + */ + +/* + * includes + */ + #include "metadataparsepng.h" #include +/* + * defines and macros + */ + +/* returns the current byte, advance to the next one and decrease the size */ +#define READ(buf, size) ( (size)--, *((buf)++) ) + +/* + * static helper functions declaration + */ + static MetadataParsingReturn metadataparse_png_reading (PngParseData * png_data, guint8 ** buf, guint32 * bufsize, const guint32 offset, const guint8 * step_buf, @@ -58,13 +93,30 @@ static MetadataParsingReturn metadataparse_png_jump (PngParseData * png_data, guint8 ** buf, guint32 * bufsize, guint8 ** next_start, guint32 * next_size); -#define READ(buf, size) ( (size)--, *((buf)++) ) +/* + * extern functions implementations + */ -void -metadataparse_png_lazy_update (PngParseData * jpeg_data) -{ - /* nothing to do */ -} +/* + * metadataparse_png_init: + * @png_data: [in] png data handler to be inited + * @exif_adpt: ignored + * @iptc_adpt: ignored + * @xmp_adpt: where to create/write an adapter to hold the XMP chunk found + * @strip_chunks: Array of chunks (offset and size) marked for removal + * @inject_chunks: Array of chunks (offset, data, size) marked for injection + * @parse_only: TRUE if it should only find the chunks and write then to the + * adapter (@xmp_adpt). Or FALSE if should also put + * them on @strip_chunks. + * + * Init png data handle. + * This function must be called before any other function from this module. + * This function must not be called twice without call to + * #metadataparse_png_dispose beteween them. + * @see_also: #metadataparse_png_dispose #metadataparse_png_parse + * + * Returns: nothing + */ void metadataparse_png_init (PngParseData * png_data, GstAdapter ** exif_adpt, @@ -82,12 +134,59 @@ metadataparse_png_init (PngParseData * png_data, GstAdapter ** exif_adpt, } +/* + * metadataparse_png_dispose: + * @png_data: [in] png data handler to be freed + * + * Call this function to free any resource allocated by + * #metadataparse_png_init + * @see_also: #metadataparse_png_init + * + * Returns: nothing + */ + void metadataparse_png_dispose (PngParseData * png_data) { png_data->xmp_adapter = NULL; } +/* + * metadata_parse: + * @png_data: [in] png data handle + * @buf: [in] data to be parsed + * @bufsize: [in] size of @buf in bytes + * @offset: is the offset where @buf starts from the beginnig of the whole + * stream. + * @next_start: is a pointer after @buf which indicates where @buf should start + * on the next call to this function. It means, that after returning, this + * function has consumed *@next_start - @buf bytes. Which also means + * that @offset should also be incremanted by (*@next_start - @buf) for the + * next time. + * @next_size: [out] number of minimal bytes in @buf for the next call to this + * function + * + * This function is used to parse a PNG stream step-by-step incrementally. + * Basically this function works like a state machine, that will run in a loop + * while there is still bytes in @buf to be read or it has finished parsing. + * If the it hasn't parsed yet and there is no more data in @buf, then the + * current state is saved and a indication will be make about the buffer to + * be passed by the caller function. + * @see_also: #metadataparse_png_init + * + * Returns: + * + * %META_PARSING_ERROR + * + * %META_PARSING_DONE if parse has finished. Now strip and + * inject chunks has been found + * + * %META_PARSING_NEED_MORE_DATA if this function should be + * called again (look @next_start and @next_size) + * + * + */ + MetadataParsingReturn metadataparse_png_parse (PngParseData * png_data, guint8 * buf, guint32 * bufsize, const guint32 offset, guint8 ** next_start, @@ -98,10 +197,19 @@ metadataparse_png_parse (PngParseData * png_data, guint8 * buf, guint8 mark[8]; const guint8 *step_buf = buf; + /* step_buf holds where buf starts. this const value will be passed to + the nested parsing function, so those function knows how far they from + the initial buffer. This is not related to the beginning of the whole + stream, it is just related to the buf passed in this step to this + function */ + *next_start = buf; if (png_data->state == PNG_PARSE_NULL) { + /* only the first time this function is called it will verify the stream + type to be sure it is a PNG */ + if (*bufsize < 8) { *next_size = (buf - *next_start) + 8; ret = META_PARSING_NEED_MORE_DATA; @@ -117,9 +225,9 @@ metadataparse_png_parse (PngParseData * png_data, guint8 * buf, mark[6] = READ (buf, *bufsize); mark[7] = READ (buf, *bufsize); - if (mark[0] != 0x89 || mark[1] != 0x50 || mark[2] != 0x4E || mark[3] != 0x47 - || mark[4] != 0x0D || mark[5] != 0x0A || mark[6] != 0x1A - || mark[7] != 0x0A) { + if (mark[0] != 0x89 || mark[1] != 0x50 || mark[2] != 0x4E || + mark[3] != 0x47 || mark[4] != 0x0D || mark[5] != 0x0A || + mark[6] != 0x1A || mark[7] != 0x0A) { ret = META_PARSING_ERROR; goto done; } @@ -160,6 +268,68 @@ done: } +/* + * metadataparse_png_lazy_update: + * @png_data: [in] png data handle + * + * This function do nothing + * @see_also: metadata_lazy_update + * + * Returns: nothing + */ + +void +metadataparse_png_lazy_update (PngParseData * png_data) +{ + /* nothing to do */ +} + +/* + * static helper functions implementation + */ + +/* + * metadataparse_png_reading: + * @png_data: [in] png data handle + * @buf: [in] data to be parsed. @buf will increment during the parsing step. + * So it will hold the next byte to be read inside a parsing function or on + * the next nested parsing function. And so, @bufsize will decrement. + * @bufsize: [in] size of @buf in bytes. This value will decrement during the + * parsing for the same reason that @buf will advance. + * @offset: is the offset where @step_buf starts from the beginnig of the + * stream + * @step_buf: holds the pointer to the buffer passed to + * #metadataparse_png_parse. It means that any point inside this function + * the offset (related to the beginning of the whole stream) after the last + * byte read so far is "(*buf - step_buf) + offset" + * @next_start: is a pointer after @step_buf which indicates where the next + * call to #metadataparse_png_parse should start on the next call to this + * function. It means, that after return, this function has + * consumed *@next_start - @buf bytes. Which also means that @offset should + * also be incremanted by (*@next_start - @buf) for the next time. + * @next_size: [out] number of minimal bytes in @buf for the next call to this + * function + * + * This function is used to parse a PNG stream step-by-step incrementally. + * If this function finds a XMP chunk (or a chunk that should be + * jumped), then it changes the state of the parsing process so that the + * remaing parsing can be done by another more specialized function. + * @see_also: #metadataparse_png_init #metadataparse_png_xmp + * #metadataparse_png_jump + * + * Returns: + * + * %META_PARSING_ERROR + * + * %META_PARSING_DONE if parse has finished. Now strip and + * inject chunks has been found. Or some chunk has been found and should be + * held or jumped. + * + * %META_PARSING_NEED_MORE_DATA if this function should be + * called again (look @next_start and @next_size) + * + * + */ /* look for markers */ static MetadataParsingReturn @@ -213,7 +383,7 @@ metadataparse_png_reading (PngParseData * png_data, guint8 ** buf, memset (&chunk, 0x00, sizeof (MetadataChunk)); chunk.offset_orig = (*buf - step_buf) + offset - 8; /* maker + size */ - chunk.size = chunk_size + 12; /* chunk size plus app marker plus crc */ + chunk.size = chunk_size + 12; /* chunk size + app marker + crc */ chunk.type = MD_CHUNK_XMP; metadata_chunk_array_append_sorted (png_data->strip_chunks, &chunk); @@ -221,9 +391,10 @@ metadataparse_png_reading (PngParseData * png_data, guint8 ** buf, /* if adapter has been provided, prepare to hold chunk */ if (png_data->xmp_adapter) { - *buf += 22; /* jump "XML:com.adobe.xmp" plus some flags */ + *buf += 22; /* jump "XML:com.adobe.xmp" + some flags */ *bufsize -= 22; - png_data->read = chunk_size - 22; /* four CRC bytes at the end will be jumped after */ + /* four CRC bytes at the end will be jumped after */ + png_data->read = chunk_size - 22; png_data->state = PNG_PARSE_XMP; ret = META_PARSING_DONE; goto done; @@ -244,14 +415,44 @@ done: } -static MetadataParsingReturn -metadataparse_png_jump (PngParseData * png_data, guint8 ** buf, - guint32 * bufsize, guint8 ** next_start, guint32 * next_size) -{ - png_data->state = PNG_PARSE_READING; - return metadataparse_util_jump_chunk (&png_data->read, buf, - bufsize, next_start, next_size); -} +/* + * metadataparse_png_xmp: + * @png_data: [in] png data handle + * @buf: [in] data to be parsed + * @bufsize: [in] size of @buf in bytes + * @next_start: look at #metadataparse_png_reading + * @next_size: look at #metadataparse_png_reading + * NOTE: To have a explanation of each parameters of this function look at + * the documentation of #metadataparse_png_reading + * + * This function saves the XMP chunk to @png_data->xmp_adapter and makes the + * parsing process point to the next buffer after the XMP chunk. + * This function will be called by the parsing process 'cause at some point + * #metadataparse_png_reading found out the XMP chunk, skipped the PNG + * wrapper bytes and changed the state of parsing process to PNG_PARSE_XMP. + * Which just happens if @png_data->parse_only is FALSE and there is a XMP + * chunk into the stream and @png_data->xmp_adapter is not NULL. + * This function will just be called once even if there is more than one XMP + * chunk in the stream. This function do it by setting @png_data->xmp_adapter + * to NULL. + * After this function has completely parsed (hold) the chunk, it changes the + * parsing state to PNG_PARSE_JUMP which makes + * #metadataparse_png_jump to be called in order to jumo the remaing 4 CRC + * bytes + * @see_also: #metadataparse_util_hold_chunk #metadataparse_png_reading + * #metadataparse_png_jump + * + * Returns: + * + * %META_PARSING_ERROR + * + * %META_PARSING_DONE if the chunk bas been completely hold + * + * %META_PARSING_NEED_MORE_DATA if this function should be + * called again (look @next_start and @next_size) + * + * + */ static MetadataParsingReturn metadataparse_png_xmp (PngParseData * png_data, guint8 ** buf, @@ -271,3 +472,38 @@ metadataparse_png_xmp (PngParseData * png_data, guint8 ** buf, return ret; } + +/* + * metadataparse_png_jump: + * @png_data: [in] png data handle + * @buf: [in] data to be parsed + * @bufsize: [in] size of @buf in bytes + * @next_start: look at #metadataparse_png_reading + * @next_size: look at #metadataparse_png_reading + * NOTE: To have a explanation of each parameters of this function look at + * the documentation of #metadataparse_png_reading + * + * This function just makes a chunk we are not interested in to be jumped. + * This is done basically by incrementing @next_start and @buf, + * and decreasing @bufsize and setting the next parsing state properly. + * @see_also: #metadataparse_png_reading #metadataparse_util_jump_chunk + * + * Returns: + * + * %META_PARSING_DONE if bytes has been skiped and there is + * still data in @buf + * + * %META_PARSING_NEED_MORE_DATA if the skiped bytes end at + * some point after @buf + @bufsize + * + * + */ + +static MetadataParsingReturn +metadataparse_png_jump (PngParseData * png_data, guint8 ** buf, + guint32 * bufsize, guint8 ** next_start, guint32 * next_size) +{ + png_data->state = PNG_PARSE_READING; + return metadataparse_util_jump_chunk (&png_data->read, buf, + bufsize, next_start, next_size); +} diff --git a/ext/metadata/metadataparsepng.h b/ext/metadata/metadataparsepng.h index 26f87294bd..8e2b1d6286 100644 --- a/ext/metadata/metadataparsepng.h +++ b/ext/metadata/metadataparsepng.h @@ -44,12 +44,20 @@ #ifndef __METADATAPARSE_PNG_H__ #define __METADATAPARSE_PNG_H__ +/* + * includes + */ + #include #include "metadatatypes.h" G_BEGIN_DECLS +/* + * enum and types + */ + typedef enum _tag_PngParseState { PNG_PARSE_NULL, @@ -73,6 +81,9 @@ typedef struct _tag_PngParseData guint32 read; } PngParseData; +/* + * external function prototypes + */ extern void metadataparse_png_init (PngParseData * png_data, GstAdapter ** exif_adpt, @@ -82,11 +93,12 @@ metadataparse_png_init (PngParseData * png_data, GstAdapter ** exif_adpt, extern void metadataparse_png_dispose (PngParseData * png_data); -extern void metadataparse_png_lazy_update (PngParseData * jpeg_data); +extern void metadataparse_png_lazy_update (PngParseData * png_data); extern MetadataParsingReturn metadataparse_png_parse (PngParseData * png_data, guint8 * buf, - guint32 * bufsize, const guint32 offset, guint8 ** next_start, guint32 * next_size); + guint32 * bufsize, const guint32 offset, guint8 ** next_start, + guint32 * next_size); G_END_DECLS #endif /* __METADATAPARSE_PNG_H__ */ diff --git a/ext/metadata/metadataparseutil.c b/ext/metadata/metadataparseutil.c index dbb1618da7..794d534a4f 100644 --- a/ext/metadata/metadataparseutil.c +++ b/ext/metadata/metadataparseutil.c @@ -41,9 +41,38 @@ * Boston, MA 02111-1307, USA. */ +/* + * SECTION: metadataparseutil + * @short_description: This module has some util function for parsing. + * + * Last reviewed on 2008-01-24 (0.10.15) + */ + +/* + * includes + */ + #include "metadataparseutil.h" #include +/* + * extern functions implementations + */ + +/* + * metadataparse_util_tag_list_add_chunk: + * @taglist: tag list in which the whole chunk tag will be added + * @mode: GStreamer merge mode + * @name: name of the tag (ex: GST_TAG_EXIF, GST_TAG_IPTC, GST_TAG_XMP) + * @adapter: contains the whole chunk to be added as tag to @taglist + * + * This function get all the bytes from @adapter, create a GST_BUFFER, copy + * the bytes to it and then add it to @taglist as a tage @name using a + * merge @mode. + * + * Returns: nothing. + */ + void metadataparse_util_tag_list_add_chunk (GstTagList * taglist, GstTagMergeMode mode, const gchar * name, GstAdapter * adapter) @@ -64,6 +93,39 @@ metadataparse_util_tag_list_add_chunk (GstTagList * taglist, } +/* + * metadataparse_util_hold_chunk: + * @read: number of bytes that still need to be hold + * @buf: [in] data to be parsed + * @bufsize: [in] size of @buf in bytes + * @next_start: indicates a pointer after the @buf where the next parsing step + * should start from + * @next_size: indicates the minimal size of the the buffer to be given on + * the next call to the parser + * @adapter: adapter to hold the chunk + * NOTE: To have a explanation of each parameters of this function look at the + * documentation of #metadataparse_jpeg_reading or #metadataparse_png_reading + * + * This function holds a chunk into the adapter. If there is enough bytes + * (*@read > *@bufsize), then it just hold and make the parser continue after + * the chunk by setting @next_start properly. Otherwise, if there is not + * enough bytes in @buf, it just set @next_start and @next_size, to make the + * parse return META_PARSING_NEED_MORE_DATA and request the caller the proper + * offset and size, so in the sencond time this function is called it should + * (or must) have enough data hold the whole chunk. + * + * Returns: + * + * %META_PARSING_ERROR + * + * %META_PARSING_DONE if the chunk bas been completely hold + * + * %META_PARSING_NEED_MORE_DATA if this function should be + * called again (look @next_start and @next_size) + * + * + */ + MetadataParsingReturn metadataparse_util_hold_chunk (guint32 * read, guint8 ** buf, guint32 * bufsize, guint8 ** next_start, @@ -95,6 +157,16 @@ metadataparse_util_hold_chunk (guint32 * read, guint8 ** buf, return ret; } +/* + * metadataparse_util_jump_chunk: + * NOTE: To have a explanation of each parameters of this function look at + * the documentation of #metadataparse_util_hold_chunk + * + * This function works in the same way as #metadataparse_util_hold_chunk, but + * just skip the bytes instead of also hold it + * + */ + MetadataParsingReturn metadataparse_util_jump_chunk (guint32 * read, guint8 ** buf, guint32 * bufsize, guint8 ** next_start, guint32 * next_size) diff --git a/ext/metadata/metadataparseutil.h b/ext/metadata/metadataparseutil.h index 1dac942cc2..e24341bdc0 100644 --- a/ext/metadata/metadataparseutil.h +++ b/ext/metadata/metadataparseutil.h @@ -44,6 +44,10 @@ #ifndef __GST_METADATAPARSE_UTIL_H__ #define __GST_METADATAPARSE_UTIL_H__ +/* + * includes + */ + #include #include @@ -51,6 +55,10 @@ G_BEGIN_DECLS +/* + * external function prototypes + */ + extern void metadataparse_util_tag_list_add_chunk (GstTagList * taglist, GstTagMergeMode mode, const gchar * name, GstAdapter * adapter); diff --git a/ext/metadata/metadatatags.c b/ext/metadata/metadatatags.c index fbbdc32867..b780703316 100644 --- a/ext/metadata/metadatatags.c +++ b/ext/metadata/metadatatags.c @@ -41,8 +41,67 @@ * Boston, MA 02111-1307, USA. */ +/* + * SECTION: metadatatags + * @short_description: This module contains has tag definitions to be mapped + * to EXIF, IPTC and XMP tags. + * + * This module register tags need for image metadata but aren't already define + * in GStreamer base. So, the EXIF, IPTC and XMP tags can be mapped to tags + * not registered in this file (tags already in GST base) + * + * Last reviewed on 2008-01-24 (0.10.15) + */ + +/* + * includes + */ + #include "metadatatags.h" +/* + * static helper functions declaration + */ + +static void metadata_tags_exif_register (void); + +static void metadata_tags_iptc_register (void); + +static void metadata_tags_xmp_register (void); + +/* + * extern functions implementations + */ + +void +metadata_tags_register (void) +{ + + /* whole chunk tags */ + + gst_tag_register (GST_TAG_EXIF, GST_TAG_FLAG_META, + GST_TYPE_BUFFER, GST_TAG_EXIF, "exif metadata chunk", NULL); + + gst_tag_register (GST_TAG_IPTC, GST_TAG_FLAG_META, + GST_TYPE_BUFFER, GST_TAG_IPTC, "iptc metadata chunk", NULL); + + gst_tag_register (GST_TAG_XMP, GST_TAG_FLAG_META, + GST_TYPE_BUFFER, GST_TAG_XMP, "xmp metadata chunk", NULL); + + /* tags related to some metadata */ + + metadata_tags_exif_register (); + metadata_tags_iptc_register (); + metadata_tags_xmp_register (); + +} + + +/* + * static helper functions implementation + */ + + /* * EXIF tags */ @@ -179,30 +238,3 @@ metadata_tags_xmp_register (void) { } - -/* - * - */ - -void -metadata_tags_register (void) -{ - - /* whole chunk tags */ - - gst_tag_register (GST_TAG_EXIF, GST_TAG_FLAG_META, - GST_TYPE_BUFFER, GST_TAG_EXIF, "exif metadata chunk", NULL); - - gst_tag_register (GST_TAG_IPTC, GST_TAG_FLAG_META, - GST_TYPE_BUFFER, GST_TAG_IPTC, "iptc metadata chunk", NULL); - - gst_tag_register (GST_TAG_XMP, GST_TAG_FLAG_META, - GST_TYPE_BUFFER, GST_TAG_XMP, "xmp metadata chunk", NULL); - - /* tags related to some metadata */ - - metadata_tags_exif_register (); - metadata_tags_iptc_register (); - metadata_tags_xmp_register (); - -} diff --git a/ext/metadata/metadatatags.h b/ext/metadata/metadatatags.h index a5ee914ebc..c458324f18 100644 --- a/ext/metadata/metadatatags.h +++ b/ext/metadata/metadatatags.h @@ -44,17 +44,29 @@ #ifndef __GST_METADATA_TAGS_H__ #define __GST_METADATA_TAGS_H__ +/* + * includes + */ + #include #include G_BEGIN_DECLS +/* + * enum and types + */ + /* set bit to desired mapping */ typedef enum { METADATA_TAG_MAP_INDIVIDUALS = 1 << 0, METADATA_TAG_MAP_WHOLECHUNK = 1 << 1 } MetadataTagMapping; +/* + * defines + */ + #define GST_TAG_EXIF "exif" #define GST_TAG_IPTC "iptc" @@ -79,6 +91,10 @@ typedef enum { #define GST_TAG_CAPTURE_CONTRAST "capture-contrast" #define GST_TAG_CAPTURE_SATURATION "capture-saturation" +/* + * external function prototypes + */ + extern void metadata_tags_register (void); diff --git a/ext/metadata/metadatatypes.c b/ext/metadata/metadatatypes.c index 8a5b496898..e142569c9a 100644 --- a/ext/metadata/metadatatypes.c +++ b/ext/metadata/metadatatypes.c @@ -41,10 +41,41 @@ * Boston, MA 02111-1307, USA. */ +/* + * SECTION: metadatatypes + * @short_description: This module contains function to operates a list of + * chunks + * + * Last reviewed on 2008-01-24 (0.10.15) + */ + +/* + * includes + */ + #include "metadatatypes.h" #include +/* + * extern functions implementations + */ + +/* + * metadata_chunk_array_init: + * @array: an array of chunks + * @alloc_size: number of chunks that can be added to the array without futher + * allocation + * + * Call this function before any other function in this module. + * Nerver call this function a second time without call + * #metadata_chunk_array_free beteween them + * An example of use is: + * int test() { MetadataChunkArray a; metadata_chunk_array_init(&a, 1); ... } + * + * Returns: nothing + */ + void metadata_chunk_array_init (MetadataChunkArray * array, gsize alloc_size) { @@ -53,6 +84,16 @@ metadata_chunk_array_init (MetadataChunkArray * array, gsize alloc_size) array->allocated_len = alloc_size; } +/* + * metadata_chunk_array_free: + * @array: an array of chunks + * + * Call this function after have finished using the @array to free any internal + * memory alocated by it. + * + * Returns: nothing + */ + void metadata_chunk_array_free (MetadataChunkArray * array) { @@ -64,6 +105,17 @@ metadata_chunk_array_free (MetadataChunkArray * array) } } +/* + * metadata_chunk_array_clear: + * @array: an array of chunks + * + * Free memory allocated internally by each chunk and set the @array->len to 0 + * (zero). So, the number of chunks into the array will be zero, + * but the number of slots into the array to strore chunks will be kept + * + * Returns: nothing + */ + void metadata_chunk_array_clear (MetadataChunkArray * array) { @@ -75,6 +127,19 @@ metadata_chunk_array_clear (MetadataChunkArray * array) } } +/* + * metadata_chunk_array_append: + * @array: an array of chunks + * @chunk: chunk to be append + * + * Just append a @chunk to the end of the @array. The @array now will be the + * owner of @chunk->data. Just call this function if you a sure the @array + * chunks will be sorted by @chunk->offset_orig anyway. + * @see_also: #metadata_chunk_array_append_sorted + * + * Returns: nothing + */ + void metadata_chunk_array_append (MetadataChunkArray * array, MetadataChunk * chunk) { @@ -87,6 +152,19 @@ metadata_chunk_array_append (MetadataChunkArray * array, MetadataChunk * chunk) ++array->len; } +/* + * metadata_chunk_array_append_sorted: + * @array: an array of chunks + * @chunk: chunk to be append + * + * Append a @chunk sorted by @chunk->offset_orig the @array. The @array now + * will be the owner of @chunk->data. This function supposes that @array + * is already sorted by @chunk->offset_orig. + * @see_also: #metadata_chunk_array_append + * + * Returns: nothing + */ + void metadata_chunk_array_append_sorted (MetadataChunkArray * array, MetadataChunk * chunk) @@ -116,6 +194,18 @@ metadata_chunk_array_append_sorted (MetadataChunkArray * array, } +/* + * metadata_chunk_array_remove_zero_size: + * @array: an array of chunks + * + * This function removes all the chunks in @array that has 'chunk.size == 0'. + * It is possible to have the 'chunk.data==NULL' and 'chunk.size != 0', those + * chunks are used by muxer for lazy 'filling' and are not removed by this + * function. + * + * Returns: nothing + */ + void metadata_chunk_array_remove_zero_size (MetadataChunkArray * array) { diff --git a/ext/metadata/metadatatypes.h b/ext/metadata/metadatatypes.h index d58d23b4a3..fd7df9dd58 100644 --- a/ext/metadata/metadatatypes.h +++ b/ext/metadata/metadatatypes.h @@ -44,10 +44,18 @@ #ifndef __METADATATYPES_H__ #define __METADATATYPES_H__ +/* + * includes + */ + #include G_BEGIN_DECLS +/* + * enum and types + */ + /* *INDENT-OFF* */ typedef enum _tag_MetadataParsingReturn { @@ -78,10 +86,14 @@ typedef struct _tag_MetadataChunk typedef struct _tag_MetadataChunkArray { MetadataChunk * chunk; - gsize len; - gsize allocated_len; + gsize len; /* number of chunks into aray */ + gsize allocated_len; /* number of slots into the array to store chunks */ } MetadataChunkArray; +/* + * external function prototypes + */ + extern void metadata_chunk_array_init(MetadataChunkArray * array, gsize alloc_size); @@ -94,11 +106,9 @@ metadata_chunk_array_clear(MetadataChunkArray * array); extern void metadata_chunk_array_append(MetadataChunkArray * array, MetadataChunk * chunk); -/* sorted by offset (chunk supposed to be already sorted - * returns false if chunks are inserted in same offset - */ extern void -metadata_chunk_array_append_sorted(MetadataChunkArray * array, MetadataChunk * chunk); +metadata_chunk_array_append_sorted(MetadataChunkArray * array, + MetadataChunk * chunk); extern void metadata_chunk_array_remove_zero_size (MetadataChunkArray * array); diff --git a/ext/metadata/metadataxmp.c b/ext/metadata/metadataxmp.c index cc8172ce35..6712fbdb31 100644 --- a/ext/metadata/metadataxmp.c +++ b/ext/metadata/metadataxmp.c @@ -41,39 +41,75 @@ * Boston, MA 02111-1307, USA. */ +/* + * SECTION: metadataxmp + * @short_description: This module provides functions to extract tags from + * XMP metadata chunks and create XMP chunks from metadata tags. + * @see_also: #metadatatags.[c/h] + * + * If lib exempi isn't available at compilation time, only the whole chunk + * (#METADATA_TAG_MAP_WHOLECHUNK) tags is created. It means that individual + * tags aren't mapped. + * + * + * + * #metadata_xmp_init must be called before any other function in this + * module and must be paired with a call to #metadata_xmp_dispose + * + * + * + * Last reviewed on 2008-01-24 (0.10.15) + */ + +/* + * includes + */ + #include "metadataxmp.h" #include "metadataparseutil.h" #include "metadatatags.h" +/* + * defines + */ + GST_DEBUG_CATEGORY (gst_metadata_xmp_debug); #define GST_CAT_DEFAULT gst_metadata_xmp_debug +/* + * Implementation when lib exempi isn't available at compilation time + */ + #ifndef HAVE_XMP +/* + * extern functions implementations + */ + +gboolean +metadata_xmp_init (void) +{ + return TRUE; +} + +void +metadata_xmp_dispose (void) +{ + return; +} + void metadataparse_xmp_tag_list_add (GstTagList * taglist, GstTagMergeMode mode, GstAdapter * adapter, MetadataTagMapping mapping) { if (mapping & METADATA_TAG_MAP_WHOLECHUNK) { - GST_LOG ("XMP not defined, here I should send just one tag as whole chunk"); + GST_LOG ("XMP not defined, sending just one tag as whole chunk"); metadataparse_util_tag_list_add_chunk (taglist, mode, GST_TAG_XMP, adapter); } } -gboolean -metadataparse_xmp_init (void) -{ - return TRUE; -} - -void -metadataparse_xmp_dispose (void) -{ - return; -} - void metadatamux_xmp_create_chunk_from_tag_list (guint8 ** buf, guint32 * size, const GstTagList * taglist) @@ -83,10 +119,20 @@ metadatamux_xmp_create_chunk_from_tag_list (guint8 ** buf, guint32 * size, #else /* ifndef HAVE_XMP */ +/* + * Implementation when lib exempi isn't available at compilation time + */ + +/* + * includes + */ + #include #include -#define XMP_SCHEMA_NODE 0x80000000UL +/* + * enum and types + */ typedef struct _tag_SchemaTagMap { @@ -102,6 +148,12 @@ typedef struct _tag_SchemaMap const SchemaTagMap *tags_map; } SchemaMap; +/* + * defines and static global vars + */ + +#define XMP_SCHEMA_NODE 0x80000000UL + static const SchemaTagMap schema_map_dublin_tags_map[] = { {"description", GST_TAG_DESCRIPTION}, {"title", GST_TAG_TITLE}, @@ -109,7 +161,8 @@ static const SchemaTagMap schema_map_dublin_tags_map[] = { {NULL, NULL} }; -static const SchemaMap schema_map_dublin = { "http://purl.org/dc/elements/1.1/", +static const SchemaMap schema_map_dublin = { + "http://purl.org/dc/elements/1.1/", "dc:", 3, schema_map_dublin_tags_map @@ -120,10 +173,22 @@ static const SchemaMap *schemas_map[] = { NULL }; +/* + * static helper functions declaration + */ + +static const SchemaTagMap *metadataparse_xmp_get_tagsmap_from_path (const + SchemaMap * schema_map, const gchar * path, uint32_t opt); + +static const SchemaTagMap *metadatamux_xmp_get_tagsmap_from_gsttag (const + SchemaMap * schema_map, const gchar * tag); + static void -metadataparse_xmp_iter_add_to_tag_list (GstTagList * taglist, - GstTagMergeMode mode, const char *path, const char *value, - const SchemaMap * schema_map, const uint32_t opt); +metadataparse_xmp_iter (GstTagList * taglist, GstTagMergeMode mode, XmpPtr xmp); + +static void +metadataparse_xmp_iter_node_schema (GstTagList * taglist, GstTagMergeMode mode, + XmpPtr xmp, const char *schema, const char *path); static void metadataparse_xmp_iter_array (GstTagList * taglist, GstTagMergeMode mode, @@ -131,34 +196,75 @@ metadataparse_xmp_iter_array (GstTagList * taglist, GstTagMergeMode mode, const SchemaMap * schema_map); static void -metadataparse_xmp_iter_node_schema (GstTagList * taglist, GstTagMergeMode mode, - XmpPtr xmp, const char *schema, const char *path); +metadataparse_xmp_iter_simple_qual (GstTagList * taglist, GstTagMergeMode mode, + const char *path, const char *value, const SchemaMap * schema_map); static void metadataparse_xmp_iter_simple (GstTagList * taglist, GstTagMergeMode mode, - const char *schema, const char *path, const char *value, - const SchemaMap * schema_map); + const char *path, const char *value, const SchemaMap * schema_map); static void -metadataparse_xmp_iter_simple_qual (GstTagList * taglist, GstTagMergeMode mode, - const char *schema, const char *path, const char *value, - const SchemaMap * schema_map); +metadataparse_xmp_iter_add_to_tag_list (GstTagList * taglist, + GstTagMergeMode mode, const char *path, const char *value, + const SchemaMap * schema_map, const uint32_t opt); static void -metadataparse_xmp_iter (GstTagList * taglist, GstTagMergeMode mode, XmpPtr xmp); +metadatamux_xmp_for_each_tag_in_list (const GstTagList * list, + const gchar * tag, gpointer user_data); + +/* + * extern functions implementations + */ + +/* + * metadata_xmp_init: + * + * Init lib exempi (if present in compilation time) + * This function must be called before any other function from this module. + * This function must not be called twice without call + * to #metadata_xmp_dispose beteween them. + * @see_also: #metadata_xmp_dispose + * + * Returns: nothing + */ gboolean -metadataparse_xmp_init (void) +metadata_xmp_init (void) { return xmp_init (); } +/* + * metadata_xmp_dispose: + * + * Call this function to free any resource allocated by #metadata_xmp_init + * @see_also: #metadata_xmp_init + * + * Returns: nothing + */ + void -metadataparse_xmp_dispose (void) +metadata_xmp_dispose (void) { xmp_terminate (); } +/* + * metadataparse_xmp_tag_list_add: + * @taglist: tag list in which extracted tags will be added + * @mode: tag list merge mode + * @adapter: contains the XMP metadata chunk + * @mapping: if is to extract individual tags and/or the whole chunk. + * + * This function gets a XMP chunk (@adapter) and extract tags from it + * and then to add to @taglist. + * Note: The XMP chunk (@adapetr) must NOT be wrapped by any bytes specific + * to any file format + * @see_also: #metadataparse_xmp_iter + * + * Returns: nothing + */ + void metadataparse_xmp_tag_list_add (GstTagList * taglist, GstTagMergeMode mode, GstAdapter * adapter, MetadataTagMapping mapping) @@ -172,8 +278,9 @@ metadataparse_xmp_tag_list_add (GstTagList * taglist, GstTagMergeMode mode, } /* add chunk tag */ - if (mapping & METADATA_TAG_MAP_WHOLECHUNK) + if (mapping & METADATA_TAG_MAP_WHOLECHUNK) { metadataparse_util_tag_list_add_chunk (taglist, mode, GST_TAG_XMP, adapter); + } if (!(mapping & METADATA_TAG_MAP_INDIVIDUALS)) goto done; @@ -196,32 +303,96 @@ done: } -static const SchemaTagMap * -metadataparse_get_tagsmap_from_gsttag (const SchemaMap * schema_map, - const gchar * tag) +/* + * metadatamux_xmp_create_chunk_from_tag_list: + * @buf: buffer that will have the created XMP chunk + * @size: size of the buffer that will be created + * @taglist: list of tags to be added to XMP chunk + * + * Get tags from @taglist, create a XMP chunk based on it and save to @buf. + * Note: The XMP chunk is NOT wrapped by any bytes specific to any file format + * + * Returns: nothing + */ + +void +metadatamux_xmp_create_chunk_from_tag_list (guint8 ** buf, guint32 * size, + const GstTagList * taglist) { - SchemaTagMap *tags_map = NULL; - int i; + GstBuffer *xmp_chunk = NULL; + const GValue *val = NULL; + XmpPtr xmp = NULL; + XmpStringPtr xmp_str_buf = xmp_string_new (); - if (NULL == schema_map) + if (!(buf && size)) goto done; + if (*buf) { + g_free (*buf); + *buf = NULL; + } + *size = 0; + val = gst_tag_list_get_value_index (taglist, GST_TAG_XMP, 0); + if (val) { + xmp_chunk = gst_value_get_buffer (val); + if (xmp_chunk) + xmp = xmp_new (GST_BUFFER_DATA (xmp_chunk), GST_BUFFER_SIZE (xmp_chunk)); + } - for (i = 0; schema_map->tags_map[i].gst_tag; i++) { - if (0 == strcmp (schema_map->tags_map[i].gst_tag, tag)) { - tags_map = (SchemaTagMap *) & schema_map->tags_map[i]; - break; - } + if (NULL == xmp) + xmp = xmp_new_empty (); + + gst_tag_list_foreach (taglist, metadatamux_xmp_for_each_tag_in_list, xmp); + + if (!xmp_serialize (xmp, xmp_str_buf, 0, 2)) { + GST_ERROR ("failed to serialize xmp into chunk\n"); + } else if (xmp_str_buf) { + unsigned int len = strlen (xmp_string_cstr (xmp_str_buf)); + + *size = len + 1; + *buf = malloc (*size); + memcpy (*buf, xmp_string_cstr (xmp_str_buf), *size); + } else { + GST_ERROR ("failed to serialize xmp into chunk\n"); } done: - return tags_map; + if (xmp_str_buf) + xmp_string_free (xmp_str_buf); + if (xmp) + xmp_free (xmp); + + return; } +/* + * static helper functions implementation + */ + +/* + * metadataparse_xmp_get_tagsmap_from_path: + * @schema_map: Structure containg a map beteween GST tags and tags into a XMP + * schema + * @path: string describing a XMP tag + * @opt: indicates if the string (@path) has extras caracters like '[' and ']' + * + * This returns a structure that contains the GStreamer tag mapped to an XMP + * tag. + * + * Returns: + * + * Structure containing the GST tag mapped + * to the XMP tag (@path) + * + * %NULL if there is no mapped GST tag for XMP tag (@path) + * + * + */ + static const SchemaTagMap * -metadataparse_get_tagsmap_from_path (const SchemaMap * schema_map, +metadataparse_xmp_get_tagsmap_from_path (const SchemaMap * schema_map, const gchar * path, uint32_t opt) { @@ -238,7 +409,7 @@ metadataparse_get_tagsmap_from_path (const SchemaMap * schema_map, string = g_string_new (path); - /* remove the language qualifier */ + /* remove the language qualifier "[xxx]" */ ch = string->str + string->len - 3; while (ch != string->str + schema_map->prefix_len) { if (*ch == '[') { @@ -266,160 +437,63 @@ done: } -static void -metadataparse_xmp_iter_add_to_tag_list (GstTagList * taglist, - GstTagMergeMode mode, const char *path, const char *value, - const SchemaMap * schema_map, const uint32_t opt) +/* + * metadatamux_xmp_get_tagsmap_from_gsttag: + * @schema_map: Structure containg a map beteween GST tags and tags into a XMP + * schema + * @tag: GStreaner tag to look for + * + * This returns a structure that contains the XMP tag mapped to a GStreamer + * tag. + * + * Returns: + * + * Structure containing the XMP tag mapped + * to the GST tag (@path) + * + * %NULL if there is no mapped XMP tag for GST @tag + * + * + */ + +static const SchemaTagMap * +metadatamux_xmp_get_tagsmap_from_gsttag (const SchemaMap * schema_map, + const gchar * tag) { + SchemaTagMap *tags_map = NULL; + int i; - const SchemaTagMap *smaptag = - metadataparse_get_tagsmap_from_path (schema_map, path, opt); - - if (NULL == smaptag) + if (NULL == schema_map) goto done; - if (NULL == smaptag->gst_tag) - goto done; - GType type = gst_tag_get_type (smaptag->gst_tag); - - switch (type) { - case G_TYPE_STRING: - gst_tag_list_add (taglist, mode, smaptag->gst_tag, value, NULL); - break; - default: + for (i = 0; schema_map->tags_map[i].gst_tag; i++) { + if (0 == strcmp (schema_map->tags_map[i].gst_tag, tag)) { + tags_map = (SchemaTagMap *) & schema_map->tags_map[i]; break; + } } done: - return; + return tags_map; } -void -metadataparse_xmp_iter_simple_qual (GstTagList * taglist, GstTagMergeMode mode, - const char *schema, const char *path, const char *value, - const SchemaMap * schema_map) -{ - GString *string = g_string_new (path); - gchar *ch; - - /* remove the language qualifier */ - ch = string->str + string->len - 3; - while (ch != string->str + schema_map->prefix_len) { - if (*ch == '[') { - *ch = '\0'; - } - --ch; - } - - GST_LOG (" %s = %s", string->str, value); - - metadataparse_xmp_iter_add_to_tag_list (taglist, mode, path, value, - schema_map, XMP_PROP_HAS_QUALIFIERS); - - g_string_free (string, TRUE); -} - - -void -metadataparse_xmp_iter_simple (GstTagList * taglist, GstTagMergeMode mode, - const char *schema, const char *path, const char *value, - const SchemaMap * schema_map) -{ - GST_LOG (" %s = %s", path, value); - - metadataparse_xmp_iter_add_to_tag_list (taglist, mode, path, value, - schema_map, 0); - -} - -void -metadataparse_xmp_iter_array (GstTagList * taglist, GstTagMergeMode mode, - XmpPtr xmp, const char *schema, const char *path, - const SchemaMap * schema_map) -{ - XmpStringPtr xstr_schema = xmp_string_new (); - XmpStringPtr xstr_path = xmp_string_new (); - XmpStringPtr xstr_prop = xmp_string_new (); - uint32_t opt = 0; - XmpIteratorPtr xmp_iter = NULL; - - xmp_iter = xmp_iterator_new (xmp, schema, path, XMP_ITER_JUSTCHILDREN); - - if (NULL == xmp_iter) - goto done; - - while (xmp_iterator_next (xmp_iter, xstr_schema, xstr_path, xstr_prop, &opt)) { - const char *schema = xmp_string_cstr (xstr_schema); - const char *path = xmp_string_cstr (xstr_path); - const char *value = xmp_string_cstr (xstr_prop); - - if (XMP_IS_NODE_SCHEMA (opt)) { - GST_LOG ("Unexpected iteraction"); - } else if (XMP_IS_PROP_SIMPLE (opt)) { - if (strcmp (path, "") != 0) { - if (XMP_HAS_PROP_QUALIFIERS (opt)) { - /* ignore language qualifier, just get the first */ - metadataparse_xmp_iter_simple_qual (taglist, mode, schema, path, - value, schema_map); - } else { - metadataparse_xmp_iter_simple (taglist, mode, schema, path, value, - schema_map); - } - } - } else if (XMP_IS_PROP_ARRAY (opt)) { - /* FIXME: array with merge mode */ - GstTagMergeMode new_mode = mode; - -#if 0 - //const gchar *tag = ; - if (mode == GST_TAG_MERGE_REPLACE) { - //gst_tag_list_remove_tag(taglist, ); - } -#endif - if (XMP_IS_ARRAY_ALTTEXT (opt)) { - metadataparse_xmp_iter_array (taglist, new_mode, xmp, schema, path, - schema_map); - xmp_iterator_skip (xmp_iter, XMP_ITER_SKIPSUBTREE); - } else { - metadataparse_xmp_iter_array (taglist, new_mode, xmp, schema, path, - schema_map); - xmp_iterator_skip (xmp_iter, XMP_ITER_SKIPSUBTREE); - } - } - - } - -done: - - if (xmp_iter) - xmp_iterator_free (xmp_iter); - - if (xstr_prop) - xmp_string_free (xstr_prop); - - if (xstr_path) - xmp_string_free (xstr_path); - - if (xstr_schema) - xmp_string_free (xstr_schema); - -} - -void -metadataparse_xmp_iter_node_schema (GstTagList * taglist, GstTagMergeMode mode, - XmpPtr xmp, const char *schema, const char *path) -{ - SchemaMap *schema_map = NULL; - - if (0 == strcmp (schema, "http://purl.org/dc/elements/1.1/")) { - schema_map = (SchemaMap *) & schema_map_dublin; - } - - metadataparse_xmp_iter_array (taglist, mode, xmp, schema, path, schema_map); -} +/* + * metadataparse_xmp_iter: + * @taglist: tag list in which extracted tags will be added + * @mode: tag list merge mode + * @xmp: handle to XMP data from lib exempi + * + * This function looks all the shemas in a XMP data (@xmp) and then calls + * #metadataparse_xmp_iter_node_schema for each schema. In the end, the idea is + * to add all XMP mapped tags to @taglist by unsing a specified merge @mode + * @see_also: #metadataparse_xmp_tag_list_add + * #metadataparse_xmp_iter_node_schema + * + * Returns: nothing + */ void metadataparse_xmp_iter (GstTagList * taglist, GstTagMergeMode mode, XmpPtr xmp) @@ -462,10 +536,263 @@ done: xmp_string_free (xstr_schema); } +/* + * metadataparse_xmp_iter_node_schema: + * @taglist: tag list in which extracted tags will be added + * @mode: tag list merge mode + * @xmp: handle to XMP data from lib exempi + * @schema: schema name string + * @path: schema path + * + * This function gets a @schema, finds the #SchemaMap (structure + * containing @schema description and map with GST tags) to it. And then call + * #metadataparse_xmp_iter_array. In the end, the idea is + * to add all XMP Schema mapped tags to @taglist by unsing a specified + * merge @mode + * @see_also: #metadataparse_xmp_iter + * #metadataparse_xmp_iter_array + * + * Returns: nothing + */ + +void +metadataparse_xmp_iter_node_schema (GstTagList * taglist, GstTagMergeMode mode, + XmpPtr xmp, const char *schema, const char *path) +{ + SchemaMap *schema_map = NULL; + + if (0 == strcmp (schema, "http://purl.org/dc/elements/1.1/")) { + schema_map = (SchemaMap *) & schema_map_dublin; + } + + metadataparse_xmp_iter_array (taglist, mode, xmp, schema, path, schema_map); +} + +/* + * metadataparse_xmp_iter_array: + * @taglist: tag list in which extracted tags will be added + * @mode: tag list merge mode + * @xmp: handle to XMP data from lib exempi + * @schema: schema name string + * @path: schema path + * @schema_map: structure containing @schema description and map with GST tags + * + * This function looks all the tags into a @schema and call other functions in + * order to add the mapped ones to @taglist by using a specified merge @mode + * @see_also: #metadataparse_xmp_iter_node_schema + * #metadataparse_xmp_iter_simple_qual metadataparse_xmp_iter_simple + * + * Returns: nothing + */ + +void +metadataparse_xmp_iter_array (GstTagList * taglist, GstTagMergeMode mode, + XmpPtr xmp, const char *schema, const char *path, + const SchemaMap * schema_map) +{ + XmpStringPtr xstr_schema = xmp_string_new (); + XmpStringPtr xstr_path = xmp_string_new (); + XmpStringPtr xstr_prop = xmp_string_new (); + uint32_t opt = 0; + XmpIteratorPtr xmp_iter = NULL; + + xmp_iter = xmp_iterator_new (xmp, schema, path, XMP_ITER_JUSTCHILDREN); + + if (NULL == xmp_iter) + goto done; + + while (xmp_iterator_next (xmp_iter, xstr_schema, xstr_path, xstr_prop, &opt)) { + const char *schema = xmp_string_cstr (xstr_schema); + const char *path = xmp_string_cstr (xstr_path); + const char *value = xmp_string_cstr (xstr_prop); + + if (XMP_IS_NODE_SCHEMA (opt)) { + GST_LOG ("Unexpected iteraction"); + } else if (XMP_IS_PROP_SIMPLE (opt)) { + if (strcmp (path, "") != 0) { + if (XMP_HAS_PROP_QUALIFIERS (opt)) { + /* ignore language qualifier, just get the first */ + metadataparse_xmp_iter_simple_qual (taglist, mode, path, value, + schema_map); + } else { + metadataparse_xmp_iter_simple (taglist, mode, path, value, + schema_map); + } + } + } else if (XMP_IS_PROP_ARRAY (opt)) { + /* FIXME: array with merge mode */ + GstTagMergeMode new_mode = mode; + +#if 0 + //const gchar *tag = ; + if (mode == GST_TAG_MERGE_REPLACE) { + //gst_tag_list_remove_tag(taglist, ); + } +#endif + if (XMP_IS_ARRAY_ALTTEXT (opt)) { + metadataparse_xmp_iter_array (taglist, new_mode, xmp, schema, path, + schema_map); + xmp_iterator_skip (xmp_iter, XMP_ITER_SKIPSUBTREE); + } else { + metadataparse_xmp_iter_array (taglist, new_mode, xmp, schema, path, + schema_map); + xmp_iterator_skip (xmp_iter, XMP_ITER_SKIPSUBTREE); + } + } + + } + +done: + + if (xmp_iter) + xmp_iterator_free (xmp_iter); + + if (xstr_prop) + xmp_string_free (xstr_prop); + + if (xstr_path) + xmp_string_free (xstr_path); + + if (xstr_schema) + xmp_string_free (xstr_schema); + +} + +/* + * metadataparse_xmp_iter_simple_qual: + * @taglist: tag list in which extracted tags will be added + * @mode: tag list merge mode + * @path: schema path + * @value: value of the (@path) tag + * @schema_map: structure containing @schema description and map with GST tags + * + * This function gets a XMP tag (@path) with quilifiers and try to add it + * to @taglist by calling #metadataparse_xmp_iter_add_to_tag_list + * @see_also: #metadataparse_xmp_iter_array + * #metadataparse_xmp_iter_simple #metadataparse_xmp_iter_add_to_tag_list + * + * Returns: nothing + */ + +void +metadataparse_xmp_iter_simple_qual (GstTagList * taglist, GstTagMergeMode mode, + const char *path, const char *value, const SchemaMap * schema_map) +{ + GString *string = g_string_new (path); + +#ifndef GST_DISABLE_GST_DEBUG + gchar *ch; + + /* remove the language qualifier */ + ch = string->str + string->len - 3; + while (ch != string->str + schema_map->prefix_len) { + if (*ch == '[') { + *ch = '\0'; + } + --ch; + } + GST_LOG (" %s = %s", string->str, value); +#endif /* #ifndef GST_DISABLE_GST_DEBUG */ + + metadataparse_xmp_iter_add_to_tag_list (taglist, mode, path, value, + schema_map, XMP_PROP_HAS_QUALIFIERS); + + g_string_free (string, TRUE); +} + +/* + * metadataparse_xmp_iter_simple: + * @taglist: tag list in which extracted tags will be added + * @mode: tag list merge mode + * @path: schema path + * @value: value of the (@path) tag + * @schema_map: structure containing @schema description and map with GST tags + * + * This function gets a simple XMP tag (@path) and try to add it to @taglist by + * calling # metadataparse_xmp_iter_add_to_tag_list + * @see_also: #metadataparse_xmp_iter_array + * #metadataparse_xmp_iter_simple_qual #metadataparse_xmp_iter_add_to_tag_list + * + * Returns: nothing + */ + +void +metadataparse_xmp_iter_simple (GstTagList * taglist, GstTagMergeMode mode, + const char *path, const char *value, const SchemaMap * schema_map) +{ + GST_LOG (" %s = %s", path, value); + + metadataparse_xmp_iter_add_to_tag_list (taglist, mode, path, value, + schema_map, 0); + +} + +/* + * metadataparse_xmp_iter_add_to_tag_list: + * @taglist: tag list in which extracted tags will be added + * @mode: tag list merge mode + * @path: schema path + * @value: value of the (@path) tag + * @schema_map: structure containing @schema description and map with GST tags + * @opt: indicates if the string (@path) has extras caracters like '[' and ']' + * + * This function gets a XMP tag (@path) and see if it is mapped to a GST tag by + * calling #metadataparse_xmp_get_tagsmap_from_path, if so, add it to @taglist + * by using a specified merge @mode + * @see_also: #metadataparse_xmp_iter_simple_qual + * #metadataparse_xmp_iter_simple #metadataparse_xmp_get_tagsmap_from_path + * + * Returns: nothing + */ static void -metadataxmp_for_each_tag_in_list (const GstTagList * list, const gchar * tag, - gpointer user_data) +metadataparse_xmp_iter_add_to_tag_list (GstTagList * taglist, + GstTagMergeMode mode, const char *path, const char *value, + const SchemaMap * schema_map, const uint32_t opt) +{ + + const SchemaTagMap *smaptag = + metadataparse_xmp_get_tagsmap_from_path (schema_map, path, opt); + + if (NULL == smaptag) + goto done; + + if (NULL == smaptag->gst_tag) + goto done; + + GType type = gst_tag_get_type (smaptag->gst_tag); + + switch (type) { + case G_TYPE_STRING: + gst_tag_list_add (taglist, mode, smaptag->gst_tag, value, NULL); + break; + default: + break; + } + +done: + + return; + +} + +/* + * metadatamux_xmp_for_each_tag_in_list: + * @list: GStreamer tag list from which @tag belongs to + * @tag: GStreamer tag to be added to the XMP chunk + * @user_data: pointer to #XmpPtr in which the tag will be added + * + * This function designed to be called for each tag in GST tag list. This + * function adds get the tag value from tag @list and then add it to the XMP + * chunk by using #XmpPtr and related functions from lib exempi + * @see_also: #metadatamux_xmp_create_chunk_from_tag_list + * + * Returns: nothing + */ + +static void +metadatamux_xmp_for_each_tag_in_list (const GstTagList * list, + const gchar * tag, gpointer user_data) { XmpPtr xmp = (XmpPtr) user_data; int i; @@ -474,7 +801,7 @@ metadataxmp_for_each_tag_in_list (const GstTagList * list, const gchar * tag, const SchemaMap *smap = schemas_map[i]; const SchemaTagMap *stagmap = - metadataparse_get_tagsmap_from_gsttag (smap, tag); + metadatamux_xmp_get_tagsmap_from_gsttag (smap, tag); if (stagmap) { @@ -501,56 +828,4 @@ metadataxmp_for_each_tag_in_list (const GstTagList * list, const gchar * tag, } -void -metadatamux_xmp_create_chunk_from_tag_list (guint8 ** buf, guint32 * size, - const GstTagList * taglist) -{ - GstBuffer *xmp_chunk = NULL; - const GValue *val = NULL; - XmpPtr xmp = NULL; - XmpStringPtr xmp_str_buf = xmp_string_new (); - - if (!(buf && size)) - goto done; - if (*buf) { - g_free (*buf); - *buf = NULL; - } - *size = 0; - - val = gst_tag_list_get_value_index (taglist, GST_TAG_XMP, 0); - if (val) { - xmp_chunk = gst_value_get_buffer (val); - if (xmp_chunk) - xmp = xmp_new (GST_BUFFER_DATA (xmp_chunk), GST_BUFFER_SIZE (xmp_chunk)); - } - - if (NULL == xmp) - xmp = xmp_new_empty (); - - gst_tag_list_foreach (taglist, metadataxmp_for_each_tag_in_list, xmp); - - if (!xmp_serialize (xmp, xmp_str_buf, 0, 2)) { - GST_ERROR ("failed to serialize xmp into chunk\n"); - } else if (xmp_str_buf) { - unsigned int len = strlen (xmp_string_cstr (xmp_str_buf)); - - *size = len + 1; - *buf = malloc (*size); - memcpy (*buf, xmp_string_cstr (xmp_str_buf), *size); - } else { - GST_ERROR ("failed to serialize xmp into chunk\n"); - } - -done: - - if (xmp_str_buf) - xmp_string_free (xmp_str_buf); - - if (xmp) - xmp_free (xmp); - - return; -} - #endif /* else (ifndef HAVE_XMP) */ diff --git a/ext/metadata/metadataxmp.h b/ext/metadata/metadataxmp.h index 73a53241c7..831b563f18 100644 --- a/ext/metadata/metadataxmp.h +++ b/ext/metadata/metadataxmp.h @@ -50,14 +50,18 @@ G_BEGIN_DECLS +/* + * external function prototypes + */ + +extern gboolean metadata_xmp_init (void); + +extern void metadata_xmp_dispose (void); + extern void metadataparse_xmp_tag_list_add (GstTagList * taglist, GstTagMergeMode mode, GstAdapter * adapter, MetadataTagMapping mapping); -extern gboolean metadataparse_xmp_init (void); - -extern void metadataparse_xmp_dispose (void); - extern void metadatamux_xmp_create_chunk_from_tag_list (guint8 ** buf, guint32 *size, const GstTagList * taglist); diff --git a/ext/metadata/test/Makefile b/ext/metadata/test/Makefile deleted file mode 100644 index dfcd3f7358..0000000000 --- a/ext/metadata/test/Makefile +++ /dev/null @@ -1,16 +0,0 @@ - -CC=gcc -CFLAGS=-c -Wall -g3 -O0 `pkg-config --cflags gstreamer-0.10 libglade-2.0 gtk+-2.0` -CLIBS=-lgstinterfaces-0.10 -Wl -export-dynamic `pkg-config --libs gstreamer-0.10 libglade-2.0 gtk+-2.0` - -all: metadata_editor - -metadata_editor: metadata_editor.o - $(CC) $(CLIBS) metadata_editor.o -o metadata_editor - -metadata_editor.o: metadata_editor.c - $(CC) $(CFLAGS) metadata_editor.c - -clean: - rm -rf *.o metadata_editor - diff --git a/tests/icles/Makefile.am b/tests/icles/Makefile.am index da44e312d5..26a5453ae2 100644 --- a/tests/icles/Makefile.am +++ b/tests/icles/Makefile.am @@ -11,9 +11,27 @@ else GST_SOUNDTOUCH_TESTS = endif +if USE_METADATA + +GST_METADATA_TESTS = metadata_editor + +metadata_editor_SOURCES = metadata_editor.c +metadata_editor_CFLAGS = $(GST_CFLAGS) \ + `pkg-config --cflags gstreamer-0.10 libglade-2.0 gtk+-2.0` +metadata_editor_LDADD = $(GST_LIBS) +metadata_editor_LDFLAGS = $(GST_PLUGIN_LDFLAGS) \ + -Wl -export-dynamic \ + -lgstinterfaces-0.10 \ + `pkg-config --libs gstreamer-0.10 libglade-2.0 gtk+-2.0` + +else +GST_METADATA_TESTS = +endif + + equalizer_test_SOURCES = equalizer-test.c equalizer_test_CFLAGS = $(GST_CFLAGS) equalizer_test_LDADD = $(GST_LIBS) equalizer_test_LDFLAGS = $(GST_PLUGIN_LDFLAGS) -noinst_PROGRAMS = $(GST_SOUNDTOUCH_TESTS) equalizer-test +noinst_PROGRAMS = $(GST_SOUNDTOUCH_TESTS) $(GST_METADATA_TESTS) equalizer-test diff --git a/ext/metadata/test/metadata_editor.c b/tests/icles/metadata_editor.c similarity index 99% rename from ext/metadata/test/metadata_editor.c rename to tests/icles/metadata_editor.c index f24f999441..69d9c29ab6 100644 --- a/ext/metadata/test/metadata_editor.c +++ b/tests/icles/metadata_editor.c @@ -523,7 +523,7 @@ ui_create () { int ret = 0; - ui_glade_xml = glade_xml_new ("MetadataEditorMain.glade", NULL, NULL); + ui_glade_xml = glade_xml_new ("metadata_editor.glade", NULL, NULL); if (!ui_glade_xml) { fprintf (stderr, "glade_xml_new failed\n"); diff --git a/ext/metadata/test/MetadataEditorMain.glade b/tests/icles/metadata_editor.glade similarity index 100% rename from ext/metadata/test/MetadataEditorMain.glade rename to tests/icles/metadata_editor.glade