gst/avi/gstcdxaparse.c

   1 /* GStreamer
   2  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
   3  *               <2002> Wim Taymans <wim.taymans@chello.be>
   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
  22 #include <string.h>
  23
  24 #include "gstcdxaparse.h"
  25
  26 #define MAKE_FOUR_CC(a,b,c,d) ( ((guint32)a)     | (((guint32)b)<< 8) | \
  27                                 ((guint32)c)<<16 | (((guint32)d)<<24) )
  28
  29
  30 /* RIFF types */
  31 #define GST_RIFF_TAG_RIFF  MAKE_FOUR_CC('R','I','F','F')
  32 #define GST_RIFF_RIFF_CDXA MAKE_FOUR_CC('C','D','X','A')
  33
  34
  35 #define GST_RIFF_TAG_fmt  MAKE_FOUR_CC('f','m','t',' ')
  36 #define GST_RIFF_TAG_data MAKE_FOUR_CC('d','a','t','a')
  37
  38
  39 /* elementfactory information */
  40 static GstElementDetails gst_cdxa_parse_details = {
  41   ".dat parser",
  42   "Parser/Video",
  43   "Parse a .dat file (VCD) into raw mpeg1",
  44   VERSION,
  45   "Wim Taymans <wim.taymans@tvd.be>",
  46   "(C) 2002",
  47 };
  48
  49 static GstCaps* cdxa_typefind (GstBuffer *buf, gpointer private);
  50
  51 /* typefactory for 'cdxa' */
  52 static GstTypeDefinition cdxadefinition = {
  53   "cdxaparse_video/avi",
  54   "video/avi",
  55   ".dat",
  56   cdxa_typefind,
  57 };
  58
  59 /* CDXAParse signals and args */
  60 enum {
  61   /* FILL ME */
  62   LAST_SIGNAL
  63 };
  64
  65 enum {
  66   ARG_0,
  67   ARG_BITRATE,
  68   ARG_MEDIA_TIME,
  69   ARG_CURRENT_TIME,
  70   /* FILL ME */
  71 };
  72
  73 GST_PADTEMPLATE_FACTORY (sink_templ,
  74   "sink",
  75   GST_PAD_SINK,
  76   GST_PAD_ALWAYS,
  77   GST_CAPS_NEW (
  78     "cdxaparse_sink",
  79      "video/avi",
  80       "RIFF", GST_PROPS_STRING ("CDXA")
  81   )
  82 )
  83
  84 GST_PADTEMPLATE_FACTORY (src_templ,
  85   "src",
  86   GST_PAD_SRC,
  87   GST_PAD_ALWAYS,
  88   GST_CAPS_NEW (
  89     "cdxaparse_src",
  90     "video/mpeg",
  91       "mpegversion",   GST_PROPS_INT (1),
  92       "systemstream",  GST_PROPS_BOOLEAN (TRUE)
  93   )
  94 )
  95
  96 static void     gst_cdxa_parse_class_init       (GstCDXAParseClass *klass);
  97 static void     gst_cdxa_parse_init             (GstCDXAParse *cdxa_parse);
  98
  99 static void     gst_cdxa_parse_loop             (GstElement *element);
 100
 101 static GstElementStateReturn
 102                 gst_cdxa_parse_change_state     (GstElement *element);
 103
 104
 105 static GstElementClass *parent_class = NULL;
 106 //static guint gst_cdxa_parse_signals[LAST_SIGNAL] = { 0 };
 107
 108 GType
 109 gst_cdxa_parse_get_type(void)
 110 {
 111   static GType cdxa_parse_type = 0;
 112
 113   if (!cdxa_parse_type) {
 114     static const GTypeInfo cdxa_parse_info = {
 115       sizeof(GstCDXAParseClass),
 116       NULL,
 117       NULL,
 118       (GClassInitFunc)gst_cdxa_parse_class_init,
 119       NULL,
 120       NULL,
 121       sizeof(GstCDXAParse),
 122       0,
 123       (GInstanceInitFunc)gst_cdxa_parse_init,
 124     };
 125     cdxa_parse_type = g_type_register_static(GST_TYPE_ELEMENT, "GstCDXAParse", &cdxa_parse_info, 0);
 126   }
 127   return cdxa_parse_type;
 128 }
 129
 130 static void
 131 gst_cdxa_parse_class_init (GstCDXAParseClass *klass)
 132 {
 133   GObjectClass *gobject_class;
 134   GstElementClass *gstelement_class;
 135
 136   gobject_class = (GObjectClass*)klass;
 137   gstelement_class = (GstElementClass*)klass;
 138
 139   g_object_class_install_property (G_OBJECT_CLASS(klass), ARG_BITRATE,
 140     g_param_spec_long ("bitrate","bitrate","bitrate",
 141                        G_MINLONG, G_MAXLONG, 0, G_PARAM_READABLE)); // CHECKME
 142   g_object_class_install_property (G_OBJECT_CLASS(klass), ARG_MEDIA_TIME,
 143     g_param_spec_long ("media_time","media_time","media_time",
 144                        G_MINLONG, G_MAXLONG, 0, G_PARAM_READABLE)); // CHECKME
 145   g_object_class_install_property (G_OBJECT_CLASS(klass), ARG_CURRENT_TIME,
 146     g_param_spec_long ("current_time","current_time","current_time",
 147                        G_MINLONG, G_MAXLONG, 0, G_PARAM_READABLE)); // CHECKME
 148
 149   parent_class = g_type_class_ref (GST_TYPE_ELEMENT);
 150
 151   gstelement_class->change_state = gst_cdxa_parse_change_state;
 152 }
 153
 154 static void
 155 gst_cdxa_parse_init (GstCDXAParse *cdxa_parse)
 156 {
 157   guint i;
 158
 159   GST_FLAG_SET (cdxa_parse, GST_ELEMENT_EVENT_AWARE);
 160
 161   cdxa_parse->sinkpad = gst_pad_new_from_template (
 162                   GST_PADTEMPLATE_GET (sink_templ), "sink");
 163   gst_element_add_pad (GST_ELEMENT (cdxa_parse), cdxa_parse->sinkpad);
 164
 165   cdxa_parse->srcpad = gst_pad_new_from_template (
 166                   GST_PADTEMPLATE_GET (src_templ), "src");
 167   gst_element_add_pad (GST_ELEMENT (cdxa_parse), cdxa_parse->srcpad);
 168
 169   gst_element_set_loop_function (GST_ELEMENT (cdxa_parse), gst_cdxa_parse_loop);
 170
 171 }
 172
 173 static GstCaps*
 174 cdxa_typefind (GstBuffer *buf,
 175               gpointer private)
 176 {
 177   gchar *data = GST_BUFFER_DATA (buf);
 178   GstCaps *new;
 179
 180   GST_DEBUG (0,"cdxa_parse: typefind\n");
 181
 182   if (GUINT32_FROM_LE (((guint32 *)data)[0]) != GST_RIFF_TAG_RIFF)
 183     return NULL;
 184   if (GUINT32_FROM_LE (((guint32 *)data)[2]) != GST_RIFF_RIFF_CDXA)
 185     return NULL;
 186
 187   new = GST_CAPS_NEW ("cdxa_typefind",
 188                       "video/avi",
 189                         "RIFF", GST_PROPS_STRING ("CDXA"));
 190
 191   return new;
 192 }
 193
 194 static gboolean
 195 gst_cdxa_parse_handle_event (GstCDXAParse *cdxa_parse)
 196 {
 197   guint32 remaining;
 198   GstEvent *event;
 199   GstEventType type;
 200
 201   gst_bytestream_get_status (cdxa_parse->bs, &remaining, &event);
 202
 203   type = event? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;
 204
 205   switch (type) {
 206     case GST_EVENT_EOS:
 207       gst_pad_event_default (cdxa_parse->sinkpad, event);
 208       break;
 209     case GST_EVENT_SEEK:
 210       g_warning ("seek event\n");
 211       break;
 212     case GST_EVENT_FLUSH:
 213       g_warning ("flush event\n");
 214       break;
 215     case GST_EVENT_DISCONTINUOUS:
 216       g_warning ("discont event\n");
 217       break;
 218     default:
 219       g_warning ("unhandled event %d\n", type);
 220       break;
 221   }
 222
 223   return TRUE;
 224 }
 225
 226 /*
 227
 228 CDXA starts with the following header:
 229
 230 ! RIFF:4 ! size:4 ! "CDXA" ! "fmt " ! size:4 ! (size+1)&~1 bytes of crap !
 231 ! "data" ! data_size:4 ! (data_size/2352) sectors...
 232
 233 */
 234
 235 typedef struct
 236 {
 237   gchar   RIFF_tag[4];
 238   guint32 riff_size;
 239   gchar   CDXA_tag[4];
 240   gchar   fmt_tag[4];
 241   guint32 fmt_size;
 242 } CDXAParseHeader;
 243
 244 /*
 245 A sectors is 2352 bytes long and is composed of:
 246
 247 !  sync    !  header ! subheader ! data ...   ! edc     !
 248 ! 12 bytes ! 4 bytes ! 8 bytes   ! 2324 bytes ! 4 bytes !
 249 !-------------------------------------------------------!
 250
 251 We parse the data out of it and send it to the srcpad.
 252 */
 253
 254 static void
 255 gst_cdxa_parse_loop (GstElement *element)
 256 {
 257   GstCDXAParse *cdxa_parse;
 258   CDXAParseHeader *header;
 259
 260   g_return_if_fail (element != NULL);
 261   g_return_if_fail (GST_IS_CDXA_PARSE (element));
 262
 263   cdxa_parse = GST_CDXA_PARSE (element);
 264
 265   if (cdxa_parse->state == CDXA_PARSE_HEADER) {
 266     guint32 fmt_size;
 267     guint8 *buf;
 268
 269     header = (CDXAParseHeader *) gst_bytestream_peek_bytes (cdxa_parse->bs, 20);
 270     if (!header)
 271       return;
 272
 273     cdxa_parse->riff_size = GUINT32_FROM_LE (header->riff_size);
 274     fmt_size = (GUINT32_FROM_LE (header->fmt_size) + 1)&~1;
 275
 276     /* flush the header + fmt_size bytes + 4 bytes "data" */
 277     if (!gst_bytestream_flush (cdxa_parse->bs, 20 + fmt_size + 4))
 278       return;
 279
 280     /* get the data size */
 281     buf = gst_bytestream_peek_bytes (cdxa_parse->bs, 4);
 282     if (!buf)
 283       return;
 284     cdxa_parse->data_size = GUINT32_FROM_LE (*((guint32 *)buf));
 285
 286     /* flush the data size */
 287     if (!gst_bytestream_flush (cdxa_parse->bs, 4))
 288       return;
 289
 290     if (cdxa_parse->data_size % CDXA_SECTOR_SIZE)
 291       g_warning ("cdxa_parse: size not multiple of %d bytes", CDXA_SECTOR_SIZE);
 292
 293     cdxa_parse->sectors = cdxa_parse->data_size / CDXA_SECTOR_SIZE;
 294
 295     cdxa_parse->state = CDXA_PARSE_DATA;
 296   }
 297   else {
 298     GstBuffer *buf;
 299     GstBuffer *outbuf;
 300
 301     buf = gst_bytestream_read (cdxa_parse->bs, CDXA_SECTOR_SIZE);
 302     if (!buf) {
 303       gst_cdxa_parse_handle_event (cdxa_parse);
 304       return;
 305     }
 306
 307     outbuf = gst_buffer_create_sub (buf, 24, CDXA_DATA_SIZE);
 308     gst_buffer_unref (buf);
 309
 310     gst_pad_push (cdxa_parse->srcpad, outbuf);
 311   }
 312 }
 313
 314 static GstElementStateReturn
 315 gst_cdxa_parse_change_state (GstElement *element)
 316 {
 317   GstCDXAParse *cdxa_parse = GST_CDXA_PARSE (element);
 318
 319   switch (GST_STATE_TRANSITION (element)) {
 320     case GST_STATE_NULL_TO_READY:
 321       break;
 322     case GST_STATE_READY_TO_PAUSED:
 323       cdxa_parse->state = CDXA_PARSE_HEADER;
 324       cdxa_parse->bs = gst_bytestream_new (cdxa_parse->sinkpad);
 325       break;
 326     case GST_STATE_PAUSED_TO_PLAYING:
 327       break;
 328     case GST_STATE_PLAYING_TO_PAUSED:
 329       break;
 330     case GST_STATE_PAUSED_TO_READY:
 331       gst_bytestream_destroy (cdxa_parse->bs);
 332       break;
 333     case GST_STATE_READY_TO_NULL:
 334       break;
 335     default:
 336       break;
 337   }
 338
 339   parent_class->change_state (element);
 340
 341   return GST_STATE_SUCCESS;
 342 }
 343
 344 static gboolean
 345 plugin_init (GModule *module, GstPlugin *plugin)
 346 {
 347   GstElementFactory *factory;
 348   GstTypeFactory *type;
 349
 350   /* this filter needs the riff parser */
 351   if (!gst_library_load ("gstbytestream")) {
 352     gst_info("cdxaparse: could not load support library: 'gstbytestream'\n");
 353     return FALSE;
 354   }
 355
 356   /* create an elementfactory for the cdxa_parse element */
 357   factory = gst_elementfactory_new ("cdxaparse", GST_TYPE_CDXA_PARSE,
 358                                     &gst_cdxa_parse_details);
 359   g_return_val_if_fail (factory != NULL, FALSE);
 360
 361   gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (src_templ));
 362   gst_elementfactory_add_padtemplate (factory, GST_PADTEMPLATE_GET (sink_templ));
 363
 364   type = gst_typefactory_new (&cdxadefinition);
 365   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type));
 366
 367   gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
 368
 369   return TRUE;
 370 }
 371
 372 GstPluginDesc plugin_desc = {
 373   GST_VERSION_MAJOR,
 374   GST_VERSION_MINOR,
 375   "cdxaparse",
 376   plugin_init
 377 };
 378