src/ebml.c

   1 /*****************************************************************************
   2  * matroska.c:
   3  *****************************************************************************
   4  * Copyright (C) 2005 x264 project
   5  * $Id: $
   6  *
   7  * Authors: Mike Matsnev
   8  *          Nathan Caldwell
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24 #include "libmkv.h"
  25 #include "matroska.h"
  26 #include "config.h"
  27
  28 mk_Context *mk_createContext(mk_Writer *w, mk_Context *parent, unsigned id) {
  29   mk_Context  *c;
  30
  31   if (w->freelist) {
  32     c = w->freelist;
  33     w->freelist = w->freelist->next;
  34   } else {
  35     c = malloc(sizeof(*c));
  36     memset(c, 0, sizeof(*c));
  37   }
  38
  39   if (c == NULL)
  40     return NULL;
  41
  42   c->parent = parent;
  43   c->owner = w;
  44   c->id = id;
  45
  46   if (c->owner->actlist)
  47     c->owner->actlist->prev = &c->next;
  48   c->next = c->owner->actlist;
  49   c->prev = &c->owner->actlist;
  50
  51   return c;
  52 }
  53
  54 int    mk_appendContextData(mk_Context *c, const void *data, uint64_t size) {
  55   uint64_t  ns = c->d_cur + size;
  56
  57   if (ns > c->d_max) {
  58     void      *dp;
  59     uint64_t  dn = c->d_max ? c->d_max << 1 : 16;
  60     while (ns > dn)
  61       dn <<= 1;
  62
  63     dp = realloc(c->data, dn);
  64     if (dp == NULL)
  65       return -1;
  66
  67     c->data = dp;
  68     c->d_max = dn;
  69   }
  70
  71   memcpy((char*)c->data + c->d_cur, data, size);
  72
  73   c->d_cur = ns;
  74
  75   return 0;
  76 }
  77
  78 int    mk_writeID(mk_Context *c, unsigned id) {
  79   unsigned char   c_id[4] = { id >> 24, id >> 16, id >> 8, id };
  80
  81   if (c_id[0])
  82     return mk_appendContextData(c, c_id, 4);
  83   if (c_id[1])
  84     return mk_appendContextData(c, c_id+1, 3);
  85   if (c_id[2])
  86     return mk_appendContextData(c, c_id+2, 2);
  87   return mk_appendContextData(c, c_id+3, 1);
  88 }
  89
  90 int    mk_writeSize(mk_Context *c, uint64_t size) {
  91   unsigned char   c_size[8] = { 0x01, size >> 48, size >> 40, size >> 32, size >> 24, size >> 16, size >> 8, size };
  92
  93   if (size < 0x7f) {
  94     c_size[7] |= 0x80;
  95     return mk_appendContextData(c, c_size+7, 1);
  96   }
  97   if (size < 0x3fff) {
  98     c_size[6] |= 0x40;
  99     return mk_appendContextData(c, c_size+6, 2);
 100   }
 101   if (size < 0x1fffff) {
 102     c_size[5] |= 0x20;
 103     return mk_appendContextData(c, c_size+5, 3);
 104   }
 105   if (size < 0x0fffffff) {
 106     c_size[4] |= 0x10;
 107     return mk_appendContextData(c, c_size+4, 4);
 108   }
 109   if (size < 0x07ffffffff) {
 110     c_size[3] |= 0x08;
 111     return mk_appendContextData(c, c_size+3, 5);
 112   }
 113   if (size < 0x03ffffffffff) {
 114     c_size[2] |= 0x04;
 115     return mk_appendContextData(c, c_size+2, 6);
 116   }
 117   if (size < 0x01ffffffffffff) {
 118     c_size[1] |= 0x02;
 119     return mk_appendContextData(c, c_size+1, 7);
 120   }
 121   return mk_appendContextData(c, c_size, 9);
 122 }
 123
 124 int    mk_writeSSize(mk_Context *c, int64_t size) {
 125   uint64_t    u_size = (uint64_t)llabs(size);
 126   unsigned    size_size = mk_ebmlSizeSize( u_size << 1 ); // We need to shift by one to get the correct size here.
 127
 128   switch (size_size)
 129   {
 130     case 1:
 131       size += 0x3f;
 132       break;
 133     case 2:
 134       size += 0x1fff;
 135       break;
 136     case 3:
 137       size += 0x0fffff;
 138       break;
 139     case 4:
 140       size += 0x07ffffff;
 141       break;
 142     case 5:
 143       size += 0x03ffffffff;
 144       break;
 145     case 6:
 146       size += 0x01ffffffffff;
 147       break;
 148     case 7:
 149       size += 0x00ffffffffffff;
 150       break;
 151       default:    // Matroska currently doesn't support any int > 56-bit.
 152         return -1;
 153   }
 154
 155   return mk_writeSize(c, size);
 156 }
 157
 158 int    mk_flushContextID(mk_Context *c) {
 159   unsigned char size_undf[8] = {0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 160
 161   if (c->id == 0)
 162     return 0;
 163
 164   CHECK(mk_writeID(c->parent, c->id));
 165   CHECK(mk_appendContextData(c->parent, &size_undf, 8));
 166
 167   c->id = 0;
 168
 169   return 0;
 170 }
 171
 172 int    mk_flushContextData(mk_Context *c) {
 173   if (c->d_cur == 0)
 174     return 0;
 175
 176   if (c->parent)
 177     CHECK(mk_appendContextData(c->parent, c->data, c->d_cur));
 178   else {
 179     if (fwrite(c->data, c->d_cur, 1, c->owner->fp) != 1)
 180       return -1;
 181     w->f_pos += c->d_cur;
 182     if (w->f_pos > w->f_eof)
 183       w->f_eof = w->f_pos;
 184   }
 185
 186   c->d_cur = 0;
 187
 188   return 0;
 189 }
 190
 191 int    mk_closeContext(mk_Context *c, off_t *off) {
 192   if (c->id) {
 193     CHECK(mk_writeID(c->parent, c->id));
 194     CHECK(mk_writeSize(c->parent, c->d_cur));
 195   }
 196
 197   if (c->parent && off != NULL)
 198     *off += c->parent->d_cur;
 199
 200   CHECK(mk_flushContextData(c));
 201
 202   if (c->next)
 203     c->next->prev = c->prev;
 204   *(c->prev) = c->next;
 205   c->next = c->owner->freelist;
 206   c->owner->freelist = c;
 207
 208   return 0;
 209 }
 210
 211 void   mk_destroyContexts(mk_Writer *w) {
 212   mk_Context  *cur, *next;
 213
 214   for (cur = w->freelist; cur; cur = next) {
 215     next = cur->next;
 216     free(cur->data);
 217     free(cur);
 218   }
 219
 220   for (cur = w->actlist; cur; cur = next) {
 221     next = cur->next;
 222     free(cur->data);
 223     free(cur);
 224   }
 225
 226   w->freelist = w->actlist = w->root = NULL;
 227 }
 228
 229 int    mk_writeStr(mk_Context *c, unsigned id, const char *str) {
 230   size_t  len = strlen(str);
 231
 232   CHECK(mk_writeID(c, id));
 233   CHECK(mk_writeSize(c, len));
 234   CHECK(mk_appendContextData(c, str, len));
 235   return 0;
 236 }
 237
 238 int    mk_writeBin(mk_Context *c, unsigned id, const void *data, unsigned size) {
 239   CHECK(mk_writeID(c, id));
 240   CHECK(mk_writeSize(c, size));
 241   CHECK(mk_appendContextData(c, data, size));
 242   return 0;
 243 }
 244
 245 int    mk_writeUInt(mk_Context *c, unsigned id, uint64_t ui) {
 246   unsigned char   c_ui[8] = { ui >> 56, ui >> 48, ui >> 40, ui >> 32, ui >> 24, ui >> 16, ui >> 8, ui };
 247   unsigned    i = 0;
 248
 249   CHECK(mk_writeID(c, id));
 250   while (i < 7 && c_ui[i] == 0)
 251     ++i;
 252   CHECK(mk_writeSize(c, 8 - i));
 253   CHECK(mk_appendContextData(c, c_ui+i, 8 - i));
 254   return 0;
 255 }
 256
 257 int    mk_writeSInt(mk_Context *c, unsigned id, int64_t si) {
 258   unsigned char   c_si[8] = { si >> 56, si >> 48, si >> 40, si >> 32, si >> 24, si >> 16, si >> 8, si };
 259   unsigned    i = 0;
 260
 261   CHECK(mk_writeID(c, id));
 262   if (si < 0)
 263     while (i < 7 && c_si[i] == 0xff && c_si[i+1] & 0x80)
 264       ++i;
 265   else
 266     while (i < 7 && c_si[i] == 0 && !(c_si[i+1] & 0x80))
 267       ++i;
 268   CHECK(mk_writeSize(c, 8 - i));
 269   CHECK(mk_appendContextData(c, c_si+i, 8 - i));
 270   return 0;
 271 }
 272
 273 int    mk_writeFloatRaw(mk_Context *c, float f) {
 274   union {
 275     float f;
 276     unsigned u;
 277   } u;
 278   unsigned char c_f[4];
 279
 280   u.f = f;
 281   c_f[0] = u.u >> 24;
 282   c_f[1] = u.u >> 16;
 283   c_f[2] = u.u >> 8;
 284   c_f[3] = u.u;
 285
 286   return mk_appendContextData(c, c_f, 4);
 287 }
 288
 289 int    mk_writeFloat(mk_Context *c, unsigned id, float f) {
 290   CHECK(mk_writeID(c, id));
 291   CHECK(mk_writeSize(c, 4));
 292   CHECK(mk_writeFloatRaw(c, f));
 293   return 0;
 294 }
 295
 296 unsigned   mk_ebmlSizeSize(uint64_t s) {
 297   if (s < 0x7f)
 298     return 1;
 299   if (s < 0x3fff)
 300     return 2;
 301   if (s < 0x1fffff)
 302     return 3;
 303   if (s < 0x0fffffff)
 304     return 4;
 305   if (s < 0x07ffffffff)
 306     return 5;
 307   if (s < 0x03ffffffffff)
 308     return 6;
 309   if (s < 0x01ffffffffffff)
 310     return 7;
 311   return 8;
 312 }
 313
 314 unsigned   mk_ebmlSIntSize(int64_t si) {
 315   unsigned char   c_si[8] = { si >> 56, si >> 48, si >> 40, si >> 32, si >> 24, si >> 16, si >> 8, si };
 316   unsigned    i = 0;
 317
 318   if (si < 0)
 319     while (i < 7 && c_si[i] == 0xff && c_si[i+1] & 0x80)
 320       ++i;
 321   else
 322     while (i < 7 && c_si[i] == 0 && !(c_si[i+1] & 0x80))
 323       ++i;
 324
 325   return 8 - i;
 326 }