/* GStreamer * Copyright (C) <1999> Erik Walthinsen * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ #define PCM_BUFFER_SIZE (1152*4) /*#define DEBUG_ENABLED*/ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include /* struct and table stolen from ac3dec by Aaron Holtzman */ struct frmsize_s { guint16 bit_rate; guint16 frm_size[3]; }; static struct frmsize_s frmsizecod_tbl[] = { { 32 ,{64 ,69 ,96 } }, { 32 ,{64 ,70 ,96 } }, { 40 ,{80 ,87 ,120 } }, { 40 ,{80 ,88 ,120 } }, { 48 ,{96 ,104 ,144 } }, { 48 ,{96 ,105 ,144 } }, { 56 ,{112 ,121 ,168 } }, { 56 ,{112 ,122 ,168 } }, { 64 ,{128 ,139 ,192 } }, { 64 ,{128 ,140 ,192 } }, { 80 ,{160 ,174 ,240 } }, { 80 ,{160 ,175 ,240 } }, { 96 ,{192 ,208 ,288 } }, { 96 ,{192 ,209 ,288 } }, { 112 ,{224 ,243 ,336 } }, { 112 ,{224 ,244 ,336 } }, { 128 ,{256 ,278 ,384 } }, { 128 ,{256 ,279 ,384 } }, { 160 ,{320 ,348 ,480 } }, { 160 ,{320 ,349 ,480 } }, { 192 ,{384 ,417 ,576 } }, { 192 ,{384 ,418 ,576 } }, { 224 ,{448 ,487 ,672 } }, { 224 ,{448 ,488 ,672 } }, { 256 ,{512 ,557 ,768 } }, { 256 ,{512 ,558 ,768 } }, { 320 ,{640 ,696 ,960 } }, { 320 ,{640 ,697 ,960 } }, { 384 ,{768 ,835 ,1152 } }, { 384 ,{768 ,836 ,1152 } }, { 448 ,{896 ,975 ,1344 } }, { 448 ,{896 ,976 ,1344 } }, { 512 ,{1024 ,1114 ,1536 } }, { 512 ,{1024 ,1115 ,1536 } }, { 576 ,{1152 ,1253 ,1728 } }, { 576 ,{1152 ,1254 ,1728 } }, { 640 ,{1280 ,1393 ,1920 } }, { 640 ,{1280 ,1394 ,1920 } }}; /* elementfactory information */ static GstElementDetails ac3parse_details = GST_ELEMENT_DETAILS ( "AC3 Parser", "Codec/Parser/Audio", "Parses and frames AC3 audio streams, provides seek", "Erik Walthinsen " ); /* GstAc3Parse signals and args */ enum { /* FILL ME */ LAST_SIGNAL }; enum { ARG_0, ARG_SKIP, /* FILL ME */ }; GST_PAD_TEMPLATE_FACTORY (src_factory, "src", GST_PAD_SRC, GST_PAD_ALWAYS, GST_CAPS_NEW ("ac3parse_src", "audio/ac3", "channels", GST_PROPS_INT_RANGE (1, 6), "rate", GST_PROPS_INT_RANGE (32000, 48000) ) ); GST_PAD_TEMPLATE_FACTORY (sink_factory, "sink", GST_PAD_SINK, GST_PAD_ALWAYS, GST_CAPS_NEW ("ac3parse_sink", "audio/x-ac3", NULL ) ); static void gst_ac3parse_class_init (gpointer g_class); static void gst_ac3parse_init (GstAc3Parse *ac3parse); static void gst_ac3parse_chain (GstPad *pad, GstData *data); static void gst_ac3parse_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec); static void gst_ac3parse_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); static GstElementStateReturn gst_ac3parse_change_state (GstElement *element); static GstElementClass *parent_class = NULL; /*static guint gst_ac3parse_signals[LAST_SIGNAL] = { 0 };*/ GType ac3parse_get_type (void) { static GType ac3parse_type = 0; if (!ac3parse_type) { static const GTypeInfo ac3parse_info = { sizeof(GstAc3ParseClass), NULL, NULL, (GClassInitFunc)gst_ac3parse_class_init, NULL, NULL, sizeof(GstAc3Parse), 0, (GInstanceInitFunc)gst_ac3parse_init, }; ac3parse_type = g_type_register_static(GST_TYPE_ELEMENT, "GstAc3Parse", &ac3parse_info, 0); } return ac3parse_type; } static void gst_ac3parse_class_init (gpointer g_class) { GObjectClass *gobject_class; GstElementClass *gstelement_class; GstAc3ParseClass *klass; klass = (GstAc3ParseClass *)g_class; gobject_class = (GObjectClass*)klass; gstelement_class = (GstElementClass*)klass; gst_element_class_add_pad_template (gstelement_class, GST_PAD_TEMPLATE_GET(src_factory)); gst_element_class_add_pad_template (gstelement_class, GST_PAD_TEMPLATE_GET(sink_factory)); gst_element_class_set_details (gstelement_class, &ac3parse_details); g_object_class_install_property(G_OBJECT_CLASS(klass), ARG_SKIP, g_param_spec_int("skip","skip","skip", G_MININT,G_MAXINT,0,G_PARAM_READWRITE)); /* CHECKME */ parent_class = g_type_class_ref(GST_TYPE_ELEMENT); gobject_class->set_property = gst_ac3parse_set_property; gobject_class->get_property = gst_ac3parse_get_property; gstelement_class->change_state = gst_ac3parse_change_state; } static void gst_ac3parse_init (GstAc3Parse *ac3parse) { ac3parse->sinkpad = gst_pad_new_from_template ( GST_PAD_TEMPLATE_GET(sink_factory), "sink"); gst_element_add_pad (GST_ELEMENT (ac3parse), ac3parse->sinkpad); gst_pad_set_chain_function (ac3parse->sinkpad, gst_ac3parse_chain); ac3parse->srcpad = gst_pad_new_from_template ( GST_PAD_TEMPLATE_GET(src_factory), "src"); gst_element_add_pad (GST_ELEMENT (ac3parse), ac3parse->srcpad); ac3parse->partialbuf = NULL; ac3parse->skip = 0; ac3parse->sample_rate = ac3parse->channels = -1; } static void gst_ac3parse_chain (GstPad *pad, GstData *_data) { GstBuffer *buf = GST_BUFFER (_data); GstAc3Parse *ac3parse; guchar *data; glong size,offset = 0; guint16 header; guint8 channeldata, acmod, mask; GstBuffer *outbuf = NULL; gint bpf; guint sample_rate = -1, channels = -1; g_return_if_fail(pad != NULL); g_return_if_fail(GST_IS_PAD(pad)); g_return_if_fail(buf != NULL); /* g_return_if_fail(GST_IS_BUFFER(buf)); */ ac3parse = GST_AC3PARSE(GST_OBJECT_PARENT (pad)); GST_DEBUG ("ac3parse: received buffer of %d bytes", GST_BUFFER_SIZE (buf)); /* deal with partial frame from previous buffer */ if (ac3parse->partialbuf) { ac3parse->partialbuf = gst_buffer_merge(ac3parse->partialbuf, buf);; /* and the one we received.. */ gst_buffer_unref(buf); } else { ac3parse->partialbuf = buf; } data = GST_BUFFER_DATA(ac3parse->partialbuf); size = GST_BUFFER_SIZE(ac3parse->partialbuf); /* we're searching for at least 7 bytes. first the * syncinfo, where 2 bytes are for the syncword * (header ID, 0x0b77), 2 bytes crc1 (checksum) and 1 byte * fscod+fmrsizecod (framerate/bitrate) and then the * bitstreaminfo bsid (version), bsmod (data type) and * acmod (channel info, 3 bits). Then some "maybe" * bits, and then the LFE indicator (subwoofer bit) */ while (offset < size-6) { int skipped = 0; GST_DEBUG ("ac3parse: offset %ld, size %ld ",offset, size); /* search for a possible start byte */ for (;((data[offset] != 0x0b) && (offset < size-6));offset++) skipped++ ; if (skipped) { fprintf(stderr, "ac3parse: **** now at %ld skipped %d bytes (FIXME?)\n",offset,skipped); } /* construct the header word */ header = GUINT16_TO_BE(*((guint16 *)(data+offset))); /* g_print("AC3PARSE: sync word is 0x%02X\n",header); */ /* if it's a valid header, go ahead and send off the frame */ if (header == 0x0b77) { gint rate, fsize; /* g_print("AC3PARSE: found sync at %d\n",offset); */ /* get the bits we're interested in */ rate = (data[offset+4] >> 6) & 0x3; switch (rate) { case 0x0: /* 00b */ sample_rate = 48000; break; case 0x1: /* 01b */ sample_rate = 44100; break; case 0x2: /* 10b */ sample_rate = 32000; break; case 0x3: /* 11b */ default: /* reserved. if this happens, we're screwed */ g_assert (0); break; } fsize = data[offset+4] & 0x3f; /* calculate the bpf of the frame */ bpf = frmsizecod_tbl[fsize].frm_size[rate] * 2; /* calculate number of channels */ channeldata = data[offset+6]; /* skip bsid/bsmod */ acmod = (channeldata >> 5) & 0x7; switch (acmod) { case 0x1: /* 001b = 1 channel */ channels = 1; break; case 0x0: /* 000b = 2 independent channels*/ case 0x2: /* 010b = 2x front (stereo) */ channels = 2; break; case 0x3: /* 011b = 3 front */ case 0x4: /* 100b = 2 front, 1 rear */ channels = 3; break; case 0x5: /* 101b = 3 front, 1 rear */ case 0x6: /* 110b = 2 front, 2 rear */ channels = 4; break; case 0x7: /* 111b = 3 front, 2 rear */ channels = 5; break; default: /* whaaaaaaaaaaaaaa!!!!!!!!!!! */ g_assert (0); } /* fetch LFE bit (subwoofer) */ mask = 0x10; if (acmod & 0x1 && acmod != 0x1) /* 3 front speakers? */ mask >>= 2; if (acmod & 0x4) /* surround channel? */ mask >>= 2; if (acmod == 0x2) /* 2/0 mode? */ mask >>= 2; if (channeldata & mask) /* LFE: do we have a subwoofer channel? */ channels++; /* if we don't have the whole frame... */ if ((size - offset) < bpf) { GST_DEBUG ("ac3parse: partial buffer needed %ld < %d ",size-offset, bpf); break; } else { gboolean need_capsnego = FALSE; outbuf = gst_buffer_create_sub (ac3parse->partialbuf,offset,bpf); /* make sure our properties still match */ if (channels > 0 && ac3parse->channels != channels) { ac3parse->channels = channels; need_capsnego = TRUE; } if (sample_rate > 0 && ac3parse->sample_rate != sample_rate) { ac3parse->sample_rate = sample_rate; need_capsnego = TRUE; } if (need_capsnego) { GstCaps *newcaps; newcaps = GST_CAPS_NEW ("ac3parse_src", "audio/x-ac3", "channels", GST_PROPS_INT (channels), "rate", GST_PROPS_INT (sample_rate)); if (gst_pad_try_set_caps (ac3parse->srcpad, newcaps) <= 0) { gst_element_error (GST_ELEMENT (ac3parse), "Ac3parse: failed to negotiate format with next element"); return; } } offset += bpf; if (ac3parse->skip == 0 && GST_PAD_IS_LINKED(ac3parse->srcpad)) { GST_DEBUG ("ac3parse: pushing buffer of %d bytes",GST_BUFFER_SIZE(outbuf)); gst_pad_push(ac3parse->srcpad,GST_DATA (outbuf)); } else { GST_DEBUG ("ac3parse: skipping buffer of %d bytes",GST_BUFFER_SIZE(outbuf)); gst_buffer_unref(outbuf); ac3parse->skip--; } } } else { offset++; fprintf(stderr, "ac3parse: *** wrong header, skipping byte (FIXME?)\n"); } } /* if we have processed this block and there are still */ /* bytes left not in a partial block, copy them over. */ if (size-offset > 0) { gint remainder = (size - offset); GST_DEBUG ("ac3parse: partial buffer needed %d for trailing bytes",remainder); outbuf = gst_buffer_create_sub(ac3parse->partialbuf,offset,remainder); gst_buffer_unref(ac3parse->partialbuf); ac3parse->partialbuf = outbuf; } } static void gst_ac3parse_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GstAc3Parse *src; /* it's not null if we got it, but it might not be ours */ g_return_if_fail(GST_IS_AC3PARSE(object)); src = GST_AC3PARSE(object); switch (prop_id) { case ARG_SKIP: src->skip = g_value_get_int (value); break; default: break; } } static void gst_ac3parse_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { GstAc3Parse *src; /* it's not null if we got it, but it might not be ours */ g_return_if_fail(GST_IS_AC3PARSE(object)); src = GST_AC3PARSE(object); switch (prop_id) { case ARG_SKIP: g_value_set_int (value, src->skip); break; default: break; } } static GstElementStateReturn gst_ac3parse_change_state (GstElement *element) { GstAc3Parse *ac3parse = GST_AC3PARSE(element); switch (GST_STATE_TRANSITION (element)) { case GST_STATE_PAUSED_TO_READY: /* reset stream info */ ac3parse->channels = ac3parse->sample_rate = -1; break; } if (GST_ELEMENT_CLASS (parent_class)->change_state) return GST_ELEMENT_CLASS (parent_class)->change_state (element); return GST_STATE_SUCCESS; } static gboolean plugin_init (GstPlugin *plugin) { if(!gst_element_register(plugin, "ac3parse", GST_RANK_SECONDARY, GST_TYPE_AC3PARSE)){ return FALSE; } return TRUE; } GST_PLUGIN_DEFINE( GST_VERSION_MAJOR, GST_VERSION_MINOR, "ac3parse", "ac3 parsing", plugin_init, VERSION, "LGPL", GST_COPYRIGHT, GST_PACKAGE, GST_ORIGIN )