pts_offset);
}
+guint32
+atom_traf_get_sample_num (AtomTRAF * traf)
+{
+ AtomTRUN *trun;
+
+ if (G_UNLIKELY (!traf->truns))
+ return 0;
+
+ trun = traf->truns->data;
+ return atom_array_get_len (&trun->entries);
+}
+
void
atom_moof_add_traf (AtomMOOF * moof, AtomTRAF * traf)
{
moof->trafs = g_list_append (moof->trafs, traf);
}
+static void
+atom_tfra_free (AtomTFRA * tfra)
+{
+ atom_full_clear (&tfra->header);
+ atom_array_clear (&tfra->entries);
+ g_free (tfra);
+}
+
+AtomMFRA *
+atom_mfra_new (AtomsContext * context)
+{
+ AtomMFRA *mfra = g_new0 (AtomMFRA, 1);
+
+ atom_header_set (&mfra->header, FOURCC_mfra, 0, 0);
+ return mfra;
+}
+
+void
+atom_mfra_add_tfra (AtomMFRA * mfra, AtomTFRA * tfra)
+{
+ mfra->tfras = g_list_append (mfra->tfras, tfra);
+}
+
+void
+atom_mfra_free (AtomMFRA * mfra)
+{
+ GList *walker;
+
+ walker = mfra->tfras;
+ while (walker) {
+ atom_tfra_free ((AtomTFRA *) walker->data);
+ walker = g_list_next (walker);
+ }
+ g_list_free (mfra->tfras);
+ mfra->tfras = NULL;
+
+ atom_clear (&mfra->header);
+ g_free (mfra);
+}
+
+static void
+atom_tfra_init (AtomTFRA * tfra, guint32 track_ID)
+{
+ guint8 flags[3] = { 0, 0, 0 };
+
+ atom_full_init (&tfra->header, FOURCC_tfra, 0, 0, 0, flags);
+ tfra->track_ID = track_ID;
+ atom_array_init (&tfra->entries, 512);
+}
+
+AtomTFRA *
+atom_tfra_new (AtomsContext * context, guint32 track_ID)
+{
+ AtomTFRA *tfra = g_new0 (AtomTFRA, 1);
+
+ atom_tfra_init (tfra, track_ID);
+ return tfra;
+
+}
+
+static inline gint
+need_bytes (guint32 num)
+{
+ gint n = 0;
+
+ while (num >>= 8)
+ n++;
+
+ return n;
+}
+
+void
+atom_tfra_add_entry (AtomTFRA * tfra, guint64 dts, guint32 sample_num)
+{
+ TFRAEntry entry;
+
+ entry.time = dts;
+ /* fill in later */
+ entry.moof_offset = 0;
+ /* always write a single trun in a single traf */
+ entry.traf_number = 1;
+ entry.trun_number = 1;
+ entry.sample_number = sample_num;
+
+ /* auto-use 64 bits if needed */
+ if (dts > G_MAXUINT32)
+ tfra->header.version = 1;
+
+ /* 1 byte will always do for traf and trun number,
+ * check how much sample_num needs */
+ tfra->lengths = (tfra->lengths & 0xfc) ||
+ MAX (tfra->lengths, need_bytes (sample_num));
+
+ atom_array_append (&tfra->entries, entry, 256);
+}
+
+void
+atom_tfra_update_offset (AtomTFRA * tfra, guint64 offset)
+{
+ gint i;
+
+ /* auto-use 64 bits if needed */
+ if (offset > G_MAXUINT32)
+ tfra->header.version = 1;
+
+ for (i = atom_array_get_len (&tfra->entries) - 1; i >= 0; i--) {
+ TFRAEntry *entry = &atom_array_index (&tfra->entries, i);
+
+ if (entry->moof_offset)
+ break;
+ entry->moof_offset = offset;
+ }
+}
+
+static guint64
+atom_tfra_copy_data (AtomTFRA * tfra, guint8 ** buffer, guint64 * size,
+ guint64 * offset)
+{
+ guint64 original_offset = *offset;
+ guint32 i;
+ TFRAEntry *entry;
+ guint32 data;
+ guint bytes;
+ guint version;
+
+ if (!atom_full_copy_data (&tfra->header, buffer, size, offset)) {
+ return 0;
+ }
+
+ prop_copy_uint32 (tfra->track_ID, buffer, size, offset);
+ prop_copy_uint32 (tfra->lengths, buffer, size, offset);
+ prop_copy_uint32 (atom_array_get_len (&tfra->entries), buffer, size, offset);
+
+ version = tfra->header.version;
+ for (i = 0; i < atom_array_get_len (&tfra->entries); ++i) {
+ entry = &atom_array_index (&tfra->entries, i);
+ if (version) {
+ prop_copy_uint64 (entry->time, buffer, size, offset);
+ prop_copy_uint64 (entry->moof_offset, buffer, size, offset);
+ } else {
+ prop_copy_uint32 (entry->time, buffer, size, offset);
+ prop_copy_uint32 (entry->moof_offset, buffer, size, offset);
+ }
+
+ bytes = (tfra->lengths & (0x3 << 4)) + 1;
+ data = GUINT32_TO_BE (entry->traf_number);
+ prop_copy_fixed_size_string (((guint8 *) & data) + 4 - bytes, bytes,
+ buffer, size, offset);
+
+ bytes = (tfra->lengths & (0x3 << 2)) + 1;
+ data = GUINT32_TO_BE (entry->trun_number);
+ prop_copy_fixed_size_string (((guint8 *) & data) + 4 - bytes, bytes,
+ buffer, size, offset);
+
+ bytes = (tfra->lengths & (0x3)) + 1;
+ data = GUINT32_TO_BE (entry->sample_number);
+ prop_copy_fixed_size_string (((guint8 *) & data) + 4 - bytes, bytes,
+ buffer, size, offset);
+
+ }
+
+ atom_write_size (buffer, size, offset, original_offset);
+ return *offset - original_offset;
+}
+
+static guint64
+atom_mfro_copy_data (guint32 s, guint8 ** buffer, guint64 * size,
+ guint64 * offset)
+{
+ guint64 original_offset = *offset;
+ guint8 flags[3] = { 0, 0, 0 };
+ AtomFull mfro;
+
+ atom_full_init (&mfro, FOURCC_mfro, 0, 0, 0, flags);
+
+ if (!atom_full_copy_data (&mfro, buffer, size, offset)) {
+ return 0;
+ }
+
+ prop_copy_uint32 (s, buffer, size, offset);
+
+ atom_write_size (buffer, size, offset, original_offset);
+
+ return *offset - original_offset;
+}
+
+
+guint64
+atom_mfra_copy_data (AtomMFRA * mfra, guint8 ** buffer, guint64 * size,
+ guint64 * offset)
+{
+ guint64 original_offset = *offset;
+ GList *walker;
+
+ if (!atom_copy_data (&mfra->header, buffer, size, offset))
+ return 0;
+
+ walker = g_list_first (mfra->tfras);
+ while (walker != NULL) {
+ if (!atom_tfra_copy_data ((AtomTFRA *) walker->data, buffer, size, offset)) {
+ return 0;
+ }
+ walker = g_list_next (walker);
+ }
+
+ /* 16 is the size of the mfro atom */
+ if (!atom_mfro_copy_data (*offset - original_offset + 16, buffer,
+ size, offset))
+ return 0;
+
+ atom_write_size (buffer, size, offset, original_offset);
+ return *offset - original_offset;
+}
+
/* some sample description construction helpers */
AtomInfo *
GList *extension_atoms;
} AtomWAVE;
+typedef struct _TFRAEntry
+{
+ guint64 time;
+ guint64 moof_offset;
+ guint32 traf_number;
+ guint32 trun_number;
+ guint32 sample_number;
+} TFRAEntry;
+
+typedef struct _AtomTFRA
+{
+ AtomFull header;
+
+ guint32 track_ID;
+ guint32 lengths;
+ /* array of entries */
+ ATOM_ARRAY (TFRAEntry) entries;
+} AtomTFRA;
+
+typedef struct _AtomMFRA
+{
+ Atom header;
+
+ /* list of tfra */
+ GList *tfras;
+} AtomMFRA;
+
/*
* Function to serialize an atom
*/
void atom_traf_add_samples (AtomTRAF * traf, guint32 delta,
guint32 size, gboolean sync,
gboolean do_pts, gint64 pts_offset);
+guint32 atom_traf_get_sample_num (AtomTRAF * traf);
void atom_moof_add_traf (AtomMOOF *moof, AtomTRAF *traf);
+AtomMFRA* atom_mfra_new (AtomsContext *context);
+void atom_mfra_free (AtomMFRA *mfra);
+AtomTFRA* atom_tfra_new (AtomsContext *context, guint32 track_ID);
+void atom_tfra_add_entry (AtomTFRA *tfra, guint64 dts, guint32 sample_num);
+void atom_tfra_update_offset (AtomTFRA * tfra, guint64 offset);
+void atom_mfra_add_tfra (AtomMFRA *mfra, AtomTFRA *tfra);
+guint64 atom_mfra_copy_data (AtomMFRA *mfra, guint8 **buffer, guint64 *size, guint64* offset);
+
+
/* media sample description related helpers */
typedef struct
qtpad->traf = NULL;
}
atom_array_clear (&qtpad->fragment_buffers);
+
+ /* reference owned elsewhere */
+ qtpad->tfra = NULL;
}
/*
atom_moov_free (qtmux->moov);
qtmux->moov = NULL;
}
+ if (qtmux->mfra) {
+ atom_mfra_free (qtmux->mfra);
+ qtmux->mfra = NULL;
+ }
if (qtmux->fast_start_file) {
fclose (qtmux->fast_start_file);
g_remove (qtmux->fast_start_file_path);
/* prepare moov and/or tags */
gst_qt_mux_configure_moov (qtmux, NULL);
gst_qt_mux_setup_metadata (qtmux);
- ret = gst_qt_mux_send_moov (qtmux, NULL, FALSE);
+ ret = gst_qt_mux_send_moov (qtmux, &qtmux->header_size, FALSE);
if (ret != GST_FLOW_OK)
return ret;
/* extra atoms */
- ret = gst_qt_mux_send_extra_atoms (qtmux, TRUE, NULL, FALSE);
+ ret =
+ gst_qt_mux_send_extra_atoms (qtmux, TRUE, &qtmux->header_size, FALSE);
if (ret != GST_FLOW_OK)
return ret;
+ /* prepare index */
+ qtmux->mfra = atom_mfra_new (qtmux->context);
} else {
/* extended to ensure some spare space */
ret = gst_qt_mux_send_mdat_header (qtmux, &qtmux->header_size, 0, TRUE);
if (qtmux->fragment_sequence) {
GstEvent *event;
+ if (qtmux->mfra) {
+ guint8 *data = NULL;
+ GstBuffer *buf;
+
+ size = offset = 0;
+ GST_DEBUG_OBJECT (qtmux, "adding mfra");
+ if (!atom_mfra_copy_data (qtmux->mfra, &data, &size, &offset))
+ goto serialize_error;
+ buf = _gst_buffer_new_take_data (data, offset);
+ ret = gst_qt_mux_send_buffer (qtmux, buf, NULL, FALSE);
+ if (ret != GST_FLOW_OK)
+ return ret;
+ }
+
timescale = qtmux->timescale;
/* only mvex duration is updated,
* mvhd should be consistent with empty moov
static GstFlowReturn
gst_qt_mux_pad_fragment_add_buffer (GstQTMux * qtmux, GstQTPad * pad,
- GstBuffer * buf, gboolean force, guint32 nsamples, guint32 delta,
- guint32 size, gboolean sync, gboolean do_pts, gint64 pts_offset)
+ GstBuffer * buf, gboolean force, guint32 nsamples, gint64 dts,
+ guint32 delta, guint32 size, gboolean sync, gboolean do_pts,
+ gint64 pts_offset)
{
GstFlowReturn ret = GST_FLOW_OK;
GstBuffer *buffer;
guint i, total_size;
+ /* now we know where moof ends up, update offset in tfra */
+ if (pad->tfra)
+ atom_tfra_update_offset (pad->tfra, qtmux->header_size);
+
moof = atom_moof_new (qtmux->context, qtmux->fragment_sequence);
/* takes ownership */
atom_moof_add_traf (moof, pad->traf);
atom_moof_copy_data (moof, &data, &size, &offset);
buffer = _gst_buffer_new_take_data (data, offset);
GST_LOG_OBJECT (qtmux, "writing moof size %d", GST_BUFFER_SIZE (buffer));
- ret = gst_qt_mux_send_buffer (qtmux, buffer, NULL, FALSE);
+ ret = gst_qt_mux_send_buffer (qtmux, buffer, &qtmux->header_size, FALSE);
/* and actual data */
total_size = 0;
GST_LOG_OBJECT (qtmux, "writing %d buffers, total_size %d",
atom_array_get_len (&pad->fragment_buffers), total_size);
if (ret == GST_FLOW_OK)
- ret = gst_qt_mux_send_mdat_header (qtmux, NULL, total_size, FALSE);
+ ret = gst_qt_mux_send_mdat_header (qtmux, &qtmux->header_size, total_size,
+ FALSE);
for (i = 0; i < atom_array_get_len (&pad->fragment_buffers); i++) {
if (G_LIKELY (ret == GST_FLOW_OK))
ret = gst_qt_mux_send_buffer (qtmux,
- atom_array_index (&pad->fragment_buffers, i), NULL, FALSE);
+ atom_array_index (&pad->fragment_buffers, i), &qtmux->header_size,
+ FALSE);
else
gst_buffer_unref (atom_array_index (&pad->fragment_buffers, i));
}
atom_array_init (&pad->fragment_buffers, 512);
pad->fragment_duration = gst_util_uint64_scale (qtmux->fragment_duration,
atom_trak_get_timescale (pad->trak), 1000);
+
+ if (G_UNLIKELY (qtmux->mfra && !pad->tfra)) {
+ pad->tfra = atom_tfra_new (qtmux->context, atom_trak_get_id (pad->trak));
+ atom_mfra_add_tfra (qtmux->mfra, pad->tfra);
+ }
}
/* add buffer and metadata */
atom_array_append (&pad->fragment_buffers, buf, 256);
pad->fragment_duration -= delta;
+ if (pad->tfra) {
+ guint32 sn = atom_traf_get_sample_num (pad->traf);
+
+ if ((sync && pad->sync) || (sn == 1 && !pad->sync))
+ atom_tfra_add_entry (pad->tfra, dts, sn);
+ }
+
if (G_UNLIKELY (force))
goto flush;
if (qtmux->fragment_sequence) {
/* ensure that always sync samples are marked as such */
return gst_qt_mux_pad_fragment_add_buffer (qtmux, pad, last_buf,
- buf == NULL, nsamples, scaled_duration, sample_size, !pad->sync || sync,
- do_pts, pts_offset);
+ buf == NULL, nsamples, last_dts, scaled_duration, sample_size,
+ !pad->sync || sync, do_pts, pts_offset);
} else {
atom_trak_add_samples (pad->trak, nsamples, scaled_duration, sample_size,
chunk_offset, sync, do_pts, pts_offset);
ATOM_ARRAY (GstBuffer *) fragment_buffers;
/* running fragment duration */
gint64 fragment_duration;
+ /* optional fragment index book-keeping */
+ AtomTFRA *tfra;
/* if nothing is set, it won't be called */
GstQTPadPrepareBufferFunc prepare_buf_func;
GSList *extra_atoms; /* list of extra top-level atoms (e.g. UUID for xmp)
* Stored as AtomInfo structs */
+ /* fragmented file index */
+ AtomMFRA *mfra;
+
/* fast start */
FILE *fast_start_file;
projects / platform / upstream / gstreamer.git / commitdiff