mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-10-04 17:52:29 +00:00
Code Issues 1 Projects Releases Wiki Activity

Added new module for common functions. Using GST_TYPE_FRACTION for Exif (S)Rational types.

Browse source 
Original commit message from CVS:
Added new module for common functions. Using GST_TYPE_FRACTION for Exif (S)Rational types.
This commit is contained in:
Edgard Lima 2007-12-14 18:18:37 +00:00
parent 91bb79004f
commit b2a023be7b
13 changed files with 1312 additions and 1619 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
ChangeLog
View file

@ -1,3 +1,22 @@
2007-12-14 Edgard Lima,,,, <edgard.lima@indt.org.br>
* ext/metadata/Makefile.am:
* ext/metadata/TODO:
* ext/metadata/gstmetadata.c:
* ext/metadata/gstmetadatacommon.c:
* ext/metadata/gstmetadatacommon.h:
* ext/metadata/gstmetadatademux.c:
* ext/metadata/gstmetadatademux.h:
* ext/metadata/gstmetadatamux.c:
* ext/metadata/gstmetadatamux.h:
* ext/metadata/gstmetadataparse.c:
* ext/metadata/gstmetadataparse.h:
* ext/metadata/metadataexif.c:
* ext/metadata/metadatatags.c:
* ext/metadata/test/metadata_editor.c:
Added new module for common functions. Using GST_TYPE_FRACTION for
Exif (S)Rational types.
2007-12-14 Zaheer Abbas Merali <zaheerabbas at merali dot org>
* gst/mpegtsparse/mpegtspacketizer.c:

9
ext/metadata/Makefile.am
View file

@ -1,7 +1,8 @@
plugin_LTLIBRARIES = libgstmetadata.la
libgstmetadata_la_SOURCES = gstmetadata.c \
gstmetadataparse.c \
gstmetadatacommon.c \
gstmetadatademux.c \
metadata.c \
metadataparsejpeg.c \
metadatamuxjpeg.c \
@ -15,11 +16,15 @@ libgstmetadata_la_SOURCES = gstmetadata.c \
gstmetadatamux.c \
metadatatags.c
libgstmetadata_ladir = $(includedir)/gstreamer-@GST_MAJORMINOR@/metadata
libgstmetadata_la_HEADERS = metadatatags.h
libgstmetadata_la_CFLAGS = $(METADATA_CFLAGS) $(GST_PLUGINS_BASE_CFLAGS) $(GST_BASE_CFLAGS)
libgstmetadata_la_LIBADD = $(METADATA_LIBS) -lgsttag-@GST_MAJORMINOR@ $(GST_PLUGINS_BASE_LIBS) $(GST_BASE_LIBS)
libgstmetadata_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
noinst_HEADERS = gstmetadataparse.h \
noinst_HEADERS = gstmetadatademux.h \
gstmetadatacommon.h \
metadata.h \
metadataparsejpeg.h \
metadatamuxjpeg.h \

10
ext/metadata/TODO
View file

@ -4,10 +4,9 @@ This file contains a list of things to be done as well some open issues (questio
TODO:
1- Add individual tags IPTC and XMP (and more for EXIF)
2- Use GST_TYPE_FRACTION for Rational and SRational (metadataexif.c)
3- Get properties like 'width' and 'height' from caps
4- Review the code (in order to move to gst-plugins-good)
5- Document how the plugin works (atchitecture and interaction beteween modules)
2- Get properties like 'width' and 'height' from caps
3- Review the code (in order to move to gst-plugins-good)
4- Document how the plugin works (atchitecture and interaction beteween modules)
OPEN ISSUES:
@ -15,4 +14,7 @@ OPEN ISSUES:
2- How to change metadata when the orignal image was modified.
ex: file.jpeg has XMP, then we do filesrc ! metadataparse ! jpegdec ! pngenc ! metadatamux ! files
is the metadata still valid? which fields are no valid anymore?
3- Add GST_TYPE_FRACTION support for GStreamer TAGS
4- Have parse, demux and mux? (or just demux and must) see issue (5)
5- After decided issue (4) put more things to gstmetadatacommon (or else create a Class)

6
ext/metadata/gstmetadata.c
View file

@ -49,7 +49,7 @@
#include "metadatatags.h"
extern gboolean gst_metadata_parse_plugin_init (GstPlugin * plugin);
extern gboolean gst_metadata_demux_plugin_init (GstPlugin * plugin);
extern gboolean gst_metadata_mux_plugin_init (GstPlugin * plugin);
GST_DEBUG_CATEGORY_EXTERN (gst_metadata_exif_debug);
@ -71,7 +71,7 @@ plugin_init (GstPlugin * plugin)
metadata_tags_register ();
ret = gst_metadata_parse_plugin_init (plugin);
ret = gst_metadata_demux_plugin_init (plugin);
ret = ret && gst_metadata_mux_plugin_init (plugin);
@ -82,5 +82,5 @@ plugin_init (GstPlugin * plugin)
GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
GST_VERSION_MINOR,
"metadata",
"Metadata (EXIF, IPTC and XMP) image (JPEG, TIFF) parser and muxer",
"Metadata (EXIF, IPTC and XMP) image (JPEG, TIFF) demuxer and muxer",
plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN)

631
ext/metadata/gstmetadatacommon.c Normal file
View file

