mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-23 18:21:04 +00:00
Code Issues 1 Projects Releases Wiki Activity

Copy qtmux from revision 148 of the gst-qtmux repository.

Browse source 
Original commit message from CVS:
patch by: Thiago Sousa Santos <thiagossantos@gmail.com>
* configure.ac:
* gst/qtmux/Makefile.am:
* gst/qtmux/atoms.c:
* gst/qtmux/atoms.h:
* gst/qtmux/descriptors.c:
* gst/qtmux/descriptors.h:
* gst/qtmux/fourcc.h:
* gst/qtmux/ftypcc.h:
* gst/qtmux/gstqtmux.c:
* gst/qtmux/gstqtmux.h:
* gst/qtmux/gstqtmuxmap.c:
* gst/qtmux/gstqtmuxmap.h:
* gst/qtmux/properties.c:
* gst/qtmux/properties.h:
Copy qtmux from revision 148 of the gst-qtmux repository.
Fixes #550280.
This commit is contained in:
Thiago Sousa Santos 2008-11-08 02:00:58 +00:00 committed by David Schleef
parent 5e8f80a9f5
commit e8d0f5e3b3
15 changed files with 6878 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
ChangeLog
View file

@ -1,3 +1,24 @@
2008-11-07 David Schleef <ds@schleef.org>
patch by: Thiago Sousa Santos <thiagossantos@gmail.com>
* configure.ac:
* gst/qtmux/Makefile.am:
* gst/qtmux/atoms.c:
* gst/qtmux/atoms.h:
* gst/qtmux/descriptors.c:
* gst/qtmux/descriptors.h:
* gst/qtmux/fourcc.h:
* gst/qtmux/ftypcc.h:
* gst/qtmux/gstqtmux.c:
* gst/qtmux/gstqtmux.h:
* gst/qtmux/gstqtmuxmap.c:
* gst/qtmux/gstqtmuxmap.h:
* gst/qtmux/properties.c:
* gst/qtmux/properties.h:
Copy qtmux from revision 148 of the gst-qtmux repository.
Fixes #550280.
2008-11-07 Wim Taymans <wim.taymans@collabora.co.uk>
* gst-libs/gst/app/gstappsrc.c: (gst_app_src_class_init),

2
configure.ac
View file

@ -255,6 +255,7 @@ AG_GST_CHECK_PLUGIN(mve)
AG_GST_CHECK_PLUGIN(nsf)
AG_GST_CHECK_PLUGIN(nuvdemux)
AG_GST_CHECK_PLUGIN(pcapparse)
AG_GST_CHECK_PLUGIN(qtmux)
AG_GST_CHECK_PLUGIN(rawparse)
AG_GST_CHECK_PLUGIN(real)
AG_GST_CHECK_PLUGIN(rtpmanager)
@ -1409,6 +1410,7 @@ gst/mve/Makefile
gst/nsf/Makefile
gst/nuvdemux/Makefile
gst/pcapparse/Makefile
gst/qtmux/Makefile
gst/rawparse/Makefile
gst/rtpmanager/Makefile
gst/scaletempo/Makefile

25
gst/qtmux/Makefile.am Normal file
View file

@ -0,0 +1,25 @@
# plugindir is set in configure
plugin_LTLIBRARIES = libgstqtmux.la
# sources used to compile this plug-in
libgstqtmux_la_SOURCES = gstqtmux.c \
atoms.c \
descriptors.c \
properties.c \
gstqtmuxmap.c
# flags used to compile this plugin
# add other _CFLAGS and _LIBS as needed
libgstqtmux_la_CFLAGS = $(GST_CFLAGS) $(GST_BASE_CFLAGS)
libgstqtmux_la_LIBADD = $(GST_LIBS) $(GST_BASE_LIBS)
libgstqtmux_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS)
# headers we need but don't want installed
noinst_HEADERS = gstqtmux.h \
atoms.h \
descriptors.h \
properties.h \
fourcc.h \
ftypcc.h \
gstqtmuxmap.h

2936
gst/qtmux/atoms.c Normal file
View file

File diff suppressed because it is too large Load diff

620
gst/qtmux/atoms.h Normal file
View file

