libvpx/webmenc.c - platform/external/libvpx - Git at Google

 /*
  *  Copyright (c) 2013 The WebM project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 #include "webmenc.h"

 #include <limits.h>
 #include <string.h>

 #include "third_party/libmkv/EbmlWriter.h"
 #include "third_party/libmkv/EbmlIDs.h"

 void Ebml_Write(struct EbmlGlobal *glob,
                 const void *buffer_in,
                 unsigned long len) {
   (void) fwrite(buffer_in, 1, len, glob->stream);
 }

 #define WRITE_BUFFER(s) \
 for (i = len - 1; i >= 0; i--) { \
   x = (char)(*(const s *)buffer_in >> (i * CHAR_BIT)); \
   Ebml_Write(glob, &x, 1); \
 }

 void Ebml_Serialize(struct EbmlGlobal *glob,
                     const void *buffer_in,
                     int buffer_size,
                     unsigned long len) {
   char x;
   int i;

   /* buffer_size:
    * 1 - int8_t;
    * 2 - int16_t;
    * 3 - int32_t;
    * 4 - int64_t;
    */
   switch (buffer_size) {
     case 1:
       WRITE_BUFFER(int8_t)
       break;
     case 2:
       WRITE_BUFFER(int16_t)
       break;
     case 4:
       WRITE_BUFFER(int32_t)
       break;
     case 8:
       WRITE_BUFFER(int64_t)
       break;
     default:
       break;
   }
 }
 #undef WRITE_BUFFER

 /* Need a fixed size serializer for the track ID. libmkv provides a 64 bit
  * one, but not a 32 bit one.
  */
 static void Ebml_SerializeUnsigned32(struct EbmlGlobal *glob,
                                      unsigned int class_id,
                                      uint64_t ui) {
   const unsigned char sizeSerialized = 4 | 0x80;
   Ebml_WriteID(glob, class_id);
   Ebml_Serialize(glob, &sizeSerialized, sizeof(sizeSerialized), 1);
   Ebml_Serialize(glob, &ui, sizeof(ui), 4);
 }

 static void Ebml_StartSubElement(struct EbmlGlobal *glob,
                                  EbmlLoc *ebmlLoc,
                                  unsigned int class_id) {
   const uint64_t kEbmlUnknownLength = LITERALU64(0x01FFFFFF, 0xFFFFFFFF);
   Ebml_WriteID(glob, class_id);
   *ebmlLoc = ftello(glob->stream);
   Ebml_Serialize(glob, &kEbmlUnknownLength, sizeof(kEbmlUnknownLength), 8);
 }

 static void Ebml_EndSubElement(struct EbmlGlobal *glob, EbmlLoc *ebmlLoc) {
   off_t pos;
   uint64_t size;

   /* Save the current stream pointer. */
   pos = ftello(glob->stream);

   /* Calculate the size of this element. */
   size = pos - *ebmlLoc - 8;
   size |= LITERALU64(0x01000000, 0x00000000);

   /* Seek back to the beginning of the element and write the new size. */
   fseeko(glob->stream, *ebmlLoc, SEEK_SET);
   Ebml_Serialize(glob, &size, sizeof(size), 8);

   /* Reset the stream pointer. */
   fseeko(glob->stream, pos, SEEK_SET);
 }

 void write_webm_seek_element(struct EbmlGlobal *ebml,
                              unsigned int id,
                              off_t pos) {
   uint64_t offset = pos - ebml->position_reference;
   EbmlLoc start;
   Ebml_StartSubElement(ebml, &start, Seek);
   Ebml_SerializeBinary(ebml, SeekID, id);
   Ebml_SerializeUnsigned64(ebml, SeekPosition, offset);
   Ebml_EndSubElement(ebml, &start);
 }

 void write_webm_seek_info(struct EbmlGlobal *ebml) {
   off_t pos;
   EbmlLoc start;
   EbmlLoc startInfo;
   uint64_t frame_time;
   char version_string[64];

   /* Save the current stream pointer. */
   pos = ftello(ebml->stream);

   if (ebml->seek_info_pos)
     fseeko(ebml->stream, ebml->seek_info_pos, SEEK_SET);
   else
     ebml->seek_info_pos = pos;

   Ebml_StartSubElement(ebml, &start, SeekHead);
   write_webm_seek_element(ebml, Tracks, ebml->track_pos);
   write_webm_seek_element(ebml, Cues, ebml->cue_pos);
   write_webm_seek_element(ebml, Info, ebml->segment_info_pos);
   Ebml_EndSubElement(ebml, &start);

   /* Create and write the Segment Info. */
   if (ebml->debug) {
     strcpy(version_string, "vpxenc");
   } else {
     strcpy(version_string, "vpxenc ");
     strncat(version_string,
             vpx_codec_version_str(),
             sizeof(version_string) - 1 - strlen(version_string));
   }

   frame_time = (uint64_t)1000 * ebml->framerate.den
                / ebml->framerate.num;
   ebml->segment_info_pos = ftello(ebml->stream);
   Ebml_StartSubElement(ebml, &startInfo, Info);
   Ebml_SerializeUnsigned(ebml, TimecodeScale, 1000000);
   Ebml_SerializeFloat(ebml, Segment_Duration,
                       (double)(ebml->last_pts_ms + frame_time));
   Ebml_SerializeString(ebml, 0x4D80, version_string);
   Ebml_SerializeString(ebml, 0x5741, version_string);
   Ebml_EndSubElement(ebml, &startInfo);
 }

 void write_webm_file_header(struct EbmlGlobal *glob,
                             const vpx_codec_enc_cfg_t *cfg,
                             const struct vpx_rational *fps,
                             stereo_format_t stereo_fmt,
                             unsigned int fourcc) {
   EbmlLoc start;
   EbmlLoc trackStart;
   EbmlLoc videoStart;
   unsigned int trackNumber = 1;
   uint64_t trackID = 0;
   unsigned int pixelWidth = cfg->g_w;
   unsigned int pixelHeight = cfg->g_h;

   /* Write the EBML header. */
   Ebml_StartSubElement(glob, &start, EBML);
   Ebml_SerializeUnsigned(glob, EBMLVersion, 1);
   Ebml_SerializeUnsigned(glob, EBMLReadVersion, 1);
   Ebml_SerializeUnsigned(glob, EBMLMaxIDLength, 4);
   Ebml_SerializeUnsigned(glob, EBMLMaxSizeLength, 8);
   Ebml_SerializeString(glob, DocType, "webm");
   Ebml_SerializeUnsigned(glob, DocTypeVersion, 2);
   Ebml_SerializeUnsigned(glob, DocTypeReadVersion, 2);
   Ebml_EndSubElement(glob, &start);

   /* Open and begin writing the segment element. */
   Ebml_StartSubElement(glob, &glob->startSegment, Segment);
   glob->position_reference = ftello(glob->stream);
   glob->framerate = *fps;
   write_webm_seek_info(glob);

   /* Open and write the Tracks element. */
   glob->track_pos = ftello(glob->stream);
   Ebml_StartSubElement(glob, &trackStart, Tracks);

   /* Open and write the Track entry. */
   Ebml_StartSubElement(glob, &start, TrackEntry);
   Ebml_SerializeUnsigned(glob, TrackNumber, trackNumber);
   glob->track_id_pos = ftello(glob->stream);
   Ebml_SerializeUnsigned32(glob, TrackUID, trackID);
   Ebml_SerializeUnsigned(glob, TrackType, 1);
   Ebml_SerializeString(glob, CodecID,
                        fourcc == VP8_FOURCC ? "V_VP8" : "V_VP9");
   Ebml_StartSubElement(glob, &videoStart, Video);
   Ebml_SerializeUnsigned(glob, PixelWidth, pixelWidth);
   Ebml_SerializeUnsigned(glob, PixelHeight, pixelHeight);
   Ebml_SerializeUnsigned(glob, StereoMode, stereo_fmt);
   Ebml_EndSubElement(glob, &videoStart);

   /* Close Track entry. */
   Ebml_EndSubElement(glob, &start);

   /* Close Tracks element. */
   Ebml_EndSubElement(glob, &trackStart);

   /* Segment element remains open. */
 }

 void write_webm_block(struct EbmlGlobal *glob,
                       const vpx_codec_enc_cfg_t *cfg,
                       const vpx_codec_cx_pkt_t *pkt) {
   unsigned int block_length;
   unsigned char track_number;
   uint16_t block_timecode = 0;
   unsigned char flags;
   int64_t pts_ms;
   int start_cluster = 0, is_keyframe;

   /* Calculate the PTS of this frame in milliseconds. */
   pts_ms = pkt->data.frame.pts * 1000
            * (uint64_t)cfg->g_timebase.num / (uint64_t)cfg->g_timebase.den;

   if (pts_ms <= glob->last_pts_ms)
     pts_ms = glob->last_pts_ms + 1;

   glob->last_pts_ms = pts_ms;

   /* Calculate the relative time of this block. */
   if (pts_ms - glob->cluster_timecode > SHRT_MAX)
     start_cluster = 1;
   else
     block_timecode = (uint16_t)pts_ms - glob->cluster_timecode;

   is_keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY);
   if (start_cluster || is_keyframe) {
     if (glob->cluster_open)
       Ebml_EndSubElement(glob, &glob->startCluster);

     /* Open the new cluster. */
     block_timecode = 0;
     glob->cluster_open = 1;
     glob->cluster_timecode = (uint32_t)pts_ms;
     glob->cluster_pos = ftello(glob->stream);
     Ebml_StartSubElement(glob, &glob->startCluster, Cluster);
     Ebml_SerializeUnsigned(glob, Timecode, glob->cluster_timecode);

     /* Save a cue point if this is a keyframe. */
     if (is_keyframe) {
       struct cue_entry *cue, *new_cue_list;

       new_cue_list = realloc(glob->cue_list,
                              (glob->cues + 1) * sizeof(struct cue_entry));
       if (new_cue_list)
         glob->cue_list = new_cue_list;
       else
         fatal("Failed to realloc cue list.");

       cue = &glob->cue_list[glob->cues];
       cue->time = glob->cluster_timecode;
       cue->loc = glob->cluster_pos;
       glob->cues++;
     }
   }

   /* Write the Simple Block. */
   Ebml_WriteID(glob, SimpleBlock);

   block_length = (unsigned int)pkt->data.frame.sz + 4;
   block_length |= 0x10000000;
   Ebml_Serialize(glob, &block_length, sizeof(block_length), 4);

   track_number = 1;
   track_number |= 0x80;
   Ebml_Write(glob, &track_number, 1);

   Ebml_Serialize(glob, &block_timecode, sizeof(block_timecode), 2);

   flags = 0;
   if (is_keyframe)
     flags |= 0x80;
   if (pkt->data.frame.flags & VPX_FRAME_IS_INVISIBLE)
     flags |= 0x08;
   Ebml_Write(glob, &flags, 1);

   Ebml_Write(glob, pkt->data.frame.buf, (unsigned int)pkt->data.frame.sz);
 }

 void write_webm_file_footer(struct EbmlGlobal *glob, int hash) {
   EbmlLoc start_cues;
   EbmlLoc start_cue_point;
   EbmlLoc start_cue_tracks;
   unsigned int i;

   if (glob->cluster_open)
     Ebml_EndSubElement(glob, &glob->startCluster);

   glob->cue_pos = ftello(glob->stream);
   Ebml_StartSubElement(glob, &start_cues, Cues);

   for (i = 0; i < glob->cues; i++) {
     struct cue_entry *cue = &glob->cue_list[i];
     Ebml_StartSubElement(glob, &start_cue_point, CuePoint);
     Ebml_SerializeUnsigned(glob, CueTime, cue->time);

     Ebml_StartSubElement(glob, &start_cue_tracks, CueTrackPositions);
     Ebml_SerializeUnsigned(glob, CueTrack, 1);
     Ebml_SerializeUnsigned64(glob, CueClusterPosition,
                              cue->loc - glob->position_reference);
     Ebml_EndSubElement(glob, &start_cue_tracks);

     Ebml_EndSubElement(glob, &start_cue_point);
   }

   Ebml_EndSubElement(glob, &start_cues);

   /* Close the Segment. */
   Ebml_EndSubElement(glob, &glob->startSegment);

   /* Patch up the seek info block. */
   write_webm_seek_info(glob);

   /* Patch up the track id. */
   fseeko(glob->stream, glob->track_id_pos, SEEK_SET);
   Ebml_SerializeUnsigned32(glob, TrackUID, glob->debug ? 0xDEADBEEF : hash);

   fseeko(glob->stream, 0, SEEK_END);
 }
	/*
	* Copyright (c) 2013 The WebM project authors. All Rights Reserved.
	*
	* Use of this source code is governed by a BSD-style license
	* that can be found in the LICENSE file in the root of the source
	* tree. An additional intellectual property rights grant can be found
	* in the file PATENTS. All contributing project authors may
	* be found in the AUTHORS file in the root of the source tree.
	*/
	#include "webmenc.h"

	#include <limits.h>
	#include <string.h>

	#include "third_party/libmkv/EbmlWriter.h"
	#include "third_party/libmkv/EbmlIDs.h"

	void Ebml_Write(struct EbmlGlobal *glob,
	const void *buffer_in,
	unsigned long len) {
	(void) fwrite(buffer_in, 1, len, glob->stream);
	}

	#define WRITE_BUFFER(s) \
	for (i = len - 1; i >= 0; i--) { \
	x = (char)((const s )buffer_in >> (i * CHAR_BIT)); \
	Ebml_Write(glob, &x, 1); \
	}

	void Ebml_Serialize(struct EbmlGlobal *glob,
	const void *buffer_in,
	int buffer_size,
	unsigned long len) {
	char x;
	int i;

	/* buffer_size:
	* 1 - int8_t;
	* 2 - int16_t;
	* 3 - int32_t;
	* 4 - int64_t;
	*/
	switch (buffer_size) {
	case 1:
	WRITE_BUFFER(int8_t)
	break;
	case 2:
	WRITE_BUFFER(int16_t)
	break;
	case 4:
	WRITE_BUFFER(int32_t)
	break;
	case 8:
	WRITE_BUFFER(int64_t)
	break;
	default:
	break;
	}
	}
	#undef WRITE_BUFFER

	/* Need a fixed size serializer for the track ID. libmkv provides a 64 bit
	* one, but not a 32 bit one.
	*/
	static void Ebml_SerializeUnsigned32(struct EbmlGlobal *glob,
	unsigned int class_id,
	uint64_t ui) {
	const unsigned char sizeSerialized = 4 \| 0x80;
	Ebml_WriteID(glob, class_id);
	Ebml_Serialize(glob, &sizeSerialized, sizeof(sizeSerialized), 1);
	Ebml_Serialize(glob, &ui, sizeof(ui), 4);
	}

	static void Ebml_StartSubElement(struct EbmlGlobal *glob,
	EbmlLoc *ebmlLoc,
	unsigned int class_id) {
	const uint64_t kEbmlUnknownLength = LITERALU64(0x01FFFFFF, 0xFFFFFFFF);
	Ebml_WriteID(glob, class_id);
	*ebmlLoc = ftello(glob->stream);
	Ebml_Serialize(glob, &kEbmlUnknownLength, sizeof(kEbmlUnknownLength), 8);
	}

	static void Ebml_EndSubElement(struct EbmlGlobal glob, EbmlLoc ebmlLoc) {
	off_t pos;
	uint64_t size;

	/* Save the current stream pointer. */
	pos = ftello(glob->stream);

	/* Calculate the size of this element. */
	size = pos - *ebmlLoc - 8;
	size \|= LITERALU64(0x01000000, 0x00000000);

	/* Seek back to the beginning of the element and write the new size. */
	fseeko(glob->stream, *ebmlLoc, SEEK_SET);
	Ebml_Serialize(glob, &size, sizeof(size), 8);

	/* Reset the stream pointer. */
	fseeko(glob->stream, pos, SEEK_SET);
	}

	void write_webm_seek_element(struct EbmlGlobal *ebml,
	unsigned int id,
	off_t pos) {
	uint64_t offset = pos - ebml->position_reference;
	EbmlLoc start;
	Ebml_StartSubElement(ebml, &start, Seek);
	Ebml_SerializeBinary(ebml, SeekID, id);
	Ebml_SerializeUnsigned64(ebml, SeekPosition, offset);
	Ebml_EndSubElement(ebml, &start);
	}

	void write_webm_seek_info(struct EbmlGlobal *ebml) {
	off_t pos;
	EbmlLoc start;
	EbmlLoc startInfo;
	uint64_t frame_time;
	char version_string[64];

	/* Save the current stream pointer. */
	pos = ftello(ebml->stream);

	if (ebml->seek_info_pos)
	fseeko(ebml->stream, ebml->seek_info_pos, SEEK_SET);
	else
	ebml->seek_info_pos = pos;

	Ebml_StartSubElement(ebml, &start, SeekHead);
	write_webm_seek_element(ebml, Tracks, ebml->track_pos);
	write_webm_seek_element(ebml, Cues, ebml->cue_pos);
	write_webm_seek_element(ebml, Info, ebml->segment_info_pos);
	Ebml_EndSubElement(ebml, &start);

	/* Create and write the Segment Info. */
	if (ebml->debug) {
	strcpy(version_string, "vpxenc");
	} else {
	strcpy(version_string, "vpxenc ");
	strncat(version_string,
	vpx_codec_version_str(),
	sizeof(version_string) - 1 - strlen(version_string));
	}

	frame_time = (uint64_t)1000 * ebml->framerate.den
	/ ebml->framerate.num;
	ebml->segment_info_pos = ftello(ebml->stream);
	Ebml_StartSubElement(ebml, &startInfo, Info);
	Ebml_SerializeUnsigned(ebml, TimecodeScale, 1000000);
	Ebml_SerializeFloat(ebml, Segment_Duration,
	(double)(ebml->last_pts_ms + frame_time));
	Ebml_SerializeString(ebml, 0x4D80, version_string);
	Ebml_SerializeString(ebml, 0x5741, version_string);
	Ebml_EndSubElement(ebml, &startInfo);
	}

	void write_webm_file_header(struct EbmlGlobal *glob,
	const vpx_codec_enc_cfg_t *cfg,
	const struct vpx_rational *fps,
	stereo_format_t stereo_fmt,
	unsigned int fourcc) {
	EbmlLoc start;
	EbmlLoc trackStart;
	EbmlLoc videoStart;
	unsigned int trackNumber = 1;
	uint64_t trackID = 0;
	unsigned int pixelWidth = cfg->g_w;
	unsigned int pixelHeight = cfg->g_h;

	/* Write the EBML header. */
	Ebml_StartSubElement(glob, &start, EBML);
	Ebml_SerializeUnsigned(glob, EBMLVersion, 1);
	Ebml_SerializeUnsigned(glob, EBMLReadVersion, 1);
	Ebml_SerializeUnsigned(glob, EBMLMaxIDLength, 4);
	Ebml_SerializeUnsigned(glob, EBMLMaxSizeLength, 8);
	Ebml_SerializeString(glob, DocType, "webm");
	Ebml_SerializeUnsigned(glob, DocTypeVersion, 2);
	Ebml_SerializeUnsigned(glob, DocTypeReadVersion, 2);
	Ebml_EndSubElement(glob, &start);

	/* Open and begin writing the segment element. */
	Ebml_StartSubElement(glob, &glob->startSegment, Segment);
	glob->position_reference = ftello(glob->stream);
	glob->framerate = *fps;
	write_webm_seek_info(glob);

	/* Open and write the Tracks element. */
	glob->track_pos = ftello(glob->stream);
	Ebml_StartSubElement(glob, &trackStart, Tracks);

	/* Open and write the Track entry. */
	Ebml_StartSubElement(glob, &start, TrackEntry);
	Ebml_SerializeUnsigned(glob, TrackNumber, trackNumber);
	glob->track_id_pos = ftello(glob->stream);
	Ebml_SerializeUnsigned32(glob, TrackUID, trackID);
	Ebml_SerializeUnsigned(glob, TrackType, 1);
	Ebml_SerializeString(glob, CodecID,
	fourcc == VP8_FOURCC ? "V_VP8" : "V_VP9");
	Ebml_StartSubElement(glob, &videoStart, Video);
	Ebml_SerializeUnsigned(glob, PixelWidth, pixelWidth);
	Ebml_SerializeUnsigned(glob, PixelHeight, pixelHeight);
	Ebml_SerializeUnsigned(glob, StereoMode, stereo_fmt);
	Ebml_EndSubElement(glob, &videoStart);

	/* Close Track entry. */
	Ebml_EndSubElement(glob, &start);

	/* Close Tracks element. */
	Ebml_EndSubElement(glob, &trackStart);

	/* Segment element remains open. */
	}

	void write_webm_block(struct EbmlGlobal *glob,
	const vpx_codec_enc_cfg_t *cfg,
	const vpx_codec_cx_pkt_t *pkt) {
	unsigned int block_length;
	unsigned char track_number;
	uint16_t block_timecode = 0;
	unsigned char flags;
	int64_t pts_ms;
	int start_cluster = 0, is_keyframe;

	/* Calculate the PTS of this frame in milliseconds. */
	pts_ms = pkt->data.frame.pts * 1000
	* (uint64_t)cfg->g_timebase.num / (uint64_t)cfg->g_timebase.den;

	if (pts_ms <= glob->last_pts_ms)
	pts_ms = glob->last_pts_ms + 1;

	glob->last_pts_ms = pts_ms;

	/* Calculate the relative time of this block. */
	if (pts_ms - glob->cluster_timecode > SHRT_MAX)
	start_cluster = 1;
	else
	block_timecode = (uint16_t)pts_ms - glob->cluster_timecode;

	is_keyframe = (pkt->data.frame.flags & VPX_FRAME_IS_KEY);
	if (start_cluster \|\| is_keyframe) {
	if (glob->cluster_open)
	Ebml_EndSubElement(glob, &glob->startCluster);

	/* Open the new cluster. */
	block_timecode = 0;
	glob->cluster_open = 1;
	glob->cluster_timecode = (uint32_t)pts_ms;
	glob->cluster_pos = ftello(glob->stream);
	Ebml_StartSubElement(glob, &glob->startCluster, Cluster);
	Ebml_SerializeUnsigned(glob, Timecode, glob->cluster_timecode);

	/* Save a cue point if this is a keyframe. */
	if (is_keyframe) {
	struct cue_entry cue, new_cue_list;

	new_cue_list = realloc(glob->cue_list,
	(glob->cues + 1) * sizeof(struct cue_entry));
	if (new_cue_list)
	glob->cue_list = new_cue_list;
	else
	fatal("Failed to realloc cue list.");

	cue = &glob->cue_list[glob->cues];
	cue->time = glob->cluster_timecode;
	cue->loc = glob->cluster_pos;
	glob->cues++;
	}
	}

	/* Write the Simple Block. */
	Ebml_WriteID(glob, SimpleBlock);

	block_length = (unsigned int)pkt->data.frame.sz + 4;
	block_length \|= 0x10000000;
	Ebml_Serialize(glob, &block_length, sizeof(block_length), 4);

	track_number = 1;
	track_number \|= 0x80;
	Ebml_Write(glob, &track_number, 1);

	Ebml_Serialize(glob, &block_timecode, sizeof(block_timecode), 2);

	flags = 0;
	if (is_keyframe)
	flags \|= 0x80;
	if (pkt->data.frame.flags & VPX_FRAME_IS_INVISIBLE)
	flags \|= 0x08;
	Ebml_Write(glob, &flags, 1);

	Ebml_Write(glob, pkt->data.frame.buf, (unsigned int)pkt->data.frame.sz);
	}

	void write_webm_file_footer(struct EbmlGlobal *glob, int hash) {
	EbmlLoc start_cues;
	EbmlLoc start_cue_point;
	EbmlLoc start_cue_tracks;
	unsigned int i;

	if (glob->cluster_open)
	Ebml_EndSubElement(glob, &glob->startCluster);

	glob->cue_pos = ftello(glob->stream);
	Ebml_StartSubElement(glob, &start_cues, Cues);

	for (i = 0; i < glob->cues; i++) {
	struct cue_entry *cue = &glob->cue_list[i];
	Ebml_StartSubElement(glob, &start_cue_point, CuePoint);
	Ebml_SerializeUnsigned(glob, CueTime, cue->time);

	Ebml_StartSubElement(glob, &start_cue_tracks, CueTrackPositions);
	Ebml_SerializeUnsigned(glob, CueTrack, 1);
	Ebml_SerializeUnsigned64(glob, CueClusterPosition,
	cue->loc - glob->position_reference);
	Ebml_EndSubElement(glob, &start_cue_tracks);

	Ebml_EndSubElement(glob, &start_cue_point);
	}

	Ebml_EndSubElement(glob, &start_cues);

	/* Close the Segment. */
	Ebml_EndSubElement(glob, &glob->startSegment);

	/* Patch up the seek info block. */
	write_webm_seek_info(glob);

	/* Patch up the track id. */
	fseeko(glob->stream, glob->track_id_pos, SEEK_SET);
	Ebml_SerializeUnsigned32(glob, TrackUID, glob->debug ? 0xDEADBEEF : hash);

	fseeko(glob->stream, 0, SEEK_END);
	}