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; }
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; }