-/* GStreamer
- * Copyright (C) 1999 Erik Walthinsen <omega@cse.ogi.edu>
+/* GStreamer Audio CD Source Base Class
* Copyright (C) 2005 Tim-Philipp Müller <tim centricular net>
*
* This library is free software; you can redistribute it and/or
*/
/**
- * SECTION:gstcddabasesrc
- * @short_description: Base class for CD digital audio (CDDA) sources
+ * SECTION:gstaudiocdsrc
+ * @short_description: Base class for Audio CD sources
*
* <refsect2>
* <para>
- * Provides a base class for CDDA sources, which handles things like seeking,
- * querying, discid calculation, tags, and buffer timestamping.
+ * Provides a base class for CD digital audio (CDDA) sources, which handles
+ * things like seeking, querying, discid calculation, tags, and buffer
+ * timestamping.
* </para>
- * <title>Using GstCddaBaseSrc-based elements in applications</title>
+ * <title>Using GstAudioCdSrc-based elements in applications</title>
* <para>
- * GstCddaBaseSrc registers two #GstFormat<!-- -->s of its own, namely
+ * GstAudioCdSrc registers two #GstFormat<!-- -->s of its own, namely
* the "track" format and the "sector" format. Applications will usually
* only find the "track" format interesting. You can retrieve that #GstFormat
* for use in seek events or queries with gst_format_get_by_nick("track").
#include <string.h>
#include <stdlib.h> /* for strtol */
+#include <gst/tag/tag.h>
#include <gst/audio/audio.h>
-#include "gstcddabasesrc.h"
+#include "gstaudiocdsrc.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
+GST_DEBUG_CATEGORY_STATIC (gst_audio_cd_src_debug);
+#define GST_CAT_DEFAULT gst_audio_cd_src_debug
#define DEFAULT_DEVICE "/dev/cdrom"
ARG_TOC_BIAS
};
-static void gst_cdda_base_src_uri_handler_init (gpointer g_iface,
+static void gst_audio_cd_src_uri_handler_init (gpointer g_iface,
gpointer iface_data);
-static void gst_cdda_base_src_get_property (GObject * object, guint prop_id,
+static void gst_audio_cd_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,
+static void gst_audio_cd_src_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec);
-static void gst_cdda_base_src_finalize (GObject * obj);
-static gboolean gst_cdda_base_src_query (GstBaseSrc * src, GstQuery * query);
-static gboolean gst_cdda_base_src_handle_event (GstBaseSrc * basesrc,
+static void gst_audio_cd_src_finalize (GObject * obj);
+static gboolean gst_audio_cd_src_query (GstBaseSrc * src, GstQuery * query);
+static gboolean gst_audio_cd_src_handle_event (GstBaseSrc * basesrc,
GstEvent * event);
-static gboolean gst_cdda_base_src_do_seek (GstBaseSrc * basesrc,
+static gboolean gst_audio_cd_src_do_seek (GstBaseSrc * basesrc,
GstSegment * segment);
-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,
+static gboolean gst_audio_cd_src_start (GstBaseSrc * basesrc);
+static gboolean gst_audio_cd_src_stop (GstBaseSrc * basesrc);
+static GstFlowReturn gst_audio_cd_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);
+static gboolean gst_audio_cd_src_is_seekable (GstBaseSrc * basesrc);
+static void gst_audio_cd_src_update_duration (GstAudioCdSrc * src);
+static void gst_audio_cd_src_set_index (GstElement * src, GstIndex * index);
+static GstIndex *gst_audio_cd_src_get_index (GstElement * src);
-#define gst_cdda_base_src_parent_class parent_class
-G_DEFINE_TYPE_WITH_CODE (GstCddaBaseSrc, gst_cdda_base_src, GST_TYPE_PUSH_SRC,
+#define gst_audio_cd_src_parent_class parent_class
+G_DEFINE_TYPE_WITH_CODE (GstAudioCdSrc, gst_audio_cd_src, GST_TYPE_PUSH_SRC,
G_IMPLEMENT_INTERFACE (GST_TYPE_URI_HANDLER,
- gst_cdda_base_src_uri_handler_init));
+ gst_audio_cd_src_uri_handler_init));
#define SRC_CAPS \
"audio/x-raw, " \
"rate = (int) 44100, " \
"channels = (int) 2" \
-static GstStaticPadTemplate gst_cdda_base_src_src_template =
+static GstStaticPadTemplate gst_audio_cd_src_src_template =
GST_STATIC_PAD_TEMPLATE ("src",
GST_PAD_SRC,
GST_PAD_ALWAYS,
static GstFormat sector_format;
GType
-gst_cdda_base_src_mode_get_type (void)
+gst_audio_cd_src_mode_get_type (void)
{
static GType mode_type; /* 0 */
static const GEnumValue modes[] = {
- {GST_CDDA_BASE_SRC_MODE_NORMAL, "Stream consists of a single track",
+ {GST_AUDIO_CD_SRC_MODE_NORMAL, "Stream consists of a single track",
"normal"},
- {GST_CDDA_BASE_SRC_MODE_CONTINUOUS, "Stream consists of the whole disc",
+ {GST_AUDIO_CD_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);
+ mode_type = g_enum_register_static ("GstAudioCdSrcMode", modes);
return mode_type;
}
static void
-gst_cdda_base_src_class_init (GstCddaBaseSrcClass * klass)
+gst_audio_cd_src_class_init (GstAudioCdSrcClass * klass)
{
GstElementClass *element_class;
GstPushSrcClass *pushsrc_class;
basesrc_class = (GstBaseSrcClass *) klass;
pushsrc_class = (GstPushSrcClass *) klass;
- GST_DEBUG_CATEGORY_INIT (gst_cdda_base_src_debug, "cddabasesrc", 0,
- "CDDA Base Source");
+ GST_DEBUG_CATEGORY_INIT (gst_audio_cd_src_debug, "audiocdsrc", 0,
+ "Audio CD source base class");
/* our very own formats */
track_format = gst_format_register ("track", "CD track");
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
- 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;
+ gobject_class->set_property = gst_audio_cd_src_set_property;
+ gobject_class->get_property = gst_audio_cd_src_get_property;
+ gobject_class->finalize = gst_audio_cd_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_PARAM_STATIC_STRINGS));
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_spec_enum ("mode", "Mode", "Mode", GST_TYPE_AUDIO_CD_SRC_MODE,
+ GST_AUDIO_CD_SRC_MODE_NORMAL,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TRACK,
#endif
gst_element_class_add_pad_template (element_class,
- gst_static_pad_template_get (&gst_cdda_base_src_src_template));
+ gst_static_pad_template_get (&gst_audio_cd_src_src_template));
- 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);
+ element_class->set_index = GST_DEBUG_FUNCPTR (gst_audio_cd_src_set_index);
+ element_class->get_index = GST_DEBUG_FUNCPTR (gst_audio_cd_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);
+ basesrc_class->start = GST_DEBUG_FUNCPTR (gst_audio_cd_src_start);
+ basesrc_class->stop = GST_DEBUG_FUNCPTR (gst_audio_cd_src_stop);
+ basesrc_class->query = GST_DEBUG_FUNCPTR (gst_audio_cd_src_query);
+ basesrc_class->event = GST_DEBUG_FUNCPTR (gst_audio_cd_src_handle_event);
+ basesrc_class->do_seek = GST_DEBUG_FUNCPTR (gst_audio_cd_src_do_seek);
+ basesrc_class->is_seekable = GST_DEBUG_FUNCPTR (gst_audio_cd_src_is_seekable);
- pushsrc_class->create = GST_DEBUG_FUNCPTR (gst_cdda_base_src_create);
+ pushsrc_class->create = GST_DEBUG_FUNCPTR (gst_audio_cd_src_create);
}
static void
-gst_cdda_base_src_init (GstCddaBaseSrc * src)
+gst_audio_cd_src_init (GstAudioCdSrc * src)
{
/* 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->mode = GST_AUDIO_CD_SRC_MODE_NORMAL;
src->uri_track = -1;
}
static void
-gst_cdda_base_src_finalize (GObject * obj)
+gst_audio_cd_src_finalize (GObject * obj)
{
- GstCddaBaseSrc *cddasrc = GST_CDDA_BASE_SRC (obj);
+ GstAudioCdSrc *cddasrc = GST_AUDIO_CD_SRC (obj);
g_free (cddasrc->uri);
g_free (cddasrc->device);
}
static void
-gst_cdda_base_src_set_device (GstCddaBaseSrc * src, const gchar * device)
+gst_audio_cd_src_set_device (GstAudioCdSrc * src, const gchar * device)
{
if (src->device)
g_free (src->device);
}
static void
-gst_cdda_base_src_set_property (GObject * object, guint prop_id,
+gst_audio_cd_src_set_property (GObject * object, guint prop_id,
const GValue * value, GParamSpec * pspec)
{
- GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (object);
+ GstAudioCdSrc *src = GST_AUDIO_CD_SRC (object);
GST_OBJECT_LOCK (src);
case ARG_DEVICE:{
const gchar *dev = g_value_get_string (value);
- gst_cdda_base_src_set_device (src, dev);
+ gst_audio_cd_src_set_device (src, dev);
break;
}
case ARG_TRACK:{
}
static void
-gst_cdda_base_src_get_property (GObject * object, guint prop_id,
+gst_audio_cd_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);
+ GstAudioCdSrcClass *klass = GST_AUDIO_CD_SRC_GET_CLASS (object);
+ GstAudioCdSrc *src = GST_AUDIO_CD_SRC (object);
GST_OBJECT_LOCK (src);
}
static gint
-gst_cdda_base_src_get_track_from_sector (GstCddaBaseSrc * src, gint sector)
+gst_audio_cd_src_get_track_from_sector (GstAudioCdSrc * src, gint sector)
{
gint i;
}
static gboolean
-gst_cdda_base_src_convert (GstCddaBaseSrc * src, GstFormat src_format,
+gst_audio_cd_src_convert (GstAudioCdSrc * src, GstFormat src_format,
gint64 src_val, GstFormat dest_format, gint64 * dest_val)
{
gboolean started;
} else if (dest_format == track_format) {
if (!started)
goto not_started;
- *dest_val = gst_cdda_base_src_get_track_from_sector (src, sector);
+ *dest_val = gst_audio_cd_src_get_track_from_sector (src, sector);
} else {
goto unknown_format;
}
} else if (dest_format == track_format) {
if (!started)
goto not_started;
- *dest_val = gst_cdda_base_src_get_track_from_sector (src, sector);
+ *dest_val = gst_audio_cd_src_get_track_from_sector (src, sector);
} else {
goto unknown_format;
}
}
static gboolean
-gst_cdda_base_src_query (GstBaseSrc * basesrc, GstQuery * query)
+gst_audio_cd_src_query (GstBaseSrc * basesrc, GstQuery * query)
{
- GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (basesrc);
+ GstAudioCdSrc *src = GST_AUDIO_CD_SRC (basesrc);
gboolean started;
started = GST_OBJECT_FLAG_IS_SET (basesrc, GST_BASE_SRC_STARTED);
if (src->cur_track < 0 || src->cur_track >= src->num_tracks)
return FALSE;
- if (src->mode == GST_CDDA_BASE_SRC_MODE_NORMAL) {
+ if (src->mode == GST_AUDIO_CD_SRC_MODE_NORMAL) {
sectors = src->tracks[src->cur_track].end -
src->tracks[src->cur_track].start + 1;
} else {
}
/* ... and convert into final format */
- if (!gst_cdda_base_src_convert (src, sector_format, sectors,
+ if (!gst_audio_cd_src_convert (src, sector_format, sectors,
dest_format, &dest_val)) {
return FALSE;
}
if (src->cur_track < 0 || src->cur_track >= src->num_tracks)
return FALSE;
- if (src->mode == GST_CDDA_BASE_SRC_MODE_NORMAL) {
+ if (src->mode == GST_AUDIO_CD_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,
+ if (!gst_audio_cd_src_convert (src, sector_format, pos_sector,
dest_format, &dest_val)) {
return FALSE;
}
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,
+ if (!gst_audio_cd_src_convert (src, src_format, src_val, dest_format,
&dest_val)) {
return FALSE;
}
}
static gboolean
-gst_cdda_base_src_is_seekable (GstBaseSrc * basesrc)
+gst_audio_cd_src_is_seekable (GstBaseSrc * basesrc)
{
return TRUE;
}
static gboolean
-gst_cdda_base_src_do_seek (GstBaseSrc * basesrc, GstSegment * segment)
+gst_audio_cd_src_do_seek (GstBaseSrc * basesrc, GstSegment * segment)
{
- GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (basesrc);
+ GstAudioCdSrc *src = GST_AUDIO_CD_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,
+ if (!gst_audio_cd_src_convert (src, GST_FORMAT_TIME, segment->start,
sector_format, &seek_sector)) {
GST_WARNING_OBJECT (src, "conversion failed");
return FALSE;
g_assert (src->cur_track >= 0 && src->cur_track < src->num_tracks);
switch (src->mode) {
- case GST_CDDA_BASE_SRC_MODE_NORMAL:
+ case GST_AUDIO_CD_SRC_MODE_NORMAL:
seek_sector += src->tracks[src->cur_track].start;
break;
- case GST_CDDA_BASE_SRC_MODE_CONTINUOUS:
+ case GST_AUDIO_CD_SRC_MODE_CONTINUOUS:
seek_sector += src->tracks[0].start;
break;
default:
}
static gboolean
-gst_cdda_base_src_handle_track_seek (GstCddaBaseSrc * src, gdouble rate,
+gst_audio_cd_src_handle_track_seek (GstAudioCdSrc * src, gdouble rate,
GstSeekFlags flags, GstSeekType start_type, gint64 start,
GstSeekType stop_type, gint64 stop)
{
gint64 start_time = -1;
gint64 stop_time = -1;
- if (src->mode != GST_CDDA_BASE_SRC_MODE_CONTINUOUS) {
+ if (src->mode != GST_AUDIO_CD_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,
+ if (!gst_audio_cd_src_convert (src, track_format, start,
GST_FORMAT_TIME, &start_time)) {
GST_DEBUG_OBJECT (src, "cannot convert track %d to time",
(gint) start);
}
break;
case GST_SEEK_TYPE_END:
- if (!gst_cdda_base_src_convert (src, track_format,
+ if (!gst_audio_cd_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);
switch (stop_type) {
case GST_SEEK_TYPE_SET:
- if (!gst_cdda_base_src_convert (src, track_format, stop,
+ if (!gst_audio_cd_src_convert (src, track_format, stop,
GST_FORMAT_TIME, &stop_time)) {
GST_DEBUG_OBJECT (src, "cannot convert track %d to time",
(gint) stop);
}
break;
case GST_SEEK_TYPE_END:
- if (!gst_cdda_base_src_convert (src, track_format,
+ if (!gst_audio_cd_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);
src->uri_track = -1;
src->prev_track = -1;
- gst_cdda_base_src_update_duration (src);
+ gst_audio_cd_src_update_duration (src);
} else {
GST_DEBUG_OBJECT (src, "is current track, just seeking back to start");
}
}
static gboolean
-gst_cdda_base_src_handle_event (GstBaseSrc * basesrc, GstEvent * event)
+gst_audio_cd_src_handle_event (GstBaseSrc * basesrc, GstEvent * event)
{
- GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (basesrc);
+ GstAudioCdSrc *src = GST_AUDIO_CD_SRC (basesrc);
gboolean ret = FALSE;
GST_LOG_OBJECT (src, "handling %s event", GST_EVENT_TYPE_NAME (event));
}
if (format == track_format) {
- ret = gst_cdda_base_src_handle_track_seek (src, rate, flags,
+ ret = gst_audio_cd_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",
}
static GstURIType
-gst_cdda_base_src_uri_get_type (GType type)
+gst_audio_cd_src_uri_get_type (GType type)
{
return GST_URI_SRC;
}
static gchar **
-gst_cdda_base_src_uri_get_protocols (GType type)
+gst_audio_cd_src_uri_get_protocols (GType type)
{
static gchar *protocols[] = { (char *) "cdda", NULL };
}
static const gchar *
-gst_cdda_base_src_uri_get_uri (GstURIHandler * handler)
+gst_audio_cd_src_uri_get_uri (GstURIHandler * handler)
{
- GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (handler);
+ GstAudioCdSrc *src = GST_AUDIO_CD_SRC (handler);
GST_OBJECT_LOCK (src);
/* We accept URIs of the format cdda://(device#track)|(track) */
static gboolean
-gst_cdda_base_src_uri_set_uri (GstURIHandler * handler, const gchar * uri)
+gst_audio_cd_src_uri_set_uri (GstURIHandler * handler, const gchar * uri)
{
- GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (handler);
+ GstAudioCdSrc *src = GST_AUDIO_CD_SRC (handler);
gchar *protocol;
const gchar *location;
gchar *track_number;
track_number = nuri + (track_number - uri);
*track_number = '\0';
device = gst_uri_get_location (nuri);
- gst_cdda_base_src_set_device (src, device);
+ gst_audio_cd_src_set_device (src, device);
g_free (device);
src->uri_track = strtol (track_number + 1, NULL, 10);
g_free (nuri);
}
static void
-gst_cdda_base_src_uri_handler_init (gpointer g_iface, gpointer iface_data)
+gst_audio_cd_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;
+ iface->get_type = gst_audio_cd_src_uri_get_type;
+ iface->get_uri = gst_audio_cd_src_uri_get_uri;
+ iface->set_uri = gst_audio_cd_src_uri_set_uri;
+ iface->get_protocols = gst_audio_cd_src_uri_get_protocols;
}
/**
- * gst_cdda_base_src_add_track:
- * @src: a #GstCddaBaseSrc
- * @track: address of #GstCddaBaseSrcTrack to add
+ * gst_audio_cd_src_add_track:
+ * @src: a #GstAudioCdSrc
+ * @track: address of #GstAudioCdSrcTrack 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
*/
gboolean
-gst_cdda_base_src_add_track (GstCddaBaseSrc * src, GstCddaBaseSrcTrack * track)
+gst_audio_cd_src_add_track (GstAudioCdSrc * src, GstAudioCdSrcTrack * track)
{
- g_return_val_if_fail (GST_IS_CDDA_BASE_SRC (src), FALSE);
+ g_return_val_if_fail (GST_IS_AUDIO_CD_SRC (src), FALSE);
g_return_val_if_fail (track != NULL, FALSE);
g_return_val_if_fail (track->num > 0, FALSE);
GST_OBJECT_LOCK (src);
++src->num_tracks;
- src->tracks = g_renew (GstCddaBaseSrcTrack, src->tracks, src->num_tracks);
+ src->tracks = g_renew (GstAudioCdSrcTrack, src->tracks, src->num_tracks);
src->tracks[src->num_tracks - 1] = *track;
GST_OBJECT_UNLOCK (src);
}
static void
-gst_cdda_base_src_update_duration (GstCddaBaseSrc * src)
+gst_audio_cd_src_update_duration (GstAudioCdSrc * src)
{
GstBaseSrc *basesrc;
gint64 dur;
}
static void
-gst_cddabasesrc_calculate_musicbrainz_discid (GstCddaBaseSrc * src)
+gst_audio_cd_src_calculate_musicbrainz_discid (GstAudioCdSrc * src)
{
GString *s;
GChecksum *sha;
}
static void
-gst_cdda_base_src_calculate_cddb_id (GstCddaBaseSrc * src)
+gst_audio_cd_src_calculate_cddb_id (GstAudioCdSrc * src)
{
GString *s;
guint first_sector = 0, last_sector = 0;
}
static void
-gst_cdda_base_src_add_tags (GstCddaBaseSrc * src)
+gst_audio_cd_src_add_tags (GstAudioCdSrc * src)
{
gint i;
src->tracks[i].tags = gst_tag_list_new_empty ();
num_sectors = src->tracks[i].end - src->tracks[i].start + 1;
- gst_cdda_base_src_convert (src, sector_format, num_sectors,
+ gst_audio_cd_src_convert (src, sector_format, num_sectors,
GST_FORMAT_TIME, &duration);
gst_tag_list_add (src->tracks[i].tags,
}
static void
-gst_cdda_base_src_add_index_associations (GstCddaBaseSrc * src)
+gst_audio_cd_src_add_index_associations (GstAudioCdSrc * src)
{
gint i;
}
static void
-gst_cdda_base_src_set_index (GstElement * element, GstIndex * index)
+gst_audio_cd_src_set_index (GstElement * element, GstIndex * index)
{
- GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (element);
+ GstAudioCdSrc *src = GST_AUDIO_CD_SRC (element);
GstIndex *old;
GST_OBJECT_LOCK (element);
static GstIndex *
-gst_cdda_base_src_get_index (GstElement * element)
+gst_audio_cd_src_get_index (GstElement * element)
{
- GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (element);
+ GstAudioCdSrc *src = GST_AUDIO_CD_SRC (element);
GstIndex *index;
GST_OBJECT_LOCK (element);
}
static gint
-gst_cdda_base_src_track_sort_func (gconstpointer a, gconstpointer b,
+gst_audio_cd_src_track_sort_func (gconstpointer a, gconstpointer b,
gpointer foo)
{
- GstCddaBaseSrcTrack *track_a = ((GstCddaBaseSrcTrack *) a);
- GstCddaBaseSrcTrack *track_b = ((GstCddaBaseSrcTrack *) b);
+ GstAudioCdSrcTrack *track_a = ((GstAudioCdSrcTrack *) a);
+ GstAudioCdSrcTrack *track_b = ((GstAudioCdSrcTrack *) b);
/* sort data tracks to the end, and audio tracks by track number */
if (track_a->is_audio == track_b->is_audio)
}
static gboolean
-gst_cdda_base_src_start (GstBaseSrc * basesrc)
+gst_audio_cd_src_start (GstBaseSrc * basesrc)
{
- GstCddaBaseSrcClass *klass = GST_CDDA_BASE_SRC_GET_CLASS (basesrc);
- GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (basesrc);
+ GstAudioCdSrcClass *klass = GST_AUDIO_CD_SRC_GET_CLASS (basesrc);
+ GstAudioCdSrc *src = GST_AUDIO_CD_SRC (basesrc);
gboolean ret;
gchar *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);
+ gst_audio_cd_src_stop (basesrc);
return FALSE;
}
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);
+ gst_audio_cd_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);
+ gst_audio_cd_src_calculate_cddb_id (src);
+ gst_audio_cd_src_calculate_musicbrainz_discid (src);
#if 0
/* adjust sector offsets if necessary */
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);
+ sizeof (GstAudioCdSrcTrack), gst_audio_cd_src_track_sort_func, NULL);
while (src->num_tracks > 0 && !src->tracks[src->num_tracks - 1].is_audio)
--src->num_tracks;
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);
+ gst_audio_cd_src_stop (basesrc);
return FALSE;
}
- gst_cdda_base_src_add_tags (src);
+ gst_audio_cd_src_add_tags (src);
if (src->index && GST_INDEX_IS_WRITABLE (src->index))
- gst_cdda_base_src_add_index_associations (src);
+ gst_audio_cd_src_add_index_associations (src);
src->cur_track = 0;
src->prev_track = -1;
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->mode = GST_AUDIO_CD_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);
+ gst_audio_cd_src_update_duration (src);
return TRUE;
}
static void
-gst_cdda_base_src_clear_tracks (GstCddaBaseSrc * src)
+gst_audio_cd_src_clear_tracks (GstAudioCdSrc * src)
{
if (src->tracks != NULL) {
gint i;
}
static gboolean
-gst_cdda_base_src_stop (GstBaseSrc * basesrc)
+gst_audio_cd_src_stop (GstBaseSrc * basesrc)
{
- GstCddaBaseSrcClass *klass = GST_CDDA_BASE_SRC_GET_CLASS (basesrc);
- GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (basesrc);
+ GstAudioCdSrcClass *klass = GST_AUDIO_CD_SRC_GET_CLASS (basesrc);
+ GstAudioCdSrc *src = GST_AUDIO_CD_SRC (basesrc);
g_assert (klass->close != NULL);
klass->close (src);
- gst_cdda_base_src_clear_tracks (src);
+ gst_audio_cd_src_clear_tracks (src);
if (src->tags) {
gst_tag_list_free (src->tags);
static GstFlowReturn
-gst_cdda_base_src_create (GstPushSrc * pushsrc, GstBuffer ** buffer)
+gst_audio_cd_src_create (GstPushSrc * pushsrc, GstBuffer ** buffer)
{
- GstCddaBaseSrcClass *klass = GST_CDDA_BASE_SRC_GET_CLASS (pushsrc);
- GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (pushsrc);
+ GstAudioCdSrcClass *klass = GST_AUDIO_CD_SRC_GET_CLASS (pushsrc);
+ GstAudioCdSrc *src = GST_AUDIO_CD_SRC (pushsrc);
GstBuffer *buf;
gboolean eos;
g_assert (klass->read_sector != NULL);
switch (src->mode) {
- case GST_CDDA_BASE_SRC_MODE_NORMAL:
+ case GST_AUDIO_CD_SRC_MODE_NORMAL:
eos = (src->cur_sector > src->tracks[src->cur_track].end);
break;
- case GST_CDDA_BASE_SRC_MODE_CONTINUOUS:
+ case GST_AUDIO_CD_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_track = gst_audio_cd_src_get_track_from_sector (src,
src->cur_sector);
break;
default:
gst_pad_push_event (GST_BASE_SRC_PAD (src), gst_event_new_tag (tags));
src->prev_track = src->cur_track;
- gst_cdda_base_src_update_duration (src);
+ gst_audio_cd_src_update_duration (src);
g_object_notify (G_OBJECT (src), "track");
}
-/* GStreamer
- * Copyright (C) 1999 Erik Walthinsen <omega@cse.ogi.edu>
+/* GStreamer Audio CD Source Base Class
* Copyright (C) 2005 Tim-Philipp Müller <tim centricular net>
*
* This library is free software; you can redistribute it and/or
* Boston, MA 02111-1307, USA.
*/
-#ifndef __GST_CDDA_BASE_SRC_H__
-#define __GST_CDDA_BASE_SRC_H__
+#ifndef __GST_AUDIO_CD_SRC_H__
+#define __GST_AUDIO_CD_SRC_H__
#include <gst/gst.h>
#include <gst/base/gstpushsrc.h>
-/* must include this for backwards-compatibility so the
- * GST_TAG_CDDA_* defines are included. Remove in 0.11 */
-#include <gst/tag/tag.h>
-
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))
+#define GST_TYPE_AUDIO_CD_SRC (gst_audio_cd_src_get_type())
+#define GST_AUDIO_CD_SRC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_AUDIO_CD_SRC, GstAudioCdSrc))
+#define GST_AUDIO_CD_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GST_TYPE_AUDIO_CD_SRC, GstAudioCdSrcClass))
+#define GST_IS_AUDIO_CD_SRC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_AUDIO_CD_SRC))
+#define GST_IS_AUDIO_CD_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GST_TYPE_AUDIO_CD_SRC))
+#define GST_AUDIO_CD_SRC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GST_TYPE_AUDIO_CD_SRC, GstAudioCdSrcClass))
-typedef struct _GstCddaBaseSrc GstCddaBaseSrc;
-typedef struct _GstCddaBaseSrcClass GstCddaBaseSrcClass;
-typedef struct _GstCddaBaseSrcTrack GstCddaBaseSrcTrack;
+typedef struct _GstAudioCdSrc GstAudioCdSrc;
+typedef struct _GstAudioCdSrcClass GstAudioCdSrcClass;
+typedef struct _GstAudioCdSrcTrack GstAudioCdSrcTrack;
/**
- * 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
+ * GstAudioCdSrcMode:
+ * @GST_AUDIO_CD_SRC_MODE_NORMAL : each single track is a stream
+ * @GST_AUDIO_CD_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;
+ GST_AUDIO_CD_SRC_MODE_NORMAL, /* stream = one track */
+ GST_AUDIO_CD_SRC_MODE_CONTINUOUS /* stream = whole disc */
+} GstAudioCdSrcMode;
-#define GST_TYPE_CDDA_BASE_SRC_MODE (gst_cdda_base_src_mode_get_type ())
+#define GST_TYPE_AUDIO_CD_SRC_MODE (gst_audio_cd_src_mode_get_type ())
/**
- * GstCddaBaseSrcTrack:
+ * GstAudioCdSrcTrack:
* @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)
*
* CD track abstraction to communicate TOC entries to the base class.
*/
-struct _GstCddaBaseSrcTrack {
+struct _GstAudioCdSrcTrack {
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!) */
gpointer _gst_reserved2[GST_PADDING/2];
};
-struct _GstCddaBaseSrc {
+struct _GstAudioCdSrc {
GstPushSrc pushsrc;
/*< protected >*/ /* for use by sub-classes only */
GstTagList *tags; /* tags that apply to all tracks */
/*< private >*/
- GstCddaBaseSrcMode mode;
+ GstAudioCdSrcMode mode;
gchar *device;
guint num_tracks;
guint num_all_tracks;
- GstCddaBaseSrcTrack *tracks;
+ GstAudioCdSrcTrack *tracks;
gint cur_track; /* current track (starting from 0) */
gint prev_track; /* current track last time */
};
/**
- * GstCddaBaseSrcClass:
+ * GstAudioCdSrcClass:
* @pushsrc_class: the parent class
* @open: opening the device
* @close: closing the device
* @get_default_device: getting the default device
* @probe_devices: probing possible devices
*
- * Cdda source base class.
+ * Audio CD source base class.
*/
-struct _GstCddaBaseSrcClass {
+struct _GstAudioCdSrcClass {
GstPushSrcClass pushsrc_class;
/* open/close the CD device */
- gboolean (*open) (GstCddaBaseSrc *src, const gchar *device);
- void (*close) (GstCddaBaseSrc *src);
+ gboolean (*open) (GstAudioCdSrc *src, const gchar *device);
+ void (*close) (GstAudioCdSrc *src);
/* read one sector (LBA) */
- GstBuffer * (*read_sector) (GstCddaBaseSrc *src, gint sector);
+ GstBuffer * (*read_sector) (GstAudioCdSrc *src, gint sector);
/* return default device or NULL (optional) */
- gchar * (*get_default_device) (GstCddaBaseSrc *src);
+ gchar * (*get_default_device) (GstAudioCdSrc *src);
/* return NULL-terminated string array of CD devices, or NULL (optional) */
- gchar ** (*probe_devices) (GstCddaBaseSrc *src);
+ /* FIXME 0.11: reconsider for new probing/device discovery API, remove if in doubt */
+ gchar ** (*probe_devices) (GstAudioCdSrc *src);
/*< private >*/
gpointer _gst_reserved[GST_PADDING];
};
-GType gst_cdda_base_src_get_type (void);
-GType gst_cdda_base_src_mode_get_type (void);
+GType gst_audio_cd_src_get_type (void);
+GType gst_audio_cd_src_mode_get_type (void);
-gboolean gst_cdda_base_src_add_track (GstCddaBaseSrc * src,
- GstCddaBaseSrcTrack * track);
+gboolean gst_audio_cd_src_add_track (GstAudioCdSrc * src,
+ GstAudioCdSrcTrack * track);
#if 0
/*
G_END_DECLS
-#endif /* __GST_CDDA_BASE_SRC_H__ */
+#endif /* __GST_AUDIO_CD_SRC_H__ */
projects / platform / upstream / gstreamer.git / commitdiff