@ -0,0 +1,631 @@
/*
* GStreamer
* Copyright 2007 Edgard Lima <edgard.lima@indt.org.br>
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Alternatively, the contents of this file may be used under the
* GNU Lesser General Public License Version 2.1 (the "LGPL"), in
* which case the following provisions apply instead of the ones
* mentioned above:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/**
* SECTION:metadatamux-metadata
*
* <refsect2>
* <title>Example launch line</title>
* <para>
* <programlisting>
* gst-launch -v -m filesrc location=./test.jpeg ! metadatamux ! fakesink silent=TRUE
* </programlisting>
* </para>
* </refsect2>
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <string.h>
/*
* static functions declaration
*/
#include "gstmetadatacommon.h"
/*
* offset - offset of buffer in original stream
* size - size of buffer
* seg_offset - offset of segment in original stream
* seg_size - size of segment
* boffset - offset inside buffer where segment starts (-1 for no intersection)
* bsize - size of intersection
* seg_binter - if segment start inside buffer is zero. if segment start before
* buffer and intersect, it is the offset inside segment.
*
* ret:
* -1 - segment before buffer
* 0 - segment intersects
* 1 - segment after buffer
*/
static int
gst_metadata_common_get_strip_seg (const gint64 offset, guint32 size,
const gint64 seg_offset, const guint32 seg_size,
gint64 * boffset, guint32 * bsize, guint32 * seg_binter)
{
int ret = -1;
*boffset = -1;
*bsize = 0;
*seg_binter = -1;
/* all segment after buffer */
if (seg_offset >= offset + size) {
ret = 1;
goto done;
}
if (seg_offset < offset) {
/* segment start somewhere before buffer */
/* all segment before buffer */
if (seg_offset + seg_size <= offset) {
ret = -1;
goto done;
}
*seg_binter = offset - seg_offset;
*boffset = 0;
/* FIXME : optimize to >= size -> = size */
if (seg_offset + seg_size >= offset + size) {
/* segment cover all buffer */
*bsize = size;
} else {
/* segment goes from start of buffer to somewhere before end */
*bsize = seg_size - *seg_binter;
}
ret = 0;
} else {
/* segment start somewhere into buffer */
*boffset = seg_offset - offset;
*seg_binter = 0;
if (seg_offset + seg_size <= offset + size) {
/* all segment into buffer */
*bsize = seg_size;
} else {
*bsize = size - *boffset;
}
ret = 0;
}
done:
return ret;
}
/*
* extern functions declaration
*/
void
gst_metadata_common_init (GstMetadataCommon * common, gboolean parse,
guint8 options)
{
metadata_init (&common->metadata, parse, options);
}
void
gst_metadata_common_dispose (GstMetadataCommon * common)
{
if (common->append_buffer) {
gst_buffer_unref (common->append_buffer);
common->append_buffer = NULL;
}
metadata_dispose (&common->metadata);
}
/*
/*
* TRUE -> buffer striped or injeted
* FALSE -> buffer unmodified
*/
gboolean
gst_metadata_common_strip_push_buffer (GstMetadataCommon * common,
gint64 offset_orig, GstBuffer ** prepend, GstBuffer ** buf)
{
MetadataChunk *strip = common->metadata.strip_chunks.chunk;
MetadataChunk *inject = common->metadata.inject_chunks.chunk;
const gsize strip_len = common->metadata.strip_chunks.len;
const gsize inject_len = common->metadata.inject_chunks.len;
gboolean buffer_reallocated = FALSE;
guint32 size_buf_in = GST_BUFFER_SIZE (*buf);
gint64 *boffset_strip = NULL;
guint32 *bsize_strip = NULL;
guint32 *seg_binter_strip = NULL;
int i, j;
gboolean need_free_strip = FALSE;
guint32 striped_bytes = 0;
guint32 injected_bytes = 0;
guint32 prepend_size = prepend && *prepend ? GST_BUFFER_SIZE (*prepend) : 0;
if (inject_len) {
for (i = 0; i < inject_len; ++i) {
int res;
if (inject[i].offset_orig >= offset_orig) {
if (inject[i].offset_orig < offset_orig + size_buf_in) {
injected_bytes += inject[i].size;
} else {
/* segment is after size (segments are sorted) */
break;
}
}
}
}
/*
* strip segments
*/
if (strip_len == 0)
goto inject;
if (G_UNLIKELY (strip_len > 16)) {
boffset_strip = g_new (gint64, strip_len);
bsize_strip = g_new (guint32, strip_len);
seg_binter_strip = g_new (guint32, strip_len);
need_free_strip = TRUE;
} else {
boffset_strip = g_alloca (sizeof (boffset_strip[0]) * strip_len);
bsize_strip = g_alloca (sizeof (bsize_strip[0]) * strip_len);
seg_binter_strip = g_alloca (sizeof (seg_binter_strip[0]) * strip_len);
}
memset (bsize_strip, 0x00, sizeof (bsize_strip[0]) * strip_len);
for (i = 0; i < strip_len; ++i) {
int res;
res = gst_metadata_common_get_strip_seg (offset_orig, size_buf_in,
strip[i].offset_orig, strip[i].size, &boffset_strip[i], &bsize_strip[i],
&seg_binter_strip[i]);
/* segment is after size (segments are sorted) */
striped_bytes += bsize_strip[i];
if (res > 0) {
break;
}
}
if (striped_bytes) {
guint8 *data;
if (!buffer_reallocated) {
buffer_reallocated = TRUE;
if (injected_bytes + prepend_size > striped_bytes) {
GstBuffer *new_buf =
gst_buffer_new_and_alloc (GST_BUFFER_SIZE (*buf) + injected_bytes +
prepend_size - striped_bytes);
memcpy (GST_BUFFER_DATA (new_buf), GST_BUFFER_DATA (*buf),
GST_BUFFER_SIZE (*buf));
gst_buffer_unref (*buf);
*buf = new_buf;
} else if (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY)) {
GstBuffer *new_buf = gst_buffer_copy (*buf);
gst_buffer_unref (*buf);
*buf = new_buf;
GST_BUFFER_FLAG_UNSET (*buf, GST_BUFFER_FLAG_READONLY);
GST_BUFFER_SIZE (*buf) += injected_bytes + prepend_size - striped_bytes;
}
}
data = GST_BUFFER_DATA (*buf);
striped_bytes = 0;
for (i = 0; i < strip_len; ++i) {
/* intersect */
if (bsize_strip[i]) {
memmove (data + boffset_strip[i] - striped_bytes,
data + boffset_strip[i] + bsize_strip[i] - striped_bytes,
size_buf_in - boffset_strip[i] - bsize_strip[i]);
striped_bytes += bsize_strip[i];
}
}
size_buf_in -= striped_bytes;
}
inject:
/*
* inject segments
*/
if (inject_len) {
guint8 *data;
guint32 striped_so_far;
if (!buffer_reallocated) {
buffer_reallocated = TRUE;
if (injected_bytes + prepend_size > striped_bytes) {
GstBuffer *new_buf =
gst_buffer_new_and_alloc (GST_BUFFER_SIZE (*buf) + injected_bytes +
prepend_size - striped_bytes);
memcpy (GST_BUFFER_DATA (new_buf), GST_BUFFER_DATA (*buf),
GST_BUFFER_SIZE (*buf));
gst_buffer_unref (*buf);
*buf = new_buf;
} else if (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY)) {
GstBuffer *new_buf = gst_buffer_copy (*buf);
gst_buffer_unref (*buf);
*buf = new_buf;
GST_BUFFER_FLAG_UNSET (*buf, GST_BUFFER_FLAG_READONLY);
GST_BUFFER_SIZE (*buf) += injected_bytes + prepend_size - striped_bytes;
}
}
data = GST_BUFFER_DATA (*buf);
injected_bytes = 0;
striped_so_far = 0;
j = 0;
for (i = 0; i < inject_len; ++i) {
int res;
while (j < strip_len) {
if (strip[j].offset_orig < inject[i].offset_orig)
striped_so_far += bsize_strip[j++];
else
break;
}
if (inject[i].offset_orig >= offset_orig) {
if (inject[i].offset_orig <
offset_orig + size_buf_in + striped_bytes - injected_bytes) {
/* insert */
guint32 buf_off =
inject[i].offset_orig - offset_orig - striped_so_far +
injected_bytes;
memmove (data + buf_off + inject[i].size, data + buf_off,
size_buf_in - buf_off);
memcpy (data + buf_off, inject[i].data, inject[i].size);
injected_bytes += inject[i].size;
size_buf_in += inject[i].size;
} else {
/* segment is after size (segments are sorted) */
break;
}
}
}
}
done:
if (prepend_size) {
if (injected_bytes == 0 && striped_bytes == 0) {
GstBuffer *new_buf =
gst_buffer_new_and_alloc (size_buf_in + prepend_size);
memcpy (GST_BUFFER_DATA (new_buf) + prepend_size, GST_BUFFER_DATA (*buf),
size_buf_in);
gst_buffer_unref (*buf);
*buf = new_buf;
} else {
memmove (GST_BUFFER_DATA (*buf) + prepend_size, GST_BUFFER_DATA (*buf),
size_buf_in);
}
memcpy (GST_BUFFER_DATA (*buf), GST_BUFFER_DATA (*prepend), prepend_size);
gst_buffer_unref (*prepend);
*prepend = NULL;
}
GST_BUFFER_SIZE (*buf) = size_buf_in + prepend_size;
if (need_free_strip) {
g_free (boffset_strip);
g_free (bsize_strip);
g_free (seg_binter_strip);
}
return injected_bytes || striped_bytes;
}
/*
* pos - position in stream striped
* orig_pos - position in original stream
* return TRUE - position in original buffer
* FALSE - position in inserted chunk
*/
gboolean
gst_metadata_common_translate_pos_to_orig (GstMetadataCommon * common,
gint64 pos, gint64 * orig_pos, GstBuffer ** buf)
{
MetadataChunk *strip = common->metadata.strip_chunks.chunk;
MetadataChunk *inject = common->metadata.inject_chunks.chunk;
const gsize strip_len = common->metadata.strip_chunks.len;
const gsize inject_len = common->metadata.inject_chunks.len;
const gint64 duration_orig = common->duration_orig;
const gint64 duration = common->duration;
int i;
gboolean ret = TRUE;
guint64 new_buf_size = 0;
guint64 injected_before = 0;
if (G_UNLIKELY (pos == -1)) {
*orig_pos = -1;
return TRUE;
} else if (G_UNLIKELY (pos >= duration)) {
/* this should never happen */
*orig_pos = duration_orig;
return TRUE;
}
/* calculate for injected */
/* just calculate size */
*orig_pos = pos; /* save pos */
for (i = 0; i < inject_len; ++i) {
/* check if pos in inside chunk */
if (inject[i].offset <= pos) {
if (pos < inject[i].offset + inject[i].size) {
/* orig pos points after insert chunk */
new_buf_size += inject[i].size;
/* put pos after current chunk */
pos = inject[i].offset + inject[i].size;
ret = FALSE;
} else {
/* in case pos is not inside a injected chunk */
injected_before += inject[i].size;
}
} else {
break;
}
}
/* alloc buffer and calcute original pos */
if (buf && ret == FALSE) {
guint8 *data;
if (*buf)
gst_buffer_unref (*buf);
*buf = gst_buffer_new_and_alloc (new_buf_size);
data = GST_BUFFER_DATA (*buf);
pos = *orig_pos; /* recover saved pos */
for (i = 0; i < inject_len; ++i) {
if (inject[i].offset > pos) {
break;
}
if (inject[i].offset <= pos && pos < inject[i].offset + inject[i].size) {
memcpy (data, inject[i].data, inject[i].size);
data += inject[i].size;
pos = inject[i].offset + inject[i].size;
/* out position after insert chunk orig */
*orig_pos = inject[i].offset_orig + inject[i].size;
}
}
}
if (ret == FALSE) {
/* if it inside a injected is already done */
goto done;
}
/* calculate for striped */
*orig_pos = pos - injected_before;
for (i = 0; i < strip_len; ++i) {
if (strip[i].offset_orig > pos) {
break;
}
*orig_pos += strip[i].size;
}
done:
if (G_UNLIKELY (*orig_pos >= duration_orig)) {
*orig_pos = duration_orig - 1;
}
return ret;
}
/*
* return:
* -1 -> error
* 0 -> succeded
* 1 -> need more data
*/
gboolean
gst_metadata_common_calculate_offsets (GstMetadataCommon * common)
{
int i, j;
guint32 append_size;
guint32 bytes_striped, bytes_inject;
MetadataChunk *strip = common->metadata.strip_chunks.chunk;
MetadataChunk *inject = common->metadata.inject_chunks.chunk;
gsize strip_len;
gsize inject_len;
if (common->state != MT_STATE_PARSED)
return FALSE;
metadata_lazy_update (&common->metadata);
strip_len = common->metadata.strip_chunks.len;
inject_len = common->metadata.inject_chunks.len;
bytes_striped = 0;
bytes_inject = 0;
/* calculate the new position off injected chunks */
j = 0;
for (i = 0; i < inject_len; ++i) {
for (; j < strip_len; ++j) {
if (strip[j].offset_orig >= inject[i].offset_orig) {
break;
}
bytes_striped += strip[j].size;
}
inject[i].offset = inject[i].offset_orig - bytes_striped + bytes_inject;
bytes_inject += inject[i].size;
}
/* calculate append (doesnt make much sense, but, anyway..) */
append_size = 0;
for (i = inject_len - 1; i >= 0; --i) {
if (inject[i].offset_orig == common->duration_orig)
append_size += inject[i].size;
else
break;
}
if (append_size) {
guint8 *data;
common->append_buffer = gst_buffer_new_and_alloc (append_size);
GST_BUFFER_FLAG_SET (common->append_buffer, GST_BUFFER_FLAG_READONLY);
data = GST_BUFFER_DATA (common->append_buffer);
for (i = inject_len - 1; i >= 0; --i) {
if (inject[i].offset_orig == common->duration_orig) {
memcpy (data, inject[i].data, inject[i].size);
data += inject[i].size;
} else {
break;
}
}
}
if (common->duration_orig) {
common->duration = common->duration_orig;
for (i = 0; i < inject_len; ++i) {
common->duration += inject[i].size;
}
for (i = 0; i < strip_len; ++i) {
common->duration -= strip[i].size;
}
}
return TRUE;
}
void
gst_metadata_common_update_segment_with_new_buffer (GstMetadataCommon * common,
guint8 ** buf, guint32 * size, MetadataChunkType type)
{
int i;
MetadataChunk *inject = common->metadata.inject_chunks.chunk;
const gsize inject_len = common->metadata.inject_chunks.len;
if (!(buf && size))
goto done;
if (*buf == 0)
goto done;
if (*size == 0)
goto done;
for (i = 0; i < inject_len; ++i) {
if (inject[i].type == type) {
inject[i].size = *size;
if (inject[i].data)
g_free (inject[i].data);
inject[i].data = *buf;
*size = 0;
*buf = 0;
break;
}
}
done:
return;
}
const gchar *
gst_metadata_common_get_type_name (int img_type)
{
gchar *type_name = NULL;
switch (img_type) {
case IMG_JPEG:
type_name = "jpeg";
break;
case IMG_PNG:
type_name = "png";
break;
default:
type_name = "invalid type";
break;
}
return type_name;
}

