From d129bea2be902ca4c54b7545c82240f152077460 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Tim-Philipp=20M=C3=BCller?= Date: Wed, 28 Dec 2005 18:06:50 +0000 Subject: [PATCH] Add new libgstcdda with GstCddaBaseSrc class. Original commit message from CVS: * configure.ac: * gst-libs/gst/Makefile.am: * gst-libs/gst/cdda/Makefile.am: * gst-libs/gst/cdda/base64.c: * gst-libs/gst/cdda/base64.h: * gst-libs/gst/cdda/gstcddabasesrc.c: (gst_cdda_base_src_mode_get_type), (gst_cdda_base_src_base_init), (gst_cdda_base_src_class_init), (gst_cdda_base_src_init), (gst_cdda_base_src_finalize), (gst_cdda_base_src_set_property), (gst_cdda_base_src_get_property), (gst_cdda_base_src_get_track_from_sector), (gst_cdda_base_src_get_query_types), (gst_cdda_base_src_convert), (gst_cdda_base_src_query), (gst_cdda_base_src_is_seekable), (gst_cdda_base_src_do_seek), (gst_cdda_base_src_handle_track_seek), (gst_cdda_base_src_handle_event), (gst_cdda_base_src_uri_get_type), (gst_cdda_base_src_uri_get_protocols), (gst_cdda_base_src_uri_get_uri), (gst_cdda_base_src_uri_set_uri), (gst_cdda_base_src_uri_handler_init), (gst_cdda_base_src_setup_interfaces), (gst_cdda_base_src_add_track), (gst_cdda_base_src_update_duration), (cddb_sum), (gst_cddabasesrc_calculate_musicbrainz_discid), (lba_to_msf), (gst_cdda_base_src_calculate_cddb_id), (gst_cdda_base_src_add_tags), (gst_cdda_base_src_add_index_associations), (gst_cdda_base_src_set_index), (gst_cdda_base_src_get_index), (gst_cdda_base_src_track_sort_func), (gst_cdda_base_src_start), (gst_cdda_base_src_clear_tracks), (gst_cdda_base_src_stop), (gst_cdda_base_src_create): * gst-libs/gst/cdda/gstcddabasesrc.h: * gst-libs/gst/cdda/sha1.c: * gst-libs/gst/cdda/sha1.h: Add new libgstcdda with GstCddaBaseSrc class. --- ChangeLog | 35 + configure.ac | 1 + gst-libs/gst/Makefile.am | 1 + gst-libs/gst/cdda/Makefile.am | 16 + gst-libs/gst/cdda/base64.c | 115 +++ gst-libs/gst/cdda/base64.h | 75 ++ gst-libs/gst/cdda/gstcddabasesrc.c | 1541 ++++++++++++++++++++++++++++++++++++ gst-libs/gst/cdda/gstcddabasesrc.h | 181 +++++ gst-libs/gst/cdda/sha1.c | 450 +++++++++++ gst-libs/gst/cdda/sha1.h | 62 ++ 10 files changed, 2477 insertions(+) create mode 100644 gst-libs/gst/cdda/Makefile.am create mode 100644 gst-libs/gst/cdda/base64.c create mode 100644 gst-libs/gst/cdda/base64.h create mode 100644 gst-libs/gst/cdda/gstcddabasesrc.c create mode 100644 gst-libs/gst/cdda/gstcddabasesrc.h create mode 100644 gst-libs/gst/cdda/sha1.c create mode 100644 gst-libs/gst/cdda/sha1.h diff --git a/ChangeLog b/ChangeLog index 6f09afe..345a97a 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,5 +1,40 @@ 2005-12-28 Tim-Philipp Müller + * configure.ac: + * gst-libs/gst/Makefile.am: + * gst-libs/gst/cdda/Makefile.am: + * gst-libs/gst/cdda/base64.c: + * gst-libs/gst/cdda/base64.h: + * gst-libs/gst/cdda/gstcddabasesrc.c: + (gst_cdda_base_src_mode_get_type), (gst_cdda_base_src_base_init), + (gst_cdda_base_src_class_init), (gst_cdda_base_src_init), + (gst_cdda_base_src_finalize), (gst_cdda_base_src_set_property), + (gst_cdda_base_src_get_property), + (gst_cdda_base_src_get_track_from_sector), + (gst_cdda_base_src_get_query_types), (gst_cdda_base_src_convert), + (gst_cdda_base_src_query), (gst_cdda_base_src_is_seekable), + (gst_cdda_base_src_do_seek), (gst_cdda_base_src_handle_track_seek), + (gst_cdda_base_src_handle_event), (gst_cdda_base_src_uri_get_type), + (gst_cdda_base_src_uri_get_protocols), + (gst_cdda_base_src_uri_get_uri), (gst_cdda_base_src_uri_set_uri), + (gst_cdda_base_src_uri_handler_init), + (gst_cdda_base_src_setup_interfaces), + (gst_cdda_base_src_add_track), (gst_cdda_base_src_update_duration), + (cddb_sum), (gst_cddabasesrc_calculate_musicbrainz_discid), + (lba_to_msf), (gst_cdda_base_src_calculate_cddb_id), + (gst_cdda_base_src_add_tags), + (gst_cdda_base_src_add_index_associations), + (gst_cdda_base_src_set_index), (gst_cdda_base_src_get_index), + (gst_cdda_base_src_track_sort_func), (gst_cdda_base_src_start), + (gst_cdda_base_src_clear_tracks), (gst_cdda_base_src_stop), + (gst_cdda_base_src_create): + * gst-libs/gst/cdda/gstcddabasesrc.h: + * gst-libs/gst/cdda/sha1.c: + * gst-libs/gst/cdda/sha1.h: + Add new libgstcdda with GstCddaBaseSrc class. + +2005-12-28 Tim-Philipp Müller + * ext/gnomevfs/gstgnomevfssink.h: Use GstBaseSinkClass as parent_class member for class struct, not GstBaseSink. diff --git a/configure.ac b/configure.ac index 83ef1d2..e1f83da 100644 --- a/configure.ac +++ b/configure.ac @@ -629,6 +629,7 @@ ext/vorbis/Makefile gst-libs/Makefile gst-libs/gst/Makefile gst-libs/gst/audio/Makefile +gst-libs/gst/cdda/Makefile gst-libs/gst/floatcast/Makefile gst-libs/gst/interfaces/Makefile gst-libs/gst/netbuffer/Makefile diff --git a/gst-libs/gst/Makefile.am b/gst-libs/gst/Makefile.am index 44bcca2..5b5e925 100644 --- a/gst-libs/gst/Makefile.am +++ b/gst-libs/gst/Makefile.am @@ -1,5 +1,6 @@ SUBDIRS = \ audio \ + cdda \ floatcast \ interfaces \ netbuffer \ diff --git a/gst-libs/gst/cdda/Makefile.am b/gst-libs/gst/cdda/Makefile.am new file mode 100644 index 0000000..c70c2bf --- /dev/null +++ b/gst-libs/gst/cdda/Makefile.am @@ -0,0 +1,16 @@ +lib_LTLIBRARIES = libgstcdda-@GST_MAJORMINOR@.la + +libgstcdda_@GST_MAJORMINOR@_la_SOURCES = \ + gstcddabasesrc.c \ + base64.c \ + base64.h \ + sha1.c \ + sha1.h + +libgstcdda_@GST_MAJORMINOR@includedir = $(includedir)/gstreamer-@GST_MAJORMINOR@/gst/cdda +libgstcdda_@GST_MAJORMINOR@include_HEADERS = \ + gstcddabasesrc.h + +libgstcdda_@GST_MAJORMINOR@_la_LIBADD = $(GST_LIBS) $(GST_BASE_LIBS) +libgstcdda_@GST_MAJORMINOR@_la_CFLAGS = $(GST_CFLAGS) $(GST_BASE_CFLAGS) +libgstcdda_@GST_MAJORMINOR@_la_LDFLAGS = $(GST_LIB_LDFLAGS) $(GST_ALL_LDFLAGS) $(GST_LT_LDFLAGS) diff --git a/gst-libs/gst/cdda/base64.c b/gst-libs/gst/cdda/base64.c new file mode 100644 index 0000000..e5334a3 --- /dev/null +++ b/gst-libs/gst/cdda/base64.c @@ -0,0 +1,115 @@ +/* -------------------------------------------------------------------------- + + MusicBrainz -- The Internet music metadatabase + + Copyright (C) 2000 Robert Kaye + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser 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 + + $Id$ + +----------------------------------------------------------------------------*/ +/* + * Program: RFC-822 routines (originally from SMTP) + * + * Author: Mark Crispin + * Networks and Distributed Computing + * Computing & Communications + * University of Washington + * Administration Building, AG-44 + * Seattle, WA 98195 + * Internet: MRC@CAC.Washington.EDU + * + * Date: 27 July 1988 + * Last Edited: 10 September 1998 + * + * Sponsorship: The original version of this work was developed in the + * Symbolic Systems Resources Group of the Knowledge Systems + * Laboratory at Stanford University in 1987-88, and was funded + * by the Biomedical Research Technology Program of the National + * Institutes of Health under grant number RR-00785. + * + * Original version Copyright 1988 by The Leland Stanford Junior University + * Copyright 1998 by the University of Washington + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, provided + * that the above copyright notices appear in all copies and that both the + * above copyright notices and this permission notice appear in supporting + * documentation, and that the name of the University of Washington or The + * Leland Stanford Junior University not be used in advertising or publicity + * pertaining to distribution of the software without specific, written prior + * permission. This software is made available "as is", and + * THE UNIVERSITY OF WASHINGTON AND THE LELAND STANFORD JUNIOR UNIVERSITY + * DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO THIS SOFTWARE, + * INCLUDING WITHOUT LIMITATION ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE, AND IN NO EVENT SHALL THE UNIVERSITY OF + * WASHINGTON OR THE LELAND STANFORD JUNIOR UNIVERSITY BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER + * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF + * CONTRACT, TORT (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include +#include +#include +#include + +#include "base64.h" + +/* NOTE: This is not true RFC822 anymore. The use of the characters + '/', '+', and '=' is no bueno when the ID will be used as part of a URL. + '_', '.', and '-' have been used instead +*/ + +/* Convert binary contents to BASE64 + * Accepts: source + * length of source + * pointer to return destination length + * Returns: destination as BASE64 + */ + +unsigned char * +rfc822_binary (void *src, unsigned long srcl, unsigned long *len) +{ + unsigned char *ret, *d; + unsigned char *s = (unsigned char *) src; + char *v = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._"; + unsigned long i = ((srcl + 2) / 3) * 4; + + *len = i += 2 * ((i / 60) + 1); + d = ret = (unsigned char *) malloc ((size_t)++ i); + for (i = 0; srcl; s += 3) { /* process tuplets */ + *d++ = v[s[0] >> 2]; /* byte 1: high 6 bits (1) */ + /* byte 2: low 2 bits (1), high 4 bits (2) */ + *d++ = v[((s[0] << 4) + (--srcl ? (s[1] >> 4) : 0)) & 0x3f]; + /* byte 3: low 4 bits (2), high 2 bits (3) */ + *d++ = srcl ? v[((s[1] << 2) + (--srcl ? (s[2] >> 6) : 0)) & 0x3f] : '-'; + /* byte 4: low 6 bits (3) */ + *d++ = srcl ? v[s[2] & 0x3f] : '-'; + if (srcl) + srcl--; /* count third character if processed */ + if ((++i) == 15) { /* output 60 characters? */ + i = 0; /* restart line break count, insert CRLF */ + *d++ = '\015'; + *d++ = '\012'; + } + } + *d = '\0'; /* tie off string */ + + return ret; /* return the resulting string */ +} diff --git a/gst-libs/gst/cdda/base64.h b/gst-libs/gst/cdda/base64.h new file mode 100644 index 0000000..d7c2d0b --- /dev/null +++ b/gst-libs/gst/cdda/base64.h @@ -0,0 +1,75 @@ +/* -------------------------------------------------------------------------- + + MusicBrainz -- The Internet music metadatabase + + Copyright (C) 2000 Robert Kaye + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser 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 + + $Id$ + +----------------------------------------------------------------------------*/ +/* + * Program: RFC-822 routines (originally from SMTP) + * + * Author: Mark Crispin + * Networks and Distributed Computing + * Computing & Communications + * University of Washington + * Administration Building, AG-44 + * Seattle, WA 98195 + * Internet: MRC@CAC.Washington.EDU + * + * Date: 27 July 1988 + * Last Edited: 10 September 1998 + * + * Sponsorship: The original version of this work was developed in the + * Symbolic Systems Resources Group of the Knowledge Systems + * Laboratory at Stanford University in 1987-88, and was funded + * by the Biomedical Research Technology Program of the National + * Institutes of Health under grant number RR-00785. + * + * Original version Copyright 1988 by The Leland Stanford Junior University + * Copyright 1998 by the University of Washington + * + * Permission to use, copy, modify, and distribute this software and its + * documentation for any purpose and without fee is hereby granted, provided + * that the above copyright notices appear in all copies and that both the + * above copyright notices and this permission notice appear in supporting + * documentation, and that the name of the University of Washington or The + * Leland Stanford Junior University not be used in advertising or publicity + * pertaining to distribution of the software without specific, written prior + * permission. This software is made available "as is", and + * THE UNIVERSITY OF WASHINGTON AND THE LELAND STANFORD JUNIOR UNIVERSITY + * DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO THIS SOFTWARE, + * INCLUDING WITHOUT LIMITATION ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE, AND IN NO EVENT SHALL THE UNIVERSITY OF + * WASHINGTON OR THE LELAND STANFORD JUNIOR UNIVERSITY BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER + * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF + * CONTRACT, TORT (INCLUDING NEGLIGENCE) OR STRICT LIABILITY, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#ifndef __GST_CDDA_BASE64_H__ +#define __GST_CDDA_BASE64_H__ + +#define rfc822_binary _gst_cdda_rfc822_binary + +unsigned char *rfc822_binary (void *src,unsigned long srcl,unsigned long *len); + +#endif /* __GST_CDDA_BASE64_H__ */ + diff --git a/gst-libs/gst/cdda/gstcddabasesrc.c b/gst-libs/gst/cdda/gstcddabasesrc.c new file mode 100644 index 0000000..b2376c0 --- /dev/null +++ b/gst-libs/gst/cdda/gstcddabasesrc.c @@ -0,0 +1,1541 @@ +/* GStreamer + * Copyright (C) 1999 Erik Walthinsen + * Copyright (C) 2005 Tim-Philipp Müller + * + * 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. + */ + +/* TODO: + * + * - in ::start(), we want to post a tags message with an array or a list + * of tagslists of all tracks, so that applications know at least the + * number of tracks and all track durations immediately without having + * to do any querying. We have to decide what type and name to use for + * this array of track taglists. + * + * - FIX cddb discid calculation algorithm for mixed mode CDs - do we use + * offsets and duration of ALL tracks (data + audio) for the CDDB ID + * calculation, or only audio tracks? + * + * - Do we really need properties for the TOC bias/offset stuff? Wouldn't + * environment variables make much more sense? Do we need this at all + * (does it only affect ancient hardware?) + */ + +/** + * SECTION:gstcddabasesrc + * @short_description: Base class for CD digital audio (CDDA) sources + * + * + * + * Provides a base class for CDDA sources, which handles things like seeking, + * querying, discid calculation, tags, and buffer timestamping. + * + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#include "gstcddabasesrc.h" +#include "gst/gst-i18n-plugin.h" + +GST_DEBUG_CATEGORY_STATIC (gst_cdda_base_src_debug); +#define GST_CAT_DEFAULT gst_cdda_base_src_debug + +#define DEFAULT_DEVICE "/dev/cdrom" + +#define CD_FRAMESIZE_RAW (2352) + +#define SECTORS_PER_SECOND (75) +#define SECTORS_PER_MINUTE (75*60) +#define SAMPLES_PER_SECTOR (CD_FRAMESIZE_RAW >> 2) +#define TIME_INTERVAL_FROM_SECTORS(sectors) ((SAMPLES_PER_SECTOR * sectors * GST_SECOND) / 44100) +#define SECTORS_FROM_TIME_INTERVAL(dtime) (dtime * 44100 / (SAMPLES_PER_SECTOR * GST_SECOND)) + +#define GST_TYPE_CDDA_BASE_SRC_MODE (gst_cdda_base_src_mode_get_type ()) + +enum +{ + ARG_0, + ARG_MODE, + ARG_DEVICE, + ARG_TRACK, + ARG_TOC_OFFSET, + ARG_TOC_BIAS +}; + +static void gst_cdda_base_src_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec); +static void gst_cdda_base_src_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec); +static void gst_cdda_base_src_finalize (GObject * obj); +static const GstQueryType *gst_cdda_base_src_get_query_types (GstPad * pad); +static gboolean gst_cdda_base_src_query (GstBaseSrc * src, GstQuery * query); +static gboolean gst_cdda_base_src_handle_event (GstBaseSrc * basesrc, + GstEvent * event); +static gboolean gst_cdda_base_src_do_seek (GstBaseSrc * basesrc, + GstSegment * segment); +static void gst_cdda_base_src_setup_interfaces (GType type); +static gboolean gst_cdda_base_src_start (GstBaseSrc * basesrc); +static gboolean gst_cdda_base_src_stop (GstBaseSrc * basesrc); +static GstFlowReturn gst_cdda_base_src_create (GstPushSrc * pushsrc, + GstBuffer ** buf); +static gboolean gst_cdda_base_src_is_seekable (GstBaseSrc * basesrc); +static void gst_cdda_base_src_update_duration (GstCddaBaseSrc * src); +static void gst_cdda_base_src_set_index (GstElement * src, GstIndex * index); +static GstIndex *gst_cdda_base_src_get_index (GstElement * src); + +GST_BOILERPLATE_FULL (GstCddaBaseSrc, gst_cdda_base_src, GstPushSrc, + GST_TYPE_PUSH_SRC, gst_cdda_base_src_setup_interfaces); + +#define SRC_CAPS \ + "audio/x-raw-int, " \ + "endianness = (int) BYTE_ORDER, " \ + "signed = (boolean) true, " \ + "width = (int) 16, " \ + "depth = (int) 16, " \ + "rate = (int) 44100, " \ + "channels = (int) 2" \ + +static GstStaticPadTemplate gst_cdda_base_src_src_template = +GST_STATIC_PAD_TEMPLATE ("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS (SRC_CAPS) + ); + +/* our two formats */ +static GstFormat track_format; +static GstFormat sector_format; + +static GType +gst_cdda_base_src_mode_get_type (void) +{ + static GType mode_type; /* 0 */ + static GEnumValue modes[] = { + {GST_CDDA_BASE_SRC_MODE_NORMAL, "Stream consists of a single track", + "normal"}, + {GST_CDDA_BASE_SRC_MODE_CONTINUOUS, "Stream consists of the whole disc", + "continuous"}, + {0, NULL, NULL} + }; + + if (mode_type == 0) + mode_type = g_enum_register_static ("GstCddaBaseSrcMode", modes); + + return mode_type; +} + +static void +gst_cdda_base_src_base_init (gpointer g_class) +{ + GstElementClass *element_class = GST_ELEMENT_CLASS (g_class); + + gst_element_class_add_pad_template (element_class, + gst_static_pad_template_get (&gst_cdda_base_src_src_template)); + + /* our very own formats */ + track_format = gst_format_register ("track", "CD track"); + sector_format = gst_format_register ("sector", "CD sector"); + + /* tags */ + gst_tag_register (GST_TAG_CDDA_CDDB_DISCID, GST_TAG_FLAG_META, + G_TYPE_STRING, "discid", "CDDB discid for metadata retrieval", + gst_tag_merge_use_first); + + gst_tag_register (GST_TAG_CDDA_CDDB_DISCID_FULL, GST_TAG_FLAG_META, + G_TYPE_STRING, "discid full", + "CDDB discid for metadata retrieval (full)", gst_tag_merge_use_first); + + gst_tag_register (GST_TAG_CDDA_MUSICBRAINZ_DISCID, GST_TAG_FLAG_META, + G_TYPE_STRING, "musicbrainz-discid", + "Musicbrainz discid for metadata retrieval", gst_tag_merge_use_first); + + gst_tag_register (GST_TAG_CDDA_MUSICBRAINZ_DISCID_FULL, GST_TAG_FLAG_META, + G_TYPE_STRING, "musicbrainz-discid-full", + "Musicbrainz discid for metadata retrieval (full)", + gst_tag_merge_use_first); + +#if 0 + ///// FIXME: what type to use here? /////// + gst_tag_register (GST_TAG_CDDA_TRACK_TAGS, GST_TAG_FLAG_META, GST_TYPE_TAG_LIST, "track-tags", "CDDA taglist for one track", gst_tag_merge_use_first); ///////////// FIXME: right function??? /////// +#endif + + GST_DEBUG_CATEGORY_INIT (gst_cdda_base_src_debug, "cddabasesrc", 0, + "CDDA Base Source"); +} + +static void +gst_cdda_base_src_class_init (GstCddaBaseSrcClass * klass) +{ + GstElementClass *element_class; + GstPushSrcClass *pushsrc_class; + GstBaseSrcClass *basesrc_class; + GObjectClass *gobject_class; + + gobject_class = (GObjectClass *) klass; + element_class = (GstElementClass *) klass; + basesrc_class = (GstBaseSrcClass *) klass; + pushsrc_class = (GstPushSrcClass *) klass; + + gobject_class->set_property = gst_cdda_base_src_set_property; + gobject_class->get_property = gst_cdda_base_src_get_property; + gobject_class->finalize = gst_cdda_base_src_finalize; + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DEVICE, + g_param_spec_string ("device", "Device", "CD device location", + NULL, G_PARAM_READWRITE)); + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MODE, + g_param_spec_enum ("mode", "Mode", "Mode", GST_TYPE_CDDA_BASE_SRC_MODE, + GST_CDDA_BASE_SRC_MODE_NORMAL, G_PARAM_READWRITE)); + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TRACK, + g_param_spec_uint ("track", "Track", "Track", 1, 99, 1, + G_PARAM_READWRITE)); + +#if 0 + /* Do we really need this toc adjustment stuff as properties? does the user + * have a chance to set it in practice, e.g. when using sound-juicer, rb, + * totem, whatever? Shouldn't we rather use environment variables + * for this? (tpm) */ + + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TOC_OFFSET, + g_param_spec_int ("toc-offset", "Table of contents offset", + "Add sectors to the values reported", G_MININT, G_MAXINT, 0, + G_PARAM_READWRITE)); + g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TOC_BIAS, + g_param_spec_boolean ("toc-bias", "Table of contents bias", + "Assume that the beginning offset of track 1 as reported in the TOC " + "will be addressed as LBA 0. Necessary for some Toshiba drives to " + "get track boundaries", FALSE, G_PARAM_READWRITE)); +#endif + + element_class->set_index = GST_DEBUG_FUNCPTR (gst_cdda_base_src_set_index); + element_class->get_index = GST_DEBUG_FUNCPTR (gst_cdda_base_src_get_index); + + basesrc_class->start = GST_DEBUG_FUNCPTR (gst_cdda_base_src_start); + basesrc_class->stop = GST_DEBUG_FUNCPTR (gst_cdda_base_src_stop); + basesrc_class->query = GST_DEBUG_FUNCPTR (gst_cdda_base_src_query); + basesrc_class->event = GST_DEBUG_FUNCPTR (gst_cdda_base_src_handle_event); + basesrc_class->do_seek = GST_DEBUG_FUNCPTR (gst_cdda_base_src_do_seek); + basesrc_class->is_seekable = + GST_DEBUG_FUNCPTR (gst_cdda_base_src_is_seekable); + + pushsrc_class->create = GST_DEBUG_FUNCPTR (gst_cdda_base_src_create); +} + +static void +gst_cdda_base_src_init (GstCddaBaseSrc * src, GstCddaBaseSrcClass * klass) +{ + gst_pad_set_query_type_function (GST_BASE_SRC_PAD (src), + GST_DEBUG_FUNCPTR (gst_cdda_base_src_get_query_types)); + + /* we're not live and we operate in time */ + gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME); + gst_base_src_set_live (GST_BASE_SRC (src), FALSE); + + src->device = NULL; + src->mode = GST_CDDA_BASE_SRC_MODE_NORMAL; + src->uri_track = -1; +} + +static void +gst_cdda_base_src_finalize (GObject * obj) +{ + GstCddaBaseSrc *cddasrc = GST_CDDA_BASE_SRC (obj); + + g_free (cddasrc->uri); + g_free (cddasrc->device); + + G_OBJECT_CLASS (parent_class)->finalize (obj); +} + +static void +gst_cdda_base_src_set_property (GObject * object, guint prop_id, + const GValue * value, GParamSpec * pspec) +{ + GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (object); + + GST_OBJECT_LOCK (src); + + switch (prop_id) { + case ARG_MODE:{ + src->mode = g_value_get_enum (value); + break; + } + case ARG_DEVICE:{ + const gchar *dev = g_value_get_string (value); + + g_free (src->device); + if (dev && *dev) { + src->device = g_strdup (dev); + } else { + src->device = NULL; + } + break; + } + case ARG_TRACK:{ + guint track = g_value_get_uint (value); + + if (src->num_tracks > 0 && track > src->num_tracks) { + g_warning ("Invalid track %u", track); + } else if (track > 0 && src->tracks != NULL) { + src->cur_sector = src->tracks[track - 1].start; + src->uri_track = track; + } else { + src->uri_track = track; /* seek will be done in start() */ + } + break; + } + case ARG_TOC_OFFSET:{ + src->toc_offset = g_value_get_int (value); + break; + } + case ARG_TOC_BIAS:{ + src->toc_bias = g_value_get_boolean (value); + break; + } + default:{ + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } + } + + GST_OBJECT_UNLOCK (src); +} + +static void +gst_cdda_base_src_get_property (GObject * object, guint prop_id, + GValue * value, GParamSpec * pspec) +{ + GstCddaBaseSrcClass *klass = GST_CDDA_BASE_SRC_GET_CLASS (object); + GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (object); + + GST_OBJECT_LOCK (src); + + switch (prop_id) { + case ARG_MODE: + g_value_set_enum (value, src->mode); + break; + case ARG_DEVICE:{ + if (src->device == NULL && klass->get_default_device != NULL) { + gchar *d = klass->get_default_device (src); + + if (d != NULL) { + g_value_set_string (value, DEFAULT_DEVICE); + g_free (d); + break; + } + } + if (src->device == NULL) + g_value_set_string (value, DEFAULT_DEVICE); + else + g_value_set_string (value, src->device); + break; + } + case ARG_TRACK:{ + if (src->num_tracks <= 0 && src->uri_track > 0) { + g_value_set_uint (value, src->uri_track); + } else { + g_value_set_uint (value, src->cur_track + 1); + } + break; + } + case ARG_TOC_OFFSET: + g_value_set_int (value, src->toc_offset); + break; + case ARG_TOC_BIAS: + g_value_set_boolean (value, src->toc_bias); + break; + default:{ + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } + } + + GST_OBJECT_UNLOCK (src); +} + +static gint +gst_cdda_base_src_get_track_from_sector (GstCddaBaseSrc * src, gint sector) +{ + gint i; + + for (i = 0; i < src->num_tracks; ++i) { + if (sector >= src->tracks[i].start && sector <= src->tracks[i].end) + return i; + } + return -1; +} + +static const GstQueryType * +gst_cdda_base_src_get_query_types (GstPad * pad) +{ + static const GstQueryType src_query_types[] = { + GST_QUERY_DURATION, + GST_QUERY_POSITION, + GST_QUERY_CONVERT, + 0 + }; + + return src_query_types; +} + +static gboolean +gst_cdda_base_src_convert (GstCddaBaseSrc * src, GstFormat src_format, + gint64 src_val, GstFormat dest_format, gint64 * dest_val) +{ + gboolean started; + + GST_LOG_OBJECT (src, "converting value %" G_GINT64_FORMAT " from %s into %s", + src_val, gst_format_get_name (src_format), + gst_format_get_name (dest_format)); + + if (src_format == dest_format) { + *dest_val = src_val; + return TRUE; + } + + started = GST_OBJECT_FLAG_IS_SET (GST_BASE_SRC (src), GST_BASE_SRC_STARTED); + + if (src_format == track_format) { + if (!started) + goto not_started; + if (src_val < 0 || src_val >= src->num_tracks) { + GST_DEBUG_OBJECT (src, "track number %d out of bounds", (gint) src_val); + goto wrong_value; + } + src_format = GST_FORMAT_DEFAULT; + src_val = src->tracks[src_val].start * SAMPLES_PER_SECTOR; + } else if (src_format == sector_format) { + src_format = GST_FORMAT_DEFAULT; + src_val = src_val * SAMPLES_PER_SECTOR; + } + + if (src_format == dest_format) { + *dest_val = src_val; + goto done; + } + + switch (src_format) { + case GST_FORMAT_BYTES: + /* convert to samples (4 bytes per sample) */ + src_val = src_val >> 2; + /* fallthrough */ + case GST_FORMAT_DEFAULT:{ + switch (dest_format) { + case GST_FORMAT_BYTES:{ + if (src_val < 0) { + GST_DEBUG_OBJECT (src, "sample source value negative"); + goto wrong_value; + } + *dest_val = src_val << 2; /* 4 bytes per sample */ + break; + } + case GST_FORMAT_TIME:{ + *dest_val = gst_util_uint64_scale_int (src_val, GST_SECOND, 44100); + break; + } + default:{ + gint64 sector = src_val / SAMPLES_PER_SECTOR; + + if (dest_format == sector_format) { + *dest_val = sector; + } else if (dest_format == track_format) { + if (!started) + goto not_started; + *dest_val = gst_cdda_base_src_get_track_from_sector (src, sector); + } else { + goto unknown_format; + } + break; + } + } + break; + } + case GST_FORMAT_TIME:{ + gint64 sample_offset; + + if (src_val == GST_CLOCK_TIME_NONE) { + GST_DEBUG_OBJECT (src, "source time value invalid"); + goto wrong_value; + } + + sample_offset = gst_util_uint64_scale_int (src_val, 44100, GST_SECOND); + switch (dest_format) { + case GST_FORMAT_BYTES:{ + *dest_val = sample_offset << 2; /* 4 bytes per sample */ + break; + } + case GST_FORMAT_DEFAULT:{ + *dest_val = sample_offset; + break; + } + default:{ + gint64 sector = sample_offset / SAMPLES_PER_SECTOR; + + if (dest_format == sector_format) { + *dest_val = sector; + } else if (dest_format == track_format) { + if (!started) + goto not_started; + *dest_val = gst_cdda_base_src_get_track_from_sector (src, sector); + } else { + goto unknown_format; + } + break; + } + } + break; + } + default:{ + goto unknown_format; + } + } + +done: + { + GST_LOG_OBJECT (src, "returning %" G_GINT64_FORMAT, *dest_val); + return TRUE; + } + +unknown_format: + { + GST_DEBUG_OBJECT (src, "conversion failed: %s", "unsupported format"); + return FALSE; + } + +wrong_value: + { + GST_DEBUG_OBJECT (src, "conversion failed: %s", + "source value not within allowed range"); + return FALSE; + } + +not_started: + { + GST_DEBUG_OBJECT (src, "conversion failed: %s", + "cannot do this conversion, device not open"); + return FALSE; + } +} + +static gboolean +gst_cdda_base_src_query (GstBaseSrc * basesrc, GstQuery * query) +{ + GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (basesrc); + gboolean started; + + started = GST_OBJECT_FLAG_IS_SET (basesrc, GST_BASE_SRC_STARTED); + + GST_LOG_OBJECT (src, "handling %s query", + gst_query_type_get_name (GST_QUERY_TYPE (query))); + + switch (GST_QUERY_TYPE (query)) { + case GST_QUERY_DURATION:{ + GstFormat dest_format; + gint64 dest_val; + guint sectors; + + gst_query_parse_duration (query, &dest_format, NULL); + + if (!started) + return FALSE; + + g_assert (src->tracks != NULL); + + if (dest_format == track_format) { + GST_LOG_OBJECT (src, "duration: %d tracks", src->num_tracks); + gst_query_set_duration (query, track_format, src->num_tracks); + return TRUE; + } + + if (src->cur_track < 0 || src->cur_track >= src->num_tracks) + return FALSE; + + if (src->mode == GST_CDDA_BASE_SRC_MODE_NORMAL) { + sectors = src->tracks[src->cur_track].end - + src->tracks[src->cur_track].start + 1; + } else { + sectors = src->tracks[src->num_tracks - 1].end - + src->tracks[0].start + 1; + } + + /* ... and convert into final format */ + if (!gst_cdda_base_src_convert (src, sector_format, sectors, + dest_format, &dest_val)) { + return FALSE; + } + + gst_query_set_duration (query, dest_format, dest_val); + + GST_LOG ("duration: %u sectors, %" G_GINT64_FORMAT " in format %s", + sectors, dest_val, gst_format_get_name (dest_format)); + break; + } + case GST_QUERY_POSITION:{ + GstFormat dest_format; + gint64 pos_sector; + gint64 dest_val; + + gst_query_parse_position (query, &dest_format, NULL); + + if (!started) + return FALSE; + + g_assert (src->tracks != NULL); + + if (dest_format == track_format) { + GST_LOG_OBJECT (src, "position: track %d", src->cur_track); + gst_query_set_position (query, track_format, src->cur_track); + return TRUE; + } + + if (src->cur_track < 0 || src->cur_track >= src->num_tracks) + return FALSE; + + if (src->mode == GST_CDDA_BASE_SRC_MODE_NORMAL) { + pos_sector = src->cur_sector - src->tracks[src->cur_track].start; + } else { + pos_sector = src->cur_sector - src->tracks[0].start; + } + + if (!gst_cdda_base_src_convert (src, sector_format, pos_sector, + dest_format, &dest_val)) { + return FALSE; + } + + gst_query_set_position (query, dest_format, dest_val); + + GST_LOG ("position: sector %u, %" G_GINT64_FORMAT " in format %s", + (guint) pos_sector, dest_val, gst_format_get_name (dest_format)); + break; + } + case GST_QUERY_CONVERT:{ + GstFormat src_format, dest_format; + gint64 src_val, dest_val; + + gst_query_parse_convert (query, &src_format, &src_val, &dest_format, + NULL); + + if (!gst_cdda_base_src_convert (src, src_format, src_val, dest_format, + &dest_val)) { + return FALSE; + } + + gst_query_set_convert (query, src_format, src_val, dest_format, dest_val); + break; + } + default:{ + GST_DEBUG_OBJECT (src, "unsupported query type"); + return FALSE; + } + } + + return TRUE; +} + +static gboolean +gst_cdda_base_src_is_seekable (GstBaseSrc * basesrc) +{ + return TRUE; +} + +static gboolean +gst_cdda_base_src_do_seek (GstBaseSrc * basesrc, GstSegment * segment) +{ + GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (basesrc); + gint64 seek_sector; + + GST_DEBUG_OBJECT (src, "segment %" GST_TIME_FORMAT "-%" GST_TIME_FORMAT, + GST_TIME_ARGS (segment->start), GST_TIME_ARGS (segment->stop)); + + if (!gst_cdda_base_src_convert (src, GST_FORMAT_TIME, segment->start, + sector_format, &seek_sector)) { + GST_WARNING_OBJECT (src, "conversion failed"); + return FALSE; + } + + /* we should only really be called when open */ + g_assert (src->cur_track >= 0 && src->cur_track < src->num_tracks); + + switch (src->mode) { + case GST_CDDA_BASE_SRC_MODE_NORMAL: + seek_sector += src->tracks[src->cur_track].start; + break; + case GST_CDDA_BASE_SRC_MODE_CONTINUOUS: + seek_sector += src->tracks[0].start; + break; + default: + g_assert_not_reached (); + } + + src->cur_sector = (gint) seek_sector; + + GST_DEBUG_OBJECT (src, "seek'd to sector %d", src->cur_sector); + + return TRUE; +} + +static gboolean +gst_cdda_base_src_handle_track_seek (GstCddaBaseSrc * src, gdouble rate, + GstSeekFlags flags, GstSeekType start_type, gint64 start, + GstSeekType stop_type, gint64 stop) +{ + GstBaseSrc *basesrc = GST_BASE_SRC (src); + GstEvent *event; + + if ((flags & GST_SEEK_FLAG_SEGMENT) == GST_SEEK_FLAG_SEGMENT) { + gint64 start_time = -1; + gint64 stop_time = -1; + + if (src->mode != GST_CDDA_BASE_SRC_MODE_CONTINUOUS) { + GST_DEBUG_OBJECT (src, "segment seek in track format is only " + "supported in CONTINUOUS mode, not in mode %d", src->mode); + return FALSE; + } + + switch (start_type) { + case GST_SEEK_TYPE_SET: + if (!gst_cdda_base_src_convert (src, track_format, start, + GST_FORMAT_TIME, &start_time)) { + GST_DEBUG_OBJECT (src, "cannot convert track %d to time", + (gint) start); + return FALSE; + } + break; + case GST_SEEK_TYPE_END: + if (!gst_cdda_base_src_convert (src, track_format, + src->num_tracks - start - 1, GST_FORMAT_TIME, &start_time)) { + GST_DEBUG_OBJECT (src, "cannot convert track %d to time", + (gint) start); + return FALSE; + } + start_type = GST_SEEK_TYPE_SET; + break; + case GST_SEEK_TYPE_NONE: + start_time = -1; + break; + default: + g_assert_not_reached (); + } + + switch (stop_type) { + case GST_SEEK_TYPE_SET: + if (!gst_cdda_base_src_convert (src, track_format, stop, + GST_FORMAT_TIME, &stop_time)) { + GST_DEBUG_OBJECT (src, "cannot convert track %d to time", + (gint) stop); + return FALSE; + } + break; + case GST_SEEK_TYPE_END: + if (!gst_cdda_base_src_convert (src, track_format, + src->num_tracks - stop - 1, GST_FORMAT_TIME, &stop_time)) { + GST_DEBUG_OBJECT (src, "cannot convert track %d to time", + (gint) stop); + return FALSE; + } + stop_type = GST_SEEK_TYPE_SET; + break; + case GST_SEEK_TYPE_NONE: + stop_time = -1; + break; + default: + g_assert_not_reached (); + } + + GST_LOG_OBJECT (src, "seek segment %" GST_TIME_FORMAT "-%" GST_TIME_FORMAT, + GST_TIME_ARGS (start_time), GST_TIME_ARGS (stop_time)); + + /* send fake segment seek event in TIME format to + * base class, which will hopefully handle the rest */ + + event = gst_event_new_seek (rate, GST_FORMAT_TIME, flags, start_type, + start_time, stop_type, stop_time); + + return GST_BASE_SRC_CLASS (parent_class)->event (basesrc, event); + } + + /* not a segment seek */ + + if (start_type == GST_SEEK_TYPE_NONE) { + GST_LOG_OBJECT (src, "start seek type is NONE, nothing to do"); + return TRUE; + } + + if (stop_type != GST_SEEK_TYPE_NONE) { + GST_WARNING_OBJECT (src, "ignoring stop seek type (expected NONE)"); + } + + if (start < 0 || start >= src->num_tracks) { + GST_DEBUG_OBJECT (src, "invalid track %" G_GINT64_FORMAT, start); + return FALSE; + } + + src->cur_track = (gint) start; + src->uri_track = -1; + src->prev_track = -1; + + GST_DEBUG_OBJECT (src, "seeking to track %d", src->cur_track + 1); + + src->cur_sector = src->tracks[src->cur_track].start; + GST_DEBUG_OBJECT (src, "starting at sector %d", src->cur_sector); + + gst_cdda_base_src_update_duration (src); + + /* send fake segment seek event in TIME format to + * base class (so we get a newsegment etc.) */ + event = gst_event_new_seek (rate, GST_FORMAT_TIME, flags, + GST_SEEK_TYPE_SET, 0, GST_SEEK_TYPE_NONE, -1); + + return GST_BASE_SRC_CLASS (parent_class)->event (basesrc, event); +} + +static gboolean +gst_cdda_base_src_handle_event (GstBaseSrc * basesrc, GstEvent * event) +{ + GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (basesrc); + gboolean ret = FALSE; + + GST_LOG_OBJECT (src, "handling %s event", GST_EVENT_TYPE_NAME (event)); + + switch (GST_EVENT_TYPE (event)) { + case GST_EVENT_SEEK:{ + GstSeekType start_type, stop_type; + GstSeekFlags flags; + GstFormat format; + gdouble rate; + gint64 start, stop; + + if (!GST_OBJECT_FLAG_IS_SET (basesrc, GST_BASE_SRC_STARTED)) { + GST_DEBUG_OBJECT (src, "seek failed: device not open"); + break; + } + + gst_event_parse_seek (event, &rate, &format, &flags, &start_type, &start, + &stop_type, &stop); + + if (format == sector_format) { + GST_DEBUG_OBJECT (src, "seek in sector format not supported"); + break; + } + + if (format == track_format) { + ret = gst_cdda_base_src_handle_track_seek (src, rate, flags, + start_type, start, stop_type, stop); + } else { + GST_LOG_OBJECT (src, "let base class handle seek in %s format", + gst_format_get_name (format)); + gst_event_ref (event); + ret = GST_BASE_SRC_CLASS (parent_class)->event (basesrc, event); + } + break; + } + default:{ + GST_LOG_OBJECT (src, "let base class handle event"); + gst_event_ref (event); + ret = GST_BASE_SRC_CLASS (parent_class)->event (basesrc, event); + break; + } + } + + return ret; +} + +static guint +gst_cdda_base_src_uri_get_type (void) +{ + return GST_URI_SRC; +} + +static gchar ** +gst_cdda_base_src_uri_get_protocols (void) +{ + static gchar *protocols[] = { "cdda", NULL }; + + return protocols; +} + +static const gchar * +gst_cdda_base_src_uri_get_uri (GstURIHandler * handler) +{ + GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (handler); + + GST_OBJECT_LOCK (src); + + g_free (src->uri); + + if (GST_OBJECT_FLAG_IS_SET (GST_BASE_SRC (src), GST_BASE_SRC_STARTED)) { + src->uri = g_strdup_printf ("cdda://%d", src->uri_track); + } else { + src->uri = g_strdup ("cdda://1"); + } + + GST_OBJECT_UNLOCK (src); + + return src->uri; +} + +/* Note: gst_element_make_from_uri() might call us with just 'cdda://' as + * URI and expects us to return TRUE then (and this might be in any state) */ + +static gboolean +gst_cdda_base_src_uri_set_uri (GstURIHandler * handler, const gchar * uri) +{ + GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (handler); + gchar *protocol, *location; + + GST_OBJECT_LOCK (src); + + protocol = gst_uri_get_protocol (uri); + if (!protocol || strcmp (protocol, "cdda") != 0) { + g_free (protocol); + goto failed; + } + g_free (protocol); + + location = gst_uri_get_location (uri); + if (location == NULL || *location == '\0') { + g_free (location); + location = g_strdup ("1"); + } + + src->uri_track = strtol (location, NULL, 10); + g_free (location); + + if (src->uri_track == 0) + goto failed; + + if (src->num_tracks > 0 + && src->tracks != NULL && src->uri_track > src->num_tracks) + goto failed; + + if (src->uri_track > 0 && src->tracks != NULL) { + GST_OBJECT_UNLOCK (src); + + gst_pad_send_event (GST_BASE_SRC_PAD (src), + gst_event_new_seek (1.0, track_format, GST_SEEK_FLAG_FLUSH, + GST_SEEK_TYPE_SET, src->uri_track - 1, GST_SEEK_TYPE_NONE, -1)); + } else { + /* seek will be done in start() */ + GST_OBJECT_UNLOCK (src); + } + + GST_LOG_OBJECT (handler, "successfully handled uri '%s'", uri); + + return TRUE; + +failed: + { + GST_OBJECT_UNLOCK (src); + GST_DEBUG_OBJECT (src, "cannot handle URI '%s'", uri); + return FALSE; + } +} + +static void +gst_cdda_base_src_uri_handler_init (gpointer g_iface, gpointer iface_data) +{ + GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface; + + iface->get_type = gst_cdda_base_src_uri_get_type; + iface->get_uri = gst_cdda_base_src_uri_get_uri; + iface->set_uri = gst_cdda_base_src_uri_set_uri; + iface->get_protocols = gst_cdda_base_src_uri_get_protocols; +} + +static void +gst_cdda_base_src_setup_interfaces (GType type) +{ + static const GInterfaceInfo urihandler_info = { + gst_cdda_base_src_uri_handler_init, + NULL, + NULL, + }; + + g_type_add_interface_static (type, GST_TYPE_URI_HANDLER, &urihandler_info); +} + +/** + * gst_cdda_base_src_add_track: + * @src: a #GstCddaBaseSrc + * @track: address of #GstCddaBaseSrcTrack to add + * + * CDDA sources use this function from their start vfunc to announce the + * available data and audio tracks to the base source class. The caller + * should allocate @track on the stack, the base source will do a shallow + * copy of the structure (and take ownership of the taglist if there is one). + * + * Returns: FALSE on error, otherwise TRUE. + */ + +gboolean +gst_cdda_base_src_add_track (GstCddaBaseSrc * src, GstCddaBaseSrcTrack * track) +{ + g_return_val_if_fail (GST_IS_CDDA_BASE_SRC (src), FALSE); + g_return_val_if_fail (track != NULL, FALSE); + g_return_val_if_fail (track->num > 0, FALSE); + + GST_DEBUG_OBJECT (src, "adding track %2u (%2u) [%6u-%6u] [%5s], tags: %" + GST_PTR_FORMAT, src->num_tracks + 1, track->num, track->start, + track->end, (track->is_audio) ? "AUDIO" : "DATA ", track->tags); + + if (src->num_tracks > 0) { + guint end_of_previous_track = src->tracks[src->num_tracks - 1].end; + + g_return_val_if_fail (track->start >= end_of_previous_track, FALSE); + } + + GST_OBJECT_LOCK (src); + + ++src->num_tracks; + src->tracks = g_renew (GstCddaBaseSrcTrack, src->tracks, src->num_tracks); + src->tracks[src->num_tracks - 1] = *track; + + GST_OBJECT_UNLOCK (src); + + return TRUE; +} + +static void +gst_cdda_base_src_update_duration (GstCddaBaseSrc * src) +{ + GstBaseSrc *basesrc; + GstFormat format; + gint64 duration; + + basesrc = GST_BASE_SRC (src); + + format = GST_FORMAT_TIME; + if (gst_pad_query_duration (GST_BASE_SRC_PAD (src), &format, &duration)) { + gst_segment_set_duration (&basesrc->segment, GST_FORMAT_TIME, duration); + } else { + gst_segment_set_duration (&basesrc->segment, GST_FORMAT_TIME, -1); + } + + gst_element_post_message (GST_ELEMENT (src), + gst_message_new_duration (GST_OBJECT (src), GST_FORMAT_TIME, -1)); + + GST_LOG_OBJECT (src, "duration updated to %" GST_TIME_FORMAT, + GST_TIME_ARGS (duration)); +} + +#define CD_MSF_OFFSET 150 + +/* the cddb hash function */ +static guint +cddb_sum (gint n) +{ + guint ret; + + ret = 0; + while (n > 0) { + ret += (n % 10); + n /= 10; + } + return ret; +} + +#include "base64.h" +#include "sha1.h" + +static void +gst_cddabasesrc_calculate_musicbrainz_discid (GstCddaBaseSrc * src) +{ + GString *s; + SHA_INFO sha; + guchar digest[20], *ptr; + gchar tmp[9]; + gulong i; + guint leadout_sector; + + s = g_string_new (NULL); + + leadout_sector = src->tracks[src->num_tracks - 1].end + 1 + CD_MSF_OFFSET; + + /* generate SHA digest */ + sha_init (&sha); + g_snprintf (tmp, sizeof (tmp), "%02X", src->tracks[0].num); + g_string_append_printf (s, "%02X", src->tracks[0].num); + sha_update (&sha, (SHA_BYTE *) tmp, 2); + + g_snprintf (tmp, sizeof (tmp), "%02X", src->tracks[src->num_tracks - 1].num); + g_string_append_printf (s, " %02X", src->tracks[src->num_tracks - 1].num); + sha_update (&sha, (SHA_BYTE *) tmp, 2); + + g_snprintf (tmp, sizeof (tmp), "%08X", leadout_sector); + g_string_append_printf (s, " %08X", leadout_sector); + sha_update (&sha, (SHA_BYTE *) tmp, 8); + + for (i = 0; i < 99; i++) { + if (i < src->num_tracks) { + guint frame_offset = src->tracks[i].start + CD_MSF_OFFSET; + + g_snprintf (tmp, sizeof (tmp), "%08X", frame_offset); + g_string_append_printf (s, " %08X", frame_offset); + sha_update (&sha, (SHA_BYTE *) tmp, 8); + } else { + sha_update (&sha, (SHA_BYTE *) "00000000", 8); + } + } + sha_final (digest, &sha); + + /* re-encode to base64 */ + ptr = rfc822_binary (digest, 20, &i); + + g_assert (i < sizeof (src->mb_discid) + 1); + memcpy (src->mb_discid, ptr, i); + src->mb_discid[i] = '\0'; + free (ptr); + + GST_DEBUG_OBJECT (src, "musicbrainz-discid = %s", src->mb_discid); + GST_DEBUG_OBJECT (src, "musicbrainz-discid-full = %s", s->str); + + gst_tag_list_add (src->tags, GST_TAG_MERGE_REPLACE, + GST_TAG_CDDA_MUSICBRAINZ_DISCID, src->mb_discid, + GST_TAG_CDDA_MUSICBRAINZ_DISCID_FULL, s->str, NULL); + + g_string_free (s, TRUE); +} + +static void +lba_to_msf (guint sector, guint * p_m, guint * p_s, guint * p_f, guint * p_secs) +{ + guint m, s, f; + + m = sector / SECTORS_PER_MINUTE; + sector = sector % SECTORS_PER_MINUTE; + s = sector / SECTORS_PER_SECOND; + f = sector % SECTORS_PER_SECOND; + + if (p_m) + *p_m = m; + if (p_s) + *p_s = s; + if (p_f) + *p_f = f; + if (p_secs) + *p_secs = s + (m * 60); +} + +static void +gst_cdda_base_src_calculate_cddb_id (GstCddaBaseSrc * src) +{ + GString *s; + guint first_sector = 0, last_sector = 0; + guint start_secs, end_secs, secs, len_secs; + guint total_secs, num_audio_tracks; + guint id, t, i; + + id = 0; + total_secs = 0; + num_audio_tracks = 0; + + /* FIXME: do we use offsets and duration of ALL tracks (data + audio) + * for the CDDB ID calculation, or only audio tracks? */ + for (i = 0; i < src->num_tracks; ++i) { + if (1) { /* src->tracks[i].is_audio) { */ + if (num_audio_tracks == 0) { + first_sector = src->tracks[i].start + CD_MSF_OFFSET; + } + last_sector = src->tracks[i].end + CD_MSF_OFFSET + 1; + ++num_audio_tracks; + + lba_to_msf (src->tracks[i].start + CD_MSF_OFFSET, NULL, NULL, NULL, + &secs); + + len_secs = (src->tracks[i].end - src->tracks[i].start + 1) / 75; + + GST_DEBUG_OBJECT (src, "track %02u: lsn %6u (%02u:%02u), " + "length: %u seconds (%02u:%02u)", + num_audio_tracks, src->tracks[i].start + CD_MSF_OFFSET, + secs / 60, secs % 60, len_secs, len_secs / 60, len_secs % 60); + + id += cddb_sum (secs); + total_secs += len_secs; + } + } + + /* first_sector = src->tracks[0].start + CD_MSF_OFFSET; */ + lba_to_msf (first_sector, NULL, NULL, NULL, &start_secs); + + /* last_sector = src->tracks[src->num_tracks-1].end + CD_MSF_OFFSET; */ + lba_to_msf (last_sector, NULL, NULL, NULL, &end_secs); + + GST_DEBUG_OBJECT (src, "first_sector = %u = %u secs (%02u:%02u)", + first_sector, start_secs, start_secs / 60, start_secs % 60); + GST_DEBUG_OBJECT (src, "last_sector = %u = %u secs (%02u:%02u)", + last_sector, end_secs, end_secs / 60, end_secs % 60); + + t = end_secs - start_secs; + + GST_DEBUG_OBJECT (src, "total length = %u secs (%02u:%02u), added title " + "lengths = %u seconds (%02u:%02u)", t, t / 60, t % 60, total_secs, + total_secs / 60, total_secs % 60); + + src->discid = ((id % 0xff) << 24 | t << 8 | num_audio_tracks); + + s = g_string_new (NULL); + g_string_append_printf (s, "%08x", src->discid); + + gst_tag_list_add (src->tags, GST_TAG_MERGE_REPLACE, + GST_TAG_CDDA_CDDB_DISCID, src->discid, NULL); + + g_string_append_printf (s, " %u", src->num_tracks); + for (i = 0; i < src->num_tracks; ++i) { + g_string_append_printf (s, " %u", src->tracks[i].start + CD_MSF_OFFSET); + } + g_string_append_printf (s, " %u", t); + + gst_tag_list_add (src->tags, GST_TAG_MERGE_REPLACE, + GST_TAG_CDDA_CDDB_DISCID_FULL, s->str, NULL); + + GST_DEBUG_OBJECT (src, "cddb discid = %s", s->str); + + g_string_free (s, TRUE); +} + +static void +gst_cdda_base_src_add_tags (GstCddaBaseSrc * src) +{ + gint i; + + /* fill in details for each track */ + for (i = 0; i < src->num_tracks; ++i) { + gint64 duration; + guint num_sectors; + + if (src->tracks[i].tags == NULL) + src->tracks[i].tags = gst_tag_list_new (); + + num_sectors = src->tracks[i].end - src->tracks[i].start + 1; + gst_cdda_base_src_convert (src, sector_format, num_sectors, + GST_FORMAT_TIME, &duration); + + gst_tag_list_add (src->tracks[i].tags, + GST_TAG_MERGE_REPLACE_ALL, + GST_TAG_TRACK_NUMBER, i + 1, + GST_TAG_TRACK_COUNT, src->num_tracks, GST_TAG_DURATION, duration, NULL); + } + + /* now fill in per-album tags and include each track's tags + * in the album tags, so that interested parties can retrieve + * the relevant details for each track in one go */ + + /* /////////////////////////////// FIXME should we rather insert num_tracks + * tags by the name of 'track-tags' and have the caller use + * gst_tag_list_get_value_index() rather than use tag names incl. + * the track number ?? *//////////////////////////////////////// + + gst_tag_list_add (src->tags, GST_TAG_MERGE_REPLACE_ALL, + GST_TAG_TRACK_COUNT, src->num_tracks, NULL); +#if 0 + for (i = 0; i < src->num_tracks; ++i) { + gst_tag_list_add (src->tags, GST_TAG_MERGE_APPEND, + GST_TAG_CDDA_TRACK_TAGS, src->tracks[i].tags, NULL); + } +#endif + + GST_DEBUG ("src->tags = %" GST_PTR_FORMAT, src->tags); +} + +static void +gst_cdda_base_src_add_index_associations (GstCddaBaseSrc * src) +{ + gint i; + + for (i = 0; i < src->num_tracks; i++) { + gint64 sector; + + sector = src->tracks[i].start; + gst_index_add_association (src->index, src->index_id, GST_ASSOCIATION_FLAG_KEY_UNIT, track_format, i, /* here we count from 0 */ + sector_format, sector, + GST_FORMAT_TIME, + (gint64) (((CD_FRAMESIZE_RAW >> 2) * sector * GST_SECOND) / 44100), + GST_FORMAT_BYTES, (gint64) (sector << 2), GST_FORMAT_DEFAULT, + (gint64) ((CD_FRAMESIZE_RAW >> 2) * sector), NULL); + } +} + +static void +gst_cdda_base_src_set_index (GstElement * element, GstIndex * index) +{ + GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (element); + + src->index = index; + + gst_index_get_writer_id (index, GST_OBJECT (src), &src->index_id); + gst_index_add_format (index, src->index_id, track_format); + gst_index_add_format (index, src->index_id, sector_format); +} + + +static GstIndex * +gst_cdda_base_src_get_index (GstElement * element) +{ + GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (element); + + return src->index; +} + +static gint +gst_cdda_base_src_track_sort_func (gconstpointer a, gconstpointer b, + gpointer foo) +{ + GstCddaBaseSrcTrack *track_a = ((GstCddaBaseSrcTrack *) a); + GstCddaBaseSrcTrack *track_b = ((GstCddaBaseSrcTrack *) b); + + /* sort data tracks to the end, and audio tracks by track number */ + if (track_a->is_audio == track_b->is_audio) + return (gint) track_a->num - (gint) track_b->num; + + if (track_a->is_audio) { + return -1; + } else { + return 1; + } +} + +static gboolean +gst_cdda_base_src_start (GstBaseSrc * basesrc) +{ + GstCddaBaseSrcClass *klass = GST_CDDA_BASE_SRC_GET_CLASS (basesrc); + GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (basesrc); + gboolean ret; + gchar *device = NULL; + + src->discid = 0; + src->mb_discid[0] = '\0'; + + g_assert (klass->open != NULL); + + if (src->device != NULL) { + device = g_strdup (src->device); + } else if (klass->get_default_device != NULL) { + device = klass->get_default_device (src); + } + + if (device == NULL) + device = g_strdup (DEFAULT_DEVICE); + + GST_LOG_OBJECT (basesrc, "opening device %s", device); + + src->tags = gst_tag_list_new (); + + ret = klass->open (src, device); + g_free (device); + device = NULL; + + if (!ret) { + GST_DEBUG_OBJECT (basesrc, "failed to open device"); + /* subclass (should have) posted an error message with the details */ + gst_cdda_base_src_stop (basesrc); + return FALSE; + } + + if (src->num_tracks == 0 || src->tracks == NULL) { + GST_DEBUG_OBJECT (src, "no tracks"); + GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, + (_("This CD has no audio tracks")), (NULL)); + gst_cdda_base_src_stop (basesrc); + return FALSE; + } + + /* need to calculate disc IDs before we ditch the data tracks */ + gst_cdda_base_src_calculate_cddb_id (src); + gst_cddabasesrc_calculate_musicbrainz_discid (src); + +#if 0 + /* adjust sector offsets if necessary */ + if (src->toc_bias) { + src->toc_offset -= src->tracks[0].start; + } + for (i = 0; i < src->num_tracks; ++i) { + src->tracks[i].start += src->toc_offset; + src->tracks[i].end += src->toc_offset; + } +#endif + + /* now that we calculated the various disc IDs, + * sort the data tracks to end and ignore them */ + src->num_all_tracks = src->num_tracks; + + g_qsort_with_data (src->tracks, src->num_tracks, + sizeof (GstCddaBaseSrcTrack), gst_cdda_base_src_track_sort_func, NULL); + + while (src->num_tracks > 0 && !src->tracks[src->num_tracks - 1].is_audio) + --src->num_tracks; + + if (src->num_tracks == 0) { + GST_DEBUG_OBJECT (src, "no audio tracks"); + GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, + (_("This CD has no audio tracks")), (NULL)); + gst_cdda_base_src_stop (basesrc); + return FALSE; + } + + gst_cdda_base_src_add_tags (src); + + if (src->index && GST_INDEX_IS_WRITABLE (src->index)) + gst_cdda_base_src_add_index_associations (src); + + src->cur_track = 0; + src->prev_track = -1; + + if (src->uri_track > 0 && src->uri_track <= src->num_tracks) { + GST_LOG_OBJECT (src, "seek to track %d", src->uri_track); + src->cur_track = src->uri_track - 1; + src->uri_track = -1; + src->mode = GST_CDDA_BASE_SRC_MODE_NORMAL; + } + + src->cur_sector = src->tracks[src->cur_track].start; + GST_LOG_OBJECT (src, "starting at sector %d", src->cur_sector); + + gst_cdda_base_src_update_duration (src); + + return TRUE; +} + +static void +gst_cdda_base_src_clear_tracks (GstCddaBaseSrc * src) +{ + if (src->tracks != NULL) { + gint i; + + for (i = 0; i < src->num_all_tracks; ++i) { + if (src->tracks[i].tags) + gst_tag_list_free (src->tracks[i].tags); + } + + g_free (src->tracks); + src->tracks = NULL; + } + src->num_tracks = 0; + src->num_all_tracks = 0; +} + +static gboolean +gst_cdda_base_src_stop (GstBaseSrc * basesrc) +{ + GstCddaBaseSrcClass *klass = GST_CDDA_BASE_SRC_GET_CLASS (basesrc); + GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (basesrc); + + g_assert (klass->close != NULL); + + klass->close (src); + + gst_cdda_base_src_clear_tracks (src); + + if (src->tags) { + gst_tag_list_free (src->tags); + src->tags = NULL; + } + + src->prev_track = -1; + src->cur_track = -1; + + return TRUE; +} + +static GstFlowReturn +gst_cdda_base_src_create (GstPushSrc * pushsrc, GstBuffer ** buffer) +{ + GstCddaBaseSrcClass *klass = GST_CDDA_BASE_SRC_GET_CLASS (pushsrc); + GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (pushsrc); + GstBuffer *buf; + GstFormat format; + gboolean eos; + gint64 position; + gint64 duration; + + g_assert (klass->read_sector != NULL); + + switch (src->mode) { + case GST_CDDA_BASE_SRC_MODE_NORMAL: + eos = (src->cur_sector >= src->tracks[src->cur_track].end); + break; + case GST_CDDA_BASE_SRC_MODE_CONTINUOUS: + eos = (src->cur_sector >= src->tracks[src->num_tracks - 1].end); + src->cur_track = gst_cdda_base_src_get_track_from_sector (src, + src->cur_sector); + break; + default: + g_assert_not_reached (); + } + + if (eos) { + src->prev_track = -1; + GST_DEBUG_OBJECT (src, "EOS at sector %d, cur_track=%d, mode=%d", + src->cur_sector, src->cur_track, src->mode); + gst_pad_push_event (GST_BASE_SRC_PAD (src), gst_event_new_eos ()); + return GST_FLOW_UNEXPECTED; + } + + if (src->prev_track != src->cur_track) { + GstTagList *tags; + + tags = gst_tag_list_merge (src->tags, src->tracks[src->cur_track].tags, + GST_TAG_MERGE_REPLACE); + GST_LOG_OBJECT (src, "announcing tags: %" GST_PTR_FORMAT, tags); + gst_element_found_tags_for_pad (GST_ELEMENT (src), + GST_BASE_SRC_PAD (src), tags); + src->prev_track = src->cur_track; + + gst_cdda_base_src_update_duration (src); + + g_object_notify (G_OBJECT (src), "track"); + } + + GST_LOG_OBJECT (src, "asking for sector %u", src->cur_sector); + + buf = klass->read_sector (src, src->cur_sector); + + if (buf == NULL) { + GST_WARNING_OBJECT (src, "failed to read sector %u", src->cur_sector); + return GST_FLOW_ERROR; + } + + if (GST_BUFFER_CAPS (buf) == NULL) { + gst_buffer_set_caps (buf, GST_PAD_CAPS (GST_BASE_SRC_PAD (src))); + } + + format = GST_FORMAT_TIME; + if (!gst_pad_query_position (GST_BASE_SRC_PAD (src), &format, &position)) { + position = GST_CLOCK_TIME_NONE; + } + + /* 4 bytes per sample, 44100 samples per second */ + duration = gst_util_uint64_scale_int (GST_BUFFER_SIZE (buf) >> 2, GST_SECOND, + 44100); + + GST_BUFFER_TIMESTAMP (buf) = position; + GST_BUFFER_DURATION (buf) = duration; + + GST_LOG_OBJECT (src, "pushing sector %d with timestamp %" GST_TIME_FORMAT, + src->cur_sector, GST_TIME_ARGS (position)); + + ++src->cur_sector; + + *buffer = buf; + + return GST_FLOW_OK; +} diff --git a/gst-libs/gst/cdda/gstcddabasesrc.h b/gst-libs/gst/cdda/gstcddabasesrc.h new file mode 100644 index 0000000..27813c8 --- /dev/null +++ b/gst-libs/gst/cdda/gstcddabasesrc.h @@ -0,0 +1,181 @@ +/* GStreamer + * Copyright (C) 1999 Erik Walthinsen + * Copyright (C) 2005 Tim-Philipp Müller + * + * 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_CDDA_BASE_SRC_H__ +#define __GST_CDDA_BASE_SRC_H__ + +#include +#include + +G_BEGIN_DECLS + +#define GST_TYPE_CDDA_BASE_SRC (gst_cdda_base_src_get_type()) +#define GST_CDDA_BASE_SRC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_CDDA_BASE_SRC, GstCddaBaseSrc)) +#define GST_CDDA_BASE_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_CDDA_BASE_SRC, GstCddaBaseSrcClass)) +#define GST_IS_CDDA_BASE_SRC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_CDDA_BASE_SRC)) +#define GST_IS_CDDA_BASE_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_CDDA_BASE_SRC)) +#define GST_CDDA_BASE_SRC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_CDDA_BASE_SRC, GstCddaBaseSrcClass)) + +typedef struct _GstCddaBaseSrc GstCddaBaseSrc; +typedef struct _GstCddaBaseSrcClass GstCddaBaseSrcClass; +typedef struct _GstCddaBaseSrcTrack GstCddaBaseSrcTrack; + +/** + * GstCddaBaseSrcMode: + * @GST_CDDA_BASE_SRC_MODE_NORMAL : each single track is a stream + * @GST_CDDA_BASE_SRC_MODE_CONTINUOUS : the entire disc is a single stream + * + * Mode in which the CD audio source operates. Influences timestamping, + * EOS handling and seeking. + */ +typedef enum { + GST_CDDA_BASE_SRC_MODE_NORMAL, /* stream = one track */ + GST_CDDA_BASE_SRC_MODE_CONTINUOUS /* stream = whole disc */ +} GstCddaBaseSrcMode; + +/** + * GstCddaBaseSrcTrack: + * @is_audio: Whether this is an audio track + * @num: Track number in TOC (usually starts from 1, but not always) + * @start: The first sector of this track (LBA) + * @end: The last sector of this track (LBA) + * @tags: Track-specific tags (e.g. from cd-text information), or NULL + * + * CD track abstraction to communicate TOC entries to the base class. + */ +struct _GstCddaBaseSrcTrack { + gboolean is_audio; /* TRUE if this is an audio track */ + guint num; /* real track number (usually starts from 1) */ + guint start; /* first sector of track (LBA, not LSN!) */ + guint end; /* last sector of track (LBA, not LSN!) */ + GstTagList *tags; /* NULL or tags for track (e.g. from cd-text) */ + + /*< private >*/ + guint _gst_reserved1[GST_PADDING/2]; + gpointer _gst_reserved2[GST_PADDING/2]; +}; + +struct _GstCddaBaseSrc { + GstPushSrc pushsrc; + + /*< protected >*/ /* for use by sub-classes only */ + GstTagList *tags; /* tags that apply to all tracks */ + + /*< private >*/ + GstCddaBaseSrcMode mode; + + gchar *device; + + guint num_tracks; + guint num_all_tracks; + GstCddaBaseSrcTrack *tracks; + + gint cur_track; /* current track (starting from 0) */ + gint prev_track; /* current track last time */ + gint cur_sector; /* current sector */ + gint seek_sector; /* -1 or sector to seek to */ + + gint uri_track; + gchar *uri; + + guint32 discid; /* cddb disc id (for unit test) */ + gchar mb_discid[32]; /* musicbrainz discid */ + + GstIndex *index; + gint index_id; + + gint toc_offset; + gboolean toc_bias; + + /*< private >*/ + guint _gst_reserved1[GST_PADDING/2]; + gpointer _gst_reserved2[GST_PADDING/2]; +}; + +struct _GstCddaBaseSrcClass { + GstPushSrcClass pushsrc_class; + + /* open/close the CD device */ + gboolean (*open) (GstCddaBaseSrc *src, const gchar *device); + void (*close) (GstCddaBaseSrc *src); + + /* read one sector (LBA) */ + GstBuffer * (*read_sector) (GstCddaBaseSrc *src, gint sector); + + /* return default device or NULL (optional) */ + gchar * (*get_default_device) (GstCddaBaseSrc *src); + + /* return NULL-terminated string array of CD devices, or NULL (optional) */ + gchar ** (*probe_devices) (GstCddaBaseSrc *src); + + /*< private >*/ + gpointer _gst_reserved[GST_PADDING]; +}; + +GType gst_cdda_base_src_get_type (void); + +gboolean gst_cdda_base_src_add_track (GstCddaBaseSrc * src, + GstCddaBaseSrcTrack * track); + + +/* tags */ + +/** + * GST_TAG_CDDA_CDDB_DISCID: + * + * CDDB disc id in its short form (e.g. 'aa063d0f') + */ +#define GST_TAG_CDDA_CDDB_DISCID "discid" + +/** + * GST_TAG_CDDA_CDDB_DISCID_FULL: + * + * CDDB disc id including all details + */ +#define GST_TAG_CDDA_CDDB_DISCID_FULL "discid-full" + +/** + * GST_TAG_CDDA_MUSICBRAINZ_DISCID: + * + * Musicbrainz disc id (e.g. 'ahg7JUcfR3vCYBphSDIogOOWrr0-') + */ +#define GST_TAG_CDDA_MUSICBRAINZ_DISCID "musicbrainz-discid" + +/** + * GST_TAG_CDDA_MUSICBRAINZ_DISCID_FULL: + * + * Musicbrainz disc id details + */ +#define GST_TAG_CDDA_MUSICBRAINZ_DISCID_FULL "musicbrainz-discid-full" + +#if 0 +/** + * GST_TAG_CDDA_TRACK_TAGS: + * + * Tag details for all available tracks + * FiXME: find out which type we want for this! + */ +#define GST_TAG_CDDA_TRACK_TAGS "track-tags" +#endif + +G_END_DECLS + +#endif /* __GST_CDDA_BASE_SRC_H__ */ + diff --git a/gst-libs/gst/cdda/sha1.c b/gst-libs/gst/cdda/sha1.c new file mode 100644 index 0000000..d406bad --- /dev/null +++ b/gst-libs/gst/cdda/sha1.c @@ -0,0 +1,450 @@ +/* (PD) 2001 The Bitzi Corporation + * Please see file COPYING or http://bitzi.com/publicdomain + * for more info. + * + * NIST Secure Hash Algorithm + * heavily modified by Uwe Hollerbach + * from Peter C. Gutmann's implementation as found in + * Applied Cryptography by Bruce Schneier + * Further modifications to include the "UNRAVEL" stuff, below + * + * This code is in the public domain + * + * $Id$ + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#include +#define SHA_BYTE_ORDER G_BYTE_ORDER + +#include +#include "sha1.h" + +/* UNRAVEL should be fastest & biggest */ +/* UNROLL_LOOPS should be just as big, but slightly slower */ +/* both undefined should be smallest and slowest */ + +#define UNRAVEL +/* #define UNROLL_LOOPS */ + +/* SHA f()-functions */ + +#define f1(x,y,z) ((x & y) | (~x & z)) +#define f2(x,y,z) (x ^ y ^ z) +#define f3(x,y,z) ((x & y) | (x & z) | (y & z)) +#define f4(x,y,z) (x ^ y ^ z) + +/* SHA constants */ + +#define CONST1 0x5a827999L +#define CONST2 0x6ed9eba1L +#define CONST3 0x8f1bbcdcL +#define CONST4 0xca62c1d6L + +/* truncate to 32 bits -- should be a null op on 32-bit machines */ + +#define T32(x) ((x) & 0xffffffffL) + +/* 32-bit rotate */ + +#define R32(x,n) T32(((x << n) | (x >> (32 - n)))) + +/* the generic case, for when the overall rotation is not unraveled */ + +#define FG(n) \ + T = T32(R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n); \ + E = D; D = C; C = R32(B,30); B = A; A = T + +/* specific cases, for when the overall rotation is unraveled */ + +#define FA(n) \ + T = T32(R32(A,5) + f##n(B,C,D) + E + *WP++ + CONST##n); B = R32(B,30) + +#define FB(n) \ + E = T32(R32(T,5) + f##n(A,B,C) + D + *WP++ + CONST##n); A = R32(A,30) + +#define FC(n) \ + D = T32(R32(E,5) + f##n(T,A,B) + C + *WP++ + CONST##n); T = R32(T,30) + +#define FD(n) \ + C = T32(R32(D,5) + f##n(E,T,A) + B + *WP++ + CONST##n); E = R32(E,30) + +#define FE(n) \ + B = T32(R32(C,5) + f##n(D,E,T) + A + *WP++ + CONST##n); D = R32(D,30) + +#define FT(n) \ + A = T32(R32(B,5) + f##n(C,D,E) + T + *WP++ + CONST##n); C = R32(C,30) + +/* do SHA transformation */ + +static void +sha_transform (SHA_INFO * sha_info) +{ + int i; + SHA_BYTE *dp; + SHA_LONG T, A, B, C, D, E, W[80], *WP; + + dp = sha_info->data; + +/* +the following makes sure that at least one code block below is +traversed or an error is reported, without the necessity for nested +preprocessor if/else/endif blocks, which are a great pain in the +nether regions of the anatomy... +*/ +#undef SWAP_DONE + +#if (SHA_BYTE_ORDER == 1234) +#define SWAP_DONE + for (i = 0; i < 16; ++i) { + T = *((SHA_LONG *) dp); + dp += 4; + W[i] = ((T << 24) & 0xff000000) | ((T << 8) & 0x00ff0000) | + ((T >> 8) & 0x0000ff00) | ((T >> 24) & 0x000000ff); + } +#endif /* SHA_BYTE_ORDER == 1234 */ + +#if (SHA_BYTE_ORDER == 4321) +#define SWAP_DONE + for (i = 0; i < 16; ++i) { + T = *((SHA_LONG *) dp); + dp += 4; + W[i] = T32 (T); + } +#endif /* SHA_BYTE_ORDER == 4321 */ + +#if (SHA_BYTE_ORDER == 12345678) +#define SWAP_DONE + for (i = 0; i < 16; i += 2) { + T = *((SHA_LONG *) dp); + dp += 8; + W[i] = ((T << 24) & 0xff000000) | ((T << 8) & 0x00ff0000) | + ((T >> 8) & 0x0000ff00) | ((T >> 24) & 0x000000ff); + T >>= 32; + W[i + 1] = ((T << 24) & 0xff000000) | ((T << 8) & 0x00ff0000) | + ((T >> 8) & 0x0000ff00) | ((T >> 24) & 0x000000ff); + } +#endif /* SHA_BYTE_ORDER == 12345678 */ + +#if (SHA_BYTE_ORDER == 87654321) +#define SWAP_DONE + for (i = 0; i < 16; i += 2) { + T = *((SHA_LONG *) dp); + dp += 8; + W[i] = T32 (T >> 32); + W[i + 1] = T32 (T); + } +#endif /* SHA_BYTE_ORDER == 87654321 */ + +#ifndef SWAP_DONE +#error Unknown byte order -- you need to add code here +#endif /* SWAP_DONE */ + + for (i = 16; i < 80; ++i) { + W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]; +#if (SHA_VERSION == 1) + W[i] = R32 (W[i], 1); +#endif /* SHA_VERSION */ + } + A = sha_info->digest[0]; + B = sha_info->digest[1]; + C = sha_info->digest[2]; + D = sha_info->digest[3]; + E = sha_info->digest[4]; + WP = W; +#ifdef UNRAVEL + FA (1); + FB (1); + FC (1); + FD (1); + FE (1); + FT (1); + FA (1); + FB (1); + FC (1); + FD (1); + FE (1); + FT (1); + FA (1); + FB (1); + FC (1); + FD (1); + FE (1); + FT (1); + FA (1); + FB (1); + FC (2); + FD (2); + FE (2); + FT (2); + FA (2); + FB (2); + FC (2); + FD (2); + FE (2); + FT (2); + FA (2); + FB (2); + FC (2); + FD (2); + FE (2); + FT (2); + FA (2); + FB (2); + FC (2); + FD (2); + FE (3); + FT (3); + FA (3); + FB (3); + FC (3); + FD (3); + FE (3); + FT (3); + FA (3); + FB (3); + FC (3); + FD (3); + FE (3); + FT (3); + FA (3); + FB (3); + FC (3); + FD (3); + FE (3); + FT (3); + FA (4); + FB (4); + FC (4); + FD (4); + FE (4); + FT (4); + FA (4); + FB (4); + FC (4); + FD (4); + FE (4); + FT (4); + FA (4); + FB (4); + FC (4); + FD (4); + FE (4); + FT (4); + FA (4); + FB (4); + sha_info->digest[0] = T32 (sha_info->digest[0] + E); + sha_info->digest[1] = T32 (sha_info->digest[1] + T); + sha_info->digest[2] = T32 (sha_info->digest[2] + A); + sha_info->digest[3] = T32 (sha_info->digest[3] + B); + sha_info->digest[4] = T32 (sha_info->digest[4] + C); +#else /* !UNRAVEL */ +#ifdef UNROLL_LOOPS + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (1); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (2); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (3); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); + FG (4); +#else /* !UNROLL_LOOPS */ + for (i = 0; i < 20; ++i) { + FG (1); + } + for (i = 20; i < 40; ++i) { + FG (2); + } + for (i = 40; i < 60; ++i) { + FG (3); + } + for (i = 60; i < 80; ++i) { + FG (4); + } +#endif /* !UNROLL_LOOPS */ + sha_info->digest[0] = T32 (sha_info->digest[0] + A); + sha_info->digest[1] = T32 (sha_info->digest[1] + B); + sha_info->digest[2] = T32 (sha_info->digest[2] + C); + sha_info->digest[3] = T32 (sha_info->digest[3] + D); + sha_info->digest[4] = T32 (sha_info->digest[4] + E); +#endif /* !UNRAVEL */ +} + +/* initialize the SHA digest */ + +void +sha_init (SHA_INFO * sha_info) +{ + sha_info->digest[0] = 0x67452301L; + sha_info->digest[1] = 0xefcdab89L; + sha_info->digest[2] = 0x98badcfeL; + sha_info->digest[3] = 0x10325476L; + sha_info->digest[4] = 0xc3d2e1f0L; + sha_info->count_lo = 0L; + sha_info->count_hi = 0L; + sha_info->local = 0; +} + +/* update the SHA digest */ + +void +sha_update (SHA_INFO * sha_info, SHA_BYTE * buffer, int count) +{ + int i; + SHA_LONG clo; + + clo = T32 (sha_info->count_lo + ((SHA_LONG) count << 3)); + if (clo < sha_info->count_lo) { + ++sha_info->count_hi; + } + sha_info->count_lo = clo; + sha_info->count_hi += (SHA_LONG) count >> 29; + if (sha_info->local) { + i = SHA_BLOCKSIZE - sha_info->local; + if (i > count) { + i = count; + } + memcpy (((SHA_BYTE *) sha_info->data) + sha_info->local, buffer, i); + count -= i; + buffer += i; + sha_info->local += i; + if (sha_info->local == SHA_BLOCKSIZE) { + sha_transform (sha_info); + } else { + return; + } + } + while (count >= SHA_BLOCKSIZE) { + memcpy (sha_info->data, buffer, SHA_BLOCKSIZE); + buffer += SHA_BLOCKSIZE; + count -= SHA_BLOCKSIZE; + sha_transform (sha_info); + } + memcpy (sha_info->data, buffer, count); + sha_info->local = count; +} + +/* finish computing the SHA digest */ + +void +sha_final (unsigned char digest[20], SHA_INFO * sha_info) +{ + int count; + SHA_LONG lo_bit_count, hi_bit_count; + + lo_bit_count = sha_info->count_lo; + hi_bit_count = sha_info->count_hi; + count = (int) ((lo_bit_count >> 3) & 0x3f); + ((SHA_BYTE *) sha_info->data)[count++] = 0x80; + if (count > SHA_BLOCKSIZE - 8) { + memset (((SHA_BYTE *) sha_info->data) + count, 0, SHA_BLOCKSIZE - count); + sha_transform (sha_info); + memset ((SHA_BYTE *) sha_info->data, 0, SHA_BLOCKSIZE - 8); + } else { + memset (((SHA_BYTE *) sha_info->data) + count, 0, + SHA_BLOCKSIZE - 8 - count); + } + sha_info->data[56] = (unsigned char) ((hi_bit_count >> 24) & 0xff); + sha_info->data[57] = (unsigned char) ((hi_bit_count >> 16) & 0xff); + sha_info->data[58] = (unsigned char) ((hi_bit_count >> 8) & 0xff); + sha_info->data[59] = (unsigned char) ((hi_bit_count >> 0) & 0xff); + sha_info->data[60] = (unsigned char) ((lo_bit_count >> 24) & 0xff); + sha_info->data[61] = (unsigned char) ((lo_bit_count >> 16) & 0xff); + sha_info->data[62] = (unsigned char) ((lo_bit_count >> 8) & 0xff); + sha_info->data[63] = (unsigned char) ((lo_bit_count >> 0) & 0xff); + sha_transform (sha_info); + digest[0] = (unsigned char) ((sha_info->digest[0] >> 24) & 0xff); + digest[1] = (unsigned char) ((sha_info->digest[0] >> 16) & 0xff); + digest[2] = (unsigned char) ((sha_info->digest[0] >> 8) & 0xff); + digest[3] = (unsigned char) ((sha_info->digest[0]) & 0xff); + digest[4] = (unsigned char) ((sha_info->digest[1] >> 24) & 0xff); + digest[5] = (unsigned char) ((sha_info->digest[1] >> 16) & 0xff); + digest[6] = (unsigned char) ((sha_info->digest[1] >> 8) & 0xff); + digest[7] = (unsigned char) ((sha_info->digest[1]) & 0xff); + digest[8] = (unsigned char) ((sha_info->digest[2] >> 24) & 0xff); + digest[9] = (unsigned char) ((sha_info->digest[2] >> 16) & 0xff); + digest[10] = (unsigned char) ((sha_info->digest[2] >> 8) & 0xff); + digest[11] = (unsigned char) ((sha_info->digest[2]) & 0xff); + digest[12] = (unsigned char) ((sha_info->digest[3] >> 24) & 0xff); + digest[13] = (unsigned char) ((sha_info->digest[3] >> 16) & 0xff); + digest[14] = (unsigned char) ((sha_info->digest[3] >> 8) & 0xff); + digest[15] = (unsigned char) ((sha_info->digest[3]) & 0xff); + digest[16] = (unsigned char) ((sha_info->digest[4] >> 24) & 0xff); + digest[17] = (unsigned char) ((sha_info->digest[4] >> 16) & 0xff); + digest[18] = (unsigned char) ((sha_info->digest[4] >> 8) & 0xff); + digest[19] = (unsigned char) ((sha_info->digest[4]) & 0xff); +} diff --git a/gst-libs/gst/cdda/sha1.h b/gst-libs/gst/cdda/sha1.h new file mode 100644 index 0000000..2e9e64a --- /dev/null +++ b/gst-libs/gst/cdda/sha1.h @@ -0,0 +1,62 @@ +/* NIST Secure Hash Algorithm */ +/* heavily modified by Uwe Hollerbach */ +/* from Peter C. Gutmann's implementation as found in */ +/* Applied Cryptography by Bruce Schneier */ +/* This code is in the public domain */ +/* $Id$ */ + +#ifndef __GST_CDDA_SHA_H__ +#define __GST_CDDA_SHA_H__ + +#include +#include + +/* Useful defines & typedefs */ +typedef unsigned char SHA_BYTE; /* 8-bit quantity */ +typedef unsigned long SHA_LONG; /* 32-or-more-bit quantity */ + +#define SHA_BLOCKSIZE 64 +#define SHA_DIGESTSIZE 20 + +typedef struct { + SHA_LONG digest[5]; /* message digest */ + SHA_LONG count_lo, count_hi; /* 64-bit bit count */ + SHA_BYTE data[SHA_BLOCKSIZE]; /* SHA data buffer */ + int local; /* unprocessed amount in data */ +} SHA_INFO; + +#define sha_init _gst_cdda_sha_init +#define sha_update _gst_cdda_sha_update +#define sha_final _gst_cdda_sha_final + +void sha_init(SHA_INFO *); +void sha_update(SHA_INFO *, SHA_BYTE *, int); +void sha_final(unsigned char [20], SHA_INFO *); + +#define SHA_VERSION 1 + +#ifdef HAVE_CONFIG_H +#include "config.h" + + +#ifdef WORDS_BIGENDIAN +# if SIZEOF_LONG == 4 +# define SHA_BYTE_ORDER 4321 +# elif SIZEOF_LONG == 8 +# define SHA_BYTE_ORDER 87654321 +# endif +#else +# if SIZEOF_LONG == 4 +# define SHA_BYTE_ORDER 1234 +# elif SIZEOF_LONG == 8 +# define SHA_BYTE_ORDER 12345678 +# endif +#endif + +#else + +#define SHA_BYTE_ORDER 1234 + +#endif + +#endif /* __GST_CDDA_SHA_H__ */ -- 2.7.4