[69684] | 1 | /* $Id: WebMWriter.cpp 70623 2018-01-18 10:05:23Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
| 3 | * WebMWriter.cpp - WebM container handling.
|
---|
| 4 | */
|
---|
| 5 |
|
---|
| 6 | /*
|
---|
[70622] | 7 | * Copyright (C) 2013-2018 Oracle Corporation
|
---|
[69684] | 8 | *
|
---|
| 9 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
| 10 | * available from http://www.virtualbox.org. This file is free software;
|
---|
| 11 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
| 12 | * General Public License (GPL) as published by the Free Software
|
---|
| 13 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
| 14 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
| 15 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
| 16 | */
|
---|
| 17 |
|
---|
| 18 | /**
|
---|
| 19 | * For more information, see:
|
---|
| 20 | * - https://w3c.github.io/media-source/webm-byte-stream-format.html
|
---|
| 21 | * - https://www.webmproject.org/docs/container/#muxer-guidelines
|
---|
| 22 | */
|
---|
| 23 |
|
---|
| 24 | #define LOG_GROUP LOG_GROUP_MAIN_DISPLAY
|
---|
| 25 | #include "LoggingNew.h"
|
---|
| 26 |
|
---|
| 27 | #include <list>
|
---|
| 28 | #include <map>
|
---|
| 29 | #include <queue>
|
---|
| 30 | #include <stack>
|
---|
| 31 |
|
---|
| 32 | #include <math.h> /* For lround.h. */
|
---|
| 33 |
|
---|
| 34 | #include <iprt/asm.h>
|
---|
| 35 | #include <iprt/buildconfig.h>
|
---|
| 36 | #include <iprt/cdefs.h>
|
---|
| 37 | #include <iprt/critsect.h>
|
---|
| 38 | #include <iprt/err.h>
|
---|
| 39 | #include <iprt/file.h>
|
---|
| 40 | #include <iprt/rand.h>
|
---|
| 41 | #include <iprt/string.h>
|
---|
| 42 |
|
---|
| 43 | #include <VBox/log.h>
|
---|
| 44 | #include <VBox/version.h>
|
---|
| 45 |
|
---|
| 46 | #include "WebMWriter.h"
|
---|
| 47 | #include "EBML_MKV.h"
|
---|
| 48 |
|
---|
| 49 |
|
---|
| 50 | WebMWriter::WebMWriter(void)
|
---|
| 51 | {
|
---|
| 52 | /* Size (in bytes) of time code to write. We use 2 bytes (16 bit) by default. */
|
---|
| 53 | m_cbTimecode = 2;
|
---|
| 54 | m_uTimecodeMax = UINT16_MAX;
|
---|
| 55 |
|
---|
| 56 | m_fInTracksSection = false;
|
---|
| 57 | }
|
---|
| 58 |
|
---|
| 59 | WebMWriter::~WebMWriter(void)
|
---|
| 60 | {
|
---|
[70622] | 61 | Close();
|
---|
[69684] | 62 | }
|
---|
| 63 |
|
---|
| 64 | /**
|
---|
| 65 | * Opens (creates) an output file using an already open file handle.
|
---|
| 66 | *
|
---|
| 67 | * @returns VBox status code.
|
---|
| 68 | * @param a_pszFilename Name of the file the file handle points at.
|
---|
| 69 | * @param a_phFile Pointer to open file handle to use.
|
---|
| 70 | * @param a_enmAudioCodec Audio codec to use.
|
---|
| 71 | * @param a_enmVideoCodec Video codec to use.
|
---|
| 72 | */
|
---|
| 73 | int WebMWriter::OpenEx(const char *a_pszFilename, PRTFILE a_phFile,
|
---|
| 74 | WebMWriter::AudioCodec a_enmAudioCodec, WebMWriter::VideoCodec a_enmVideoCodec)
|
---|
| 75 | {
|
---|
| 76 | try
|
---|
| 77 | {
|
---|
| 78 | m_enmAudioCodec = a_enmAudioCodec;
|
---|
| 79 | m_enmVideoCodec = a_enmVideoCodec;
|
---|
| 80 |
|
---|
| 81 | LogFunc(("Creating '%s'\n", a_pszFilename));
|
---|
| 82 |
|
---|
| 83 | int rc = createEx(a_pszFilename, a_phFile);
|
---|
| 84 | if (RT_SUCCESS(rc))
|
---|
| 85 | {
|
---|
| 86 | rc = init();
|
---|
| 87 | if (RT_SUCCESS(rc))
|
---|
| 88 | rc = writeHeader();
|
---|
| 89 | }
|
---|
| 90 | }
|
---|
| 91 | catch(int rc)
|
---|
| 92 | {
|
---|
| 93 | return rc;
|
---|
| 94 | }
|
---|
| 95 | return VINF_SUCCESS;
|
---|
| 96 | }
|
---|
| 97 |
|
---|
| 98 | /**
|
---|
| 99 | * Opens an output file.
|
---|
| 100 | *
|
---|
| 101 | * @returns VBox status code.
|
---|
| 102 | * @param a_pszFilename Name of the file to create.
|
---|
| 103 | * @param a_fOpen File open mode of type RTFILE_O_.
|
---|
| 104 | * @param a_enmAudioCodec Audio codec to use.
|
---|
| 105 | * @param a_enmVideoCodec Video codec to use.
|
---|
| 106 | */
|
---|
| 107 | int WebMWriter::Open(const char *a_pszFilename, uint64_t a_fOpen,
|
---|
| 108 | WebMWriter::AudioCodec a_enmAudioCodec, WebMWriter::VideoCodec a_enmVideoCodec)
|
---|
| 109 | {
|
---|
| 110 | try
|
---|
| 111 | {
|
---|
| 112 | m_enmAudioCodec = a_enmAudioCodec;
|
---|
| 113 | m_enmVideoCodec = a_enmVideoCodec;
|
---|
| 114 |
|
---|
| 115 | LogFunc(("Creating '%s'\n", a_pszFilename));
|
---|
| 116 |
|
---|
| 117 | int rc = create(a_pszFilename, a_fOpen);
|
---|
| 118 | if (RT_SUCCESS(rc))
|
---|
| 119 | {
|
---|
| 120 | rc = init();
|
---|
| 121 | if (RT_SUCCESS(rc))
|
---|
| 122 | rc = writeHeader();
|
---|
| 123 | }
|
---|
| 124 | }
|
---|
| 125 | catch(int rc)
|
---|
| 126 | {
|
---|
| 127 | return rc;
|
---|
| 128 | }
|
---|
| 129 | return VINF_SUCCESS;
|
---|
| 130 | }
|
---|
| 131 |
|
---|
| 132 | /**
|
---|
| 133 | * Closes the WebM file and drains all queues.
|
---|
| 134 | *
|
---|
| 135 | * @returns IPRT status code.
|
---|
| 136 | */
|
---|
| 137 | int WebMWriter::Close(void)
|
---|
| 138 | {
|
---|
[70622] | 139 | LogFlowFuncEnter();
|
---|
| 140 |
|
---|
[69684] | 141 | if (!isOpen())
|
---|
| 142 | return VINF_SUCCESS;
|
---|
| 143 |
|
---|
| 144 | /* Make sure to drain all queues. */
|
---|
| 145 | processQueues(&CurSeg.queueBlocks, true /* fForce */);
|
---|
| 146 |
|
---|
| 147 | writeFooter();
|
---|
| 148 |
|
---|
| 149 | WebMTracks::iterator itTrack = CurSeg.mapTracks.begin();
|
---|
| 150 | for (; itTrack != CurSeg.mapTracks.end(); ++itTrack)
|
---|
| 151 | {
|
---|
| 152 | WebMTrack *pTrack = itTrack->second;
|
---|
| 153 |
|
---|
| 154 | delete pTrack;
|
---|
| 155 | CurSeg.mapTracks.erase(itTrack);
|
---|
| 156 | }
|
---|
| 157 |
|
---|
| 158 | Assert(CurSeg.queueBlocks.Map.size() == 0);
|
---|
| 159 | Assert(CurSeg.mapTracks.size() == 0);
|
---|
| 160 |
|
---|
| 161 | close();
|
---|
| 162 |
|
---|
| 163 | return VINF_SUCCESS;
|
---|
| 164 | }
|
---|
| 165 |
|
---|
| 166 | /**
|
---|
| 167 | * Adds an audio track.
|
---|
| 168 | *
|
---|
| 169 | * @returns IPRT status code.
|
---|
| 170 | * @param uHz Input sampling rate.
|
---|
| 171 | * Must be supported by the selected audio codec.
|
---|
| 172 | * @param cChannels Number of input audio channels.
|
---|
| 173 | * @param cBits Number of input bits per channel.
|
---|
| 174 | * @param puTrack Track number on successful creation. Optional.
|
---|
| 175 | */
|
---|
| 176 | int WebMWriter::AddAudioTrack(uint16_t uHz, uint8_t cChannels, uint8_t cBits, uint8_t *puTrack)
|
---|
| 177 | {
|
---|
| 178 | #ifdef VBOX_WITH_LIBOPUS
|
---|
| 179 | int rc;
|
---|
| 180 |
|
---|
| 181 | /*
|
---|
| 182 | * Check if the requested codec rate is supported.
|
---|
| 183 | *
|
---|
| 184 | * Only the following values are supported by an Opus standard build
|
---|
| 185 | * -- every other rate only is supported by a custom build.
|
---|
| 186 | */
|
---|
| 187 | switch (uHz)
|
---|
| 188 | {
|
---|
| 189 | case 48000:
|
---|
| 190 | case 24000:
|
---|
| 191 | case 16000:
|
---|
| 192 | case 12000:
|
---|
| 193 | case 8000:
|
---|
| 194 | rc = VINF_SUCCESS;
|
---|
| 195 | break;
|
---|
| 196 |
|
---|
| 197 | default:
|
---|
| 198 | rc = VERR_NOT_SUPPORTED;
|
---|
| 199 | break;
|
---|
| 200 | }
|
---|
| 201 |
|
---|
| 202 | if (RT_FAILURE(rc))
|
---|
| 203 | return rc;
|
---|
| 204 |
|
---|
[70623] | 205 | /* Some players (e.g. Firefox with Nestegg) rely on track numbers starting at 1.
|
---|
| 206 | * Using a track number 0 will show those files as being corrupted. */
|
---|
| 207 | const uint8_t uTrack = (uint8_t)CurSeg.mapTracks.size() + 1;
|
---|
[69684] | 208 |
|
---|
| 209 | subStart(MkvElem_TrackEntry);
|
---|
| 210 |
|
---|
| 211 | serializeUnsignedInteger(MkvElem_TrackNumber, (uint8_t)uTrack);
|
---|
| 212 | serializeString (MkvElem_Language, "und" /* "Undefined"; see ISO-639-2. */);
|
---|
| 213 | serializeUnsignedInteger(MkvElem_FlagLacing, (uint8_t)0);
|
---|
| 214 |
|
---|
| 215 | WebMTrack *pTrack = new WebMTrack(WebMTrackType_Audio, uTrack, RTFileTell(getFile()));
|
---|
| 216 |
|
---|
| 217 | pTrack->Audio.uHz = uHz;
|
---|
| 218 | pTrack->Audio.msPerBlock = 20; /** Opus uses 20ms by default. Make this configurable? */
|
---|
| 219 | pTrack->Audio.framesPerBlock = uHz / (1000 /* s in ms */ / pTrack->Audio.msPerBlock);
|
---|
| 220 |
|
---|
| 221 | WEBMOPUSPRIVDATA opusPrivData(uHz, cChannels);
|
---|
| 222 |
|
---|
| 223 | LogFunc(("Opus @ %RU16Hz (%RU16ms + %RU16 frames per block)\n",
|
---|
| 224 | pTrack->Audio.uHz, pTrack->Audio.msPerBlock, pTrack->Audio.framesPerBlock));
|
---|
| 225 |
|
---|
| 226 | serializeUnsignedInteger(MkvElem_TrackUID, pTrack->uUUID, 4)
|
---|
| 227 | .serializeUnsignedInteger(MkvElem_TrackType, 2 /* Audio */)
|
---|
| 228 | .serializeString(MkvElem_CodecID, "A_OPUS")
|
---|
| 229 | .serializeData(MkvElem_CodecPrivate, &opusPrivData, sizeof(opusPrivData))
|
---|
| 230 | .serializeUnsignedInteger(MkvElem_CodecDelay, 0)
|
---|
| 231 | .serializeUnsignedInteger(MkvElem_SeekPreRoll, 80 * 1000000) /* 80ms in ns. */
|
---|
| 232 | .subStart(MkvElem_Audio)
|
---|
| 233 | .serializeFloat(MkvElem_SamplingFrequency, (float)uHz)
|
---|
| 234 | .serializeUnsignedInteger(MkvElem_Channels, cChannels)
|
---|
| 235 | .serializeUnsignedInteger(MkvElem_BitDepth, cBits)
|
---|
| 236 | .subEnd(MkvElem_Audio)
|
---|
| 237 | .subEnd(MkvElem_TrackEntry);
|
---|
| 238 |
|
---|
| 239 | CurSeg.mapTracks[uTrack] = pTrack;
|
---|
| 240 |
|
---|
| 241 | if (puTrack)
|
---|
| 242 | *puTrack = uTrack;
|
---|
| 243 |
|
---|
| 244 | return VINF_SUCCESS;
|
---|
| 245 | #else
|
---|
| 246 | RT_NOREF(uHz, cChannels, cBits, puTrack);
|
---|
| 247 | return VERR_NOT_SUPPORTED;
|
---|
| 248 | #endif
|
---|
| 249 | }
|
---|
| 250 |
|
---|
| 251 | /**
|
---|
| 252 | * Adds a video track.
|
---|
| 253 | *
|
---|
| 254 | * @returns IPRT status code.
|
---|
| 255 | * @param uWidth Width (in pixels) of the video track.
|
---|
| 256 | * @param uHeight Height (in pixels) of the video track.
|
---|
[70623] | 257 | * @param uFPS FPS (Frames Per Second) of the video track.
|
---|
[69684] | 258 | * @param puTrack Track number of the added video track on success. Optional.
|
---|
| 259 | */
|
---|
[70623] | 260 | int WebMWriter::AddVideoTrack(uint16_t uWidth, uint16_t uHeight, uint32_t uFPS, uint8_t *puTrack)
|
---|
[69684] | 261 | {
|
---|
| 262 | #ifdef VBOX_WITH_LIBVPX
|
---|
[70623] | 263 | /* Some players (e.g. Firefox with Nestegg) rely on track numbers starting at 1.
|
---|
| 264 | * Using a track number 0 will show those files as being corrupted. */
|
---|
| 265 | const uint8_t uTrack = (uint8_t)CurSeg.mapTracks.size() + 1;
|
---|
[69684] | 266 |
|
---|
| 267 | subStart(MkvElem_TrackEntry);
|
---|
| 268 |
|
---|
| 269 | serializeUnsignedInteger(MkvElem_TrackNumber, (uint8_t)uTrack);
|
---|
| 270 | serializeString (MkvElem_Language, "und" /* "Undefined"; see ISO-639-2. */);
|
---|
| 271 | serializeUnsignedInteger(MkvElem_FlagLacing, (uint8_t)0);
|
---|
| 272 |
|
---|
| 273 | WebMTrack *pTrack = new WebMTrack(WebMTrackType_Video, uTrack, RTFileTell(getFile()));
|
---|
| 274 |
|
---|
| 275 | /** @todo Resolve codec type. */
|
---|
| 276 | serializeUnsignedInteger(MkvElem_TrackUID, pTrack->uUUID /* UID */, 4)
|
---|
| 277 | .serializeUnsignedInteger(MkvElem_TrackType, 1 /* Video */)
|
---|
| 278 | .serializeString(MkvElem_CodecID, "V_VP8")
|
---|
| 279 | .subStart(MkvElem_Video)
|
---|
| 280 | .serializeUnsignedInteger(MkvElem_PixelWidth, uWidth)
|
---|
| 281 | .serializeUnsignedInteger(MkvElem_PixelHeight, uHeight)
|
---|
[70623] | 282 | /* Some players rely on the FPS rate for timing calculations.
|
---|
| 283 | * So make sure to *always* include that. */
|
---|
| 284 | .serializeFloat (MkvElem_FrameRate, (float)uFPS)
|
---|
[69684] | 285 | .subEnd(MkvElem_Video);
|
---|
| 286 |
|
---|
| 287 | subEnd(MkvElem_TrackEntry);
|
---|
| 288 |
|
---|
| 289 | CurSeg.mapTracks[uTrack] = pTrack;
|
---|
| 290 |
|
---|
| 291 | if (puTrack)
|
---|
| 292 | *puTrack = uTrack;
|
---|
| 293 |
|
---|
| 294 | return VINF_SUCCESS;
|
---|
| 295 | #else
|
---|
| 296 | RT_NOREF(uWidth, uHeight, dbFPS, puTrack);
|
---|
| 297 | return VERR_NOT_SUPPORTED;
|
---|
| 298 | #endif
|
---|
| 299 | }
|
---|
| 300 |
|
---|
| 301 | /**
|
---|
| 302 | * Gets file name.
|
---|
| 303 | *
|
---|
| 304 | * @returns File name as UTF-8 string.
|
---|
| 305 | */
|
---|
| 306 | const Utf8Str& WebMWriter::GetFileName(void)
|
---|
| 307 | {
|
---|
| 308 | return getFileName();
|
---|
| 309 | }
|
---|
| 310 |
|
---|
| 311 | /**
|
---|
| 312 | * Gets current output file size.
|
---|
| 313 | *
|
---|
| 314 | * @returns File size in bytes.
|
---|
| 315 | */
|
---|
| 316 | uint64_t WebMWriter::GetFileSize(void)
|
---|
| 317 | {
|
---|
| 318 | return getFileSize();
|
---|
| 319 | }
|
---|
| 320 |
|
---|
| 321 | /**
|
---|
| 322 | * Gets current free storage space available for the file.
|
---|
| 323 | *
|
---|
| 324 | * @returns Available storage free space.
|
---|
| 325 | */
|
---|
| 326 | uint64_t WebMWriter::GetAvailableSpace(void)
|
---|
| 327 | {
|
---|
| 328 | return getAvailableSpace();
|
---|
| 329 | }
|
---|
| 330 |
|
---|
| 331 | /**
|
---|
| 332 | * Takes care of the initialization of the instance.
|
---|
| 333 | *
|
---|
| 334 | * @returns IPRT status code.
|
---|
| 335 | */
|
---|
| 336 | int WebMWriter::init(void)
|
---|
| 337 | {
|
---|
| 338 | return CurSeg.init();
|
---|
| 339 | }
|
---|
| 340 |
|
---|
| 341 | /**
|
---|
| 342 | * Takes care of the destruction of the instance.
|
---|
| 343 | */
|
---|
| 344 | void WebMWriter::destroy(void)
|
---|
| 345 | {
|
---|
| 346 | CurSeg.destroy();
|
---|
| 347 | }
|
---|
| 348 |
|
---|
| 349 | /**
|
---|
| 350 | * Writes the WebM file header.
|
---|
| 351 | *
|
---|
| 352 | * @returns IPRT status code.
|
---|
| 353 | */
|
---|
| 354 | int WebMWriter::writeHeader(void)
|
---|
| 355 | {
|
---|
| 356 | LogFunc(("Header @ %RU64\n", RTFileTell(getFile())));
|
---|
| 357 |
|
---|
| 358 | subStart(MkvElem_EBML)
|
---|
| 359 | .serializeUnsignedInteger(MkvElem_EBMLVersion, 1)
|
---|
| 360 | .serializeUnsignedInteger(MkvElem_EBMLReadVersion, 1)
|
---|
| 361 | .serializeUnsignedInteger(MkvElem_EBMLMaxIDLength, 4)
|
---|
| 362 | .serializeUnsignedInteger(MkvElem_EBMLMaxSizeLength, 8)
|
---|
| 363 | .serializeString(MkvElem_DocType, "webm")
|
---|
| 364 | .serializeUnsignedInteger(MkvElem_DocTypeVersion, 2)
|
---|
| 365 | .serializeUnsignedInteger(MkvElem_DocTypeReadVersion, 2)
|
---|
| 366 | .subEnd(MkvElem_EBML);
|
---|
| 367 |
|
---|
| 368 | subStart(MkvElem_Segment);
|
---|
| 369 |
|
---|
| 370 | /* Save offset of current segment. */
|
---|
| 371 | CurSeg.offStart = RTFileTell(getFile());
|
---|
| 372 |
|
---|
[70622] | 373 | writeSeekHeader();
|
---|
[69684] | 374 |
|
---|
| 375 | /* Save offset of upcoming tracks segment. */
|
---|
| 376 | CurSeg.offTracks = RTFileTell(getFile());
|
---|
| 377 |
|
---|
| 378 | /* The tracks segment starts right after this header. */
|
---|
| 379 | subStart(MkvElem_Tracks);
|
---|
| 380 | m_fInTracksSection = true;
|
---|
| 381 |
|
---|
| 382 | return VINF_SUCCESS;
|
---|
| 383 | }
|
---|
| 384 |
|
---|
| 385 | /**
|
---|
| 386 | * Writes a simple block into the EBML structure.
|
---|
| 387 | *
|
---|
| 388 | * @returns IPRT status code.
|
---|
| 389 | * @param a_pTrack Track the simple block is assigned to.
|
---|
| 390 | * @param a_pBlock Simple block to write.
|
---|
| 391 | */
|
---|
| 392 | int WebMWriter::writeSimpleBlockEBML(WebMTrack *a_pTrack, WebMSimpleBlock *a_pBlock)
|
---|
| 393 | {
|
---|
| 394 | #ifdef LOG_ENABLED
|
---|
| 395 | WebMCluster &Cluster = CurSeg.CurCluster;
|
---|
| 396 |
|
---|
[70622] | 397 | Log3Func(("[T%RU8C%RU64] Off=%RU64, AbsPTSMs=%RU64, RelToClusterMs=%RU16, %zu bytes\n",
|
---|
[69684] | 398 | a_pTrack->uTrack, Cluster.uID, RTFileTell(getFile()),
|
---|
[70622] | 399 | a_pBlock->Data.tcAbsPTSMs, a_pBlock->Data.tcRelToClusterMs, a_pBlock->Data.cb));
|
---|
[69684] | 400 | #endif
|
---|
| 401 | /*
|
---|
| 402 | * Write a "Simple Block".
|
---|
| 403 | */
|
---|
| 404 | writeClassId(MkvElem_SimpleBlock);
|
---|
| 405 | /* Block size. */
|
---|
| 406 | writeUnsignedInteger(0x10000000u | ( 1 /* Track number size. */
|
---|
[70622] | 407 | + m_cbTimecode /* Timecode size .*/
|
---|
| 408 | + 1 /* Flags size. */
|
---|
| 409 | + a_pBlock->Data.cb /* Actual frame data size. */), 4);
|
---|
[69684] | 410 | /* Track number. */
|
---|
| 411 | writeSize(a_pTrack->uTrack);
|
---|
| 412 | /* Timecode (relative to cluster opening timecode). */
|
---|
| 413 | writeUnsignedInteger(a_pBlock->Data.tcRelToClusterMs, m_cbTimecode);
|
---|
| 414 | /* Flags. */
|
---|
| 415 | writeUnsignedInteger(a_pBlock->Data.fFlags, 1);
|
---|
| 416 | /* Frame data. */
|
---|
| 417 | write(a_pBlock->Data.pv, a_pBlock->Data.cb);
|
---|
| 418 |
|
---|
| 419 | return VINF_SUCCESS;
|
---|
| 420 | }
|
---|
| 421 |
|
---|
| 422 | /**
|
---|
| 423 | * Writes a simple block and enqueues it into the segment's render queue.
|
---|
| 424 | *
|
---|
| 425 | * @returns IPRT status code.
|
---|
| 426 | * @param a_pTrack Track the simple block is assigned to.
|
---|
| 427 | * @param a_pBlock Simple block to write and enqueue.
|
---|
| 428 | */
|
---|
| 429 | int WebMWriter::writeSimpleBlockQueued(WebMTrack *a_pTrack, WebMSimpleBlock *a_pBlock)
|
---|
| 430 | {
|
---|
| 431 | RT_NOREF(a_pTrack);
|
---|
| 432 |
|
---|
| 433 | int rc = VINF_SUCCESS;
|
---|
| 434 |
|
---|
| 435 | try
|
---|
| 436 | {
|
---|
[70622] | 437 | const WebMTimecodeAbs tcAbsPTS = a_pBlock->Data.tcAbsPTSMs;
|
---|
[69684] | 438 |
|
---|
| 439 | /* See if we already have an entry for the specified timecode in our queue. */
|
---|
[70622] | 440 | WebMBlockMap::iterator itQueue = CurSeg.queueBlocks.Map.find(tcAbsPTS);
|
---|
[69684] | 441 | if (itQueue != CurSeg.queueBlocks.Map.end()) /* Use existing queue. */
|
---|
| 442 | {
|
---|
| 443 | WebMTimecodeBlocks &Blocks = itQueue->second;
|
---|
| 444 | Blocks.Enqueue(a_pBlock);
|
---|
| 445 | }
|
---|
| 446 | else /* Create a new timecode entry. */
|
---|
| 447 | {
|
---|
| 448 | WebMTimecodeBlocks Blocks;
|
---|
| 449 | Blocks.Enqueue(a_pBlock);
|
---|
| 450 |
|
---|
[70622] | 451 | CurSeg.queueBlocks.Map[tcAbsPTS] = Blocks;
|
---|
[69684] | 452 | }
|
---|
| 453 |
|
---|
| 454 | processQueues(&CurSeg.queueBlocks, false /* fForce */);
|
---|
| 455 | }
|
---|
| 456 | catch(...)
|
---|
| 457 | {
|
---|
| 458 | delete a_pBlock;
|
---|
| 459 | a_pBlock = NULL;
|
---|
| 460 |
|
---|
| 461 | rc = VERR_NO_MEMORY;
|
---|
| 462 | }
|
---|
| 463 |
|
---|
| 464 | return rc;
|
---|
| 465 | }
|
---|
| 466 |
|
---|
| 467 | #ifdef VBOX_WITH_LIBVPX
|
---|
| 468 | /**
|
---|
| 469 | * Writes VPX (VP8 video) simple data block.
|
---|
| 470 | *
|
---|
| 471 | * @returns IPRT status code.
|
---|
| 472 | * @param a_pTrack Track ID to write data to.
|
---|
| 473 | * @param a_pCfg VPX encoder configuration to use.
|
---|
| 474 | * @param a_pPkt VPX packet video data packet to write.
|
---|
| 475 | */
|
---|
| 476 | int WebMWriter::writeSimpleBlockVP8(WebMTrack *a_pTrack, const vpx_codec_enc_cfg_t *a_pCfg, const vpx_codec_cx_pkt_t *a_pPkt)
|
---|
| 477 | {
|
---|
| 478 | RT_NOREF(a_pTrack);
|
---|
| 479 |
|
---|
[70622] | 480 | /* Calculate the absolute PTS of this frame (in ms). */
|
---|
| 481 | WebMTimecodeAbs tcAbsPTSMs = a_pPkt->data.frame.pts * 1000
|
---|
| 482 | * (uint64_t) a_pCfg->g_timebase.num / a_pCfg->g_timebase.den;
|
---|
| 483 | if ( tcAbsPTSMs
|
---|
| 484 | && tcAbsPTSMs <= a_pTrack->tcAbsLastWrittenMs)
|
---|
[69684] | 485 | {
|
---|
[70622] | 486 | tcAbsPTSMs = a_pTrack->tcAbsLastWrittenMs + 1;
|
---|
[69684] | 487 | }
|
---|
| 488 |
|
---|
| 489 | const bool fKeyframe = RT_BOOL(a_pPkt->data.frame.flags & VPX_FRAME_IS_KEY);
|
---|
| 490 |
|
---|
| 491 | uint8_t fFlags = VBOX_WEBM_BLOCK_FLAG_NONE;
|
---|
| 492 | if (fKeyframe)
|
---|
| 493 | fFlags |= VBOX_WEBM_BLOCK_FLAG_KEY_FRAME;
|
---|
| 494 | if (a_pPkt->data.frame.flags & VPX_FRAME_IS_INVISIBLE)
|
---|
| 495 | fFlags |= VBOX_WEBM_BLOCK_FLAG_INVISIBLE;
|
---|
| 496 |
|
---|
| 497 | return writeSimpleBlockQueued(a_pTrack,
|
---|
| 498 | new WebMSimpleBlock(a_pTrack,
|
---|
[70622] | 499 | tcAbsPTSMs, a_pPkt->data.frame.buf, a_pPkt->data.frame.sz, fFlags));
|
---|
[69684] | 500 | }
|
---|
| 501 | #endif /* VBOX_WITH_LIBVPX */
|
---|
| 502 |
|
---|
| 503 | #ifdef VBOX_WITH_LIBOPUS
|
---|
| 504 | /**
|
---|
| 505 | * Writes an Opus (audio) simple data block.
|
---|
| 506 | *
|
---|
| 507 | * @returns IPRT status code.
|
---|
| 508 | * @param a_pTrack Track ID to write data to.
|
---|
| 509 | * @param pvData Pointer to simple data block to write.
|
---|
| 510 | * @param cbData Size (in bytes) of simple data block to write.
|
---|
[70622] | 511 | * @param tcAbsPTSMs Absolute PTS of simple data block.
|
---|
[69684] | 512 | *
|
---|
| 513 | * @remarks Audio blocks that have same absolute timecode as video blocks SHOULD be written before the video blocks.
|
---|
| 514 | */
|
---|
[70622] | 515 | int WebMWriter::writeSimpleBlockOpus(WebMTrack *a_pTrack, const void *pvData, size_t cbData, WebMTimecodeAbs tcAbsPTSMs)
|
---|
[69684] | 516 | {
|
---|
| 517 | AssertPtrReturn(a_pTrack, VERR_INVALID_POINTER);
|
---|
| 518 | AssertPtrReturn(pvData, VERR_INVALID_POINTER);
|
---|
| 519 | AssertReturn(cbData, VERR_INVALID_PARAMETER);
|
---|
| 520 |
|
---|
| 521 | /* Every Opus frame is a key frame. */
|
---|
| 522 | const uint8_t fFlags = VBOX_WEBM_BLOCK_FLAG_KEY_FRAME;
|
---|
| 523 |
|
---|
| 524 | return writeSimpleBlockQueued(a_pTrack,
|
---|
[70622] | 525 | new WebMSimpleBlock(a_pTrack, tcAbsPTSMs, pvData, cbData, fFlags));
|
---|
[69684] | 526 | }
|
---|
| 527 | #endif /* VBOX_WITH_LIBOPUS */
|
---|
| 528 |
|
---|
| 529 | /**
|
---|
| 530 | * Writes a data block to the specified track.
|
---|
| 531 | *
|
---|
| 532 | * @returns IPRT status code.
|
---|
| 533 | * @param uTrack Track ID to write data to.
|
---|
| 534 | * @param pvData Pointer to data block to write.
|
---|
| 535 | * @param cbData Size (in bytes) of data block to write.
|
---|
| 536 | */
|
---|
| 537 | int WebMWriter::WriteBlock(uint8_t uTrack, const void *pvData, size_t cbData)
|
---|
| 538 | {
|
---|
| 539 | RT_NOREF(cbData); /* Only needed for assertions for now. */
|
---|
| 540 |
|
---|
| 541 | int rc = RTCritSectEnter(&CurSeg.CritSect);
|
---|
| 542 | AssertRC(rc);
|
---|
| 543 |
|
---|
| 544 | WebMTracks::iterator itTrack = CurSeg.mapTracks.find(uTrack);
|
---|
| 545 | if (itTrack == CurSeg.mapTracks.end())
|
---|
| 546 | {
|
---|
| 547 | RTCritSectLeave(&CurSeg.CritSect);
|
---|
| 548 | return VERR_NOT_FOUND;
|
---|
| 549 | }
|
---|
| 550 |
|
---|
| 551 | WebMTrack *pTrack = itTrack->second;
|
---|
| 552 | AssertPtr(pTrack);
|
---|
| 553 |
|
---|
| 554 | if (m_fInTracksSection)
|
---|
| 555 | {
|
---|
| 556 | subEnd(MkvElem_Tracks);
|
---|
| 557 | m_fInTracksSection = false;
|
---|
| 558 | }
|
---|
| 559 |
|
---|
| 560 | switch (pTrack->enmType)
|
---|
| 561 | {
|
---|
| 562 |
|
---|
| 563 | case WebMTrackType_Audio:
|
---|
| 564 | {
|
---|
| 565 | #ifdef VBOX_WITH_LIBOPUS
|
---|
| 566 | if (m_enmAudioCodec == WebMWriter::AudioCodec_Opus)
|
---|
| 567 | {
|
---|
| 568 | Assert(cbData == sizeof(WebMWriter::BlockData_Opus));
|
---|
| 569 | WebMWriter::BlockData_Opus *pData = (WebMWriter::BlockData_Opus *)pvData;
|
---|
| 570 | rc = writeSimpleBlockOpus(pTrack, pData->pvData, pData->cbData, pData->uPTSMs);
|
---|
| 571 | }
|
---|
| 572 | else
|
---|
| 573 | #endif /* VBOX_WITH_LIBOPUS */
|
---|
| 574 | rc = VERR_NOT_SUPPORTED;
|
---|
| 575 | break;
|
---|
| 576 | }
|
---|
| 577 |
|
---|
| 578 | case WebMTrackType_Video:
|
---|
| 579 | {
|
---|
| 580 | #ifdef VBOX_WITH_LIBVPX
|
---|
| 581 | if (m_enmVideoCodec == WebMWriter::VideoCodec_VP8)
|
---|
| 582 | {
|
---|
| 583 | Assert(cbData == sizeof(WebMWriter::BlockData_VP8));
|
---|
| 584 | WebMWriter::BlockData_VP8 *pData = (WebMWriter::BlockData_VP8 *)pvData;
|
---|
| 585 | rc = writeSimpleBlockVP8(pTrack, pData->pCfg, pData->pPkt);
|
---|
| 586 | }
|
---|
| 587 | else
|
---|
| 588 | #endif /* VBOX_WITH_LIBVPX */
|
---|
| 589 | rc = VERR_NOT_SUPPORTED;
|
---|
| 590 | break;
|
---|
| 591 | }
|
---|
| 592 |
|
---|
| 593 | default:
|
---|
| 594 | rc = VERR_NOT_SUPPORTED;
|
---|
| 595 | break;
|
---|
| 596 | }
|
---|
| 597 |
|
---|
| 598 | int rc2 = RTCritSectLeave(&CurSeg.CritSect);
|
---|
| 599 | AssertRC(rc2);
|
---|
| 600 |
|
---|
| 601 | return rc;
|
---|
| 602 | }
|
---|
| 603 |
|
---|
| 604 | /**
|
---|
| 605 | * Processes a render queue.
|
---|
| 606 | *
|
---|
| 607 | * @returns IPRT status code.
|
---|
| 608 | * @param pQueue Queue to process.
|
---|
| 609 | * @param fForce Whether forcing to process the render queue or not.
|
---|
| 610 | * Needed to drain the queues when terminating.
|
---|
| 611 | */
|
---|
| 612 | int WebMWriter::processQueues(WebMQueue *pQueue, bool fForce)
|
---|
| 613 | {
|
---|
[70622] | 614 | if (pQueue->tsLastProcessedMs == 0)
|
---|
| 615 | pQueue->tsLastProcessedMs = RTTimeMilliTS();
|
---|
[69684] | 616 |
|
---|
| 617 | if (!fForce)
|
---|
| 618 | {
|
---|
| 619 | /* Only process when we reached a certain threshold. */
|
---|
[70622] | 620 | if (RTTimeMilliTS() - pQueue->tsLastProcessedMs < 5000 /* ms */ /** @todo Make this configurable */)
|
---|
[69684] | 621 | return VINF_SUCCESS;
|
---|
| 622 | }
|
---|
| 623 |
|
---|
| 624 | WebMCluster &Cluster = CurSeg.CurCluster;
|
---|
| 625 |
|
---|
| 626 | /* Iterate through the block map. */
|
---|
| 627 | WebMBlockMap::iterator it = pQueue->Map.begin();
|
---|
| 628 | while (it != CurSeg.queueBlocks.Map.end())
|
---|
| 629 | {
|
---|
[70622] | 630 | WebMTimecodeAbs mapAbsPTSMs = it->first;
|
---|
| 631 | WebMTimecodeBlocks mapBlocks = it->second;
|
---|
[69684] | 632 |
|
---|
| 633 | /* Whether to start a new cluster or not. */
|
---|
| 634 | bool fClusterStart = false;
|
---|
| 635 |
|
---|
| 636 | /* No blocks written yet? Start a new cluster. */
|
---|
| 637 | if (Cluster.cBlocks == 0)
|
---|
| 638 | fClusterStart = true;
|
---|
| 639 |
|
---|
| 640 | /* Did we reach the maximum a cluster can hold? Use a new cluster then. */
|
---|
[70622] | 641 | if (mapAbsPTSMs - Cluster.tcAbsStartMs > VBOX_WEBM_CLUSTER_MAX_LEN_MS)
|
---|
[69684] | 642 | fClusterStart = true;
|
---|
| 643 |
|
---|
| 644 | /* If the block map indicates that a cluster is needed for this timecode, create one. */
|
---|
| 645 | if (mapBlocks.fClusterNeeded)
|
---|
| 646 | fClusterStart = true;
|
---|
| 647 |
|
---|
| 648 | if ( fClusterStart
|
---|
| 649 | && !mapBlocks.fClusterStarted)
|
---|
| 650 | {
|
---|
| 651 | if (Cluster.fOpen) /* Close current cluster first. */
|
---|
| 652 | {
|
---|
| 653 | /* Make sure that the current cluster contained some data. */
|
---|
| 654 | Assert(Cluster.offStart);
|
---|
| 655 | Assert(Cluster.cBlocks);
|
---|
| 656 |
|
---|
| 657 | subEnd(MkvElem_Cluster);
|
---|
| 658 | Cluster.fOpen = false;
|
---|
| 659 | }
|
---|
| 660 |
|
---|
[70622] | 661 | Cluster.fOpen = true;
|
---|
| 662 | Cluster.uID = CurSeg.cClusters;
|
---|
| 663 | Cluster.tcAbsStartMs = mapAbsPTSMs;
|
---|
| 664 | Cluster.offStart = RTFileTell(getFile());
|
---|
| 665 | Cluster.cBlocks = 0;
|
---|
[69684] | 666 |
|
---|
[70622] | 667 | Log2Func(("[C%RU64] Start @ %RU64ms (map TC is %RU64) / %RU64 bytes\n",
|
---|
| 668 | Cluster.uID, Cluster.tcAbsStartMs, mapAbsPTSMs, Cluster.offStart));
|
---|
| 669 |
|
---|
[69684] | 670 | if (CurSeg.cClusters)
|
---|
[70622] | 671 | AssertMsg(Cluster.tcAbsStartMs, ("[C%RU64] @ %RU64 starting timecode is 0 which is invalid\n",
|
---|
| 672 | Cluster.uID, Cluster.offStart));
|
---|
[69684] | 673 |
|
---|
[70623] | 674 | WebMTracks::iterator itTrack = CurSeg.mapTracks.begin();
|
---|
| 675 | while (itTrack != CurSeg.mapTracks.end())
|
---|
| 676 | {
|
---|
| 677 | /* Insert cue points for all tracks if a new cluster has been started. */
|
---|
| 678 | WebMCuePoint cue(itTrack->second /* pTrack */, Cluster.offStart, Cluster.tcAbsStartMs);
|
---|
| 679 | CurSeg.lstCues.push_back(cue);
|
---|
[69684] | 680 |
|
---|
[70623] | 681 | ++itTrack;
|
---|
| 682 | }
|
---|
| 683 |
|
---|
[69684] | 684 | subStart(MkvElem_Cluster)
|
---|
[70622] | 685 | .serializeUnsignedInteger(MkvElem_Timecode, Cluster.tcAbsStartMs);
|
---|
[69684] | 686 |
|
---|
| 687 | CurSeg.cClusters++;
|
---|
| 688 |
|
---|
| 689 | mapBlocks.fClusterStarted = true;
|
---|
| 690 | }
|
---|
| 691 |
|
---|
| 692 | /* Iterate through all blocks related to the current timecode. */
|
---|
| 693 | while (!mapBlocks.Queue.empty())
|
---|
| 694 | {
|
---|
| 695 | WebMSimpleBlock *pBlock = mapBlocks.Queue.front();
|
---|
| 696 | AssertPtr(pBlock);
|
---|
| 697 |
|
---|
| 698 | WebMTrack *pTrack = pBlock->pTrack;
|
---|
| 699 | AssertPtr(pTrack);
|
---|
| 700 |
|
---|
| 701 | /* Calculate the block's relative time code to the current cluster's starting time code. */
|
---|
[70622] | 702 | Assert(pBlock->Data.tcAbsPTSMs >= Cluster.tcAbsStartMs);
|
---|
| 703 | pBlock->Data.tcRelToClusterMs = pBlock->Data.tcAbsPTSMs - Cluster.tcAbsStartMs;
|
---|
[69684] | 704 |
|
---|
| 705 | int rc2 = writeSimpleBlockEBML(pTrack, pBlock);
|
---|
| 706 | AssertRC(rc2);
|
---|
| 707 |
|
---|
| 708 | Cluster.cBlocks++;
|
---|
| 709 |
|
---|
| 710 | pTrack->cTotalBlocks++;
|
---|
[70622] | 711 | pTrack->tcAbsLastWrittenMs = pBlock->Data.tcAbsPTSMs;
|
---|
[69684] | 712 |
|
---|
[70622] | 713 | if (CurSeg.tcAbsLastWrittenMs < pTrack->tcAbsLastWrittenMs)
|
---|
| 714 | CurSeg.tcAbsLastWrittenMs = pTrack->tcAbsLastWrittenMs;
|
---|
[69684] | 715 |
|
---|
[70623] | 716 | /* Save a cue point if this is a keyframe (if no new cluster has been started,
|
---|
| 717 | * as this implies that a cue point already is present. */
|
---|
| 718 | if ( !fClusterStart
|
---|
| 719 | && (pBlock->Data.fFlags & VBOX_WEBM_BLOCK_FLAG_KEY_FRAME))
|
---|
[69684] | 720 | {
|
---|
[70622] | 721 | WebMCuePoint cue(pBlock->pTrack, Cluster.offStart, Cluster.tcAbsStartMs);
|
---|
[69684] | 722 | CurSeg.lstCues.push_back(cue);
|
---|
| 723 | }
|
---|
| 724 |
|
---|
| 725 | delete pBlock;
|
---|
| 726 | pBlock = NULL;
|
---|
| 727 |
|
---|
| 728 | mapBlocks.Queue.pop();
|
---|
| 729 | }
|
---|
| 730 |
|
---|
| 731 | Assert(mapBlocks.Queue.empty());
|
---|
| 732 |
|
---|
| 733 | CurSeg.queueBlocks.Map.erase(it);
|
---|
| 734 |
|
---|
| 735 | it = CurSeg.queueBlocks.Map.begin();
|
---|
| 736 | }
|
---|
| 737 |
|
---|
| 738 | Assert(CurSeg.queueBlocks.Map.empty());
|
---|
| 739 |
|
---|
[70622] | 740 | pQueue->tsLastProcessedMs = RTTimeMilliTS();
|
---|
[69684] | 741 |
|
---|
| 742 | return VINF_SUCCESS;
|
---|
| 743 | }
|
---|
| 744 |
|
---|
| 745 | /**
|
---|
| 746 | * Writes the WebM footer.
|
---|
| 747 | *
|
---|
| 748 | * @returns IPRT status code.
|
---|
| 749 | */
|
---|
| 750 | int WebMWriter::writeFooter(void)
|
---|
| 751 | {
|
---|
| 752 | AssertReturn(isOpen(), VERR_WRONG_ORDER);
|
---|
| 753 |
|
---|
| 754 | if (m_fInTracksSection)
|
---|
| 755 | {
|
---|
| 756 | subEnd(MkvElem_Tracks);
|
---|
| 757 | m_fInTracksSection = false;
|
---|
| 758 | }
|
---|
| 759 |
|
---|
| 760 | if (CurSeg.CurCluster.fOpen)
|
---|
| 761 | {
|
---|
| 762 | subEnd(MkvElem_Cluster);
|
---|
| 763 | CurSeg.CurCluster.fOpen = false;
|
---|
| 764 | }
|
---|
| 765 |
|
---|
| 766 | /*
|
---|
| 767 | * Write Cues element.
|
---|
| 768 | */
|
---|
| 769 | CurSeg.offCues = RTFileTell(getFile());
|
---|
[70622] | 770 | LogFunc(("Cues @ %RU64\n", CurSeg.offCues));
|
---|
[69684] | 771 |
|
---|
| 772 | subStart(MkvElem_Cues);
|
---|
| 773 |
|
---|
| 774 | std::list<WebMCuePoint>::iterator itCuePoint = CurSeg.lstCues.begin();
|
---|
| 775 | while (itCuePoint != CurSeg.lstCues.end())
|
---|
| 776 | {
|
---|
| 777 | /* Sanity. */
|
---|
| 778 | AssertPtr(itCuePoint->pTrack);
|
---|
| 779 |
|
---|
[70622] | 780 | LogFunc(("CuePoint @ %RU64: Track #%RU8 (Cluster @ %RU64, tcAbs=%RU64)\n",
|
---|
[69684] | 781 | RTFileTell(getFile()), itCuePoint->pTrack->uTrack,
|
---|
| 782 | itCuePoint->offCluster, itCuePoint->tcAbs));
|
---|
| 783 |
|
---|
| 784 | subStart(MkvElem_CuePoint)
|
---|
[70622] | 785 | .serializeUnsignedInteger(MkvElem_CueTime, itCuePoint->tcAbs)
|
---|
| 786 | .subStart(MkvElem_CueTrackPositions)
|
---|
| 787 | .serializeUnsignedInteger(MkvElem_CueTrack, itCuePoint->pTrack->uTrack)
|
---|
| 788 | .serializeUnsignedInteger(MkvElem_CueClusterPosition, itCuePoint->offCluster - CurSeg.offStart, 8)
|
---|
| 789 | .subEnd(MkvElem_CueTrackPositions)
|
---|
| 790 | .subEnd(MkvElem_CuePoint);
|
---|
[69684] | 791 |
|
---|
| 792 | itCuePoint++;
|
---|
| 793 | }
|
---|
| 794 |
|
---|
| 795 | subEnd(MkvElem_Cues);
|
---|
| 796 | subEnd(MkvElem_Segment);
|
---|
| 797 |
|
---|
| 798 | /*
|
---|
[70622] | 799 | * Re-Update seek header with final information.
|
---|
[69684] | 800 | */
|
---|
| 801 |
|
---|
[70622] | 802 | writeSeekHeader();
|
---|
[69684] | 803 |
|
---|
| 804 | return RTFileSeek(getFile(), 0, RTFILE_SEEK_END, NULL);
|
---|
| 805 | }
|
---|
| 806 |
|
---|
| 807 | /**
|
---|
[70622] | 808 | * Writes the segment's seek header.
|
---|
[69684] | 809 | */
|
---|
[70622] | 810 | void WebMWriter::writeSeekHeader(void)
|
---|
[69684] | 811 | {
|
---|
| 812 | if (CurSeg.offSeekInfo)
|
---|
| 813 | RTFileSeek(getFile(), CurSeg.offSeekInfo, RTFILE_SEEK_BEGIN, NULL);
|
---|
| 814 | else
|
---|
| 815 | CurSeg.offSeekInfo = RTFileTell(getFile());
|
---|
| 816 |
|
---|
[70622] | 817 | LogFunc(("Seek Headeder @ %RU64\n", CurSeg.offSeekInfo));
|
---|
[69684] | 818 |
|
---|
| 819 | subStart(MkvElem_SeekHead);
|
---|
| 820 |
|
---|
| 821 | subStart(MkvElem_Seek)
|
---|
| 822 | .serializeUnsignedInteger(MkvElem_SeekID, MkvElem_Tracks)
|
---|
| 823 | .serializeUnsignedInteger(MkvElem_SeekPosition, CurSeg.offTracks - CurSeg.offStart, 8)
|
---|
| 824 | .subEnd(MkvElem_Seek);
|
---|
| 825 |
|
---|
[70622] | 826 | if (CurSeg.offCues)
|
---|
| 827 | LogFunc(("Updating Cues @ %RU64\n", CurSeg.offCues));
|
---|
[69684] | 828 |
|
---|
| 829 | subStart(MkvElem_Seek)
|
---|
| 830 | .serializeUnsignedInteger(MkvElem_SeekID, MkvElem_Cues)
|
---|
| 831 | .serializeUnsignedInteger(MkvElem_SeekPosition, CurSeg.offCues - CurSeg.offStart, 8)
|
---|
| 832 | .subEnd(MkvElem_Seek);
|
---|
| 833 |
|
---|
| 834 | subStart(MkvElem_Seek)
|
---|
| 835 | .serializeUnsignedInteger(MkvElem_SeekID, MkvElem_Info)
|
---|
| 836 | .serializeUnsignedInteger(MkvElem_SeekPosition, CurSeg.offInfo - CurSeg.offStart, 8)
|
---|
| 837 | .subEnd(MkvElem_Seek);
|
---|
| 838 |
|
---|
| 839 | subEnd(MkvElem_SeekHead);
|
---|
| 840 |
|
---|
[70622] | 841 | /*
|
---|
| 842 | * Write the segment's info element.
|
---|
| 843 | */
|
---|
| 844 |
|
---|
| 845 | /* Save offset of the segment's info element. */
|
---|
[69684] | 846 | CurSeg.offInfo = RTFileTell(getFile());
|
---|
| 847 |
|
---|
| 848 | LogFunc(("Info @ %RU64\n", CurSeg.offInfo));
|
---|
| 849 |
|
---|
| 850 | char szMux[64];
|
---|
| 851 | RTStrPrintf(szMux, sizeof(szMux),
|
---|
| 852 | #ifdef VBOX_WITH_LIBVPX
|
---|
| 853 | "vpxenc%s", vpx_codec_version_str());
|
---|
| 854 | #else
|
---|
| 855 | "unknown");
|
---|
| 856 | #endif
|
---|
| 857 | char szApp[64];
|
---|
| 858 | RTStrPrintf(szApp, sizeof(szApp), VBOX_PRODUCT " %sr%u", VBOX_VERSION_STRING, RTBldCfgRevision());
|
---|
| 859 |
|
---|
[70622] | 860 | const WebMTimecodeAbs tcAbsDurationMs = CurSeg.tcAbsLastWrittenMs - CurSeg.tcAbsStartMs;
|
---|
[69684] | 861 |
|
---|
| 862 | if (!CurSeg.lstCues.empty())
|
---|
| 863 | {
|
---|
[70622] | 864 | LogFunc(("tcAbsDurationMs=%RU64\n", tcAbsDurationMs));
|
---|
| 865 | AssertMsg(tcAbsDurationMs, ("Segment seems to be empty (duration is 0)\n"));
|
---|
[69684] | 866 | }
|
---|
| 867 |
|
---|
| 868 | subStart(MkvElem_Info)
|
---|
[70622] | 869 | .serializeUnsignedInteger(MkvElem_TimecodeScale, CurSeg.uTimecodeScaleFactor)
|
---|
| 870 | .serializeFloat(MkvElem_Segment_Duration, tcAbsDurationMs)
|
---|
| 871 | .serializeString(MkvElem_MuxingApp, szMux)
|
---|
| 872 | .serializeString(MkvElem_WritingApp, szApp)
|
---|
| 873 | .subEnd(MkvElem_Info);
|
---|
[69684] | 874 | }
|
---|
| 875 |
|
---|