96
ext/metadata/gstmetadatacommon.h Normal file
View file

@ -0,0 +1,96 @@
/*
* GStreamer
* Copyright 2007 Edgard Lima <edgard.lima@indt.org.br>
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
* Alternatively, the contents of this file may be used under the
* GNU Lesser General Public License Version 2.1 (the "LGPL"), in
* which case the following provisions apply instead of the ones
* mentioned above:
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __GST_METADATA_COMMON_H__
#define __GST_METADATA_COMMON_H__
#include "metadata.h"
G_BEGIN_DECLS
typedef struct _GstMetadataCommon GstMetadataCommon;
typedef enum _tag_MetadataState
{
MT_STATE_NULL, /* still need to check media type */
MT_STATE_PARSED
} MetadataState;
struct _GstMetadataCommon {
MetaData metadata;
gint64 duration_orig; /* durarion of stream */
gint64 duration; /* durarion of modified stream */
GstBuffer * append_buffer;
MetadataState state;
};
extern void
gst_metadata_common_init(GstMetadataCommon *common, gboolean parse, guint8 options);
extern void
gst_metadata_common_dispose(GstMetadataCommon *common);
extern gboolean
gst_metadata_common_strip_push_buffer (GstMetadataCommon *common, gint64 offset_orig,
GstBuffer ** prepend, GstBuffer ** buf);
extern gboolean
gst_metadata_common_translate_pos_to_orig (GstMetadataCommon *common,
gint64 pos, gint64 * orig_pos, GstBuffer ** buf);
extern gboolean
gst_metadata_common_calculate_offsets (GstMetadataCommon *common);
extern void
gst_metadata_common_update_segment_with_new_buffer (GstMetadataCommon *common,
guint8 ** buf, guint32 * size, MetadataChunkType type);
extern const gchar *
gst_metadata_common_get_type_name (int img_type);
G_END_DECLS
#endif /* __GST_METADATA_COMMON_H__ */

