1 /* GStreamer

     2  * Copyright (C) 1999 Erik Walthinsen <omega@cse.ogi.edu>

     3  * Copyright (C) 2005 Tim-Philipp Müller <tim centricular net>

     4  *

     5  * This library is free software; you can redistribute it and/or

     6  * modify it under the terms of the GNU Library General Public

     7  * License as published by the Free Software Foundation; either

     8  * version 2 of the License, or (at your option) any later version.

     9  *

    10  * This library is distributed in the hope that it will be useful,

    11  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    13  * Library General Public License for more details.

    14  *

    15  * You should have received a copy of the GNU Library General Public

    16  * License along with this library; if not, write to the

    17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    18  * Boston, MA 02111-1307, USA.

    19  */

    20 

    21 /* TODO:

    22  *

    23  *  - in ::start(), we want to post a tags message with an array or a list

    24  *    of tagslists of all tracks, so that applications know at least the

    25  *    number of tracks and all track durations immediately without having

    26  *    to do any querying. We have to decide what type and name to use for

    27  *    this array of track taglists.

    28  *

    29  *  - FIX cddb discid calculation algorithm for mixed mode CDs - do we use

    30  *    offsets and duration of ALL tracks (data + audio) for the CDDB ID

    31  *    calculation, or only audio tracks?

    32  *

    33  *  - Do we really need properties for the TOC bias/offset stuff? Wouldn't

    34  *    environment variables make much more sense? Do we need this at all

    35  *    (does it only affect ancient hardware?)

    36  */

    37 

    38 /**

    39  * SECTION:gstcddabasesrc

    40  * @short_description: Base class for CD digital audio (CDDA) sources

    41  *

    42  * <refsect2>

    43  * <para>

    44  * Provides a base class for CDDA sources, which handles things like seeking,

    45  * querying, discid calculation, tags, and buffer timestamping.

    46  * </para>

    47  * <title>Using GstCddaBaseSrc-based elements in applications</title>

    48  * <para>

    49  * GstCddaBaseSrc registers two #GstFormat<!-- -->s of its own, namely

    50  * the "track" format and the "sector" format. Applications will usually

    51  * only find the "track" format interesting. You can retrieve that #GstFormat

    52  * for use in seek events or queries with gst_format_get_by_nick("track").

    53  * </para>

    54  * <para>

    55  * In order to query the number of tracks, for example, an application would

    56  * set the CDDA source element to READY or PAUSED state and then query the

    57  * the number of tracks via gst_element_query_duration() using the track

    58  * format acquired above. Applications can query the currently playing track

    59  * in the same way.

    60  * </para>

    61  * <para>

    62  * Alternatively, applications may retrieve the currently playing track and

    63  * the total number of tracks from the taglist that will posted on the bus

    64  * whenever the CD is opened or the currently playing track changes. The

    65  * taglist will contain GST_TAG_TRACK_NUMBER and GST_TAG_TRACK_COUNT tags.

    66  * </para>

    67  * <para>

    68  * Applications playing back CD audio using playbin and cdda://n URIs should

    69  * issue a seek command in track format to change between tracks, rather than

    70  * setting a new cdda://n+1 URI on playbin (as setting a new URI on playbin

    71  * involves closing and re-opening the CD device, which is much much slower).

    72  * </para>

    73  * <title>Tags and meta-information</title>

    74  * <para>

    75  * CDDA sources will automatically emit a number of tags, details about which

    76  * can be found in the libgsttag documentation. Those tags are:

    77  * #GST_TAG_CDDA_CDDB_DISCID, #GST_TAG_CDDA_CDDB_DISCID_FULL,

    78  * #GST_TAG_CDDA_MUSICBRAINZ_DISCID, #GST_TAG_CDDA_MUSICBRAINZ_DISCID_FULL,

    79  * among others.

    80  * </para>

    81  * </refsect2>

    82  */

    83 

    84 

    85 #ifdef HAVE_CONFIG_H

    86 #include "config.h"

    87 #endif

    88 

    89 #include <string.h>

    90 #include <stdlib.h>             /* for strtol */

    91 

    92 #include "gstcddabasesrc.h"

    93 #include "gst/gst-i18n-plugin.h"

    94 

    95 #ifdef __SYMBIAN32__

    96 #include <glib_global.h>

    97 #endif

    98 

    99 GST_DEBUG_CATEGORY_STATIC (gst_cdda_base_src_debug);

   100 #define GST_CAT_DEFAULT gst_cdda_base_src_debug

   101 

   102 #define DEFAULT_DEVICE                       "/dev/cdrom"

   103 

   104 #define CD_FRAMESIZE_RAW                     (2352)

   105 

   106 #define SECTORS_PER_SECOND                   (75)

   107 #define SECTORS_PER_MINUTE                   (75*60)

   108 #define SAMPLES_PER_SECTOR                   (CD_FRAMESIZE_RAW >> 2)

   109 #define TIME_INTERVAL_FROM_SECTORS(sectors)  ((SAMPLES_PER_SECTOR * sectors * GST_SECOND) / 44100)

   110 #define SECTORS_FROM_TIME_INTERVAL(dtime)    (dtime * 44100 / (SAMPLES_PER_SECTOR * GST_SECOND))

   111 

   112 #define GST_TYPE_CDDA_BASE_SRC_MODE          (gst_cdda_base_src_mode_get_type ())

   113 

   114 enum

   115 {

   116   ARG_0,

   117   ARG_MODE,

   118   ARG_DEVICE,

   119   ARG_TRACK,

   120   ARG_TOC_OFFSET,

   121   ARG_TOC_BIAS

   122 };

   123 

   124 static void gst_cdda_base_src_get_property (GObject * object, guint prop_id,

   125     GValue * value, GParamSpec * pspec);

   126 static void gst_cdda_base_src_set_property (GObject * object, guint prop_id,

   127     const GValue * value, GParamSpec * pspec);

   128 static void gst_cdda_base_src_finalize (GObject * obj);

   129 static const GstQueryType *gst_cdda_base_src_get_query_types (GstPad * pad);

   130 static gboolean gst_cdda_base_src_query (GstBaseSrc * src, GstQuery * query);

   131 static gboolean gst_cdda_base_src_handle_event (GstBaseSrc * basesrc,

   132     GstEvent * event);

   133 static gboolean gst_cdda_base_src_do_seek (GstBaseSrc * basesrc,

   134     GstSegment * segment);

   135 static void gst_cdda_base_src_setup_interfaces (GType type);

   136 static gboolean gst_cdda_base_src_start (GstBaseSrc * basesrc);

   137 static gboolean gst_cdda_base_src_stop (GstBaseSrc * basesrc);

   138 static GstFlowReturn gst_cdda_base_src_create (GstPushSrc * pushsrc,

   139     GstBuffer ** buf);

   140 static gboolean gst_cdda_base_src_is_seekable (GstBaseSrc * basesrc);

   141 static void gst_cdda_base_src_update_duration (GstCddaBaseSrc * src);

   142 static void gst_cdda_base_src_set_index (GstElement * src, GstIndex * index);

   143 static GstIndex *gst_cdda_base_src_get_index (GstElement * src);

   144 

   145 GST_BOILERPLATE_FULL (GstCddaBaseSrc, gst_cdda_base_src, GstPushSrc,

   146     GST_TYPE_PUSH_SRC, gst_cdda_base_src_setup_interfaces);

   147 

   148 #define SRC_CAPS \

   149   "audio/x-raw-int, "               \

   150   "endianness = (int) BYTE_ORDER, " \

   151   "signed = (boolean) true, "       \

   152   "width = (int) 16, "              \

   153   "depth = (int) 16, "              \

   154   "rate = (int) 44100, "            \

   155   "channels = (int) 2"              \

   156 

   157 static GstStaticPadTemplate gst_cdda_base_src_src_template =

   158 GST_STATIC_PAD_TEMPLATE ("src",

   159     GST_PAD_SRC,

   160     GST_PAD_ALWAYS,

   161     GST_STATIC_CAPS (SRC_CAPS)

   162     );

   163 

   164 /* our two formats */

   165 static GstFormat track_format;

   166 static GstFormat sector_format;

   167 

   168 static GType

   169 gst_cdda_base_src_mode_get_type (void)

   170 {

   171   static GType mode_type;       /* 0 */

   172   static const GEnumValue modes[] = {

   173     {GST_CDDA_BASE_SRC_MODE_NORMAL, "Stream consists of a single track",

   174         "normal"},

   175     {GST_CDDA_BASE_SRC_MODE_CONTINUOUS, "Stream consists of the whole disc",

   176         "continuous"},

   177     {0, NULL, NULL}

   178   };

   179 

   180   if (mode_type == 0)

   181     mode_type = g_enum_register_static ("GstCddaBaseSrcMode", modes);

   182 

   183   return mode_type;

   184 }

   185 

   186 static void

   187 gst_cdda_base_src_base_init (gpointer g_class)

   188 {

   189   GstElementClass *element_class = GST_ELEMENT_CLASS (g_class);

   190 

   191   gst_element_class_add_pad_template (element_class,

   192       gst_static_pad_template_get (&gst_cdda_base_src_src_template));

   193 

   194   /* our very own formats */

   195   track_format = gst_format_register ("track", "CD track");

   196   sector_format = gst_format_register ("sector", "CD sector");

   197 

   198   /* register CDDA tags */

   199   gst_tag_register_musicbrainz_tags ();

   200 

   201 #if 0

   202   ///// FIXME: what type to use here? ///////

   203   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??? ///////

   204 #endif

   205 

   206   GST_DEBUG_CATEGORY_INIT (gst_cdda_base_src_debug, "cddabasesrc", 0,

   207       "CDDA Base Source");

   208 }

   209 

   210 static void

   211 gst_cdda_base_src_class_init (GstCddaBaseSrcClass * klass)

   212 {

   213   GstElementClass *element_class;

   214   GstPushSrcClass *pushsrc_class;

   215   GstBaseSrcClass *basesrc_class;

   216   GObjectClass *gobject_class;

   217 

   218   gobject_class = (GObjectClass *) klass;

   219   element_class = (GstElementClass *) klass;

   220   basesrc_class = (GstBaseSrcClass *) klass;

   221   pushsrc_class = (GstPushSrcClass *) klass;

   222 

   223   gobject_class->set_property = gst_cdda_base_src_set_property;

   224   gobject_class->get_property = gst_cdda_base_src_get_property;

   225   gobject_class->finalize = gst_cdda_base_src_finalize;

   226 

   227   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_DEVICE,

   228       g_param_spec_string ("device", "Device", "CD device location",

   229           NULL, G_PARAM_READWRITE));

   230   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_MODE,

   231       g_param_spec_enum ("mode", "Mode", "Mode", GST_TYPE_CDDA_BASE_SRC_MODE,

   232           GST_CDDA_BASE_SRC_MODE_NORMAL, G_PARAM_READWRITE));

   233 

   234   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TRACK,

   235       g_param_spec_uint ("track", "Track", "Track", 1, 99, 1,

   236           G_PARAM_READWRITE));

   237 

   238 #if 0

   239   /* Do we really need this toc adjustment stuff as properties? does the user

   240    * have a chance to set it in practice, e.g. when using sound-juicer, rb,

   241    * totem, whatever? Shouldn't we rather use environment variables

   242    * for this? (tpm) */

   243 

   244   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TOC_OFFSET,

   245       g_param_spec_int ("toc-offset", "Table of contents offset",

   246           "Add <n> sectors to the values reported", G_MININT, G_MAXINT, 0,

   247           G_PARAM_READWRITE));

   248   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TOC_BIAS,

   249       g_param_spec_boolean ("toc-bias", "Table of contents bias",

   250           "Assume that the beginning offset of track 1 as reported in the TOC "

   251           "will be addressed as LBA 0.  Necessary for some Toshiba drives to "

   252           "get track boundaries", FALSE, G_PARAM_READWRITE));

   253 #endif

   254 

   255   element_class->set_index = GST_DEBUG_FUNCPTR (gst_cdda_base_src_set_index);

   256   element_class->get_index = GST_DEBUG_FUNCPTR (gst_cdda_base_src_get_index);

   257 

   258   basesrc_class->start = GST_DEBUG_FUNCPTR (gst_cdda_base_src_start);

   259   basesrc_class->stop = GST_DEBUG_FUNCPTR (gst_cdda_base_src_stop);

   260   basesrc_class->query = GST_DEBUG_FUNCPTR (gst_cdda_base_src_query);

   261   basesrc_class->event = GST_DEBUG_FUNCPTR (gst_cdda_base_src_handle_event);

   262   basesrc_class->do_seek = GST_DEBUG_FUNCPTR (gst_cdda_base_src_do_seek);

   263   basesrc_class->is_seekable =

   264       GST_DEBUG_FUNCPTR (gst_cdda_base_src_is_seekable);

   265 

   266   pushsrc_class->create = GST_DEBUG_FUNCPTR (gst_cdda_base_src_create);

   267 }

   268 

   269 static void

   270 gst_cdda_base_src_init (GstCddaBaseSrc * src, GstCddaBaseSrcClass * klass)

   271 {

   272   gst_pad_set_query_type_function (GST_BASE_SRC_PAD (src),

   273       GST_DEBUG_FUNCPTR (gst_cdda_base_src_get_query_types));

   274 

   275   /* we're not live and we operate in time */

   276   gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME);

   277   gst_base_src_set_live (GST_BASE_SRC (src), FALSE);

   278 

   279   src->device = NULL;

   280   src->mode = GST_CDDA_BASE_SRC_MODE_NORMAL;

   281   src->uri_track = -1;

   282 }

   283 

   284 static void

   285 gst_cdda_base_src_finalize (GObject * obj)

   286 {

   287   GstCddaBaseSrc *cddasrc = GST_CDDA_BASE_SRC (obj);

   288 

   289   g_free (cddasrc->uri);

   290   g_free (cddasrc->device);

   291 

   292   G_OBJECT_CLASS (parent_class)->finalize (obj);

   293 }

   294 

   295 static void

   296 gst_cdda_base_src_set_property (GObject * object, guint prop_id,

   297     const GValue * value, GParamSpec * pspec)

   298 {

   299   GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (object);

   300 

   301   GST_OBJECT_LOCK (src);

   302 

   303   switch (prop_id) {

   304     case ARG_MODE:{

   305       src->mode = g_value_get_enum (value);

   306       break;

   307     }

   308     case ARG_DEVICE:{

   309       const gchar *dev = g_value_get_string (value);

   310 

   311       g_free (src->device);

   312       if (dev && *dev) {

   313         src->device = g_strdup (dev);

   314       } else {

   315         src->device = NULL;

   316       }

   317       break;

   318     }

   319     case ARG_TRACK:{

   320       guint track = g_value_get_uint (value);

   321 

   322       if (src->num_tracks > 0 && track > src->num_tracks) {

   323         g_warning ("Invalid track %u", track);

   324       } else if (track > 0 && src->tracks != NULL) {

   325         src->cur_sector = src->tracks[track - 1].start;

   326         src->uri_track = track;

   327       } else {

   328         src->uri_track = track; /* seek will be done in start() */

   329       }

   330       break;

   331     }

   332     case ARG_TOC_OFFSET:{

   333       src->toc_offset = g_value_get_int (value);

   334       break;

   335     }

   336     case ARG_TOC_BIAS:{

   337       src->toc_bias = g_value_get_boolean (value);

   338       break;

   339     }

   340     default:{

   341       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

   342       break;

   343     }

   344   }

   345 

   346   GST_OBJECT_UNLOCK (src);

   347 }

   348 

   349 static void

   350 gst_cdda_base_src_get_property (GObject * object, guint prop_id,

   351     GValue * value, GParamSpec * pspec)

   352 {

   353   GstCddaBaseSrcClass *klass = GST_CDDA_BASE_SRC_GET_CLASS (object);

   354   GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (object);

   355 

   356   GST_OBJECT_LOCK (src);

   357 

   358   switch (prop_id) {

   359     case ARG_MODE:

   360       g_value_set_enum (value, src->mode);

   361       break;

   362     case ARG_DEVICE:{

   363       if (src->device == NULL && klass->get_default_device != NULL) {

   364         gchar *d = klass->get_default_device (src);

   365 

   366         if (d != NULL) {

   367           g_value_set_string (value, DEFAULT_DEVICE);

   368           g_free (d);

   369           break;

   370         }

   371       }

   372       if (src->device == NULL)

   373         g_value_set_string (value, DEFAULT_DEVICE);

   374       else

   375         g_value_set_string (value, src->device);

   376       break;

   377     }

   378     case ARG_TRACK:{

   379       if (src->num_tracks <= 0 && src->uri_track > 0) {

   380         g_value_set_uint (value, src->uri_track);

   381       } else {

   382         g_value_set_uint (value, src->cur_track + 1);

   383       }

   384       break;

   385     }

   386     case ARG_TOC_OFFSET:

   387       g_value_set_int (value, src->toc_offset);

   388       break;

   389     case ARG_TOC_BIAS:

   390       g_value_set_boolean (value, src->toc_bias);

   391       break;

   392     default:{

   393       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

   394       break;

   395     }

   396   }

   397 

   398   GST_OBJECT_UNLOCK (src);

   399 }

   400 

   401 static gint

   402 gst_cdda_base_src_get_track_from_sector (GstCddaBaseSrc * src, gint sector)

   403 {

   404   gint i;

   405 

   406   for (i = 0; i < src->num_tracks; ++i) {

   407     if (sector >= src->tracks[i].start && sector <= src->tracks[i].end)

   408       return i;

   409   }

   410   return -1;

   411 }

   412 

   413 static const GstQueryType *

   414 gst_cdda_base_src_get_query_types (GstPad * pad)

   415 {

   416   static const GstQueryType src_query_types[] = {

   417     GST_QUERY_DURATION,

   418     GST_QUERY_POSITION,

   419     GST_QUERY_CONVERT,

   420     0

   421   };

   422 

   423   return src_query_types;

   424 }

   425 

   426 static gboolean

   427 gst_cdda_base_src_convert (GstCddaBaseSrc * src, GstFormat src_format,

   428     gint64 src_val, GstFormat dest_format, gint64 * dest_val)

   429 {

   430   gboolean started;

   431 

   432   GST_LOG_OBJECT (src, "converting value %" G_GINT64_FORMAT " from %s into %s",

   433       src_val, gst_format_get_name (src_format),

   434       gst_format_get_name (dest_format));

   435 

   436   if (src_format == dest_format) {

   437     *dest_val = src_val;

   438     return TRUE;

   439   }

   440 

   441   started = GST_OBJECT_FLAG_IS_SET (GST_BASE_SRC (src), GST_BASE_SRC_STARTED);

   442 

   443   if (src_format == track_format) {

   444     if (!started)

   445       goto not_started;

   446     if (src_val < 0 || src_val >= src->num_tracks) {

   447       GST_DEBUG_OBJECT (src, "track number %d out of bounds", (gint) src_val);

   448       goto wrong_value;

   449     }

   450     src_format = GST_FORMAT_DEFAULT;

   451     src_val = src->tracks[src_val].start * SAMPLES_PER_SECTOR;

   452   } else if (src_format == sector_format) {

   453     src_format = GST_FORMAT_DEFAULT;

   454     src_val = src_val * SAMPLES_PER_SECTOR;

   455   }

   456 

   457   if (src_format == dest_format) {

   458     *dest_val = src_val;

   459     goto done;

   460   }

   461 

   462   switch (src_format) {

   463     case GST_FORMAT_BYTES:

   464       /* convert to samples (4 bytes per sample) */

   465       src_val = src_val >> 2;

   466       /* fallthrough */

   467     case GST_FORMAT_DEFAULT:{

   468       switch (dest_format) {

   469         case GST_FORMAT_BYTES:{

   470           if (src_val < 0) {

   471             GST_DEBUG_OBJECT (src, "sample source value negative");

   472             goto wrong_value;

   473           }

   474           *dest_val = src_val << 2;     /* 4 bytes per sample */

   475           break;

   476         }

   477         case GST_FORMAT_TIME:{

   478           *dest_val = gst_util_uint64_scale_int (src_val, GST_SECOND, 44100);

   479           break;

   480         }

   481         default:{

   482           gint64 sector = src_val / SAMPLES_PER_SECTOR;

   483 

   484           if (dest_format == sector_format) {

   485             *dest_val = sector;

   486           } else if (dest_format == track_format) {

   487             if (!started)

   488               goto not_started;

   489             *dest_val = gst_cdda_base_src_get_track_from_sector (src, sector);

   490           } else {

   491             goto unknown_format;

   492           }

   493           break;

   494         }

   495       }

   496       break;

   497     }

   498     case GST_FORMAT_TIME:{

   499       gint64 sample_offset;

   500 

   501       if (src_val == GST_CLOCK_TIME_NONE) {

   502         GST_DEBUG_OBJECT (src, "source time value invalid");

   503         goto wrong_value;

   504       }

   505 

   506       sample_offset = gst_util_uint64_scale_int (src_val, 44100, GST_SECOND);

   507       switch (dest_format) {

   508         case GST_FORMAT_BYTES:{

   509           *dest_val = sample_offset << 2;       /* 4 bytes per sample */

   510           break;

   511         }

   512         case GST_FORMAT_DEFAULT:{

   513           *dest_val = sample_offset;

   514           break;

   515         }

   516         default:{

   517           gint64 sector = sample_offset / SAMPLES_PER_SECTOR;

   518 

   519           if (dest_format == sector_format) {

   520             *dest_val = sector;

   521           } else if (dest_format == track_format) {

   522             if (!started)

   523               goto not_started;

   524             *dest_val = gst_cdda_base_src_get_track_from_sector (src, sector);

   525           } else {

   526             goto unknown_format;

   527           }

   528           break;

   529         }

   530       }

   531       break;

   532     }

   533     default:{

   534       goto unknown_format;

   535     }

   536   }

   537 

   538 done:

   539   {

   540     GST_LOG_OBJECT (src, "returning %" G_GINT64_FORMAT, *dest_val);

   541     return TRUE;

   542   }

   543 

   544 unknown_format:

   545   {

   546     GST_DEBUG_OBJECT (src, "conversion failed: %s", "unsupported format");

   547     return FALSE;

   548   }

   549 

   550 wrong_value:

   551   {

   552     GST_DEBUG_OBJECT (src, "conversion failed: %s",

   553         "source value not within allowed range");

   554     return FALSE;

   555   }

   556 

   557 not_started:

   558   {

   559     GST_DEBUG_OBJECT (src, "conversion failed: %s",

   560         "cannot do this conversion, device not open");

   561     return FALSE;

   562   }

   563 }

   564 

   565 static gboolean

   566 gst_cdda_base_src_query (GstBaseSrc * basesrc, GstQuery * query)

   567 {

   568   GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (basesrc);

   569   gboolean started;

   570 

   571   started = GST_OBJECT_FLAG_IS_SET (basesrc, GST_BASE_SRC_STARTED);

   572 

   573   GST_LOG_OBJECT (src, "handling %s query",

   574       gst_query_type_get_name (GST_QUERY_TYPE (query)));

   575 

   576   switch (GST_QUERY_TYPE (query)) {

   577     case GST_QUERY_DURATION:{

   578       GstFormat dest_format;

   579       gint64 dest_val;

   580       guint sectors;

   581 

   582       gst_query_parse_duration (query, &dest_format, NULL);

   583 

   584       if (!started)

   585         return FALSE;

   586 

   587       g_assert (src->tracks != NULL);

   588 

   589       if (dest_format == track_format) {

   590         GST_LOG_OBJECT (src, "duration: %d tracks", src->num_tracks);

   591         gst_query_set_duration (query, track_format, src->num_tracks);

   592         return TRUE;

   593       }

   594 

   595       if (src->cur_track < 0 || src->cur_track >= src->num_tracks)

   596         return FALSE;

   597 

   598       if (src->mode == GST_CDDA_BASE_SRC_MODE_NORMAL) {

   599         sectors = src->tracks[src->cur_track].end -

   600             src->tracks[src->cur_track].start + 1;

   601       } else {

   602         sectors = src->tracks[src->num_tracks - 1].end -

   603             src->tracks[0].start + 1;

   604       }

   605 

   606       /* ... and convert into final format */

   607       if (!gst_cdda_base_src_convert (src, sector_format, sectors,

   608               dest_format, &dest_val)) {

   609         return FALSE;

   610       }

   611 

   612       gst_query_set_duration (query, dest_format, dest_val);

   613 

   614       GST_LOG ("duration: %u sectors, %" G_GINT64_FORMAT " in format %s",

   615           sectors, dest_val, gst_format_get_name (dest_format));

   616       break;

   617     }

   618     case GST_QUERY_POSITION:{

   619       GstFormat dest_format;

   620       gint64 pos_sector;

   621       gint64 dest_val;

   622 

   623       gst_query_parse_position (query, &dest_format, NULL);

   624 

   625       if (!started)

   626         return FALSE;

   627 

   628       g_assert (src->tracks != NULL);

   629 

   630       if (dest_format == track_format) {

   631         GST_LOG_OBJECT (src, "position: track %d", src->cur_track);

   632         gst_query_set_position (query, track_format, src->cur_track);

   633         return TRUE;

   634       }

   635 

   636       if (src->cur_track < 0 || src->cur_track >= src->num_tracks)

   637         return FALSE;

   638 

   639       if (src->mode == GST_CDDA_BASE_SRC_MODE_NORMAL) {

   640         pos_sector = src->cur_sector - src->tracks[src->cur_track].start;

   641       } else {

   642         pos_sector = src->cur_sector - src->tracks[0].start;

   643       }

   644 

   645       if (!gst_cdda_base_src_convert (src, sector_format, pos_sector,

   646               dest_format, &dest_val)) {

   647         return FALSE;

   648       }

   649 

   650       gst_query_set_position (query, dest_format, dest_val);

   651 

   652       GST_LOG ("position: sector %u, %" G_GINT64_FORMAT " in format %s",

   653           (guint) pos_sector, dest_val, gst_format_get_name (dest_format));

   654       break;

   655     }

   656     case GST_QUERY_CONVERT:{

   657       GstFormat src_format, dest_format;

   658       gint64 src_val, dest_val;

   659 

   660       gst_query_parse_convert (query, &src_format, &src_val, &dest_format,

   661           NULL);

   662 

   663       if (!gst_cdda_base_src_convert (src, src_format, src_val, dest_format,

   664               &dest_val)) {

   665         return FALSE;

   666       }

   667 

   668       gst_query_set_convert (query, src_format, src_val, dest_format, dest_val);

   669       break;

   670     }

   671     default:{

   672       GST_DEBUG_OBJECT (src, "unhandled query, chaining up to parent class");

   673       return GST_BASE_SRC_CLASS (parent_class)->query (basesrc, query);

   674     }

   675   }

   676 

   677   return TRUE;

   678 }

   679 

   680 static gboolean

   681 gst_cdda_base_src_is_seekable (GstBaseSrc * basesrc)

   682 {

   683   return TRUE;

   684 }

   685 

   686 static gboolean

   687 gst_cdda_base_src_do_seek (GstBaseSrc * basesrc, GstSegment * segment)

   688 {

   689   GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (basesrc);

   690   gint64 seek_sector;

   691 

   692   GST_DEBUG_OBJECT (src, "segment %" GST_TIME_FORMAT "-%" GST_TIME_FORMAT,

   693       GST_TIME_ARGS (segment->start), GST_TIME_ARGS (segment->stop));

   694 

   695   if (!gst_cdda_base_src_convert (src, GST_FORMAT_TIME, segment->start,

   696           sector_format, &seek_sector)) {

   697     GST_WARNING_OBJECT (src, "conversion failed");

   698     return FALSE;

   699   }

   700 

   701   /* we should only really be called when open */

   702   g_assert (src->cur_track >= 0 && src->cur_track < src->num_tracks);

   703 

   704   switch (src->mode) {

   705     case GST_CDDA_BASE_SRC_MODE_NORMAL:

   706       seek_sector += src->tracks[src->cur_track].start;

   707       break;

   708     case GST_CDDA_BASE_SRC_MODE_CONTINUOUS:

   709       seek_sector += src->tracks[0].start;

   710       break;

   711     default:

   712       g_return_val_if_reached (FALSE);

   713   }

   714 

   715   src->cur_sector = (gint) seek_sector;

   716 

   717   GST_DEBUG_OBJECT (src, "seek'd to sector %d", src->cur_sector);

   718 

   719   return TRUE;

   720 }

   721 

   722 static gboolean

   723 gst_cdda_base_src_handle_track_seek (GstCddaBaseSrc * src, gdouble rate,

   724     GstSeekFlags flags, GstSeekType start_type, gint64 start,

   725     GstSeekType stop_type, gint64 stop)

   726 {

   727   GstBaseSrc *basesrc = GST_BASE_SRC (src);

   728   GstEvent *event;

   729 

   730   if ((flags & GST_SEEK_FLAG_SEGMENT) == GST_SEEK_FLAG_SEGMENT) {

   731     gint64 start_time = -1;

   732     gint64 stop_time = -1;

   733 

   734     if (src->mode != GST_CDDA_BASE_SRC_MODE_CONTINUOUS) {

   735       GST_DEBUG_OBJECT (src, "segment seek in track format is only "

   736           "supported in CONTINUOUS mode, not in mode %d", src->mode);

   737       return FALSE;

   738     }

   739 

   740     switch (start_type) {

   741       case GST_SEEK_TYPE_SET:

   742         if (!gst_cdda_base_src_convert (src, track_format, start,

   743                 GST_FORMAT_TIME, &start_time)) {

   744           GST_DEBUG_OBJECT (src, "cannot convert track %d to time",

   745               (gint) start);

   746           return FALSE;

   747         }

   748         break;

   749       case GST_SEEK_TYPE_END:

   750         if (!gst_cdda_base_src_convert (src, track_format,

   751                 src->num_tracks - start - 1, GST_FORMAT_TIME, &start_time)) {

   752           GST_DEBUG_OBJECT (src, "cannot convert track %d to time",

   753               (gint) start);

   754           return FALSE;

   755         }

   756         start_type = GST_SEEK_TYPE_SET;

   757         break;

   758       case GST_SEEK_TYPE_NONE:

   759         start_time = -1;

   760         break;

   761       default:

   762         g_return_val_if_reached (FALSE);

   763     }

   764 

   765     switch (stop_type) {

   766       case GST_SEEK_TYPE_SET:

   767         if (!gst_cdda_base_src_convert (src, track_format, stop,

   768                 GST_FORMAT_TIME, &stop_time)) {

   769           GST_DEBUG_OBJECT (src, "cannot convert track %d to time",

   770               (gint) stop);

   771           return FALSE;

   772         }

   773         break;

   774       case GST_SEEK_TYPE_END:

   775         if (!gst_cdda_base_src_convert (src, track_format,

   776                 src->num_tracks - stop - 1, GST_FORMAT_TIME, &stop_time)) {

   777           GST_DEBUG_OBJECT (src, "cannot convert track %d to time",

   778               (gint) stop);

   779           return FALSE;

   780         }

   781         stop_type = GST_SEEK_TYPE_SET;

   782         break;

   783       case GST_SEEK_TYPE_NONE:

   784         stop_time = -1;

   785         break;

   786       default:

   787         g_return_val_if_reached (FALSE);

   788     }

   789 

   790     GST_LOG_OBJECT (src, "seek segment %" GST_TIME_FORMAT "-%" GST_TIME_FORMAT,

   791         GST_TIME_ARGS (start_time), GST_TIME_ARGS (stop_time));

   792 

   793     /* send fake segment seek event in TIME format to

   794      * base class, which will hopefully handle the rest */

   795 

   796     event = gst_event_new_seek (rate, GST_FORMAT_TIME, flags, start_type,

   797         start_time, stop_type, stop_time);

   798 

   799     return GST_BASE_SRC_CLASS (parent_class)->event (basesrc, event);

   800   }

   801 

   802   /* not a segment seek */

   803 

   804   if (start_type == GST_SEEK_TYPE_NONE) {

   805     GST_LOG_OBJECT (src, "start seek type is NONE, nothing to do");

   806     return TRUE;

   807   }

   808 

   809   if (stop_type != GST_SEEK_TYPE_NONE) {

   810     GST_WARNING_OBJECT (src, "ignoring stop seek type (expected NONE)");

   811   }

   812 

   813   if (start < 0 || start >= src->num_tracks) {

   814     GST_DEBUG_OBJECT (src, "invalid track %" G_GINT64_FORMAT, start);

   815     return FALSE;

   816   }

   817 

   818   GST_DEBUG_OBJECT (src, "seeking to track %" G_GINT64_FORMAT, start + 1);

   819 

   820   src->cur_sector = src->tracks[start].start;

   821   GST_DEBUG_OBJECT (src, "starting at sector %d", src->cur_sector);

   822 

   823   if (src->cur_track != start) {

   824     src->cur_track = (gint) start;

   825     src->uri_track = -1;

   826     src->prev_track = -1;

   827 

   828     gst_cdda_base_src_update_duration (src);

   829   } else {

   830     GST_DEBUG_OBJECT (src, "is current track, just seeking back to start");

   831   }

   832 

   833   /* send fake segment seek event in TIME format to

   834    * base class (so we get a newsegment etc.) */

   835   event = gst_event_new_seek (rate, GST_FORMAT_TIME, flags,

   836       GST_SEEK_TYPE_SET, 0, GST_SEEK_TYPE_NONE, -1);

   837 

   838   return GST_BASE_SRC_CLASS (parent_class)->event (basesrc, event);

   839 }

   840 

   841 static gboolean

   842 gst_cdda_base_src_handle_event (GstBaseSrc * basesrc, GstEvent * event)

   843 {

   844   GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (basesrc);

   845   gboolean ret = FALSE;

   846 

   847   GST_LOG_OBJECT (src, "handling %s event", GST_EVENT_TYPE_NAME (event));

   848 

   849   switch (GST_EVENT_TYPE (event)) {

   850     case GST_EVENT_SEEK:{

   851       GstSeekType start_type, stop_type;

   852       GstSeekFlags flags;

   853       GstFormat format;

   854       gdouble rate;

   855       gint64 start, stop;

   856 

   857       if (!GST_OBJECT_FLAG_IS_SET (basesrc, GST_BASE_SRC_STARTED)) {

   858         GST_DEBUG_OBJECT (src, "seek failed: device not open");

   859         break;

   860       }

   861 

   862       gst_event_parse_seek (event, &rate, &format, &flags, &start_type, &start,

   863           &stop_type, &stop);

   864 

   865       if (format == sector_format) {

   866         GST_DEBUG_OBJECT (src, "seek in sector format not supported");

   867         break;

   868       }

   869 

   870       if (format == track_format) {

   871         ret = gst_cdda_base_src_handle_track_seek (src, rate, flags,

   872             start_type, start, stop_type, stop);

   873       } else {

   874         GST_LOG_OBJECT (src, "let base class handle seek in %s format",

   875             gst_format_get_name (format));

   876         event = gst_event_ref (event);

   877         ret = GST_BASE_SRC_CLASS (parent_class)->event (basesrc, event);

   878       }

   879       break;

   880     }

   881     default:{

   882       GST_LOG_OBJECT (src, "let base class handle event");

   883       event = gst_event_ref (event);

   884       ret = GST_BASE_SRC_CLASS (parent_class)->event (basesrc, event);

   885       break;

   886     }

   887   }

   888 

   889   return ret;

   890 }

   891 

   892 static GstURIType

   893 gst_cdda_base_src_uri_get_type (void)

   894 {

   895   return GST_URI_SRC;

   896 }

   897 

   898 static gchar **

   899 gst_cdda_base_src_uri_get_protocols (void)

   900 {

   901   static gchar *protocols[] = { "cdda", NULL };

   902 

   903   return protocols;

   904 }

   905 

   906 static const gchar *

   907 gst_cdda_base_src_uri_get_uri (GstURIHandler * handler)

   908 {

   909   GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (handler);

   910 

   911   GST_OBJECT_LOCK (src);

   912 

   913   g_free (src->uri);

   914 

   915   if (GST_OBJECT_FLAG_IS_SET (GST_BASE_SRC (src), GST_BASE_SRC_STARTED)) {

   916     src->uri = g_strdup_printf ("cdda://%d", src->uri_track);

   917   } else {

   918     src->uri = g_strdup ("cdda://1");

   919   }

   920 

   921   GST_OBJECT_UNLOCK (src);

   922 

   923   return src->uri;

   924 }

   925 

   926 /* Note: gst_element_make_from_uri() might call us with just 'cdda://' as

   927  * URI and expects us to return TRUE then (and this might be in any state) */

   928 

   929 static gboolean

   930 gst_cdda_base_src_uri_set_uri (GstURIHandler * handler, const gchar * uri)

   931 {

   932   GstCddaBaseSrc *src = GST_CDDA_BASE_SRC (handler);

   933   gchar *protocol, *location;

   934 

   935   GST_OBJECT_LOCK (src);

   936 

   937   protocol = gst_uri_get_protocol (uri);

   938   if (!protocol || strcmp (protocol, "cdda") != 0) {

   939     g_free (protocol);

   940     goto failed;

   941   }

   942   g_free (protocol);

   943 

   944   location = gst_uri_get_location (uri);

   945   if (location == NULL || *location == '\0') {

   946     g_free (location);

   947     location = g_strdup ("1");

   948   }

   949 

   950   src->uri_track = strtol (location, NULL, 10);

   951   g_free (location);

   952 

   953   if (src->uri_track == 0)

   954     goto failed;

   955 

   956   if (src->num_tracks > 0

   957       && src->tracks != NULL && src->uri_track > src->num_tracks)

   958     goto failed;

   959 

   960   if (src->uri_track > 0 && src->tracks != NULL) {

   961     GST_OBJECT_UNLOCK (src);

   962 

   963     gst_pad_send_event (GST_BASE_SRC_PAD (src),

   964         gst_event_new_seek (1.0, track_format, GST_SEEK_FLAG_FLUSH,

   965             GST_SEEK_TYPE_SET, src->uri_track - 1, GST_SEEK_TYPE_NONE, -1));

   966   } else {

   967     /* seek will be done in start() */

   968     GST_OBJECT_UNLOCK (src);

   969   }

   970 

   971   GST_LOG_OBJECT (handler, "successfully handled uri '%s'", uri);

   972 

   973   return TRUE;

   974 

   975 failed:

   976   {

   977     GST_OBJECT_UNLOCK (src);

   978     GST_DEBUG_OBJECT (src, "cannot handle URI '%s'", uri);

   979     return FALSE;

   980   }

   981 }

   982 

   983 static void

   984 gst_cdda_base_src_uri_handler_init (gpointer g_iface, gpointer iface_data)

   985 {

   986   GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;

   987 

   988   iface->get_type = gst_cdda_base_src_uri_get_type;

   989   iface->get_uri = gst_cdda_base_src_uri_get_uri;

   990   iface->set_uri = gst_cdda_base_src_uri_set_uri;

   991   iface->get_protocols = gst_cdda_base_src_uri_get_protocols;

   992 }

   993 

   994 static void

   995 gst_cdda_base_src_setup_interfaces (GType type)

   996 {

   997   static const GInterfaceInfo urihandler_info = {

   998     gst_cdda_base_src_uri_handler_init,

   999     NULL,

  1000     NULL,

  1001   };

  1002 

  1003   g_type_add_interface_static (type, GST_TYPE_URI_HANDLER, &urihandler_info);

  1004 }

  1005 

  1006 /**

  1007  * gst_cdda_base_src_add_track:

  1008  * @src: a #GstCddaBaseSrc

  1009  * @track: address of #GstCddaBaseSrcTrack to add

  1010  * 

  1011  * CDDA sources use this function from their start vfunc to announce the

  1012  * available data and audio tracks to the base source class. The caller

  1013  * should allocate @track on the stack, the base source will do a shallow

  1014  * copy of the structure (and take ownership of the taglist if there is one).

  1015  *

  1016  * Returns: FALSE on error, otherwise TRUE.

  1017  */

  1018 #ifdef __SYMBIAN32__

  1019 EXPORT_C

  1020 #endif

  1021 

  1022 

  1023 gboolean

  1024 gst_cdda_base_src_add_track (GstCddaBaseSrc * src, GstCddaBaseSrcTrack * track)

  1025 {

  1026   g_return_val_if_fail (GST_IS_CDDA_BASE_SRC (src), FALSE);

  1027   g_return_val_if_fail (track != NULL, FALSE);

  1028   g_return_val_if_fail (track->num > 0, FALSE);

  1029 

  1030   GST_DEBUG_OBJECT (src, "adding track %2u (%2u) [%6u-%6u] [%5s], tags: %"

  1031       GST_PTR_FORMAT, src->num_tracks + 1, track->num, track->start,

  1032       track->end, (track->is_audio) ? "AUDIO" : "DATA ", track->tags);

  1033 

  1034   if (src->num_tracks > 0) {

  1035     guint end_of_previous_track = src->tracks[src->num_tracks - 1].end;

  1036 

  1037     if (track->start < end_of_previous_track) {

  1038       GST_WARNING ("track %2u overlaps with previous tracks", track->num);

  1039       return FALSE;

  1040     }

  1041   }

  1042 

  1043   GST_OBJECT_LOCK (src);

  1044 

  1045   ++src->num_tracks;

  1046   src->tracks = g_renew (GstCddaBaseSrcTrack, src->tracks, src->num_tracks);

  1047   src->tracks[src->num_tracks - 1] = *track;

  1048 

  1049   GST_OBJECT_UNLOCK (src);

  1050 

  1051   return TRUE;

  1052 }

  1053 

  1054 static void

  1055 gst_cdda_base_src_update_duration (GstCddaBaseSrc * src)

  1056 {

  1057   GstBaseSrc *basesrc;

  1058   GstFormat format;

  1059   gint64 duration;

  1060 

  1061   basesrc = GST_BASE_SRC (src);

  1062 

  1063   format = GST_FORMAT_TIME;

  1064   if (gst_pad_query_duration (GST_BASE_SRC_PAD (src), &format, &duration)) {

  1065     gst_segment_set_duration (&basesrc->segment, GST_FORMAT_TIME, duration);

  1066   } else {

  1067     gst_segment_set_duration (&basesrc->segment, GST_FORMAT_TIME, -1);

  1068     duration = GST_CLOCK_TIME_NONE;

  1069   }

  1070 

  1071   gst_element_post_message (GST_ELEMENT (src),

  1072       gst_message_new_duration (GST_OBJECT (src), GST_FORMAT_TIME, -1));

  1073 

  1074   GST_LOG_OBJECT (src, "duration updated to %" GST_TIME_FORMAT,

  1075       GST_TIME_ARGS (duration));

  1076 }

  1077 

  1078 #define CD_MSF_OFFSET 150

  1079 

  1080 /* the cddb hash function */

  1081 static guint

  1082 cddb_sum (gint n)

  1083 {

  1084   guint ret;

  1085 

  1086   ret = 0;

  1087   while (n > 0) {

  1088     ret += (n % 10);

  1089     n /= 10;

  1090   }

  1091   return ret;

  1092 }

  1093 

  1094 #include "base64.h"

  1095 #include "sha1.h"

  1096 

  1097 static void

  1098 gst_cddabasesrc_calculate_musicbrainz_discid (GstCddaBaseSrc * src)

  1099 {

  1100   GString *s;

  1101   SHA_INFO sha;

  1102   guchar digest[20], *ptr;

  1103   gchar tmp[9];

  1104   gulong i;

  1105   guint leadout_sector;

  1106 

  1107   s = g_string_new (NULL);

  1108 

  1109   leadout_sector = src->tracks[src->num_tracks - 1].end + 1 + CD_MSF_OFFSET;

  1110 

  1111   /* generate SHA digest */

  1112   sha_init (&sha);

  1113   g_snprintf (tmp, sizeof (tmp), "%02X", src->tracks[0].num);

  1114   g_string_append_printf (s, "%02X", src->tracks[0].num);

  1115   sha_update (&sha, (SHA_BYTE *) tmp, 2);

  1116 

  1117   g_snprintf (tmp, sizeof (tmp), "%02X", src->tracks[src->num_tracks - 1].num);

  1118   g_string_append_printf (s, " %02X", src->tracks[src->num_tracks - 1].num);

  1119   sha_update (&sha, (SHA_BYTE *) tmp, 2);

  1120 

  1121   g_snprintf (tmp, sizeof (tmp), "%08X", leadout_sector);

  1122   g_string_append_printf (s, " %08X", leadout_sector);

  1123   sha_update (&sha, (SHA_BYTE *) tmp, 8);

  1124 

  1125   for (i = 0; i < 99; i++) {

  1126     if (i < src->num_tracks) {

  1127       guint frame_offset = src->tracks[i].start + CD_MSF_OFFSET;

  1128 

  1129       g_snprintf (tmp, sizeof (tmp), "%08X", frame_offset);

  1130       g_string_append_printf (s, " %08X", frame_offset);

  1131       sha_update (&sha, (SHA_BYTE *) tmp, 8);

  1132     } else {

  1133       sha_update (&sha, (SHA_BYTE *) "00000000", 8);

  1134     }