mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-08 21:28:45 +00:00
Original commit message from CVS: add ranks only for plugins who participate in autoplugging. If you have a file that used to autoplug but doesn't anymore, then let me know or add a rank to the missing element.
704 lines
22 KiB
C
704 lines
22 KiB
C
/* GStreamer
|
|
* Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include "qtdemux.h"
|
|
|
|
/* elementfactory information */
|
|
static GstElementDetails
|
|
gst_qtdemux_details =
|
|
{
|
|
"quicktime parser",
|
|
"Parser/Video",
|
|
"Parses a quicktime stream into audio and video substreams",
|
|
VERSION,
|
|
"A.Baguinski <artm@v2.nl>",
|
|
"(C) 2002",
|
|
};
|
|
|
|
static GstCaps* quicktime_type_find (GstBuffer *buf, gpointer private);
|
|
|
|
/* typefactory for 'quicktime' */
|
|
static GstTypeDefinition quicktimedefinition = {
|
|
"qtdemux_video/quicktime",
|
|
"video/quicktime",
|
|
".mov",
|
|
quicktime_type_find,
|
|
};
|
|
|
|
enum {
|
|
LAST_SIGNAL
|
|
};
|
|
|
|
enum {
|
|
ARG_0
|
|
};
|
|
|
|
GST_PAD_TEMPLATE_FACTORY (sink_templ,
|
|
"sink",
|
|
GST_PAD_SINK,
|
|
GST_PAD_ALWAYS,
|
|
GST_CAPS_NEW (
|
|
"qtdemux_sink",
|
|
"video/quicktime",
|
|
NULL
|
|
)
|
|
);
|
|
|
|
/*
|
|
* 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)
|
|
)
|
|
);
|
|
|
|
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} }
|
|
};
|
|
|
|
#define GST_QTP_TYPE_CNT sizeof(gst_qtp_type_table)/sizeof(GstQtpTypePair)
|
|
|
|
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 GType qtdemux_type = 0;
|
|
|
|
if (!qtdemux_type) {
|
|
static const GTypeInfo qtdemux_info = {
|
|
sizeof(GstQTDemuxClass), NULL, NULL,
|
|
(GClassInitFunc)gst_qtdemux_class_init,
|
|
NULL, NULL, sizeof(GstQTDemux), 0,
|
|
(GInstanceInitFunc)gst_qtdemux_init,
|
|
};
|
|
qtdemux_type = g_type_register_static (GST_TYPE_ELEMENT, "GstQTDemux", &qtdemux_info, 0);
|
|
}
|
|
return qtdemux_type;
|
|
}
|
|
|
|
static void
|
|
gst_qtdemux_class_init (GstQTDemuxClass *klass)
|
|
{
|
|
GObjectClass *gobject_class;
|
|
GstElementClass *gstelement_class;
|
|
int i;
|
|
|
|
gobject_class = (GObjectClass*)klass;
|
|
gstelement_class = (GstElementClass*)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_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*
|
|
quicktime_type_find (GstBuffer *buf,
|
|
gpointer private)
|
|
{
|
|
gchar *data = GST_BUFFER_DATA (buf);
|
|
|
|
/* exactly like in the old version */
|
|
if (!strncmp (&data[4], "wide", 4) ||
|
|
!strncmp (&data[4], "moov", 4) ||
|
|
!strncmp (&data[4], "mdat", 4)) {
|
|
return gst_caps_new ("quicktime_type_find",
|
|
"video/quicktime",
|
|
NULL);
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static gboolean
|
|
plugin_init (GModule *module, GstPlugin *plugin)
|
|
{
|
|
GstElementFactory *factory;
|
|
GstTypeFactory *type;
|
|
|
|
if (!gst_library_load("gstbytestream")) {
|
|
gst_info("qtdemux: could not load support library 'gstbytestream'\n");
|
|
return FALSE;
|
|
}
|
|
|
|
factory = gst_element_factory_new("qtdemux",GST_TYPE_QTDEMUX,
|
|
&gst_qtdemux_details);
|
|
g_return_val_if_fail(factory != NULL, FALSE);
|
|
gst_element_factory_set_rank (factory, GST_ELEMENT_RANK_PRIMARY);
|
|
|
|
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));
|
|
|
|
type = gst_type_factory_new (&quicktimedefinition);
|
|
gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (type));
|
|
|
|
gst_plugin_add_feature (plugin, GST_PLUGIN_FEATURE (factory));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
GstPluginDesc plugin_desc = {
|
|
GST_VERSION_MAJOR,
|
|
GST_VERSION_MINOR,
|
|
"qtdemux",
|
|
plugin_init
|
|
};
|
|
|
|
static gboolean
|
|
gst_qtdemux_handle_event (GstQTDemux * qtdemux)
|
|
{
|
|
guint32 remaining;
|
|
GstEvent * event;
|
|
GstEventType type;
|
|
|
|
gst_bytestream_get_status (qtdemux->bs,&remaining,&event);
|
|
type = event? GST_EVENT_TYPE (event) : GST_EVENT_UNKNOWN;
|
|
|
|
switch (type) {
|
|
case GST_EVENT_EOS:
|
|
gst_pad_event_default (qtdemux->sinkpad,event);
|
|
break;
|
|
case GST_EVENT_DISCONTINUOUS:
|
|
gst_bytestream_flush_fast (qtdemux->bs, remaining);
|
|
default:
|
|
gst_pad_event_default (qtdemux->sinkpad,event);
|
|
break;
|
|
}
|
|
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);
|
|
|
|
/* new track emerges here */
|
|
static GstQtpTrack * track_to_be = NULL;
|
|
|
|
/*
|
|
* - gst_qtp_* functions together with gst_qtdemux_loop implement quicktime
|
|
* parser.
|
|
*/
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
gst_qtp_read_bytes_atom_head(qtdemux,&atom);
|
|
GST_INFO (GST_CAT_PLUGIN_INFO,"gst_qtdemux_loop: atom(%c%c%c%c,%llu,%llu)\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;
|
|
}
|
|
|
|
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);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* 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 (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;
|
|
}
|
|
} else {
|
|
return TRUE;
|
|
}
|
|
}
|
|
} while (gst_qtdemux_handle_event (qtdemux));
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
gst_qtp_read_bytes(GstQTDemux * qtdemux, void * buffer, size_t size)
|
|
{
|
|
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;
|
|
}
|
|
} while (gst_qtdemux_handle_event (qtdemux));
|
|
}
|
|
|
|
static GstBuffer *
|
|
gst_qtp_read(GstQTDemux * qtdemux, size_t size)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* skips some input (e.g. to ignore unknown atom)
|
|
*/
|
|
static gboolean
|
|
gst_qtp_skip(GstQTDemux * qtdemux, guint64 skip)
|
|
{
|
|
GstByteStream * bs = qtdemux->bs;
|
|
|
|
if (skip) {
|
|
gst_bytestream_flush(bs,skip);
|
|
qtdemux->bs_pos += skip;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
/* convenience function for skipping the given atom */
|
|
static gboolean
|
|
gst_qtp_skip_atom(GstQTDemux * qtdemux, GstQtpAtom * atom)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/* skips the container with type 'type' if finds it in the nesting stack */
|
|
static gboolean
|
|
gst_qtp_skip_container(GstQTDemux * qtdemux, guint32 type)
|
|
{
|
|
GSList * iter = qtdemux->nested;
|
|
|
|
while (iter && ((GstQtpAtom*)(iter->data))->type != type)
|
|
iter = iter->next;
|
|
|
|
if (iter)
|
|
return gst_qtp_skip_atom(qtdemux,(GstQtpAtom*)iter->data);
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
gst_guint32_compare(gconstpointer a, gconstpointer b)
|
|
{
|
|
if ((guint32*)a < (guint32*)b)
|
|
return -1;
|
|
else if ((guint32*)a > (guint32*)b)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
}
|
|
}
|
|
|
|
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);
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* 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)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static void
|
|
gst_qtp_tkhd_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
|
|
{
|
|
guint32 wh[2];
|
|
/* if we get here track_to_be must be not NULL */
|
|
g_assert(track_to_be);
|
|
|
|
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)
|
|
{
|
|
guint32 a[3];
|
|
|
|
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'));
|
|
}
|
|
return;
|
|
}
|
|
|
|
static void
|
|
gst_qtp_stsd_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
|
|
{
|
|
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);
|
|
}
|
|
|
|
static void
|
|
gst_qtp_stts_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
|
|
{
|
|
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));
|
|
}
|
|
static void
|
|
gst_qtp_stsc_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
|
|
{
|
|
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));
|
|
}
|
|
|
|
static void
|
|
gst_qtp_stsz_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
|
|
{
|
|
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));
|
|
}
|
|
|
|
static void
|
|
gst_qtp_stco_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
|
|
{
|
|
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));
|
|
}
|
|
|
|
static void
|
|
gst_qtp_mdhd_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
|
|
{
|
|
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);
|
|
}
|
|
|
|
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_CONNECTED(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);
|
|
}
|
|
}
|
|
return FALSE; /* == keep going (TRUE to stop) */
|
|
}
|
|
|
|
static void
|
|
gst_qtp_mdat_handler (GstQTDemux * qtdemux,GstQtpAtom * atom,gboolean enter)
|
|
{
|
|
/* actually playing */
|
|
g_tree_foreach(qtdemux->samples,gst_qtp_traverse,qtdemux);
|
|
}
|