890
ext/metadata/gstmetadataparse.c → ext/metadata/gstmetadatademux.c
View file

File diff suppressed because it is too large Load diff

52
ext/metadata/gstmetadataparse.h → ext/metadata/gstmetadatademux.h
View file

@ -41,45 +41,40 @@
* Boston, MA 02111-1307, USA.
*/
#ifndef __GST_METADATA_PARSE_H__
#define __GST_METADATA_PARSE_H__
#ifndef __GST_METADATA_DEMUX_H__
#define __GST_METADATA_DEMUX_H__
#include <gst/gst.h>
#include "metadata.h"
#include "gstmetadatacommon.h"
G_BEGIN_DECLS
/* #defines don't like whitespacey bits */
#define GST_TYPE_METADATA_PARSE \
(gst_metadata_parse_get_type())
#define GST_METADATA_PARSE(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_METADATA_PARSE,GstMetadataParse))
#define GST_METADATA_PARSE_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_METADATA_PARSE,GstMetadataParseClass))
#define GST_IS_METADATA_PARSE(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_METADATA_PARSE))
#define GST_IS_METADATA_PARSE_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_METADATA_PARSE))
typedef struct _GstMetadataParse GstMetadataParse;
typedef struct _GstMetadataParseClass GstMetadataParseClass;
#define GST_TYPE_METADATA_DEMUX \
(gst_metadata_demux_get_type())
#define GST_METADATA_DEMUX(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_METADATA_DEMUX,GstMetadataDemux))
#define GST_METADATA_DEMUX_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_METADATA_DEMUX,GstMetadataDemuxClass))
#define GST_IS_METADATA_DEMUX(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_METADATA_DEMUX))
#define GST_IS_METADATA_DEMUX_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_METADATA_DEMUX))
typedef struct _GstMetadataDemux GstMetadataDemux;
typedef struct _GstMetadataDemuxClass GstMetadataDemuxClass;
typedef enum _tag_MetadataState
{
MT_STATE_NULL, /* still need to check media type */
MT_STATE_PARSED
} MetadataState;
struct _GstMetadataParse
struct _GstMetadataDemux
{
GstElement element;
GstPad *sinkpad, *srcpad;
GstMetadataCommon common;
guint8 options;
gboolean need_send_tag;
MetaData parse_data;
GstAdapter *adapter_parsing;
GstAdapter *adapter_holding;
guint32 next_offset;
@ -87,14 +82,9 @@ struct _GstMetadataParse
ImageType img_type;
gint64 offset_orig; /* offset in original stream */
gint64 duration_orig; /* durarion of stream */
gint64 offset; /* offset in current stream */
gint64 duration; /* durarion of modified stream */
MetadataState state;
GstBuffer * prepend_buffer;
GstBuffer * append_buffer;
gboolean need_more_data;
@ -102,12 +92,12 @@ struct _GstMetadataParse
};
struct _GstMetadataParseClass
struct _GstMetadataDemuxClass
{
GstElementClass parent_class;
};
extern GType gst_metadata_parse_get_type (void);
extern GType gst_metadata_demux_get_type (void);
G_END_DECLS
#endif /* __GST_METADATA_PARSE_H__ */
#endif /* __GST_METADATA_DEMUX_H__ */

