configure: --enable-shared for libx264.so
[x262.git] / matroska.c
1 /*****************************************************************************
2  * matroska.c:
3  *****************************************************************************
4  * Copyright (C) 2005 x264 project
5  * $Id: $
6  *
7  * Authors: Mike Matsnev
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 #define _LARGEFILE_SOURCE
25 #define _FILE_OFFSET_BITS 64
26
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30
31 #ifdef HAVE_STDINT_H
32 #include <stdint.h>
33 #else
34 #include <inttypes.h>
35 #endif
36
37 #include "matroska.h"
38
39 #define CLSIZE    1048576
40 #define CHECK(x)  do { if ((x) < 0) return -1; } while (0)
41
42 struct mk_Context {
43   struct mk_Context *next, **prev, *parent;
44   struct mk_Writer  *owner;
45   unsigned          id;
46
47   void              *data;
48   unsigned          d_cur, d_max;
49 };
50
51 typedef struct mk_Context mk_Context;
52
53 struct mk_Writer {
54   FILE                *fp;
55
56   unsigned            duration_ptr;
57
58   mk_Context          *root, *cluster, *frame;
59   mk_Context          *freelist;
60   mk_Context          *actlist;
61
62   int64_t             def_duration;
63   int64_t             timescale;
64   int64_t             cluster_tc_scaled;
65   int64_t             frame_tc, prev_frame_tc_scaled, max_frame_tc;
66
67   char                wrote_header, in_frame, keyframe;
68 };
69
70 static mk_Context *mk_createContext(mk_Writer *w, mk_Context *parent, unsigned id) {
71   mk_Context  *c;
72
73   if (w->freelist) {
74     c = w->freelist;
75     w->freelist = w->freelist->next;
76   } else {
77     c = malloc(sizeof(*c));
78     memset(c, 0, sizeof(*c));
79   }
80
81   if (c == NULL)
82     return NULL;
83
84   c->parent = parent;
85   c->owner = w;
86   c->id = id;
87
88   if (c->owner->actlist)
89     c->owner->actlist->prev = &c->next;
90   c->next = c->owner->actlist;
91   c->prev = &c->owner->actlist;
92
93   return c;
94 }
95
96 static int        mk_appendContextData(mk_Context *c, const void *data, unsigned size) {
97   unsigned  ns = c->d_cur + size;
98
99   if (ns > c->d_max) {
100     void      *dp;
101     unsigned  dn = c->d_max ? c->d_max << 1 : 16;
102     while (ns > dn)
103       dn <<= 1;
104
105     dp = realloc(c->data, dn);
106     if (dp == NULL)
107       return -1;
108
109     c->data = dp;
110     c->d_max = dn;
111   }
112
113   memcpy((char*)c->data + c->d_cur, data, size);
114
115   c->d_cur = ns;
116
117   return 0;
118 }
119
120 static int        mk_writeID(mk_Context *c, unsigned id) {
121   unsigned char   c_id[4] = { id >> 24, id >> 16, id >> 8, id };
122
123   if (c_id[0])
124     return mk_appendContextData(c, c_id, 4);
125   if (c_id[1])
126     return mk_appendContextData(c, c_id+1, 3);
127   if (c_id[2])
128     return mk_appendContextData(c, c_id+2, 2);
129   return mk_appendContextData(c, c_id+3, 1);
130 }
131
132 static int        mk_writeSize(mk_Context *c, unsigned size) {
133   unsigned char   c_size[5] = { 0x08, size >> 24, size >> 16, size >> 8, size };
134
135   if (size < 0x7f) {
136     c_size[4] |= 0x80;
137     return mk_appendContextData(c, c_size+4, 1);
138   }
139   if (size < 0x3fff) {
140     c_size[3] |= 0x40;
141     return mk_appendContextData(c, c_size+3, 2);
142   }
143   if (size < 0x1fffff) {
144     c_size[2] |= 0x20;
145     return mk_appendContextData(c, c_size+2, 3);
146   }
147   if (size < 0x0fffffff) {
148     c_size[1] |= 0x10;
149     return mk_appendContextData(c, c_size+1, 4);
150   }
151   return mk_appendContextData(c, c_size, 5);
152 }
153
154 static int        mk_flushContextID(mk_Context *c) {
155   unsigned char ff = 0xff;
156
157   if (c->id == 0)
158     return 0;
159
160   CHECK(mk_writeID(c->parent, c->id));
161   CHECK(mk_appendContextData(c->parent, &ff, 1));
162
163   c->id = 0;
164
165   return 0;
166 }
167
168 static int        mk_flushContextData(mk_Context *c) {
169   if (c->d_cur == 0)
170     return 0;
171
172   if (c->parent)
173     CHECK(mk_appendContextData(c->parent, c->data, c->d_cur));
174   else
175     if (fwrite(c->data, c->d_cur, 1, c->owner->fp) != 1)
176       return -1;
177
178   c->d_cur = 0;
179
180   return 0;
181 }
182
183 static int        mk_closeContext(mk_Context *c, unsigned *off) {
184   if (c->id) {
185     CHECK(mk_writeID(c->parent, c->id));
186     CHECK(mk_writeSize(c->parent, c->d_cur));
187   }
188
189   if (c->parent && off != NULL)
190     *off += c->parent->d_cur;
191
192   CHECK(mk_flushContextData(c));
193
194   if (c->next)
195     c->next->prev = c->prev;
196   *(c->prev) = c->next;
197   c->next = c->owner->freelist;
198   c->owner->freelist = c;
199
200   return 0;
201 }
202
203 static void       mk_destroyContexts(mk_Writer *w) {
204   mk_Context  *cur, *next;
205
206   for (cur = w->freelist; cur; cur = next) {
207     next = cur->next;
208     free(cur->data);
209     free(cur);
210   }
211
212   for (cur = w->actlist; cur; cur = next) {
213     next = cur->next;
214     free(cur->data);
215     free(cur);
216   }
217
218   w->freelist = w->actlist = w->root = NULL;
219 }
220
221 static int        mk_writeStr(mk_Context *c, unsigned id, const char *str) {
222   size_t  len = strlen(str);
223
224   CHECK(mk_writeID(c, id));
225   CHECK(mk_writeSize(c, len));
226   CHECK(mk_appendContextData(c, str, len));
227   return 0;
228 }
229
230 static int        mk_writeBin(mk_Context *c, unsigned id, const void *data, unsigned size) {
231   CHECK(mk_writeID(c, id));
232   CHECK(mk_writeSize(c, size));
233   CHECK(mk_appendContextData(c, data, size));
234   return 0;
235 }
236
237 static int        mk_writeUInt(mk_Context *c, unsigned id, int64_t ui) {
238   unsigned char   c_ui[8] = { ui >> 56, ui >> 48, ui >> 40, ui >> 32, ui >> 24, ui >> 16, ui >> 8, ui };
239   unsigned        i = 0;
240
241   CHECK(mk_writeID(c, id));
242   while (i < 7 && c_ui[i] == 0)
243     ++i;
244   CHECK(mk_writeSize(c, 8 - i));
245   CHECK(mk_appendContextData(c, c_ui+i, 8 - i));
246   return 0;
247 }
248
249 static int        mk_writeSInt(mk_Context *c, unsigned id, int64_t si) {
250   unsigned char   c_si[8] = { si >> 56, si >> 48, si >> 40, si >> 32, si >> 24, si >> 16, si >> 8, si };
251   unsigned        i = 0;
252
253   CHECK(mk_writeID(c, id));
254   if (si < 0)
255     while (i < 7 && c_si[i] == 0xff && c_si[i+1] & 0x80)
256       ++i;
257   else
258     while (i < 7 && c_si[i] == 0 && !(c_si[i+1] & 0x80))
259       ++i;
260   CHECK(mk_writeSize(c, 8 - i));
261   CHECK(mk_appendContextData(c, c_si+i, 8 - i));
262   return 0;
263 }
264
265 static int        mk_writeFloatRaw(mk_Context *c, float f) {
266   union {
267     float f;
268     unsigned u;
269   } u;
270   unsigned char c_f[4];
271
272   u.f = f;
273   c_f[0] = u.u >> 24;
274   c_f[1] = u.u >> 16;
275   c_f[2] = u.u >> 8;
276   c_f[3] = u.u;
277
278   return mk_appendContextData(c, c_f, 4);
279 }
280
281 static int        mk_writeFloat(mk_Context *c, unsigned id, float f) {
282   CHECK(mk_writeID(c, id));
283   CHECK(mk_writeSize(c, 4));
284   CHECK(mk_writeFloatRaw(c, f));
285   return 0;
286 }
287
288 static unsigned   mk_ebmlSizeSize(unsigned s) {
289   if (s < 0x7f)
290     return 1;
291   if (s < 0x3fff)
292     return 2;
293   if (s < 0x1fffff)
294     return 3;
295   if (s < 0x0fffffff)
296     return 4;
297   return 5;
298 }
299
300 static unsigned   mk_ebmlSIntSize(int64_t si) {
301   unsigned char   c_si[8] = { si >> 56, si >> 48, si >> 40, si >> 32, si >> 24, si >> 16, si >> 8, si };
302   unsigned        i = 0;
303
304   if (si < 0)
305     while (i < 7 && c_si[i] == 0xff && c_si[i+1] & 0x80)
306       ++i;
307   else
308     while (i < 7 && c_si[i] == 0 && !(c_si[i+1] & 0x80))
309       ++i;
310
311   return 8 - i;
312 }
313
314 mk_Writer *mk_createWriter(const char *filename) {
315   mk_Writer *w = malloc(sizeof(*w));
316   if (w == NULL)
317     return NULL;
318
319   memset(w, 0, sizeof(*w));
320
321   w->root = mk_createContext(w, NULL, 0);
322   if (w->root == NULL) {
323     free(w);
324     return NULL;
325   }
326
327   w->fp = fopen(filename, "wb");
328   if (w->fp == NULL) {
329     mk_destroyContexts(w);
330     free(w);
331     return NULL;
332   }
333
334   w->timescale = 1000000;
335
336   return w;
337 }
338
339 int       mk_writeHeader(mk_Writer *w, const char *writingApp,
340                          const char *codecID,
341                          const void *codecPrivate, unsigned codecPrivateSize,
342                          int64_t default_frame_duration,
343                          int64_t timescale,
344                          unsigned width, unsigned height,
345                          unsigned d_width, unsigned d_height)
346 {
347   mk_Context  *c, *ti, *v;
348
349   if (w->wrote_header)
350     return -1;
351
352   w->timescale = timescale;
353   w->def_duration = default_frame_duration;
354
355   if ((c = mk_createContext(w, w->root, 0x1a45dfa3)) == NULL) // EBML
356     return -1;
357   CHECK(mk_writeUInt(c, 0x4286, 1)); // EBMLVersion
358   CHECK(mk_writeUInt(c, 0x42f7, 1)); // EBMLReadVersion
359   CHECK(mk_writeUInt(c, 0x42f2, 4)); // EBMLMaxIDLength
360   CHECK(mk_writeUInt(c, 0x42f3, 8)); // EBMLMaxSizeLength
361   CHECK(mk_writeStr(c, 0x4282, "matroska")); // DocType
362   CHECK(mk_writeUInt(c, 0x4287, 1)); // DocTypeVersion
363   CHECK(mk_writeUInt(c, 0x4285, 1)); // DocTypeReadversion
364   CHECK(mk_closeContext(c, 0));
365
366   if ((c = mk_createContext(w, w->root, 0x18538067)) == NULL) // Segment
367     return -1;
368   CHECK(mk_flushContextID(c));
369   CHECK(mk_closeContext(c, 0));
370
371   if ((c = mk_createContext(w, w->root, 0x1549a966)) == NULL) // SegmentInfo
372     return -1;
373   CHECK(mk_writeStr(c, 0x4d80, "Haali Matroska Writer b0"));
374   CHECK(mk_writeStr(c, 0x5741, writingApp));
375   CHECK(mk_writeUInt(c, 0x2ad7b1, w->timescale));
376   CHECK(mk_writeFloat(c, 0x4489, 0));
377   w->duration_ptr = c->d_cur - 4;
378   CHECK(mk_closeContext(c, &w->duration_ptr));
379
380   if ((c = mk_createContext(w, w->root, 0x1654ae6b)) == NULL) // tracks
381     return -1;
382   if ((ti = mk_createContext(w, c, 0xae)) == NULL) // TrackEntry
383     return -1;
384   CHECK(mk_writeUInt(ti, 0xd7, 1)); // TrackNumber
385   CHECK(mk_writeUInt(ti, 0x73c5, 1)); // TrackUID
386   CHECK(mk_writeUInt(ti, 0x83, 1)); // TrackType
387   CHECK(mk_writeUInt(ti, 0x9c, 0)); // FlagLacing
388   CHECK(mk_writeStr(ti, 0x86, codecID)); // CodecID
389   if (codecPrivateSize)
390     CHECK(mk_writeBin(ti, 0x63a2, codecPrivate, codecPrivateSize)); // CodecPrivate
391   if (default_frame_duration)
392     CHECK(mk_writeUInt(ti, 0x23e383, default_frame_duration)); // DefaultDuration
393
394   if ((v = mk_createContext(w, ti, 0xe0)) == NULL) // Video
395     return -1;
396   CHECK(mk_writeUInt(v, 0xb0, width));
397   CHECK(mk_writeUInt(v, 0xba, height));
398   CHECK(mk_writeUInt(v, 0x54b0, d_width));
399   CHECK(mk_writeUInt(v, 0x54ba, d_height));
400   CHECK(mk_closeContext(v, 0));
401
402   CHECK(mk_closeContext(ti, 0));
403
404   CHECK(mk_closeContext(c, 0));
405
406   CHECK(mk_flushContextData(w->root));
407
408   w->wrote_header = 1;
409
410   return 0;
411 }
412
413 static int mk_closeCluster(mk_Writer *w) {
414   if (w->cluster == NULL)
415     return 0;
416   CHECK(mk_closeContext(w->cluster, 0));
417   w->cluster = NULL;
418   CHECK(mk_flushContextData(w->root));
419   return 0;
420 }
421
422 int       mk_flushFrame(mk_Writer *w) {
423   int64_t       delta, ref = 0;
424   unsigned      fsize, bgsize;
425   unsigned char c_delta_flags[3];
426
427   if (!w->in_frame)
428     return 0;
429
430   delta = w->frame_tc/w->timescale - w->cluster_tc_scaled;
431   if (delta > 32767ll || delta < -32768ll)
432     CHECK(mk_closeCluster(w));
433
434   if (w->cluster == NULL) {
435     w->cluster_tc_scaled = w->frame_tc / w->timescale;
436     w->cluster = mk_createContext(w, w->root, 0x1f43b675); // Cluster
437     if (w->cluster == NULL)
438       return -1;
439
440     CHECK(mk_writeUInt(w->cluster, 0xe7, w->cluster_tc_scaled)); // Timecode
441
442     delta = 0;
443   }
444
445   fsize = w->frame ? w->frame->d_cur : 0;
446   bgsize = fsize + 4 + mk_ebmlSizeSize(fsize + 4) + 1;
447   if (!w->keyframe) {
448     ref = w->prev_frame_tc_scaled - w->cluster_tc_scaled - delta;
449     bgsize += 1 + 1 + mk_ebmlSIntSize(ref);
450   }
451
452   CHECK(mk_writeID(w->cluster, 0xa0)); // BlockGroup
453   CHECK(mk_writeSize(w->cluster, bgsize));
454   CHECK(mk_writeID(w->cluster, 0xa1)); // Block
455   CHECK(mk_writeSize(w->cluster, fsize + 4));
456   CHECK(mk_writeSize(w->cluster, 1)); // track number
457
458   c_delta_flags[0] = delta >> 8;
459   c_delta_flags[1] = delta;
460   c_delta_flags[2] = 0;
461   CHECK(mk_appendContextData(w->cluster, c_delta_flags, 3));
462   if (w->frame) {
463     CHECK(mk_appendContextData(w->cluster, w->frame->data, w->frame->d_cur));
464     w->frame->d_cur = 0;
465   }
466   if (!w->keyframe)
467     CHECK(mk_writeSInt(w->cluster, 0xfb, ref)); // ReferenceBlock
468
469   w->in_frame = 0;
470   w->prev_frame_tc_scaled = w->cluster_tc_scaled + delta;
471
472   if (w->cluster->d_cur > CLSIZE)
473     CHECK(mk_closeCluster(w));
474
475   return 0;
476 }
477
478 int       mk_startFrame(mk_Writer *w) {
479   if (mk_flushFrame(w) < 0)
480     return -1;
481
482   w->in_frame = 1;
483   w->keyframe = 0;
484
485   return 0;
486 }
487
488 int       mk_setFrameFlags(mk_Writer *w,int64_t timestamp, int keyframe) {
489   if (!w->in_frame)
490     return -1;
491
492   w->frame_tc = timestamp;
493   w->keyframe = keyframe != 0;
494
495   if (w->max_frame_tc < timestamp)
496     w->max_frame_tc = timestamp;
497
498   return 0;
499 }
500
501 int       mk_addFrameData(mk_Writer *w, const void *data, unsigned size) {
502   if (!w->in_frame)
503     return -1;
504
505   if (w->frame == NULL)
506     if ((w->frame = mk_createContext(w, NULL, 0)) == NULL)
507       return -1;
508
509   return mk_appendContextData(w->frame, data, size);
510 }
511
512 int       mk_close(mk_Writer *w) {
513   int   ret = 0;
514   if (mk_flushFrame(w) < 0 || mk_closeCluster(w) < 0)
515     ret = -1;
516   if (w->wrote_header) {
517     fseek(w->fp, w->duration_ptr, SEEK_SET);
518     if (mk_writeFloatRaw(w->root, (float)((double)(w->max_frame_tc+w->def_duration) / w->timescale)) < 0 ||
519         mk_flushContextData(w->root) < 0)
520       ret = -1;
521   }
522   mk_destroyContexts(w);
523   fclose(w->fp);
524   free(w);
525   return ret;
526 }
527