diff options
Diffstat (limited to 'gst/qtdemux/qtdemux.c')
| -rw-r--r-- | gst/qtdemux/qtdemux.c | 1698 |
1 files changed, 1232 insertions, 466 deletions
diff --git a/gst/qtdemux/qtdemux.c b/gst/qtdemux/qtdemux.c index 4512f757..516da94e 100644 --- a/gst/qtdemux/qtdemux.c +++ b/gst/qtdemux/qtdemux.c @@ -1,5 +1,6 @@ /* GStreamer * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu> + * Copyright (C) <2003> David A. Schleef <ds@schleef.org> * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -17,27 +18,70 @@ * Boston, MA 02111-1307, USA. */ +#include "qtdemux.h" -#include <stdlib.h> #include <string.h> -#include "qtdemux.h" -/* elementfactory information */ +typedef struct _QtNode QtNode; +typedef struct _QtNodeType QtNodeType; +typedef struct _QtDemuxSample QtDemuxSample; +//typedef struct _QtDemuxStream QtDemuxStream; + +struct _QtNode { + guint32 type; + gpointer data; + int len; +}; + +struct _QtNodeType { + guint32 fourcc; + char *name; + int flags; + void (*dump)(GstQTDemux *qtdemux, void *buffer, int depth); +}; + +struct _QtDemuxSample { + int sample_index; + int chunk; + int size; + guint32 offset; + guint64 timestamp; +}; + +struct _QtDemuxStream { + guint32 subtype; + GstCaps *caps; + GstPad *pad; + int n_samples; + QtDemuxSample *samples; + int timescale; + + int sample_index; +}; + +enum QtDemuxState { + QTDEMUX_STATE_NULL, + QTDEMUX_STATE_HEADER, + QTDEMUX_STATE_SEEKING, + QTDEMUX_STATE_MOVIE, + QTDEMUX_STATE_SEEKING_EOS, + QTDEMUX_STATE_EOS, +}; + static GstElementDetails gst_qtdemux_details = { - "quicktime parser", - "Codec/Parser", + "QuickTime Demuxer", + "Codec/Demuxer", "LGPL", - "Parses a quicktime stream into audio and video substreams", + "Demultiplex a QuickTime file into audio and video streams", VERSION, - "A.Baguinski <artm@v2.nl>", - "(C) 2002", + "David Schleef <ds@schleef.org>", + "(C) 2003", }; static GstCaps* quicktime_type_find (GstBuffer *buf, gpointer private); -/* typefactory for 'quicktime' */ static GstTypeDefinition quicktimedefinition = { "qtdemux_video/quicktime", "video/quicktime", @@ -64,78 +108,37 @@ GST_PAD_TEMPLATE_FACTORY (sink_templ, ) ) -/* - * so far i only support Photo Jpeg videos and no audio. - * after this one works ok, i'll see what's next. - */ GST_PAD_TEMPLATE_FACTORY (src_video_templ, "video_%02d", GST_PAD_SRC, GST_PAD_SOMETIMES, - GST_CAPS_NEW ( - "qtdemux_src_video", - "video/jpeg", - "width", GST_PROPS_INT_RANGE (16, 4096), - "height", GST_PROPS_INT_RANGE (16, 4096) - ) + NULL ) -static GstElementClass *parent_class = NULL; -/* - * contains correspondence between atom types and - * GstQtpAtomType structures - */ -static GHashTable * gst_qtp_type_registry; - -typedef struct { - guint32 type; - GstQtpAtomType atype; -} GstQtpTypePair; - -static void gst_qtp_trak_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter); -static void gst_qtp_tkhd_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter); -static void gst_qtp_hdlr_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter); -static void gst_qtp_stsd_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter); -static void gst_qtp_stts_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter); -static void gst_qtp_stsc_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter); -static void gst_qtp_stsz_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter); -static void gst_qtp_stco_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter); -static void gst_qtp_mdhd_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter); -static void gst_qtp_mdat_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter); - -GstQtpTypePair gst_qtp_type_table[] = { - { GST_MAKE_FOURCC('m','o','o','v'), {GST_QTP_CONTAINER_ATOM,NULL} }, - { GST_MAKE_FOURCC('t','r','a','k'), {GST_QTP_CONTAINER_ATOM,gst_qtp_trak_handler} }, - { GST_MAKE_FOURCC('e','d','t','s'), {GST_QTP_CONTAINER_ATOM,NULL} }, - { GST_MAKE_FOURCC('m','d','i','a'), {GST_QTP_CONTAINER_ATOM,NULL} }, - { GST_MAKE_FOURCC('m','i','n','f'), {GST_QTP_CONTAINER_ATOM,NULL} }, - { GST_MAKE_FOURCC('d','i','n','f'), {GST_QTP_CONTAINER_ATOM,NULL} }, - { GST_MAKE_FOURCC('s','t','b','l'), {GST_QTP_CONTAINER_ATOM,NULL} }, - { GST_MAKE_FOURCC('m','d','a','t'), {0,gst_qtp_mdat_handler} }, - { GST_MAKE_FOURCC('m','v','h','d'), {0,NULL} }, - { GST_MAKE_FOURCC('t','k','h','d'), {0,gst_qtp_tkhd_handler} }, - { GST_MAKE_FOURCC('e','l','s','t'), {0,NULL} }, - { GST_MAKE_FOURCC('m','d','h','d'), {0,gst_qtp_mdhd_handler} }, - { GST_MAKE_FOURCC('h','d','l','r'), {0,gst_qtp_hdlr_handler} }, - { GST_MAKE_FOURCC('v','m','h','d'), {0,NULL} }, - { GST_MAKE_FOURCC('d','r','e','f'), {0,NULL} }, - { GST_MAKE_FOURCC('s','t','t','s'), {0,gst_qtp_stts_handler} }, - { GST_MAKE_FOURCC('s','t','s','d'), {0,gst_qtp_stsd_handler} }, - { GST_MAKE_FOURCC('s','t','s','z'), {0,gst_qtp_stsz_handler} }, - { GST_MAKE_FOURCC('s','t','s','c'), {0,gst_qtp_stsc_handler} }, - { GST_MAKE_FOURCC('s','t','c','o'), {0,gst_qtp_stco_handler} } -}; +GST_PAD_TEMPLATE_FACTORY (src_audio_templ, + "audio_%02d", + GST_PAD_SRC, + GST_PAD_SOMETIMES, + NULL +) -#define GST_QTP_TYPE_CNT sizeof(gst_qtp_type_table)/sizeof(GstQtpTypePair) +static GstElementClass *parent_class = NULL; static void gst_qtdemux_class_init (GstQTDemuxClass *klass); static void gst_qtdemux_init (GstQTDemux *quicktime_demux); -static void gst_qtdemux_loop (GstElement *element); -static GstElementStateReturn gst_qtdemux_change_state (GstElement * element); -static gint gst_guint32_compare(gconstpointer _a, gconstpointer _b); - -static GType -gst_qtdemux_get_type (void) +static GstElementStateReturn gst_qtdemux_change_state(GstElement *element); +static void gst_qtdemux_loop_header (GstElement *element); +static gboolean gst_qtdemux_handle_sink_event (GstQTDemux *qtdemux); + +static void qtdemux_parse_moov(GstQTDemux *qtdemux, void *buffer, int length); +static void qtdemux_parse(GstQTDemux *qtdemux, GNode *node, void *buffer, int length); +static QtNodeType *qtdemux_type_get(guint32 fourcc); +static void qtdemux_node_dump(GstQTDemux *qtdemux, GNode *node); +static void qtdemux_parse_tree(GstQTDemux *qtdemux); +static GstCaps *qtdemux_video_caps(GstQTDemux *qtdemux, guint32 fourcc); +static GstCaps *qtdemux_audio_caps(GstQTDemux *qtdemux, guint32 fourcc); + +static GType gst_qtdemux_get_type (void) { static GType qtdemux_type = 0; @@ -151,12 +154,10 @@ gst_qtdemux_get_type (void) return qtdemux_type; } -static void -gst_qtdemux_class_init (GstQTDemuxClass *klass) +static void gst_qtdemux_class_init (GstQTDemuxClass *klass) { GObjectClass *gobject_class; GstElementClass *gstelement_class; - int i; gobject_class = (GObjectClass*)klass; gstelement_class = (GstElementClass*)klass; @@ -164,50 +165,14 @@ gst_qtdemux_class_init (GstQTDemuxClass *klass) parent_class = g_type_class_ref (GST_TYPE_ELEMENT); gstelement_class->change_state = gst_qtdemux_change_state; - - gst_qtp_type_registry = g_hash_table_new(g_int_hash,g_int_equal); - for(i=0;i<GST_QTP_TYPE_CNT;i++) { - g_hash_table_insert(gst_qtp_type_registry,&(gst_qtp_type_table[i].type),&(gst_qtp_type_table[i].atype)); - } -} - -static GstElementStateReturn -gst_qtdemux_change_state (GstElement * element) -{ - GstQTDemux * qtdemux = GST_QTDEMUX (element); - - switch (GST_STATE_TRANSITION (element)) { - case GST_STATE_READY_TO_PAUSED: - qtdemux->bs = gst_bytestream_new (qtdemux->sinkpad); - break; - case GST_STATE_PAUSED_TO_READY: - gst_bytestream_destroy (qtdemux->bs); - break; - default: - break; - } - parent_class->change_state (element); - return GST_STATE_SUCCESS; } static void gst_qtdemux_init (GstQTDemux *qtdemux) { - guint i; - qtdemux->sinkpad = gst_pad_new_from_template (GST_PAD_TEMPLATE_GET (sink_templ), "sink"); - gst_element_set_loop_function (GST_ELEMENT (qtdemux), gst_qtdemux_loop); + gst_element_set_loop_function (GST_ELEMENT (qtdemux), gst_qtdemux_loop_header); gst_element_add_pad (GST_ELEMENT (qtdemux), qtdemux->sinkpad); - - for (i=0; i<GST_QTDEMUX_MAX_VIDEO_PADS; i++) - qtdemux->video_pad[i] = NULL; - qtdemux->num_video_pads = 0; - - qtdemux->bs_pos = 0; - qtdemux->nested = NULL; - qtdemux->nested_cnt = 0; - qtdemux->tracks = NULL; - qtdemux->samples = NULL; } static GstCaps* @@ -215,14 +180,15 @@ quicktime_type_find (GstBuffer *buf, gpointer private) { gchar *data = GST_BUFFER_DATA (buf); - /* we could get a NULL buffer, for example when the input could not be - * mmap'd */ g_return_val_if_fail (data != NULL, NULL); - /* exactly like in the old version */ - if (!strncmp (&data[4], "wide", 4) || - !strncmp (&data[4], "moov", 4) || - !strncmp (&data[4], "mdat", 4)) { + if(GST_BUFFER_SIZE(buf) < 8){ + return NULL; + } + if (strncmp (&data[4], "wide", 4)==0 || + strncmp (&data[4], "moov", 4)==0 || + strncmp (&data[4], "mdat", 4)==0 || + strncmp (&data[4], "free", 4)==0) { return gst_caps_new ("quicktime_type_find", "video/quicktime", NULL); @@ -246,6 +212,7 @@ plugin_init (GModule *module, GstPlugin *plugin) gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (sink_templ)); gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (src_video_templ)); + gst_element_factory_add_pad_template (factory, GST_PAD_TEMPLATE_GET (src_audio_templ)); type = gst_type_factory_new (&quicktimedefinition); gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type)); @@ -262,447 +229,1246 @@ GstPluginDesc plugin_desc = { plugin_init }; -static gboolean -gst_qtdemux_handle_event (GstQTDemux * qtdemux) +static gboolean gst_qtdemux_handle_sink_event (GstQTDemux *qtdemux) { guint32 remaining; - GstEvent * event; + GstEvent *event; GstEventType type; - gst_bytestream_get_status (qtdemux->bs,&remaining,&event); - type = event? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN; + gst_bytestream_get_status(qtdemux->bs, &remaining, &event); + + type = event ? GST_EVENT_TYPE(event) : GST_EVENT_UNKNOWN; + GST_DEBUG(0,"qtdemux: event %p %d", event, type); - switch (type) { + switch(GST_EVENT_TYPE(event)){ case GST_EVENT_EOS: - gst_pad_event_default (qtdemux->sinkpad,event); + gst_bytestream_flush(qtdemux->bs, remaining); + gst_pad_event_default(qtdemux->sinkpad, event); + return FALSE; + case GST_EVENT_FLUSH: + g_warning("flush event"); break; case GST_EVENT_DISCONTINUOUS: - gst_bytestream_flush_fast (qtdemux->bs, remaining); + GST_DEBUG(0,"discontinuous event\n"); + //gst_bytestream_flush_fast(qtdemux->bs, remaining); + break; default: - gst_pad_event_default (qtdemux->sinkpad,event); + g_warning("unhandled event %d",type); break; } + + gst_event_unref(event); return TRUE; } -static gboolean gst_qtp_read_bytes_atom_head(GstQTDemux * qtdemux,GstQtpAtom * atom); -static gboolean gst_qtp_skip(GstQTDemux * qtdemux, guint64 skip); -static gboolean gst_qtp_skip_atom(GstQTDemux * qtdemux, GstQtpAtom * atom); -static gboolean gst_qtp_skip_container(GstQTDemux * qtdemux, guint32 type); +static GstElementStateReturn gst_qtdemux_change_state(GstElement *element) +{ + GstQTDemux *qtdemux = GST_QTDEMUX(element); -/* new track emerges here */ -static GstQtpTrack * track_to_be = NULL; + switch(GST_STATE_TRANSITION(element)){ + case GST_STATE_NULL_TO_READY: + break; + case GST_STATE_READY_TO_PAUSED: + qtdemux->bs = gst_bytestream_new(qtdemux->sinkpad); + qtdemux->state = QTDEMUX_STATE_HEADER; + /* FIXME */ + break; + case GST_STATE_PAUSED_TO_PLAYING: + break; + case GST_STATE_PLAYING_TO_PAUSED: + break; + case GST_STATE_PAUSED_TO_READY: + gst_bytestream_destroy(qtdemux->bs); + break; + case GST_STATE_READY_TO_NULL: + break; + default: + break; + } -/* - * - gst_qtp_* functions together with gst_qtdemux_loop implement quicktime - * parser. - */ + return GST_ELEMENT_CLASS(parent_class)->change_state(element); +} -static void -gst_qtdemux_loop (GstElement *element) -{ - GstQTDemux * qtdemux = GST_QTDEMUX (element); - GstQtpAtom atom; - GstQtpAtomType * atom_type; - - /* ain't we out of the current container? */ - if (qtdemux->nested) { - GstQtpAtom * current = (GstQtpAtom *) qtdemux->nested->data; - while (current && (current->size!=0) && (current->start+current->size <= qtdemux->bs_pos)) { - /* indeed we are! */ - qtdemux->nested = qtdemux->nested->next; - qtdemux->nested_cnt--; - /* if atom type has a handler call it with enter=FALSE (i.e. leave) */ - atom_type = g_hash_table_lookup (gst_qtp_type_registry,&(current->type)); - if (atom_type && atom_type->handler) - atom_type->handler(qtdemux,current,FALSE); - free(current); - current = qtdemux->nested?(GstQtpAtom *) qtdemux->nested->data:NULL; +static void gst_qtdemux_loop_header (GstElement *element) +{ + GstQTDemux *qtdemux = GST_QTDEMUX(element); + guint8 *data; + guint32 length; + guint32 fourcc; + GstBuffer *buf; + int offset; + int cur_offset; + int size; + int ret; + + + GST_DEBUG(0,"loop at position %d",(int)gst_bytestream_tell(qtdemux->bs)); + + switch(qtdemux->state){ + case QTDEMUX_STATE_HEADER: + { + ret = gst_bytestream_peek_bytes(qtdemux->bs, &data, 16); + if(ret<16){ + gst_qtdemux_handle_sink_event(qtdemux); + return; } - } - - gst_qtp_read_bytes_atom_head(qtdemux,&atom); - GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtdemux_loop: atom(%c%c%c%c,%" G_GUINT64_FORMAT ",%" G_GUINT64_FORMAT")\n",GST_FOURCC_TO_CHARSEQ(atom.type),atom.start,atom.size); - atom_type = g_hash_table_lookup (gst_qtp_type_registry,&atom.type); - if (!atom_type) { - gst_qtp_skip_atom(qtdemux,&atom); - return; + length = GUINT32_FROM_BE(*(guint32 *)data); + GST_DEBUG(0,"length %08x",length); + fourcc = GUINT32_FROM_LE(*(guint32 *)(data+4)); + GST_DEBUG(0,"fourcc " GST_FOURCC_FORMAT, GST_FOURCC_ARGS(fourcc)); + if(length==0){ + length = gst_bytestream_length(qtdemux->bs) - gst_bytestream_tell(qtdemux->bs); + } + if(length==1){ + guint32 length1, length2; + + length1 = GUINT32_FROM_BE(*(guint32 *)(data+8)); + GST_DEBUG(0,"length1 %08x",length1); + length2 = GUINT32_FROM_BE(*(guint32 *)(data+12)); + GST_DEBUG(0,"length2 %08x",length2); + + length=length2; + } + + switch(fourcc){ + case GST_MAKE_FOURCC('m','d','a','t'): + { + int ret; + int pos; + + pos = gst_bytestream_tell(qtdemux->bs); + ret = gst_bytestream_seek(qtdemux->bs, pos + length, GST_SEEK_METHOD_SET); + GST_DEBUG(0,"seek returned %d",ret); + return; + } + case GST_MAKE_FOURCC('m','o','o','v'): + { + GstBuffer *moov; + guint32 n_read; + + n_read = gst_bytestream_read(qtdemux->bs, &moov, length); + if(n_read<length){ + /* FIXME */ + g_warning("need to handle event\n"); + } + qtdemux_parse_moov(qtdemux, GST_BUFFER_DATA(moov), length); + if(0)qtdemux_node_dump(qtdemux, qtdemux->moov_node); + qtdemux_parse_tree(qtdemux); + qtdemux->state = QTDEMUX_STATE_MOVIE; + break; + } + case GST_MAKE_FOURCC('f','r','e','e'): + { + gst_bytestream_flush(qtdemux->bs, length); + break; + } + case GST_MAKE_FOURCC('w','i','d','e'): + { + gst_bytestream_flush(qtdemux->bs, length); + break; + } + default: + { + g_print("unknown %08x '" GST_FOURCC_FORMAT "' at %" G_GUINT64_FORMAT "\n", + GST_MAKE_FOURCC('1','2','3','4'), + GST_FOURCC_ARGS(GST_MAKE_FOURCC('1','2','3','4')),gst_bytestream_tell(qtdemux->bs)); + gst_bytestream_flush(qtdemux->bs, length); + break; + } + } + break; } + case QTDEMUX_STATE_SEEKING_EOS: + { + guint8 *data; + + do{ + ret = gst_bytestream_peek_bytes(qtdemux->bs, &data, 1); + g_print("peek_bytes returned %d after EOS seek\n",ret); + if(ret<1){ + if(!gst_qtdemux_handle_sink_event(qtdemux)){ + return; + } + }else{ + break; + } + }while(TRUE); + gst_element_set_eos(element); - if (atom_type->flags & GST_QTP_CONTAINER_ATOM) { - GstQtpAtom * new_atom; - new_atom = malloc(sizeof(GstQtpAtom)); - memcpy(new_atom,&atom,sizeof(GstQtpAtom)); - qtdemux->nested_cnt++; - qtdemux->nested = g_slist_prepend (qtdemux->nested, new_atom); - if (atom_type->handler) - atom_type->handler(qtdemux,&atom,TRUE); - } else { - /* leaf atom */ - if (atom_type->handler) - atom_type->handler(qtdemux,&atom,TRUE); - /* - * if there wasn't a handler - we skip the whole atom - * if there was - ensure that next thing read will be after the atom - * (handler isn't obligated to read anything) - */ - gst_qtp_skip_atom(qtdemux,&atom); + qtdemux->state = QTDEMUX_STATE_EOS; return; } -} + case QTDEMUX_STATE_EOS: + g_warning("spinning in EOS\n"); + return; + case QTDEMUX_STATE_MOVIE: + { + QtDemuxStream *stream; + guint64 min_time; + int index = -1; + int i; + + min_time = G_MAXUINT64; + for(i=0;i<qtdemux->n_streams;i++){ + stream = qtdemux->streams[i]; + + if(stream->sample_index < stream->n_samples && + stream->samples[stream->sample_index].timestamp < min_time){ + min_time = stream->samples[stream->sample_index].timestamp; + index = i; + } + } -/* - * peeks an atom header, - * advances qtdemux->bs_pos (cause bytestream won't tell) - * flushes bytestream - */ -static gboolean -gst_qtp_read_bytes_atom_head(GstQTDemux * qtdemux,GstQtpAtom * atom) -{ - GstByteStream * bs = qtdemux->bs; - GstQtpAtomMinHeader * amh = NULL; - guint64 * esize=NULL; - - /* FIXME this can't be right, rewrite with _read */ - do { /* do ... while (event()) is necessary for bytestream events */ - if (!amh) { - if (gst_bytestream_peek_bytes (bs, (guint8**)&amh, 8) == 8) { - atom->size = GUINT32_FROM_BE(amh->size); - atom->type = amh->type; /* don't need to turn this around magicly FIXME this can depend on endiannes */ - atom->start = qtdemux->bs_pos; - gst_bytestream_flush (bs, 8); - qtdemux->bs_pos += 8; + if(index==-1){ + for(i=0;i<qtdemux->n_streams;i++){ + gst_pad_push(qtdemux->streams[i]->pad, + GST_BUFFER(gst_event_new (GST_EVENT_EOS))); + } + ret = gst_bytestream_seek(qtdemux->bs, 0, GST_SEEK_METHOD_END); + GST_DEBUG(0,"seek returned %d",ret); + + qtdemux->state = QTDEMUX_STATE_SEEKING_EOS; + return; + } + + stream = qtdemux->streams[index]; + + offset = stream->samples[stream->sample_index].offset; + size = stream->samples[stream->sample_index].size; + + cur_offset = gst_bytestream_tell(qtdemux->bs); + if(offset != cur_offset){ + GST_DEBUG(0,"seeking to offset %d",offset); + ret = gst_bytestream_seek(qtdemux->bs, offset, GST_SEEK_METHOD_SET); + GST_DEBUG(0,"seek returned %d",ret); +#if 0 + if(!gst_bytestream_seek(qtdemux->bs, offset, GST_SEEK_METHOD_SET)){ + GstEvent *event; + guint32 remaining; + + g_print("seek failed\n"); + gst_bytestream_get_status(qtdemux->bs, &remaining, &event); + + gst_pad_push(stream->pad, GST_BUFFER(event)); + return; } +#endif + return; } - if (amh) { - if (atom->size == 1) { /* need to peek extended size field */ - if (gst_bytestream_peek_bytes (bs, (guint8**)&esize, 8) == 8) { - atom->size = GUINT64_FROM_BE(*esize); - gst_bytestream_flush (bs, 8); - qtdemux->bs_pos += 8; - return TRUE; + + GST_DEBUG(0,"reading %d bytes\n",size); + buf = NULL; + do{ + ret = gst_bytestream_read(qtdemux->bs, &buf, size); + if(ret < size){ + GST_DEBUG(0,"read failed (%d < %d)",ret,size); + if(!gst_qtdemux_handle_sink_event(qtdemux)){ + return; } - } else { - return TRUE; + }else{ + break; } + }while(TRUE); + + if(buf){ + GST_BUFFER_TIMESTAMP(buf) = stream->samples[stream->sample_index].timestamp; + gst_pad_push(stream->pad, buf); } - } while (gst_qtdemux_handle_event (qtdemux)); - return TRUE; + stream->sample_index++; + break; + } + default: + /* unreached */ + g_assert(0); + } + } -static void -gst_qtp_read_bytes(GstQTDemux * qtdemux, void * buffer, size_t size) +void gst_qtdemux_add_stream(GstQTDemux *qtdemux, QtDemuxStream *stream) { - void * data; - GstByteStream * bs = qtdemux->bs; - - do { - if (gst_bytestream_peek_bytes (bs, (guint8**)&data, size) == size) { - memcpy(buffer,data,size); - gst_bytestream_flush(bs,size); - qtdemux->bs_pos += size; - return; + if(stream->subtype == GST_MAKE_FOURCC('v','i','d','e')){ + stream->pad = gst_pad_new_from_template ( + GST_PAD_TEMPLATE_GET (src_video_templ), g_strdup_printf ("video_%02d", + qtdemux->n_video_streams)); + if(stream->caps){ + if(gst_caps_has_property(stream->caps,"width")){ + /* FIXME */ + gst_caps_set(stream->caps,"width",GST_PROPS_INT(100)); + } + if(gst_caps_has_property(stream->caps,"height")){ + /* FIXME */ + gst_caps_set(stream->caps,"height",GST_PROPS_INT(100)); + } + } + qtdemux->n_video_streams++; + }else{ + stream->pad = gst_pad_new_from_template ( + GST_PAD_TEMPLATE_GET (src_audio_templ), g_strdup_printf ("audio_%02d", + qtdemux->n_audio_streams)); +#if 0 + if(stream->caps){ + if(gst_caps_has_property(stream->caps,"rate")){ + /* FIXME */ + gst_caps_set(stream->caps,"rate",GST_PROPS_INT(44100)); + } + if(gst_caps_has_property(stream->caps,"channels")){ + /* FIXME */ + gst_caps_set(stream->caps,"channels",GST_PROPS_INT(2)); + } } - } while (gst_qtdemux_handle_event (qtdemux)); +#endif + g_print("setting caps to %s\n",gst_caps_to_string(stream->caps)); + qtdemux->n_audio_streams++; + } + gst_element_add_pad(GST_ELEMENT (qtdemux), stream->pad); + if(stream->caps){ + gst_pad_try_set_caps(stream->pad, stream->caps); + } + + qtdemux->streams[qtdemux->n_streams] = stream; + qtdemux->n_streams++; } -static GstBuffer * -gst_qtp_read(GstQTDemux * qtdemux, size_t size) + +#define QT_CONTAINER 1 + +#define FOURCC_moov GST_MAKE_FOURCC('m','o','o','v') +#define FOURCC_mvhd GST_MAKE_FOURCC('m','v','h','d') +#define FOURCC_clip GST_MAKE_FOURCC('c','l','i','p') +#define FOURCC_trak GST_MAKE_FOURCC('t','r','a','k') +#define FOURCC_udta GST_MAKE_FOURCC('u','d','t','a') +#define FOURCC_ctab GST_MAKE_FOURCC('c','t','a','b') +#define FOURCC_tkhd GST_MAKE_FOURCC('t','k','h','d') +#define FOURCC_crgn GST_MAKE_FOURCC('c','r','g','n') +#define FOURCC_matt GST_MAKE_FOURCC('m','a','t','t') +#define FOURCC_kmat GST_MAKE_FOURCC('k','m','a','t') +#define FOURCC_edts GST_MAKE_FOURCC('e','d','t','s') +#define FOURCC_elst GST_MAKE_FOURCC('e','l','s','t') +#define FOURCC_load GST_MAKE_FOURCC('l','o','a','d') +#define FOURCC_tref GST_MAKE_FOURCC('t','r','e','f') +#define FOURCC_imap GST_MAKE_FOURCC('i','m','a','p') +#define FOURCC___in GST_MAKE_FOURCC(' ',' ','i','n') +#define FOURCC___ty GST_MAKE_FOURCC(' ',' ','t','y') +#define FOURCC_mdia GST_MAKE_FOURCC('m','d','i','a') +#define FOURCC_mdhd GST_MAKE_FOURCC('m','d','h','d') +#define FOURCC_hdlr GST_MAKE_FOURCC('h','d','l','r') +#define FOURCC_minf GST_MAKE_FOURCC('m','i','n','f') +#define FOURCC_vmhd GST_MAKE_FOURCC('v','m','h','d') +#define FOURCC_smhd GST_MAKE_FOURCC('s','m','h','d') +#define FOURCC_gmhd GST_MAKE_FOURCC('g','m','h','d') +#define FOURCC_gmin GST_MAKE_FOURCC('g','m','i','n') +#define FOURCC_dinf GST_MAKE_FOURCC('d','i','n','f') +#define FOURCC_dref GST_MAKE_FOURCC('d','r','e','f') +#define FOURCC_stbl GST_MAKE_FOURCC('s','t','b','l') +#define FOURCC_stsd GST_MAKE_FOURCC('s','t','s','d') +#define FOURCC_stts GST_MAKE_FOURCC('s','t','t','s') +#define FOURCC_stss GST_MAKE_FOURCC('s','t','s','s') +#define FOURCC_stsc GST_MAKE_FOURCC('s','t','s','c') +#define FOURCC_stsz GST_MAKE_FOURCC('s','t','s','z') +#define FOURCC_stco GST_MAKE_FOURCC('s','t','c','o') +#define FOURCC_vide GST_MAKE_FOURCC('v','i','d','e') +#define FOURCC_soun GST_MAKE_FOURCC('s','o','u','n') +#define FOURCC_co64 GST_MAKE_FOURCC('c','o','6','4') + + +static void qtdemux_dump_mvhd(GstQTDemux *qtdemux, void *buffer, int depth); +static void qtdemux_dump_tkhd(GstQTDemux *qtdemux, void *buffer, int depth); +static void qtdemux_dump_elst(GstQTDemux *qtdemux, void *buffer, int depth); +static void qtdemux_dump_mdhd(GstQTDemux *qtdemux, void *buffer, int depth); +static void qtdemux_dump_hdlr(GstQTDemux *qtdemux, void *buffer, int depth); +static void qtdemux_dump_vmhd(GstQTDemux *qtdemux, void *buffer, int depth); +static void qtdemux_dump_dref(GstQTDemux *qtdemux, void *buffer, int depth); +static void qtdemux_dump_stsd(GstQTDemux *qtdemux, void *buffer, int depth); +static void qtdemux_dump_stts(GstQTDemux *qtdemux, void *buffer, int depth); +static void qtdemux_dump_stss(GstQTDemux *qtdemux, void *buffer, int depth); +static void qtdemux_dump_stsc(GstQTDemux *qtdemux, void *buffer, int depth); +static void qtdemux_dump_stsz(GstQTDemux *qtdemux, void *buffer, int depth); +static void qtdemux_dump_stco(GstQTDemux *qtdemux, void *buffer, int depth); +static void qtdemux_dump_co64(GstQTDemux *qtdemux, void *buffer, int depth); + +QtNodeType qt_node_types[] = { + { FOURCC_moov, "movie", QT_CONTAINER, }, + { FOURCC_mvhd, "movie header", 0, + qtdemux_dump_mvhd }, + { FOURCC_clip, "clipping", QT_CONTAINER, }, + { FOURCC_trak, "track", QT_CONTAINER, }, + { FOURCC_udta, "user data", 0, }, /* special container */ + { FOURCC_ctab, "color table", 0, }, + { FOURCC_tkhd, "track header", 0, + qtdemux_dump_tkhd }, + { FOURCC_crgn, "clipping region", 0, }, + { FOURCC_matt, "track matte", QT_CONTAINER, }, + { FOURCC_kmat, "compressed matte", 0, }, + { FOURCC_edts, "edit", QT_CONTAINER, }, + { FOURCC_elst, "edit list", 0, + qtdemux_dump_elst }, + { FOURCC_load, "track load settings", 0, }, + { FOURCC_tref, "track reference", QT_CONTAINER, }, + { FOURCC_imap, "track input map", QT_CONTAINER, }, + { FOURCC___in, "track input", 0, }, /* special container */ + { FOURCC___ty, "input type", 0, }, + { FOURCC_mdia, "media", QT_CONTAINER }, + { FOURCC_mdhd, "media header", 0, + qtdemux_dump_mdhd }, + { FOURCC_hdlr, "handler reference", 0, + qtdemux_dump_hdlr }, + { FOURCC_minf, "media information", QT_CONTAINER }, + { FOURCC_vmhd, "video media information", 0, + qtdemux_dump_vmhd }, + { FOURCC_smhd, "sound media information", 0 }, + { FOURCC_gmhd, "base media information header", 0 }, + { FOURCC_gmin, "base media info", 0 }, + { FOURCC_dinf, "data information", QT_CONTAINER }, + { FOURCC_dref, "data reference", 0, + qtdemux_dump_dref }, + { FOURCC_stbl, "sample table", QT_CONTAINER }, + { FOURCC_stsd, "sample description", 0, + qtdemux_dump_stsd }, + { FOURCC_stts, "time-to-sample", 0, + qtdemux_dump_stts }, + { FOURCC_stss, "sync sample", 0, + qtdemux_dump_stss }, + { FOURCC_stsc, "sample-to-chunk", 0, + qtdemux_dump_stsc }, + { FOURCC_stsz, "sample size", 0, + qtdemux_dump_stsz }, + { FOURCC_stco, "chunk offset", 0, + qtdemux_dump_stco }, + { FOURCC_co64, "64-bit chunk offset", 0, + qtdemux_dump_co64 }, + { FOURCC_vide, "video media", 0 }, + { 0, "unknown", 0 }, +}; +static int n_qt_node_types = sizeof(qt_node_types)/sizeof(qt_node_types[0]); + + + +static void qtdemux_parse_moov(GstQTDemux *qtdemux, void *buffer, int length) { - GstBuffer * buf; - GstByteStream * bs = qtdemux->bs; - do { - if (gst_bytestream_read (bs, &buf, size) == size) { - qtdemux->bs_pos += size; - return buf; - } - } while (gst_qtdemux_handle_event (qtdemux)); - return NULL; + + qtdemux->moov_node = g_node_new(buffer); + + qtdemux_parse(qtdemux, qtdemux->moov_node, buffer, length); + } -/* - * skips some input (e.g. to ignore unknown atom) - */ -static gboolean -gst_qtp_skip(GstQTDemux * qtdemux, guint64 skip) +static void qtdemux_parse(GstQTDemux *qtdemux, GNode *node, void *buffer, int length) { - GstByteStream * bs = qtdemux->bs; + guint32 fourcc; + guint32 node_length; + QtNodeType *type; + void *end; + + //g_print("qtdemux_parse %p %d\n",buffer, length); + + node_length = GUINT32_FROM_BE(*(guint32 *)buffer); + fourcc = GUINT32_FROM_LE(*(guint32 *)(buffer+4)); + + type = qtdemux_type_get(fourcc); - if (skip) { - gst_bytestream_flush(bs,skip); - qtdemux->bs_pos += skip; + //g_print("parsing '" GST_FOURCC_FORMAT "', length=%d\n", + //GST_FOURCC_ARGS(fourcc), node_length); + + if(type->flags & QT_CONTAINER){ + void *buf; + guint32 len; + + buf = buffer + 8; + end = buffer + length; + while(buf < end){ + GNode *child; + + if(buf + 8 >= end){ + /* FIXME: get annoyed */ + g_print("buffer overrun\n"); + } + len = GUINT32_FROM_BE(*(guint32 *)buf); + + child = g_node_new(buf); + g_node_append(node, child); + qtdemux_parse(qtdemux, child, buf, len); + + buf += len; + } + }else{ + //g_print("not container\n"); + } - return TRUE; } -/* convenience function for skipping the given atom */ -static gboolean -gst_qtp_skip_atom(GstQTDemux * qtdemux, GstQtpAtom * atom) +static QtNodeType *qtdemux_type_get(guint32 fourcc) { - if (qtdemux->bs_pos < atom->start + atom->size) { - guint64 skip = atom->start + atom->size - qtdemux->bs_pos; - return gst_qtp_skip(qtdemux,skip); - } else - return FALSE; + int i; + + for(i=0;i<n_qt_node_types;i++){ + if(qt_node_types[i].fourcc == fourcc) + return qt_node_types+i; + } + return qt_node_types+n_qt_node_types-1; } -/* skips the container with type 'type' if finds it in the nesting stack */ -static gboolean -gst_qtp_skip_container(GstQTDemux * qtdemux, guint32 type) +static gboolean qtdemux_node_dump_foreach(GNode *node, gpointer data) { - GSList * iter = qtdemux->nested; + void *buffer = node->data; + guint32 node_length; + guint32 fourcc; + QtNodeType *type; + int depth; - while (iter && ((GstQtpAtom*)(iter->data))->type != type) - iter = iter->next; + node_length = GUINT32_FROM_BE(*(guint32 *)buffer); + fourcc = GUINT32_FROM_LE(*(guint32 *)(buffer+4)); - if (iter) - return gst_qtp_skip_atom(qtdemux,(GstQtpAtom*)iter->data); - else - return FALSE; + type = qtdemux_type_get(fourcc); + + depth = (g_node_depth(node)-1)*2; + g_print("%*s'" GST_FOURCC_FORMAT "', [%d], %s\n", + depth, "", + GST_FOURCC_ARGS(fourcc), + node_length, + type->name); + + if(type->dump)type->dump(data, buffer, depth); + + return FALSE; } -static gint -gst_guint32_compare(gconstpointer a, gconstpointer b) +static void qtdemux_node_dump(GstQTDemux *qtdemux, GNode *node) { - if ((guint32*)a < (guint32*)b) - return -1; - else if ((guint32*)a > (guint32*)b) - return 1; - else - return 0; + g_node_traverse(qtdemux->moov_node, G_PRE_ORDER, G_TRAVERSE_ALL, -1, + qtdemux_node_dump_foreach, qtdemux); } -static void -gst_qtp_trak_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter) -{ - if (enter) { /* enter trak */ - GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_trak_handler: enter\n"); - track_to_be = malloc(sizeof(GstQtpTrack)); - track_to_be->stsd = NULL; - track_to_be->stts = NULL; - track_to_be->stsc = NULL; - track_to_be->stsz = NULL; - track_to_be->stco = NULL; - track_to_be->samples = NULL; - track_to_be->pad = NULL; - } else { /* leave trak */ - GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_trak_handler: leave\n"); - if (track_to_be) { /* if we didnt discard this track earlier */ - GstQtpStscRec * stsc; - guint32 * stsz, * stco, offset; - int chunk,sample,nchunks,nsamples,stsc_idx,nstsc; - GstCaps * newcaps = NULL; - - /* process sample tables */ - - /* - * FIXME have to check which sample tables are present and which are not - * and skip the track if there's not enough tables or set default values - * if some optional tables are missing - */ - - /* - * FIXME i assume that there's only one of each stsd record and stts - * record in the tables that's not always true, this must be changed - * later, as soon as i encounter qt file with bigger tables. - */ - track_to_be->format = ((GstQtpStsdRec*)GST_BUFFER_DATA(track_to_be->stsd))->format; - GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_trak_handler: format: %c%c%c%c\n",GST_FOURCC_TO_CHARSEQ(track_to_be->format)); - track_to_be->sample_duration = GUINT32_FROM_BE(((GstQtpSttsRec*)GST_BUFFER_DATA(track_to_be->stts))->duration); - GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_trak_handler: sample duration: %d\n",track_to_be->sample_duration); - /* - * depending on format we can decide to refuse this track all together - * if we don't know what for format that it. - */ - switch (track_to_be->format) { - case GST_MAKE_FOURCC('j','p','e','g'): - track_to_be->pad = gst_pad_new_from_template( - GST_PAD_TEMPLATE_GET(src_video_templ), - g_strdup_printf("video_%02d",qtdemux->num_video_pads++)); - newcaps = GST_CAPS_NEW( - "qtdemux_video_src", - "video/jpeg", - "width", GST_PROPS_INT(track_to_be->width), - "height", GST_PROPS_INT(track_to_be->height)); - gst_pad_try_set_caps(track_to_be->pad,newcaps); - gst_element_add_pad(GST_ELEMENT(qtdemux),track_to_be->pad); - break; - } +#define QTDEMUX_GUINT32_GET(a) GUINT32_FROM_BE(*(guint32 *)(a)) +#define QTDEMUX_GUINT16_GET(a) GUINT16_FROM_BE(*(guint16 *)(a)) +#define QTDEMUX_GUINT8_GET(a) (*(guint8 *)(a)) +#define QTDEMUX_FP32_GET(a) (GUINT32_FROM_BE(*(guint16 *)(a))/65536.0) +#define QTDEMUX_FP16_GET(a) (GUINT16_FROM_BE(*(guint16 *)(a))/256.0) +#define QTDEMUX_FOURCC_GET(a) GUINT32_FROM_LE(*(guint32 *)(a)) - /* - * now let's find all about individual samples and put them into samples - * tree - */ - if (!qtdemux->samples) { - qtdemux->samples = g_tree_new(gst_guint32_compare); - } - stsc = (GstQtpStscRec*)GST_BUFFER_DATA(track_to_be->stsc); - stsz = (guint32*)GST_BUFFER_DATA(track_to_be->stsz); - stco = (guint32*)GST_BUFFER_DATA(track_to_be->stco); - nchunks = GST_BUFFER_SIZE(track_to_be->stco)/sizeof(guint32); - nsamples = GST_BUFFER_SIZE(track_to_be->stsz)/sizeof(guint32); - nstsc = GST_BUFFER_SIZE(track_to_be->stsc)/sizeof(GstQtpStscRec); - - track_to_be->samples = malloc(nsamples*sizeof(GstQtpSample)); - for(chunk=0,sample=0,stsc_idx=0; - chunk<nchunks; - chunk++) { - int i; - offset = GUINT32_FROM_BE(stco[chunk]); - if (stsc_idx+1<nstsc && chunk+1==GUINT32_FROM_BE(stsc[stsc_idx+1].first_chunk)) { - stsc_idx++; - } - for(i=0;i<GUINT32_FROM_BE(stsc[stsc_idx].samples_per_chunk);i++,sample++) { - guint32 size = GUINT32_FROM_BE(stsz[sample]); - track_to_be->samples[sample].offset = offset; - track_to_be->samples[sample].size = size; - track_to_be->samples[sample].timestamp = sample*((1000000*track_to_be->sample_duration)/track_to_be->time_scale); - track_to_be->samples[sample].track = track_to_be; - g_tree_insert(qtdemux->samples,&(track_to_be->samples[sample].offset),&(track_to_be->samples[sample])); - offset += size; - } - } +#define QTDEMUX_GUINT64_GET(a) ((((guint64)QTDEMUX_GUINT32_GET(a))<<32)|QTDEMUX_GUINT32_GET(((void *)a)+4)) - GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_trak_handler: trak added to the list\n"); - qtdemux->tracks = g_list_prepend(qtdemux->tracks,track_to_be); +static void qtdemux_dump_mvhd(GstQTDemux *qtdemux, void *buffer, int depth) +{ + g_print("%*s version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8)); + g_print("%*s creation time: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12)); + g_print("%*s modify time: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+16)); + g_print("%*s time scale: 1/%u sec\n", depth, "", QTDEMUX_GUINT32_GET(buffer+20)); + g_print("%*s duration: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+24)); + g_print("%*s pref. rate: %g\n", depth, "", QTDEMUX_FP32_GET(buffer+28)); + g_print("%*s pref. volume: %g\n", depth, "", QTDEMUX_FP16_GET(buffer+32)); + g_print("%*s preview time: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+80)); + g_print("%*s preview dur.: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+84)); + g_print("%*s poster time: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+88)); + g_print("%*s select time: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+92)); + g_print("%*s select dur.: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+96)); + g_print("%*s current time: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+100)); + g_print("%*s next track ID: %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+104)); +} - gst_buffer_unref(track_to_be->stsd); - gst_buffer_unref(track_to_be->stts); - gst_buffer_unref(track_to_be->stsc); - gst_buffer_unref(track_to_be->stsz); - gst_buffer_unref(track_to_be->stco); - track_to_be = 0; - } +static void qtdemux_dump_tkhd(GstQTDemux *qtdemux, void *buffer, int depth) +{ + g_print("%*s version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8)); + g_print("%*s creation time: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12)); + g_print("%*s modify time: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+16)); + g_print("%*s track ID: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+20)); + g_print("%*s duration: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+28)); + g_print("%*s layer: %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+36)); + g_print("%*s alt group: %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+38)); + g_print("%*s volume: %g\n", depth, "", QTDEMUX_FP16_GET(buffer+44)); + g_print("%*s track width: %g\n", depth, "", QTDEMUX_FP32_GET(buffer+84)); + g_print("%*s track height: %g\n", depth, "", QTDEMUX_FP32_GET(buffer+88)); + +} + +static void qtdemux_dump_elst(GstQTDemux *qtdemux, void *buffer, int depth) +{ + int i; + int n; + + g_print("%*s version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8)); + g_print("%*s n entries: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12)); + n = QTDEMUX_GUINT32_GET(buffer+12); + for(i=0;i<n;i++){ + g_print("%*s track dur: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+16+i*12)); + g_print("%*s media time: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+20+i*12)); + g_print("%*s media rate: %g\n", depth, "", QTDEMUX_FP32_GET(buffer+24+i*12)); } } -/* - * weird formats they apple guys are using - * weird conversion copied from openquicktime - * FIXME either it can be done more beautiful/fast way or this fixme has to go - */ -static float -fixed32_to_float(guint32 fixed) +static void qtdemux_dump_mdhd(GstQTDemux *qtdemux, void *buffer, int depth) { - unsigned char * data = (unsigned char*)&fixed; - guint32 a, b, c, d; - a = data[0]; - b = data[1]; - c = data[2]; - d = data[3]; - a = (a << 8) + b; - b = (c << 8) + d; - return (float)a + (float)b / 65536; + g_print("%*s version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8)); + g_print("%*s creation time: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12)); + g_print("%*s modify time: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+16)); + g_print("%*s time scale: 1/%u sec\n", depth, "", QTDEMUX_GUINT32_GET(buffer+20)); + g_print("%*s duration: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+24)); + g_print("%*s language: %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+28)); + g_print("%*s quality: %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+30)); + } -static void -gst_qtp_tkhd_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter) +static void qtdemux_dump_hdlr(GstQTDemux *qtdemux, void *buffer, int depth) { - guint32 wh[2]; - /* if we get here track_to_be must be not NULL */ - g_assert(track_to_be); + g_print("%*s version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8)); + g_print("%*s type: " GST_FOURCC_FORMAT "\n", depth, "", + GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(buffer+12))); + g_print("%*s subtype: " GST_FOURCC_FORMAT "\n", depth, "", + GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(buffer+16))); + g_print("%*s manufacturer: " GST_FOURCC_FORMAT "\n", depth, "", + GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(buffer+20))); + g_print("%*s flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+24)); + g_print("%*s flags mask: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+28)); + g_print("%*s name: %*s\n", depth, "", + QTDEMUX_GUINT8_GET(buffer+32), (char *)(buffer+33)); - gst_qtp_skip(qtdemux,76); /* don't need those values */ - gst_qtp_read_bytes(qtdemux,wh,8); - track_to_be->width = (guint32) fixed32_to_float(wh[0]); - track_to_be->height = (guint32) fixed32_to_float(wh[1]); - GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_tkhd_handler: track dimmensions: %dx%d\n",track_to_be->width,track_to_be->height); } -static void -gst_qtp_hdlr_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter) +static void qtdemux_dump_vmhd(GstQTDemux *qtdemux, void *buffer, int depth) { - guint32 a[3]; + g_print("%*s version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8)); + g_print("%*s mode/color: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+16)); +} - gst_qtp_read_bytes(qtdemux,a,12); - GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_hdlr_handler: %c%c%c%c %c%c%c%c\n",GST_FOURCC_TO_CHARSEQ(a[1]),GST_FOURCC_TO_CHARSEQ(a[2])); - if (a[1]==GST_MAKE_FOURCC('m','h','l','r') && a[2]!=GST_MAKE_FOURCC('v','i','d','e')) { - GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_hdlr_handler: rejecting the track\n"); - /* forget about this track! */ - free(track_to_be); - track_to_be = NULL; - gst_qtp_skip_container(qtdemux,GST_MAKE_FOURCC('t','r','a','k')); +static void qtdemux_dump_dref(GstQTDemux *qtdemux, void *buffer, int depth) +{ + int n; + int i; + int offset; + + g_print("%*s version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8)); + g_print("%*s n entries: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12)); + n = QTDEMUX_GUINT32_GET(buffer+12); + offset = 16; + for(i=0;i<n;i++){ + g_print("%*s size: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset)); + g_print("%*s type: " GST_FOURCC_FORMAT "\n", depth, "", + GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(buffer+offset+4))); + offset += QTDEMUX_GUINT32_GET(buffer+offset); } - return; } -static void -gst_qtp_stsd_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter) +static void qtdemux_dump_stsd(GstQTDemux *qtdemux, void *buffer, int depth) { - guint32 a[2]; - gst_qtp_read_bytes(qtdemux,a,8); - GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_stsd_handler: %d entries in the table\n",GUINT32_FROM_BE(a[1])); - /* just put the rest of the atom into sample description table */ - track_to_be->stsd = gst_qtp_read(qtdemux,atom->start + atom->size - qtdemux->bs_pos); + int i; + int n; + int offset; + + g_print("%*s version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8)); + g_print("%*s n entries: %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12)); + n = QTDEMUX_GUINT32_GET(buffer+12); + offset = 16; + for(i=0;i<n;i++){ + g_print("%*s size: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset)); + g_print("%*s type: " GST_FOURCC_FORMAT "\n", depth, "", + GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(buffer+offset+4))); + g_print("%*s data reference:%d\n", depth, "", QTDEMUX_GUINT16_GET(buffer+offset+14)); + + g_print("%*s version/rev.: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset+16)); + g_print("%*s vendor: " GST_FOURCC_FORMAT "\n", depth, "", + GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(buffer+offset+20))); + g_print("%*s temporal qual: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset+24)); + g_print("%*s spatial qual: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset+28)); + g_print("%*s width: %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+offset+32)); + g_print("%*s height: %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+offset+34)); + g_print("%*s horiz. resol: %g\n", depth, "", QTDEMUX_FP32_GET(buffer+offset+36)); + g_print("%*s vert. resol.: %g\n", depth, "", QTDEMUX_FP32_GET(buffer+offset+40)); + g_print("%*s data size: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset+44)); + g_print("%*s frame count: %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+offset+48)); + g_print("%*s compressor: %*s\n", depth, "", + QTDEMUX_GUINT8_GET(buffer+offset+49), (char *)(buffer+offset+51)); + g_print("%*s depth: %u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+offset+82)); + g_print("%*s color table ID:%u\n", depth, "", QTDEMUX_GUINT16_GET(buffer+offset+84)); + + offset += QTDEMUX_GUINT32_GET(buffer+offset); + } } -static void -gst_qtp_stts_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter) +static void qtdemux_dump_stts(GstQTDemux *qtdemux, void *buffer, int depth) { - guint32 a[2]; - gst_qtp_read_bytes(qtdemux,a,8); - GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_stts_handler: %d entries in the table\n",GUINT32_FROM_BE(a[1])); - track_to_be->stts = gst_qtp_read(qtdemux,GUINT32_FROM_BE(a[1])*sizeof(GstQtpSttsRec)); + int i; + int n; + int offset; + + g_print("%*s version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8)); + g_print("%*s n entries: %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12)); + n = QTDEMUX_GUINT32_GET(buffer+12); + offset = 16; + for(i=0;i<n;i++){ + g_print("%*s count: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset)); + g_print("%*s duration: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset + 4)); + + offset += 8; + } } -static void -gst_qtp_stsc_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter) + +static void qtdemux_dump_stss(GstQTDemux *qtdemux, void *buffer, int depth) { - guint32 a[2]; - gst_qtp_read_bytes(qtdemux,a,8); - GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_stsc_handler: %d entries in the table\n",GUINT32_FROM_BE(a[1])); - track_to_be->stsc = gst_qtp_read(qtdemux,GUINT32_FROM_BE(a[1])*sizeof(GstQtpStscRec)); + int i; + int n; + int offset; + + g_print("%*s version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8)); + g_print("%*s n entries: %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12)); + n = QTDEMUX_GUINT32_GET(buffer+12); + offset = 16; + for(i=0;i<n;i++){ + g_print("%*s sample: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset)); + + offset += 4; + } } -static void -gst_qtp_stsz_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter) +static void qtdemux_dump_stsc(GstQTDemux *qtdemux, void *buffer, int depth) { - guint32 a[3]; - gst_qtp_read_bytes(qtdemux,a,12); - GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_stsz_handler: %d entries in the table\n",GUINT32_FROM_BE(a[2])); - /* FIXME have to chech a[2], it contains size if all samples if they are the same size */ - track_to_be->stsz = gst_qtp_read(qtdemux,GUINT32_FROM_BE(a[2])*sizeof(guint32)); + int i; + int n; + int offset; + + g_print("%*s version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8)); + g_print("%*s n entries: %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12)); + n = QTDEMUX_GUINT32_GET(buffer+12); + offset = 16; + for(i=0;i<n;i++){ + g_print("%*s first chunk: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset)); + g_print("%*s sample per ch: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset+4)); + g_print("%*s sample desc id:%08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset+8)); + + offset += 12; + } } -static void -gst_qtp_stco_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter) +static void qtdemux_dump_stsz(GstQTDemux *qtdemux, void *buffer, int depth) { - guint32 a[2]; - gst_qtp_read_bytes(qtdemux,a,8); - GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_stco_handler: %d entries in the table\n",GUINT32_FROM_BE(a[1])); - track_to_be->stco = gst_qtp_read(qtdemux,GUINT32_FROM_BE(a[1])*sizeof(guint32)); + int i; + int n; + int offset; + int sample_size; + + g_print("%*s version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8)); + g_print("%*s sample size: %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12)); + sample_size = QTDEMUX_GUINT32_GET(buffer+12); + if(sample_size == 0){ + g_print("%*s n entries: %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+16)); + n = QTDEMUX_GUINT32_GET(buffer+16); + offset = 20; + for(i=0;i<n;i++){ + g_print("%*s sample size: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset)); + + offset += 4; + } + } } -static void -gst_qtp_mdhd_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter) +static void qtdemux_dump_stco(GstQTDemux *qtdemux, void *buffer, int depth) { - guint32 a[4]; - gst_qtp_read_bytes(qtdemux,a,16); - track_to_be->time_scale = GUINT32_FROM_BE(a[3]); - GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtp_mdhd_handler: time scale: %d\n",track_to_be->time_scale); + int i; + int n; + int offset; + + g_print("%*s version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8)); + g_print("%*s n entries: %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12)); + n = QTDEMUX_GUINT32_GET(buffer+12); + offset = 16; + for(i=0;i<n;i++){ + g_print("%*s chunk offset: %u\n", depth, "", QTDEMUX_GUINT32_GET(buffer+offset)); + + offset += 4; + } } -static gboolean -gst_qtp_traverse(gpointer poffs,gpointer value,gpointer data) -{ - GstQtpSample * sample = (GstQtpSample*)value; - GstQTDemux * qtdemux = (GstQTDemux*)data; - - if (qtdemux->bs_pos < sample->offset) { - gst_qtp_skip(qtdemux,sample->offset - qtdemux->bs_pos); - if (sample->track->pad && GST_PAD_IS_LINKED(sample->track->pad)) { - GstBuffer * buf; - buf = gst_qtp_read(qtdemux,sample->size); - GST_BUFFER_TIMESTAMP(buf) = sample->timestamp; - gst_pad_push(sample->track->pad,buf); +static void qtdemux_dump_co64(GstQTDemux *qtdemux, void *buffer, int depth) +{ + int i; + int n; + int offset; + + g_print("%*s version/flags: %08x\n", depth, "", QTDEMUX_GUINT32_GET(buffer+8)); + g_print("%*s n entries: %d\n", depth, "", QTDEMUX_GUINT32_GET(buffer+12)); + n = QTDEMUX_GUINT32_GET(buffer+12); + offset = 16; + for(i=0;i<n;i++){ + g_print("%*s chunk offset: %" G_GUINT64_FORMAT "\n", depth, "", QTDEMUX_GUINT64_GET(buffer+offset)); + + offset += 8; + } +} + + +static GNode *qtdemux_tree_get_child_by_type(GNode *node, guint32 fourcc) +{ + GNode *child; + void *buffer; + guint32 child_fourcc; + + for(child = g_node_first_child(node); child; child = g_node_next_sibling(child)){ + buffer = child->data; + + child_fourcc = GUINT32_FROM_LE(*(guint32 *)(buffer+4)); + + if(child_fourcc == fourcc){ + return child; + } + } + return NULL; +} + +static GNode *qtdemux_tree_get_sibling_by_type(GNode *node, guint32 fourcc) +{ + GNode *child; + void *buffer; + guint32 child_fourcc; + + for(child = g_node_next_sibling(node); child; child = g_node_next_sibling(child)){ + buffer = child->data; + + child_fourcc = GUINT32_FROM_LE(*(guint32 *)(buffer+4)); + + if(child_fourcc == fourcc){ + return child; + } + } + return NULL; +} + +static void qtdemux_parse_trak(GstQTDemux *qtdemux, GNode *trak); + +static void qtdemux_parse_tree(GstQTDemux *qtdemux) +{ + GNode *mvhd; + GNode *trak; + + mvhd = qtdemux_tree_get_child_by_type(qtdemux->moov_node, FOURCC_mvhd); + + qtdemux->timescale = QTDEMUX_GUINT32_GET(mvhd->data + 20); + qtdemux->duration = QTDEMUX_GUINT32_GET(mvhd->data + 24); + + g_print("timescale: %d\n", qtdemux->timescale); + g_print("duration: %d\n", qtdemux->duration); + + trak = qtdemux_tree_get_child_by_type(qtdemux->moov_node, FOURCC_trak); + qtdemux_parse_trak(qtdemux, trak); + + trak = qtdemux_tree_get_sibling_by_type(trak, FOURCC_trak); + if(trak)qtdemux_parse_trak(qtdemux, trak); +} + +static void qtdemux_parse_trak(GstQTDemux *qtdemux, GNode *trak) +{ + int offset; + GNode *tkhd; + GNode *mdia; + GNode *mdhd; + GNode *hdlr; + GNode *minf; + GNode *stbl; + GNode *stsd; + GNode *stsc; + GNode *stsz; + GNode *stco; + GNode *co64; + GNode *stts; + int n_samples; + QtDemuxSample *samples; + int n_samples_per_chunk; + int index; + int i,j,k; + QtDemuxStream *stream; + int n_sample_times; + guint64 timestamp; + int sample_size; + int sample_index; + + stream = g_new0(QtDemuxStream,1); + + tkhd = qtdemux_tree_get_child_by_type(trak, FOURCC_tkhd); + g_assert(tkhd); + + /* track duration? */ + + //g_print("track duration: %u\n", QTDEMUX_GUINT32_GET(buffer+28)); + + g_print("track width: %g\n", QTDEMUX_FP32_GET(tkhd->data+84)); + g_print("track height: %g\n", QTDEMUX_FP32_GET(tkhd->data+88)); + + mdia = qtdemux_tree_get_child_by_type(trak, FOURCC_mdia); + g_assert(mdia); + + mdhd = qtdemux_tree_get_child_by_type(mdia, FOURCC_mdhd); + g_assert(mdhd); + + g_print("track time scale: %d\n", QTDEMUX_GUINT32_GET(mdhd->data+20)); + stream->timescale = QTDEMUX_GUINT32_GET(mdhd->data+20); + //g_print("track height: %g\n", QTDEMUX_FP32_GET(mdhd->data+88)); + + hdlr = qtdemux_tree_get_child_by_type(mdia, FOURCC_hdlr); + g_assert(hdlr); + + g_print("track type: " GST_FOURCC_FORMAT "\n", + GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(hdlr->data+12))); + g_print("track subtype: " GST_FOURCC_FORMAT "\n", + GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(hdlr->data+16))); + + stream->subtype = QTDEMUX_FOURCC_GET(hdlr->data+16); + + minf = qtdemux_tree_get_child_by_type(mdia, FOURCC_minf); + g_assert(minf); + + stbl = qtdemux_tree_get_child_by_type(minf, FOURCC_stbl); + g_assert(stbl); + + stsd = qtdemux_tree_get_child_by_type(stbl, FOURCC_stsd); + g_assert(stsd); + + if(stream->subtype == FOURCC_vide){ + offset = 16; + g_print("st type: " GST_FOURCC_FORMAT "\n", + GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(stsd->data+offset+4))); + + g_print("width: %u\n", QTDEMUX_GUINT16_GET(stsd->data+offset+32)); + g_print("height: %u\n", QTDEMUX_GUINT16_GET(stsd->data+offset+34)); + + //g_print("data size: %u\n", QTDEMUX_GUINT32_GET(stsd->data+offset+44)); + //g_print("frame count: %u\n", QTDEMUX_GUINT16_GET(stsd->data+offset+48)); + + //g_print("compressor: %*s\n", QTDEMUX_GUINT8_GET(stsd->data+offset+49), (char *)(stsd->data+offset+51)); + + stream->caps = qtdemux_video_caps(qtdemux, + QTDEMUX_FOURCC_GET(stsd->data+offset+4)); + g_print("caps %s\n",gst_caps_to_string(stream->caps)); + }else if(stream->subtype == FOURCC_soun){ + g_print("st type: " GST_FOURCC_FORMAT "\n", + GST_FOURCC_ARGS(QTDEMUX_FOURCC_GET(stsd->data+16+4))); + + offset = 32; + g_print("version/rev: %08x\n", QTDEMUX_GUINT32_GET(stsd->data+offset)); + g_print("vendor: %08x\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 4)); + g_print("n_channels: %d\n", QTDEMUX_GUINT16_GET(stsd->data+offset + 8)); + g_print("sample_size: %d\n", QTDEMUX_GUINT16_GET(stsd->data+offset + 10)); + g_print("compression_id: %d\n", QTDEMUX_GUINT16_GET(stsd->data+offset + 12)); + g_print("packet size: %d\n", QTDEMUX_GUINT16_GET(stsd->data+offset + 14)); + g_print("sample rate: %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 16)); + + g_print("samples/packet: %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 20)); + g_print("bytes/packet: %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 24)); + g_print("bytes/frame: %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 28)); + g_print("bytes/sample: %d\n", QTDEMUX_GUINT32_GET(stsd->data+offset + 32)); + + stream->caps = qtdemux_audio_caps(qtdemux, + QTDEMUX_FOURCC_GET(stsd->data+16+4)); + g_print("caps %s\n",gst_caps_to_string(stream->caps)); + }else{ + g_print("unknown subtype\n"); + return; + } + + /* sample to chunk */ + stsc = qtdemux_tree_get_child_by_type(stbl, FOURCC_stsc); + g_assert(stsc); + /* sample size */ + stsz = qtdemux_tree_get_child_by_type(stbl, FOURCC_stsz); + g_assert(stsz); + /* chunk offsets */ + stco = qtdemux_tree_get_child_by_type(stbl, FOURCC_stco); + co64 = qtdemux_tree_get_child_by_type(stbl, FOURCC_co64); + g_assert(stco || co64); + /* sample time */ + stts = qtdemux_tree_get_child_by_type(stbl, FOURCC_stts); + g_assert(stts); + + sample_size = QTDEMUX_GUINT32_GET(stsz->data+12); + if(sample_size == 0){ + n_samples = QTDEMUX_GUINT32_GET(stsz->data+16); + stream->n_samples = n_samples; + samples = g_malloc(sizeof(QtDemuxSample)*n_samples); + stream->samples = samples; + + for(i=0;i<n_samples;i++){ + samples[i].size = QTDEMUX_GUINT32_GET(stsz->data + i*4 + 20); + } + n_samples_per_chunk = QTDEMUX_GUINT32_GET(stsc->data+12); + index = 0; + offset = 16; + for(i=0;i<n_samples_per_chunk;i++){ + int first_chunk, last_chunk; + int samples_per_chunk; + + first_chunk = QTDEMUX_GUINT32_GET(stsc->data + 16 + i*12 + 0) - 1; + if(i==n_samples_per_chunk-1){ + last_chunk = INT_MAX; + }else{ + last_chunk = QTDEMUX_GUINT32_GET(stsc->data +16 + i*12 + 12) - 1; + } + samples_per_chunk = QTDEMUX_GUINT32_GET(stsc->data + 16 + i*12 + 4); + + for(j=first_chunk;j<last_chunk;j++){ + int chunk_offset; + if(stco){ + chunk_offset = QTDEMUX_GUINT32_GET(stco->data + 16 + j*4); + }else{ + chunk_offset = QTDEMUX_GUINT64_GET(co64->data + 16 + j*8); + } + for(k=0;k<samples_per_chunk;k++){ + samples[index].chunk = j; + samples[index].offset = chunk_offset; + chunk_offset += samples[index].size; + index++; + if(index>=n_samples)goto done; + } + } + } +done: + + n_sample_times = QTDEMUX_GUINT32_GET(stts->data + 12); + timestamp = 0; + index = 0; + for(i=0;i<n_sample_times;i++){ + int n; + int duration; + guint64 time; + + n = QTDEMUX_GUINT32_GET(stts->data + 16 + 8*i); + duration = QTDEMUX_GUINT32_GET(stts->data + 16 + 8*i + 4); + time = (GST_SECOND * duration)/stream->timescale; + for(j=0;j<n;j++){ + samples[index].timestamp = timestamp; + timestamp += time; + index++; + } + } + }else{ + g_print("treating chunks as samples\n"); + + /* treat chunks as samples */ + if(stco){ + n_samples = QTDEMUX_GUINT32_GET(stco->data+12); + }else{ + n_samples = QTDEMUX_GUINT32_GET(co64->data+12); + } + stream->n_samples = n_samples; + samples = g_malloc(sizeof(QtDemuxSample)*n_samples); + stream->samples = samples; + + n_samples_per_chunk = QTDEMUX_GUINT32_GET(stsc->data+12); + offset = 16; + sample_index = 0; + for(i=0;i<n_samples_per_chunk;i++){ + int first_chunk, last_chunk; + int samples_per_chunk; + + first_chunk = QTDEMUX_GUINT32_GET(stsc->data + 16 + i*12 + 0) - 1; + if(i==n_samples-1){ + last_chunk = INT_MAX; + }else{ + last_chunk = QTDEMUX_GUINT32_GET(stsc->data +16 + i*12 + 12) - 1; + } + samples_per_chunk = QTDEMUX_GUINT32_GET(stsc->data + 16 + i*12 + 4); + + for(j=first_chunk;j<last_chunk;j++){ + int chunk_offset; + if(stco){ + chunk_offset = QTDEMUX_GUINT32_GET(stco->data + 16 + j*4); + }else{ + chunk_offset = QTDEMUX_GUINT64_GET(co64->data + 16 + j*8); + } + samples[j].chunk = j; + samples[j].offset = chunk_offset; + samples[j].size = samples_per_chunk; /* FIXME */ + samples[j].sample_index = sample_index; + sample_index += samples_per_chunk; + if(j>=n_samples)goto done2; + } } +done2: + + n_sample_times = QTDEMUX_GUINT32_GET(stts->data + 12); + g_print("n_sample_times = %d\n",n_sample_times); + timestamp = 0; + index = 0; + sample_index = 0; + for(i=0;i<n_sample_times;i++){ + int duration; + guint64 time; + + sample_index += QTDEMUX_GUINT32_GET(stts->data + 16 + 8*i); + duration = QTDEMUX_GUINT32_GET(stts->data + 16 + 8*i + 4); + for(;index < n_samples && samples[index].sample_index < sample_index;index++){ + int size; + + samples[index].timestamp = timestamp; + size = samples[index+1].sample_index - samples[index].sample_index; + time = (GST_SECOND * duration * samples[index].size)/stream->timescale ; + timestamp += time; + } + } + } + + + for(i=0;i<n_samples;i++){ + g_print("%d: %d %d %d %d %" G_GUINT64_FORMAT "\n",i, + samples[i].sample_index,samples[i].chunk, + samples[i].offset, samples[i].size, samples[i].timestamp); + if(i>10)break; + } + + gst_qtdemux_add_stream(qtdemux,stream); +} + + +static GstCaps *qtdemux_video_caps(GstQTDemux *qtdemux, guint32 fourcc) +{ + switch(fourcc){ + case GST_MAKE_FOURCC('3','I','V','1'): + return GST_CAPS_NEW("3IV1_caps","video/x-quicktime-3IV1",NULL); + case GST_MAKE_FOURCC('j','p','e','g'): + /* JPEG */ + return GST_CAPS_NEW("jpeg_caps","video/jpeg",NULL); + case GST_MAKE_FOURCC('m','j','p','a'): + /* Motion-JPEG (format A) */ + return GST_CAPS_NEW("mjpa_caps","video/x-mjpeg",NULL); + case GST_MAKE_FOURCC('m','j','p','b'): + /* Motion-JPEG (format B) */ + return GST_CAPS_NEW("mjpa_caps","video/x-mjpeg",NULL); + case GST_MAKE_FOURCC('S','V','Q','3'): + return GST_CAPS_NEW("SVQ3_caps","video/x-svq", + "svqversion", GST_PROPS_INT(3),NULL); + case GST_MAKE_FOURCC('s','v','q','i'): + case GST_MAKE_FOURCC('S','V','Q','1'): + return GST_CAPS_NEW("SVQ1_caps","video/x-svq", + "svqversion", GST_PROPS_INT(1),NULL); + case GST_MAKE_FOURCC('r','a','w',' '): + /* uncompressed RGB */ + return GST_CAPS_NEW("raw__caps","video/raw", + "format",GST_PROPS_FOURCC(GST_MAKE_FOURCC('R','G','B',' ')), + "width",GST_PROPS_INT_RANGE(1,G_MAXINT), + "height",GST_PROPS_INT_RANGE(1,G_MAXINT)); + case GST_MAKE_FOURCC('Y','u','v','2'): + /* uncompressed YUV2 */ + return GST_CAPS_NEW("Yuv2_caps","video/raw", + "format",GST_PROPS_FOURCC(GST_MAKE_FOURCC('Y','U','V','2')), + "width",GST_PROPS_INT_RANGE(1,G_MAXINT), + "height",GST_PROPS_INT_RANGE(1,G_MAXINT)); + case GST_MAKE_FOURCC('m','p','e','g'): + /* MPEG */ + return GST_CAPS_NEW("mpeg_caps","video/mpeg",NULL); + case GST_MAKE_FOURCC('g','i','f',' '): + return GST_CAPS_NEW("gif__caps","image/gif",NULL); + case GST_MAKE_FOURCC('m','p','4','v'): + /* MPEG-4 */ + return NULL; + //return GST_CAPS_NEW("mp4v_caps", "video/mpeg",NULL); + case GST_MAKE_FOURCC('r','p','z','a'): + case GST_MAKE_FOURCC('c','v','i','d'): + /* Cinepak */ + case GST_MAKE_FOURCC('r','l','e',' '): + case GST_MAKE_FOURCC('s','m','c',' '): + case GST_MAKE_FOURCC('k','p','c','d'): + default: + g_print("Don't know how to convert fourcc '" GST_FOURCC_FORMAT + "' to caps\n", GST_FOURCC_ARGS(fourcc)); + return NULL; } - return FALSE; /* == keep going (TRUE to stop) */ } -static void -gst_qtp_mdat_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter) +static GstCaps *qtdemux_audio_caps(GstQTDemux *qtdemux, guint32 fourcc) { - /* actually playing */ - g_tree_foreach(qtdemux->samples,gst_qtp_traverse,qtdemux); + switch(fourcc){ + case GST_MAKE_FOURCC('N','O','N','E'): + return GST_CAPS_NEW("NONE_caps","audio/raw",NULL); + case GST_MAKE_FOURCC('r','a','w',' '): + /* FIXME */ + return GST_CAPS_NEW("raw__caps","audio/raw", + "format",GST_PROPS_STRING("int"), + "law", GST_PROPS_INT(0), + "width",GST_PROPS_INT(8), + "depth",GST_PROPS_INT(8), + "signed",GST_PROPS_BOOLEAN(FALSE), + "rate",GST_PROPS_INT_RANGE(1,G_MAXINT), + "channels",GST_PROPS_INT_RANGE(1,G_MAXINT)); + case GST_MAKE_FOURCC('t','w','o','s'): + /* FIXME */ + return GST_CAPS_NEW("twos_caps","audio/raw", + "format",GST_PROPS_STRING("int"), + "law", GST_PROPS_INT(0), + "width",GST_PROPS_INT(16), + "depth",GST_PROPS_INT(16), + "endianness",GST_PROPS_INT(G_BIG_ENDIAN), + "signed",GST_PROPS_BOOLEAN(TRUE)); + case GST_MAKE_FOURCC('s','o','w','t'): + /* FIXME */ + return GST_CAPS_NEW("sowt_caps","audio/raw", + "format",GST_PROPS_STRING("int"), + "law", GST_PROPS_INT(0), + "width",GST_PROPS_INT(16), + "depth",GST_PROPS_INT(16), + "endianness",GST_PROPS_INT(G_LITTLE_ENDIAN), + "signed",GST_PROPS_BOOLEAN(TRUE)); + case GST_MAKE_FOURCC('f','l','6','4'): + return GST_CAPS_NEW("fl64_caps","audio/raw", + "format",GST_PROPS_STRING("float"), + "layout",GST_PROPS_STRING("gdouble")); + case GST_MAKE_FOURCC('f','l','3','2'): + return GST_CAPS_NEW("fl32_caps","audio/raw", + "format",GST_PROPS_STRING("float"), + "layout",GST_PROPS_STRING("gfloat")); + case GST_MAKE_FOURCC('i','n','2','4'): + /* FIXME */ + return GST_CAPS_NEW("in24_caps","audio/raw", + "format",GST_PROPS_STRING("int"), + "law", GST_PROPS_INT(0), + "width",GST_PROPS_INT(24), + "depth",GST_PROPS_INT(32), + "endianness",GST_PROPS_INT(G_BIG_ENDIAN), + "signed",GST_PROPS_BOOLEAN(TRUE)); + case GST_MAKE_FOURCC('i','n','3','2'): + /* FIXME */ + return GST_CAPS_NEW("in32_caps","audio/raw", + "format",GST_PROPS_STRING("int"), + "law", GST_PROPS_INT(0), + "width",GST_PROPS_INT(24), + "depth",GST_PROPS_INT(32), + "endianness",GST_PROPS_INT(G_BIG_ENDIAN)); + case GST_MAKE_FOURCC('u','l','a','w'): + /* FIXME */ + return GST_CAPS_NEW("ulaw_caps","audio/raw", + "format",GST_PROPS_STRING("int"), + "law", GST_PROPS_INT(2)); + case GST_MAKE_FOURCC('a','l','a','w'): + /* FIXME */ + return GST_CAPS_NEW("alaw_caps","audio/raw", + "format",GST_PROPS_STRING("int"), + "law", GST_PROPS_INT(1)); + case 0x6d730002: + /* Microsoft ADPCM-ACM code 2 */ + return GST_CAPS_NEW("msxx_caps","audio/adpcm",NULL); + case 0x6d730011: + /* FIXME DVI/Intel IMA ADPCM/ACM code 17 */ + return GST_CAPS_NEW("msxx_caps","audio/adpcm",NULL); + case 0x6d730055: + /* MPEG layer 3, CBR only (pre QT4.1) */ + case GST_MAKE_FOURCC('.','m','p','3'): + /* MPEG layer 3, CBR & VBR (QT4.1 and later) */ + return GST_CAPS_NEW("msxx_caps","audio/x-mp3",NULL); + case GST_MAKE_FOURCC('d','v','c','a'): + /* DV audio */ + case GST_MAKE_FOURCC('q','t','v','r'): + /* ? */ + case GST_MAKE_FOURCC('Q','D','M','C'): + /* QDesign music */ + case GST_MAKE_FOURCC('Q','D','M','2'): + /* QDesign music version 2 (no constant) */ + case GST_MAKE_FOURCC('M','A','C','3'): + /* MACE 3:1 */ + case GST_MAKE_FOURCC('M','A','C','6'): + /* MACE 6:1 */ + case GST_MAKE_FOURCC('i','m','a','4'): + /* ? */ + case GST_MAKE_FOURCC('Q','c','l','p'): + /* QUALCOMM PureVoice */ + default: + g_print("Don't know how to convert fourcc '" GST_FOURCC_FORMAT + "' to caps\n", GST_FOURCC_ARGS(fourcc)); + return NULL; + } } + |