mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2025-01-03 05:59:10 +00:00
Code Issues 1 Projects Releases Wiki Activity

Now parser is generic (just add/remove a list of chunks). And a template of muxer has been created.

Browse source 
Original commit message from CVS:
Now parser is generic (just add/remove a list of chunks). And a template of muxer has been created.
This commit is contained in:
Edgard Lima 2007-11-23 17:35:21 +00:00
parent db93cd7461
commit 1cb35c7574
15 changed files with 1177 additions and 359 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
ChangeLog
View file

@ -1,3 +1,23 @@
2007-11-23 Edgard Lima <edgard.lima@indt.org.br>
* ext/metadata/Makefile.am:
* ext/metadata/gstmetadata.c:
* ext/metadata/gstmetadatamux.c:
* ext/metadata/gstmetadatamux.h:
* ext/metadata/gstmetadataparse.c:
* ext/metadata/gstmetadataparse.h:
* ext/metadata/metadataparse.c:
* ext/metadata/metadataparse.h:
* ext/metadata/metadataparsejpeg.c:
* ext/metadata/metadataparsejpeg.h:
* ext/metadata/metadataparsepng.c:
* ext/metadata/metadataparsepng.h:
* ext/metadata/metadataparsetypes.h:
* ext/metadata/metadatatypes.c:
* ext/metadata/metadatatypes.h:
Now parser is generic (just add/remove a list of chunks). And a
template of muxer has been created.
2007-11-23 Sebastian Dröge <slomo@circular-chaos.org>
* gst/speexresample/gstspeexresample.c:

22
ext/metadata/Makefile.am
View file

@ -8,18 +8,22 @@ libgstmetadata_la_SOURCES = gstmetadata.c \
metadataparseexif.c \
metadataparseiptc.c \
metadataparsexmp.c \
metadataparseutil.c
metadataparseutil.c \
metadatatypes.c \
gstmetadatamux.c
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 \
metadataparse.h \
metadataparsejpeg.h \
metadataparsepng.h \
metadataparseexif.h \
metadataparseiptc.h \
metadataparsexmp.h \
metadataparseutil.h
noinst_HEADERS = gstmetadataparse.h \
metadataparse.h \
metadataparsejpeg.h \
metadataparsepng.h \
metadataparseexif.h \
metadataparseiptc.h \
metadataparsexmp.h \
metadataparseutil.h \
metadatatypes.h \
gstmetadatamux.h

14
ext/metadata/gstmetadata.c
View file

@ -45,14 +45,22 @@
#include "config.h"
#endif
#include "gstmetadataparse.h"
/* #include "gstmetadatamux.h" ...soon.. */
#include <gst/gst.h>
extern gboolean gst_metadata_parse_plugin_init (GstPlugin * plugin);
extern gboolean gst_metadata_mux_plugin_init (GstPlugin * plugin);
static gboolean
plugin_init (GstPlugin * plugin)
{
return gst_metadata_parse_plugin_init (plugin);
gboolean ret = TRUE;
ret = gst_metadata_parse_plugin_init (plugin);
ret = ret && gst_metadata_mux_plugin_init (plugin);
return ret;
}

243
ext/metadata/gstmetadatamux.c Normal file
View file