759
ext/metadata/gstmetadatamux.c
View file

File diff suppressed because it is too large Load diff

16
ext/metadata/gstmetadatamux.h
View file

@ -46,7 +46,7 @@
#include <gst/gst.h>
#include "metadata.h"
#include "gstmetadatacommon.h"
G_BEGIN_DECLS
/* #defines don't like whitespacey bits */
@ -63,21 +63,16 @@ G_BEGIN_DECLS
typedef struct _GstMetadataMux GstMetadataMux;
typedef struct _GstMetadataMuxClass GstMetadataMuxClass;
typedef enum _tag_MetadataState
{
MT_STATE_NULL, /* still need to check media type */
MT_STATE_MUXED
} MetadataState;
struct _GstMetadataMux
{
GstElement element;
GstPad *sinkpad, *srcpad;
GstMetadataCommon common;
guint8 options;
MetaData mux_data;
GstAdapter *adapter_parsing;
GstAdapter *adapter_holding;
guint32 next_offset;
@ -85,14 +80,9 @@ struct _GstMetadataMux
ImageType img_type;
gint64 offset_orig; /* offset in original stream */
gint64 duration_orig; /* durarion of stream */
gint64 offset; /* offset in current stream */
gint64 duration; /* durarion of modified stream */
MetadataState state;
GstBuffer * prepend_buffer;
GstBuffer * append_buffer;
gboolean need_more_data;

275
ext/metadata/metadataexif.c
View file

@ -89,7 +89,6 @@ typedef struct _tag_MapIntStr
{
ExifTag exif;
const gchar *str;
GType type;
} MapIntStr;
static void
@ -99,21 +98,21 @@ static void exif_content_foreach_entry_func (ExifEntry * entry, void *);
/* *INDENT-OFF* */
static MapIntStr mappedTags[] = {
{EXIF_TAG_MAKE, /*EXIF_FORMAT_ASCII,*/ GST_TAG_DEVICE_MAKE, G_TYPE_STRING},
{EXIF_TAG_MODEL, /*EXIF_FORMAT_ASCII,*/ GST_TAG_DEVICE_MODEL, G_TYPE_STRING},
{EXIF_TAG_SOFTWARE, /*EXIF_FORMAT_ASCII,*/ GST_TAG_CREATOR_TOOL, G_TYPE_STRING},
{EXIF_TAG_X_RESOLUTION, /*EXIF_FORMAT_RATIONAL,*/ GST_TAG_IMAGE_XRESOLUTION, G_TYPE_FLOAT}, /* inches */
{EXIF_TAG_Y_RESOLUTION, /*EXIF_FORMAT_RATIONAL,*/ GST_TAG_IMAGE_YRESOLUTION, G_TYPE_FLOAT}, /* inches */
{EXIF_TAG_EXPOSURE_TIME, /*EXIF_FORMAT_RATIONAL,*/ GST_TAG_CAPTURE_EXPOSURE_TIME, G_TYPE_FLOAT},
{EXIF_TAG_FNUMBER, /*EXIF_FORMAT_RATIONAL,*/ GST_TAG_CAPTURE_FNUMBER, G_TYPE_FLOAT},
{EXIF_TAG_EXPOSURE_PROGRAM, /*EXIF_FORMAT_SHORT,*/ GST_TAG_CAPTURE_EXPOSURE_PROGRAM, G_TYPE_UINT},
{EXIF_TAG_BRIGHTNESS_VALUE, /*EXIF_FORMAT_SRATIONAL,*/ GST_TAG_CAPTURE_BRIGHTNESS, G_TYPE_FLOAT},
{EXIF_TAG_WHITE_BALANCE, /*EXIF_FORMAT_SHORT,*/ GST_TAG_CAPTURE_WHITE_BALANCE, G_TYPE_UINT},
{EXIF_TAG_DIGITAL_ZOOM_RATIO, /*EXIF_FORMAT_RATIONAL,*/ GST_TAG_CAPTURE_DIGITAL_ZOOM, G_TYPE_FLOAT},
{EXIF_TAG_GAIN_CONTROL, /*EXIF_FORMAT_SHORT,*/ GST_TAG_CAPTURE_GAIN, G_TYPE_UINT},
{EXIF_TAG_CONTRAST, /*EXIF_FORMAT_SHORT,*/ GST_TAG_CAPTURE_CONTRAST, G_TYPE_INT},
{EXIF_TAG_SATURATION, /*EXIF_FORMAT_SHORT,*/ GST_TAG_CAPTURE_SATURATION, G_TYPE_INT},
{0, NULL, G_TYPE_NONE}
{EXIF_TAG_MAKE, /*ASCII,*/ GST_TAG_DEVICE_MAKE, /*STRING*/},
{EXIF_TAG_MODEL, /*ASCII,*/ GST_TAG_DEVICE_MODEL, /*STRING*/},
{EXIF_TAG_SOFTWARE, /*ASCII,*/ GST_TAG_CREATOR_TOOL, /*STRING*/},
{EXIF_TAG_X_RESOLUTION, /*RATIONAL,*/ GST_TAG_IMAGE_XRESOLUTION, /*FRACTION*/}, /* inches */
{EXIF_TAG_Y_RESOLUTION, /*RATIONAL,*/ GST_TAG_IMAGE_YRESOLUTION, /*FRACTION*/}, /* inches */
{EXIF_TAG_EXPOSURE_TIME, /*RATIONAL,*/ GST_TAG_CAPTURE_EXPOSURE_TIME, /*FRACTION*/},
{EXIF_TAG_FNUMBER, /*RATIONAL,*/ GST_TAG_CAPTURE_FNUMBER, /*FRACTION*/},
{EXIF_TAG_EXPOSURE_PROGRAM, /*SHORT,*/ GST_TAG_CAPTURE_EXPOSURE_PROGRAM, /*UINT*/},
{EXIF_TAG_BRIGHTNESS_VALUE, /*SRATIONAL,*/ GST_TAG_CAPTURE_BRIGHTNESS, /*FRACTION*/},
{EXIF_TAG_WHITE_BALANCE, /*SHORT,*/ GST_TAG_CAPTURE_WHITE_BALANCE, /*UINT*/},
{EXIF_TAG_DIGITAL_ZOOM_RATIO, /*RATIONAL,*/ GST_TAG_CAPTURE_DIGITAL_ZOOM, /*FRACTION*/},
{EXIF_TAG_GAIN_CONTROL, /*SHORT,*/ GST_TAG_CAPTURE_GAIN, /*UINT*/},
{EXIF_TAG_CONTRAST, /*SHORT,*/ GST_TAG_CAPTURE_CONTRAST, /*INT*/},
{EXIF_TAG_SATURATION, /*SHORT,*/ GST_TAG_CAPTURE_SATURATION, /*INT*/},
{0, NULL}
};
/* *INDENT-ON* */
@ -123,12 +122,13 @@ metadataparse_exif_get_tag_from_exif (ExifTag exif, GType * type)
int i = 0;
while (mappedTags[i].exif) {
if (exif == mappedTags[i].exif)
if (exif == mappedTags[i].exif) {
*type = gst_tag_get_type (mappedTags[i].str);
break;
}
++i;
}
*type = mappedTags[i].type;
return mappedTags[i].str;
}
@ -139,12 +139,13 @@ metadataparse_exif_get_exif_from_tag (const gchar * tag, GType * type)
int i = 0;
while (mappedTags[i].exif) {
if (0 == strcmp (mappedTags[i].str, tag))
if (0 == strcmp (mappedTags[i].str, tag)) {
*type = gst_tag_get_type (tag);
break;
}
++i;
}
*type = mappedTags[i].type;
return mappedTags[i].exif;
}
@ -257,61 +258,59 @@ exif_content_foreach_entry_func (ExifEntry * entry, void *user_data)
goto done;
}
if (tag) {
/* FIXME: create a generic function for this */
/* could also be used with entry->format */
if (!tag)
goto done;
if (type == GST_TYPE_FRACTION) {
gint numerator = 0;
gint denominator = 1;
switch (entry->format) {
case EXIF_FORMAT_SRATIONAL:
{
ExifSRational v_srat;
v_srat = exif_get_srational (entry->data, byte_order);
if (v_srat.denominator) {
numerator = (gint) v_srat.numerator;
denominator = (gint) v_srat.denominator;
}
}
break;
case EXIF_FORMAT_RATIONAL:
{
ExifRational v_rat;
v_rat = exif_get_rational (entry->data, byte_order);
if (v_rat.denominator) {
numerator = (gint) v_rat.numerator;
denominator = (gint) v_rat.denominator;
}
if (meudata->resolution_unit == 3) {
/* converts from cm to inches */
if (entry->tag == EXIF_TAG_X_RESOLUTION
|| entry->tag == EXIF_TAG_Y_RESOLUTION) {
numerator *= 2;
denominator *= 5;
}
}
}
break;
default:
GST_ERROR ("Unexpected Tag Type");
goto done;
break;
}
gst_tag_list_add (meudata->taglist, meudata->mode, tag, numerator,
denominator, NULL);
} else {
switch (type) {
case G_TYPE_STRING:
gst_tag_list_add (meudata->taglist, meudata->mode, tag,
exif_entry_get_value (entry, buf, sizeof (buf)), NULL);
break;
case G_TYPE_FLOAT:
{
gfloat f_value;
switch (entry->format) {
case EXIF_FORMAT_SRATIONAL:
{
ExifSRational v_srat;
v_srat = exif_get_srational (entry->data, byte_order);
if (v_srat.denominator == 0)
f_value = 0.0f;
else
f_value = (float) v_srat.numerator / (float) v_srat.denominator;
if (v_srat.numerator == 0xFFFFFFFF) {
if (entry->tag == EXIF_TAG_BRIGHTNESS_VALUE) {
f_value = 100.0f;
}
}
}
break;
case EXIF_FORMAT_RATIONAL:
{
ExifRational v_rat;
v_rat = exif_get_rational (entry->data, byte_order);
if (v_rat.denominator == 0)
f_value = 0.0f;
else
f_value = (float) v_rat.numerator / (float) v_rat.denominator;
if (meudata->resolution_unit == 3) {
/* converts from cm to inches */
if (entry->tag == EXIF_TAG_X_RESOLUTION
|| entry->tag == EXIF_TAG_Y_RESOLUTION) {
f_value *= 0.4f;
}
}
}
break;
default:
GST_ERROR ("Unexpected Tag Type");
goto done;
break;
}
gst_tag_list_add (meudata->taglist, meudata->mode, tag, f_value, NULL);
}
break;
case G_TYPE_INT:
/* fall through */
case G_TYPE_UINT:
@ -350,8 +349,10 @@ exif_content_foreach_entry_func (ExifEntry * entry, void *user_data)
default:
break;
}
}
done:
GST_LOG ("\n Entry %p: %s (%s)\n"
@ -465,90 +466,82 @@ metadataexif_for_each_tag_in_list (const GstTagList * list, const gchar * tag,
exif_entry_initialize (entry, exif_tag);
}
switch (type) {
case G_TYPE_STRING:
{
gchar *value = NULL;
if (type == GST_TYPE_FRACTION) {
const GValue *gvalue = gst_tag_list_get_value_index (list, tag, 0);
gint numerator = gst_value_get_fraction_numerator (gvalue);
gint denominator = gst_value_get_fraction_denominator (gvalue);
if (gst_tag_list_get_string (list, tag, &value)) {
entry->components = strlen (value) + 1;
entry->size = exif_format_get_size (entry->format) * entry->components;
entry->data = value;
switch (entry->format) {
case EXIF_FORMAT_SRATIONAL:
{
ExifSRational sr = { numerator, denominator };
exif_set_srational (entry->data, byte_order, sr);
}
}
break;
case G_TYPE_FLOAT:
{
gfloat value;
break;
case EXIF_FORMAT_RATIONAL:
{
ExifRational r = { numerator, denominator };
gst_tag_list_get_float (list, tag, &value);
exif_set_rational (entry->data, byte_order, r);
if (entry->tag == EXIF_TAG_X_RESOLUTION ||
entry->tag == EXIF_TAG_Y_RESOLUTION) {
ExifEntry *unit_entry = NULL;
switch (entry->format) {
case EXIF_FORMAT_SRATIONAL:
{
ExifSRational sr;
if ((unit_entry = exif_data_get_entry (ed, EXIF_TAG_RESOLUTION_UNIT))) {
ExifShort vsh = exif_get_short (unit_entry->data, byte_order);
sr = float_to_srational (value);
if (entry->tag == EXIF_TAG_BRIGHTNESS_VALUE) {
if (value == 100.0f) {
sr.numerator = 0xFFFFFFFF;
sr.denominator = 1;
}
}
exif_set_srational (entry->data, byte_order, sr);
}
break;
case EXIF_FORMAT_RATIONAL:
{
ExifRational r;
r = float_to_rational (value);
exif_set_rational (entry->data, byte_order, r);
if (entry->tag == EXIF_TAG_X_RESOLUTION ||
entry->tag == EXIF_TAG_Y_RESOLUTION) {
ExifEntry *unit_entry = NULL;
if ((unit_entry =
exif_data_get_entry (ed, EXIF_TAG_RESOLUTION_UNIT))) {
ExifShort vsh = exif_get_short (unit_entry->data, byte_order);
if (vsh != 2) /* inches */
exif_set_short (unit_entry->data, byte_order, 2);
}
if (vsh != 2) /* inches */
exif_set_short (unit_entry->data, byte_order, 2);
}
}
break;
default:
break;
}
break;
default:
break;
}
break;
case G_TYPE_UINT:
case G_TYPE_INT:
{
gint value;
ExifShort v_short;
} else {
if (G_TYPE_UINT == type) {
gst_tag_list_get_uint (list, tag, &value);
} else {
gst_tag_list_get_int (list, tag, &value);
switch (type) {
case G_TYPE_STRING:
{
gchar *value = NULL;
if (gst_tag_list_get_string (list, tag, &value)) {
entry->components = strlen (value) + 1;
entry->size =
exif_format_get_size (entry->format) * entry->components;
entry->data = value;
}
}
if (entry->tag == EXIF_TAG_CONTRAST || entry->tag == EXIF_TAG_SATURATION) {
if (value < -33)
value = 1; /* low */
else if (value < 34)
value = 0; /* normal */
else
value = 2; /* high */
break;
case G_TYPE_UINT:
case G_TYPE_INT:
{
gint value;
ExifShort v_short;
if (G_TYPE_UINT == type) {
gst_tag_list_get_uint (list, tag, &value);
} else {
gst_tag_list_get_int (list, tag, &value);
}
if (entry->tag == EXIF_TAG_CONTRAST
|| entry->tag == EXIF_TAG_SATURATION) {
if (value < -33)
value = 1; /* low */
else if (value < 34)
value = 0; /* normal */
else
value = 2; /* high */
}
v_short = value;
exif_set_short (entry->data, byte_order, v_short);
}
v_short = value;
exif_set_short (entry->data, byte_order, v_short);
break;
default:
break;
}
break;
default:
break;
}
done:

106
ext/metadata/metadatatags.c
View file

@ -49,39 +49,6 @@
static void
metadata_tags_exif_register (void)
{
gst_tag_register (GST_TAG_EXIF, GST_TAG_FLAG_META,
GST_TYPE_BUFFER, GST_TAG_EXIF, "exif metadata chunk", NULL);
}
/*
* IPTC tags
*/
static void
metadata_tags_iptc_register (void)
{
gst_tag_register (GST_TAG_IPTC, GST_TAG_FLAG_META,
GST_TYPE_BUFFER, GST_TAG_IPTC, "iptc metadata chunk", NULL);
}
/*
* XMP tags
*/
static void
metadata_tags_xmp_register (void)
{
gst_tag_register (GST_TAG_XMP, GST_TAG_FLAG_META,
GST_TYPE_BUFFER, GST_TAG_XMP, "xmp metadata chunk", NULL);
}
/*
*
*/
void
metadata_tags_register (void)
{
/* devices tags */
@ -101,20 +68,21 @@ metadata_tags_register (void)
/* image tags */
gst_tag_register (GST_TAG_IMAGE_XRESOLUTION, GST_TAG_FLAG_META, G_TYPE_FLOAT,
GST_TAG_IMAGE_XRESOLUTION, "Horizontal resolution in pixels per inch",
NULL);
gst_tag_register (GST_TAG_IMAGE_YRESOLUTION, GST_TAG_FLAG_META, G_TYPE_FLOAT,
GST_TAG_IMAGE_YRESOLUTION, "Vertical resolution in pixels per inch",
NULL);
gst_tag_register (GST_TAG_IMAGE_XRESOLUTION, GST_TAG_FLAG_META,
GST_TYPE_FRACTION, GST_TAG_IMAGE_XRESOLUTION,
"Horizontal resolution in pixels per inch", NULL);
gst_tag_register (GST_TAG_IMAGE_YRESOLUTION, GST_TAG_FLAG_META,
GST_TYPE_FRACTION, GST_TAG_IMAGE_YRESOLUTION,
"Vertical resolution in pixels per inch", NULL);
/* capture tags */
gst_tag_register (GST_TAG_CAPTURE_EXPOSURE_TIME, GST_TAG_FLAG_META,
G_TYPE_FLOAT, GST_TAG_CAPTURE_EXPOSURE_TIME, "Exposure time in seconds",
GST_TYPE_FRACTION, GST_TAG_CAPTURE_EXPOSURE_TIME,
"Exposure time in seconds", NULL);
gst_tag_register (GST_TAG_CAPTURE_FNUMBER, GST_TAG_FLAG_META,
GST_TYPE_FRACTION, GST_TAG_CAPTURE_FNUMBER, "F number (focal ratio)",
NULL);
gst_tag_register (GST_TAG_CAPTURE_FNUMBER, GST_TAG_FLAG_META, G_TYPE_FLOAT,
GST_TAG_CAPTURE_FNUMBER, "F number (focal ratio)", NULL);
/**
0 - not defined
1- Manual
@ -137,11 +105,11 @@ metadata_tags_register (void)
"Class of program used for exposure", NULL);
/** The unit is the APEX value.
Ordinarily it is given in the range of -99.99 to 99.99.
100.0 mean unknown
if numerator is 0xFFFFFFFF means unknown
*/
gst_tag_register (GST_TAG_CAPTURE_BRIGHTNESS, GST_TAG_FLAG_META, G_TYPE_FLOAT,
GST_TAG_CAPTURE_BRIGHTNESS, "Brightness (APEX from -99.99 to 99.99)",
NULL);
gst_tag_register (GST_TAG_CAPTURE_BRIGHTNESS, GST_TAG_FLAG_META,
GST_TYPE_FRACTION, GST_TAG_CAPTURE_BRIGHTNESS,
"Brightness (APEX from -99.99 to 99.99)", NULL);
/**
0- Auto
1- Off
@ -160,7 +128,8 @@ metadata_tags_register (void)
/** if Zero ZOOM not used
*/
gst_tag_register (GST_TAG_CAPTURE_DIGITAL_ZOOM, GST_TAG_FLAG_META,
G_TYPE_FLOAT, GST_TAG_CAPTURE_DIGITAL_ZOOM, "Digital zoom ratio", NULL);
GST_TYPE_FRACTION, GST_TAG_CAPTURE_DIGITAL_ZOOM, "Digital zoom ratio",
NULL);
/**
0- None
1- Low gain up
@ -189,6 +158,49 @@ metadata_tags_register (void)
gst_tag_register (GST_TAG_CAPTURE_SATURATION, GST_TAG_FLAG_META, G_TYPE_INT,
GST_TAG_CAPTURE_SATURATION, "", NULL);
}
/*
* IPTC tags
*/
static void
metadata_tags_iptc_register (void)
{
}
/*
* XMP tags
*/
static void
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 ();

62
ext/metadata/test/metadata_editor.c
View file

@ -160,33 +160,43 @@ change_tag_list (GstTagList ** list, const gchar * tag, const gchar * value)
type = gst_tag_get_type (tag);
switch (type) {
case G_TYPE_STRING:
gst_tag_list_add (*list, GST_TAG_MERGE_REPLACE, tag, value, NULL);
ret = TRUE;
break;
case G_TYPE_FLOAT:
{
gfloat fv = (gfloat) g_strtod (value, NULL);
if (type == GST_TYPE_FRACTION) {
/* FIXME: Ask GStreamer guys to add GST_FRACTION support to TAGS */
/* Even better: ask GLib guys to add this type */
gint n, d;
gst_tag_list_add (*list, GST_TAG_MERGE_REPLACE, tag, fv, NULL);
ret = TRUE;
}
break;
case G_TYPE_INT:
/* fall through */
case G_TYPE_UINT:
{
gint iv = atoi (value);
sscanf (value, "%d/%d", &n, &d);
gst_tag_list_add (*list, GST_TAG_MERGE_REPLACE, tag, n, d, NULL);
ret = TRUE;
} else {
switch (type) {
case G_TYPE_STRING:
gst_tag_list_add (*list, GST_TAG_MERGE_REPLACE, tag, value, NULL);
ret = TRUE;
break;
case G_TYPE_FLOAT:
{
gfloat fv = (gfloat) g_strtod (value, NULL);
gst_tag_list_add (*list, GST_TAG_MERGE_REPLACE, tag, iv, NULL);
ret = TRUE;
gst_tag_list_add (*list, GST_TAG_MERGE_REPLACE, tag, fv, NULL);
ret = TRUE;
}
break;
case G_TYPE_INT:
/* fall through */
case G_TYPE_UINT:
{
gint iv = atoi (value);
gst_tag_list_add (*list, GST_TAG_MERGE_REPLACE, tag, iv, NULL);
ret = TRUE;
}
break;
default:
fprintf (stderr, "This app still doesn't handle type (%s)(%ld)\n",
g_type_name (type), type);
break;
}
break;
default:
fprintf (stderr, "This app still doesn't handle type (%s)(%ld)\n",
g_type_name (type), type);
break;
}
done:
@ -700,7 +710,7 @@ me_gst_setup_encode_pipeline (const gchar * src_file, const gchar * dest_file,
/* create elements */
gst_source = gst_element_factory_make ("filesrc", NULL);
gst_metadata_demux = gst_element_factory_make ("metadataparse", NULL);
gst_metadata_demux = gst_element_factory_make ("metadatademux", NULL);
gst_metadata_mux = gst_element_factory_make ("metadatamux", NULL);
gst_file_sink = gst_element_factory_make ("filesink", NULL);
@ -767,7 +777,7 @@ me_gst_setup_view_pipeline (const gchar * filename, GdkWindow * window)
/* create elements */
gst_source = gst_element_factory_make ("filesrc", NULL);
gst_metadata_demux = gst_element_factory_make ("metadataparse", NULL);
gst_metadata_demux = gst_element_factory_make ("metadatademux", NULL);
/* let's do a dummy stuff to avoid decodebin */
if (is_png (filename))
gst_image_dec = gst_element_factory_make ("pngdec", NULL);