@ -0,0 +1,620 @@
/* Quicktime muxer plugin for GStreamer
* Copyright (C) 2008 Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
*
* 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.
*/
#ifndef __ATOMS_H__
#define __ATOMS_H__
#include <glib.h>
#include <string.h>
#include "descriptors.h"
#include "properties.h"
#include "fourcc.h"
#include "ftypcc.h"
/* light-weight context that may influence header atom tree construction */
typedef enum _AtomsTreeFlavor
{
ATOMS_TREE_FLAVOR_MOV,
ATOMS_TREE_FLAVOR_ISOM
} AtomsTreeFlavor;
typedef struct _AtomsContext
{
AtomsTreeFlavor flavor;
} AtomsContext;
AtomsContext* atoms_context_new (AtomsTreeFlavor flavor);
void atoms_context_free (AtomsContext *context);
#define METADATA_DATA_FLAG 0x0
#define METADATA_TEXT_FLAG 0x1
/* atom defs and functions */
/**
* Used for storing time related values for some atoms.
*/
typedef struct _TimeInfo
{
guint64 creation_time;
guint64 modification_time;
guint32 timescale;
guint64 duration;
} TimeInfo;
typedef struct _Atom
{
guint32 size;
guint32 type;
guint64 extended_size;
} Atom;
typedef struct _AtomFull
{
Atom header;
guint8 version;
guint8 flags[3];
} AtomFull;
/*
* Generic extension atom
*/
typedef struct _AtomData
{
Atom header;
/* not written */
guint32 datalen;
guint8 *data;
} AtomData;
typedef struct _AtomFTYP
{
Atom header;
guint32 major_brand;
guint32 version;
guint32 *compatible_brands;
/* not written */
guint32 compatible_brands_size;
} AtomFTYP;
typedef struct _AtomMVHD
{
AtomFull header;
/* version 0: 32 bits */
TimeInfo time_info;
guint32 prefered_rate; /* ISO: 0x00010000 */
guint16 volume; /* ISO: 0x0100 */
guint16 reserved3; /* ISO: 0x0 */
guint32 reserved4[2]; /* ISO: 0, 0 */
/* ISO: identity matrix =
* { 0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000 } */
guint32 matrix[9];
/* ISO: all 0 */
guint32 preview_time;
guint32 preview_duration;
guint32 poster_time;
guint32 selection_time;
guint32 selection_duration;
guint32 current_time;
guint32 next_track_id;
} AtomMVHD;
typedef struct _AtomTKHD
{
AtomFull header;
/* version 0: 32 bits */
/* like the TimeInfo struct, but it has this track_ID inside */
guint64 creation_time;
guint64 modification_time;
guint32 track_ID;
guint32 reserved;
guint64 duration;
guint32 reserved2[2];
guint16 layer;
guint16 alternate_group;
guint16 volume;
guint16 reserved3;
/* ISO: identity matrix =
* { 0x00010000, 0, 0, 0, 0x00010000, 0, 0, 0, 0x40000000 } */
guint32 matrix[9];
guint32 width;
guint32 height;
} AtomTKHD;
typedef struct _AtomMDHD
{
AtomFull header;
/* version 0: 32 bits */
TimeInfo time_info;
/* ISO: packed ISO-639-2/T language code (first bit must be 0) */
guint16 language_code;
/* ISO: 0 */
guint16 quality;
} AtomMDHD;
typedef struct _AtomHDLR
{
AtomFull header;
/* ISO: 0 */
guint32 component_type;
guint32 handler_type;
guint32 manufacturer;
guint32 flags;
guint32 flags_mask;
gchar *name;
} AtomHDLR;
typedef struct _AtomVMHD
{
AtomFull header; /* ISO: flags = 1 */
guint16 graphics_mode;
/* RGB */
guint16 opcolor[3];
} AtomVMHD;
typedef struct _AtomSMHD
{
AtomFull header;
guint16 balance;
guint16 reserved;
} AtomSMHD;
typedef struct _AtomHMHD
{
AtomFull header;
guint16 max_pdu_size;
guint16 avg_pdu_size;
guint32 max_bitrate;
guint32 avg_bitrate;
guint32 sliding_avg_bitrate;
} AtomHMHD;
typedef struct _AtomURL
{
AtomFull header;
gchar *location;
} AtomURL;
typedef struct _AtomDREF
{
AtomFull header;
GList *entries;
} AtomDREF;
typedef struct _AtomDINF
{
Atom header;
AtomDREF dref;
} AtomDINF;
typedef struct _STTSEntry
{
guint32 sample_count;
gint32 sample_delta;
} STTSEntry;
typedef struct _AtomSTTS
{
AtomFull header;
guint n_entries;
/* list of STTSEntry */
GList *entries;
} AtomSTTS;
typedef struct _AtomSTSS
{
AtomFull header;
guint n_entries;
/* list of sample indexes (guint32) */
GList *entries;
} AtomSTSS;
typedef struct _AtomESDS
{
AtomFull header;
ESDescriptor es;
} AtomESDS;
typedef struct _AtomFRMA
{
Atom header;
guint32 media_type;
} AtomFRMA;
typedef enum _SampleEntryKind
{
UNKNOWN,
AUDIO,
VIDEO
} SampleEntryKind;
typedef struct _SampleTableEntry
{
Atom header;
guint8 reserved[6];
guint16 data_reference_index;
/* sort of entry */
SampleEntryKind kind;
} SampleTableEntry;
typedef struct _AtomHintSampleEntry
{
SampleTableEntry se;
guint32 size;
guint8 *data;
} AtomHintSampleEntry;
typedef struct _SampleTableEntryMP4V
{
SampleTableEntry se;
guint16 version;
guint16 revision_level;
guint32 vendor; /* fourcc code */
guint32 temporal_quality;
guint32 spatial_quality;
guint16 width;
guint16 height;
guint32 horizontal_resolution;
guint32 vertical_resolution;
guint32 datasize;
guint16 frame_count; /* usually 1 */
guint8 compressor[32]; /* pascal string, i.e. first byte = length */
guint16 depth;
guint16 color_table_id;
/* (optional) list of AtomInfo */
GList *extension_atoms;
} SampleTableEntryMP4V;
typedef struct _SampleTableEntryMP4A
{
SampleTableEntry se;
guint16 version;
guint16 revision_level;
guint32 vendor;
guint16 channels;
guint16 sample_size;
guint16 compression_id;
guint16 packet_size;
guint32 sample_rate; /* fixed point 16.16 */
guint32 samples_per_packet;
guint32 bytes_per_packet;
guint32 bytes_per_frame;
guint32 bytes_per_sample;
/* (optional) list of AtomInfo */
GList *extension_atoms;
} SampleTableEntryMP4A;
typedef struct _SampleTableEntryMP4S
{
SampleTableEntry se;
AtomESDS es;
} SampleTableEntryMP4S;
typedef struct _AtomSTSD
{
AtomFull header;
guint n_entries;
/* list of subclasses of SampleTableEntry */
GList *entries;
} AtomSTSD;
typedef struct _AtomSTSZ
{
AtomFull header;
guint32 sample_size;
/* need the size here because when sample_size is constant,
* the list is empty */
guint32 table_size;
/* list of guint32 */
GList *entries;
} AtomSTSZ;
typedef struct _STSCEntry
{
guint32 first_chunk;
guint32 samples_per_chunk;
guint32 sample_description_index;
} STSCEntry;
typedef struct _AtomSTSC
{
AtomFull header;
guint n_entries;
/* list of STSCEntry */
GList *entries;
} AtomSTSC;
/*
* used for both STCO and CO64
* if used as STCO, entries should be truncated to use only 32bits
*/
typedef struct _AtomSTCO64
{
AtomFull header;
guint n_entries;
/* list of guint64 */
GList *entries;
} AtomSTCO64;
typedef struct _CTTSEntry
{
guint32 samplecount;
guint32 sampleoffset;
} CTTSEntry;
typedef struct _AtomCTTS
{
AtomFull header;
/* also entry count here */
guint n_entries;
GList *entries;
} AtomCTTS;
typedef struct _AtomSTBL
{
Atom header;
AtomSTSD stsd;
AtomSTTS stts;
AtomSTSS stss;
AtomSTSC stsc;
AtomSTSZ stsz;
/* NULL if not present */
AtomCTTS *ctts;
AtomSTCO64 stco64;
} AtomSTBL;
typedef struct _AtomMINF
{
Atom header;
/* only (exactly) one of those must be present */
AtomVMHD *vmhd;
AtomSMHD *smhd;
AtomHMHD *hmhd;
AtomHDLR *hdlr;
AtomDINF dinf;
AtomSTBL stbl;
} AtomMINF;
typedef struct _AtomMDIA
{
Atom header;
AtomMDHD mdhd;
AtomHDLR hdlr;
AtomMINF minf;
} AtomMDIA;
typedef struct _AtomILST
{
Atom header;
/* list of AtomInfo */
GList* entries;
} AtomILST;
typedef struct _AtomTagData
{
AtomFull header;
guint32 reserved;
guint32 datalen;
guint8* data;
} AtomTagData;
typedef struct _AtomTag
{
Atom header;
AtomTagData data;
} AtomTag;
typedef struct _AtomMETA
{
AtomFull header;
AtomHDLR hdlr;
AtomILST *ilst;
} AtomMETA;
typedef struct _AtomUDTA
{
Atom header;
AtomMETA *meta;
} AtomUDTA;
typedef struct _AtomTRAK
{
Atom header;
AtomTKHD tkhd;
AtomMDIA mdia;
} AtomTRAK;
typedef struct _AtomMOOV
{
Atom header;
AtomMVHD mvhd;
/* list of AtomTRAK */
GList *traks;
AtomUDTA *udta;
} AtomMOOV;
typedef struct _AtomWAVE
{
Atom header;
/* list of AtomInfo */
GList *extension_atoms;
} AtomWAVE;
/*
* Function to serialize an atom
*/
typedef guint64 (*AtomCopyDataFunc) (Atom *atom, guint8 **buffer, guint64 *size, guint64 *offset);
/*
* Releases memory allocated by an atom
*/
typedef guint64 (*AtomFreeFunc) (Atom *atom);
/*
* Some atoms might have many optional different kinds of child atoms, so this
* is useful for enabling generic handling of any atom.
* All we need are the two functions (copying it to an array
* for serialization and the memory releasing function).
*/
typedef struct _AtomInfo
{
Atom *atom;
AtomCopyDataFunc copy_data_func;
AtomFreeFunc free_func;
} AtomInfo;
guint64 atom_copy_data (Atom *atom, guint8 **buffer,
guint64 *size, guint64* offset);
AtomFTYP* atom_ftyp_new (AtomsContext *context, guint32 major,
guint32 version, GList *brands);
guint64 atom_ftyp_copy_data (AtomFTYP *ftyp, guint8 **buffer,
guint64 *size, guint64 *offset);
void atom_ftyp_free (AtomFTYP *ftyp);
AtomTRAK* atom_trak_new (AtomsContext *context);
void atom_trak_add_samples (AtomTRAK * trak, guint32 nsamples, guint32 delta,
guint32 size, guint64 chunk_offset, gboolean sync,
gboolean do_pts, gint64 pts_offset);
guint32 atom_trak_get_timescale (AtomTRAK *trak);
AtomMOOV* atom_moov_new (AtomsContext *context);
void atom_moov_free (AtomMOOV *moov);
guint64 atom_moov_copy_data (AtomMOOV *atom, guint8 **buffer, guint64 *size, guint64* offset);
void atom_moov_update_timescale (AtomMOOV *moov, guint32 timescale);
void atom_moov_update_duration (AtomMOOV *moov);
void atom_moov_set_64bits (AtomMOOV *moov, gboolean large_file);
void atom_moov_chunks_add_offset (AtomMOOV *moov, guint32 offset);
void atom_moov_add_trak (AtomMOOV *moov, AtomTRAK *trak);
/* media sample description related helpers */
typedef struct
{
guint32 fourcc;
guint width;
guint height;
guint depth;
guint frame_count;
gint color_table_id;
GstBuffer *codec_data;
} VisualSampleEntry;
typedef struct
{
guint32 fourcc;
guint version;
gint compression_id;
guint sample_rate;
guint channels;
guint sample_size;
guint bytes_per_packet;
guint samples_per_packet;
guint bytes_per_sample;
guint bytes_per_frame;
GstBuffer *codec_data;
} AudioSampleEntry;
AtomInfo* build_sample_entry_extension (AtomTRAK * trak, AtomsTreeFlavor flavor,
guint32 fourcc, guint esds_type,
const GstBuffer * codec_data);
void atom_trak_set_audio_type (AtomTRAK * trak, AtomsContext * context,
AudioSampleEntry * entry, guint32 scale,
AtomInfo * ext, gint sample_size);
void atom_trak_set_video_type (AtomTRAK * trak, AtomsContext * context,
VisualSampleEntry * entry, guint32 rate,
AtomInfo * ext);
/*
* Meta tags functions
*/
void atom_moov_add_str_tag (AtomMOOV *moov, guint32 fourcc, const gchar *value);
void atom_moov_add_uint_tag (AtomMOOV *moov, guint32 fourcc, guint32 flags,
guint32 value);
void atom_moov_add_tag (AtomMOOV *moov, guint32 fourcc, guint32 flags,
const guint8 * data, guint size);
void atom_moov_add_blob_tag (AtomMOOV *moov, guint8 *data, guint size);
#endif /* __ATOMS_H__ */

442
gst/qtmux/descriptors.c Normal file
View file

@ -0,0 +1,442 @@
/* Quicktime muxer plugin for GStreamer
* Copyright (C) 2008 Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
*
* 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 "descriptors.h"
/**
* Some mp4 structures (descriptors) use a coding scheme for
* representing its size.
* It is grouped in bytes. The 1st bit set to 1 means we need another byte,
* 0 otherwise. The remaining 7 bits are the useful values.
*
* The next set of functions handle those values
*/
/**
* Gets an unsigned integer and packs it into a 'expandable size' format
* (as used by mp4 descriptors)
* @size: the integer to be parsed
* @ptr: the array to place the result
* @array_size: the size of ptr array
*/
static void
expandable_size_parse (guint64 size, guint8 * ptr, guint32 array_size)
{
int index = 0;
memset (ptr, 0, sizeof (array_size));
while (size > 0 && index < array_size) {
ptr[index++] = (size > 0x7F ? 0x80 : 0x0) | (size & 0x7F);
size = size >> 7;
}
}
/**
* Gets how many positions in an array holding an 'expandable size'
* are really used
*
* @ptr: the array with the 'expandable size'
* @array_size: the size of ptr array
*
* Returns: the number of really used positions
*/
static guint64
expandable_size_get_length (guint8 * ptr, guint32 array_size)
{
gboolean next = TRUE;
guint32 index = 0;
while (next && index < array_size) {
next = ((ptr[index] & 0x80) == 1);
index++;
}
return index;
}
/*
* Initializers below
*/
static void
desc_base_descriptor_init (BaseDescriptor * bd, guint8 tag, guint32 size)
{
bd->tag = tag;
expandable_size_parse (size, bd->size, 4);
}
static void
desc_dec_specific_info_init (DecoderSpecificInfoDescriptor * dsid)
{
desc_base_descriptor_init (&dsid->base, DECODER_SPECIFIC_INFO_TAG, 0);
dsid->length = 0;
dsid->data = NULL;
}
DecoderSpecificInfoDescriptor *
desc_dec_specific_info_new ()
{
DecoderSpecificInfoDescriptor *desc =
g_new0 (DecoderSpecificInfoDescriptor, 1);
desc_dec_specific_info_init (desc);
return desc;
}
static void
desc_dec_conf_desc_init (DecoderConfigDescriptor * dcd)
{
desc_base_descriptor_init (&dcd->base, DECODER_CONFIG_DESC_TAG, 0);
dcd->dec_specific_info = NULL;
}
static void
desc_sl_conf_desc_init (SLConfigDescriptor * sl)
{
desc_base_descriptor_init (&sl->base, SL_CONFIG_DESC_TAG, 0);
sl->predefined = 0x2;
}
void
desc_es_init (ESDescriptor * es)
{
desc_base_descriptor_init (&es->base, ES_DESCRIPTOR_TAG, 0);
es->id = 0;
es->flags = 0;
es->depends_on_es_id = 0;
es->ocr_es_id = 0;
es->url_length = 0;
es->url_string = NULL;
desc_dec_conf_desc_init (&es->dec_conf_desc);
desc_sl_conf_desc_init (&es->sl_conf_desc);
}
ESDescriptor *
desc_es_descriptor_new ()
{
ESDescriptor *es = g_new0 (ESDescriptor, 1);
desc_es_init (es);
return es;
}
/*
* Deinitializers/Destructors below
*/
static void
desc_base_descriptor_clear (BaseDescriptor * base)
{
}
void
desc_dec_specific_info_free (DecoderSpecificInfoDescriptor * dsid)
{
desc_base_descriptor_clear (&dsid->base);
if (dsid->data) {
g_free (dsid->data);
dsid->data = NULL;
}
g_free (dsid);
}
static void
desc_dec_conf_desc_clear (DecoderConfigDescriptor * dec)
{
desc_base_descriptor_clear (&dec->base);
if (dec->dec_specific_info) {
desc_dec_specific_info_free (dec->dec_specific_info);
}
}
static void
desc_sl_config_descriptor_clear (SLConfigDescriptor * sl)
{
desc_base_descriptor_clear (&sl->base);
}
void
desc_es_descriptor_clear (ESDescriptor * es)
{
desc_base_descriptor_clear (&es->base);
if (es->url_string) {
g_free (es->url_string);
es->url_string = NULL;
}
desc_dec_conf_desc_clear (&es->dec_conf_desc);
desc_sl_config_descriptor_clear (&es->sl_conf_desc);
}
void
desc_es_descriptor_free (ESDescriptor * es)
{
desc_es_descriptor_clear (es);
g_free (es);
}
/*
* Size handling functions below
*/
void
desc_dec_specific_info_alloc_data (DecoderSpecificInfoDescriptor * dsid,
guint32 size)
{
if (dsid->data) {
g_free (dsid->data);
}
dsid->data = g_new0 (guint8, size);
dsid->length = size;
}
static void
desc_base_descriptor_set_size (BaseDescriptor * bd, guint32 size)
{
expandable_size_parse (size, bd->size, 4);
}
static guint64
desc_base_descriptor_get_size (BaseDescriptor * bd)
{
guint64 size = 0;
size += sizeof (guint8);
size += expandable_size_get_length (bd->size, 4) * sizeof (guint8);
return size;
}
static guint64
desc_sl_config_descriptor_get_size (SLConfigDescriptor * sl_desc)
{
guint64 size = 0;
guint64 extra_size = 0;
size += desc_base_descriptor_get_size (&sl_desc->base);
/* predefined */
extra_size += sizeof (guint8);
desc_base_descriptor_set_size (&sl_desc->base, extra_size);
return size + extra_size;
}
static guint64
desc_dec_specific_info_get_size (DecoderSpecificInfoDescriptor * dsid)
{
guint64 size = 0;
guint64 extra_size = 0;
size += desc_base_descriptor_get_size (&dsid->base);
extra_size += sizeof (guint8) * dsid->length;
desc_base_descriptor_set_size (&dsid->base, extra_size);
return size + extra_size;
}
static guint64
desc_dec_config_descriptor_get_size (DecoderConfigDescriptor * dec_desc)
{
guint64 size = 0;
guint64 extra_size = 0;
size += desc_base_descriptor_get_size (&dec_desc->base);
/* object type */
extra_size += sizeof (guint8);
/* stream type */
extra_size += sizeof (guint8);
/* buffer size */
extra_size += sizeof (guint8) * 3;
/* max bitrate */
extra_size += sizeof (guint32);
/* avg bitrate */
extra_size += sizeof (guint32);
if (dec_desc->dec_specific_info) {
extra_size += desc_dec_specific_info_get_size (dec_desc->dec_specific_info);
}
desc_base_descriptor_set_size (&dec_desc->base, extra_size);
return size + extra_size;
}
static guint64
desc_es_descriptor_get_size (ESDescriptor * es)
{
guint64 size = 0;
guint64 extra_size = 0;
size += desc_base_descriptor_get_size (&es->base);
/* id */
extra_size += sizeof (guint16);
/* flags */
extra_size += sizeof (guint8);
/* depends_on_es_id */
if (es->flags & 0x80) {
extra_size += sizeof (guint16);
}
if (es->flags & 0x40) {
/* url_length */
extra_size += sizeof (guint8);
/* url */
extra_size += sizeof (gchar) * es->url_length;
}
if (es->flags & 0x20) {
/* ocr_es_id */
extra_size += sizeof (guint16);
}
extra_size += desc_dec_config_descriptor_get_size (&es->dec_conf_desc);
extra_size += desc_sl_config_descriptor_get_size (&es->sl_conf_desc);
desc_base_descriptor_set_size (&es->base, extra_size);
return size + extra_size;
}
static gboolean
desc_es_descriptor_check_stream_dependency (ESDescriptor * es)
{
return es->flags & 0x80;
}
static gboolean
desc_es_descriptor_check_url_flag (ESDescriptor * es)
{
return es->flags & 0x40;
}
static gboolean
desc_es_descriptor_check_ocr (ESDescriptor * es)
{
return es->flags & 0x20;
}
/* Copy/Serializations Functions below */
static guint64
desc_base_descriptor_copy_data (BaseDescriptor * desc, guint8 ** buffer,
guint64 * size, guint64 * offset)
{
guint64 original_offset = *offset;
prop_copy_uint8 (desc->tag, buffer, size, offset);
prop_copy_uint8_array (desc->size, expandable_size_get_length (desc->size, 4),
buffer, size, offset);
return original_offset - *offset;
}
static guint64
desc_sl_config_descriptor_copy_data (SLConfigDescriptor * desc,
guint8 ** buffer, guint64 * size, guint64 * offset)
{
guint64 original_offset = *offset;
if (!desc_base_descriptor_copy_data (&desc->base, buffer, size, offset)) {
return 0;
}
/* predefined attribute */
prop_copy_uint8 (desc->predefined, buffer, size, offset);
return *offset - original_offset;
}
static guint64
desc_dec_specific_info_copy_data (DecoderSpecificInfoDescriptor * desc,
guint8 ** buffer, guint64 * size, guint64 * offset)
{
guint64 original_offset = *offset;
if (!desc_base_descriptor_copy_data (&desc->base, buffer, size, offset)) {
return 0;
}
prop_copy_uint8_array (desc->data, desc->length, buffer, size, offset);
return *offset - original_offset;
}
static guint64
desc_dec_config_descriptor_copy_data (DecoderConfigDescriptor * desc,
guint8 ** buffer, guint64 * size, guint64 * offset)
{
guint64 original_offset = *offset;
if (!desc_base_descriptor_copy_data (&desc->base, buffer, size, offset)) {
return 0;
}
prop_copy_uint8 (desc->object_type, buffer, size, offset);
prop_copy_uint8 (desc->stream_type, buffer, size, offset);
prop_copy_uint8_array (desc->buffer_size_DB, 3, buffer, size, offset);
prop_copy_uint32 (desc->max_bitrate, buffer, size, offset);
prop_copy_uint32 (desc->avg_bitrate, buffer, size, offset);
if (desc->dec_specific_info) {
if (!desc_dec_specific_info_copy_data (desc->dec_specific_info, buffer,
size, offset)) {
return 0;
}
}
return *offset - original_offset;
}
guint64
desc_es_descriptor_copy_data (ESDescriptor * desc, guint8 ** buffer,
guint64 * size, guint64 * offset)
{
guint64 desc_size;
guint64 original_offset = *offset;
/* must call this twice to have size fields of all contained descriptors set
* correctly, and to have the size of the size fields taken into account */
desc_size = desc_es_descriptor_get_size (desc);
desc_size = desc_es_descriptor_get_size (desc);
if (!desc_base_descriptor_copy_data (&desc->base, buffer, size, offset)) {
return 0;
}
/* id and flags */
prop_copy_uint16 (desc->id, buffer, size, offset);
prop_copy_uint8 (desc->flags, buffer, size, offset);
if (desc_es_descriptor_check_stream_dependency (desc)) {
prop_copy_uint16 (desc->depends_on_es_id, buffer, size, offset);
}
if (desc_es_descriptor_check_url_flag (desc)) {
prop_copy_size_string (desc->url_string, desc->url_length, buffer, size,
offset);
}
if (desc_es_descriptor_check_ocr (desc)) {
prop_copy_uint16 (desc->ocr_es_id, buffer, size, offset);
}
if (!desc_dec_config_descriptor_copy_data (&desc->dec_conf_desc, buffer, size,
offset)) {
return 0;
}
if (!desc_sl_config_descriptor_copy_data (&desc->sl_conf_desc, buffer, size,
offset)) {
return 0;
}
return *offset - original_offset;
}

