mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2025-03-30 12:49:40 +00:00
Added new module for common functions. Using GST_TYPE_FRACTION for Exif (S)Rational types.
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:
parent
91bb79004f
commit
b2a023be7b
13 changed files with 1312 additions and 1619 deletions
19
ChangeLog
19
ChangeLog
|
@ -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:
|
||||
|
|
|
@ -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 \
|
||||
|
|
|
@ -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)
|
||||
|
||||
|
|
|
@ -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
631
ext/metadata/gstmetadatacommon.c
Normal 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
96
ext/metadata/gstmetadatacommon.h
Normal 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__ */
|
File diff suppressed because it is too large
Load diff
|
@ -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__ */
|
File diff suppressed because it is too large
Load diff
|
@ -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;
|
||||
|
||||
|
|
|
@ -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:
|
||||
|
|
|
@ -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 ();
|
||||
|
|
|
@ -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);
|
||||
|
|
Loading…
Reference in a new issue