int mk_flushFrame(mk_Writer *w) { int64_t delta, ref = 0; unsigned fsize, bgsize; unsigned char c_delta_flags[3]; if (!w->in_frame) return 0; delta = w->frame_tc/w->timescale - w->cluster_tc_scaled; //if (delta > 32767ll || delta < -32768ll) if (delta > 32767I64 || delta < -32768I64) //lsp051226 CHECK(mk_closeCluster(w)); if (w->cluster == NULL) { w->cluster_tc_scaled = w->frame_tc / w->timescale; w->cluster = mk_createContext(w, w->root, 0x1f43b675); // Cluster if (w->cluster == NULL) return -1; CHECK(mk_writeUInt(w->cluster, 0xe7, w->cluster_tc_scaled)); // Timecode delta = 0; } fsize = w->frame ? w->frame->d_cur : 0; bgsize = fsize + 4 + mk_ebmlSizeSize(fsize + 4) + 1; if (!w->keyframe) { ref = w->prev_frame_tc_scaled - w->cluster_tc_scaled - delta; bgsize += 1 + 1 + mk_ebmlSIntSize(ref); } CHECK(mk_writeID(w->cluster, 0xa0)); // BlockGroup CHECK(mk_writeSize(w->cluster, bgsize)); CHECK(mk_writeID(w->cluster, 0xa1)); // Block CHECK(mk_writeSize(w->cluster, fsize + 4)); CHECK(mk_writeSize(w->cluster, 1)); // track number c_delta_flags[0] = delta >> 8; c_delta_flags[1] = delta; c_delta_flags[2] = 0; CHECK(mk_appendContextData(w->cluster, c_delta_flags, 3)); if (w->frame) { CHECK(mk_appendContextData(w->cluster, w->frame->data, w->frame->d_cur)); w->frame->d_cur = 0; } if (!w->keyframe) CHECK(mk_writeSInt(w->cluster, 0xfb, ref)); // ReferenceBlock w->in_frame = 0; w->prev_frame_tc_scaled = w->cluster_tc_scaled + delta; if (w->cluster->d_cur > CLSIZE) CHECK(mk_closeCluster(w)); return 0; }
static int mk_writeSInt(mk_Context *c, unsigned id, int64_t si) { #ifdef __CW32__ unsigned char c_si[8]; #else unsigned char c_si[8] = { si >> 56, si >> 48, si >> 40, si >> 32, si >> 24, si >> 16, si >> 8, si }; #endif unsigned i = 0; #ifdef __CW32__ c_si[0] = si >> 56; c_si[1] = si >> 48; c_si[2] = si >> 40; c_si[3] = si >> 32; c_si[4] = si >> 24; c_si[5] = si >> 16; c_si[6] = si >> 8; c_si[7] = si; #endif CHECK(mk_writeID(c, id)); if (si < 0) while (i < 7 && c_si[i] == 0xff && c_si[i+1] & 0x80) ++i; else while (i < 7 && c_si[i] == 0 && !(c_si[i+1] & 0x80)) ++i; CHECK(mk_writeSize(c, 8 - i)); CHECK(mk_appendContextData(c, c_si+i, 8 - i)); return 0; }
static int mk_writeUInt(mk_Context *c, unsigned id, int64_t ui) { #ifdef __CW32__ unsigned char c_ui[8]; #else unsigned char c_ui[8] = { ui >> 56, ui >> 48, ui >> 40, ui >> 32, ui >> 24, ui >> 16, ui >> 8, ui }; #endif unsigned i = 0; #ifdef __CW32__ c_ui[0] = ui >> 56; c_ui[1] = ui >> 48; c_ui[2] = ui >> 40; c_ui[3] = ui >> 32; c_ui[4] = ui >> 24; c_ui[5] = ui >> 16; c_ui[6] = ui >> 8; c_ui[7] = ui; #endif CHECK(mk_writeID(c, id)); while (i < 7 && c_ui[i] == 0) ++i; CHECK(mk_writeSize(c, 8 - i)); CHECK(mk_appendContextData(c, c_ui+i, 8 - i)); return 0; }
static int mk_writeStr(mk_Context *c, unsigned id, const char *str) { size_t len = strlen(str); CHECK(mk_writeID(c, id)); CHECK(mk_writeSize(c, len)); CHECK(mk_appendContextData(c, str, len)); return 0; }
static int mk_writeUInt(mk_Context *c, unsigned id, int64_t ui) { unsigned char c_ui[8] = { ui >> 56, ui >> 48, ui >> 40, ui >> 32, ui >> 24, ui >> 16, ui >> 8, ui }; unsigned i = 0; CHECK(mk_writeID(c, id)); while (i < 7 && c_ui[i] == 0) ++i; CHECK(mk_writeSize(c, 8 - i)); CHECK(mk_appendContextData(c, c_ui+i, 8 - i)); return 0; }
static int mk_writeSInt(mk_Context *c, unsigned id, int64_t si) { unsigned char c_si[8] = { si >> 56, si >> 48, si >> 40, si >> 32, si >> 24, si >> 16, si >> 8, si }; unsigned i = 0; CHECK(mk_writeID(c, id)); if (si < 0) while (i < 7 && c_si[i] == 0xff && c_si[i+1] & 0x80) ++i; else while (i < 7 && c_si[i] == 0 && !(c_si[i+1] & 0x80)) ++i; CHECK(mk_writeSize(c, 8 - i)); CHECK(mk_appendContextData(c, c_si+i, 8 - i)); return 0; }
static int mk_closeContext(mk_Context *c, unsigned *off) { if (c->id) { CHECK(mk_writeID(c->parent, c->id)); CHECK(mk_writeSize(c->parent, c->d_cur)); } if (c->parent && off != NULL) *off += c->parent->d_cur; CHECK(mk_flushContextData(c)); if (c->next) c->next->prev = c->prev; *(c->prev) = c->next; c->next = c->owner->freelist; c->owner->freelist = c; return 0; }
int mk_flushFrame(mk_Writer *w, mk_Track *track) { mk_Context *c, *tp; int64_t delta, ref = 0; unsigned fsize, bgsize; uint8_t flags, c_delta[2]; int i; char *laced = NULL; uint64_t length = 0; uint64_t block_duration = 0; if (!track->in_frame) return 0; delta = track->frame.timecode / w->timescale - w->cluster.tc_scaled; block_duration = track->frame.duration / w->timescale; /* NOTE: If we switch rapidly back-and-forth between tracks with * drastically different timecodes this causes a new cluster to * be written each time a switch is made. This causes unnecessary * overhead. The calling application is assumed to have interleaved * track samples based on timestamp. */ /* Soft limit: If the frame is a video keyframe and we are not closer than * 2 seconds to the last cluster, start a new cluster. */ if (track->track_type == MK_TRACK_VIDEO && track->frame.keyframe && delta > 2000ll) CHECK(mk_closeCluster(w)); /* Hard limit: if the current cluster is greater than 20 seconds, * start a new cluster */ if (delta > 20000ll || delta < -20000ll) CHECK(mk_closeCluster(w)); if (w->cluster.context == NULL) { w->cluster.tc_scaled = track->frame.timecode / w->timescale; /* Cluster */ w->cluster.context = mk_createContext(w, w->root, MATROSKA_ID_CLUSTER); if (w->cluster.context == NULL) return -1; w->cluster.pointer = w->f_pos - w->segment_ptr; /* Cluster SeekEntry */ CHECK(mk_writeSeek(w, w->cluster.seekhead, MATROSKA_ID_CLUSTER, w->cluster.pointer)); /* Cluster Timecode */ CHECK(mk_writeUInt(w->cluster.context, MATROSKA_ID_CLUSTERTIMECODE, w->cluster.tc_scaled)); delta = 0; w->cluster.block_count = 0; } /* Calculate the encoded lacing sizes. */ switch (track->frame.lacing) { case MK_LACING_XIPH: laced = mk_laceXiph(track->frame.lacing_sizes, track->frame.lacing_num_frames, &length); break; case MK_LACING_EBML: { uint64_t u_size = 0; /* Add one below for the frame count. */ length += mk_ebmlSizeSize(track->frame.lacing_sizes[0]) + 1; for (i = 1; i < track->frame.lacing_num_frames; i++) { u_size = llabs(track->frame.lacing_sizes[i] - track->frame.lacing_sizes[i - 1]); /* Shift by one so we get the right size for a signed number. */ length += mk_ebmlSizeSize((u_size) << 1); } break; } case MK_LACING_FIXED: { laced = calloc(1, sizeof(*laced)); laced[0] = track->frame.lacing_num_frames; ++length; break; } default: break; } fsize = track->frame.data ? track->frame.data->d_cur : 0; bgsize = fsize + 4 + mk_ebmlSizeSize(fsize + 4 + length) + 1 + length; if (!track->frame.keyframe) { ref = track->prev_frame_tc_scaled - w->cluster.tc_scaled - delta; bgsize += 1 + 1 + mk_ebmlSIntSize(ref); } if (block_duration > 0) /* BlockDuration */ { bgsize += 1 + 1 + mk_ebmlUIntSize(block_duration); } CHECK(mk_writeID(w->cluster.context, MATROSKA_ID_BLOCKGROUP)); /* BlockGroup */ CHECK(mk_writeSize(w->cluster.context, bgsize)); CHECK(mk_writeID(w->cluster.context, MATROSKA_ID_BLOCK)); /* Block */ CHECK(mk_writeSize(w->cluster.context, fsize + 4 + length)); /* BlockSize */ CHECK(mk_writeSize(w->cluster.context, track->track_id)); /* track number */ w->cluster.block_count++; c_delta[0] = delta >> 8; c_delta[1] = delta; /* Timecode relative to Cluster. */ CHECK(mk_appendContextData(w->cluster.context, c_delta, 2)); /* flags = ( track->frame.keyframe << 8 ) | track->frame.lacing; */ flags = track->frame.lacing << 1; /* Flags: Bit 5-6 describe what type of lacing to use. */ CHECK(mk_appendContextData(w->cluster.context, &flags, 1)); if (track->frame.lacing) { if (track->frame.lacing == MK_LACING_EBML) { /* Number of frames in lace - 1 */ CHECK(mk_appendContextData(w->cluster.context, &track->frame.lacing_num_frames, 1)); /* Size of 1st frame. */ CHECK(mk_writeSize(w->cluster.context, track->frame.lacing_sizes[0])); for (i = 1; i < track->frame.lacing_num_frames; i++) { /* Size difference between previous size and this size. */ CHECK(mk_writeSSize(w->cluster.context, track->frame.lacing_sizes[i] - track->frame.lacing_sizes[i - 1])); } } else if (length > 0 && laced != NULL) { CHECK(mk_appendContextData(w->cluster.context, laced, length)); free(laced); laced = NULL; } } if (track->frame.data) { CHECK(mk_appendContextData(w->cluster.context, track->frame.data->data, track->frame.data->d_cur)); track->frame.data->d_cur = 0; } if (!track->frame.keyframe) /* ReferenceBlock */ CHECK(mk_writeSInt(w->cluster.context, MATROSKA_ID_REFERENCEBLOCK, ref)); if (block_duration > 0) /* BlockDuration */ CHECK(mk_writeUInt(w->cluster.context, 0x9b, block_duration)); /* This may get a little out of hand, but it seems sane enough for now. */ if (track->frame.keyframe && (track->track_type == MK_TRACK_VIDEO)) { /* if (track->frame.keyframe && (track->track_type & MK_TRACK_VIDEO) && ((track->prev_cue_pos + 3*CLSIZE) <= w->f_pos || track->frame.timecode == 0)) { */ /* CuePoint */ if ((c = mk_createContext(w, w->cues, MATROSKA_ID_CUEPOINT)) == NULL) return -1; /* CueTime */ CHECK(mk_writeUInt(c, MATROSKA_ID_CUETIME, (track->frame.timecode / w->timescale))); /* CueTrackPositions */ if ((tp = mk_createContext(w, c, MATROSKA_ID_CUETRACKPOSITIONS)) == NULL) return -1; /* CueTrack */ CHECK(mk_writeUInt(tp, MATROSKA_ID_CUETRACK, track->track_id)); /* CueClusterPosition */ CHECK(mk_writeUInt(tp, MATROSKA_ID_CUECLUSTERPOSITION, w->cluster.pointer)); /* CueBlockNumber */ /* CHECK(mk_writeUInt(c, MATROSKA_ID_CUEBLOCKNUMBER, w->cluster.block_count)); */ CHECK(mk_closeContext(tp, 0)); CHECK(mk_closeContext(c, 0)); track->prev_cue_pos = w->f_pos; } track->in_frame = 0; track->prev_frame_tc_scaled = w->cluster.tc_scaled + delta; return 0; }
static int mk_writeFloat(mk_Context *c, unsigned id, float f) { CHECK(mk_writeID(c, id)); CHECK(mk_writeSize(c, 4)); CHECK(mk_writeFloatRaw(c, f)); return 0; }
static int mk_writeBin(mk_Context *c, unsigned id, const void *data, unsigned size) { CHECK(mk_writeID(c, id)); CHECK(mk_writeSize(c, size)); CHECK(mk_appendContextData(c, data, size)); return 0; }