128
gst/qtmux/descriptors.h Normal file
View file

@ -0,0 +1,128 @@
/* Quicktime muxer plugin for GStreamer
* Copyright (C) 2008 Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
*
* 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.
*/
#ifndef __DESCRIPTORS_H__
#define __DESCRIPTORS_H__
#include <glib.h>
#include <string.h>
#include "properties.h"
/*
* Tags for descriptor (each kind is represented by a number, instead of fourcc as in atoms)
*/
#define OBJECT_DESC_TAG 0x01
#define INIT_OBJECT_DESC_TAG 0x02
#define ES_DESCRIPTOR_TAG 0x03
#define DECODER_CONFIG_DESC_TAG 0x04
#define DECODER_SPECIFIC_INFO_TAG 0x05
#define SL_CONFIG_DESC_TAG 0x06
#define ES_ID_INC_TAG 0x0E
#define MP4_INIT_OBJECT_DESC_TAG 0x10
#define ESDS_OBJECT_TYPE_MPEG1_P3 0x6B
#define ESDS_OBJECT_TYPE_MPEG2_P7_MAIN 0x66
#define ESDS_OBJECT_TYPE_MPEG4_P7_LC 0x67
#define ESDS_OBJECT_TYPE_MPEG4_P7_SSR 0x68
#define ESDS_OBJECT_TYPE_MPEG4_P2 0x20
#define ESDS_OBJECT_TYPE_MPEG4_P3 0x40
#define ESDS_STREAM_TYPE_VISUAL 0x04
#define ESDS_STREAM_TYPE_AUDIO 0x05
typedef struct _BaseDescriptor
{
guint8 tag;
/* the first bit of each byte indicates if the next byte should be used */
guint8 size[4];
} BaseDescriptor;
typedef struct _SLConfigDescriptor
{
BaseDescriptor base;
guint8 predefined; /* everything is supposed predefined */
} SLConfigDescriptor;
typedef struct _DecoderSpecificInfoDescriptor
{
BaseDescriptor base;
guint32 length;
guint8 *data;
} DecoderSpecificInfoDescriptor;
typedef struct _DecoderConfigDescriptor {
BaseDescriptor base;
guint8 object_type;
/* following are condensed into streamType:
* bit(6) streamType;
* bit(1) upStream;
* const bit(1) reserved=1;
*/
guint8 stream_type;
guint8 buffer_size_DB[3];
guint32 max_bitrate;
guint32 avg_bitrate;
DecoderSpecificInfoDescriptor *dec_specific_info;
} DecoderConfigDescriptor;
typedef struct _ESDescriptor
{
BaseDescriptor base;
guint16 id;
/* flags contains the following:
* bit(1) streamDependenceFlag;
* bit(1) URL_Flag;
* bit(1) OCRstreamFlag;
* bit(5) streamPriority;
*/
guint8 flags;
guint16 depends_on_es_id;
guint8 url_length; /* only if URL_flag is set */
guint8 *url_string; /* size is url_length */
guint16 ocr_es_id; /* only if OCRstreamFlag is set */
DecoderConfigDescriptor dec_conf_desc;
SLConfigDescriptor sl_conf_desc;
/* optional remainder of ESDescriptor is not used */
} ESDescriptor;
/* --- FUNCTIONS --- */
void desc_es_init (ESDescriptor *es);
ESDescriptor *desc_es_descriptor_new ();
guint64 desc_es_descriptor_copy_data (ESDescriptor *es, guint8 **buffer,
guint64 *size, guint64 *offset);
void desc_es_descriptor_clear (ESDescriptor *es);
DecoderSpecificInfoDescriptor *desc_dec_specific_info_new();
void desc_dec_specific_info_free (DecoderSpecificInfoDescriptor *dsid);
void desc_dec_specific_info_alloc_data (DecoderSpecificInfoDescriptor *dsid,
guint32 size);
#endif /* __DESCRIPTORS_H__ */

