WebMWriter.cpp@ 74781

Last change on this file since 74781 was 74781, checked in by vboxsync, 6 years ago
VideoRec/Main: Fixed a crash in WebMWriter::Close().
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 26.4 KB

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

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

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

Download in other formats: