Send seek event to baseparse when aacparse seek failed in push mode
[platform/upstream/gst-plugins-good.git] / gst / matroska / ebml-write.c
1 /* GStreamer EBML I/O
2  * (c) 2003 Ronald Bultje <rbultje@ronald.bitfreak.net>
3  * (c) 2005 Michal Benes <michal.benes@xeris.cz>
4  *
5  * ebml-write.c: write EBML data to file/stream
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public
18  * License along with this library; if not, write to the
19  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  */
22
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26
27 #include <string.h>
28
29 #include "ebml-write.h"
30 #include "ebml-ids.h"
31
32
33 GST_DEBUG_CATEGORY_STATIC (gst_ebml_write_debug);
34 #define GST_CAT_DEFAULT gst_ebml_write_debug
35
36 #define _do_init \
37       GST_DEBUG_CATEGORY_INIT (gst_ebml_write_debug, "ebmlwrite", 0, "Write EBML structured data")
38 #define parent_class gst_ebml_write_parent_class
39 G_DEFINE_TYPE_WITH_CODE (GstEbmlWrite, gst_ebml_write, GST_TYPE_OBJECT,
40     _do_init);
41
42 static void gst_ebml_write_finalize (GObject * object);
43
44 static void
45 gst_ebml_write_class_init (GstEbmlWriteClass * klass)
46 {
47   GObjectClass *object = G_OBJECT_CLASS (klass);
48
49   object->finalize = gst_ebml_write_finalize;
50 }
51
52 static void
53 gst_ebml_write_init (GstEbmlWrite * ebml)
54 {
55   ebml->srcpad = NULL;
56   ebml->pos = 0;
57   ebml->last_pos = G_MAXUINT64; /* force segment event */
58
59   ebml->cache = NULL;
60   ebml->streamheader = NULL;
61   ebml->streamheader_pos = 0;
62   ebml->writing_streamheader = FALSE;
63   ebml->caps = NULL;
64 }
65
66 static void
67 gst_ebml_write_finalize (GObject * object)
68 {
69   GstEbmlWrite *ebml = GST_EBML_WRITE (object);
70
71   gst_object_unref (ebml->srcpad);
72
73   if (ebml->cache) {
74     gst_byte_writer_free (ebml->cache);
75     ebml->cache = NULL;
76   }
77
78   if (ebml->streamheader) {
79     gst_byte_writer_free (ebml->streamheader);
80     ebml->streamheader = NULL;
81   }
82
83   if (ebml->caps) {
84     gst_caps_unref (ebml->caps);
85     ebml->caps = NULL;
86   }
87
88   G_OBJECT_CLASS (parent_class)->finalize (object);
89 }
90
91
92 /**
93  * gst_ebml_write_new:
94  * @srcpad: Source pad to which the output will be pushed.
95  *
96  * Creates a new #GstEbmlWrite.
97  *
98  * Returns: a new #GstEbmlWrite
99  */
100 GstEbmlWrite *
101 gst_ebml_write_new (GstPad * srcpad)
102 {
103   GstEbmlWrite *ebml =
104       GST_EBML_WRITE (g_object_new (GST_TYPE_EBML_WRITE, NULL));
105
106   ebml->srcpad = gst_object_ref (srcpad);
107   ebml->timestamp = GST_CLOCK_TIME_NONE;
108
109   gst_ebml_write_reset (ebml);
110
111   return ebml;
112 }
113
114
115 /**
116  * gst_ebml_write_reset:
117  * @ebml: a #GstEbmlWrite.
118  *
119  * Reset internal state of #GstEbmlWrite.
120  */
121 void
122 gst_ebml_write_reset (GstEbmlWrite * ebml)
123 {
124   ebml->pos = 0;
125   ebml->last_pos = G_MAXUINT64; /* force segment event */
126
127   if (ebml->cache) {
128     gst_byte_writer_free (ebml->cache);
129     ebml->cache = NULL;
130   }
131
132   if (ebml->caps) {
133     gst_caps_unref (ebml->caps);
134     ebml->caps = NULL;
135   }
136
137   ebml->last_write_result = GST_FLOW_OK;
138   ebml->timestamp = GST_CLOCK_TIME_NONE;
139 }
140
141
142 /**
143  * gst_ebml_last_write_result:
144  * @ebml: a #GstEbmlWrite.
145  *
146  * Returns: GST_FLOW_OK if there was not write error since the last call of
147  *          gst_ebml_last_write_result or code of the error.
148  */
149 GstFlowReturn
150 gst_ebml_last_write_result (GstEbmlWrite * ebml)
151 {
152   GstFlowReturn res = ebml->last_write_result;
153
154   ebml->last_write_result = GST_FLOW_OK;
155
156   return res;
157 }
158
159
160 void
161 gst_ebml_start_streamheader (GstEbmlWrite * ebml)
162 {
163   g_return_if_fail (ebml->streamheader == NULL);
164
165   GST_DEBUG ("Starting streamheader at %" G_GUINT64_FORMAT, ebml->pos);
166   ebml->streamheader = gst_byte_writer_new_with_size (1000, FALSE);
167   ebml->streamheader_pos = ebml->pos;
168   ebml->writing_streamheader = TRUE;
169 }
170
171 GstBuffer *
172 gst_ebml_stop_streamheader (GstEbmlWrite * ebml)
173 {
174   GstBuffer *buffer;
175
176   if (!ebml->streamheader)
177     return NULL;
178
179   buffer = gst_byte_writer_free_and_get_buffer (ebml->streamheader);
180   ebml->streamheader = NULL;
181   GST_DEBUG ("Streamheader was size %" G_GSIZE_FORMAT,
182       gst_buffer_get_size (buffer));
183
184   ebml->writing_streamheader = FALSE;
185   return buffer;
186 }
187
188 /**
189  * gst_ebml_write_set_cache:
190  * @ebml: a #GstEbmlWrite.
191  * @size: size of the cache.
192  * Create a cache.
193  *
194  * The idea is that you use this for writing a lot
195  * of small elements. This will just "queue" all of
196  * them and they'll be pushed to the next element all
197  * at once. This saves memory and time for buffer
198  * allocation and init, and it looks better.
199  */
200 void
201 gst_ebml_write_set_cache (GstEbmlWrite * ebml, guint size)
202 {
203   g_return_if_fail (ebml->cache == NULL);
204
205   GST_DEBUG ("Starting cache at %" G_GUINT64_FORMAT, ebml->pos);
206   ebml->cache = gst_byte_writer_new_with_size (size, FALSE);
207   ebml->cache_pos = ebml->pos;
208 }
209
210 static gboolean
211 gst_ebml_writer_send_segment_event (GstEbmlWrite * ebml, guint64 new_pos)
212 {
213   GstSegment segment;
214   gboolean res;
215
216   GST_INFO ("seeking to %" G_GUINT64_FORMAT, new_pos);
217
218   gst_segment_init (&segment,
219       ebml->streamable ? GST_FORMAT_TIME : GST_FORMAT_BYTES);
220   segment.start = new_pos;
221   segment.stop = -1;
222   segment.position = 0;
223
224   res = gst_pad_push_event (ebml->srcpad, gst_event_new_segment (&segment));
225
226   if (!res)
227     GST_WARNING ("seek to %" G_GUINT64_FORMAT "failed", new_pos);
228
229   return res;
230 }
231
232 /**
233  * gst_ebml_write_flush_cache:
234  * @ebml:      a #GstEbmlWrite.
235  * @timestamp: timestamp of the buffer.
236  *
237  * Flush the cache.
238  */
239 void
240 gst_ebml_write_flush_cache (GstEbmlWrite * ebml, gboolean is_keyframe,
241     GstClockTime timestamp)
242 {
243   GstBuffer *buffer;
244
245   if (!ebml->cache)
246     return;
247
248   buffer = gst_byte_writer_free_and_get_buffer (ebml->cache);
249   ebml->cache = NULL;
250   GST_DEBUG ("Flushing cache of size %" G_GSIZE_FORMAT,
251       gst_buffer_get_size (buffer));
252   GST_BUFFER_TIMESTAMP (buffer) = timestamp;
253   GST_BUFFER_OFFSET (buffer) = ebml->pos - gst_buffer_get_size (buffer);
254   GST_BUFFER_OFFSET_END (buffer) = ebml->pos;
255   if (ebml->last_write_result == GST_FLOW_OK) {
256     if (GST_BUFFER_OFFSET (buffer) != ebml->last_pos) {
257       gst_ebml_writer_send_segment_event (ebml, GST_BUFFER_OFFSET (buffer));
258       GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
259     } else {
260       GST_BUFFER_FLAG_UNSET (buffer, GST_BUFFER_FLAG_DISCONT);
261     }
262     if (ebml->writing_streamheader) {
263       GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_HEADER);
264     } else {
265       GST_BUFFER_FLAG_UNSET (buffer, GST_BUFFER_FLAG_HEADER);
266     }
267     if (!is_keyframe) {
268       GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
269     }
270     ebml->last_pos = ebml->pos;
271     ebml->last_write_result = gst_pad_push (ebml->srcpad, buffer);
272   } else {
273     gst_buffer_unref (buffer);
274   }
275 }
276
277
278 /**
279  * gst_ebml_write_element_new:
280  * @ebml: a #GstEbmlWrite.
281  * @size: size of the requested buffer.
282  *
283  * Create a buffer for one element. If there is
284  * a cache, use that instead.
285  *
286  * Returns: A new #GstBuffer.
287  */
288 static GstBuffer *
289 gst_ebml_write_element_new (GstEbmlWrite * ebml, GstMapInfo * map, guint size)
290 {
291   /* Create new buffer of size + ID + length */
292   GstBuffer *buf;
293
294   /* length, ID */
295   size += 12;
296
297   buf = gst_buffer_new_and_alloc (size);
298   GST_BUFFER_TIMESTAMP (buf) = ebml->timestamp;
299
300   /* FIXME unmap not possible */
301   gst_buffer_map (buf, map, GST_MAP_WRITE);
302
303   return buf;
304 }
305
306
307 /**
308  * gst_ebml_write_element_id:
309  * @data_inout: Pointer to data pointer
310  * @id: Element ID that should be written.
311  * 
312  * Write element ID into a buffer.
313  */
314 static void
315 gst_ebml_write_element_id (guint8 ** data_inout, guint32 id)
316 {
317   guint8 *data = *data_inout;
318   guint bytes = 4, mask = 0x10;
319
320   /* get ID length */
321   while (!(id & (mask << ((bytes - 1) * 8))) && bytes > 0) {
322     mask <<= 1;
323     bytes--;
324   }
325
326   /* if invalid ID, use dummy */
327   if (bytes == 0) {
328     GST_WARNING ("Invalid ID, voiding");
329     bytes = 1;
330     id = GST_EBML_ID_VOID;
331   }
332
333   /* write out, BE */
334   *data_inout += bytes;
335   while (bytes--) {
336     data[bytes] = id & 0xff;
337     id >>= 8;
338   }
339 }
340
341
342 /**
343  * gst_ebml_write_element_size:
344  * @data_inout: Pointer to data pointer
345  * @size: Element length.
346  *
347  * Write element length into a buffer.
348  */
349 static void
350 gst_ebml_write_element_size (guint8 ** data_inout, guint64 size)
351 {
352   guint8 *data = *data_inout;
353   guint bytes = 1, mask = 0x80;
354
355   if (size != GST_EBML_SIZE_UNKNOWN) {
356     /* how many bytes? - use mask-1 because an all-1 bitset is not allowed */
357     while (bytes <= 8 && (size >> ((bytes - 1) * 8)) >= (mask - 1)) {
358       mask >>= 1;
359       bytes++;
360     }
361
362     /* if invalid size, use max. */
363     if (bytes > 8) {
364       GST_WARNING ("Invalid size, writing size unknown");
365       mask = 0x01;
366       bytes = 8;
367       /* Now here's a real FIXME: we cannot read those yet! */
368       size = GST_EBML_SIZE_UNKNOWN;
369     }
370   } else {
371     mask = 0x01;
372     bytes = 8;
373   }
374
375   /* write out, BE, with length size marker */
376   *data_inout += bytes;
377   while (bytes-- > 0) {
378     data[bytes] = size & 0xff;
379     size >>= 8;
380     if (!bytes)
381       *data |= mask;
382   }
383 }
384
385
386 /**
387  * gst_ebml_write_element_data:
388  * @data_inout: Pointer to data pointer
389  * @write: Data that should be written.
390  * @length: Length of the data.
391  *
392  * Write element data into a buffer.
393  */
394 static void
395 gst_ebml_write_element_data (guint8 ** data_inout, guint8 * write,
396     guint64 length)
397 {
398   memcpy (*data_inout, write, length);
399   *data_inout += length;
400 }
401
402
403 /**
404  * gst_ebml_write_element_push:
405  * @ebml: #GstEbmlWrite
406  * @buf: #GstBuffer to be written.
407  * @buf_data: Start of data to push from @buf (or NULL for whole buffer).
408  * @buf_data_end: Data pointer positioned after the last byte in @buf_data (or
409  * NULL for whole buffer).
410  * 
411  * Write out buffer by moving it to the next element.
412  */
413 static void
414 gst_ebml_write_element_push (GstEbmlWrite * ebml, GstBuffer * buf,
415     guint8 * buf_data, guint8 * buf_data_end)
416 {
417   GstMapInfo map;
418   guint data_size;
419
420   map.data = NULL;
421
422   if (buf_data_end)
423     data_size = buf_data_end - buf_data;
424   else
425     data_size = gst_buffer_get_size (buf);
426
427   ebml->pos += data_size;
428
429   /* if there's no cache, then don't push it! */
430   if (ebml->writing_streamheader) {
431     if (!buf_data) {
432       gst_buffer_map (buf, &map, GST_MAP_READ);
433       buf_data = map.data;
434     }
435     if (!buf_data)
436       GST_WARNING ("Failed to map buffer");
437     else if (!gst_byte_writer_put_data (ebml->streamheader, buf_data,
438             data_size))
439       GST_WARNING ("Error writing data to streamheader");
440   }
441   if (ebml->cache) {
442     if (!buf_data) {
443       gst_buffer_map (buf, &map, GST_MAP_READ);
444       buf_data = map.data;
445     }
446     if (!buf_data)
447       GST_WARNING ("Failed to map buffer");
448     else if (!gst_byte_writer_put_data (ebml->cache, buf_data, data_size))
449       GST_WARNING ("Error writing data to cache");
450     if (map.data)
451       gst_buffer_unmap (buf, &map);
452     gst_buffer_unref (buf);
453     return;
454   }
455
456   if (buf_data && map.data)
457     gst_buffer_unmap (buf, &map);
458
459   if (ebml->last_write_result == GST_FLOW_OK) {
460     buf = gst_buffer_make_writable (buf);
461     GST_BUFFER_OFFSET (buf) = ebml->pos - data_size;
462     GST_BUFFER_OFFSET_END (buf) = ebml->pos;
463     if (ebml->writing_streamheader) {
464       GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_HEADER);
465     } else {
466       GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_HEADER);
467     }
468     GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DELTA_UNIT);
469
470     if (GST_BUFFER_OFFSET (buf) != ebml->last_pos) {
471       gst_ebml_writer_send_segment_event (ebml, GST_BUFFER_OFFSET (buf));
472       GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_DISCONT);
473     } else {
474       GST_BUFFER_FLAG_UNSET (buf, GST_BUFFER_FLAG_DISCONT);
475     }
476     ebml->last_pos = ebml->pos;
477     ebml->last_write_result = gst_pad_push (ebml->srcpad, buf);
478   } else {
479     gst_buffer_unref (buf);
480   }
481 }
482
483
484 /**
485  * gst_ebml_write_seek:
486  * @ebml: #GstEbmlWrite
487  * @pos: Seek position.
488  * 
489  * Seek.
490  */
491 void
492 gst_ebml_write_seek (GstEbmlWrite * ebml, guint64 pos)
493 {
494   if (ebml->writing_streamheader) {
495     GST_DEBUG ("wanting to seek to pos %" G_GUINT64_FORMAT, pos);
496     if (pos >= ebml->streamheader_pos &&
497         pos <= ebml->streamheader_pos + ebml->streamheader->parent.size) {
498       gst_byte_writer_set_pos (ebml->streamheader,
499           pos - ebml->streamheader_pos);
500       GST_DEBUG ("seeked in streamheader to position %" G_GUINT64_FORMAT,
501           pos - ebml->streamheader_pos);
502     } else {
503       GST_WARNING
504           ("we are writing streamheader still and seek is out of bounds");
505     }
506   }
507   /* Cache seeking. A bit dangerous, we assume the client writer
508    * knows what he's doing... */
509   if (ebml->cache) {
510     /* within bounds? */
511     if (pos >= ebml->cache_pos &&
512         pos <= ebml->cache_pos + ebml->cache->parent.size) {
513       GST_DEBUG ("seeking in cache to %" G_GUINT64_FORMAT, pos);
514       ebml->pos = pos;
515       gst_byte_writer_set_pos (ebml->cache, ebml->pos - ebml->cache_pos);
516       return;
517     } else {
518       GST_LOG ("Seek outside cache range. Clearing...");
519       gst_ebml_write_flush_cache (ebml, FALSE, GST_CLOCK_TIME_NONE);
520     }
521   }
522
523   GST_INFO ("scheduling seek to %" G_GUINT64_FORMAT, pos);
524   ebml->pos = pos;
525 }
526
527
528 /**
529  * gst_ebml_write_get_uint_size:
530  * @num: Number to be encoded.
531  * 
532  * Get number of bytes needed to write a uint.
533  *
534  * Returns: Encoded uint length.
535  */
536 static guint
537 gst_ebml_write_get_uint_size (guint64 num)
538 {
539   guint size = 1;
540
541   /* get size */
542   while (size < 8 && num >= (G_GINT64_CONSTANT (1) << (size * 8))) {
543     size++;
544   }
545
546   return size;
547 }
548
549
550 /**
551  * gst_ebml_write_set_uint:
552  * @data_inout: Pointer to data pointer
553  * @num: Number to be written.
554  * @size: Encoded number length.
555  *
556  * Write an uint into a buffer.
557  */
558 static void
559 gst_ebml_write_set_uint (guint8 ** data_inout, guint64 num, guint size)
560 {
561   guint8 *data = *data_inout;
562
563   *data_inout += size;
564
565   while (size-- > 0) {
566     data[size] = num & 0xff;
567     num >>= 8;
568   }
569 }
570
571
572 /**
573  * gst_ebml_write_uint:
574  * @ebml: #GstEbmlWrite
575  * @id: Element ID.
576  * @num: Number to be written.
577  *
578  * Write uint element.
579  */
580 void
581 gst_ebml_write_uint (GstEbmlWrite * ebml, guint32 id, guint64 num)
582 {
583   GstBuffer *buf;
584   guint8 *data_start, *data_end;
585   guint size = gst_ebml_write_get_uint_size (num);
586   GstMapInfo map;
587
588   buf = gst_ebml_write_element_new (ebml, &map, sizeof (num));
589   data_end = data_start = map.data;
590
591   /* write */
592   gst_ebml_write_element_id (&data_end, id);
593   gst_ebml_write_element_size (&data_end, size);
594   gst_ebml_write_set_uint (&data_end, num, size);
595   gst_buffer_unmap (buf, &map);
596   gst_buffer_set_size (buf, (data_end - data_start));
597
598   gst_ebml_write_element_push (ebml, buf, data_start, data_end);
599 }
600
601
602 /**
603  * gst_ebml_write_sint:
604  * @ebml: #GstEbmlWrite
605  * @id: Element ID.
606  * @num: Number to be written.
607  *
608  * Write sint element.
609  */
610 void
611 gst_ebml_write_sint (GstEbmlWrite * ebml, guint32 id, gint64 num)
612 {
613   GstBuffer *buf;
614   guint8 *data_start, *data_end;
615   GstMapInfo map;
616
617   /* if the signed number is on the edge of a extra-byte,
618    * then we'll fall over when detecting it. Example: if I
619    * have a number (-)0x8000 (G_MINSHORT), then my abs()<<1
620    * will be 0x10000; this is G_MAXUSHORT+1! So: if (<0) -1. */
621   guint64 unum = (num < 0 ? (-num - 1) << 1 : num << 1);
622   guint size = gst_ebml_write_get_uint_size (unum);
623
624   buf = gst_ebml_write_element_new (ebml, &map, sizeof (num));
625   data_end = data_start = map.data;
626
627   /* make unsigned */
628   if (num >= 0) {
629     unum = num;
630   } else {
631     unum = ((guint64) 0x80) << ((size - 1) * 8);
632     unum += num;
633     unum |= ((guint64) 0x80) << ((size - 1) * 8);
634   }
635
636   /* write */
637   gst_ebml_write_element_id (&data_end, id);
638   gst_ebml_write_element_size (&data_end, size);
639   gst_ebml_write_set_uint (&data_end, unum, size);
640   gst_buffer_unmap (buf, &map);
641   gst_buffer_set_size (buf, (data_end - data_start));
642
643   gst_ebml_write_element_push (ebml, buf, data_start, data_end);
644 }
645
646
647 /**
648  * gst_ebml_write_float:
649  * @ebml: #GstEbmlWrite
650  * @id: Element ID.
651  * @num: Number to be written.
652  *
653  * Write float element.
654  */
655 void
656 gst_ebml_write_float (GstEbmlWrite * ebml, guint32 id, gdouble num)
657 {
658   GstBuffer *buf;
659   GstMapInfo map;
660   guint8 *data_start, *data_end;
661
662   buf = gst_ebml_write_element_new (ebml, &map, sizeof (num));
663   data_end = data_start = map.data;
664
665   gst_ebml_write_element_id (&data_end, id);
666   gst_ebml_write_element_size (&data_end, 8);
667   num = GDOUBLE_TO_BE (num);
668   gst_ebml_write_element_data (&data_end, (guint8 *) & num, 8);
669   gst_buffer_unmap (buf, &map);
670   gst_buffer_set_size (buf, (data_end - data_start));
671
672   gst_ebml_write_element_push (ebml, buf, data_start, data_end);
673 }
674
675
676 /**
677  * gst_ebml_write_ascii:
678  * @ebml: #GstEbmlWrite
679  * @id: Element ID.
680  * @str: String to be written.
681  *
682  * Write string element.
683  */
684 void
685 gst_ebml_write_ascii (GstEbmlWrite * ebml, guint32 id, const gchar * str)
686 {
687   gint len = strlen (str) + 1;  /* add trailing '\0' */
688   GstBuffer *buf;
689   GstMapInfo map;
690   guint8 *data_start, *data_end;
691
692   buf = gst_ebml_write_element_new (ebml, &map, len);
693   data_end = data_start = map.data;
694
695   gst_ebml_write_element_id (&data_end, id);
696   gst_ebml_write_element_size (&data_end, len);
697   gst_ebml_write_element_data (&data_end, (guint8 *) str, len);
698   gst_buffer_unmap (buf, &map);
699   gst_buffer_set_size (buf, (data_end - data_start));
700
701   gst_ebml_write_element_push (ebml, buf, data_start, data_end);
702 }
703
704
705 /**
706  * gst_ebml_write_utf8:
707  * @ebml: #GstEbmlWrite
708  * @id: Element ID.
709  * @str: String to be written.
710  *
711  * Write utf8 encoded string element.
712  */
713 void
714 gst_ebml_write_utf8 (GstEbmlWrite * ebml, guint32 id, const gchar * str)
715 {
716   gst_ebml_write_ascii (ebml, id, str);
717 }
718
719
720 /**
721  * gst_ebml_write_date:
722  * @ebml: #GstEbmlWrite
723  * @id: Element ID.
724  * @date: Date in seconds since the unix epoch.
725  *
726  * Write date element.
727  */
728 void
729 gst_ebml_write_date (GstEbmlWrite * ebml, guint32 id, gint64 date)
730 {
731   gst_ebml_write_sint (ebml, id, (date - GST_EBML_DATE_OFFSET) * GST_SECOND);
732 }
733
734 /**
735  * gst_ebml_write_master_start:
736  * @ebml: #GstEbmlWrite
737  * @id: Element ID.
738  *
739  * Start wiriting mater element.
740  *
741  * Master writing is annoying. We use a size marker of
742  * the max. allowed length, so that we can later fill it
743  * in validly. 
744  *
745  * Returns: Master starting position.
746  */
747 guint64
748 gst_ebml_write_master_start (GstEbmlWrite * ebml, guint32 id)
749 {
750   guint64 pos = ebml->pos;
751   GstBuffer *buf;
752   GstMapInfo map;
753   guint8 *data_start, *data_end;
754
755   buf = gst_ebml_write_element_new (ebml, &map, 0);
756   data_end = data_start = map.data;
757
758   gst_ebml_write_element_id (&data_end, id);
759   pos += data_end - data_start;
760   gst_ebml_write_element_size (&data_end, GST_EBML_SIZE_UNKNOWN);
761   gst_buffer_unmap (buf, &map);
762   gst_buffer_set_size (buf, (data_end - data_start));
763
764   gst_ebml_write_element_push (ebml, buf, data_start, data_end);
765
766   return pos;
767 }
768
769
770 /**
771  * gst_ebml_write_master_finish_full:
772  * @ebml: #GstEbmlWrite
773  * @startpos: Master starting position.
774  *
775  * Finish writing master element.  Size of master element is difference between
776  * current position and the element start, and @extra_size added to this.
777  */
778 void
779 gst_ebml_write_master_finish_full (GstEbmlWrite * ebml, guint64 startpos,
780     guint64 extra_size)
781 {
782   guint64 pos = ebml->pos;
783   guint8 *data = g_malloc (8);
784   GstBuffer *buf = gst_buffer_new_wrapped (data, 8);
785
786   gst_ebml_write_seek (ebml, startpos);
787
788   GST_WRITE_UINT64_BE (data,
789       (G_GINT64_CONSTANT (1) << 56) | (pos - startpos - 8 + extra_size));
790
791   gst_ebml_write_element_push (ebml, buf, NULL, NULL);
792   gst_ebml_write_seek (ebml, pos);
793 }
794
795 void
796 gst_ebml_write_master_finish (GstEbmlWrite * ebml, guint64 startpos)
797 {
798   gst_ebml_write_master_finish_full (ebml, startpos, 0);
799 }
800
801 /**
802  * gst_ebml_write_binary:
803  * @ebml: #GstEbmlWrite
804  * @id: Element ID.
805  * @binary: Data to be written.
806  * @length: Length of the data
807  *
808  * Write an element with binary data.
809  */
810 void
811 gst_ebml_write_binary (GstEbmlWrite * ebml,
812     guint32 id, guint8 * binary, guint64 length)
813 {
814   GstBuffer *buf;
815   GstMapInfo map;
816   guint8 *data_start, *data_end;
817
818   buf = gst_ebml_write_element_new (ebml, &map, length);
819   data_end = data_start = map.data;
820
821   gst_ebml_write_element_id (&data_end, id);
822   gst_ebml_write_element_size (&data_end, length);
823   gst_ebml_write_element_data (&data_end, binary, length);
824   gst_buffer_unmap (buf, &map);
825   gst_buffer_set_size (buf, (data_end - data_start));
826
827   gst_ebml_write_element_push (ebml, buf, data_start, data_end);
828 }
829
830
831 /**
832  * gst_ebml_write_buffer_header:
833  * @ebml: #GstEbmlWrite
834  * @id: Element ID.
835  * @length: Length of the data
836  * 
837  * Write header of the binary element (use with gst_ebml_write_buffer function).
838  * 
839  * For things like video frames and audio samples,
840  * you want to use this function, as it doesn't have
841  * the overhead of memcpy() that other functions
842  * such as write_binary() do have.
843  */
844 void
845 gst_ebml_write_buffer_header (GstEbmlWrite * ebml, guint32 id, guint64 length)
846 {
847   GstBuffer *buf;
848   GstMapInfo map;
849   guint8 *data_start, *data_end;
850
851   buf = gst_ebml_write_element_new (ebml, &map, 0);
852   data_end = data_start = map.data;
853
854   gst_ebml_write_element_id (&data_end, id);
855   gst_ebml_write_element_size (&data_end, length);
856   gst_buffer_unmap (buf, &map);
857   gst_buffer_set_size (buf, (data_end - data_start));
858
859   gst_ebml_write_element_push (ebml, buf, data_start, data_end);
860 }
861
862
863 /**
864  * gst_ebml_write_buffer:
865  * @ebml: #GstEbmlWrite
866  * @buf: #GstBuffer cointaining the data.
867  *
868  * Write  binary element (see gst_ebml_write_buffer_header).
869  */
870 void
871 gst_ebml_write_buffer (GstEbmlWrite * ebml, GstBuffer * buf)
872 {
873   gst_ebml_write_element_push (ebml, buf, NULL, NULL);
874 }
875
876
877 /**
878  * gst_ebml_replace_uint:
879  * @ebml: #GstEbmlWrite
880  * @pos: Position of the uint that should be replaced.
881  * @num: New value.
882  *
883  * Replace uint with a new value.
884  * 
885  * When replacing a uint, we assume that it is *always*
886  * 8-byte, since that's the safest guess we can do. This
887  * is just for simplicity.
888  *
889  * FIXME: this function needs to be replaced with something
890  * proper. This is a crude hack.
891  */
892 void
893 gst_ebml_replace_uint (GstEbmlWrite * ebml, guint64 pos, guint64 num)
894 {
895   guint64 oldpos = ebml->pos;
896   guint8 *data_start, *data_end;
897   GstBuffer *buf;
898
899   data_start = g_malloc (8);
900   data_end = data_start;
901   buf = gst_buffer_new_wrapped (data_start, 8);
902
903   gst_ebml_write_seek (ebml, pos);
904   gst_ebml_write_set_uint (&data_end, num, 8);
905
906   gst_ebml_write_element_push (ebml, buf, data_start, data_end);
907   gst_ebml_write_seek (ebml, oldpos);
908 }
909
910 /**
911  * gst_ebml_write_header:
912  * @ebml: #GstEbmlWrite
913  * @doctype: Document type.
914  * @version: Document type version.
915  * 
916  * Write EBML header.
917  */
918 void
919 gst_ebml_write_header (GstEbmlWrite * ebml, const gchar * doctype,
920     guint version)
921 {
922   guint64 pos;
923
924   /* write the basic EBML header */
925   gst_ebml_write_set_cache (ebml, 0x40);
926   pos = gst_ebml_write_master_start (ebml, GST_EBML_ID_HEADER);
927 #if (GST_EBML_VERSION != 1)
928   gst_ebml_write_uint (ebml, GST_EBML_ID_EBMLVERSION, GST_EBML_VERSION);
929   gst_ebml_write_uint (ebml, GST_EBML_ID_EBMLREADVERSION, GST_EBML_VERSION);
930 #endif
931 #if 0
932   /* we don't write these until they're "non-default" (never!) */
933   gst_ebml_write_uint (ebml, GST_EBML_ID_EBMLMAXIDLENGTH, sizeof (guint32));
934   gst_ebml_write_uint (ebml, GST_EBML_ID_EBMLMAXSIZELENGTH, sizeof (guint64));
935 #endif
936   gst_ebml_write_ascii (ebml, GST_EBML_ID_DOCTYPE, doctype);
937   gst_ebml_write_uint (ebml, GST_EBML_ID_DOCTYPEVERSION, version);
938   gst_ebml_write_uint (ebml, GST_EBML_ID_DOCTYPEREADVERSION, version);
939   gst_ebml_write_master_finish (ebml, pos);
940   gst_ebml_write_flush_cache (ebml, FALSE, 0);
941 }