159
gst/qtmux/fourcc.h Normal file
View file

@ -0,0 +1,159 @@
/* 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.
*/
#ifndef __FOURCC_H__
#define __FOURCC_H__
#include <gst/gst.h>
G_BEGIN_DECLS
#define FOURCC_null 0x0
#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_dhlr GST_MAKE_FOURCC('d','h','l','r')
#define FOURCC_mhlr GST_MAKE_FOURCC('m','h','l','r')
#define FOURCC_minf GST_MAKE_FOURCC('m','i','n','f')
#define FOURCC_mdir GST_MAKE_FOURCC('m','d','i','r')
#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_strm GST_MAKE_FOURCC('s','t','r','m')
#define FOURCC_rtsp GST_MAKE_FOURCC('r','t','s','p')
#define FOURCC_co64 GST_MAKE_FOURCC('c','o','6','4')
#define FOURCC_cmov GST_MAKE_FOURCC('c','m','o','v')
#define FOURCC_dcom GST_MAKE_FOURCC('d','c','o','m')
#define FOURCC_cmvd GST_MAKE_FOURCC('c','m','v','d')
#define FOURCC_hint GST_MAKE_FOURCC('h','i','n','t')
#define FOURCC_mp4a GST_MAKE_FOURCC('m','p','4','a')
#define FOURCC__mp3 GST_MAKE_FOURCC('.','m','p','3')
#define FOURCC_mp4s GST_MAKE_FOURCC('m','p','4','s')
#define FOURCC_mp4v GST_MAKE_FOURCC('m','p','4','v')
#define FOURCC_2vuy GST_MAKE_FOURCC('2','v','u','y')
#define FOURCC_wave GST_MAKE_FOURCC('w','a','v','e')
#define FOURCC_appl GST_MAKE_FOURCC('a','p','p','l')
#define FOURCC_esds GST_MAKE_FOURCC('e','s','d','s')
#define FOURCC_hnti GST_MAKE_FOURCC('h','n','t','i')
#define FOURCC_rtp_ GST_MAKE_FOURCC('r','t','p',' ')
#define FOURCC_sdp_ GST_MAKE_FOURCC('s','d','p',' ')
#define FOURCC_meta GST_MAKE_FOURCC('m','e','t','a')
#define FOURCC_ilst GST_MAKE_FOURCC('i','l','s','t')
#define FOURCC__nam GST_MAKE_FOURCC(0xa9,'n','a','m')
#define FOURCC__ART GST_MAKE_FOURCC(0xa9,'A','R','T')
#define FOURCC__wrt GST_MAKE_FOURCC(0xa9,'w','r','t')
#define FOURCC__grp GST_MAKE_FOURCC(0xa9,'g','r','p')
#define FOURCC__alb GST_MAKE_FOURCC(0xa9,'a','l','b')
#define FOURCC__day GST_MAKE_FOURCC(0xa9,'d','a','y')
#define FOURCC__des GST_MAKE_FOURCC(0xa9,'d','e','s')
#define FOURCC_gnre GST_MAKE_FOURCC('g','n','r','e')
#define FOURCC_disc GST_MAKE_FOURCC('d','i','s','c')
#define FOURCC_disk GST_MAKE_FOURCC('d','i','s','k')
#define FOURCC_trkn GST_MAKE_FOURCC('t','r','k','n')
#define FOURCC_cprt GST_MAKE_FOURCC('c','p','r','t')
#define FOURCC_covr GST_MAKE_FOURCC('c','o','v','r')
#define FOURCC_cpil GST_MAKE_FOURCC('c','p','i','l')
#define FOURCC_tmpo GST_MAKE_FOURCC('t','m','p','o')
#define FOURCC__too GST_MAKE_FOURCC(0xa9,'t','o','o')
#define FOURCC_keyw GST_MAKE_FOURCC('k','e','y','w')
#define FOURCC_____ GST_MAKE_FOURCC('-','-','-','-')
#define FOURCC_free GST_MAKE_FOURCC('f','r','e','e')
#define FOURCC_data GST_MAKE_FOURCC('d','a','t','a')
#define FOURCC_SVQ3 GST_MAKE_FOURCC('S','V','Q','3')
#define FOURCC_rmra GST_MAKE_FOURCC('r','m','r','a')
#define FOURCC_rmda GST_MAKE_FOURCC('r','m','d','a')
#define FOURCC_rdrf GST_MAKE_FOURCC('r','d','r','f')
#define FOURCC__gen GST_MAKE_FOURCC(0xa9, 'g', 'e', 'n')
#define FOURCC_rmdr GST_MAKE_FOURCC('r','m','d','r')
#define FOURCC_rmvc GST_MAKE_FOURCC('r','m','v','c')
#define FOURCC_qtim GST_MAKE_FOURCC('q','t','i','m')
#define FOURCC_drms GST_MAKE_FOURCC('d','r','m','s')
#define FOURCC_avc1 GST_MAKE_FOURCC('a','v','c','1')
#define FOURCC_h263 GST_MAKE_FOURCC('h','2','6','3')
#define FOURCC_avcC GST_MAKE_FOURCC('a','v','c','C')
#define FOURCC_VP31 GST_MAKE_FOURCC('V','P','3','1')
#define FOURCC_rle_ GST_MAKE_FOURCC('r','l','e',' ')
#define FOURCC_MAC6 GST_MAKE_FOURCC('M','A','C','6')
#define FOURCC_MAC3 GST_MAKE_FOURCC('M','A','C','3')
#define FOURCC_ima4 GST_MAKE_FOURCC('i','m','a','4')
#define FOURCC_ulaw GST_MAKE_FOURCC('u','l','a','w')
#define FOURCC_alaw GST_MAKE_FOURCC('a','l','a','w')
#define FOURCC_twos GST_MAKE_FOURCC('t','w','o','s')
#define FOURCC_sowt GST_MAKE_FOURCC('s','o','w','t')
#define FOURCC_raw_ GST_MAKE_FOURCC('r','a','w',' ')
#define FOURCC_QDM2 GST_MAKE_FOURCC('Q','D','M','2')
#define FOURCC_alac GST_MAKE_FOURCC('a','l','a','c')
#define FOURCC_samr GST_MAKE_FOURCC('s','a','m','r')
#define FOURCC_sawb GST_MAKE_FOURCC('s','a','w','b')
#define FOURCC_mdat GST_MAKE_FOURCC('m','d','a','t')
#define FOURCC_wide GST_MAKE_FOURCC('w','i','d','e')
#define FOURCC_PICT GST_MAKE_FOURCC('P','I','C','T')
#define FOURCC_pnot GST_MAKE_FOURCC('p','n','o','t')
#define FOURCC_zlib GST_MAKE_FOURCC('z','l','i','b')
#define FOURCC_alis GST_MAKE_FOURCC('a','l','i','s')
#define FOURCC_url_ GST_MAKE_FOURCC('u','r','l',' ')
#define FOURCC_frma GST_MAKE_FOURCC('f','r','m','a')
#define FOURCC_ctts GST_MAKE_FOURCC('c','t','t','s')
#define FOURCC_drac GST_MAKE_FOURCC('d','r','a','c')
#define FOURCC_jpeg GST_MAKE_FOURCC('j','p','e','g')
/* Xiph fourcc */
#define FOURCC_XiTh GST_MAKE_FOURCC('X','i','T','h')
#define FOURCC_XdxT GST_MAKE_FOURCC('X','d','x','T')
#define FOURCC_tCtH GST_MAKE_FOURCC('t','C','t','H')
#define FOURCC_tCt_ GST_MAKE_FOURCC('t','C','t','#')
#define FOURCC_tCtC GST_MAKE_FOURCC('t','C','t','C')
/* ilst metatags */
#define FOURCC_titl GST_MAKE_FOURCC('t','i','t','l')
#define FOURCC__cmt GST_MAKE_FOURCC(0xa9, 'c','m','t')
G_END_DECLS
#endif /* __FOURCC_H__ */