@ -0,0 +1,243 @@
/*
* 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:element-plugin
*
* <refsect2>
* <title>Example launch line</title>
* <para>
* <programlisting>
* gst-launch -v -m filesrc location=./test.jpeg ! metadatamux ! filesink location=meta.jpeg
* </programlisting>
* </para>
* </refsect2>
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <gst/gst.h>
#include "gstmetadatamux.h"
GST_DEBUG_CATEGORY_STATIC (gst_metadata_mux_debug);
#define GST_CAT_DEFAULT gst_metadata_mux_debug
/* Filter signals and args */
enum
{
/* FILL ME */
LAST_SIGNAL
};
enum
{
ARG_0,
};
static GstStaticPadTemplate sink_factory = GST_STATIC_PAD_TEMPLATE ("sink",
GST_PAD_SINK,
GST_PAD_ALWAYS,
GST_STATIC_CAPS ("image/jpeg, tags-extracted = (bool) true;"
"image/png, tags-extracted = (bool) true")
);
static GstStaticPadTemplate src_factory = GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
GST_STATIC_CAPS ("image/jpeg; " "image/png")
);
GST_BOILERPLATE (GstMetadataMux, gst_metadata_mux, GstElement,
GST_TYPE_ELEMENT);
static void gst_metadata_mux_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
static void gst_metadata_mux_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec);
static gboolean gst_metadata_mux_set_caps (GstPad * pad, GstCaps * caps);
static GstFlowReturn gst_metadata_mux_chain (GstPad * pad, GstBuffer * buf);
static void
gst_metadata_mux_base_init (gpointer gclass)
{
static GstElementDetails element_details = {
"PluginTemplate",
"Generic/PluginTemplate",
"Generic Template Element",
"Thomas Vander Stichele <thomas@apestaart.org>"
};
GstElementClass *element_class = GST_ELEMENT_CLASS (gclass);
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&src_factory));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&sink_factory));
gst_element_class_set_details (element_class, &element_details);
}
/* initialize the plugin's class */
static void
gst_metadata_mux_class_init (GstMetadataMuxClass * klass)
{
GObjectClass *gobject_class;
GstElementClass *gstelement_class;
gobject_class = (GObjectClass *) klass;
gstelement_class = (GstElementClass *) klass;
gobject_class->set_property = gst_metadata_mux_set_property;
gobject_class->get_property = gst_metadata_mux_get_property;
}
/* initialize the new element
* instantiate pads and add them to element
* set functions
* initialize structure
*/
static void
gst_metadata_mux_init (GstMetadataMux * filter, GstMetadataMuxClass * gclass)
{
GstElementClass *klass = GST_ELEMENT_GET_CLASS (filter);
filter->sinkpad =
gst_pad_new_from_template (gst_element_class_get_pad_template (klass,
"sink"), "sink");
gst_pad_set_setcaps_function (filter->sinkpad,
GST_DEBUG_FUNCPTR (gst_metadata_mux_set_caps));
gst_pad_set_getcaps_function (filter->sinkpad,
GST_DEBUG_FUNCPTR (gst_pad_proxy_getcaps));
filter->srcpad =
gst_pad_new_from_template (gst_element_class_get_pad_template (klass,
"src"), "src");
gst_pad_set_getcaps_function (filter->srcpad,
GST_DEBUG_FUNCPTR (gst_pad_proxy_getcaps));
gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad);
gst_element_add_pad (GST_ELEMENT (filter), filter->srcpad);
gst_pad_set_chain_function (filter->sinkpad,
GST_DEBUG_FUNCPTR (gst_metadata_mux_chain));
}
static void
gst_metadata_mux_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
GstMetadataMux *filter = GST_METADATA_MUX (object);
switch (prop_id) {
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gst_metadata_mux_get_property (GObject * object, guint prop_id,
GValue * value, GParamSpec * pspec)
{
GstMetadataMux *filter = GST_METADATA_MUX (object);
switch (prop_id) {
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/* GstElement vmethod implementations */
/* this function handles the link with other elements */
static gboolean
gst_metadata_mux_set_caps (GstPad * pad, GstCaps * caps)
{
GstMetadataMux *filter;
GstPad *otherpad;
filter = GST_METADATA_MUX (gst_pad_get_parent (pad));
otherpad = (pad == filter->srcpad) ? filter->sinkpad : filter->srcpad;
return gst_pad_set_caps (pad, caps);
}
/* chain function
* this function does the actual processing
*/
static GstFlowReturn
gst_metadata_mux_chain (GstPad * pad, GstBuffer * buf)
{
GstMetadataMux *filter;
filter = GST_METADATA_MUX (GST_OBJECT_PARENT (pad));
/* just push out the incoming buffer without touching it */
return gst_pad_push (filter->srcpad, buf);
}
/* entry point to initialize the plug-in
* initialize the plug-in itself
* register the element factories and pad templates
* register the features
*
* exchange the string 'plugin' with your elemnt name
*/
gboolean
gst_metadata_mux_plugin_init (GstPlugin * plugin)
{
/* exchange the strings 'plugin' and 'Template plugin' with your
* plugin name and description */
GST_DEBUG_CATEGORY_INIT (gst_metadata_mux_debug, "metadatamux",
0, "Metadata muxer");
return gst_element_register (plugin, "metadatamux",
GST_RANK_NONE, GST_TYPE_METADATA_MUX);
}

47
ext/metadata/metadataparsetypes.h → ext/metadata/gstmetadatamux.h
View file

@ -41,24 +41,43 @@
* Boston, MA 02111-1307, USA.
*/
#ifndef __METADATAPARSETYPES_H__
#define __METADATAPARSETYPES_H__
#ifndef __GST_METADATA_MUX_H__
#define __GST_METADATA_MUX_H__
#include <gst/base/gstadapter.h>
#include <gst/gst.h>
G_BEGIN_DECLS
typedef struct _tag_MetadataChunk
{
gint64 offset; /* from the beginning of file */
guint32 size; /* size of bytes in chunk (same as adapter size) */
GstAdapter *adapter;
/* in some cases, when there is JPEG/EXIF, and no JIF as first chunk
is is need to add a chunk data back to the file */
guint32 size_inject; /* same as buffer size */
guint8 * buffer;
} MetadataChunk;
/* #defines don't like whitespacey bits */
#define GST_TYPE_METADATA_MUX \
(gst_metadata_mux_get_type())
#define GST_METADATA_MUX(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_METADATA_MUX,GstMetadataMux))
#define GST_METADATA_MUX_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_METADATA_MUX,GstMetadataMuxClass))
#define GST_IS_METADATAMUX(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_METADATA_MUX))
#define GST_IS_METADATAMUX_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_METADATA_MUX))
typedef struct _GstMetadataMux GstMetadataMux;
typedef struct _GstMetadataMuxClass GstMetadataMuxClass;
struct _GstMetadataMux
{
GstElement element;
GstPad *sinkpad, *srcpad;
};
struct _GstMetadataMuxClass
{
GstElementClass parent_class;
};
GType gst_metadata_mux_get_type (void);
G_END_DECLS
#endif /* __METADATAPARSETYPES_H__ */
#endif /* __GST_METADATA_MUX_H__ */

677
ext/metadata/gstmetadataparse.c
View file

@ -138,13 +138,13 @@ static gboolean gst_metadata_parse_sink_event (GstPad * pad, GstEvent * event);
static GstFlowReturn gst_metadata_parse_chain (GstPad * pad, GstBuffer * buf);
static gboolean
gst_metadata_parse_get_range (GstPad * pad, guint64 offset, guint size,
gst_metadata_parse_get_range (GstPad * pad, guint64 offset_orig, guint size,
GstBuffer ** buf);
static gboolean gst_metadata_parse_activate (GstPad * pad);
static gboolean gst_metadata_parse_sink_activate (GstPad * pad);
static gboolean
gst_metadata_parse_element_activate_src_pull (GstPad * pad, gboolean active);
gst_metadata_parse_src_activate_pull (GstPad * pad, gboolean active);
static gboolean gst_metadata_parse_pull_range_parse (GstMetadataParse * filter);
@ -161,19 +161,20 @@ gst_metadata_parse_parse (GstMetadataParse * filter, const guint8 * buf,
static void gst_metadata_parse_send_tags (GstMetadataParse * filter);
static gboolean gst_metadata_parse_activate (GstPad * pad);
static int
gst_metadata_parse_get_strip_seg (const gint64 offset, guint32 size,
const gint64 seg_offset, const guint32 seg_size,
guint32 * boffset, guint32 * bsize, guint32 * seg_binter);
static gboolean
gst_metadata_parse_strip_buffer (GstMetadataParse * filter, gint64 offset,
GstBuffer ** buf);
gint64 * boffset, guint32 * bsize, guint32 * seg_binter);
static void
gst_metadata_parse_translate_pos (GstMetadataParse * filter, gint64 pos,
gint64 * orig_pos);
static gboolean
gst_metadata_parse_strip_push_buffer (GstMetadataParse * filter,
gint64 offset_orig, GstBuffer ** prepend, GstBuffer ** buf);
static gboolean
gst_metadata_parse_translate_pos_to_orig (GstMetadataParse * filter, gint64 pos,
gint64 * orig_pos, GstBuffer ** buf);
static const GstQueryType *gst_metadata_parse_get_query_types (GstPad * pad);
@ -254,7 +255,8 @@ gst_metadata_parse_init (GstMetadataParse * filter,
gst_pad_set_event_function (filter->sinkpad, gst_metadata_parse_sink_event);
gst_pad_set_chain_function (filter->sinkpad,
GST_DEBUG_FUNCPTR (gst_metadata_parse_chain));
gst_pad_set_activate_function (filter->sinkpad, gst_metadata_parse_activate);
gst_pad_set_activate_function (filter->sinkpad,
gst_metadata_parse_sink_activate);
/* source pad */
@ -269,9 +271,11 @@ gst_metadata_parse_init (GstMetadataParse * filter,
gst_pad_set_query_type_function (filter->srcpad,
GST_DEBUG_FUNCPTR (gst_metadata_parse_get_query_types));
gst_pad_use_fixed_caps (filter->srcpad);
gst_pad_set_getrange_function (filter->srcpad, gst_metadata_parse_get_range);
gst_pad_set_activatepull_function (filter->srcpad,
GST_DEBUG_FUNCPTR (gst_metadata_parse_element_activate_src_pull));
GST_DEBUG_FUNCPTR (gst_metadata_parse_src_activate_pull));
/* addind pads */
gst_element_add_pad (GST_ELEMENT (filter), filter->sinkpad);
@ -460,7 +464,13 @@ gst_metadata_parse_src_event (GstPad * pad, GstEvent * event)
}
start_type == GST_SEEK_TYPE_SET;
gst_metadata_parse_translate_pos (filter, start, &start);
if (filter->prepend_buffer) {
gst_buffer_unref (filter->prepend_buffer);
filter->prepend_buffer = NULL;
}
gst_metadata_parse_translate_pos_to_orig (filter, start, &start,
&filter->prepend_buffer);
if (stop_type == GST_SEEK_TYPE_CUR)
stop = filter->offset + stop;
@ -471,7 +481,7 @@ gst_metadata_parse_src_event (GstPad * pad, GstEvent * event)
}
stop_type == GST_SEEK_TYPE_SET;
gst_metadata_parse_translate_pos (filter, stop, &stop);
gst_metadata_parse_translate_pos_to_orig (filter, stop, &stop, NULL);
gst_event_unref (event);
event = gst_event_new_seek (rate, format, flags,
@ -549,14 +559,31 @@ static void
gst_metadata_parse_dispose_members (GstMetadataParse * filter)
{
metadataparse_dispose (&filter->parse_data);
if (filter->adapter) {
gst_object_unref (filter->adapter);
filter->adapter = NULL;
if (filter->adapter_parsing) {
gst_object_unref (filter->adapter_parsing);
filter->adapter_parsing = NULL;
}
if (filter->adapter_holding) {
gst_object_unref (filter->adapter_holding);
filter->adapter_holding = NULL;
}
if (filter->taglist) {
gst_tag_list_free (filter->taglist);
filter->taglist = NULL;
}
if (filter->append_buffer) {
gst_buffer_unref (filter->append_buffer);
filter->append_buffer = NULL;
}
if (filter->prepend_buffer) {
gst_buffer_unref (filter->prepend_buffer);
filter->prepend_buffer = NULL;
}
}
static void
@ -567,30 +594,23 @@ gst_metadata_parse_init_members (GstMetadataParse * filter)
filter->iptc = TRUE;
filter->xmp = TRUE;
memset (filter->seg_offset_orig, 0x00,
sizeof (filter->seg_offset_orig[0]) * 3);
memset (filter->seg_size, 0x00, sizeof (filter->seg_size[0]) * 3);
memset (filter->seg_inject_offset, 0x00,
sizeof (filter->seg_inject_offset[0]) * 3);
memset (filter->seg_inject_data, 0x00,
sizeof (filter->seg_inject_data[0]) * 3);
memset (filter->seg_inject_size, 0x00,
sizeof (filter->seg_inject_size[0]) * 3);
filter->num_segs = 0;
filter->taglist = NULL;
filter->adapter = NULL;
filter->adapter_parsing = NULL;
filter->adapter_holding = NULL;
filter->next_offset = 0;
filter->next_size = 0;
filter->img_type = IMG_NONE;
filter->duration = -1;
filter->offset_orig = 0;
filter->duration_orig = 0;
filter->offset = 0;
filter->duration = 0;
filter->state = MT_STATE_NULL;
filter->need_more_data = FALSE;
metadataparse_init (&filter->parse_data);
filter->append_buffer = NULL;
filter->prepend_buffer = NULL;
memset (&filter->parse_data, 0x00, sizeof (ParseData));
}
static gboolean
@ -745,13 +765,13 @@ gst_metadata_parse_send_tags (GstMetadataParse * filter)
if (PARSE_DATA_OPTION (filter->parse_data) & PARSE_OPT_EXIF)
metadataparse_exif_tag_list_add (filter->taglist, GST_TAG_MERGE_KEEP,
filter->parse_data.exif.adapter);
filter->parse_data.exif_adapter);
if (PARSE_DATA_OPTION (filter->parse_data) & PARSE_OPT_IPTC)
metadataparse_iptc_tag_list_add (filter->taglist, GST_TAG_MERGE_KEEP,
filter->parse_data.iptc.adapter);
filter->parse_data.iptc_adapter);
if (PARSE_DATA_OPTION (filter->parse_data) & PARSE_OPT_XMP)
metadataparse_xmp_tag_list_add (filter->taglist, GST_TAG_MERGE_KEEP,
filter->parse_data.xmp.adapter);
filter->parse_data.xmp_adapter);
if (!gst_tag_list_is_empty (filter->taglist)) {
@ -853,77 +873,50 @@ gst_metadata_parse_parse (GstMetadataParse * filter, const guint8 * buf,
filter->need_more_data = TRUE;
} else {
int i, j;
guint32 bytes_striped;
guint32 append_size;
guint32 bytes_striped, bytes_inject;
MetadataChunk *strip = filter->parse_data.strip_chunks.chunk;
MetadataChunk *inject = filter->parse_data.inject_chunks.chunk;
const gsize strip_len = filter->parse_data.strip_chunks.len;
const gsize inject_len = filter->parse_data.inject_chunks.len;
filter->num_segs = 0;
bytes_striped = 0;
bytes_inject = 0;
/* FIXME: better design for segments */
filter->seg_size[0] = filter->parse_data.exif.size;
filter->seg_offset_orig[0] = filter->parse_data.exif.offset;
filter->seg_inject_size[0] = filter->parse_data.exif.size_inject;
filter->seg_inject_data[0] = filter->parse_data.exif.buffer;
filter->seg_size[1] = filter->parse_data.iptc.size;
filter->seg_offset_orig[1] = filter->parse_data.iptc.offset;
filter->seg_inject_size[1] = filter->parse_data.iptc.size_inject;
filter->seg_inject_data[1] = filter->parse_data.iptc.buffer;
filter->seg_size[2] = filter->parse_data.xmp.size;
filter->seg_offset_orig[2] = filter->parse_data.xmp.offset;
filter->seg_inject_size[2] = filter->parse_data.xmp.size_inject;
filter->seg_inject_data[2] = filter->parse_data.xmp.buffer;
for (i = 0; i < 3; ++i) {
if (filter->seg_size[i]) {
filter->num_segs++;
/* calculate the new position off injected chunks */
for (i = 0; i < inject_len; ++i) {
for (j = 0; j < strip_len; ++i) {
if (strip[j].offset_orig >= inject[i].offset_orig) {
break;
}
inject[i].offset = inject[i].offset_orig - bytes_striped + bytes_inject;
bytes_striped += strip[j].size;
}
bytes_inject += inject[i].size;
}
if (filter->num_segs) {
/* calculate append (doesnt make much sense, but, anyway..) */
append_size = 0;
for (i = inject_len - 1; i >= 0; --i) {
if (inject[i].offset_orig == filter->duration_orig)
append_size += inject[i].size;
else
break;
}
if (append_size) {
guint8 *data;
for (i = 0; i < 3; ++i) {
int j, min = i;
for (j = i + 1; j < 3; ++j) {
if (filter->seg_size[j])
if (filter->seg_size[min] == 0
|| filter->seg_offset_orig[j] < filter->seg_offset_orig[min])
min = j;
}
if (min != i) {
gint64 aux_offset;
guint32 aux_size;
guint8 *aux_data;
aux_offset = filter->seg_offset_orig[i];
aux_size = filter->seg_size[i];
filter->seg_offset_orig[i] = filter->seg_offset_orig[min];
filter->seg_size[i] = filter->seg_size[min];
filter->seg_offset_orig[min] = aux_offset;
filter->seg_size[min] = aux_size;
aux_size = filter->seg_inject_size[i];
filter->seg_inject_size[i] = filter->seg_inject_size[min];
filter->seg_inject_size[min] = aux_size;
aux_data = filter->seg_inject_data[i];
filter->seg_inject_data[i] = filter->seg_inject_data[min];
filter->seg_inject_data[min] = aux_data;
filter->append_buffer = gst_buffer_new_and_alloc (append_size);
GST_BUFFER_FLAG_SET (filter->append_buffer, GST_BUFFER_FLAG_READONLY);
data = GST_BUFFER_DATA (filter->append_buffer);
for (i = inject_len - 1; i >= 0; --i) {
if (inject[i].offset_orig == filter->duration_orig) {
memcpy (data, inject[i].data, inject[i].size);
data += inject[i].size;
} else {
break;
}
}
bytes_striped = 0;
/* calculate the new position off injected chunks */
for (i = 0; i < filter->num_segs; ++i) {
filter->seg_inject_offset[i] =
filter->seg_offset_orig[i] - bytes_striped;
bytes_striped += filter->seg_size[i] - filter->seg_inject_size[i];
}
}
filter->state = MT_STATE_PARSED;
@ -965,18 +958,19 @@ gst_metadata_parse_chain (GstPad * pad, GstBuffer * buf)
GstFlowReturn ret = GST_FLOW_ERROR;
guint32 buf_size = 0;
guint32 new_buf_size = 0;
gboolean append = FALSE;
filter = GST_METADATA_PARSE (gst_pad_get_parent (pad));
/* commented until I figure out how to strip if it wasn't parsed yet */
#if 0
if (filter->state != MT_STATE_PARSED) {
guint32 adpt_size = gst_adapter_available (filter->adapter);
guint32 adpt_size = gst_adapter_available (filter->adapter_parsing);
if (filter->next_offset) {
if (filter->next_offset >= adpt_size) {
/* clean adapter */
gst_adapter_clear (filter->adapter);
gst_adapter_clear (filter->adapter_parsing);
filter->next_offset -= adpt_size;
if (filter->next_offset >= GST_BUFFER_SIZE (buf)) {
/* we don't need data in this buffer */
@ -991,51 +985,87 @@ gst_metadata_parse_chain (GstPad * pad, GstBuffer * buf)
memcpy (GST_BUFFER_DATA (new_buf), GST_BUFFER_DATA (buf),
GST_BUFFER_SIZE (buf) - filter->next_offset);
filter->next_offset = 0;
gst_adapter_push (filter->adapter, new_buf);
gst_adapter_push (filter->adapter_parsing, new_buf);
}
} else {
/* remove first bytes and add buffer */
gst_adapter_flush (filter->adapter, filter->next_offset);
gst_adapter_flush (filter->adapter_parsing, filter->next_offset);
filter->next_offset = 0;
gst_adapter_push (filter->adapter, gst_buffer_copy (buf));
gst_adapter_push (filter->adapter_parsing, gst_buffer_copy (buf));
}
} else {
/* just push buffer */
gst_adapter_push (filter->adapter, gst_buffer_copy (buf));
gst_adapter_push (filter->adapter_parsing, gst_buffer_copy (buf));
}
adpt_size = gst_adapter_available (filter->adapter);
adpt_size = gst_adapter_available (filter->adapter_parsing);
if (adpt_size && filter->next_size <= adpt_size) {
const guint8 *new_buf = gst_adapter_peek (filter->adapter, adpt_size);
const guint8 *new_buf =
gst_adapter_peek (filter->adapter_parsing, adpt_size);
if (gst_metadata_parse_parse (filter, new_buf, adpt_size) < 0)
goto done;
}
}
#endif
if (filter->need_send_tag) {
gst_metadata_parse_send_tags (filter);
}
if (filter->state == MT_STATE_PARSED) {
buf_size = GST_BUFFER_SIZE (buf);
gst_metadata_parse_strip_buffer (filter, filter->offset_orig, &buf);
if (filter->adapter_holding) {
gst_adapter_push (filter->adapter_holding, buf);
buf = gst_adapter_take_buffer (filter->adapter_holding,
gst_adapter_available (filter->adapter_holding));
g_object_unref (filter->adapter_holding);
filter->adapter_holding = NULL;
}
if (buf) { /* may be all buffer has been striped */
gst_buffer_set_caps (buf, GST_PAD_CAPS (filter->srcpad));
new_buf_size = GST_BUFFER_SIZE (buf);
if (filter->need_send_tag) {
gst_metadata_parse_send_tags (filter);
}
if (filter->offset_orig + GST_BUFFER_SIZE (buf) == filter->duration_orig)
append = TRUE;
buf_size = GST_BUFFER_SIZE (buf);
gst_metadata_parse_strip_push_buffer (filter, filter->offset_orig,
&filter->prepend_buffer, &buf);
if (buf) { /* may be all buffer has been striped */
gst_buffer_set_caps (buf, GST_PAD_CAPS (filter->srcpad));
new_buf_size = GST_BUFFER_SIZE (buf);
ret = gst_pad_push (filter->srcpad, buf);
buf = NULL; /* this function don't owner it anymore */
if (ret != GST_FLOW_OK)
goto done;
} else {
ret = GST_FLOW_OK;
}
if (append && filter->append_buffer) {
gst_buffer_set_caps (filter->append_buffer,
GST_PAD_CAPS (filter->srcpad));
gst_buffer_ref (filter->append_buffer);
ret = gst_pad_push (filter->srcpad, filter->append_buffer);
if (ret != GST_FLOW_OK)
goto done;
}
filter->offset_orig += buf_size;
filter->offset += new_buf_size;
ret = gst_pad_push (filter->srcpad, buf);
buf = NULL; /* this function don't owner it anymore */
} else {
/* just store while still not parsed */
if (!filter->adapter_holding)
filter->adapter_holding = gst_adapter_new ();
gst_adapter_push (filter->adapter_holding, buf);
buf = NULL;
ret = GST_FLOW_OK;
}
done:
filter->offset_orig += buf_size;
filter->offset += new_buf_size;
if (buf) {
/* there was an error and buffer wasn't pushed */
@ -1106,13 +1136,19 @@ gst_metadata_parse_pull_range_parse (GstMetadataParse * filter)
if (res == 0) {
int i;
MetadataChunk *strip = filter->parse_data.strip_chunks.chunk;
MetadataChunk *inject = filter->parse_data.inject_chunks.chunk;
const gsize strip_len = filter->parse_data.strip_chunks.len;
const gsize inject_len = filter->parse_data.inject_chunks.len;
filter->duration = duration;
filter->duration_orig = duration;
for (i = 0; i < filter->num_segs; ++i) {
filter->duration -= (filter->seg_size[i] - filter->seg_inject_size[i]);
for (i = 0; i < inject_len; ++i) {
filter->duration += inject[i].size;
}
for (i = 0; i < strip_len; ++i) {
filter->duration -= strip[i].size;
}
}
@ -1124,7 +1160,7 @@ done:
}
static gboolean
gst_metadata_parse_activate (GstPad * pad)
gst_metadata_parse_sink_activate (GstPad * pad)
{
GstMetadataParse *filter = NULL;
gboolean ret = TRUE;
@ -1178,7 +1214,7 @@ done:
static int
gst_metadata_parse_get_strip_seg (const gint64 offset, guint32 size,
const gint64 seg_offset, const guint32 seg_size,
guint32 * boffset, guint32 * bsize, guint32 * seg_binter)
gint64 * boffset, guint32 * bsize, guint32 * seg_binter)
{
int ret = -1;
@ -1239,119 +1275,320 @@ done:
}
/*
* TRUE -> buffer striped (or injeted)
* TRUE -> buffer striped or injeted
* FALSE -> buffer unmodified
*/
static gboolean
gst_metadata_parse_strip_buffer (GstMetadataParse * filter, gint64 offset,
GstBuffer ** buf)
gst_metadata_parse_strip_push_buffer (GstMetadataParse * filter,
gint64 offset_orig, GstBuffer ** prepend, GstBuffer ** buf)
{
MetadataChunk *strip = filter->parse_data.strip_chunks.chunk;
MetadataChunk *inject = filter->parse_data.inject_chunks.chunk;
const gsize strip_len = filter->parse_data.strip_chunks.len;
const gsize inject_len = filter->parse_data.inject_chunks.len;
const gint64 *seg_offset = filter->seg_offset_orig;
const guint32 *seg_size = filter->seg_size;
const guint32 *seg_inject_size = filter->seg_inject_size;
const guint8 **seg_inject_data = filter->seg_inject_data;
guint32 size_buf_in = GST_BUFFER_SIZE (*buf);
const size = GST_BUFFER_SIZE (*buf);
gint64 *boffset_strip = NULL;
guint32 *bsize_strip = NULL;
guint32 *seg_binter_strip = NULL;
gint64 boffset[3];
guint32 bsize[3];
guint32 seg_binter[3];
int i, j;
gboolean need_free_strip = FALSE;
int i;
gboolean ret = FALSE;
guint32 striped_bytes = 0;
guint32 injected_bytes = 0;
if (filter->num_segs == 0)
goto done;
guint32 prepend_size = prepend && *prepend ? GST_BUFFER_SIZE (*prepend) : 0;
memset (bsize, 0x00, sizeof (bsize));
if (inject_len) {
for (i = 0; i < filter->num_segs; ++i) {
int res;
for (i = 0; i < inject_len; ++i) {
int res;
res = gst_metadata_parse_get_strip_seg (offset, size,
seg_offset[i], seg_size[i], &boffset[i], &bsize[i], &seg_binter[i]);
/* segment is after size (segments are sorted) */
if (res > 0)
break;
if (res == 0)
ret = TRUE;
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;
}
}
}
}
/* segments must be sorted by offset to make this copy */
if (ret) {
/*
* 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_parse_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;
guint32 moved = 0;
if (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY)) {
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);
for (i = 0; i < filter->num_segs; ++i) {
striped_bytes = 0;
for (i = 0; i < strip_len; ++i) {
/* intersect */
if (bsize[i]) {
/* has data to inject */
if (seg_inject_size[i]) {
/* has data to inject here */
if (seg_binter[i] < seg_inject_size[i]) {
const guint32 inject_size = seg_inject_size[i] - seg_binter[i];
memcpy (data + boffset[i], seg_inject_data[i] + seg_binter[i],
inject_size);
boffset[i] += inject_size;
bsize[i] -= inject_size;
}
}
if (bsize[i]) {
/* if even inject there is still thing to remove */
memmove (data + boffset[i] - moved,
data + boffset[i] + bsize[i] - moved,
size - boffset[i] - bsize[i] + moved);
moved += bsize[i];
}
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];
}
}
GST_BUFFER_SIZE (*buf) -= moved;
size_buf_in -= striped_bytes;
}
inject:
/*
* inject segments
*/
if (inject_len) {
guint8 *data;
guint32 striped_so_far;
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) {
/* 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 += injected_bytes;
} else {
/* segment is after size (segments are sorted) */
break;
}
}
}
}
done:
return ret;
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
*/
static void
gst_metadata_parse_translate_pos (GstMetadataParse * filter, gint64 pos,
gint64 * orig_pos)
static gboolean
gst_metadata_parse_translate_pos_to_orig (GstMetadataParse * filter, gint64 pos,
gint64 * orig_pos, GstBuffer ** buf)
{
int i;
MetadataChunk *strip = filter->parse_data.strip_chunks.chunk;
MetadataChunk *inject = filter->parse_data.inject_chunks.chunk;
const gsize strip_len = filter->parse_data.strip_chunks.len;
const gsize inject_len = filter->parse_data.inject_chunks.len;
gboolean ret = TRUE;
guint64 new_buf_size = 0;
guint64 injected_before = 0;
*orig_pos = 0;
for (i = 0; i < filter->num_segs; ++i) {
if (filter->seg_offset_orig[i] > pos) {
if (G_UNLIKELY (pos == -1)) {
*orig_pos = -1;
return TRUE;
} else if (G_UNLIKELY (pos >= filter->duration)) {
/* this should never happen */
*orig_pos = filter->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;
}
*orig_pos += filter->seg_size[i] - filter->seg_inject_size[i];
}
*orig_pos += pos;
/* 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 >= filter->duration_orig)) {
*orig_pos = filter->duration_orig - 1;
}
return ret;
}
@ -1360,33 +1597,64 @@ gst_metadata_parse_get_range (GstPad * pad,
guint64 offset, guint size, GstBuffer ** buf)
{
GstMetadataParse *filter = NULL;
gboolean ret;
gint64 pos;
const gint64 saved_offset = offset + size;
gboolean ret = TRUE;
const gint64 offset_orig = 0;
guint size_orig;
GstBuffer *prepend = NULL;
gboolean need_append = FALSE;
filter = GST_METADATA_PARSE (GST_PAD_PARENT (pad));
if (offset + size > filter->duration) {
/* this should never happen */
return FALSE;
}
size_orig = size;
if (filter->need_send_tag) {
gst_metadata_parse_send_tags (filter);
}
gst_metadata_parse_translate_pos (filter, offset + size - 1, &pos);
gst_metadata_parse_translate_pos (filter, offset, &offset);
gst_metadata_parse_translate_pos_to_orig (filter, offset, &offset_orig,
&prepend);
ret = gst_pad_pull_range (filter->sinkpad, offset, 1 + pos - offset, buf);
if (size > 1) {
gint64 pos;
if (ret == GST_FLOW_OK && *buf) {
gst_metadata_parse_strip_buffer (filter, offset, buf);
filter->offset_orig = pos;
filter->offset = saved_offset;
pos = offset + size - 1;
gst_metadata_parse_translate_pos_to_orig (filter, pos, &pos, NULL);
size_orig = pos + 1 - offset_orig;
}
if (size_orig) {
ret = gst_pad_pull_range (filter->sinkpad, offset_orig, size_orig, buf);
if (ret == GST_FLOW_OK && *buf) {
/* FIXEME: put prepend here */
gst_metadata_parse_strip_push_buffer (filter, offset_orig, &prepend, buf);
filter->offset_orig = offset;
filter->offset = offset;
if (GST_BUFFER_SIZE (*buf) < size) {
/* need append */
need_append = TRUE;
}
}
} else {
*buf = prepend;
}
done:
return ret;
}
static gboolean
gst_metadata_parse_element_activate_src_pull (GstPad * pad, gboolean active)
gst_metadata_parse_src_activate_pull (GstPad * pad, gboolean active)
{
GstMetadataParse *filter = NULL;
gboolean ret;
@ -1415,8 +1683,9 @@ gst_metadata_parse_change_state (GstElement * element,
switch (transition) {
case GST_STATE_CHANGE_NULL_TO_READY:
gst_metadata_parse_init_members (filter);
filter->adapter = gst_adapter_new ();
filter->adapter_parsing = gst_adapter_new ();
filter->taglist = gst_tag_list_new ();
metadataparse_init (&filter->parse_data);
break;
default:
break;

24
ext/metadata/gstmetadataparse.h
View file

@ -79,30 +79,26 @@ struct _GstMetadataParse
gboolean iptc;
gboolean xmp;
gint64 seg_offset_orig[3]; /* offset in chunk in original stream */
guint32 seg_size[3];
gint64 seg_inject_offset[3]; /* offset of chunk in resulting stream */
guint32 seg_inject_size[3];
guint8 * seg_inject_data[3];
gint8 num_segs;
gboolean need_send_tag;
GstTagList *taglist;
ParseData parse_data;
GstAdapter *adapter;
GstAdapter *adapter_parsing;
GstAdapter *adapter_holding;
guint32 next_offset;
guint32 next_size;
ImageType img_type;
gint64 offset_orig;
gint64 duration;
gint64 offset;
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;
@ -116,7 +112,5 @@ struct _GstMetadataParseClass
extern GType gst_metadata_parse_get_type (void);
extern gboolean gst_metadata_parse_plugin_init (GstPlugin * plugin);
G_END_DECLS
#endif /* __GST_METADATA_PARSE_H__ */

70
ext/metadata/metadataparse.c
View file

@ -63,10 +63,12 @@ metadataparse_init (ParseData * parse_data)
parse_data->state = STATE_NULL;
parse_data->img_type = IMG_NONE;
parse_data->option = PARSE_OPT_ALL;
parse_data->offset = 0;
memset (&parse_data->exif, 0x00, sizeof (MetadataChunk));
memset (&parse_data->iptc, 0x00, sizeof (MetadataChunk));
memset (&parse_data->xmp, 0x00, sizeof (MetadataChunk));
parse_data->offset_orig = 0;
parse_data->exif_adapter = NULL;
parse_data->iptc_adapter = NULL;
parse_data->xmp_adapter = NULL;
metadata_chunk_array_init (&parse_data->strip_chunks, 4);
metadata_chunk_array_init (&parse_data->inject_chunks, 1);
}
/*
@ -100,12 +102,14 @@ metadataparse_parse (ParseData * parse_data, const guint8 * buf,
case IMG_JPEG:
ret =
metadataparse_jpeg_parse (&parse_data->format_data.jpeg,
(guint8 *) buf, &bufsize, parse_data->offset, &next_start, next_size);
(guint8 *) buf, &bufsize, parse_data->offset_orig, &next_start,
next_size);
break;
case IMG_PNG:
ret =
metadataparse_png_parse (&parse_data->format_data.png,
(guint8 *) buf, &bufsize, parse_data->offset, &next_start, next_size);
(guint8 *) buf, &bufsize, parse_data->offset_orig, &next_start,
next_size);
break;
default:
/* unexpected */
@ -115,7 +119,7 @@ metadataparse_parse (ParseData * parse_data, const guint8 * buf,
}
*next_offset = next_start - buf;
parse_data->offset += *next_offset;
parse_data->offset_orig += *next_offset;
done:
@ -139,34 +143,24 @@ metadataparse_dispose (ParseData * parse_data)
break;
}
if (parse_data->xmp.adapter) {
gst_object_unref (parse_data->xmp.adapter);
metadata_chunk_array_free (&parse_data->strip_chunks);
metadata_chunk_array_free (&parse_data->inject_chunks);
if (parse_data->xmp_adapter) {
gst_object_unref (parse_data->xmp_adapter);
parse_data->xmp_adapter = NULL;
}
if (parse_data->iptc.adapter) {
gst_object_unref (parse_data->iptc.adapter);
if (parse_data->iptc_adapter) {
gst_object_unref (parse_data->iptc_adapter);
parse_data->iptc_adapter = NULL;
}
if (parse_data->exif.adapter) {
gst_object_unref (parse_data->exif.adapter);
if (parse_data->exif_adapter) {
gst_object_unref (parse_data->exif_adapter);
parse_data->exif_adapter = NULL;
}
if (parse_data->xmp.buffer) {
free (parse_data->xmp.buffer);
}
if (parse_data->iptc.buffer) {
free (parse_data->iptc.buffer);
}
if (parse_data->exif.buffer) {
free (parse_data->exif.buffer);
}
memset (&parse_data->xmp, 0x00, sizeof (MetadataChunk));
memset (&parse_data->iptc, 0x00, sizeof (MetadataChunk));
memset (&parse_data->exif, 0x00, sizeof (MetadataChunk));
}
/*
@ -180,9 +174,9 @@ metadataparse_parse_none (ParseData * parse_data, const guint8 * buf,
{
int ret = -1;
MetadataChunk *exif = NULL;
MetadataChunk *iptc = NULL;
MetadataChunk *xmp = NULL;
GstAdapter **exif = NULL;
GstAdapter **iptc = NULL;
GstAdapter **xmp = NULL;
*next_start = (guint8 *) buf;
@ -195,14 +189,15 @@ metadataparse_parse_none (ParseData * parse_data, const guint8 * buf,
}
if (parse_data->option & PARSE_OPT_EXIF)
exif = &parse_data->exif;
exif = &parse_data->exif_adapter;
if (parse_data->option & PARSE_OPT_IPTC)
iptc = &parse_data->iptc;
iptc = &parse_data->iptc_adapter;
if (parse_data->option & PARSE_OPT_XMP)
xmp = &parse_data->xmp;
xmp = &parse_data->xmp_adapter;
if (buf[0] == 0xFF && buf[1] == 0xD8 && buf[2] == 0xFF) {
metadataparse_jpeg_init (&parse_data->format_data.jpeg, exif, iptc, xmp);
metadataparse_jpeg_init (&parse_data->format_data.jpeg, exif, iptc, xmp,
&parse_data->strip_chunks, &parse_data->inject_chunks);
ret = 0;
parse_data->img_type = IMG_JPEG;
goto done;
@ -216,7 +211,8 @@ metadataparse_parse_none (ParseData * parse_data, const guint8 * buf,
if (buf[0] == 0x89 && buf[1] == 0x50 && buf[2] == 0x4E && buf[3] == 0x47 &&
buf[4] == 0x0D && buf[5] == 0x0A && buf[6] == 0x1A && buf[7] == 0x0A) {
metadataparse_png_init (&parse_data->format_data.png, exif, iptc, xmp);
metadataparse_png_init (&parse_data->format_data.png, exif, iptc, xmp,
&parse_data->strip_chunks, &parse_data->inject_chunks);
ret = 0;
parse_data->img_type = IMG_PNG;
goto done;

14
ext/metadata/metadataparse.h
View file

@ -45,7 +45,7 @@
#define __METADATAPARSE_H__
#include <gst/base/gstadapter.h>
#include "metadataparsetypes.h"
#include "metadatatypes.h"
#include "metadataparsejpeg.h"
#include "metadataparsepng.h"
@ -79,15 +79,19 @@ typedef struct _tag_ParseData
ParseState state;
ImageType img_type;
ParseOption option;
guint32 offset; /* offset since begining of stream */
guint32 offset_orig; /* offset since begining of stream */
union
{
JpegData jpeg;
PngData png;
} format_data;
MetadataChunk exif;
MetadataChunk iptc;
MetadataChunk xmp;
GstAdapter * exif_adapter;
GstAdapter * iptc_adapter;
GstAdapter * xmp_adapter;
MetadataChunkArray strip_chunks;
MetadataChunkArray inject_chunks;
} ParseData;
#define PARSE_DATA_IMG_TYPE(p) (p).img_type

138
ext/metadata/metadataparsejpeg.c
View file

@ -71,16 +71,20 @@ metadataparse_jpeg_jump (JpegData * jpeg_data, guint8 ** buf,
#define READ(buf, size) ( (size)--, *((buf)++) )
void
metadataparse_jpeg_init (JpegData * jpeg_data, MetadataChunk * exif,
MetadataChunk * iptc, MetadataChunk * xmp)
metadataparse_jpeg_init (JpegData * jpeg_data, GstAdapter ** exif_adpt,
GstAdapter ** iptc_adpt, GstAdapter ** xmp_adpt,
MetadataChunkArray * strip_chunks, MetadataChunkArray * inject_chunks)
{
jpeg_data->state = JPEG_NULL;
jpeg_data->exif = exif;
jpeg_data->iptc = iptc;
jpeg_data->xmp = xmp;
jpeg_data->exif_adapter = exif_adpt;
jpeg_data->iptc_adapter = iptc_adpt;
jpeg_data->xmp_adapter = xmp_adpt;
jpeg_data->read = 0;
jpeg_data->jfif_found = FALSE;
jpeg_data->strip_chunks = strip_chunks;
jpeg_data->inject_chunks = inject_chunks;
metadataparse_xmp_init ();
}
@ -89,9 +93,9 @@ metadataparse_jpeg_dispose (JpegData * jpeg_data)
{
metadataparse_xmp_dispose ();
jpeg_data->exif = NULL;
jpeg_data->iptc = NULL;
jpeg_data->xmp = NULL;
jpeg_data->exif_adapter = NULL;
jpeg_data->iptc_adapter = NULL;
jpeg_data->xmp_adapter = NULL;
}
int
@ -242,28 +246,42 @@ metadataparse_jpeg_reading (JpegData * jpeg_data, guint8 ** buf,
goto done;
}
if (jpeg_data->exif) {
if (0 == memcmp (ExifHeader, *buf, 6)) {
jpeg_data->exif->offset = (*buf - step_buf) + offset - 4; /* maker + size */
jpeg_data->exif->size = chunk_size + 2; /* chunk size plus app marker */
if (0 == memcmp (ExifHeader, *buf, 6)) {
MetadataChunk chunk;
memset (&chunk, 0x00, sizeof (MetadataChunk));
chunk.offset_orig = (*buf - step_buf) + offset - 4; /* maker + size */
chunk.size = chunk_size + 2; /* chunk size plus app marker */
metadata_chunk_array_append_sorted (jpeg_data->strip_chunks, &chunk);
if (!jpeg_data->jfif_found) {
/* only inject if no JFIF has been found */
static const guint8 segment[] = { 0xff, 0xe0, 0x00, 0x10,
0x4a, 0x46, 0x49, 0x46, 0x00,
0x01, 0x02,
0x00, 0x00, 0x01, 0x00, 0x01,
0x00, 0x00
};
memset (&chunk, 0x00, sizeof (MetadataChunk));
chunk.offset_orig = 2;
chunk.size = 18;
chunk.data = g_new (guint8, 18);
memcpy (chunk.data, segment, 18);
metadata_chunk_array_append_sorted (jpeg_data->inject_chunks,
&chunk);
}
if (jpeg_data->exif_adapter) {
jpeg_data->read = chunk_size - 2;
ret = 0;
if (!jpeg_data->jfif_found) {
static const guint8 chunk[] = { 0xff, 0xe0, 0x00, 0x10,
0x4a, 0x46, 0x49, 0x46, 0x00,
0x01, 0x02,
0x00, 0x00, 0x01, 0x00, 0x01,
0x00, 0x00
};
/* only inject if no JFIF has been found */
jpeg_data->exif->size_inject = 18;
jpeg_data->exif->buffer = malloc (18);
memcpy (jpeg_data->exif->buffer, chunk, 18);
}
jpeg_data->state = JPEG_EXIF;
ret = 0;
goto done;
}
}
@ -274,15 +292,23 @@ metadataparse_jpeg_reading (JpegData * jpeg_data, guint8 ** buf,
goto done;
}
if (jpeg_data->xmp) {
if (0 == memcmp (XmpHeader, *buf, 29)) {
jpeg_data->xmp->offset = (*buf - step_buf) + offset - 4; /* maker + size */
jpeg_data->xmp->size = chunk_size + 2; /* chunk size plus app marker */
if (0 == memcmp (XmpHeader, *buf, 29)) {
MetadataChunk chunk;
memset (&chunk, 0x00, sizeof (MetadataChunk));
chunk.offset_orig = (*buf - step_buf) + offset - 4; /* maker + size */
chunk.size = chunk_size + 2; /* chunk size plus app marker */
metadata_chunk_array_append_sorted (jpeg_data->strip_chunks,
&chunk);
/* if adapter has been provided, prepare to hold chunk */
if (jpeg_data->xmp_adapter) {
*buf += 29;
*bufsize -= 29;
jpeg_data->read = chunk_size - 2 - 29;
ret = 0;
jpeg_data->state = JPEG_XMP;
ret = 0;
goto done;
}
}
@ -297,13 +323,21 @@ metadataparse_jpeg_reading (JpegData * jpeg_data, guint8 ** buf,
goto done;
}
if (jpeg_data->iptc) {
if (0 == memcmp (IptcHeader, *buf, 14)) {
jpeg_data->iptc->offset = (*buf - step_buf) + offset - 4; /* maker + size */
jpeg_data->iptc->size = chunk_size + 2; /* chunk size plus app marker */
if (0 == memcmp (IptcHeader, *buf, 14)) {
MetadataChunk chunk;
memset (&chunk, 0x00, sizeof (MetadataChunk));
chunk.offset_orig = (*buf - step_buf) + offset - 4; /* maker + size */
chunk.size = chunk_size + 2; /* chunk size plus app marker */
metadata_chunk_array_append_sorted (jpeg_data->strip_chunks, &chunk);
/* if adapter has been provided, prepare to hold chunk */
if (jpeg_data->iptc_adapter) {
jpeg_data->read = chunk_size - 2;
ret = 0;
jpeg_data->state = JPEG_IPTC;
ret = 0;
goto done;
}
}
@ -335,13 +369,13 @@ metadataparse_jpeg_exif (JpegData * jpeg_data, guint8 ** buf,
int ret;
ret = metadataparse_util_hold_chunk (&jpeg_data->read, buf,
bufsize, next_start, next_size, &jpeg_data->exif->adapter);
bufsize, next_start, next_size, jpeg_data->exif_adapter);
if (ret == 0) {
jpeg_data->state = JPEG_READING;
/* if there is a second Exif chunk in the file it will be jumped */
jpeg_data->exif = NULL;
jpeg_data->exif_adapter = NULL;
}
return ret;
@ -355,7 +389,7 @@ metadataparse_jpeg_iptc (JpegData * jpeg_data, guint8 ** buf,
int ret;
ret = metadataparse_util_hold_chunk (&jpeg_data->read, buf,
bufsize, next_start, next_size, &jpeg_data->iptc->adapter);
bufsize, next_start, next_size, jpeg_data->iptc_adapter);
if (ret == 0) {
@ -367,8 +401,8 @@ metadataparse_jpeg_iptc (JpegData * jpeg_data, guint8 ** buf,
jpeg_data->state = JPEG_READING;
size = gst_adapter_available (jpeg_data->iptc->adapter);
buf = gst_adapter_peek (jpeg_data->iptc->adapter, size);
size = gst_adapter_available (*jpeg_data->iptc_adapter);
buf = gst_adapter_peek (*jpeg_data->iptc_adapter, size);
res = iptc_jpeg_ps3_find_iptc (buf, size, &iptc_len);
@ -377,21 +411,21 @@ metadataparse_jpeg_iptc (JpegData * jpeg_data, guint8 ** buf,
ret = -1;
} else if (res == 0) {
/* no iptc data found */
gst_adapter_clear (jpeg_data->iptc->adapter);
gst_adapter_clear (*jpeg_data->iptc_adapter);
} else {
gst_adapter_flush (jpeg_data->iptc->adapter, res);
size = gst_adapter_available (jpeg_data->iptc->adapter);
gst_adapter_flush (*jpeg_data->iptc_adapter, res);
size = gst_adapter_available (*jpeg_data->iptc_adapter);
if (size > iptc_len) {
GstBuffer *buf;
buf = gst_adapter_take_buffer (jpeg_data->iptc->adapter, iptc_len);
gst_adapter_clear (jpeg_data->iptc->adapter);
gst_adapter_push (jpeg_data->iptc->adapter, buf);
buf = gst_adapter_take_buffer (*jpeg_data->iptc_adapter, iptc_len);
gst_adapter_clear (*jpeg_data->iptc_adapter);
gst_adapter_push (*jpeg_data->iptc_adapter, buf);
}
}
/* if there is a second Iptc chunk in the file it will be jumped */
jpeg_data->iptc = NULL;
jpeg_data->iptc_adapter = NULL;
}
@ -406,12 +440,12 @@ metadataparse_jpeg_xmp (JpegData * jpeg_data, guint8 ** buf,
int ret;
ret = metadataparse_util_hold_chunk (&jpeg_data->read, buf,
bufsize, next_start, next_size, &jpeg_data->xmp->adapter);
bufsize, next_start, next_size, jpeg_data->xmp_adapter);
if (ret == 0) {
jpeg_data->state = JPEG_READING;
/* if there is a second XMP chunk in the file it will be jumped */
jpeg_data->xmp = NULL;
jpeg_data->xmp_adapter = NULL;
}
return ret;
}

20
ext/metadata/metadataparsejpeg.h
View file

@ -44,7 +44,9 @@
#ifndef __METADATAPARSE_JPEG_H__
#define __METADATAPARSE_JPEG_H__
#include "metadataparsetypes.h"
#include <gst/base/gstadapter.h>
#include "metadatatypes.h"
G_BEGIN_DECLS
@ -63,17 +65,23 @@ typedef enum _tag_JpegState
typedef struct _tag_JpegData
{
JpegState state;
MetadataChunk *exif;
MetadataChunk *iptc;
MetadataChunk *xmp;
GstAdapter ** exif_adapter;
GstAdapter ** iptc_adapter;
GstAdapter ** xmp_adapter;
MetadataChunkArray * strip_chunks;
MetadataChunkArray * inject_chunks;
guint32 read;
gboolean jfif_found;
} JpegData;
extern void
metadataparse_jpeg_init (JpegData * jpeg_data, MetadataChunk * adpt_exif,
MetadataChunk * adpt_iptc, MetadataChunk * adpt_xmp);
metadataparse_jpeg_init (JpegData * jpeg_data, GstAdapter ** exif_adpt,
GstAdapter ** iptc_adpt, GstAdapter ** xmp_adpt,
MetadataChunkArray * strip_chunks, MetadataChunkArray * inject_chunks);
extern void metadataparse_jpeg_dispose (JpegData * jpeg_data);

31
ext/metadata/metadataparsepng.c
View file

@ -61,13 +61,17 @@ metadataparse_png_jump (PngData * png_data, guint8 ** buf,
#define READ(buf, size) ( (size)--, *((buf)++) )
void
metadataparse_png_init (PngData * png_data, MetadataChunk * exif,
MetadataChunk * iptc, MetadataChunk * xmp)
metadataparse_png_init (PngData * png_data, GstAdapter ** exif_adpt,
GstAdapter ** iptc_adpt, GstAdapter ** xmp_adpt,
MetadataChunkArray * strip_chunks, MetadataChunkArray * inject_chunks)
{
png_data->state = PNG_NULL;
png_data->xmp = xmp;
png_data->xmp_adapter = xmp_adpt;
png_data->read = 0;
png_data->strip_chunks = strip_chunks;
png_data->inject_chunks = inject_chunks;
metadataparse_xmp_init ();
}
@ -76,7 +80,7 @@ metadataparse_png_dispose (PngData * png_data)
{
metadataparse_xmp_dispose ();
png_data->xmp = NULL;
png_data->xmp_adapter = NULL;
}
int
@ -197,10 +201,17 @@ metadataparse_png_reading (PngData * png_data, guint8 ** buf,
goto done;
}
if (png_data->xmp) {
if (0 == memcmp (XmpHeader, *buf, 18)) {
png_data->xmp->offset = (*buf - step_buf) + offset - 8; /* maker + size */
png_data->xmp->size = chunk_size + 12; /* chunk size plus app marker plus crc */
if (0 == memcmp (XmpHeader, *buf, 18)) {
MetadataChunk chunk;
memset (&chunk, 0x00, sizeof (MetadataChunk));
chunk.offset_orig = (*buf - step_buf) + offset - 8; /* maker + size */
chunk.size = chunk_size + 12; /* chunk size plus app marker plus crc */
metadata_chunk_array_append_sorted (png_data->strip_chunks, &chunk);
/* if adapter has been provided, prepare to hold chunk */
if (png_data->xmp_adapter) {
*buf += 22; /* jump "XML:com.adobe.xmp" plus some flags */
*bufsize -= 22;
png_data->read = chunk_size - 22; /* four CRC bytes at the end will be jumped after */
@ -240,13 +251,13 @@ metadataparse_png_xmp (PngData * png_data, guint8 ** buf,
int ret;
ret = metadataparse_util_hold_chunk (&png_data->read, buf,
bufsize, next_start, next_size, &png_data->xmp->adapter);
bufsize, next_start, next_size, png_data->xmp_adapter);
if (ret == 0) {
/* jump four CRC bytes at the end of chunk */
png_data->read = 4;
png_data->state = PNG_JUMPING;
/* if there is a second XMP chunk in the file it will be jumped */
png_data->xmp = NULL;
png_data->xmp_adapter = NULL;
}
return ret;

16
ext/metadata/metadataparsepng.h
View file

@ -44,7 +44,9 @@
#ifndef __METADATAPARSE_PNG_H__
#define __METADATAPARSE_PNG_H__
#include "metadataparsetypes.h"
#include <gst/base/gstadapter.h>
#include "metadatatypes.h"
G_BEGIN_DECLS
@ -61,14 +63,20 @@ typedef enum _tag_PngState
typedef struct _tag_PngData
{
PngState state;
MetadataChunk *xmp;
GstAdapter ** xmp_adapter;
MetadataChunkArray * strip_chunks;
MetadataChunkArray * inject_chunks;
guint32 read;
} PngData;
extern void
metadataparse_png_init (PngData * png_data, MetadataChunk *exif,
MetadataChunk * iptc, MetadataChunk *xmp);
metadataparse_png_init (PngData * png_data, GstAdapter ** exif_adpt,
GstAdapter ** iptc_adpt, GstAdapter ** xmp_adpt,
MetadataChunkArray * strip_chunks, MetadataChunkArray * inject_chunks);
extern void metadataparse_png_dispose (PngData * png_data);

115
ext/metadata/metadatatypes.c Normal file
View file

@ -0,0 +1,115 @@
/*
* 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.
*/
#include "metadatatypes.h"
#include <string.h>
void
metadata_chunk_array_init (MetadataChunkArray * array, gsize alloc_size)
{
array->len = 0;
array->chunk = g_new0 (MetadataChunk, alloc_size);
array->allocated_len = alloc_size;
}
void
metadata_chunk_array_free (MetadataChunkArray * array)
{
metadata_chunk_array_clear (array);
array->allocated_len = 0;
if (array->chunk) {
g_free (array->chunk);
array->chunk = NULL;
}
}
void
metadata_chunk_array_clear (MetadataChunkArray * array)
{
while (array->len) {
array->len--;
if (array->chunk[array->len].data) {
g_free (array->chunk[array->len].data);
}
}
}
void
metadata_chunk_array_append (MetadataChunkArray * array, MetadataChunk * chunk)
{
if (array->len == array->allocated_len) {
array->allocated_len += 2;
array->chunk = g_realloc (array->chunk, array->allocated_len);
}
memcpy (&array->chunk[array->len], chunk, sizeof (MetadataChunk));
++array->len;
}
void
metadata_chunk_array_append_sorted (MetadataChunkArray * array,
MetadataChunk * chunk)
{
gint32 i, pos;
if (array->len == array->allocated_len) {
array->allocated_len += 2;
array->chunk = g_realloc (array->chunk, array->allocated_len);
}
pos = array->len;
for (i = array->len - 1; i >= 0; --i) {
if (chunk->offset_orig > array->chunk[i].offset_orig) {
break;
}
}
pos = i + 1;
if (pos < array->len) {
memmove (&array->chunk[pos + 1], &array->chunk[pos],
sizeof (MetadataChunk) * (array->len - pos));
}
memcpy (&array->chunk[pos], chunk, sizeof (MetadataChunk));
++array->len;
return;
}

85
ext/metadata/metadatatypes.h Normal file
View file

@ -0,0 +1,85 @@
/*
* 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 __METADATATYPES_H__
#define __METADATATYPES_H__
#include <glib.h>
G_BEGIN_DECLS
typedef struct _tag_MetadataChunk
{
gint64 offset_orig; /* from the beginning of original file */
gint64 offset; /*here just for convinience (filled by element) offset in new stream */
guint32 size; /* chunk or buffer size*/
guint8 * data;
} MetadataChunk;
typedef struct _tag_MetadataChunkArray
{
MetadataChunk * chunk;
gsize len;
gsize allocated_len;
} MetadataChunkArray;
extern void
metadata_chunk_array_init(MetadataChunkArray * array, gsize alloc_size);
extern void
metadata_chunk_array_free(MetadataChunkArray * array);
extern void
metadata_chunk_array_clear(MetadataChunkArray * array);
extern void
metadata_chunk_array_append(MetadataChunkArray * array, MetadataChunk * chunk);
/* sorted by offset (chunk supposed to be already sorted
* returns false if chunks are inserted in same offset
*/
extern void
metadata_chunk_array_append_sorted(MetadataChunkArray * array, MetadataChunk * chunk);
G_END_DECLS
#endif /* __METADATATYPES_H__ */