src/matroska.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 int mk_seekFile(mk_Writer *w, uint64_t pos) {
  29   if (fseek(w->fp, pos, SEEK_SET))
  30     return -1;
  31
  32   w->f_pos = pos;
  33
  34   if (pos > w->f_eof)
  35     w->f_eof = pos;
  36
  37   return 0;
  38 }
  39
  40 char  *mk_laceXiph(uint64_t *sizes, uint8_t num_frames, uint64_t *output_size) {
  41   unsigned i, j;
  42   uint64_t offset = 0;
  43   uint64_t alloc_size = num_frames * 6;  // Complete guess. We'll realloc if we need more space, though.
  44   char *laced = calloc(alloc_size, sizeof(char));
  45   if (laced == NULL)
  46     return NULL;
  47
  48   laced[offset++] = num_frames;
  49   for (i = 0; i < num_frames; i++)
  50   {
  51     for (j = sizes[i]; j >= 255 ; j -= 255)
  52     {
  53       laced[offset++] = 255;
  54       if (offset + 1 >= alloc_size) {
  55         int avg_sz = offset / (i - 1);  // Compute approximate average bytes/frame
  56         alloc_size += avg_sz * (num_frames - i);  // Add our average + number of frames left to size
  57         if ((laced = realloc(laced, alloc_size)) == NULL)
  58           return NULL;
  59       }
  60     }
  61     laced[offset++] = j;
  62   }
  63
  64   if (output_size != NULL)
  65     *output_size = offset;
  66
  67   return laced;
  68 }
  69
  70 mk_Writer *mk_createWriter(const char *filename, int64_t timescale, uint8_t vlc_compat) {
  71   mk_Writer *w = calloc(1, sizeof(*w));
  72   if (w == NULL)
  73     return NULL;
  74
  75   w->root = mk_createContext(w, NULL, 0);
  76   if (w->root == NULL) {
  77     free(w);
  78     return NULL;
  79   }
  80
  81   if ((w->cues = mk_createContext(w, w->root, 0x1c53bb6b)) == NULL) // Cues
  82   {
  83     mk_destroyContexts(w);
  84     free(w);
  85     return NULL;
  86   }
  87
  88   if (vlc_compat) {
  89     if ((w->cluster.seekhead = mk_createContext(w, w->root, 0x114d9b74)) == NULL) // SeekHead
  90     {
  91       mk_destroyContexts(w);
  92       free(w);
  93       return NULL;
  94     }
  95   }
  96
  97   w->fp = fopen(filename, "wb");
  98   if (w->fp == NULL) {
  99     mk_destroyContexts(w);
 100     free(w);
 101     return NULL;
 102   }
 103
 104   w->timescale = timescale;
 105   w->vlc_compat = vlc_compat;
 106
 107   return w;
 108 }
 109
 110 int   mk_writeHeader(mk_Writer *w, const char *writingApp) {
 111   mk_Context  *c;
 112
 113   if (w->wrote_header)
 114     return -1;
 115
 116   if ((c = mk_createContext(w, w->root, 0x1a45dfa3)) == NULL) // EBML
 117     return -1;
 118   CHECK(mk_writeUInt(c, 0x4286, 1)); // EBMLVersion
 119   CHECK(mk_writeUInt(c, 0x42f7, 1)); // EBMLReadVersion
 120   CHECK(mk_writeUInt(c, 0x42f2, 4)); // EBMLMaxIDLength
 121   CHECK(mk_writeUInt(c, 0x42f3, 8)); // EBMLMaxSizeLength
 122   CHECK(mk_writeStr(c, 0x4282, "matroska")); // DocType
 123   CHECK(mk_writeUInt(c, 0x4287, 1)); // DocTypeVersion
 124   CHECK(mk_writeUInt(c, 0x4285, 1)); // DocTypeReadversion
 125   CHECK(mk_closeContext(c, 0));
 126
 127   if ((c = mk_createContext(w, w->root, 0x18538067)) == NULL) // Segment
 128     return -1;
 129   CHECK(mk_flushContextID(c));
 130   w->segment_ptr = c->d_cur;
 131   CHECK(mk_closeContext(c, &w->segment_ptr));
 132
 133   if (w->vlc_compat) {
 134     CHECK(mk_writeVoid(w->root, 0x100));  // 256 bytes should be enough room for our Seek entries.
 135     CHECK(mk_writeVoid(w->root, 0x800)); // 2048 bytes for Chapters.
 136   }
 137   else {
 138     w->seek_data.seekhead = 0x80000000;
 139     CHECK(mk_writeSeekHead(w, &w->seekhead_ptr));
 140     w->seek_data.seekhead = 0;
 141   }
 142
 143   if ((c = mk_createContext(w, w->root, 0x1549a966)) == NULL) // SegmentInfo
 144     return -1;
 145   w->seek_data.segmentinfo = w->root->d_cur - w->segment_ptr;
 146   CHECK(mk_writeStr(c, 0x4d80, PACKAGE_STRING)); // MuxingApp
 147   CHECK(mk_writeStr(c, 0x5741, writingApp)); // WritingApp
 148   CHECK(mk_writeUInt(c, 0x2ad7b1, w->timescale)); // TimecodeScale
 149   CHECK(mk_writeFloat(c, 0x4489, 0)); // Duration
 150   w->duration_ptr = c->d_cur - 4;
 151   CHECK(mk_closeContext(c, &w->duration_ptr));
 152
 153   w->seek_data.tracks = w->root->d_cur - w->segment_ptr;
 154
 155   if (w->tracks)
 156     CHECK(mk_closeContext(w->tracks, 0));
 157
 158   CHECK(mk_flushContextData(w->root));
 159
 160   w->wrote_header = 1;
 161   w->def_duration = w->tracks_arr[0]->default_duration;
 162   return 0;
 163 }
 164
 165 static int mk_closeCluster(mk_Writer *w) {
 166   if (w->cluster.context == NULL)
 167     return 0;
 168   w->cluster.count++;
 169   CHECK(mk_closeContext(w->cluster.context, 0));
 170   w->cluster.context = NULL;
 171   CHECK(mk_flushContextData(w->root));
 172   return 0;
 173 }
 174
 175 int   mk_flushFrame(mk_Writer *w, mk_Track *track) {
 176   mk_Context *c, *tp;
 177   int64_t   delta, ref = 0;
 178   unsigned  fsize, bgsize;
 179   uint8_t   flags, c_delta[2];
 180   int i;
 181   char *laced = NULL;
 182   uint64_t  length = 0;
 183
 184   if (!track->in_frame)
 185     return 0;
 186
 187   delta = track->frame.timecode/w->timescale - w->cluster.tc_scaled;
 188   if (delta > 2000ll || delta < -2000ll)
 189     CHECK(mk_closeCluster(w));
 190
 191   if (w->cluster.context == NULL) {
 192     w->cluster.tc_scaled = track->frame.timecode / w->timescale;
 193     w->cluster.context = mk_createContext(w, w->root, 0x1f43b675); // Cluster
 194     if (w->cluster.context == NULL)
 195       return -1;
 196
 197     w->cluster.pointer = w->f_pos - w->segment_ptr;
 198
 199     if (w->vlc_compat)
 200       CHECK(mk_writeSeek(w, w->cluster.seekhead, 0x1f43b675, w->cluster.pointer));
 201
 202     CHECK(mk_writeUInt(w->cluster.context, 0xe7, w->cluster.tc_scaled)); // Cluster Timecode
 203
 204     delta = 0;
 205     w->cluster.block_count = 0;
 206   }
 207
 208   /* Calculate the encoded lacing sizes. */
 209   switch (track->frame.lacing) {
 210           case MK_LACING_XIPH:
 211                   laced = mk_laceXiph(track->frame.lacing_sizes, track->frame.lacing_num_frames, &length);
 212                   break;
 213           case MK_LACING_EBML:
 214           {
 215                   uint64_t u_size = 0;
 216                   length += mk_ebmlSizeSize(track->frame.lacing_sizes[0]) + 1;  // Add one for the frame count.
 217                   for (i = 1; i < track->frame.lacing_num_frames; i++)
 218                   {
 219                           u_size = llabs(track->frame.lacing_sizes[i] - track->frame.lacing_sizes[i-1]);
 220                           length += mk_ebmlSizeSize((u_size) << 1);             // Shift by one so we get the right size for a signed number.
 221                   }
 222                   break;
 223           }
 224           case MK_LACING_FIXED:
 225           {
 226                   laced = calloc(1, sizeof(char));
 227                   laced[0] = track->frame.lacing_num_frames;
 228                   ++length;
 229                   break;
 230           }
 231   }
 232
 233   fsize = track->frame.data ? track->frame.data->d_cur : 0;
 234   bgsize = fsize + 4 + mk_ebmlSizeSize(fsize + 4 + length) + 1 + length;
 235   if (!track->frame.keyframe) {
 236     ref = track->prev_frame_tc_scaled - w->cluster.tc_scaled - delta;
 237     bgsize += 1 + 1 + mk_ebmlSIntSize(ref);
 238   }
 239
 240   CHECK(mk_writeID(w->cluster.context, 0xa0)); // BlockGroup
 241   CHECK(mk_writeSize(w->cluster.context, bgsize));
 242   CHECK(mk_writeID(w->cluster.context, 0xa1)); // Block
 243   CHECK(mk_writeSize(w->cluster.context, fsize + 4 + length));  // Block size
 244   CHECK(mk_writeSize(w->cluster.context, track->track_id)); // track number
 245
 246   w->cluster.block_count++;
 247
 248   c_delta[0] = delta >> 8;
 249   c_delta[1] = delta;
 250   CHECK(mk_appendContextData(w->cluster.context, c_delta, 2));  // Timecode relative to Cluster.
 251
 252 //   flags = ( track->frame.keyframe << 8 ) | track->frame.lacing;
 253   flags = track->frame.lacing << 1;     // Flags: Bit 5-6 describe what type of lacing to use.
 254   CHECK(mk_appendContextData(w->cluster.context, &flags, 1));
 255   if (track->frame.lacing) {
 256     if (track->frame.lacing == MK_LACING_EBML) {
 257       CHECK(mk_appendContextData(w->cluster.context, &track->frame.lacing_num_frames, 1));      // Number of frames in lace-1
 258       CHECK(mk_writeSize(w->cluster.context, track->frame.lacing_sizes[0]));    // Size of 1st frame.
 259       for (i = 1; i < track->frame.lacing_num_frames; i++)
 260       {
 261         CHECK(mk_writeSSize(w->cluster.context, track->frame.lacing_sizes[i] - track->frame.lacing_sizes[i-1]));        // Size difference between previous size and this size.
 262       }
 263     } else if (length > 0 && laced != NULL) {
 264       CHECK(mk_appendContextData(w->cluster.context, laced, length));
 265       free(laced);
 266       laced = NULL;
 267     }
 268   }
 269
 270   if (track->frame.data) {
 271     CHECK(mk_appendContextData(w->cluster.context, track->frame.data->data, track->frame.data->d_cur));
 272     track->frame.data->d_cur = 0;
 273   }
 274   if (!track->frame.keyframe)
 275     CHECK(mk_writeSInt(w->cluster.context, 0xfb, ref)); // ReferenceBlock
 276
 277   if (track->frame.keyframe && (track->track_type & MK_TRACK_VIDEO) && ((track->prev_cue_pos + 3*CLSIZE) <= w->f_pos || track->frame.timecode == 0)) {
 278     if ((c = mk_createContext(w, w->cues, 0xbb)) == NULL)  // CuePoint
 279       return -1;
 280     CHECK(mk_writeUInt(c, 0xb3, track->frame.timecode)); // CueTime
 281
 282     if ((tp = mk_createContext(w, c, 0xb7)) == NULL)  // CueTrackPositions
 283       return -1;
 284     CHECK(mk_writeUInt(tp, 0xf7, track->track_id)); // CueTrack
 285     CHECK(mk_writeUInt(tp, 0xf1, w->cluster.pointer));  // CueClusterPosition
 286 //     CHECK(mk_writeUInt(c, 0x5378, w->cluster.block_count));  // CueBlockNumber
 287     CHECK(mk_closeContext(tp, 0));
 288     CHECK(mk_closeContext(c, 0));
 289     track->prev_cue_pos = w->f_pos;
 290   }
 291
 292   track->in_frame = 0;
 293   track->prev_frame_tc_scaled = w->cluster.tc_scaled + delta;
 294
 295   if (w->cluster.context->d_cur > CLSIZE)
 296     CHECK(mk_closeCluster(w));
 297
 298   return 0;
 299 }
 300
 301 int   mk_startFrame(mk_Writer *w, mk_Track *track) {
 302   if (mk_flushFrame(w, track) < 0)
 303     return -1;
 304
 305   track->in_frame = 1;
 306   track->frame.keyframe = 0;
 307   track->frame.lacing = MK_LACING_NONE;
 308   track->frame.lacing_num_frames = 0;
 309   track->frame.lacing_sizes = NULL;
 310
 311   return 0;
 312 }
 313
 314 int   mk_setFrameFlags(mk_Writer *w, mk_Track *track, int64_t timestamp, unsigned keyframe) {
 315   if (!track->in_frame)
 316     return -1;
 317
 318   track->frame.timecode = timestamp;
 319   track->frame.keyframe = keyframe != 0;
 320
 321   if (track->max_frame_tc < timestamp)
 322     track->max_frame_tc = timestamp;
 323
 324   return 0;
 325 }
 326
 327 int   mk_setFrameLacing(mk_Writer *w, mk_Track *track, uint8_t lacing, uint8_t num_frames, uint64_t sizes[]) {
 328   if (!track->in_frame)
 329     return -1;
 330   track->frame.lacing_sizes = calloc(num_frames, sizeof(uint64_t));
 331
 332   track->frame.lacing = lacing;
 333   track->frame.lacing_num_frames = num_frames;
 334   memcpy(track->frame.lacing_sizes, sizes, num_frames * sizeof(uint64_t));
 335
 336   return 0;
 337 }
 338
 339 int   mk_addFrameData(mk_Writer *w, mk_Track *track, const void *data, unsigned size) {
 340   if (!track->in_frame)
 341     return -1;
 342
 343   if (track->frame.data == NULL)
 344     if ((track->frame.data = mk_createContext(w, NULL, 0)) == NULL)
 345       return -1;
 346
 347   return mk_appendContextData(track->frame.data, data, size);
 348 }
 349
 350 int   mk_writeSeek(mk_Writer *w, mk_Context *c, unsigned seek_id, uint64_t seek_pos) {
 351   mk_Context  *s;
 352
 353   if ((s = mk_createContext(w, c, 0x4dbb)) == NULL) // Seek
 354     return -1;
 355   CHECK(mk_writeUInt(s, 0x53ab, seek_id));  // SeekID
 356   CHECK(mk_writeUInt(s, 0x53ac, seek_pos)); // SeekPosition
 357   CHECK(mk_closeContext(s, 0));
 358
 359   return 0;
 360 }
 361
 362 /* The offset of the SeekHead is returned in *pointer. */
 363 int mk_writeSeekHead(mk_Writer *w, int64_t *pointer) {
 364   mk_Context  *c;
 365   int64_t   seekhead_ptr;
 366
 367   if ((c = mk_createContext(w, w->root, 0x114d9b74)) == NULL) // SeekHead
 368     return -1;
 369   if (pointer != NULL)
 370     seekhead_ptr = w->f_pos;
 371   if (w->seek_data.seekhead)
 372     CHECK(mk_writeSeek(w, c, 0x114d9b74, w->seek_data.seekhead));
 373   if (w->seek_data.segmentinfo)
 374     CHECK(mk_writeSeek(w, c, 0x1549a966, w->seek_data.segmentinfo));
 375   if (w->seek_data.tracks)
 376     CHECK(mk_writeSeek(w, c, 0x1654ae6b, w->seek_data.tracks));
 377   if (w->seek_data.cues)
 378     CHECK(mk_writeSeek(w, c, 0x1c53bb6b, w->seek_data.cues));
 379   if (w->seek_data.attachments)
 380     CHECK(mk_writeSeek(w, c, 0x1941a469, w->seek_data.attachments));
 381   if (w->seek_data.chapters)
 382     CHECK(mk_writeSeek(w, c, 0x1043a770, w->seek_data.chapters));
 383   if (w->seek_data.tags)
 384     CHECK(mk_writeSeek(w, c, 0x1254c367, w->seek_data.tags));
 385   CHECK(mk_closeContext(c, 0));
 386
 387   if (pointer != NULL)
 388     *pointer = seekhead_ptr;
 389
 390   return 0;
 391 }
 392
 393 int   mk_close(mk_Writer *w) {
 394   int   i, ret = 0;
 395   mk_Track *tk;
 396   int64_t max_frame_tc = w->tracks_arr[0]->max_frame_tc;
 397   uint64_t segment_size = 0;
 398   unsigned char c_size[8];
 399
 400   for (i = w->num_tracks - 1; i >= 0; i--)
 401   {
 402     tk = w->tracks_arr[i];
 403     w->tracks_arr[i] = NULL;
 404     --w->num_tracks;
 405     if (mk_flushFrame(w, tk) < 0)
 406       ret = -1;
 407     free(tk);
 408     tk = NULL;
 409   }
 410
 411   if (mk_closeCluster(w) < 0)
 412     ret = -1;
 413
 414   w->seek_data.cues = w->f_pos - w->segment_ptr;
 415   if (mk_closeContext(w->cues, 0) < 0)
 416     ret = -1;
 417   if (mk_flushContextData(w->root) < 0)
 418     ret = -1;
 419
 420   if (w->vlc_compat && w->cluster.seekhead) {
 421     w->seek_data.seekhead = w->f_pos - w->segment_ptr;
 422     if (mk_closeContext(w->cluster.seekhead, 0) < 0)
 423       ret = -1;
 424     if (mk_flushContextData(w->root) < 0)
 425       ret = -1;
 426   }
 427
 428   if (w->chapters != NULL)
 429   {
 430     if (w->vlc_compat) {
 431       if (mk_flushContextData(w->root) < 0)
 432         ret = -1;
 433       if (mk_seekFile(w, w->segment_ptr + 0x100 + 3) < 0)
 434         ret = -1;
 435     }
 436     w->seek_data.chapters = w->f_pos - w->segment_ptr;
 437     mk_writeChapters(w);
 438     if (mk_flushContextData(w->root) < 0)
 439       ret = -1;
 440     if (w->vlc_compat) {
 441       if (mk_writeVoid(w->root, (0x800 - (w->f_pos - w->segment_ptr - 0x100 - 3))) < 0)
 442         ret = -1;
 443       if (mk_flushContextData(w->root) < 0)
 444         ret = -1;
 445     }
 446   }
 447
 448   if (w->wrote_header) {
 449     if (w->vlc_compat) {
 450       if (mk_seekFile(w, w->segment_ptr) < 0)
 451         ret = -1;
 452     }
 453
 454     if (mk_writeSeekHead(w, &w->seek_data.seekhead) < 0)
 455       ret = -1;
 456     w->seek_data.seekhead -= w->segment_ptr;
 457
 458     if (w->vlc_compat)
 459     {
 460       if (mk_flushContextData(w->root) < 0)
 461         ret = -1;
 462       if (mk_writeVoid(w->root, (0x100 - (w->f_pos - w->segment_ptr))) < 0)
 463         ret = -1;
 464     }
 465
 466     if (mk_flushContextData(w->root) < 0)
 467       ret = -1;
 468
 469     if (!w->vlc_compat)
 470     {
 471       int i = w->seek_data.segmentinfo;
 472       w->seek_data.segmentinfo = 0;
 473       w->seek_data.tracks = 0;
 474       w->seek_data.cues = 0;
 475       w->seek_data.chapters = 0;
 476       w->seek_data.attachments = 0;
 477       w->seek_data.tags = 0;
 478       if (mk_seekFile(w, w->segment_ptr) < 0)
 479         ret = -1;
 480       if (mk_writeSeekHead(w, NULL) < 0 ||
 481           mk_flushContextData(w->root) < 0)
 482         ret = -1;
 483       if (((i + w->segment_ptr) - w->f_pos - 2) > 1)
 484         if (mk_writeVoid(w->root, (i + w->segment_ptr) - w->f_pos - 2) < 0 ||
 485             mk_flushContextData(w->root) < 0)
 486           ret = -1;
 487     }
 488
 489     if (mk_seekFile(w, w->duration_ptr) < 0)
 490       ret = -1;
 491     if (mk_writeFloatRaw(w->root, (float)((double)(max_frame_tc+w->def_duration) / w->timescale)) < 0 ||
 492         mk_flushContextData(w->root) < 0)
 493       ret = -1;
 494     if (mk_seekFile(w, w->segment_ptr - 8) < 0)
 495       ret = -1;
 496     segment_size = w->f_eof - w->segment_ptr;
 497     for (i = 7; i > 0; --i)
 498       c_size[i] = segment_size >> (8 * (7-i));
 499     c_size[i] = 0x01;
 500     if (mk_appendContextData(w->root, &c_size, 8) < 0 ||
 501         mk_flushContextData(w->root) < 0)
 502       ret = -1;
 503   }
 504
 505   if (mk_closeContext(w->root, 0) < 0)
 506     ret = -1;
 507   mk_destroyContexts(w);
 508   fclose(w->fp);
 509   free(w->tracks_arr);
 510   free(w);
 511
 512   return ret;
 513 }