39
gst/qtmux/ftypcc.h Normal file
View file

@ -0,0 +1,39 @@
/* GStreamer
* Copyright (C) <2008> Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
*
* 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.
*/
#ifndef __FTYP_CC_H__
#define __FTYP_CC_H__
#include <gst/gst.h>
G_BEGIN_DECLS
#define FOURCC_ftyp GST_MAKE_FOURCC('f','t','y','p')
#define FOURCC_isom GST_MAKE_FOURCC('i','s','o','m')
#define FOURCC_iso2 GST_MAKE_FOURCC('i','s','o','2')
#define FOURCC_mp41 GST_MAKE_FOURCC('m','p','4','1')
#define FOURCC_mp42 GST_MAKE_FOURCC('m','p','4','2')
#define FOURCC_mjp2 GST_MAKE_FOURCC('m','j','p','2')
#define FOURCC_3gg7 GST_MAKE_FOURCC('3','g','g','7')
#define FOURCC_avc1 GST_MAKE_FOURCC('a','v','c','1')
#define FOURCC_qt__ GST_MAKE_FOURCC('q','t',' ',' ')
G_END_DECLS
#endif /* __FTYP_CC_H__ */

1823
gst/qtmux/gstqtmux.c Normal file
View file

File diff suppressed because it is too large Load diff

134
gst/qtmux/gstqtmux.h Normal file
View file

@ -0,0 +1,134 @@
/* Quicktime muxer plugin for GStreamer
* Copyright (C) 2008 Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
*
* 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.
*/
#ifndef __GST_QT_MUX_H__
#define __GST_QT_MUX_H__
#include <gst/gst.h>
#include <gst/base/gstcollectpads.h>
#include "fourcc.h"
#include "atoms.h"
#include "gstqtmuxmap.h"
G_BEGIN_DECLS
#define GST_TYPE_QT_MUX (gst_qt_mux_get_type())
#define GST_QT_MUX(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_QT_MUX, GstQTMux))
#define GST_QT_MUX_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_QT_MUX, GstQTMux))
#define GST_IS_QT_MUX(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_QT_MUX))
#define GST_IS_QT_MUX_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_QT_MUX))
#define GST_QT_MUX_CAST(obj) ((GstQTMux*)(obj))
typedef struct _GstQTMux GstQTMux;
typedef struct _GstQTMuxClass GstQTMuxClass;
typedef struct _GstQTPad
{
GstCollectData collect; /* we extend the CollectData */
/* fourcc id of stream */
guint32 fourcc;
/* whether using format that have out of order buffers */
gboolean is_out_of_order;
/* if not 0, track with constant sized samples, e.g. raw audio */
guint sample_size;
/* make sync table entry */
gboolean sync;
GstBuffer *last_buf;
/* dts of last_buf */
GstClockTime last_dts;
/* all the atom and chunk book-keeping is delegated here
* unowned/uncounted reference, parent MOOV owns */
AtomTRAK *trak;
} GstQTPad;
typedef enum _GstQTMuxState
{
GST_QT_MUX_STATE_NONE,
GST_QT_MUX_STATE_STARTED,
GST_QT_MUX_STATE_DATA,
GST_QT_MUX_STATE_EOS
} GstQTMuxState;
struct _GstQTMux
{
GstElement element;
GstPad *srcpad;
GstCollectPads *collect;
/* state */
GstQTMuxState state;
/* size of header (prefix, atoms (ftyp, mdat)) */
guint64 header_size;
/* accumulated size of raw media data (a priori not including mdat header) */
guint64 mdat_size;
/* position of mdat extended size field (for later updating) */
guint64 mdat_pos;
/* atom helper objects */
AtomsContext *context;
AtomFTYP *ftyp;
AtomMOOV *moov;
/* fast start */
FILE *fast_start_file;
GstTagList *tags;
/* properties */
guint32 timescale;
AtomsTreeFlavor flavor;
gboolean fast_start;
gboolean large_file;
gboolean do_ctts;
gchar *fast_start_file_path;
/* for collect pads event handling function */
GstPadEventFunction collect_event;
};
struct _GstQTMuxClass
{
GstElementClass parent_class;
GstQTMuxFormat format;
};
/* type register helper struct */
typedef struct _GstQTMuxClassParams
{
GstQTMuxFormatProp *prop;
GstCaps *src_caps;
GstCaps *video_sink_caps;
GstCaps *audio_sink_caps;
} GstQTMuxClassParams;
#define GST_QT_MUX_PARAMS_QDATA g_quark_from_static_string("qt-mux-params")
GType gst_qt_mux_get_type (void);
G_END_DECLS
#endif /* __GST_QT_MUX_H__ */

245
gst/qtmux/gstqtmuxmap.c Normal file
View file

