WebMWriter.cpp@ 71139

Last change on this file since 71139 was 70623, checked in by vboxsync, 7 years ago
VideoRec/WebMWriter: Fixes required for some players (e.g latest Firefox).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 26.3 KB

Line
1	/* $Id: WebMWriter.cpp 70623 2018-01-18 10:05:23Z vboxsync $ */
2	/** @file
3	* WebMWriter.cpp - WebM container handling.
4	*/
5
6	/*
7	* Copyright (C) 2013-2018 Oracle Corporation
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	{
61	Close();
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	{
139	LogFlowFuncEnter();
140
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
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;
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.
257	* @param uFPS FPS (Frames Per Second) of the video track.
258	* @param puTrack Track number of the added video track on success. Optional.
259	*/
260	int WebMWriter::AddVideoTrack(uint16_t uWidth, uint16_t uHeight, uint32_t uFPS, uint8_t *puTrack)
261	{
262	#ifdef VBOX_WITH_LIBVPX
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;
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)
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)
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
373	writeSeekHeader();
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
397	Log3Func(("[T%RU8C%RU64] Off=%RU64, AbsPTSMs=%RU64, RelToClusterMs=%RU16, %zu bytes\n",
398	a_pTrack->uTrack, Cluster.uID, RTFileTell(getFile()),
399	a_pBlock->Data.tcAbsPTSMs, a_pBlock->Data.tcRelToClusterMs, a_pBlock->Data.cb));
400	#endif
401	/*
402	* Write a "Simple Block".
403	*/
404	writeClassId(MkvElem_SimpleBlock);
405	/* Block size. */
406	writeUnsignedInteger(0x10000000u \| ( 1 /* Track number size. */
407	+ m_cbTimecode /* Timecode size .*/
408	+ 1 /* Flags size. */
409	+ a_pBlock->Data.cb /* Actual frame data size. */), 4);
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	{
437	const WebMTimecodeAbs tcAbsPTS = a_pBlock->Data.tcAbsPTSMs;
438
439	/* See if we already have an entry for the specified timecode in our queue. */
440	WebMBlockMap::iterator itQueue = CurSeg.queueBlocks.Map.find(tcAbsPTS);
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
451	CurSeg.queueBlocks.Map[tcAbsPTS] = Blocks;
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
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)
485	{
486	tcAbsPTSMs = a_pTrack->tcAbsLastWrittenMs + 1;
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,
499	tcAbsPTSMs, a_pPkt->data.frame.buf, a_pPkt->data.frame.sz, fFlags));
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.
511	* @param tcAbsPTSMs Absolute PTS of simple data block.
512	*
513	* @remarks Audio blocks that have same absolute timecode as video blocks SHOULD be written before the video blocks.
514	*/
515	int WebMWriter::writeSimpleBlockOpus(WebMTrack a_pTrack, const void pvData, size_t cbData, WebMTimecodeAbs tcAbsPTSMs)
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,
525	new WebMSimpleBlock(a_pTrack, tcAbsPTSMs, pvData, cbData, fFlags));
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	{
614	if (pQueue->tsLastProcessedMs == 0)
615	pQueue->tsLastProcessedMs = RTTimeMilliTS();
616
617	if (!fForce)
618	{
619	/* Only process when we reached a certain threshold. */
620	if (RTTimeMilliTS() - pQueue->tsLastProcessedMs < 5000 /* ms / /* @todo Make this configurable */)
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	{
630	WebMTimecodeAbs mapAbsPTSMs = it->first;
631	WebMTimecodeBlocks mapBlocks = it->second;
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. */
641	if (mapAbsPTSMs - Cluster.tcAbsStartMs > VBOX_WEBM_CLUSTER_MAX_LEN_MS)
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
661	Cluster.fOpen = true;
662	Cluster.uID = CurSeg.cClusters;
663	Cluster.tcAbsStartMs = mapAbsPTSMs;
664	Cluster.offStart = RTFileTell(getFile());
665	Cluster.cBlocks = 0;
666
667	Log2Func(("[C%RU64] Start @ %RU64ms (map TC is %RU64) / %RU64 bytes\n",
668	Cluster.uID, Cluster.tcAbsStartMs, mapAbsPTSMs, Cluster.offStart));
669
670	if (CurSeg.cClusters)
671	AssertMsg(Cluster.tcAbsStartMs, ("[C%RU64] @ %RU64 starting timecode is 0 which is invalid\n",
672	Cluster.uID, Cluster.offStart));
673
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);
680
681	++itTrack;
682	}
683
684	subStart(MkvElem_Cluster)
685	.serializeUnsignedInteger(MkvElem_Timecode, Cluster.tcAbsStartMs);
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. */
702	Assert(pBlock->Data.tcAbsPTSMs >= Cluster.tcAbsStartMs);
703	pBlock->Data.tcRelToClusterMs = pBlock->Data.tcAbsPTSMs - Cluster.tcAbsStartMs;
704
705	int rc2 = writeSimpleBlockEBML(pTrack, pBlock);
706	AssertRC(rc2);
707
708	Cluster.cBlocks++;
709
710	pTrack->cTotalBlocks++;
711	pTrack->tcAbsLastWrittenMs = pBlock->Data.tcAbsPTSMs;
712
713	if (CurSeg.tcAbsLastWrittenMs < pTrack->tcAbsLastWrittenMs)
714	CurSeg.tcAbsLastWrittenMs = pTrack->tcAbsLastWrittenMs;
715
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))
720	{
721	WebMCuePoint cue(pBlock->pTrack, Cluster.offStart, Cluster.tcAbsStartMs);
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
740	pQueue->tsLastProcessedMs = RTTimeMilliTS();
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());
770	LogFunc(("Cues @ %RU64\n", CurSeg.offCues));
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
780	LogFunc(("CuePoint @ %RU64: Track #%RU8 (Cluster @ %RU64, tcAbs=%RU64)\n",
781	RTFileTell(getFile()), itCuePoint->pTrack->uTrack,
782	itCuePoint->offCluster, itCuePoint->tcAbs));
783
784	subStart(MkvElem_CuePoint)
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);
791
792	itCuePoint++;
793	}
794
795	subEnd(MkvElem_Cues);
796	subEnd(MkvElem_Segment);
797
798	/*
799	* Re-Update seek header with final information.
800	*/
801
802	writeSeekHeader();
803
804	return RTFileSeek(getFile(), 0, RTFILE_SEEK_END, NULL);
805	}
806
807	/**
808	* Writes the segment's seek header.
809	*/
810	void WebMWriter::writeSeekHeader(void)
811	{
812	if (CurSeg.offSeekInfo)
813	RTFileSeek(getFile(), CurSeg.offSeekInfo, RTFILE_SEEK_BEGIN, NULL);
814	else
815	CurSeg.offSeekInfo = RTFileTell(getFile());
816
817	LogFunc(("Seek Headeder @ %RU64\n", CurSeg.offSeekInfo));
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
826	if (CurSeg.offCues)
827	LogFunc(("Updating Cues @ %RU64\n", CurSeg.offCues));
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
841	/*
842	* Write the segment's info element.
843	*/
844
845	/* Save offset of the segment's info element. */
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
860	const WebMTimecodeAbs tcAbsDurationMs = CurSeg.tcAbsLastWrittenMs - CurSeg.tcAbsStartMs;
861
862	if (!CurSeg.lstCues.empty())
863	{
864	LogFunc(("tcAbsDurationMs=%RU64\n", tcAbsDurationMs));
865	AssertMsg(tcAbsDurationMs, ("Segment seems to be empty (duration is 0)\n"));
866	}
867
868	subStart(MkvElem_Info)
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);
874	}
875

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Main/src-client/WebMWriter.cpp@ 71139

Download in other formats: