mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-07-02 20:55:55 +00:00
Code Issues 1 Projects Releases Wiki Activity

spc: Add the OpenSPC spc plugin again

Browse source 
The gme plugin obsoletes it but it might still be useful
for users that don't have gme yet or prefer openspc for some reason.
This commit is contained in:
Sebastian Dröge 2009-08-08 21:17:37 +02:00
parent 24217ee31a
commit 8ad3f14873
7 changed files with 1092 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
configure.ac
View file

@ -1369,6 +1369,22 @@ AG_GST_CHECK_FEATURE(SOUNDTOUCH, [soundtouch plug-in], soundtouch, [
fi
])
dnl *** spc ***
translit(dnm, m, l) AM_CONDITIONAL(USE_SPC, true)
AG_GST_CHECK_FEATURE(SPC, [spc decoder], spc, [
AC_CHECK_HEADER(openspc.h, [
AC_CHECK_LIB(openspc, OSPC_Init, [
SPC_LIBS="-lopenspc"
AC_SUBST(SPC_LIBS)
HAVE_SPC=yes
], [
HAVE_SPC=no
])
], [
HAVE_SPC=no
])
])
dnl *** gme ***
translit(dnm, m, l) AM_CONDITIONAL(USE_GME, true)
AG_GST_CHECK_FEATURE(GME, [gme decoder], gme, [
@ -1567,6 +1583,7 @@ AM_CONDITIONAL(USE_SDL, false)
AM_CONDITIONAL(USE_SNDFILE, false)
AM_CONDITIONAL(USE_SOUNDTOUCH, false)
AM_CONDITIONAL(USE_GME, false)
AM_CONDITIONAL(USE_SPC, false)
AM_CONDITIONAL(USE_SWFDEC, false)
AM_CONDITIONAL(USE_THEORADEC, false)
AM_CONDITIONAL(USE_TIMIDITY, false)
@ -1768,6 +1785,7 @@ ext/sdl/Makefile
ext/sndfile/Makefile
ext/soundtouch/Makefile
ext/gme/Makefile
ext/spc/Makefile
ext/swfdec/Makefile
ext/theora/Makefile
ext/timidity/Makefile

8
ext/Makefile.am
View file

@ -306,6 +306,12 @@ else
SOUNDTOUCH_DIR=
endif
if USE_SPC
SPC_DIR=gme
else
SPC_DIR=
endif
if USE_GME
GME_DIR=gme
else
@ -393,6 +399,7 @@ SUBDIRS=\
$(SNDFILE_DIR) \
$(SOUNDTOUCH_DIR) \
$(GME_DIR) \
$(SPC_DIR) \
$(SWFDEC_DIR) \
$(TARKIN_DIR) \
$(THEORA_DIR) \
@ -439,6 +446,7 @@ DIST_SUBDIRS = \
sdl \
sndfile \
soundtouch \
spc \
gme \
swfdec \
theora \

11
ext/spc/Makefile.am Normal file
View file

@ -0,0 +1,11 @@
plugin_LTLIBRARIES = libgstspc.la
libgstspc_la_SOURCES = gstspc.c tag.c
libgstspc_la_CFLAGS = $(GST_CFLAGS) $(SPC_CFLAGS)
libgstspc_la_LIBADD = $(GST_LIBS) $(SPC_LIBS)
libgstspc_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
libgstspc_la_LIBTOOLFLAGS = --tag=disable-static
noinst_HEADERS = gstspc.h tag.h

595
ext/spc/gstspc.c Normal file
View file

@ -0,0 +1,595 @@
/* Copyright (C) 2004-2005 Michael Pyne <michael dot pyne at kdemail net>
* Copyright (C) 2004-2006 Chris Lee <clee at kde org>
* Copyright (C) 2007 Brian Koropoff <bkoropoff at gmail com>
*
* 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.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "gstspc.h"
#include <string.h>
#include <glib/gprintf.h>
#include <glib.h>
static const GstElementDetails gst_spc_dec_details =
GST_ELEMENT_DETAILS ("OpenSPC SPC decoder",
"Codec/Audio/Decoder",
"Uses OpenSPC to emulate an SPC processor",
"Chris Lee <clee@kde.org>, Brian Koropoff <bkoropoff@gmail.com>");
static GstStaticPadTemplate sink_factory =
GST_STATIC_PAD_TEMPLATE ("sink", GST_PAD_SINK, GST_PAD_ALWAYS,
GST_STATIC_CAPS ("audio/x-spc"));
static GstStaticPadTemplate src_factory =
GST_STATIC_PAD_TEMPLATE ("src", GST_PAD_SRC, GST_PAD_ALWAYS,
GST_STATIC_CAPS ("audio/x-raw-int, "
"endianness = (int) BYTE_ORDER, "
"signed = (boolean) TRUE, "
"width = (int) 16, "
"depth = (int) 16, " "rate = (int) 32000, " "channels = (int) 2"));
GST_BOILERPLATE (GstSpcDec, gst_spc_dec, GstElement, GST_TYPE_ELEMENT);
static GstFlowReturn gst_spc_dec_chain (GstPad * pad, GstBuffer * buffer);
static gboolean gst_spc_dec_sink_event (GstPad * pad, GstEvent * event);
static gboolean gst_spc_dec_src_event (GstPad * pad, GstEvent * event);
static gboolean gst_spc_dec_src_query (GstPad * pad, GstQuery * query);
static GstStateChangeReturn gst_spc_dec_change_state (GstElement * element,
GstStateChange transition);
static void spc_play (GstPad * pad);
static void gst_spc_dec_dispose (GObject * object);
static gboolean spc_setup (GstSpcDec * spc);
static gboolean
spc_negotiate (GstSpcDec * spc)
{
GstCaps *allowed, *caps;
GstStructure *structure;
gint width = 16, depth = 16;
gboolean sign;
int rate = 32000;
int channels = 2;
allowed = gst_pad_get_allowed_caps (spc->srcpad);
if (!allowed) {
GST_DEBUG_OBJECT (spc, "couldn't get allowed caps");
return FALSE;
}
GST_DEBUG_OBJECT (spc, "allowed caps: %" GST_PTR_FORMAT, allowed);
structure = gst_caps_get_structure (allowed, 0);
gst_structure_get_int (structure, "width", &width);
gst_structure_get_int (structure, "depth", &depth);
if (width && depth && width != depth) {
GST_DEBUG_OBJECT (spc, "width %d and depth %d are different", width, depth);
gst_caps_unref (allowed);
return FALSE;
}
gst_structure_get_boolean (structure, "signed", &sign);
gst_structure_get_int (structure, "rate", &rate);
gst_structure_get_int (structure, "channels", &channels);
caps = gst_caps_new_simple ("audio/x-raw-int",
"endianness", G_TYPE_INT, G_BYTE_ORDER,
"signed", G_TYPE_BOOLEAN, TRUE,
"width", G_TYPE_INT, width,
"depth", G_TYPE_INT, depth,
"rate", G_TYPE_INT, rate, "channels", G_TYPE_INT, channels, NULL);
gst_pad_set_caps (spc->srcpad, caps);
gst_caps_unref (caps);
gst_caps_unref (allowed);
return TRUE;
}
static void
gst_spc_dec_base_init (gpointer g_class)
{
GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);
gst_element_class_set_details (element_class, &gst_spc_dec_details);
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&sink_factory));
gst_element_class_add_pad_template (element_class,
gst_static_pad_template_get (&src_factory));
}
static void
gst_spc_dec_class_init (GstSpcDecClass * klass)
{
GstElementClass *element_class = (GstElementClass *) klass;
GObjectClass *gobject_class = (GObjectClass *) klass;
element_class->change_state = GST_DEBUG_FUNCPTR (gst_spc_dec_change_state);
gobject_class->dispose = gst_spc_dec_dispose;
}
static const GstQueryType *
gst_spc_dec_src_query_type (GstPad * pad)
{
static const GstQueryType query_types[] = {
GST_QUERY_DURATION,
GST_QUERY_POSITION,
(GstQueryType) 0
};
return query_types;
}
static void
gst_spc_dec_init (GstSpcDec * spc, GstSpcDecClass * klass)
{
spc->sinkpad = gst_pad_new_from_static_template (&sink_factory, "sink");
/* gst_pad_set_query_function (spc->sinkpad, NULL); */
gst_pad_set_event_function (spc->sinkpad, gst_spc_dec_sink_event);
gst_pad_set_chain_function (spc->sinkpad, gst_spc_dec_chain);
gst_element_add_pad (GST_ELEMENT (spc), spc->sinkpad);
spc->srcpad = gst_pad_new_from_static_template (&src_factory, "src");
gst_pad_set_event_function (spc->srcpad, gst_spc_dec_src_event);
gst_pad_set_query_function (spc->srcpad, gst_spc_dec_src_query);
gst_pad_set_query_type_function (spc->srcpad, gst_spc_dec_src_query_type);
gst_pad_use_fixed_caps (spc->srcpad);
gst_element_add_pad (GST_ELEMENT (spc), spc->srcpad);
spc->buf = NULL;
spc->initialized = FALSE;
spc_tag_clear (&spc->tag_info);
}
static void
gst_spc_dec_dispose (GObject * object)
{
GstSpcDec *spc = GST_SPC_DEC (object);
if (spc->buf) {
gst_buffer_unref (spc->buf);
spc->buf = NULL;
}
spc_tag_free (&spc->tag_info);
}
static GstFlowReturn
gst_spc_dec_chain (GstPad * pad, GstBuffer * buffer)
{
GstSpcDec *spc = GST_SPC_DEC (gst_pad_get_parent (pad));
if (spc->buf) {
spc->buf = gst_buffer_join (spc->buf, buffer);
} else {
spc->buf = buffer;
}
gst_object_unref (spc);
return GST_FLOW_OK;
}
static gboolean
gst_spc_dec_sink_event (GstPad * pad, GstEvent * event)
{
GstSpcDec *spc = GST_SPC_DEC (gst_pad_get_parent (pad));
gboolean result = TRUE;
gboolean forward = FALSE;
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
/* we get EOS when we loaded the complete file, now try to initialize the
* decoding */
if (!(result = spc_setup (spc))) {
/* can't start, post an ERROR and push EOS downstream */
GST_ELEMENT_ERROR (spc, STREAM, DEMUX, (NULL),
("can't start playback"));
forward = TRUE;
}
break;
default:
break;
}
if (forward)
result = gst_pad_push_event (spc->srcpad, event);
else
gst_event_unref (event);
gst_object_unref (spc);
return result;
}
static gint64
gst_spc_duration (GstSpcDec * spc)
{
gint64 total_ticks =
spc->tag_info.time_intro +
spc->tag_info.time_loop * spc->tag_info.loop_count +
spc->tag_info.time_end;
if (total_ticks) {
return (gint64) gst_util_uint64_scale (total_ticks, GST_SECOND, 64000);
} else if (spc->tag_info.time_seconds) {
gint64 time = (gint64) spc->tag_info.time_seconds * GST_SECOND;
return time;
} else {
return (gint64) (3 * 60) * GST_SECOND;
}
}
static gint64
gst_spc_fadeout (GstSpcDec * spc)
{
if (spc->tag_info.time_fade) {
return (gint64) gst_util_uint64_scale ((guint64) spc->tag_info.time_fade,
GST_SECOND, 64000);
} else if (spc->tag_info.time_fade_milliseconds) {
return (gint64) (spc->tag_info.time_fade_milliseconds * GST_MSECOND);
} else {
return 10 * GST_SECOND;
}
}
static gboolean
gst_spc_dec_src_event (GstPad * pad, GstEvent * event)
{
GstSpcDec *spc = GST_SPC_DEC (gst_pad_get_parent (pad));
gboolean result = FALSE;
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_SEEK:
{
gdouble rate;
GstFormat format;
GstSeekFlags flags;
GstSeekType start_type, stop_type;
gint64 start, stop;
gboolean flush;
gst_event_parse_seek (event, &rate, &format, &flags, &start_type, &start,
&stop_type, &stop);
if (format != GST_FORMAT_TIME) {
GST_DEBUG_OBJECT (spc, "seeking is only supported in TIME format");
break;
}
if (start_type != GST_SEEK_TYPE_SET || stop_type != GST_SEEK_TYPE_NONE) {
GST_DEBUG_OBJECT (spc, "unsupported seek type");
break;
}
if (stop_type == GST_SEEK_TYPE_NONE)
stop = GST_CLOCK_TIME_NONE;
if (start_type == GST_SEEK_TYPE_SET) {
guint64 cur =
gst_util_uint64_scale (spc->byte_pos, GST_SECOND, 32000 * 2 * 2);
guint64 dest = (guint64) start;
dest = CLAMP (dest, 0, gst_spc_duration (spc) + gst_spc_fadeout (spc));
if (dest == cur)
break;
flush = (flags & GST_SEEK_FLAG_FLUSH) == GST_SEEK_FLAG_FLUSH;
if (flush) {
gst_pad_push_event (spc->srcpad, gst_event_new_flush_start ());
} else {
gst_pad_stop_task (spc->srcpad);
}
GST_PAD_STREAM_LOCK (spc->srcpad);
if (flags & GST_SEEK_FLAG_SEGMENT) {
gst_element_post_message (GST_ELEMENT (spc),
gst_message_new_segment_start (GST_OBJECT (spc), format, cur));
}
if (flush) {
gst_pad_push_event (spc->srcpad, gst_event_new_flush_stop ());
}
if (stop == GST_CLOCK_TIME_NONE)
stop = (guint64) (gst_spc_duration (spc) + gst_spc_fadeout (spc));
gst_pad_push_event (spc->srcpad, gst_event_new_new_segment (FALSE, rate,
GST_FORMAT_TIME, dest, stop, dest));
/* spc->byte_pos += OSPC_Run(-1, NULL, (unsigned int) (gst_util_uint64_scale(dest - cur, 32000*2*2, GST_SECOND))); */
spc->seekpoint =
gst_util_uint64_scale (dest, 32000 * 2 * 2, GST_SECOND);
spc->seeking = TRUE;
gst_pad_start_task (spc->srcpad, (GstTaskFunction) spc_play,
spc->srcpad);
GST_PAD_STREAM_UNLOCK (spc->srcpad);
result = TRUE;
}
break;
}
default:
break;
}
gst_event_unref (event);
gst_object_unref (spc);
return result;
}
static gboolean
gst_spc_dec_src_query (GstPad * pad, GstQuery * query)
{
GstSpcDec *spc = GST_SPC_DEC (gst_pad_get_parent (pad));
gboolean result = TRUE;
switch (GST_QUERY_TYPE (query)) {
case GST_QUERY_DURATION:
{
GstFormat format;
gst_query_parse_duration (query, &format, NULL);
if (!spc->initialized || format != GST_FORMAT_TIME) {
result = FALSE;
break;
}
gst_query_set_duration (query, GST_FORMAT_TIME,
gst_spc_duration (spc) + gst_spc_fadeout (spc));
break;
}
case GST_QUERY_POSITION:
{
GstFormat format;
gst_query_parse_position (query, &format, NULL);
if (!spc->initialized || format != GST_FORMAT_TIME) {
result = FALSE;
break;
}
gst_query_set_position (query, GST_FORMAT_TIME,
(gint64) gst_util_uint64_scale (spc->byte_pos, GST_SECOND,
32000 * 2 * 2));
break;
}
default:
result = gst_pad_query_default (pad, query);
break;
}
gst_object_unref (spc);
return result;
}
static void
spc_play (GstPad * pad)
{
GstSpcDec *spc = GST_SPC_DEC (gst_pad_get_parent (pad));
GstFlowReturn flow_return;
GstBuffer *out;
gboolean seeking = spc->seeking;
gint64 duration, fade, end, position;
if (!seeking) {
out = gst_buffer_new_and_alloc (1600 * 4);
gst_buffer_set_caps (out, GST_PAD_CAPS (pad));
GST_BUFFER_TIMESTAMP (out) =
(gint64) gst_util_uint64_scale ((guint64) spc->byte_pos, GST_SECOND,
32000 * 2 * 2);
spc->byte_pos += OSPC_Run (-1, (short *) GST_BUFFER_DATA (out), 1600 * 4);
} else {
if (spc->seekpoint < spc->byte_pos) {
OSPC_Init (GST_BUFFER_DATA (spc->buf), GST_BUFFER_SIZE (spc->buf));
spc->byte_pos = 0;
}
spc->byte_pos += OSPC_Run (-1, NULL, 1600 * 4);
if (spc->byte_pos >= spc->seekpoint) {
spc->seeking = FALSE;
}
out = gst_buffer_new ();
gst_buffer_set_caps (out, GST_PAD_CAPS (pad));
}
duration = gst_spc_duration (spc);
fade = gst_spc_fadeout (spc);
end = duration + fade;
position =
(gint64) gst_util_uint64_scale ((guint64) spc->byte_pos, GST_SECOND,
32000 * 2 * 2);
if (position >= duration) {
gint16 *data = (gint16 *) GST_BUFFER_DATA (out);
guint32 size = GST_BUFFER_SIZE (out) / sizeof (gint16);
unsigned int i;
gint64 num = (fade - (position - duration));
for (i = 0; i < size; i++) {
/* Apply a parabolic volume envelope */
data[i] = (gint16) (data[i] * num / fade * num / fade);
}
}
if ((flow_return = gst_pad_push (spc->srcpad, out)) != GST_FLOW_OK) {
GST_DEBUG_OBJECT (spc, "pausing task, reason %s",
gst_flow_get_name (flow_return));
gst_pad_pause_task (pad);
if (GST_FLOW_IS_FATAL (flow_return) || flow_return == GST_FLOW_NOT_LINKED) {
gst_pad_push_event (pad, gst_event_new_eos ());
}
}
if (position >= end) {
gst_pad_pause_task (pad);
gst_pad_push_event (pad, gst_event_new_eos ());
}
gst_object_unref (spc);
return;
}
static gboolean
spc_setup (GstSpcDec * spc)
{
spc_tag_info *info;
GstTagList *taglist;
guint64 total_duration;
if (!spc->buf || !spc_negotiate (spc)) {
return FALSE;
}
info = &(spc->tag_info);
spc_tag_get_info (GST_BUFFER_DATA (spc->buf), GST_BUFFER_SIZE (spc->buf),
info);
taglist = gst_tag_list_new ();
if (info->title)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_TITLE,
info->title, NULL);
if (info->artist)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_ARTIST,
info->artist, NULL);
/* Prefer the name of the official soundtrack over the name of the game (since this is
* how track numbers are derived)
*/
if (info->album)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_ALBUM,
info->album, NULL);
else if (info->game)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_ALBUM, info->game,
NULL);
if (info->year) {
GDate *date = g_date_new_dmy (1, 1, info->year);
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_DATE, date, NULL);
g_date_free (date);
}
if (info->track) {
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_TRACK_NUMBER,
info->track, NULL);
}
if (info->comment)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_COMMENT,
info->comment, NULL);
if (info->disc)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE,
GST_TAG_ALBUM_VOLUME_NUMBER, info->disc, NULL);
if (info->publisher)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_ORGANIZATION,
info->publisher, NULL);
if (info->dumper)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_CONTACT,
info->dumper, NULL);
if (info->emulator)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, GST_TAG_ENCODER,
info->emulator == EMU_ZSNES ? "ZSNES" : "Snes9x", NULL);
total_duration = (guint64) (gst_spc_duration (spc) + gst_spc_fadeout (spc));
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE,
GST_TAG_DURATION, total_duration,
GST_TAG_GENRE, "Game", GST_TAG_CODEC, "SPC700", NULL);
gst_element_found_tags_for_pad (GST_ELEMENT (spc), spc->srcpad, taglist);
/* spc_tag_info_free(&info); */
if (OSPC_Init (GST_BUFFER_DATA (spc->buf), GST_BUFFER_SIZE (spc->buf)) != 0) {
return FALSE;
}
gst_pad_push_event (spc->srcpad, gst_event_new_new_segment (FALSE, 1.0,
GST_FORMAT_TIME, 0, -1, 0));
gst_pad_start_task (spc->srcpad, (GstTaskFunction) spc_play, spc->srcpad);
/* We can't unreference this buffer because we might need to re-initialize
* the emulator with the original data during a reverse seek
* gst_buffer_unref (spc->buf);
* spc->buf = NULL;
*/
spc->initialized = TRUE;
spc->seeking = FALSE;
spc->seekpoint = 0;
spc->byte_pos = 0;
return spc->initialized;
}
static GstStateChangeReturn
gst_spc_dec_change_state (GstElement * element, GstStateChange transition)
{
GstStateChangeReturn result;
GstSpcDec *dec;
dec = GST_SPC_DEC (element);
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
break;
default:
break;
}
result = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
if (result == GST_STATE_CHANGE_FAILURE)
return result;
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:
if (dec->buf) {
gst_buffer_unref (dec->buf);
dec->buf = NULL;
}
break;
default:
break;
}
return result;
}
static gboolean
plugin_init (GstPlugin * plugin)
{
return gst_element_register (plugin, "spcdec", GST_RANK_PRIMARY,
GST_TYPE_SPC_DEC);
}
GST_PLUGIN_DEFINE (GST_VERSION_MAJOR,
GST_VERSION_MINOR,
"spcdec",
"OpenSPC Audio Decoder",
plugin_init, VERSION, "LGPL", GST_PACKAGE_NAME, GST_PACKAGE_ORIGIN);

70
ext/spc/gstspc.h Normal file
View file

@ -0,0 +1,70 @@
/* Copyright (C) 2004-2005 Michael Pyne <michael dot pyne at kdemail net>
* Copyright (C) 2004-2006 Chris Lee <clee at kde org>
* Copyright (C) 2007 Brian Koropoff <bkoropoff at gmail com>
*
* 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_SPC_DEC_H__
#define __GST_SPC_DEC_H__
#include <gst/gst.h>
#include <openspc.h>
#include "tag.h"
G_BEGIN_DECLS
#define GST_TYPE_SPC_DEC \
(gst_spc_dec_get_type())
#define GST_SPC_DEC(obj) \
(G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_SPC_DEC,GstSpcDec))
#define GST_SPC_DEC_CLASS(klass) \
(G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_SPC_DEC,GstSpcDecClass))
#define GST_IS_SPC_DEC(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_SPC_DEC))
#define GST_IS_SPC_DEC_CLASS(klass) \
(G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_SPC_DEC))
typedef struct _GstSpcDec GstSpcDec;
typedef struct _GstSpcDecClass GstSpcDecClass;
struct _GstSpcDec
{
GstElement element;
GstPad *sinkpad;
GstPad *srcpad;
GstBuffer *buf;
gboolean initialized;
gboolean seeking;
guint32 seekpoint;
spc_tag_info tag_info;
guint32 byte_pos;
};
struct _GstSpcDecClass
{
GstElementClass parent_class;
};
G_END_DECLS
#endif /* __GST_SPC_DEC_H__ */