@ -0,0 +1,245 @@
/* Quicktime muxer plugin for GStreamer
* Copyright (C) 2008 Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
* Copyright (C) 2008 Mark Nauwelaerts <mnauw@users.sf.net>
*
* 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 "gstqtmuxmap.h"
#include "fourcc.h"
#include "ftypcc.h"
/* static info related to various format */
#define COMMON_VIDEO_CAPS \
"width = (int) [ 16, 4096 ], " \
"height = (int) [ 16, 4096 ], " \
"framerate = (fraction) [ 0, MAX ]"
#define COMMON_VIDEO_CAPS_NO_FRAMERATE \
"width = (int) [ 16, 4096 ], " \
"height = (int) [ 16, 4096 ] "
#define H264_CAPS \
"video/x-h264, " \
COMMON_VIDEO_CAPS
#define MPEG4V_CAPS \
"video/mpeg, " \
"mpegversion = (int) 4, "\
"systemstream = (boolean) false, " \
COMMON_VIDEO_CAPS "; " \
"video/x-divx, " \
"divxversion = (int) 5, "\
COMMON_VIDEO_CAPS
#define COMMON_AUDIO_CAPS(c, r) \
"channels = (int) [ 1, " G_STRINGIFY (c) " ], " \
"rate = (int) [ 1, " G_STRINGIFY (r) " ]"
#define PCM_CAPS \
"audio/x-raw-int, " \
"width = (int) 8, " \
"depth = (int) 8, " \
COMMON_AUDIO_CAPS (2, MAX) ", " \
"signed = (boolean) { true, false }; " \
"audio/x-raw-int, " \
"width = (int) 16, " \
"depth = (int) 16, " \
"endianness = (int) { BIG_ENDIAN, LITTLE_ENDIAN }, " \
COMMON_AUDIO_CAPS (2, MAX) ", " \
"signed = (boolean) true " \
#define PCM_CAPS_FULL \
PCM_CAPS "; " \
"audio/x-raw-int, " \
"width = (int) 24, " \
"depth = (int) 24, " \
"endianness = (int) { BIG_ENDIAN, LITTLE_ENDIAN }, " \
COMMON_AUDIO_CAPS (2, MAX) ", " \
"signed = (boolean) true; " \
"audio/x-raw-int, " \
"width = (int) 32, " \
"depth = (int) 32, " \
"endianness = (int) { BIG_ENDIAN, LITTLE_ENDIAN }, " \
COMMON_AUDIO_CAPS (2, MAX) ", " \
"signed = (boolean) true "
#define MP3_CAPS \
"audio/mpeg, " \
"mpegversion = (int) 1, " \
"layer = (int) 3, " \
COMMON_AUDIO_CAPS (2, MAX)
#define AAC_CAPS \
"audio/mpeg, " \
"mpegversion = (int) 4, " \
COMMON_AUDIO_CAPS (8, MAX)
GstQTMuxFormatProp gst_qt_mux_format_list[] = {
/* original QuickTime format; see Apple site (e.g. qtff.pdf) */
{
GST_QT_MUX_FORMAT_QT,
"qtmux",
"QuickTime",
"GstQTMux",
GST_STATIC_CAPS ("video/quicktime"),
GST_STATIC_CAPS ("video/x-raw-rgb, "
COMMON_VIDEO_CAPS "; "
"video/x-raw-yuv, "
"format = (fourcc) UYVY, "
COMMON_VIDEO_CAPS "; "
"video/x-h263, "
"h263version = (string) h263, "
COMMON_VIDEO_CAPS "; "
MPEG4V_CAPS "; "
H264_CAPS "; "
"video/x-dv, "
"systemstream = (boolean) false, "
COMMON_VIDEO_CAPS "; "
"image/jpeg, "
COMMON_VIDEO_CAPS_NO_FRAMERATE "; " "video/x-qt-part"),
GST_STATIC_CAPS (PCM_CAPS_FULL "; "
MP3_CAPS " ; "
AAC_CAPS " ; "
"audio/x-alaw, "
COMMON_AUDIO_CAPS (2, MAX) "; "
"audio/x-mulaw, " COMMON_AUDIO_CAPS (2, MAX))
}
,
/* ISO 14496-14: mp42 as ISO base media extension
* (supersedes original ISO 144996-1 mp41) */
{
GST_QT_MUX_FORMAT_MP4,
"mp4mux",
"MP4",
"GstMP4Mux",
/* FIXME does not feel right, due to qt caps mess */
GST_STATIC_CAPS ("video/quicktime"),
GST_STATIC_CAPS (MPEG4V_CAPS "; " H264_CAPS),
GST_STATIC_CAPS (MP3_CAPS "; " AAC_CAPS)
}
,
/* 3GPP Technical Specification 26.244 V7.3.0
* (extended in 3GPP2 File Formats for Multimedia Services) */
{
GST_QT_MUX_FORMAT_3GP,
"gppmux",
"3GPP",
"GstGPPMux",
GST_STATIC_CAPS ("application/x-3gp"),
GST_STATIC_CAPS (H264_CAPS),
GST_STATIC_CAPS ("audio/AMR, "
COMMON_AUDIO_CAPS (8, MAX) "; " MP3_CAPS "; " AAC_CAPS)
}
,
/* ISO 15444-3: Motion-JPEG-2000 (also ISO base media extension) */
{
GST_QT_MUX_FORMAT_MJ2,
"mj2mux",
"MJ2",
"GstMJ2Mux",
GST_STATIC_CAPS ("video/mj2"),
GST_STATIC_CAPS ("image/x-j2c, " COMMON_VIDEO_CAPS),
GST_STATIC_CAPS (PCM_CAPS)
}
,
{
GST_QT_MUX_FORMAT_NONE,
}
,
};
/* pretty static, but may turn out needed a few times */
AtomsTreeFlavor
gst_qt_mux_map_format_to_flavor (GstQTMuxFormat format)
{
if (format == GST_QT_MUX_FORMAT_QT)
return ATOMS_TREE_FLAVOR_MOV;
else
return ATOMS_TREE_FLAVOR_ISOM;
}
/* pretty static, but possibly dynamic format info */
/* notes:
* - avc1 brand is not used, since the specific extensions indicated by it
* are not used (e.g. sample groupings, etc)
* - 3GPP2 specific formats not (yet) used, only 3GPP, so no need yet either
* for 3g2a (but later on, moov might be used to conditionally switch to
* 3g2a if needed) */
void
gst_qt_mux_map_format_to_header (GstQTMuxFormat format, GstBuffer ** _prefix,
guint32 * _major, guint32 * _version, GList ** _compatible, AtomMOOV * moov)
{
static guint32 qt_brands[] = { 0 };
static guint32 mp4_brands[] = { FOURCC_mp41, FOURCC_isom, FOURCC_iso2, 0 };
static guint32 gpp_brands[] = { FOURCC_isom, FOURCC_iso2, 0 };
static guint32 mjp2_brands[] = { FOURCC_isom, FOURCC_iso2, 0 };
static guint8 mjp2_prefix[] =
{ 0, 0, 0, 12, 'j', 'P', ' ', ' ', 0x0D, 0x0A, 0x87, 0x0A };
guint32 *comp = NULL;
guint32 major = 0, version;
GstBuffer *prefix = NULL;
GList *result = NULL;
g_return_if_fail (_prefix != NULL);
g_return_if_fail (_major != NULL);
g_return_if_fail (_version != NULL);
g_return_if_fail (_compatible != NULL);
version = 1;
switch (format) {
case GST_QT_MUX_FORMAT_QT:
major = FOURCC_qt__;
comp = qt_brands;
version = 0x20050300;
break;
case GST_QT_MUX_FORMAT_MP4:
major = FOURCC_mp42;
comp = mp4_brands;
break;
case GST_QT_MUX_FORMAT_3GP:
major = FOURCC_3gg7;
comp = gpp_brands;
break;
case GST_QT_MUX_FORMAT_MJ2:
major = FOURCC_mjp2;
comp = mjp2_brands;
prefix = gst_buffer_new_and_alloc (sizeof (mjp2_prefix));
memcpy (GST_BUFFER_DATA (prefix), mjp2_prefix, GST_BUFFER_SIZE (prefix));
break;
default:
g_assert_not_reached ();
break;
}
/* convert list to list, hm */
while (comp && *comp != 0) {
/* order matters over efficiency */
result = g_list_append (result, GUINT_TO_POINTER (*comp));
comp++;
}
*_major = major;
*_version = version;
*_prefix = prefix;
*_compatible = result;
/* TODO 3GPP may include mp42 as compatible if applicable */
/* TODO 3GPP major brand 3gp7 if at most 1 video and audio track */
}

57
gst/qtmux/gstqtmuxmap.h Normal file
View file

@ -0,0 +1,57 @@
/* Quicktime muxer plugin for GStreamer
* Copyright (C) 2008 Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
* Copyright (C) 2008 Mark Nauwelaerts <mnauw@users.sf.net>
*
* 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.
*/
#ifndef __GST_QT_MUX_MAP_H__
#define __GST_QT_MUX_MAP_H__
#include "atoms.h"
#include <glib.h>
#include <gst/gst.h>
typedef enum _GstQTMuxFormat
{
GST_QT_MUX_FORMAT_NONE = 0,
GST_QT_MUX_FORMAT_QT,
GST_QT_MUX_FORMAT_MP4,
GST_QT_MUX_FORMAT_3GP,
GST_QT_MUX_FORMAT_MJ2
} GstQTMuxFormat;
typedef struct _GstQTMuxFormatProp
{
GstQTMuxFormat format;
gchar *name;
gchar *long_name;
gchar *type_name;
GstStaticCaps src_caps;
GstStaticCaps video_sink_caps;
GstStaticCaps audio_sink_caps;
} GstQTMuxFormatProp;
extern GstQTMuxFormatProp gst_qt_mux_format_list[];
void gst_qt_mux_map_format_to_header (GstQTMuxFormat format, GstBuffer ** _prefix,
guint32 * _major, guint32 * verson,
GList ** _compatible, AtomMOOV * moov);
AtomsTreeFlavor gst_qt_mux_map_format_to_flavor (GstQTMuxFormat format);
#endif /* __GST_QT_MUX_MAP_H__ */

183
gst/qtmux/properties.c Normal file
View file

