sys/vcd/vcdsrc.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <time.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29 #include <sys/ioctl.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <sys/types.h>
  33 #include <dirent.h>
  34 #include <errno.h>
  35 #include <linux/cdrom.h>
  36
  37 #include <vcdsrc.h>
  38
  39
  40 static GstElementDetails vcdsrc_details = {
  41   "VCD Source",
  42   "Source/File",
  43   "LGPL",
  44   "Asynchronous read from VCD disk",
  45   VERSION,
  46   "Erik Walthinsen <omega@cse.ogi.edu>",
  47   "(C) 1999",
  48 };
  49
  50
  51 /* VCDSrc signals and args */
  52 enum {
  53   /* FILL ME */
  54   LAST_SIGNAL
  55 };
  56
  57 enum {
  58   ARG_0,
  59   ARG_LOCATION,
  60   ARG_TRACK,
  61   ARG_BYTESPERREAD,
  62   ARG_OFFSET,
  63   ARG_MAX_ERRORS,
  64 };
  65
  66 static void                     vcdsrc_class_init       (VCDSrcClass *klass);
  67 static void                     vcdsrc_init             (VCDSrc *vcdsrc);
  68 static void                     vcdsrc_set_property             (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
  69 static void                     vcdsrc_get_property             (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
  70
  71 static GstBuffer *              vcdsrc_get              (GstPad *pad);
  72 /*static GstBuffer *            vcdsrc_get_region       (GstPad *pad,gulong offset,gulong size); */
  73 static GstElementStateReturn    vcdsrc_change_state     (GstElement *element);
  74
  75 static void vcdsrc_recalculate(VCDSrc *vcdsrc);
  76
  77
  78 static GstElementClass *parent_class = NULL;
  79 /*static guint vcdsrc_signals[LAST_SIGNAL] = { 0 }; */
  80
  81 GType
  82 vcdsrc_get_type (void)
  83 {
  84   static GType vcdsrc_type = 0;
  85
  86   if (!vcdsrc_type) {
  87     static const GTypeInfo vcdsrc_info = {
  88       sizeof(VCDSrcClass),      NULL,
  89       NULL,
  90       (GClassInitFunc)vcdsrc_class_init,
  91       NULL,
  92       NULL,
  93       sizeof(VCDSrc),
  94       0,
  95       (GInstanceInitFunc)vcdsrc_init,
  96     };
  97     vcdsrc_type = g_type_register_static(GST_TYPE_ELEMENT, "VCDSrc", &vcdsrc_info, 0);
  98   }
  99   return vcdsrc_type;
 100 }
 101
 102 static void
 103 vcdsrc_class_init (VCDSrcClass *klass)
 104 {
 105   GObjectClass *gobject_class;
 106   GstElementClass *gstelement_class;
 107
 108   gobject_class = (GObjectClass*)klass;
 109   gstelement_class = (GstElementClass*)klass;
 110
 111   parent_class = g_type_class_ref(GST_TYPE_ELEMENT);
 112
 113   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_LOCATION,
 114     g_param_spec_string("location","location","location",
 115                         NULL, G_PARAM_READWRITE)); /* CHECKME */
 116   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_TRACK,
 117     g_param_spec_int("track","track","track",
 118                      G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); /* CHECKME */
 119   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_BYTESPERREAD,
 120     g_param_spec_int("bytesperread","bytesperread","bytesperread",
 121                      G_MININT,G_MAXINT,0,G_PARAM_READABLE)); /* CHECKME */
 122   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_OFFSET,
 123     g_param_spec_int("offset","offset","offset",
 124                      G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); /* CHECKME */
 125   g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_MAX_ERRORS,
 126     g_param_spec_int("max-errors","","", 0,G_MAXINT,16,G_PARAM_READWRITE));
 127
 128   gobject_class->set_property = vcdsrc_set_property;
 129   gobject_class->get_property = vcdsrc_get_property;
 130
 131   gstelement_class->change_state = vcdsrc_change_state;
 132 }
 133
 134 static void
 135 vcdsrc_init (VCDSrc *vcdsrc)
 136 {
 137   vcdsrc->srcpad = gst_pad_new("src",GST_PAD_SRC);
 138   gst_pad_set_get_function (vcdsrc->srcpad, vcdsrc_get);
 139 /*  gst_pad_set_get_region_function (vcdsrc->srcpad, vcdsrc_getregion); */
 140   gst_element_add_pad(GST_ELEMENT(vcdsrc),vcdsrc->srcpad);
 141
 142   vcdsrc->device = g_strdup ("/dev/cdrom");
 143   vcdsrc->track = 2;
 144   vcdsrc->fd = 0;
 145   vcdsrc->trackoffset = 0;
 146   vcdsrc->curoffset = 0;
 147   vcdsrc->bytes_per_read = VCD_BYTES_PER_SECTOR;
 148   vcdsrc->seq = 0;
 149   vcdsrc->max_errors = 16;
 150 }
 151
 152
 153 static void
 154 vcdsrc_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 155 {
 156   VCDSrc *src;
 157
 158   /* it's not null if we got it, but it might not be ours */
 159   g_return_if_fail(GST_IS_VCDSRC(object));
 160   src = VCDSRC(object);
 161
 162   switch (prop_id) {
 163     case ARG_LOCATION:
 164       /* the element must be stopped in order to do this */
 165 /*      g_return_if_fail(!GST_FLAG_IS_SET(src,GST_STATE_RUNNING)); */
 166
 167       if (src->device) g_free(src->device);
 168       /* clear the filename if we get a NULL (is that possible?) */
 169       if (g_value_get_string (value) == NULL)
 170         src->device = NULL;
 171       /* otherwise set the new filename */
 172       else
 173         src->device = g_strdup(g_value_get_string (value));
 174       break;
 175     case ARG_TRACK:
 176       src->track = g_value_get_int (value);
 177       vcdsrc_recalculate(src);
 178       break;
 179 /*    case ARG_BYTESPERREAD:
 180       src->bytes_per_read = g_value_get_int (value);
 181       break;*/
 182     case ARG_OFFSET:
 183       src->curoffset = g_value_get_int (value) / VCD_BYTES_PER_SECTOR;
 184       break;
 185     case ARG_MAX_ERRORS:
 186       src->max_errors = g_value_get_int (value);
 187       break;
 188     default:
 189       break;
 190   }
 191
 192 }
 193
 194 static void
 195 vcdsrc_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
 196 {
 197   VCDSrc *src;
 198
 199   /* it's not null if we got it, but it might not be ours */
 200   g_return_if_fail(GST_IS_VCDSRC(object));
 201   src = VCDSRC(object);
 202
 203   switch (prop_id) {
 204     case ARG_LOCATION:
 205       g_value_set_string (value, src->device);
 206       break;
 207     case ARG_TRACK:
 208       g_value_set_int (value, src->track);
 209       break;
 210     case ARG_BYTESPERREAD:
 211       g_value_set_int (value, src->bytes_per_read);
 212       break;
 213     case ARG_OFFSET:
 214       g_value_set_int (value, src->curoffset * VCD_BYTES_PER_SECTOR);
 215       break;
 216     case ARG_MAX_ERRORS:
 217       g_value_set_int (value, src->max_errors);
 218       break;
 219     default:
 220       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 221       break;
 222   }
 223 }
 224
 225 static GstBuffer *
 226 vcdsrc_get (GstPad *pad)
 227 {
 228   VCDSrc *vcdsrc;
 229   GstBuffer *buf;
 230   gulong offset;
 231   struct cdrom_msf *msf;
 232   gint error_count = 0;
 233
 234   /* fprintf(stderr,"in vcdsrc_push\n"); */
 235
 236   g_return_val_if_fail(pad != NULL, NULL);
 237   g_return_val_if_fail(GST_IS_PAD(pad), NULL);
 238
 239   vcdsrc = VCDSRC (GST_OBJECT_PARENT (pad));
 240   g_return_val_if_fail (GST_FLAG_IS_SET (vcdsrc, VCDSRC_OPEN), NULL);
 241
 242   /* create the buffer */
 243   /* FIXME: should eventually use a bufferpool for this */
 244   buf = gst_buffer_new();
 245   g_return_val_if_fail(buf != NULL, NULL);
 246
 247   /* allocate the space for the buffer data */
 248   GST_BUFFER_DATA(buf) = g_malloc(vcdsrc->bytes_per_read);
 249   memset(GST_BUFFER_DATA(buf),0,vcdsrc->bytes_per_read);
 250   g_return_val_if_fail(GST_BUFFER_DATA(buf) != NULL, NULL);
 251
 252   msf = (struct cdrom_msf *)GST_BUFFER_DATA(buf);
 253
 254  read_sector:
 255
 256   /* read it in from the device */
 257   offset = vcdsrc->trackoffset + vcdsrc->curoffset;
 258   msf->cdmsf_frame0 = offset % 75;
 259   msf->cdmsf_sec0 = (offset / 75) % 60;
 260   msf->cdmsf_min0 = (offset / (75 * 60));
 261
 262   /*gst_info("msf is %d:%d:%d\n",msf->cdmsf_min0,msf->cdmsf_sec0, */
 263   /* msf->cdmsf_frame0); */
 264
 265   if (ioctl(vcdsrc->fd,CDROMREADRAW,msf)) {
 266     if (++error_count > vcdsrc->max_errors)
 267       {
 268         gst_element_set_eos (GST_ELEMENT (vcdsrc));
 269         return GST_BUFFER (gst_event_new (GST_EVENT_EOS));
 270       }
 271
 272     fprintf (stderr, "%s while reading raw data from cdrom at %d:%d:%d\n",
 273              strerror (errno),
 274              msf->cdmsf_min0, msf->cdmsf_sec0, msf->cdmsf_frame0);
 275     vcdsrc->curoffset += 1;
 276
 277     /* Or we can return a zero-filled buffer.  Which is better? */
 278     goto read_sector;
 279   }
 280
 281
 282   GST_BUFFER_OFFSET(buf) = vcdsrc->curoffset;
 283   GST_BUFFER_SIZE(buf) = vcdsrc->bytes_per_read;
 284   vcdsrc->curoffset += 1;
 285
 286   return buf;
 287 }
 288
 289 /* open the file, necessary to go to RUNNING state */
 290 static gboolean
 291 vcdsrc_open_file(VCDSrc *src)
 292 {
 293   int i;
 294
 295   g_return_val_if_fail(!GST_FLAG_IS_SET(src,VCDSRC_OPEN), FALSE);
 296
 297   /* open the device */
 298   src->fd = open(src->device,O_RDONLY);
 299   if (src->fd < 0) {
 300     perror("open()");
 301     gst_element_error(GST_ELEMENT(src),"opening file");
 302     return FALSE;
 303   }
 304
 305   /* read the table of contents */
 306   if (ioctl(src->fd,CDROMREADTOCHDR,&src->tochdr)) {
 307     perror("reading toc of VCD\n");
 308 /* FIXME        */
 309 /*    exit(1);  */
 310   }
 311
 312   /* allocate enough track structs for disk */
 313   src->numtracks = (src->tochdr.cdth_trk1 - src->tochdr.cdth_trk0) + 1;
 314   src->tracks = g_new (struct cdrom_tocentry, src->numtracks);
 315
 316   /* read each track entry */
 317   for (i=0;i<src->numtracks;i++) {
 318     src->tracks[i].cdte_track = i+1;
 319     src->tracks[i].cdte_format = CDROM_MSF;
 320     if (ioctl(src->fd,CDROMREADTOCENTRY, &src->tracks[i])) {
 321       perror("reading tocentry");
 322 /* FIXME        */
 323 /*      exit(1);*/
 324     }
 325     fprintf(stderr,"VCDSrc: track begins at %d:%d:%d\n",
 326       src->tracks[i].cdte_addr.msf.minute,
 327       src->tracks[i].cdte_addr.msf.second,
 328       src->tracks[i].cdte_addr.msf.frame);
 329   }
 330
 331   src->trackoffset =
 332 (((src->tracks[src->track-1].cdte_addr.msf.minute * 60) +
 333    src->tracks[src->track-1].cdte_addr.msf.second) * 75) +
 334    src->tracks[src->track-1].cdte_addr.msf.frame;
 335   fprintf(stderr,"VCDSrc: track offset is %ld\n",src->trackoffset);
 336
 337   GST_FLAG_SET(src,VCDSRC_OPEN);
 338   return TRUE;
 339 }
 340
 341 /* close the file */
 342 static void
 343 vcdsrc_close_file (VCDSrc *src)
 344 {
 345   g_return_if_fail(GST_FLAG_IS_SET(src,VCDSRC_OPEN));
 346
 347   /* close the file */
 348   close(src->fd);
 349
 350   /* zero out a lot of our state */
 351   src->fd = 0;
 352   src->curoffset = 0;
 353   src->seq = 0;
 354
 355   GST_FLAG_UNSET(src,VCDSRC_OPEN);
 356 }
 357
 358 static GstElementStateReturn
 359 vcdsrc_change_state (GstElement *element)
 360 {
 361   g_return_val_if_fail(GST_IS_VCDSRC(element), GST_STATE_FAILURE);
 362
 363   /* if going down into NULL state, close the file if it's open */
 364   if (GST_STATE_PENDING(element) == GST_STATE_NULL) {
 365     if (GST_FLAG_IS_SET(element,VCDSRC_OPEN))
 366       vcdsrc_close_file(VCDSRC(element));
 367   /* otherwise (READY or higher) we need to open the sound card */
 368   } else {
 369     if (!GST_FLAG_IS_SET(element,VCDSRC_OPEN)) {
 370       if (!vcdsrc_open_file(VCDSRC(element)))
 371         return GST_STATE_FAILURE;
 372     }
 373   }
 374
 375   if (GST_ELEMENT_CLASS(parent_class)->change_state)
 376     return GST_ELEMENT_CLASS(parent_class)->change_state(element);
 377   return GST_STATE_SUCCESS;
 378 }
 379
 380 static void
 381 vcdsrc_recalculate (VCDSrc *vcdsrc)
 382 {
 383   if (GST_FLAG_IS_SET(vcdsrc,VCDSRC_OPEN)) {
 384     /* calculate track offset (beginning of track) */
 385     vcdsrc->trackoffset =
 386 (((vcdsrc->tracks[vcdsrc->track-1].cdte_addr.msf.minute * 60) +
 387    vcdsrc->tracks[vcdsrc->track-1].cdte_addr.msf.second) * 75) +
 388    vcdsrc->tracks[vcdsrc->track-1].cdte_addr.msf.frame;
 389     fprintf(stderr,"VCDSrc: track offset is %ld\n",vcdsrc->trackoffset);
 390   }
 391 }
 392
 393 static gboolean
 394 plugin_init (GModule *module, GstPlugin *plugin)
 395 {
 396   GstElementFactory *factory;
 397
 398   /* create an elementfactory for the vcdsrc element */
 399   factory = gst_element_factory_new("vcdsrc",GST_TYPE_VCDSRC,
 400                                    &vcdsrc_details);
 401   g_return_val_if_fail(factory != NULL, FALSE);
 402   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
 403
 404   return TRUE;
 405 }
 406
 407 GstPluginDesc plugin_desc = {
 408   GST_VERSION_MAJOR,
 409   GST_VERSION_MINOR,
 410   "vcdsrc",
 411   plugin_init
 412 };