src/matroska.c

   1 /*****************************************************************************
   2  * matroska.c:
   3  *****************************************************************************
   4  * Copyright (C) 2005 x264 project
   5  *
   6  * Authors: Mike Matsnev
   7  *          Nathan Caldwell
   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 #include "config.h"
  24 #include "libmkv.h"
  25 #include "matroska.h"
  26 #include "md5.h"
  27
  28 #define RESERVED_SEEKHEAD 0x100
  29 /* 256 bytes should be enough room for our Seek entries. */
  30 #define RESERVED_CHAPTERS 0x800
  31 /* 2048 bytes, hopefully enough for Chapters. */
  32
  33 int mk_seekFile(mk_Writer *w, uint64_t pos)
  34 {
  35         if (fseek(w->fp, pos, SEEK_SET))
  36                 return -1;
  37
  38         w->f_pos = pos;
  39
  40         if (pos > w->f_eof)
  41                 w->f_eof = pos;
  42
  43         return 0;
  44 }
  45
  46 char *mk_laceXiph(uint64_t *sizes, uint8_t num_frames,
  47                                   uint64_t *output_size)
  48 {
  49         unsigned i, j;
  50         uint64_t offset = 0;
  51         uint64_t alloc_size = num_frames * 6;   /* Complete guess. It gets realloc'd
  52                                                                                          * below if we need more space, though.
  53                                                                                          */
  54         char *laced = calloc(alloc_size, sizeof(*laced));
  55         if (laced == NULL)
  56                 return NULL;
  57
  58         laced[offset++] = num_frames;
  59         for (i = 0; i < num_frames; i++) {
  60                 for (j = sizes[i]; j >= 255; j -= 255) {
  61                         laced[offset++] = 255;
  62                         if (offset + 1 >= alloc_size) {
  63                                 int avg_sz = offset / (i - 1);  /* Compute approximate average bytes/frame */
  64                                 alloc_size += avg_sz * (num_frames - i);
  65                                                                 /* Sum average so far and number of frames left
  66                                                                  * with alloc'd size
  67                                                                  */
  68                                 if ((laced = realloc(laced, alloc_size)) == NULL)
  69                                         return NULL;
  70                         }
  71                 }
  72                 laced[offset++] = j;
  73         }
  74
  75         if (output_size != NULL)
  76                 *output_size = offset;
  77
  78         return laced;
  79 }
  80
  81 mk_Writer *mk_createWriter(const char *filename, int64_t timescale,
  82                                                    uint8_t vlc_compat)
  83 {
  84         mk_Writer *w = calloc(1, sizeof(*w));
  85         if (w == NULL)
  86                 return NULL;
  87
  88         w->root = mk_createContext(w, NULL, 0);
  89         if (w->root == NULL) {
  90                 free(w);
  91                 return NULL;
  92         }
  93
  94         /* Cues */
  95         if ((w->cues = mk_createContext(w, w->root, MATROSKA_ID_CUES)) == NULL)
  96         {
  97                 mk_destroyContexts(w);
  98                 free(w);
  99                 return NULL;
 100         }
 101
 102         if (vlc_compat) {
 103                 /* SeekHead */
 104                 if ((w->cluster.seekhead = mk_createContext(w, w->root, MATROSKA_ID_SEEKHEAD)) == NULL)
 105                 {
 106                         mk_destroyContexts(w);
 107                         free(w);
 108                         return NULL;
 109                 }
 110         }
 111
 112         w->fp = fopen(filename, "wb");
 113         if (w->fp == NULL) {
 114                 mk_destroyContexts(w);
 115                 free(w);
 116                 return NULL;
 117         }
 118
 119         w->timescale = timescale;
 120         w->vlc_compat = vlc_compat;
 121
 122         return w;
 123 }
 124
 125 int mk_writeHeader(mk_Writer *w, const char *writingApp)
 126 {
 127         mk_Context *c;
 128         int64_t offset = 0;
 129
 130         if (w->wrote_header)
 131                 return -1;
 132
 133         md5_starts(&w->segment_md5);    /* Initalize MD5 */
 134
 135         CHECK(mk_writeEbmlHeader(w, "matroska", MATROSKA_VERSION, MATROSKA_VERSION));
 136
 137         /* Segment */
 138         if ((c = mk_createContext(w, w->root, MATROSKA_ID_SEGMENT)) == NULL)
 139                 return -1;
 140         CHECK(mk_flushContextID(c));
 141         w->segment_ptr = c->d_cur;
 142         CHECK(mk_closeContext(c, &w->segment_ptr));
 143
 144         if (w->vlc_compat) {
 145                 CHECK(mk_writeVoid(w->root, RESERVED_SEEKHEAD));        /* Reserved space for SeekHead */
 146                 CHECK(mk_writeVoid(w->root, RESERVED_CHAPTERS));        /* Reserved space for Chapters */
 147         } else {
 148                 w->seek_data.seekhead = 0x80000000;
 149                 CHECK(mk_writeSeekHead(w, &w->seekhead_ptr));
 150                 w->seek_data.seekhead = 0;
 151         }
 152
 153         if ((c = mk_createContext(w, w->root, MATROSKA_ID_INFO)) == NULL)       /* SegmentInfo */
 154                 return -1;
 155         w->seek_data.segmentinfo = w->root->d_cur - w->segment_ptr;
 156         CHECK(mk_writeVoid(c, 16));     /* Reserve space for a SegmentUID, to be written it later. */
 157         CHECK(mk_writeStr(c, MATROSKA_ID_MUXINGAPP, PACKAGE_STRING));   /* MuxingApp */
 158         CHECK(mk_writeStr(c, MATROSKA_ID_WRITINGAPP, writingApp));      /* WritingApp */
 159         CHECK(mk_writeUInt(c, MATROSKA_ID_TIMECODESCALE, w->timescale));        /* TimecodeScale */
 160         CHECK(mk_writeFloat(c, MATROSKA_ID_DURATION, 0));       /* Duration */
 161         w->duration_ptr = c->d_cur - 4;
 162         CHECK(mk_closeContext(c, &offset));
 163         w->duration_ptr += offset;
 164         w->segmentuid_ptr = offset;
 165
 166         w->seek_data.tracks = w->root->d_cur - w->segment_ptr;
 167
 168         if (w->tracks)
 169                 CHECK(mk_closeContext(w->tracks, 0));
 170
 171         CHECK(mk_flushContextData(w->root));
 172
 173         w->wrote_header = 1;
 174         w->def_duration = w->tracks_arr[0]->default_duration;
 175         return 0;
 176 }
 177
 178 static int mk_closeCluster(mk_Writer *w)
 179 {
 180         if (w->cluster.context == NULL)
 181                 return 0;
 182         w->cluster.count++;
 183         CHECK(mk_closeContext(w->cluster.context, 0));
 184         w->cluster.context = NULL;
 185         CHECK(mk_flushContextData(w->root));
 186
 187         return 0;
 188 }
 189
 190 int mk_flushFrame(mk_Writer *w, mk_Track *track)
 191 {
 192         mk_Context *c, *tp;
 193         int64_t delta, ref = 0;
 194         unsigned fsize, bgsize;
 195         uint8_t flags, c_delta[2];
 196         int i;
 197         char *laced = NULL;
 198         uint64_t length = 0;
 199
 200         if (!track->in_frame)
 201                 return 0;
 202
 203         delta = track->frame.timecode / w->timescale - w->cluster.tc_scaled;
 204         if (delta > 2000ll || delta < -2000ll)
 205                 CHECK(mk_closeCluster(w));
 206
 207         if (w->cluster.context == NULL) {
 208                 w->cluster.tc_scaled = track->frame.timecode / w->timescale;
 209                 /* Cluster */
 210                 w->cluster.context = mk_createContext(w, w->root, MATROSKA_ID_CLUSTER);
 211                 if (w->cluster.context == NULL)
 212                         return -1;
 213
 214                 w->cluster.pointer = w->f_pos - w->segment_ptr;
 215
 216                 if (w->vlc_compat) {
 217                         /* Cluster SeekEntry */
 218                         CHECK(mk_writeSeek(w, w->cluster.seekhead, MATROSKA_ID_CLUSTER,
 219                                                            w->cluster.pointer));
 220                 }
 221
 222                 /* Cluster Timecode */
 223                 CHECK(mk_writeUInt(w->cluster.context, MATROSKA_ID_CLUSTERTIMECODE, w->cluster.tc_scaled));
 224
 225                 delta = 0;
 226                 w->cluster.block_count = 0;
 227         }
 228
 229         /* Calculate the encoded lacing sizes. */
 230         switch (track->frame.lacing) {
 231                 case MK_LACING_XIPH:
 232                         laced = mk_laceXiph(track->frame.lacing_sizes,
 233                                                                 track->frame.lacing_num_frames, &length);
 234                         break;
 235                 case MK_LACING_EBML:
 236                 {
 237                         uint64_t u_size = 0;
 238                         /* Add one below for the frame count. */
 239                         length += mk_ebmlSizeSize(track->frame.lacing_sizes[0]) + 1;
 240                         for (i = 1; i < track->frame.lacing_num_frames; i++) {
 241                                 u_size = llabs(track->frame.lacing_sizes[i] -
 242                                                            track->frame.lacing_sizes[i - 1]);
 243                                 /* Shift by one so we get the right size for a signed number. */
 244                                 length += mk_ebmlSizeSize((u_size) << 1);
 245                         }
 246                         break;
 247                 }
 248                 case MK_LACING_FIXED:
 249                 {
 250                         laced = calloc(1, sizeof(*laced));
 251                         laced[0] = track->frame.lacing_num_frames;
 252                         ++length;
 253                         break;
 254                 }
 255                 default:
 256                         break;
 257         }
 258
 259         fsize = track->frame.data ? track->frame.data->d_cur : 0;
 260         bgsize = fsize + 4 + mk_ebmlSizeSize(fsize + 4 + length) + 1 + length;
 261         if (!track->frame.keyframe) {
 262                 ref = track->prev_frame_tc_scaled - w->cluster.tc_scaled - delta;
 263                 bgsize += 1 + 1 + mk_ebmlSIntSize(ref);
 264         }
 265
 266         CHECK(mk_writeID(w->cluster.context, MATROSKA_ID_BLOCKGROUP));  /* BlockGroup */
 267         CHECK(mk_writeSize(w->cluster.context, bgsize));
 268         CHECK(mk_writeID(w->cluster.context, MATROSKA_ID_BLOCK));       /* Block */
 269         CHECK(mk_writeSize(w->cluster.context, fsize + 4 + length));    /* BlockSize */
 270         CHECK(mk_writeSize(w->cluster.context, track->track_id));       /* track number */
 271
 272         w->cluster.block_count++;
 273
 274         c_delta[0] = delta >> 8;
 275         c_delta[1] = delta;
 276         /* Timecode relative to Cluster. */
 277         CHECK(mk_appendContextData(w->cluster.context, c_delta, 2));
 278
 279 /*      flags = ( track->frame.keyframe << 8 ) | track->frame.lacing; */
 280         flags = track->frame.lacing << 1;       /* Flags: Bit 5-6 describe what type of lacing to use. */
 281         CHECK(mk_appendContextData(w->cluster.context, &flags, 1));
 282         if (track->frame.lacing) {
 283                 if (track->frame.lacing == MK_LACING_EBML) {
 284                         /* Number of frames in lace - 1 */
 285                         CHECK(mk_appendContextData(w->cluster.context, &track->frame.lacing_num_frames, 1));
 286                         /* Size of 1st frame. */
 287                         CHECK(mk_writeSize(w->cluster.context, track->frame.lacing_sizes[0]));
 288                         for (i = 1; i < track->frame.lacing_num_frames; i++) {
 289                                 /* Size difference between previous size and this size. */
 290                                 CHECK(mk_writeSSize(w->cluster.context, track->frame.lacing_sizes[i] - track->frame.lacing_sizes[i - 1]));
 291                         }
 292                 } else if (length > 0 && laced != NULL) {
 293                         CHECK(mk_appendContextData(w->cluster.context, laced, length));
 294                         free(laced);
 295                         laced = NULL;
 296                 }
 297         }
 298
 299         if (track->frame.data) {
 300                 CHECK(mk_appendContextData(w->cluster.context, track->frame.data->data,
 301                                                                    track->frame.data->d_cur));
 302                 track->frame.data->d_cur = 0;
 303         }
 304         if (!track->frame.keyframe)
 305                 /* ReferenceBlock */
 306                 CHECK(mk_writeSInt(w->cluster.context, MATROSKA_ID_REFERENCEBLOCK, ref));
 307
 308         /* This may get a little out of hand, but it seems sane enough for now. */
 309         if (track->frame.keyframe && (track->track_type == MK_TRACK_VIDEO)) {
 310 /*      if (track->frame.keyframe && (track->track_type & MK_TRACK_VIDEO) && ((track->prev_cue_pos + 3*CLSIZE) <= w->f_pos || track->frame.timecode == 0)) { */
 311                 /* CuePoint */
 312                 if ((c = mk_createContext(w, w->cues, MATROSKA_ID_CUEPOINT)) == NULL)
 313                         return -1;
 314                 /* CueTime */
 315                 CHECK(mk_writeUInt(c, MATROSKA_ID_CUETIME, (track->frame.timecode / w->timescale)));
 316
 317                 /* CueTrackPositions */
 318                 if ((tp = mk_createContext(w, c, MATROSKA_ID_CUETRACKPOSITIONS)) == NULL)
 319                         return -1;
 320                 /* CueTrack */
 321                 CHECK(mk_writeUInt(tp, MATROSKA_ID_CUETRACK, track->track_id));
 322                 /* CueClusterPosition */
 323                 CHECK(mk_writeUInt(tp, MATROSKA_ID_CUECLUSTERPOSITION, w->cluster.pointer));
 324                 /* CueBlockNumber */
 325 /*              CHECK(mk_writeUInt(c, MATROSKA_ID_CUEBLOCKNUMBER, w->cluster.block_count)); */
 326                 CHECK(mk_closeContext(tp, 0));
 327                 CHECK(mk_closeContext(c, 0));
 328                 track->prev_cue_pos = w->f_pos;
 329         }
 330
 331         track->in_frame = 0;
 332         track->prev_frame_tc_scaled = w->cluster.tc_scaled + delta;
 333
 334         if (w->cluster.context->d_cur > CLSIZE)
 335                 CHECK(mk_closeCluster(w));
 336
 337         return 0;
 338 }
 339
 340 int mk_startFrame(mk_Writer *w, mk_Track *track)
 341 {
 342         if (mk_flushFrame(w, track) < 0)
 343                 return -1;
 344
 345         track->in_frame = 1;
 346         track->frame.keyframe = 0;
 347         track->frame.lacing = MK_LACING_NONE;
 348         track->frame.lacing_num_frames = 0;
 349         track->frame.lacing_sizes = NULL;
 350
 351         return 0;
 352 }
 353
 354 int mk_setFrameFlags(mk_Writer *w, mk_Track *track, int64_t timestamp,
 355                                          unsigned keyframe)
 356 {
 357         if (!track->in_frame)
 358                 return -1;
 359
 360         track->frame.timecode = timestamp;
 361         track->frame.keyframe = keyframe != 0;
 362
 363         if (track->max_frame_tc < timestamp)
 364                 track->max_frame_tc = timestamp;
 365
 366         return 0;
 367 }
 368
 369 int mk_setFrameLacing(mk_Writer *w, mk_Track *track,
 370                                           mk_LacingType lacing, uint8_t num_frames,
 371                                           uint64_t sizes[])
 372 {
 373         if (!track->in_frame)
 374                 return -1;
 375         track->frame.lacing_sizes = calloc(num_frames, sizeof(*sizes));
 376
 377         track->frame.lacing = lacing;
 378         track->frame.lacing_num_frames = num_frames;
 379         memcpy(track->frame.lacing_sizes, sizes,
 380                    num_frames * sizeof(*sizes));
 381
 382         return 0;
 383 }
 384
 385 int mk_addFrameData(mk_Writer *w, mk_Track *track, const void *data,
 386                                         unsigned size)
 387 {
 388         if (!track->in_frame)
 389                 return -1;
 390
 391         if (track->frame.data == NULL) {
 392                 if ((track->frame.data = mk_createContext(w, NULL, 0)) == NULL)
 393                         return -1;
 394         }
 395
 396         md5_update(&w->segment_md5, (unsigned char *) data, size);
 397
 398         return mk_appendContextData(track->frame.data, data, size);
 399 }
 400
 401 int mk_writeSeek(mk_Writer *w, mk_Context *c, unsigned seek_id,
 402                                  uint64_t seek_pos)
 403 {
 404         mk_Context *s;
 405
 406         if ((s = mk_createContext(w, c, MATROSKA_ID_SEEKENTRY)) == NULL)        /* Seek */
 407                 return -1;
 408         CHECK(mk_writeUInt(s, MATROSKA_ID_SEEKID, seek_id));    /* SeekID */
 409         CHECK(mk_writeUInt(s, MATROSKA_ID_SEEKPOSITION, seek_pos));     /* SeekPosition */
 410         CHECK(mk_closeContext(s, 0));
 411
 412         return 0;
 413 }
 414
 415 /* The offset of the SeekHead is returned in pointer. */
 416 int mk_writeSeekHead(mk_Writer *w, int64_t *pointer)
 417 {
 418         mk_Context *c;
 419         int64_t seekhead_ptr;
 420
 421         /* SeekHead */
 422         if ((c = mk_createContext(w, w->root, MATROSKA_ID_SEEKHEAD)) == NULL)
 423                 return -1;
 424         if (pointer != NULL)
 425                 seekhead_ptr = w->f_pos;
 426         if (w->seek_data.seekhead)
 427                 CHECK(mk_writeSeek(w, c, MATROSKA_ID_SEEKHEAD, w->seek_data.seekhead));
 428         if (w->seek_data.segmentinfo)
 429                 CHECK(mk_writeSeek(w, c, MATROSKA_ID_INFO, w->seek_data.segmentinfo));
 430         if (w->seek_data.tracks)
 431                 CHECK(mk_writeSeek(w, c, MATROSKA_ID_TRACKS, w->seek_data.tracks));
 432         if (w->seek_data.cues)
 433                 CHECK(mk_writeSeek(w, c, MATROSKA_ID_CUES, w->seek_data.cues));
 434         if (w->seek_data.attachments)
 435                 CHECK(mk_writeSeek(w, c, MATROSKA_ID_ATTACHMENTS, w->seek_data.attachments));
 436         if (w->seek_data.chapters)
 437                 CHECK(mk_writeSeek(w, c, MATROSKA_ID_CHAPTERS, w->seek_data.chapters));
 438         if (w->seek_data.tags)
 439                 CHECK(mk_writeSeek(w, c, MATROSKA_ID_TAGS, w->seek_data.tags));
 440         CHECK(mk_closeContext(c, 0));
 441
 442         if (pointer != NULL)
 443                 *pointer = seekhead_ptr;
 444
 445         return 0;
 446 }
 447
 448 int mk_close(mk_Writer *w)
 449 {
 450         int i, ret = 0;
 451         mk_Track *tk;
 452         int64_t max_frame_tc = w->tracks_arr[0]->max_frame_tc;
 453         uint64_t segment_size = 0;
 454         unsigned char c_size[8];
 455         unsigned char segment_uid[16];
 456
 457         md5_finish(&w->segment_md5, segment_uid);
 458
 459         for (i = w->num_tracks - 1; i >= 0; i--) {
 460                 tk = w->tracks_arr[i];
 461                 w->tracks_arr[i] = NULL;
 462                 --w->num_tracks;
 463                 if (mk_flushFrame(w, tk) < 0)
 464                         ret = -1;
 465                 free(tk);
 466                 tk = NULL;
 467         }
 468
 469         if (mk_closeCluster(w) < 0)
 470                 ret = -1;
 471
 472         w->seek_data.cues = w->f_pos - w->segment_ptr;
 473         if (mk_closeContext(w->cues, 0) < 0)
 474                 ret = -1;
 475         if (mk_flushContextData(w->root) < 0)
 476                 ret = -1;
 477
 478         if (w->vlc_compat && w->cluster.seekhead) {
 479                 w->seek_data.seekhead = w->f_pos - w->segment_ptr;
 480                 if (mk_closeContext(w->cluster.seekhead, 0) < 0)
 481                         ret = -1;
 482                 if (mk_flushContextData(w->root) < 0)
 483                         ret = -1;
 484         }
 485
 486         if (w->chapters != NULL) {
 487                 if (w->vlc_compat) {
 488                         if (mk_flushContextData(w->root) < 0)
 489                                 ret = -1;
 490                         if (mk_seekFile(w, w->segment_ptr + 0x100 + 3) < 0)
 491                                 ret = -1;
 492                 }
 493                 w->seek_data.chapters = w->f_pos - w->segment_ptr;
 494                 mk_writeChapters(w);
 495                 if (mk_flushContextData(w->root) < 0)
 496                         ret = -1;
 497                 if (w->vlc_compat) {
 498                         if (mk_writeVoid(w->root, (0x800 - (w->f_pos - w->segment_ptr - 0x100 - 3))) < 0)
 499                                 ret = -1;
 500                         if (mk_flushContextData(w->root) < 0)
 501                                 ret = -1;
 502                 }
 503         }
 504
 505         if (w->wrote_header) {
 506                 if (w->vlc_compat) {
 507                         if (mk_seekFile(w, w->segment_ptr) < 0)
 508                                 ret = -1;
 509                 }
 510
 511                 if (mk_writeSeekHead(w, &w->seek_data.seekhead) < 0)
 512                         ret = -1;
 513                 w->seek_data.seekhead -= w->segment_ptr;
 514
 515                 if (w->vlc_compat) {
 516                         if (mk_flushContextData(w->root) < 0)
 517                                 ret = -1;
 518                         if (mk_writeVoid(w->root, (0x100 - (w->f_pos - w->segment_ptr))) < 0)
 519                                 ret = -1;
 520                 }
 521
 522                 if (mk_flushContextData(w->root) < 0)
 523                         ret = -1;
 524
 525                 if (!w->vlc_compat) {
 526                         int i = w->seek_data.segmentinfo;
 527                         w->seek_data.segmentinfo = 0;
 528                         w->seek_data.tracks = 0;
 529                         w->seek_data.cues = 0;
 530                         w->seek_data.chapters = 0;
 531                         w->seek_data.attachments = 0;
 532                         w->seek_data.tags = 0;
 533                         if (mk_seekFile(w, w->segment_ptr) < 0)
 534                                 ret = -1;
 535                         if (mk_writeSeekHead(w, NULL) < 0 || mk_flushContextData(w->root) < 0)
 536                                 ret = -1;
 537                         if (((i + w->segment_ptr) - w->f_pos - 2) > 1)
 538                                 if (mk_writeVoid(w->root, (i + w->segment_ptr) - w->f_pos - 2) < 0
 539                                         || mk_flushContextData(w->root) < 0)
 540                                         ret = -1;
 541                 }
 542
 543                 if (mk_seekFile(w, w->duration_ptr) < 0)
 544                         ret = -1;
 545                 if (mk_writeFloatRaw(w->root,
 546                                                          (float) ((double) (max_frame_tc + w->def_duration) /
 547                                                          w->timescale)) < 0
 548                         || mk_flushContextData(w->root) < 0)
 549                         ret = -1;
 550                 if (mk_seekFile(w, w->segment_ptr - 8) < 0)
 551                         ret = -1;
 552                 segment_size = w->f_eof - w->segment_ptr;
 553                 for (i = 7; i > 0; --i)
 554                         c_size[i] = segment_size >> (8 * (7 - i));
 555                 c_size[i] = 0x01;
 556                 if (mk_appendContextData(w->root, &c_size, 8) < 0 ||
 557                         mk_flushContextData(w->root) < 0)
 558                         ret = -1;
 559                 if (mk_seekFile(w, w->segmentuid_ptr) < 0)
 560                         ret = -1;
 561                 if (mk_writeBin(w->root, MATROSKA_ID_SEGMENTUID, segment_uid,
 562                                                 sizeof(segment_uid)) < 0 ||
 563                         mk_flushContextData(w->root) < 0)
 564                         ret = -1;
 565         }
 566
 567         if (mk_closeContext(w->root, 0) < 0)
 568                 ret = -1;
 569         mk_destroyContexts(w);
 570         fclose(w->fp);
 571         free(w->tracks_arr);
 572         free(w);
 573
 574         return ret;
 575 }