353
ext/spc/tag.c Normal file
View file

@ -0,0 +1,353 @@
/* Copyright (C) 2007 Brian Koropoff <bkoropoff at gmail com>
*
* 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 <glib/gstring.h>
#include <glib/gtypes.h>
#include <glib/gmem.h>
#include <glib/gprintf.h>
#include <tag.h>
#include <string.h>
#include <stdlib.h>
#define EXTENDED_OFFSET 0x10200
#define EXTENDED_MAGIC ((guint32) ('x' << 0 | 'i' << 8 | 'd' << 16 | '6' << 24))
#define TYPE_LENGTH 0x0
#define TYPE_STRING 0x1
#define TYPE_INTEGER 0x4
#define TAG_TITLE 0x01
#define TAG_GAME 0x02
#define TAG_ARTIST 0x03
#define TAG_DUMPER 0x04
#define TAG_DUMP_DATE 0x05
#define TAG_EMULATOR 0x06
#define TAG_COMMENT 0x07
#define TAG_ALBUM 0x10
#define TAG_DISC 0x11
#define TAG_TRACK 0x12
#define TAG_PUBLISHER 0x13
#define TAG_YEAR 0x14
#define TAG_INTRO 0x30
#define TAG_LOOP 0x31
#define TAG_END 0x32
#define TAG_FADE 0x33
#define TAG_MUTED 0x34
#define TAG_COUNT 0x35
#define TAG_AMP 0x36
#define READ_INT8(data, offset) (data[offset])
#define READ_INT16(data, offset) ((data[offset] << 0) + (data[offset+1] << 8))
#define READ_INT24(data, offset) ((data[offset] << 0) + (data[offset+1] << 8) + (data[offset+2] << 16))
#define READ_INT32(data, offset) ((data[offset] << 0) + (data[offset+1] << 8) + (data[offset+2] << 16) + (data[offset+3] << 24))
static inline gboolean
spc_tag_is_extended (guchar * data, guint length)
{
// Extended tags come at the end of the file (at a known offset)
// and start with "xid6"
return (length > EXTENDED_OFFSET + 4
&& READ_INT32 (data, EXTENDED_OFFSET) == EXTENDED_MAGIC);
}
static inline gboolean
spc_tag_is_text_format (guchar * data, guint length)
{
// Because the id666 format is brain dead, there's
// no definite way to decide if it is in text
// format. This function implements a set of
// heuristics to make a best-effort guess.
// If the date field contains separators, it is probably text
if (data[0xA0] == '/' || data[0xA0] == '.')
return TRUE;
// If the first byte of the date field is small (but not 0,
// which could indicate an empty string), it's probably binary
if (data[0x9E] >= 1 && data[0x9E] <= 31)
return FALSE;
// If all previous tests turned up nothing, assume it's text
return TRUE;
}
static inline gboolean
spc_tag_is_present (guchar * data, guint length)
{
return data[0x23] == 26;
}
static inline GDate *
spc_tag_unpack_date (guint32 packed)
{
guint dump_year = packed / 10000;
guint dump_month = (packed % 10000) / 100;
guint dump_day = packed % 100;
if (dump_month == 0)
dump_month = 1;
if (dump_day == 0)
dump_day = 1;
if (dump_year != 0)
return g_date_new_dmy (dump_day, dump_month, dump_year);
else
return NULL;
}
void
spc_tag_clear (spc_tag_info * info)
{
info->title = info->game = info->publisher = info->artist = info->album =
info->comment = info->dumper = NULL;
info->dump_date = NULL;
info->time_seconds = 0;
info->time_fade_milliseconds = 0;
info->time_intro = 0;
info->time_end = 0;
info->time_loop = 0;
info->time_fade = 0;
info->loop_count = 0;
info->muted = 0;
info->disc = 0;
info->amplification = 0;
}
void
spc_tag_get_info (guchar * data, guint length, spc_tag_info * info)
{
spc_tag_clear (info);
if (spc_tag_is_present (data, length)) {
gboolean text_format = spc_tag_is_text_format (data, length);
info->title = g_new0 (gchar, 0x21);
info->game = g_new0 (gchar, 0x21);
info->artist = g_new0 (gchar, 0x21);
info->dumper = g_new0 (gchar, 0x10);
info->comment = g_new0 (gchar, 0x32);
strncpy (info->title, (gchar *) & data[0x2E], 32);
strncpy (info->artist, (gchar *) & data[(text_format ? 0xB1 : 0xB0)], 32);
strncpy (info->game, (gchar *) & data[0x4E], 32);
strncpy (info->dumper, (gchar *) & data[0x6E], 16);
strncpy (info->comment, (gchar *) & data[0x7E], 32);
if (text_format) {
gchar time[4];
gchar fade[6];
guint dump_year, dump_month, dump_day;
strncpy (time, (gchar *) data + 0xA9, 3);
strncpy (fade, (gchar *) data + 0xAC, 5);
time[3] = fade[5] = 0;
info->time_seconds = atoi (time);
info->time_fade_milliseconds = atoi (fade);
dump_year = (guint) atoi ((gchar *) data + 0x9E);
dump_month = (guint) atoi ((gchar *) data + 0x9E + 3);
dump_day = (guint) atoi ((gchar *) data + 0x9E + 3 + 3);
if (dump_month == 0)
dump_month = 1;
if (dump_day == 0)
dump_day = 1;
if (dump_year != 0)
info->dump_date = g_date_new_dmy (dump_day, dump_month, dump_year);
info->muted = READ_INT8 (data, 0xD1);
info->emulator = READ_INT8 (data, 0xD2);
} else {
info->time_seconds = READ_INT24 (data, 0xA9);
info->time_fade_milliseconds = READ_INT32 (data, 0xAC);
info->dump_date = spc_tag_unpack_date (READ_INT32 (data, 0x9E));
info->muted = READ_INT8 (data, 0xD0);
info->emulator = READ_INT8 (data, 0xD1);
}
}
if (spc_tag_is_extended (data, length)) {
guchar *chunk = data + EXTENDED_OFFSET + 8;
guint32 chunk_size = *((guint32 *) (data + EXTENDED_OFFSET + 4));
guchar *subchunk, *subchunk_next;
for (subchunk = chunk; subchunk < chunk + chunk_size;
subchunk = subchunk_next) {
guint8 tag = READ_INT8 (subchunk, 0);
guint8 type = READ_INT8 (subchunk, 1);
guint16 length = READ_INT16 (subchunk, 2);
guchar *value = subchunk + 4;
switch (type) {
case TYPE_LENGTH:
{
switch (tag) {
case TAG_TRACK:
info->track = READ_INT8 (subchunk, 2 + 1);
break;
case TAG_YEAR:
info->year = READ_INT16 (subchunk, 2);
break;
case TAG_COUNT:
info->loop_count = READ_INT8 (subchunk, 2);
break;
case TAG_EMULATOR:
info->emulator = READ_INT8 (subchunk, 2);
break;
case TAG_DISC:
info->disc = READ_INT8 (subchunk, 2);
break;
case TAG_MUTED:
info->muted = READ_INT8 (subchunk, 2);
break;
default:
break;
}
subchunk_next = subchunk + 4;
break;
}
case TYPE_STRING:
{
gchar *dest;
if (length <= 1)
dest = NULL;
else
switch (tag) {
case TAG_TITLE:
dest = info->title = g_renew (gchar, info->title, length);
break;
case TAG_GAME:
dest = info->game = g_renew (gchar, info->game, length);
break;
case TAG_ARTIST:
dest = info->artist = g_renew (gchar, info->artist, length);
break;
case TAG_ALBUM:
dest = info->album = g_renew (gchar, info->album, length);
break;
case TAG_DUMPER:
dest = info->dumper = g_renew (gchar, info->dumper, length);
break;
case TAG_COMMENT:
dest = info->comment = g_renew (gchar, info->comment, length);
break;
case TAG_PUBLISHER:
dest = info->publisher =
g_renew (gchar, info->publisher, length);
break;
default:
dest = NULL;
break;
}
if (dest)
strncpy (dest, (gchar *) value, length);
subchunk_next = value + length;
break;
}
case TYPE_INTEGER:
{
switch (tag) {
case TAG_INTRO:
info->time_intro = READ_INT32 (value, 0);
break;
case TAG_END:
info->time_end = READ_INT32 (value, 0);
break;
case TAG_FADE:
info->time_fade = READ_INT32 (value, 0);
break;
case TAG_LOOP:
info->time_loop = READ_INT32 (value, 0);
break;
case TAG_DUMP_DATE:
info->dump_date = spc_tag_unpack_date (READ_INT32 (value, 0));
break;
case TAG_AMP:
info->amplification = READ_INT32 (value, 0);
break;
default:
break;
}
subchunk_next = value + length;
break;
}
default:
subchunk_next = value + length;
break;
}
}
}
if (info->title && !*info->title) {
g_free (info->title);
info->title = NULL;
}
if (info->game && !*info->game) {
g_free (info->game);
info->game = NULL;
}
if (info->artist && !*info->artist) {
g_free (info->artist);
info->artist = NULL;
}
if (info->album && !*info->album) {
g_free (info->album);
info->album = NULL;
}
if (info->publisher && !*info->publisher) {
g_free (info->publisher);
info->publisher = NULL;
}
if (info->comment && !*info->comment) {
g_free (info->comment);
info->comment = NULL;
}
if (info->dumper && !*info->dumper) {
g_free (info->dumper);
info->dumper = NULL;
}
}
void
spc_tag_free (spc_tag_info * info)
{
if (info->title)
g_free (info->title);
if (info->game)
g_free (info->game);
if (info->artist)
g_free (info->artist);
if (info->album)
g_free (info->album);
if (info->publisher)
g_free (info->publisher);
if (info->comment)
g_free (info->comment);
if (info->dumper)
g_free (info->dumper);
if (info->dump_date)
g_date_free (info->dump_date);
}

37
ext/spc/tag.h Normal file
View file

@ -0,0 +1,37 @@
/* Copyright (C) 2007 Brian Koropoff <bkoropoff at gmail com>
*
* 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 <glib/gtypes.h>
#include <glib.h>
typedef struct
{
gchar *title, *game, *artist, *album, *publisher;
gchar *dumper, *comment;
enum { EMU_SNES9X = 2, EMU_ZSNES = 1, EMU_UNKNOWN = 0 } emulator;
guint8 track, disc, muted, loop_count;
guint16 year;
guint32 time_seconds, time_fade_milliseconds;
guint32 time_intro, time_loop, time_end, time_fade;
guint32 amplification;
GDate *dump_date;
} spc_tag_info;
void spc_tag_clear(spc_tag_info* info);
void spc_tag_get_info(guchar* data, guint length, spc_tag_info* info);
void spc_tag_free(spc_tag_info* info);