@ -0,0 +1,183 @@
/* Quicktime muxer plugin for GStreamer
* Copyright (C) 2008 Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
*
* 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 "properties.h"
/* if needed, re-allocate buffer to ensure size bytes can be written into it
* at offset */
void
prop_copy_ensure_buffer (guint8 ** buffer, guint64 * bsize, guint64 * offset,
guint64 size)
{
if (buffer && *bsize - *offset < size) {
*bsize += size + 10 * 1024;
*buffer = g_realloc (*buffer, *bsize);
}
}
static guint64
copy_func (void *prop, guint size, guint8 ** buffer, guint64 * bsize,
guint64 * offset)
{
if (buffer) {
prop_copy_ensure_buffer (buffer, bsize, offset, size);
memcpy (*buffer + *offset, prop, size);
}
*offset += size;
return size;
}
#define INT_ARRAY_COPY_FUNC_FAST(name, datatype) \
guint64 prop_copy_ ## name ## _array (datatype *prop, guint size, \
guint8 ** buffer, guint64 * bsize, guint64 * offset) { \
return copy_func (prop, sizeof (datatype) * size, buffer, bsize, offset);\
}
#define INT_ARRAY_COPY_FUNC(name, datatype) \
guint64 prop_copy_ ## name ## _array (datatype *prop, guint size, \
guint8 ** buffer, guint64 * bsize, guint64 * offset) { \
guint i; \
\
for (i = 0; i < size; i++) { \
prop_copy_ ## name (prop[i], buffer, bsize, offset); \
} \
return sizeof (datatype) * size; \
}
/* INTEGERS */
guint64
prop_copy_uint8 (guint8 prop, guint8 ** buffer, guint64 * size,
guint64 * offset)
{
return copy_func (&prop, sizeof (guint8), buffer, size, offset);
}
guint64
prop_copy_uint16 (guint16 prop, guint8 ** buffer, guint64 * size,
guint64 * offset)
{
prop = GUINT16_TO_BE (prop);
return copy_func (&prop, sizeof (guint16), buffer, size, offset);
}
guint64
prop_copy_uint32 (guint32 prop, guint8 ** buffer, guint64 * size,
guint64 * offset)
{
prop = GUINT32_TO_BE (prop);
return copy_func (&prop, sizeof (guint32), buffer, size, offset);
}
guint64
prop_copy_uint64 (guint64 prop, guint8 ** buffer, guint64 * size,
guint64 * offset)
{
prop = GUINT64_TO_BE (prop);
return copy_func (&prop, sizeof (guint64), buffer, size, offset);
}
guint64
prop_copy_int32 (gint32 prop, guint8 ** buffer, guint64 * size,
guint64 * offset)
{
prop = GINT32_TO_BE (prop);
return copy_func (&prop, sizeof (guint32), buffer, size, offset);
}
/* uint8 can use direct copy in any case, and may be used for large quantity */
INT_ARRAY_COPY_FUNC_FAST (uint8, guint8);
/* not used in large quantity anyway */
INT_ARRAY_COPY_FUNC (uint16, guint16);
INT_ARRAY_COPY_FUNC (uint32, guint32);
INT_ARRAY_COPY_FUNC (uint64, guint64);
/* FOURCC */
guint64
prop_copy_fourcc (guint32 prop, guint8 ** buffer, guint64 * size,
guint64 * offset)
{
prop = GINT32_TO_LE (prop);
return copy_func (&prop, sizeof (guint32), buffer, size, offset);
}
INT_ARRAY_COPY_FUNC (fourcc, guint32);
/**
* Copies a string of bytes without placing its size at the beginning.
*
* @string: the string to be copied
* @str_size: size of the string
* @buffer: the array to copy the string to
* @offset: the position in the buffer array.
* This value is updated to the point right after the copied string.
*
* Returns: the number of bytes copied
*/
guint64
prop_copy_fixed_size_string (guint8 * string, guint str_size, guint8 ** buffer,
guint64 * size, guint64 * offset)
{
return copy_func (string, str_size * sizeof (guint8), buffer, size, offset);
}
/**
* Copies a string and its size to an array. Example:
* string = 'abc\0'
* result in the array: [3][a][b][c] (each [x] represents a position)
*
* @string: the string to be copied
* @str_size: size of the string
* @buffer: the array to copy the string to
* @offset: the position in the buffer array.
* This value is updated to the point right after the copied string.
*
* Returns: the number of bytes copied
*/
guint64
prop_copy_size_string (guint8 * string, guint str_size, guint8 ** buffer,
guint64 * size, guint64 * offset)
{
guint64 original_offset = *offset;
prop_copy_uint8 (str_size, buffer, size, offset);
prop_copy_fixed_size_string (string, str_size, buffer, size, offset);
return *offset - original_offset;
}
/**
* Copies a string including its null terminating char to an array.
*
* @string: the string to be copied
* @buffer: the array to copy the string to
* @offset: the position in the buffer array.
* This value is updated to the point right after the copied string.
*
* Returns: the number of bytes copied
*/
guint64
prop_copy_null_terminated_string (gchar * string, guint8 ** buffer,
guint64 * size, guint64 * offset)
{
guint64 original_offset = *offset;
guint len = strlen (string);
prop_copy_fixed_size_string ((guint8 *) string, len, buffer, size, offset);
prop_copy_uint8 ('\0', buffer, size, offset);
return *offset - original_offset;
}

64
gst/qtmux/properties.h Normal file
View file

@ -0,0 +1,64 @@
/* Quicktime muxer plugin for GStreamer
* Copyright (C) 2008 Thiago Sousa Santos <thiagoss@embedded.ufcg.edu.br>
*
* 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.
*/
#ifndef __PROPERTIES_H__
#define __PROPERTIES_H__
#include <glib.h>
#include <string.h>
/**
* Functions for copying atoms properties.
*
* All of them receive, as the input, the property to be copied, the destination
* buffer, and a pointer to an offset in the destination buffer to copy to the right place.
* This offset will be updated to the new value (offset + copied_size)
* The functions return the size of the property that has been copied or 0
* if it couldn't copy.
*/
void prop_copy_ensure_buffer (guint8 ** buffer, guint64 * bsize, guint64 * offset, guint64 size);
guint64 prop_copy_uint8 (guint8 prop, guint8 **buffer, guint64 *size, guint64 *offset);
guint64 prop_copy_uint16 (guint16 prop, guint8 **buffer, guint64 *size, guint64 *offset);
guint64 prop_copy_uint32 (guint32 prop, guint8 **buffer, guint64 *size, guint64 *offset);
guint64 prop_copy_uint64 (guint64 prop, guint8 **buffer, guint64 *size, guint64 *offset);
guint64 prop_copy_int32 (gint32 prop, guint8 **buffer, guint64 *size, guint64 *offset);
guint64 prop_copy_uint8_array (guint8 *prop, guint size,
guint8 **buffer, guint64 *bsize, guint64 *offset);
guint64 prop_copy_uint16_array (guint16 *prop, guint size,
guint8 **buffer, guint64 *bsize, guint64 *offset);
guint64 prop_copy_uint32_array (guint32 *prop, guint size,
guint8 **buffer, guint64 *bsize, guint64 *offset);
guint64 prop_copy_uint64_array (guint64 *prop, guint size,
guint8 **buffer, guint64 *bsize, guint64 *offset);
guint64 prop_copy_fourcc (guint32 prop, guint8 **buffer, guint64 *size, guint64 *offset);
guint64 prop_copy_fourcc_array (guint32 *prop, guint size,
guint8 **buffer, guint64 *bsize, guint64 *offset);
guint64 prop_copy_fixed_size_string (guint8 *string, guint str_size,
guint8 **buffer, guint64 *size, guint64 *offset);
guint64 prop_copy_size_string (guint8 *string, guint str_size,
guint8 **buffer, guint64 *size, guint64 *offset);
guint64 prop_copy_null_terminated_string (gchar *string,
guint8 **buffer, guint64 *size, guint64 *offset);
#endif /* __PROPERTIES_H__ */