CUE.cpp@ 99749

Last change on this file since 99749 was 99739, checked in by vboxsync, 19 months ago
*: doxygen corrections (mostly about removing @returns from functions returning void).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 65.2 KB

Line
1	/* $Id: CUE.cpp 99739 2023-05-11 01:01:08Z vboxsync $ */
2	/** @file
3	* CUE - CUE/BIN Disk image, Core Code.
4	*/
5
6	/*
7	* Copyright (C) 2017-2023 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* SPDX-License-Identifier: GPL-3.0-only
26	*/
27
28
29	/*********************************************************************************************************************************
30	* Header Files *
31	*********************************************************************************************************************************/
32	#define LOG_GROUP LOG_GROUP_VD_CUE
33	#include <VBox/vd-plugin.h>
34	#include <VBox/err.h>
35
36	#include <VBox/log.h>
37	#include <VBox/scsiinline.h>
38	#include <iprt/assert.h>
39	#include <iprt/asm.h>
40	#include <iprt/alloc.h>
41	#include <iprt/cdefs.h>
42	#include <iprt/ctype.h>
43	#include <iprt/path.h>
44	#include <iprt/string.h>
45
46	#include "VDBackends.h"
47	#include "VDBackendsInline.h"
48
49
50	/*********************************************************************************************************************************
51	* Constants And Macros, Structures and Typedefs *
52	*********************************************************************************************************************************/
53
54	/**
55	* CUE descriptor file token type.
56	*/
57	typedef enum CUETOKENTYPE
58	{
59	/** Invalid token type. */
60	CUETOKENTYPE_INVALID = 0,
61	/** Reserved keyword. */
62	CUETOKENTYPE_KEYWORD,
63	/** String token. */
64	CUETOKENTYPE_STRING,
65	/** Unsigned integer. */
66	CUETOKENTYPE_INTEGER_UNSIGNED,
67	/** MSF (mm:ss:ff) location token. */
68	CUETOKENTYPE_MSF,
69	/** Error token (unexpected character found). */
70	CUETOKENTYPE_ERROR,
71	/** End of stream token. */
72	CUETOKENTYPE_EOS
73	} CUETOKENTYPE;
74
75	/**
76	* CUE reservered keyword type.
77	*/
78	typedef enum CUEKEYWORD
79	{
80	/** Invalid keyword. */
81	CUEKEYWORD_INVALID = 0,
82	/** FILE. */
83	CUEKEYWORD_FILE,
84	/** BINARY */
85	CUEKEYWORD_BINARY,
86	/** MOTOROLA */
87	CUEKEYWORD_MOTOROLA,
88	/** WAVE */
89	CUEKEYWORD_WAVE,
90	/** MP3 */
91	CUEKEYWORD_MP3,
92	/** AIFF */
93	CUEKEYWORD_AIFF,
94	/** CATALOG */
95	CUEKEYWORD_CATALOG,
96	CUEKEYWORD_CDTEXTFILE,
97	CUEKEYWORD_FLAGS,
98	CUEKEYWORD_INDEX,
99	CUEKEYWORD_ISRC,
100	CUEKEYWORD_PERFORMER,
101	CUEKEYWORD_POSTGAP,
102	CUEKEYWORD_PREGAP,
103	CUEKEYWORD_SONGWRITER,
104	CUEKEYWORD_TITLE,
105	CUEKEYWORD_TRACK,
106	CUEKEYWORD_MODE1_2048,
107	CUEKEYWORD_MODE1_2352,
108	CUEKEYWORD_MODE2_2352,
109	CUEKEYWORD_AUDIO,
110	CUEKEYWORD_REM
111	} CUEKEYWORD;
112
113	/**
114	* CUE sheet token.
115	*/
116	typedef struct CUETOKEN
117	{
118	/** The token type. */
119	CUETOKENTYPE enmType;
120	/** Token type dependent data. */
121	union
122	{
123	/** Keyword token. */
124	struct
125	{
126	/** The keyword enumerator. */
127	CUEKEYWORD enmKeyword;
128	} Keyword;
129	/** String token (without quotation marks). */
130	struct
131	{
132	/** Pointer to the start of the string. */
133	const char *psz;
134	/** Number of characters for the string excluding the null terminator. */
135	size_t cch;
136	} String;
137	/** Integer token. */
138	struct
139	{
140	/** Numerical constant. */
141	uint64_t u64;
142	} Int;
143	/** MSF location token. */
144	struct
145	{
146	/** Minute part. */
147	uint8_t u8Minute;
148	/** Second part. */
149	uint8_t u8Second;
150	/** Frame part. */
151	uint8_t u8Frame;
152	} Msf;
153	} Type;
154	} CUETOKEN;
155	/** Pointer to a CUE sheet token. */
156	typedef CUETOKEN *PCUETOKEN;
157	/** Pointer to a const CUE sheet token. */
158	typedef const CUETOKEN *PCCUETOKEN;
159
160	/**
161	* CUE tokenizer state.
162	*/
163	typedef struct CUETOKENIZER
164	{
165	/** Char buffer to read from. */
166	const char *pszInput;
167	/** Token 1. */
168	CUETOKEN Token1;
169	/** Token 2. */
170	CUETOKEN Token2;
171	/** Pointer to the current active token. */
172	PCUETOKEN pTokenCurr;
173	/** The next token in the input stream (used for peeking). */
174	PCUETOKEN pTokenNext;
175	} CUETOKENIZER;
176	/** Pointer to a CUE tokenizer state. */
177	typedef CUETOKENIZER *PCUETOKENIZER;
178
179	/**
180	* CUE keyword entry.
181	*/
182	typedef struct CUEKEYWORDDESC
183	{
184	/** Keyword string. */
185	const char *pszKeyword;
186	/** Size of the string in characters without zero terminator. */
187	size_t cchKeyword;
188	/** Keyword type. */
189	CUEKEYWORD enmKeyword;
190	} CUEKEYWORDDESC;
191	/** Pointer to a CUE keyword entry. */
192	typedef CUEKEYWORDDESC *PCUEKEYWORDDESC;
193	/** Pointer to a const CUE keyword entry. */
194	typedef const CUEKEYWORDDESC *PCCUEKEYWORDDESC;
195
196	/**
197	* CUE image data structure.
198	*/
199	typedef struct CUEIMAGE
200	{
201	/** Image name. */
202	const char *pszFilename;
203	/** Storage handle. */
204	PVDIOSTORAGE pStorage;
205	/** The backing file containing the actual data. */
206	char *pszDataFilename;
207	/** Storage handle for the backing file. */
208	PVDIOSTORAGE pStorageData;
209
210	/** Pointer to the per-disk VD interface list. */
211	PVDINTERFACE pVDIfsDisk;
212	/** Pointer to the per-image VD interface list. */
213	PVDINTERFACE pVDIfsImage;
214	/** Error interface. */
215	PVDINTERFACEERROR pIfError;
216	/** I/O interface. */
217	PVDINTERFACEIOINT pIfIo;
218
219	/** Open flags passed by VD layer. */
220	unsigned uOpenFlags;
221	/** Image flags defined during creation or determined during open. */
222	unsigned uImageFlags;
223	/** Maximum number of tracks the region list can hold. */
224	uint32_t cTracksMax;
225	/** Pointer to our internal region list. */
226	PVDREGIONLIST pRegionList;
227	/** Flag whether the backing file is little (BINARY) or big (MOTOROLA) endian. */
228	bool fLittleEndian;
229	} CUEIMAGE, *PCUEIMAGE;
230
231
232	/*********************************************************************************************************************************
233	* Static Variables *
234	*********************************************************************************************************************************/
235
236	/** NULL-terminated array of supported file extensions. */
237	static const VDFILEEXTENSION s_aCueFileExtensions[] =
238	{
239	{"cue", VDTYPE_OPTICAL_DISC},
240	{NULL, VDTYPE_INVALID}
241	};
242
243	/**
244	* Known keywords.
245	*/
246	static const CUEKEYWORDDESC g_aCueKeywords[] =
247	{
248	{RT_STR_TUPLE("FILE"), CUEKEYWORD_FILE},
249	{RT_STR_TUPLE("BINARY"), CUEKEYWORD_BINARY},
250	{RT_STR_TUPLE("MOTOROLA"), CUEKEYWORD_MOTOROLA},
251	{RT_STR_TUPLE("WAVE"), CUEKEYWORD_WAVE},
252	{RT_STR_TUPLE("MP3"), CUEKEYWORD_MP3},
253	{RT_STR_TUPLE("AIFF"), CUEKEYWORD_AIFF},
254	{RT_STR_TUPLE("CATALOG"), CUEKEYWORD_CATALOG},
255	{RT_STR_TUPLE("CDTEXTFILE"), CUEKEYWORD_CDTEXTFILE},
256	{RT_STR_TUPLE("FLAGS"), CUEKEYWORD_FLAGS},
257	{RT_STR_TUPLE("INDEX"), CUEKEYWORD_INDEX},
258	{RT_STR_TUPLE("ISRC"), CUEKEYWORD_ISRC},
259	{RT_STR_TUPLE("PERFORMER"), CUEKEYWORD_PERFORMER},
260	{RT_STR_TUPLE("POSTGAP"), CUEKEYWORD_POSTGAP},
261	{RT_STR_TUPLE("PREGAP"), CUEKEYWORD_PREGAP},
262	{RT_STR_TUPLE("SONGWRITER"), CUEKEYWORD_SONGWRITER},
263	{RT_STR_TUPLE("TITLE"), CUEKEYWORD_TITLE},
264	{RT_STR_TUPLE("TRACK"), CUEKEYWORD_TRACK},
265	{RT_STR_TUPLE("MODE1/2048"), CUEKEYWORD_MODE1_2048},
266	{RT_STR_TUPLE("MODE1/2352"), CUEKEYWORD_MODE1_2352},
267	{RT_STR_TUPLE("MODE2/2352"), CUEKEYWORD_MODE2_2352},
268	{RT_STR_TUPLE("AUDIO"), CUEKEYWORD_AUDIO},
269	{RT_STR_TUPLE("REM"), CUEKEYWORD_REM}
270	};
271
272
273	/*********************************************************************************************************************************
274	* Internal Functions *
275	*********************************************************************************************************************************/
276
277
278	/**
279	* Converts a MSF formatted address value read from the given buffer
280	* to an LBA number. MSF 00:00:00 equals LBA 0.
281	*
282	* @returns The LBA number.
283	* @param pbBuf The buffer to read the MSF formatted address
284	* from.
285	*/
286	DECLINLINE(uint32_t) cueMSF2LBA(const uint8_t *pbBuf)
287	{
288	return (pbBuf[0] * 60 + pbBuf[1]) * 75 + pbBuf[2];
289	}
290
291	/**
292	* Ensures that the region list can hold up to the given number of tracks.
293	*
294	* @returns VBox status code.
295	* @param pThis The CUE image state.
296	* @param cTracksMax Maximum number of tracks.
297	*/
298	static int cueEnsureRegionListSize(PCUEIMAGE pThis, uint32_t cTracksMax)
299	{
300	int rc = VINF_SUCCESS;
301
302	if (pThis->cTracksMax < cTracksMax)
303	{
304	PVDREGIONLIST pRegionListNew = (PVDREGIONLIST)RTMemRealloc(pThis->pRegionList,
305	RT_UOFFSETOF_DYN(VDREGIONLIST, aRegions[cTracksMax]));
306	if (pRegionListNew)
307	{
308	/* Init all the new allocated tracks. */
309	for (uint32_t i = pThis->cTracksMax; i < cTracksMax; i++)
310	pRegionListNew->aRegions[i].offRegion = UINT64_MAX;
311	pThis->pRegionList = pRegionListNew;
312	pThis->cTracksMax = cTracksMax;
313	}
314	else
315	rc = VERR_NO_MEMORY;
316	}
317
318	return rc;
319	}
320
321	/**
322	* Returns whether the tokenizer reached the end of the stream.
323	*
324	* @returns true if the tokenizer reached the end of stream marker
325	* false otherwise.
326	* @param pTokenizer The tokenizer state.
327	*/
328	DECLINLINE(bool) cueTokenizerIsEos(PCUETOKENIZER pTokenizer)
329	{
330	return *pTokenizer->pszInput == '\0';
331	}
332
333	/**
334	* Skip one character in the input stream.
335	*
336	* @param pTokenizer The tokenizer state.
337	*/
338	DECLINLINE(void) cueTokenizerSkipCh(PCUETOKENIZER pTokenizer)
339	{
340	/* Never ever go past EOS. */
341	if (!cueTokenizerIsEos(pTokenizer))
342	pTokenizer->pszInput++;
343	}
344
345	/**
346	* Returns the next char in the input buffer without advancing it.
347	*
348	* @returns Next character in the input buffer.
349	* @param pTokenizer The tokenizer state.
350	*/
351	DECLINLINE(char) cueTokenizerPeekCh(PCUETOKENIZER pTokenizer)
352	{
353	return cueTokenizerIsEos(pTokenizer)
354	? '\0'
355	: *(pTokenizer->pszInput + 1);
356	}
357
358	/**
359	* Returns the next character in the input buffer advancing the internal
360	* position.
361	*
362	* @returns Next character in the stream.
363	* @param pTokenizer The tokenizer state.
364	*/
365	DECLINLINE(char) cueTokenizerGetCh(PCUETOKENIZER pTokenizer)
366	{
367	char ch;
368
369	if (cueTokenizerIsEos(pTokenizer))
370	ch = '\0';
371	else
372	ch = *pTokenizer->pszInput;
373
374	return ch;
375	}
376
377	/**
378	* Sets a new line for the tokenizer.
379	*
380	* @param pTokenizer The tokenizer state.
381	* @param cSkip How many characters to skip.
382	*/
383	DECLINLINE(void) cueTokenizerNewLine(PCUETOKENIZER pTokenizer, unsigned cSkip)
384	{
385	pTokenizer->pszInput += cSkip;
386	}
387
388	/**
389	* Checks whether the current position in the input stream is a new line
390	* and skips it.
391	*
392	* @returns Flag whether there was a new line at the current position
393	* in the input buffer.
394	* @param pTokenizer The tokenizer state.
395	*/
396	DECLINLINE(bool) cueTokenizerIsSkipNewLine(PCUETOKENIZER pTokenizer)
397	{
398	bool fNewline = true;
399
400	if ( cueTokenizerGetCh(pTokenizer) == '\r'
401	&& cueTokenizerPeekCh(pTokenizer) == '\n')
402	cueTokenizerNewLine(pTokenizer, 2);
403	else if (cueTokenizerGetCh(pTokenizer) == '\n')
404	cueTokenizerNewLine(pTokenizer, 1);
405	else
406	fNewline = false;
407
408	return fNewline;
409	}
410
411	/**
412	* Skip all whitespace starting from the current input buffer position.
413	* Skips all present comments too.
414	*
415	* @param pTokenizer The tokenizer state.
416	*/
417	DECLINLINE(void) cueTokenizerSkipWhitespace(PCUETOKENIZER pTokenizer)
418	{
419	while (!cueTokenizerIsEos(pTokenizer))
420	{
421	while ( cueTokenizerGetCh(pTokenizer) == ' '
422	\|\| cueTokenizerGetCh(pTokenizer) == '\t')
423	cueTokenizerSkipCh(pTokenizer);
424
425	if ( !cueTokenizerIsEos(pTokenizer)
426	&& !cueTokenizerIsSkipNewLine(pTokenizer))
427	break; /* Skipped everything, next is some real content. */
428	}
429	}
430
431	/**
432	* Skips a multi line comment.
433	*
434	* @param pTokenizer The tokenizer state.
435	*/
436	DECLINLINE(void) cueTokenizerSkipComment(PCUETOKENIZER pTokenizer)
437	{
438	while ( !cueTokenizerIsEos(pTokenizer)
439	&& !cueTokenizerIsSkipNewLine(pTokenizer))
440	cueTokenizerSkipCh(pTokenizer);
441	cueTokenizerSkipWhitespace(pTokenizer);
442	}
443
444	/**
445	* Get an identifier token from the tokenizer.
446	*
447	* @param pTokenizer The tokenizer state.
448	* @param pToken The uninitialized token.
449	*/
450	static void cueTokenizerGetKeyword(PCUETOKENIZER pTokenizer, PCUETOKEN pToken)
451	{
452	char ch;
453	unsigned cchKeyword = 0;
454	bool fIsKeyword = false;
455	bool fIsComment;
456	const char *pszKeyword;
457
458	Assert(RT_C_IS_ALPHA(*pTokenizer->pszInput));
459
460	do
461	{
462	fIsComment = false;
463	pszKeyword = pTokenizer->pszInput;
464
465	do
466	{
467	cchKeyword++;
468	cueTokenizerSkipCh(pTokenizer);
469	ch = cueTokenizerGetCh(pTokenizer);
470	}
471	while (RT_C_IS_ALNUM(ch) \|\| ch == '_' \|\| ch == '/' \|\| ch == '.');
472
473	/* Check whether we got a keyword or a string constant. */
474	for (unsigned i = 0; i < RT_ELEMENTS(g_aCueKeywords); i++)
475	{
476	if (!RTStrNCmp(g_aCueKeywords[i].pszKeyword, pszKeyword, RT_MIN(cchKeyword, g_aCueKeywords[i].cchKeyword)))
477	{
478	if (g_aCueKeywords[i].enmKeyword == CUEKEYWORD_REM)
479	{
480	/* The REM keyword is handled here as it indicates a comment which we just skip. */
481	cueTokenizerSkipComment(pTokenizer);
482	fIsComment = true;
483	}
484	else
485	{
486	fIsKeyword = true;
487	pToken->enmType = CUETOKENTYPE_KEYWORD;
488	pToken->Type.Keyword.enmKeyword = g_aCueKeywords[i].enmKeyword;
489	}
490	break;
491	}
492	}
493	} while (fIsComment);
494
495	/* Make it a string. */
496	if (ch == '\0')
497	pToken->enmType = CUETOKENTYPE_EOS;
498	else if (!fIsKeyword)
499	{
500	pToken->enmType = CUETOKENTYPE_STRING;
501	pToken->Type.String.psz = pszKeyword;
502	pToken->Type.String.cch = cchKeyword;
503	}
504	}
505
506	/**
507	* Get an integer value or MSF location indicator from the tokenizer.
508	*
509	* @param pTokenizer The tokenizer state.
510	* @param pToken The uninitialized token.
511	*/
512	static void cueTokenizerGetIntegerOrMsf(PCUETOKENIZER pTokenizer, PCUETOKEN pToken)
513	{
514	char szInt[20 + 1]; /* Maximum which fits into an unsigned 64bit integer + zero terminator. */
515	unsigned cchInt = 0;
516	bool fMsf = false;
517	char ch = cueTokenizerGetCh(pTokenizer);
518
519	Assert(RT_C_IS_DIGIT(ch));
520	RT_ZERO(szInt);
521
522	/* Go through the characters and check for the : mark which denotes MSF location indicator. */
523	do
524	{
525	szInt[cchInt++] = ch;
526	cueTokenizerSkipCh(pTokenizer);
527	ch = cueTokenizerGetCh(pTokenizer);
528	if (ch == ':')
529	fMsf = true;
530	}
531	while ( (RT_C_IS_DIGIT(ch) \|\| ch == ':')
532	&& cchInt < sizeof(szInt));
533
534	if (cchInt < sizeof(szInt) - 1)
535	{
536	if (fMsf)
537	{
538	/* Check that the format matches our expectations (mm:ss:ff). */
539	if ( cchInt == 8 && szInt[2] == ':' && szInt[5] == ':')
540	{
541	/* Parse the single fields. */
542	szInt[2] = '\0';
543	szInt[5] = '\0';
544
545	int rc = RTStrToUInt8Full(&szInt[0], 10, &pToken->Type.Msf.u8Minute);
546	if (RT_SUCCESS(rc))
547	rc = RTStrToUInt8Full(&szInt[3], 10, &pToken->Type.Msf.u8Second);
548	if (RT_SUCCESS(rc))
549	rc = RTStrToUInt8Full(&szInt[6], 10, &pToken->Type.Msf.u8Frame);
550	if (RT_SUCCESS(rc))
551	pToken->enmType = CUETOKENTYPE_MSF;
552	else
553	pToken->enmType = CUETOKENTYPE_ERROR;
554	}
555	else
556	pToken->enmType = CUETOKENTYPE_ERROR;
557	}
558	else
559	{
560	pToken->enmType = CUETOKENTYPE_INTEGER_UNSIGNED;
561	int rc = RTStrToUInt64Full(&szInt[0], 10, &pToken->Type.Int.u64);
562	if (RT_FAILURE(rc))
563	pToken->enmType = CUETOKENTYPE_ERROR;
564	}
565	}
566	else
567	pToken->enmType = CUETOKENTYPE_ERROR;
568	}
569
570	/**
571	* Parses a string constant.
572	*
573	* @param pTokenizer The tokenizer state.
574	* @param pToken The uninitialized token.
575	*
576	* @remarks: No escape sequences allowed at this time.
577	*/
578	static void cueTokenizerGetStringConst(PCUETOKENIZER pTokenizer, PCUETOKEN pToken)
579	{
580	unsigned cchStr = 0;
581
582	Assert(cueTokenizerGetCh(pTokenizer) == '\"');
583	cueTokenizerSkipCh(pTokenizer); /* Skip " */
584
585	pToken->enmType = CUETOKENTYPE_STRING;
586	pToken->Type.String.psz = pTokenizer->pszInput;
587
588	while ( !cueTokenizerIsEos(pTokenizer)
589	&& cueTokenizerGetCh(pTokenizer) != '\"')
590	{
591	cchStr++;
592	cueTokenizerSkipCh(pTokenizer);
593	}
594
595	/* End of stream without a closing quote is an error. */
596	if (RT_UNLIKELY(cueTokenizerIsEos(pTokenizer)))
597	pToken->enmType = CUETOKENTYPE_ERROR;
598	else
599	{
600	cueTokenizerSkipCh(pTokenizer); /* Skip closing " */
601	pToken->Type.String.cch = cchStr;
602	}
603	}
604
605	/**
606	* Get the end of stream token.
607	*
608	* @param pTokenizer The tokenizer state.
609	* @param pToken The uninitialized token.
610	*/
611	static void cueTokenizerGetEos(PCUETOKENIZER pTokenizer, PCUETOKEN pToken)
612	{
613	Assert(cueTokenizerGetCh(pTokenizer) == '\0'); RT_NOREF(pTokenizer);
614
615	pToken->enmType = CUETOKENTYPE_EOS;
616	}
617
618	/**
619	* Read the next token from the tokenizer stream.
620	*
621	* @param pTokenizer The tokenizer to read from.
622	* @param pToken Uninitialized token to fill the token data into.
623	*/
624	static void cueTokenizerReadNextToken(PCUETOKENIZER pTokenizer, PCUETOKEN pToken)
625	{
626	/* Skip all eventually existing whitespace, newlines and comments first. */
627	cueTokenizerSkipWhitespace(pTokenizer);
628
629	char ch = cueTokenizerGetCh(pTokenizer);
630	if (RT_C_IS_ALPHA(ch))
631	cueTokenizerGetKeyword(pTokenizer, pToken);
632	else if (RT_C_IS_DIGIT(ch))
633	cueTokenizerGetIntegerOrMsf(pTokenizer, pToken);
634	else if (ch == '\"')
635	cueTokenizerGetStringConst(pTokenizer, pToken);
636	else if (ch == '\0')
637	cueTokenizerGetEos(pTokenizer, pToken);
638	else
639	pToken->enmType = CUETOKENTYPE_ERROR;
640	}
641
642	/**
643	* Create a new tokenizer.
644	*
645	* @returns Pointer to the new tokenizer state on success.
646	* NULL if out of memory.
647	* @param pszInput The input to create the tokenizer for.
648	*/
649	static PCUETOKENIZER cueTokenizerCreate(const char *pszInput)
650	{
651	PCUETOKENIZER pTokenizer = (PCUETOKENIZER)RTMemAllocZ(sizeof(CUETOKENIZER));
652	if (pTokenizer)
653	{
654	pTokenizer->pszInput = pszInput;
655	pTokenizer->pTokenCurr = &pTokenizer->Token1;
656	pTokenizer->pTokenNext = &pTokenizer->Token2;
657	/* Fill the tokenizer with two first tokens. */
658	cueTokenizerReadNextToken(pTokenizer, pTokenizer->pTokenCurr);
659	cueTokenizerReadNextToken(pTokenizer, pTokenizer->pTokenNext);
660	}
661
662	return pTokenizer;
663	}
664
665	/**
666	* Get the current token in the input stream.
667	*
668	* @returns Pointer to the next token in the stream.
669	* @param pTokenizer The tokenizer to destroy.
670	*/
671	DECLINLINE(PCCUETOKEN) cueTokenizerGetToken(PCUETOKENIZER pTokenizer)
672	{
673	return pTokenizer->pTokenCurr;
674	}
675
676	/**
677	* Get the class of the current token.
678	*
679	* @returns Class of the current token.
680	* @param pTokenizer The tokenizer state.
681	*/
682	DECLINLINE(CUETOKENTYPE) cueTokenizerGetTokenType(PCUETOKENIZER pTokenizer)
683	{
684	return pTokenizer->pTokenCurr->enmType;
685	}
686
687	/**
688	* Consume the current token advancing to the next in the stream.
689	*
690	* @param pTokenizer The tokenizer state.
691	*/
692	static void cueTokenizerConsume(PCUETOKENIZER pTokenizer)
693	{
694	PCUETOKEN pTokenTmp = pTokenizer->pTokenCurr;
695
696	/* Switch next token to current token and read in the next token. */
697	pTokenizer->pTokenCurr = pTokenizer->pTokenNext;
698	pTokenizer->pTokenNext = pTokenTmp;
699	cueTokenizerReadNextToken(pTokenizer, pTokenizer->pTokenNext);
700	}
701
702	/**
703	* Check whether the next token in the input stream is a keyword and matches the given
704	* keyword.
705	*
706	* @returns true if the token matched.
707	* false otherwise.
708	* @param pTokenizer The tokenizer state.
709	* @param enmKeyword The keyword to check against.
710	*/
711	static bool cueTokenizerIsKeywordEqual(PCUETOKENIZER pTokenizer, CUEKEYWORD enmKeyword)
712	{
713	PCCUETOKEN pToken = cueTokenizerGetToken(pTokenizer);
714
715	if ( pToken->enmType == CUETOKENTYPE_KEYWORD
716	&& pToken->Type.Keyword.enmKeyword == enmKeyword)
717	return true;
718
719	return false;
720	}
721
722	/**
723	* Check whether the next token in the input stream is a keyword and matches the given
724	* keyword and skips it.
725	*
726	* @returns true if the token matched and was skipped.
727	* false otherwise.
728	* @param pTokenizer The tokenizer state.
729	* @param enmKeyword The keyword to check against.
730	*/
731	static bool cueTokenizerSkipIfIsKeywordEqual(PCUETOKENIZER pTokenizer, CUEKEYWORD enmKeyword)
732	{
733	bool fEqual = cueTokenizerIsKeywordEqual(pTokenizer, enmKeyword);
734	if (fEqual)
735	cueTokenizerConsume(pTokenizer);
736
737	return fEqual;
738	}
739
740	/**
741	* Duplicates the string of the current token and consumes it.
742	*
743	* @returns VBox status code.
744	* @param pTokenizer The tokenizer state.
745	* @param ppszStr Where to store the pointer to the duplicated string on success.
746	* Free with RTStrFree().
747	*/
748	static int cueTokenizerConsumeStringDup(PCUETOKENIZER pTokenizer, char **ppszStr)
749	{
750	int rc = VINF_SUCCESS;
751	Assert(cueTokenizerGetTokenType(pTokenizer) == CUETOKENTYPE_STRING);
752
753	*ppszStr = RTStrDupN(pTokenizer->pTokenCurr->Type.String.psz,
754	pTokenizer->pTokenCurr->Type.String.cch);
755	if (!*ppszStr)
756	rc = VERR_NO_STR_MEMORY;
757
758	cueTokenizerConsume(pTokenizer);
759	return rc;
760	}
761
762	/**
763	* Consumes an integer token returning the value.
764	*
765	* @returns Integer value in the token.
766	* @param pTokenizer The tokenizer state.
767	*/
768	static uint64_t cueTokenizerConsumeInteger(PCUETOKENIZER pTokenizer)
769	{
770	uint64_t u64 = 0;
771	Assert(cueTokenizerGetTokenType(pTokenizer) == CUETOKENTYPE_INTEGER_UNSIGNED);
772
773	u64 = pTokenizer->pTokenCurr->Type.Int.u64;
774	cueTokenizerConsume(pTokenizer);
775	return u64;
776	}
777
778	/**
779	* Parses and skips the remaining string part of a directive.
780	*
781	* @returns VBox status code.
782	* @param pThis The CUE image state.
783	* @param pTokenizer The tokenizer state.
784	* @param pszDirective The directive we skip the string part for.
785	*/
786	static int cueParseAndSkipStringRemainder(PCUEIMAGE pThis, PCUETOKENIZER pTokenizer,
787	const char *pszDirective)
788	{
789	int rc = VINF_SUCCESS;
790
791	if (cueTokenizerGetTokenType(pTokenizer) == CUETOKENTYPE_STRING)
792	cueTokenizerConsume(pTokenizer);
793	else
794	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
795	N_("CUE: Error parsing '%s', expected string for %s directive"), pThis->pszFilename,
796	pszDirective);
797
798	return rc;
799	}
800
801	/**
802	* Parses and skips the remaining MSF part of a directive.
803	*
804	* @returns VBox status code.
805	* @param pThis The CUE image state.
806	* @param pTokenizer The tokenizer state.
807	* @param pszDirective The directive we skip the string part for.
808	*/
809	static int cueParseAndSkipMsfRemainder(PCUEIMAGE pThis, PCUETOKENIZER pTokenizer,
810	const char *pszDirective)
811	{
812	int rc = VINF_SUCCESS;
813
814	if (cueTokenizerGetTokenType(pTokenizer) == CUETOKENTYPE_MSF)
815	cueTokenizerConsume(pTokenizer);
816	else
817	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
818	N_("CUE: Error parsing '%s', expected MSF location for %s directive"), pThis->pszFilename,
819	pszDirective);
820
821	return rc;
822	}
823
824	/**
825	* Parses the remainder of a INDEX directive.
826	*
827	* @returns VBox status code.
828	* @param pThis The CUE image state.
829	* @param pTokenizer The tokenizer state.
830	* @param pu8Index Where to store the parsed index number on success.
831	* @param pu64Lba Where to store the parsed positional information on success.
832	*/
833	static int cueParseIndex(PCUEIMAGE pThis, PCUETOKENIZER pTokenizer,
834	uint8_t pu8Index, uint64_t pu64Lba)
835	{
836	int rc = VINF_SUCCESS;
837
838	/*
839	* The index consists of the index number and positional information in MSF format.
840	*/
841	if (cueTokenizerGetTokenType(pTokenizer) == CUETOKENTYPE_INTEGER_UNSIGNED)
842	{
843	uint64_t u64Index = cueTokenizerConsumeInteger(pTokenizer);
844	if (u64Index <= 99)
845	{
846	/* Parse the position. */
847	if (cueTokenizerGetTokenType(pTokenizer) == CUETOKENTYPE_MSF)
848	{
849	PCCUETOKEN pToken = cueTokenizerGetToken(pTokenizer);
850	uint8_t abMsf[3];
851	abMsf[0] = pToken->Type.Msf.u8Minute;
852	abMsf[1] = pToken->Type.Msf.u8Second;
853	abMsf[2] = pToken->Type.Msf.u8Frame;
854
855	*pu8Index = (uint8_t)u64Index;
856	*pu64Lba = cueMSF2LBA(&abMsf[0]);
857	cueTokenizerConsume(pTokenizer);
858	}
859	else
860	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
861	N_("CUE: Error parsing '%s', expected MSF location"), pThis->pszFilename);
862	}
863	else
864	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
865	N_("CUE: Error parsing '%s', index number must be between 01 and 99"), pThis->pszFilename);
866	}
867	else
868	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
869	N_("CUE: Error parsing '%s', expected index number after INDEX directive"), pThis->pszFilename);
870
871	return rc;
872	}
873
874	/**
875	* Parses the things coming below a TRACK directive.
876	*
877	* @returns VBox status code.
878	* @param pThis The CUE image state.
879	* @param pTokenizer The tokenizer state.
880	* @param pu64LbaStart Where to store the starting LBA for this track on success.
881	*/
882	static int cueParseTrackNesting(PCUEIMAGE pThis, PCUETOKENIZER pTokenizer, uint64_t *pu64LbaStart)
883	{
884	int rc = VINF_SUCCESS;
885	bool fSeenInitialIndex = false;
886
887	do
888	{
889	if ( cueTokenizerIsKeywordEqual(pTokenizer, CUEKEYWORD_TRACK)
890	\|\| cueTokenizerGetTokenType(pTokenizer) == CUETOKENTYPE_EOS)
891	break;
892
893	if (cueTokenizerGetTokenType(pTokenizer) == CUETOKENTYPE_KEYWORD)
894	{
895	if (cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_TITLE))
896	rc = cueParseAndSkipStringRemainder(pThis, pTokenizer, "TITLE");
897	else if (cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_PERFORMER))
898	rc = cueParseAndSkipStringRemainder(pThis, pTokenizer, "PERFORMER");
899	else if (cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_PREGAP))
900	rc = cueParseAndSkipMsfRemainder(pThis, pTokenizer, "PREGAP");
901	else if (cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_POSTGAP))
902	rc = cueParseAndSkipMsfRemainder(pThis, pTokenizer, "POSTGAP");
903	else if (cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_INDEX))
904	{
905	uint8_t u8Index = 0;
906	uint64_t u64Lba = 0;
907	rc = cueParseIndex(pThis, pTokenizer, &u8Index, &u64Lba);
908	if ( RT_SUCCESS(rc)
909	&& u8Index == 1)
910	{
911	if (!fSeenInitialIndex)
912	{
913	fSeenInitialIndex = true;
914	*pu64LbaStart = u64Lba;
915	}
916	else
917	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
918	N_("CUE: Error parsing '%s', multiple INDEX 01 directives"), pThis->pszFilename);
919	}
920	}
921	else
922	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
923	N_("CUE: Error parsing '%s', unexpected directive for TRACK found"), pThis->pszFilename);
924	}
925	else
926	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
927	N_("CUE: Error parsing '%s', expected a CUE sheet keyword"), pThis->pszFilename);
928	}
929	while (RT_SUCCESS(rc));
930
931	if ( RT_SUCCESS(rc)
932	&& !fSeenInitialIndex)
933	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
934	N_("CUE: Error parsing '%s', no initial INDEX directive for this track"), pThis->pszFilename);
935
936	return rc;
937	}
938
939	/**
940	* Parses the remainder of a TRACK directive.
941	*
942	* @returns VBox status code.
943	* @param pThis The CUE image state.
944	* @param pTokenizer The tokenizer state.
945	*/
946	static int cueParseTrack(PCUEIMAGE pThis, PCUETOKENIZER pTokenizer)
947	{
948	int rc = VINF_SUCCESS;
949
950	/*
951	* A track consists of the track number and data type followed by a list of indexes
952	* and other metadata like title and performer we don't care about.
953	*/
954	if (cueTokenizerGetTokenType(pTokenizer) == CUETOKENTYPE_INTEGER_UNSIGNED)
955	{
956	uint64_t u64Track = cueTokenizerConsumeInteger(pTokenizer);
957	if (u64Track <= 99)
958	{
959	/* Parse the data mode. */
960	if (cueTokenizerGetTokenType(pTokenizer) == CUETOKENTYPE_KEYWORD)
961	{
962	CUEKEYWORD enmDataMode = pTokenizer->pTokenCurr->Type.Keyword.enmKeyword;
963	if ( cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_AUDIO)
964	\|\| cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_MODE1_2048)
965	\|\| cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_MODE1_2352)
966	\|\| cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_MODE2_2352))
967	{
968	/*
969	* Parse everything coming below the track (index points, etc.), we only need to find
970	* the starting point.
971	*/
972	uint64_t uLbaStart = 0;
973	rc = cueParseTrackNesting(pThis, pTokenizer, &uLbaStart);
974	if (RT_SUCCESS(rc))
975	{
976	/* Create a new region for this track. */
977	RT_NOREF1(enmDataMode);
978	rc = cueEnsureRegionListSize(pThis, u64Track);
979	if (RT_SUCCESS(rc))
980	{
981	PVDREGIONDESC pRegion = &pThis->pRegionList->aRegions[u64Track - 1];
982	pRegion->offRegion = uLbaStart;
983	if (enmDataMode == CUEKEYWORD_MODE1_2352)
984	{
985	pRegion->cbBlock = 2352;
986	pRegion->enmDataForm = VDREGIONDATAFORM_MODE1_2352;
987	}
988	else if (enmDataMode == CUEKEYWORD_MODE2_2352)
989	{
990	pRegion->cbBlock = 2352;
991	pRegion->enmDataForm = VDREGIONDATAFORM_MODE2_2352;
992	}
993	else if (enmDataMode == CUEKEYWORD_AUDIO)
994	{
995	pRegion->cbBlock = 2352;
996	pRegion->enmDataForm = VDREGIONDATAFORM_CDDA;
997	}
998	else
999	{
1000	pRegion->cbBlock = 2048;
1001	pRegion->enmDataForm = VDREGIONDATAFORM_MODE1_2048;
1002	}
1003	pRegion->enmMetadataForm = VDREGIONMETADATAFORM_NONE;
1004	pRegion->cbData = pRegion->cbBlock;
1005	pRegion->cbMetadata = 0;
1006	}
1007	else
1008	rc = vdIfError(pThis->pIfError, rc, RT_SRC_POS,
1009	N_("CUE: Failed to allocate memory for the track list for '%s'"),
1010	pThis->pszFilename);
1011	}
1012	}
1013	else
1014	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
1015	N_("CUE: Error parsing '%s', the data mode is not supported"), pThis->pszFilename);
1016	}
1017	else
1018	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
1019	N_("CUE: Error parsing '%s', expected data mode"), pThis->pszFilename);
1020	}
1021	else
1022	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
1023	N_("CUE: Error parsing '%s', track number must be between 01 and 99"), pThis->pszFilename);
1024	}
1025	else
1026	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
1027	N_("CUE: Error parsing '%s', expected track number after TRACK directive"), pThis->pszFilename);
1028
1029	return rc;
1030	}
1031
1032	/**
1033	* Parses a list of tracks which must come after a FILE directive.
1034	*
1035	* @returns VBox status code.
1036	* @param pThis The CUE image state.
1037	* @param pTokenizer The tokenizer state.
1038	*/
1039	static int cueParseTrackList(PCUEIMAGE pThis, PCUETOKENIZER pTokenizer)
1040	{
1041	int rc = VINF_SUCCESS;
1042
1043	/*
1044	* Sometimes there is a TITLE/PERFORMER/SONGWRITER directive before the start of the track list,
1045	* skip and ignore those.
1046	*/
1047	while ( RT_SUCCESS(rc)
1048	&& ( cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_TITLE)
1049	\|\| cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_PERFORMER)
1050	\|\| cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_SONGWRITER)))
1051	rc = cueParseAndSkipStringRemainder(pThis, pTokenizer, "TITLE/PERFORMER/SONGWRITER");
1052
1053	while ( RT_SUCCESS(rc)
1054	&& cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_TRACK))
1055	rc = cueParseTrack(pThis, pTokenizer);
1056
1057	return rc;
1058	}
1059
1060	/**
1061	* Parses the remainder of a FILE directive.
1062	*
1063	* @returns VBox status code.
1064	* @param pThis The CUE image state.
1065	* @param pTokenizer The tokenizer state.
1066	*/
1067	static int cueParseFile(PCUEIMAGE pThis, PCUETOKENIZER pTokenizer)
1068	{
1069	int rc = VINF_SUCCESS;
1070
1071	/* First must come a string constant followed by a keyword giving the file type. */
1072	if (cueTokenizerGetTokenType(pTokenizer) == CUETOKENTYPE_STRING)
1073	{
1074	rc = cueTokenizerConsumeStringDup(pTokenizer, &pThis->pszDataFilename);
1075	if (RT_SUCCESS(rc))
1076	{
1077	if (cueTokenizerGetTokenType(pTokenizer) == CUETOKENTYPE_KEYWORD)
1078	{
1079	if (cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_BINARY))
1080	{
1081	pThis->fLittleEndian = true;
1082	rc = cueParseTrackList(pThis, pTokenizer);
1083	}
1084	else if (cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_MOTOROLA))
1085	{
1086	pThis->fLittleEndian = false;
1087	rc = cueParseTrackList(pThis, pTokenizer);
1088	}
1089	else
1090	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
1091	N_("CUE: Error parsing '%s', the file type is not supported (only BINARY)"), pThis->pszFilename);
1092	}
1093	else
1094	rc = vdIfError(pThis->pIfError, rc, RT_SRC_POS,
1095	N_("CUE: Error parsing '%s', expected file type"), pThis->pszFilename);
1096	}
1097	else
1098	rc = vdIfError(pThis->pIfError, rc, RT_SRC_POS,
1099	N_("CUE: Error parsing '%s', failed to allocate memory for filename"), pThis->pszFilename);
1100	}
1101	else
1102	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
1103	N_("CUE: Error parsing '%s', expected filename after FILE directive"), pThis->pszFilename);
1104
1105	return rc;
1106	}
1107
1108	/**
1109	* Parses the keyword in the given tokenizer.
1110	*
1111	* @returns VBox status code.
1112	* @param pThis The CUE image state.
1113	* @param pTokenizer The tokenizer state.
1114	*/
1115	static int cueParseKeyword(PCUEIMAGE pThis, PCUETOKENIZER pTokenizer)
1116	{
1117	int rc = VINF_SUCCESS;
1118
1119	if (cueTokenizerSkipIfIsKeywordEqual(pTokenizer, CUEKEYWORD_FILE))
1120	rc = cueParseFile(pThis, pTokenizer);
1121	else /* Skip all other keywords we don't need/support. */
1122	cueTokenizerConsume(pTokenizer);
1123
1124	return rc;
1125	}
1126
1127
1128	/**
1129	* Parses the CUE sheet from the given tokenizer.
1130	*
1131	* @returns VBox status code.
1132	* @param pThis The CUE image state.
1133	* @param pTokenizer The tokenizer state.
1134	*/
1135	static int cueParseFromTokenizer(PCUEIMAGE pThis, PCUETOKENIZER pTokenizer)
1136	{
1137	int rc = VINF_SUCCESS;
1138
1139	LogFlowFunc(("pThis=%p\n", pThis));
1140
1141	/* We don't support multiple FILE directives for now. */
1142	if (cueTokenizerGetTokenType(pTokenizer) == CUETOKENTYPE_KEYWORD)
1143	rc = cueParseKeyword(pThis, pTokenizer);
1144	else
1145	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
1146	N_("CUE: Error parsing '%s', expected a keyword"), pThis->pszFilename);
1147
1148	if ( RT_SUCCESS(rc)
1149	&& cueTokenizerGetTokenType(pTokenizer) != CUETOKENTYPE_EOS)
1150	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
1151	N_("CUE: Error parsing '%s', expected end of stream"), pThis->pszFilename);
1152
1153	LogFlowFunc(("returns rc=%Rrc\n", rc));
1154	return rc;
1155	}
1156
1157	/**
1158	* Finalizes the track list of the image.
1159	*
1160	* @returns VBox status code.
1161	* @param pThis The CUE image state.
1162	* @param cbImage Size of the image data in bytes.
1163	*/
1164	static int cueTrackListFinalize(PCUEIMAGE pThis, uint64_t cbImage)
1165	{
1166	int rc = VINF_SUCCESS;
1167
1168	if ( pThis->cTracksMax == 0
1169	\|\| pThis->pRegionList->aRegions[0].offRegion == UINT64_MAX)
1170	return vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
1171	N_("CUE: Error parsing '%s', detected empty track list"), pThis->pszFilename);
1172
1173	/*
1174	* Fixup the track list to contain the proper sizes now that we parsed all tracks,
1175	* check also that there are no gaps in the list.
1176	*/
1177	uint32_t cTracks = 1;
1178	uint64_t offDisk = 0;
1179	for (uint32_t i = 1; i < pThis->cTracksMax; i++)
1180	{
1181	PVDREGIONDESC pRegion = &pThis->pRegionList->aRegions[i];
1182	PVDREGIONDESC pRegionPrev = &pThis->pRegionList->aRegions[i - 1];
1183	if (pRegion->offRegion != UINT64_MAX)
1184	{
1185	cTracks++;
1186	uint64_t cBlocks = pRegion->offRegion - (pRegionPrev->offRegion / pRegionPrev->cbBlock);
1187	pRegionPrev->cRegionBlocksOrBytes = pRegionPrev->cbBlock * cBlocks;
1188	offDisk += pRegionPrev->cRegionBlocksOrBytes;
1189
1190	if (cbImage < pRegionPrev->cRegionBlocksOrBytes)
1191	return vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
1192	N_("CUE: Error parsing '%s', image file is too small for track list"),
1193	pThis->pszFilename);
1194
1195	cbImage -= pRegionPrev->cRegionBlocksOrBytes;
1196	pRegion->offRegion = offDisk;
1197	}
1198	else
1199	break;
1200	}
1201
1202	/* Fixup last track. */
1203	PVDREGIONDESC pRegion = &pThis->pRegionList->aRegions[cTracks - 1];
1204	pRegion->cRegionBlocksOrBytes = cbImage;
1205
1206	pThis->pRegionList->cRegions = cTracks;
1207	pThis->pRegionList->fFlags = 0;
1208
1209	/* Check that there are no gaps in the track list. */
1210	for (uint32_t i = cTracks; cTracks < pThis->cTracksMax; i++)
1211	{
1212	pRegion = &pThis->pRegionList->aRegions[i];
1213	if (pRegion->offRegion != UINT64_MAX)
1214	{
1215	rc = vdIfError(pThis->pIfError, VERR_NOT_SUPPORTED, RT_SRC_POS,
1216	N_("CUE: Error parsing '%s', detected gaps in the track list"), pThis->pszFilename);
1217	break;
1218	}
1219	}
1220
1221	return rc;
1222	}
1223
1224	/**
1225	* Internal. Free all allocated space for representing an image except pThis,
1226	* and optionally delete the image from disk.
1227	*/
1228	static int cueFreeImage(PCUEIMAGE pThis, bool fDelete)
1229	{
1230	int rc = VINF_SUCCESS;
1231
1232	/* Freeing a never allocated image (e.g. because the open failed) is
1233	* not signalled as an error. After all nothing bad happens. */
1234	if (pThis)
1235	{
1236	if (pThis->pStorage)
1237	{
1238	rc = vdIfIoIntFileClose(pThis->pIfIo, pThis->pStorage);
1239	pThis->pStorage = NULL;
1240	}
1241
1242	if (pThis->pStorageData)
1243	{
1244	rc = vdIfIoIntFileClose(pThis->pIfIo, pThis->pStorageData);
1245	pThis->pStorageData = NULL;
1246	}
1247
1248	if (pThis->pRegionList)
1249	{
1250	RTMemFree(pThis->pRegionList);
1251	pThis->pRegionList = NULL;
1252	}
1253
1254	if (pThis->pszDataFilename)
1255	{
1256	RTStrFree(pThis->pszDataFilename);
1257	pThis->pszDataFilename = NULL;
1258	}
1259
1260	if (fDelete && pThis->pszFilename)
1261	vdIfIoIntFileDelete(pThis->pIfIo, pThis->pszFilename);
1262	}
1263
1264	LogFlowFunc(("returns %Rrc\n", rc));
1265	return rc;
1266	}
1267
1268	/**
1269	* Internal: Open an image, constructing all necessary data structures.
1270	*/
1271	static int cueOpenImage(PCUEIMAGE pThis, unsigned uOpenFlags)
1272	{
1273	pThis->uOpenFlags = uOpenFlags;
1274
1275	pThis->pIfError = VDIfErrorGet(pThis->pVDIfsDisk);
1276	pThis->pIfIo = VDIfIoIntGet(pThis->pVDIfsImage);
1277	AssertPtrReturn(pThis->pIfIo, VERR_INVALID_PARAMETER);
1278
1279	/* Open the image. */
1280	int rc = vdIfIoIntFileOpen(pThis->pIfIo, pThis->pszFilename,
1281	VDOpenFlagsToFileOpenFlags(uOpenFlags,
1282	false /* fCreate */),
1283	&pThis->pStorage);
1284	if (RT_SUCCESS(rc))
1285	{
1286	uint64_t cbFile;
1287	/* The descriptor file shouldn't be huge, so limit ourselfs to 16KB for now. */
1288	rc = vdIfIoIntFileGetSize(pThis->pIfIo, pThis->pStorage, &cbFile);
1289	if ( RT_SUCCESS(rc)
1290	&& cbFile <= _16K - 1)
1291	{
1292	char szInput[_16K];
1293	RT_ZERO(szInput);
1294
1295	rc = vdIfIoIntFileReadSync(pThis->pIfIo, pThis->pStorage, 0,
1296	&szInput, cbFile);
1297	if (RT_SUCCESS(rc))
1298	{
1299	RTStrPurgeEncoding(&szInput[0]);
1300	PCUETOKENIZER pTokenizer = cueTokenizerCreate(&szInput[0]);
1301	if (pTokenizer)
1302	{
1303	rc = cueParseFromTokenizer(pThis, pTokenizer);
1304	RTMemFree(pTokenizer);
1305	if (RT_SUCCESS(rc))
1306	{
1307	/* Open the backing file. */
1308	char szBackingFile[RTPATH_MAX];
1309	rc = RTStrCopy(&szBackingFile[0], sizeof(szBackingFile), pThis->pszFilename);
1310	if (RT_SUCCESS(rc))
1311	{
1312	RTPathStripFilename(&szBackingFile[0]);
1313	rc = RTPathAppend(&szBackingFile[0], sizeof(szBackingFile), pThis->pszDataFilename);
1314	if (RT_SUCCESS(rc))
1315	{
1316	rc = vdIfIoIntFileOpen(pThis->pIfIo, szBackingFile,
1317	VDOpenFlagsToFileOpenFlags(uOpenFlags,
1318	false /* fCreate */),
1319	&pThis->pStorageData);
1320	if (RT_SUCCESS(rc))
1321	{
1322	rc = vdIfIoIntFileGetSize(pThis->pIfIo, pThis->pStorageData, &cbFile);
1323	if (RT_SUCCESS(rc))
1324	rc = cueTrackListFinalize(pThis, cbFile);
1325	else
1326	rc = vdIfError(pThis->pIfError, rc, RT_SRC_POS,
1327	N_("CUE: Unable to query size of backing file '%s'"),
1328	szBackingFile);
1329	}
1330	else
1331	rc = vdIfError(pThis->pIfError, rc, RT_SRC_POS,
1332	N_("CUE: Unable to open backing file '%s'"),
1333	szBackingFile);
1334	}
1335	else
1336	rc = vdIfError(pThis->pIfError, rc, RT_SRC_POS,
1337	N_("CUE: Error constructing backing filename from '%s'"),
1338	pThis->pszFilename);
1339	}
1340	else
1341	rc = vdIfError(pThis->pIfError, rc, RT_SRC_POS,
1342	N_("CUE: Error constructing backing filename from '%s'"),
1343	pThis->pszFilename);
1344	}
1345	}
1346	}
1347	else
1348	rc = vdIfError(pThis->pIfError, rc, RT_SRC_POS, N_("CUE: Error reading '%s'"), pThis->pszFilename);
1349	}
1350	else if (RT_SUCCESS(rc))
1351	rc = vdIfError(pThis->pIfError, VERR_VD_INVALID_SIZE,
1352	RT_SRC_POS, N_("CUE: The descriptor file '%s' is too huge (%llu vs %llu)"),
1353	pThis->pszFilename, cbFile, _16K - 1);
1354	}
1355	/* else: Do NOT signal an appropriate error here, as the VD layer has the
1356	* choice of retrying the open if it failed. */
1357
1358	if (RT_FAILURE(rc))
1359	cueFreeImage(pThis, false);
1360	return rc;
1361	}
1362
1363	/**
1364	* Converts the data form enumeration to a string.
1365	*
1366	* @returns String name of the given data form.
1367	* @param enmDataForm The data form.
1368	*/
1369	static const char *cueRegionDataFormStringify(VDREGIONDATAFORM enmDataForm)
1370	{
1371	switch (enmDataForm)
1372	{
1373	#define DATAFORM2STR(tag) case VDREGIONDATAFORM_##tag: return #tag
1374
1375	DATAFORM2STR(INVALID);
1376	DATAFORM2STR(RAW);
1377	DATAFORM2STR(CDDA);
1378	DATAFORM2STR(CDDA_PAUSE);
1379	DATAFORM2STR(MODE1_2048);
1380	DATAFORM2STR(MODE1_2352);
1381	DATAFORM2STR(MODE1_0);
1382	DATAFORM2STR(XA_2336);
1383	DATAFORM2STR(XA_2352);
1384	DATAFORM2STR(XA_0);
1385	DATAFORM2STR(MODE2_2336);
1386	DATAFORM2STR(MODE2_2352);
1387	DATAFORM2STR(MODE2_0);
1388
1389	#undef DATAFORM2STR
1390
1391	default:
1392	{
1393	AssertMsgFailed(("Unknown data form %d! forgot to add it to the switch?\n", enmDataForm));
1394	return "UNKNOWN!";
1395	}
1396	}
1397	}
1398
1399	/**
1400	* Converts the data form enumeration to a string.
1401	*
1402	* @returns String name of the given data form.
1403	* @param enmMetadataForm The metadata form.
1404	*/
1405	static const char *cueRegionMetadataFormStringify(VDREGIONMETADATAFORM enmMetadataForm)
1406	{
1407	switch (enmMetadataForm)
1408	{
1409	#define METADATAFORM2STR(tag) case VDREGIONMETADATAFORM_##tag: return #tag
1410
1411	METADATAFORM2STR(INVALID);
1412	METADATAFORM2STR(RAW);
1413	METADATAFORM2STR(NONE);
1414
1415	#undef METADATAFORM2STR
1416
1417	default:
1418	{
1419	AssertMsgFailed(("Unknown metadata form %d! forgot to add it to the switch?\n", enmMetadataForm));
1420	return "UNKNOWN!";
1421	}
1422	}
1423	}
1424
1425	/**
1426	* Returns the region containing the given offset.
1427	*
1428	* @returns Pointer to the region or NULL if not found.
1429	* @param pThis The CUE image state.
1430	* @param uOffset The offset to look for.
1431	*/
1432	static PCVDREGIONDESC cueRegionQueryByOffset(PCUEIMAGE pThis, uint64_t uOffset)
1433	{
1434	for (uint32_t i = 0; i < pThis->pRegionList->cRegions; i++)
1435	{
1436	PCVDREGIONDESC pRegion = &pThis->pRegionList->aRegions[i];
1437	if ( pRegion->offRegion <= uOffset
1438	&& pRegion->offRegion + pRegion->cRegionBlocksOrBytes > uOffset)
1439	return pRegion;
1440	}
1441
1442	return NULL;
1443	}
1444
1445	/** @copydoc VDIMAGEBACKEND::pfnProbe */
1446	static DECLCALLBACK(int) cueProbe(const char *pszFilename, PVDINTERFACE pVDIfsDisk,
1447	PVDINTERFACE pVDIfsImage, VDTYPE enmDesiredType, VDTYPE *penmType)
1448	{
1449	RT_NOREF(pVDIfsDisk, enmDesiredType);
1450	LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p\n", pszFilename, pVDIfsDisk, pVDIfsImage));
1451	int rc = VINF_SUCCESS;
1452
1453	AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
1454	AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
1455
1456
1457	PCUEIMAGE pThis = (PCUEIMAGE)RTMemAllocZ(sizeof(CUEIMAGE));
1458	if (RT_LIKELY(pThis))
1459	{
1460	pThis->pszFilename = pszFilename;
1461	pThis->pStorage = NULL;
1462	pThis->pVDIfsDisk = pVDIfsDisk;
1463	pThis->pVDIfsImage = pVDIfsImage;
1464
1465	rc = cueOpenImage(pThis, VD_OPEN_FLAGS_INFO \| VD_OPEN_FLAGS_READONLY);
1466	cueFreeImage(pThis, false);
1467	RTMemFree(pThis);
1468
1469	if (RT_SUCCESS(rc))
1470	*penmType = VDTYPE_OPTICAL_DISC;
1471	else
1472	rc = VERR_VD_GEN_INVALID_HEADER;
1473	}
1474	else
1475	rc = VERR_NO_MEMORY;
1476
1477	LogFlowFunc(("returns %Rrc\n", rc));
1478	return rc;
1479	}
1480
1481	/** @copydoc VDIMAGEBACKEND::pfnOpen */
1482	static DECLCALLBACK(int) cueOpen(const char *pszFilename, unsigned uOpenFlags,
1483	PVDINTERFACE pVDIfsDisk, PVDINTERFACE pVDIfsImage,
1484	VDTYPE enmType, void **ppBackendData)
1485	{
1486	LogFlowFunc(("pszFilename=\"%s\" uOpenFlags=%#x pVDIfsDisk=%#p pVDIfsImage=%#p enmType=%u ppBackendData=%#p\n",
1487	pszFilename, uOpenFlags, pVDIfsDisk, pVDIfsImage, enmType, ppBackendData));
1488	int rc;
1489	PCUEIMAGE pThis;
1490
1491	/* Check open flags. All valid flags are supported. */
1492	AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
1493	AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
1494	AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
1495
1496	AssertReturn(enmType == VDTYPE_OPTICAL_DISC, VERR_NOT_SUPPORTED);
1497
1498	pThis = (PCUEIMAGE)RTMemAllocZ(sizeof(CUEIMAGE));
1499	if (RT_LIKELY(pThis))
1500	{
1501	pThis->pszFilename = pszFilename;
1502	pThis->pStorage = NULL;
1503	pThis->pVDIfsDisk = pVDIfsDisk;
1504	pThis->pVDIfsImage = pVDIfsImage;
1505
1506	rc = cueOpenImage(pThis, uOpenFlags);
1507	if (RT_SUCCESS(rc))
1508	*ppBackendData = pThis;
1509	else
1510	RTMemFree(pThis);
1511	}
1512	else
1513	rc = VERR_NO_MEMORY;
1514
1515	LogFlowFunc(("returns %Rrc (pBackendData=%#p)\n", rc, *ppBackendData));
1516	return rc;
1517	}
1518
1519	/** @copydoc VDIMAGEBACKEND::pfnClose */
1520	static DECLCALLBACK(int) cueClose(void *pBackendData, bool fDelete)
1521	{
1522	LogFlowFunc(("pBackendData=%#p fDelete=%d\n", pBackendData, fDelete));
1523	PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
1524	int rc = cueFreeImage(pThis, fDelete);
1525	RTMemFree(pThis);
1526
1527	LogFlowFunc(("returns %Rrc\n", rc));
1528	return rc;
1529	}
1530
1531	/** @copydoc VDIMAGEBACKEND::pfnRead */
1532	static DECLCALLBACK(int) cueRead(void *pBackendData, uint64_t uOffset, size_t cbToRead,
1533	PVDIOCTX pIoCtx, size_t *pcbActuallyRead)
1534	{
1535	LogFlowFunc(("pBackendData=%#p uOffset=%llu cbToRead=%zu pIoCtx=%#p pcbActuallyRead=%#p\n",
1536	pBackendData, uOffset, cbToRead, pIoCtx, pcbActuallyRead));
1537	int rc = VINF_SUCCESS;
1538	PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
1539
1540	/* Get the region */
1541	PCVDREGIONDESC pRegion = cueRegionQueryByOffset(pThis, uOffset);
1542	if (pRegion)
1543	{
1544	/* Clip read size to remain in the region (not necessary I think). */
1545	uint64_t offRead = uOffset - pRegion->offRegion;
1546
1547	cbToRead = RT_MIN(cbToRead, pRegion->cRegionBlocksOrBytes - offRead);
1548	Assert(!(cbToRead % pRegion->cbBlock));
1549
1550	/* Need to convert audio data samples to little endian. */
1551	if ( pRegion->enmDataForm == VDREGIONDATAFORM_CDDA
1552	&& !pThis->fLittleEndian)
1553	{
1554	*pcbActuallyRead = cbToRead;
1555
1556	while (cbToRead)
1557	{
1558	RTSGSEG Segment;
1559	unsigned cSegments = 1;
1560	size_t cbSeg = 0;
1561
1562	cbSeg = vdIfIoIntIoCtxSegArrayCreate(pThis->pIfIo, pIoCtx, &Segment,
1563	&cSegments, cbToRead);
1564
1565	rc = vdIfIoIntFileReadSync(pThis->pIfIo, pThis->pStorageData, uOffset, Segment.pvSeg, cbSeg);
1566	if (RT_FAILURE(rc))
1567	break;
1568
1569	uint16_t pu16Buf = (uint16_t )Segment.pvSeg;
1570	for (uint32_t i = 0; i < cbSeg / sizeof(uint16_t); i++)
1571	{
1572	pu16Buf = RT_BSWAP_U16(pu16Buf);
1573	pu16Buf++;
1574	}
1575
1576	cbToRead -= RT_MIN(cbToRead, cbSeg);
1577	uOffset += cbSeg;
1578	}
1579	}
1580	else
1581	{
1582	rc = vdIfIoIntFileReadUser(pThis->pIfIo, pThis->pStorageData, uOffset,
1583	pIoCtx, cbToRead);
1584	if (RT_SUCCESS(rc))
1585	*pcbActuallyRead = cbToRead;
1586	}
1587	}
1588	else
1589	rc = VERR_INVALID_PARAMETER;
1590
1591	return rc;
1592	}
1593
1594	/** @copydoc VDIMAGEBACKEND::pfnWrite */
1595	static DECLCALLBACK(int) cueWrite(void *pBackendData, uint64_t uOffset, size_t cbToWrite,
1596	PVDIOCTX pIoCtx, size_t pcbWriteProcess, size_t pcbPreRead,
1597	size_t *pcbPostRead, unsigned fWrite)
1598	{
1599	RT_NOREF7(uOffset, cbToWrite, pIoCtx, pcbWriteProcess, pcbPreRead, pcbPostRead, fWrite);
1600	LogFlowFunc(("pBackendData=%#p uOffset=%llu pIoCtx=%#p cbToWrite=%zu pcbWriteProcess=%#p pcbPreRead=%#p pcbPostRead=%#p\n",
1601	pBackendData, uOffset, pIoCtx, cbToWrite, pcbWriteProcess, pcbPreRead, pcbPostRead));
1602	PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
1603	int rc;
1604
1605	AssertPtr(pThis);
1606
1607	if (pThis->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1608	rc = VERR_VD_IMAGE_READ_ONLY;
1609	else
1610	rc = VERR_NOT_SUPPORTED;
1611
1612	LogFlowFunc(("returns %Rrc\n", rc));
1613	return rc;
1614	}
1615
1616	/** @copydoc VDIMAGEBACKEND::pfnFlush */
1617	static DECLCALLBACK(int) cueFlush(void *pBackendData, PVDIOCTX pIoCtx)
1618	{
1619	RT_NOREF2(pBackendData, pIoCtx);
1620
1621	return VINF_SUCCESS;
1622	}
1623
1624	/** @copydoc VDIMAGEBACKEND::pfnGetVersion */
1625	static DECLCALLBACK(unsigned) cueGetVersion(void *pBackendData)
1626	{
1627	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1628	PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
1629
1630	AssertPtrReturn(pThis, 0);
1631
1632	return 1;
1633	}
1634
1635	/** @copydoc VDIMAGEBACKEND::pfnGetFileSize */
1636	static DECLCALLBACK(uint64_t) cueGetFileSize(void *pBackendData)
1637	{
1638	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1639	PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
1640
1641	AssertPtrReturn(pThis, 0);
1642
1643	uint64_t cbFile = 0;
1644	if (pThis->pStorage)
1645	{
1646	int rc = vdIfIoIntFileGetSize(pThis->pIfIo, pThis->pStorageData, &cbFile);
1647	if (RT_FAILURE(rc))
1648	cbFile = 0; /* Make sure it is 0 */
1649	}
1650
1651	LogFlowFunc(("returns %lld\n", cbFile));
1652	return cbFile;
1653	}
1654
1655	/** @copydoc VDIMAGEBACKEND::pfnGetPCHSGeometry */
1656	static DECLCALLBACK(int) cueGetPCHSGeometry(void *pBackendData,
1657	PVDGEOMETRY pPCHSGeometry)
1658	{
1659	RT_NOREF1(pPCHSGeometry);
1660	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p\n", pBackendData, pPCHSGeometry));
1661	PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
1662	int rc = VINF_SUCCESS;
1663
1664	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
1665
1666	rc = VERR_NOT_SUPPORTED;
1667
1668	LogFlowFunc(("returns %Rrc (PCHS=%u/%u/%u)\n", rc, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
1669	return rc;
1670	}
1671
1672	/** @copydoc VDIMAGEBACKEND::pfnSetPCHSGeometry */
1673	static DECLCALLBACK(int) cueSetPCHSGeometry(void *pBackendData,
1674	PCVDGEOMETRY pPCHSGeometry)
1675	{
1676	RT_NOREF1(pPCHSGeometry);
1677	LogFlowFunc(("pBackendData=%#p pPCHSGeometry=%#p PCHS=%u/%u/%u\n",
1678	pBackendData, pPCHSGeometry, pPCHSGeometry->cCylinders, pPCHSGeometry->cHeads, pPCHSGeometry->cSectors));
1679	PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
1680	int rc = VINF_SUCCESS;
1681
1682	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
1683
1684	if (pThis->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1685	rc = VERR_VD_IMAGE_READ_ONLY;
1686	else
1687	rc = VERR_NOT_SUPPORTED;
1688
1689	LogFlowFunc(("returns %Rrc\n", rc));
1690	return rc;
1691	}
1692
1693	/** @copydoc VDIMAGEBACKEND::pfnGetLCHSGeometry */
1694	static DECLCALLBACK(int) cueGetLCHSGeometry(void *pBackendData,
1695	PVDGEOMETRY pLCHSGeometry)
1696	{
1697	RT_NOREF1(pLCHSGeometry);
1698	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p\n", pBackendData, pLCHSGeometry));
1699	PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
1700	int rc = VINF_SUCCESS;
1701
1702	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
1703
1704	rc = VERR_NOT_SUPPORTED;
1705
1706	LogFlowFunc(("returns %Rrc (LCHS=%u/%u/%u)\n", rc, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
1707	return rc;
1708	}
1709
1710	/** @copydoc VDIMAGEBACKEND::pfnSetLCHSGeometry */
1711	static DECLCALLBACK(int) cueSetLCHSGeometry(void *pBackendData,
1712	PCVDGEOMETRY pLCHSGeometry)
1713	{
1714	RT_NOREF1(pLCHSGeometry);
1715	LogFlowFunc(("pBackendData=%#p pLCHSGeometry=%#p LCHS=%u/%u/%u\n",
1716	pBackendData, pLCHSGeometry, pLCHSGeometry->cCylinders, pLCHSGeometry->cHeads, pLCHSGeometry->cSectors));
1717	PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
1718	int rc = VINF_SUCCESS;
1719
1720	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
1721
1722	if (pThis->uOpenFlags & VD_OPEN_FLAGS_READONLY)
1723	rc = VERR_VD_IMAGE_READ_ONLY;
1724	else
1725	rc = VERR_NOT_SUPPORTED;
1726
1727	LogFlowFunc(("returns %Rrc\n", rc));
1728	return rc;
1729	}
1730
1731	/** @copydoc VDIMAGEBACKEND::pfnQueryRegions */
1732	static DECLCALLBACK(int) cueQueryRegions(void pBackendData, PCVDREGIONLIST ppRegionList)
1733	{
1734	LogFlowFunc(("pBackendData=%#p ppRegionList=%#p\n", pBackendData, ppRegionList));
1735	PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
1736
1737	AssertPtrReturn(pThis, VERR_VD_NOT_OPENED);
1738
1739	*ppRegionList = pThis->pRegionList;
1740	LogFlowFunc(("returns %Rrc\n", VINF_SUCCESS));
1741	return VINF_SUCCESS;
1742	}
1743
1744	/** @copydoc VDIMAGEBACKEND::pfnRegionListRelease */
1745	static DECLCALLBACK(void) cueRegionListRelease(void *pBackendData, PCVDREGIONLIST pRegionList)
1746	{
1747	RT_NOREF1(pRegionList);
1748	LogFlowFunc(("pBackendData=%#p pRegionList=%#p\n", pBackendData, pRegionList));
1749	PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
1750	AssertPtr(pThis); RT_NOREF(pThis);
1751
1752	/* Nothing to do here. */
1753	}
1754
1755	/** @copydoc VDIMAGEBACKEND::pfnGetImageFlags */
1756	static DECLCALLBACK(unsigned) cueGetImageFlags(void *pBackendData)
1757	{
1758	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1759	PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
1760
1761	AssertPtrReturn(pThis, 0);
1762
1763	LogFlowFunc(("returns %#x\n", pThis->uImageFlags));
1764	return pThis->uImageFlags;
1765	}
1766
1767	/** @copydoc VDIMAGEBACKEND::pfnGetOpenFlags */
1768	static DECLCALLBACK(unsigned) cueGetOpenFlags(void *pBackendData)
1769	{
1770	LogFlowFunc(("pBackendData=%#p\n", pBackendData));
1771	PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
1772
1773	AssertPtrReturn(pThis, 0);
1774
1775	LogFlowFunc(("returns %#x\n", pThis->uOpenFlags));
1776	return pThis->uOpenFlags;
1777	}
1778
1779	/** @copydoc VDIMAGEBACKEND::pfnSetOpenFlags */
1780	static DECLCALLBACK(int) cueSetOpenFlags(void *pBackendData, unsigned uOpenFlags)
1781	{
1782	LogFlowFunc(("pBackendData=%#p\n uOpenFlags=%#x", pBackendData, uOpenFlags));
1783	PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
1784	int rc = VINF_SUCCESS;
1785
1786	/* Image must be opened and the new flags must be valid. */
1787	if (!pThis \|\| (uOpenFlags & ~( VD_OPEN_FLAGS_READONLY \| VD_OPEN_FLAGS_INFO
1788	\| VD_OPEN_FLAGS_ASYNC_IO \| VD_OPEN_FLAGS_SHAREABLE
1789	\| VD_OPEN_FLAGS_SEQUENTIAL \| VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS)))
1790	rc = VERR_INVALID_PARAMETER;
1791	else
1792	{
1793	/* Implement this operation via reopening the image. */
1794	rc = cueFreeImage(pThis, false);
1795	if (RT_SUCCESS(rc))
1796	rc = cueOpenImage(pThis, uOpenFlags);
1797	}
1798
1799	LogFlowFunc(("returns %Rrc\n", rc));
1800	return rc;
1801	}
1802
1803	/** @copydoc VDIMAGEBACKEND::pfnGetComment */
1804	VD_BACKEND_CALLBACK_GET_COMMENT_DEF_NOT_SUPPORTED(cueGetComment);
1805
1806	/** @copydoc VDIMAGEBACKEND::pfnSetComment */
1807	VD_BACKEND_CALLBACK_SET_COMMENT_DEF_NOT_SUPPORTED(cueSetComment, PCUEIMAGE);
1808
1809	/** @copydoc VDIMAGEBACKEND::pfnGetUuid */
1810	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(cueGetUuid);
1811
1812	/** @copydoc VDIMAGEBACKEND::pfnSetUuid */
1813	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(cueSetUuid, PCUEIMAGE);
1814
1815	/** @copydoc VDIMAGEBACKEND::pfnGetModificationUuid */
1816	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(cueGetModificationUuid);
1817
1818	/** @copydoc VDIMAGEBACKEND::pfnSetModificationUuid */
1819	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(cueSetModificationUuid, PCUEIMAGE);
1820
1821	/** @copydoc VDIMAGEBACKEND::pfnGetParentUuid */
1822	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(cueGetParentUuid);
1823
1824	/** @copydoc VDIMAGEBACKEND::pfnSetParentUuid */
1825	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(cueSetParentUuid, PCUEIMAGE);
1826
1827	/** @copydoc VDIMAGEBACKEND::pfnGetParentModificationUuid */
1828	VD_BACKEND_CALLBACK_GET_UUID_DEF_NOT_SUPPORTED(cueGetParentModificationUuid);
1829
1830	/** @copydoc VDIMAGEBACKEND::pfnSetParentModificationUuid */
1831	VD_BACKEND_CALLBACK_SET_UUID_DEF_NOT_SUPPORTED(cueSetParentModificationUuid, PCUEIMAGE);
1832
1833	/** @copydoc VDIMAGEBACKEND::pfnDump */
1834	static DECLCALLBACK(void) cueDump(void *pBackendData)
1835	{
1836	PCUEIMAGE pThis = (PCUEIMAGE)pBackendData;
1837
1838	AssertPtrReturnVoid(pThis);
1839	vdIfErrorMessage(pThis->pIfError, "Dumping CUE image \"%s\" mode=%s uOpenFlags=%X File=%#p\n",
1840	pThis->pszFilename,
1841	(pThis->uOpenFlags & VD_OPEN_FLAGS_READONLY) ? "r/o" : "r/w",
1842	pThis->uOpenFlags,
1843	pThis->pStorage);
1844	vdIfErrorMessage(pThis->pIfError, "Backing File \"%s\" File=%#p\n",
1845	pThis->pszDataFilename, pThis->pStorageData);
1846	vdIfErrorMessage(pThis->pIfError, "Number of tracks: %u\n", pThis->pRegionList->cRegions);
1847	for (uint32_t i = 0; i < pThis->pRegionList->cRegions; i++)
1848	{
1849	PCVDREGIONDESC pRegion = &pThis->pRegionList->aRegions[i];
1850
1851	vdIfErrorMessage(pThis->pIfError, "------------------------ Track %u ------------------------\n", i);
1852	vdIfErrorMessage(pThis->pIfError, "Start=%llu Size=%llu BlockSize=%llu DataSize=%llu MetadataSize=%llu\n",
1853	pRegion->offRegion, pRegion->cRegionBlocksOrBytes, pRegion->cbBlock, pRegion->cbData,
1854	pRegion->cbMetadata);
1855	vdIfErrorMessage(pThis->pIfError, "DataForm=%s MetadataForm=%s\n",
1856	cueRegionDataFormStringify(pRegion->enmDataForm),
1857	cueRegionMetadataFormStringify(pRegion->enmMetadataForm));
1858	}
1859	}
1860
1861
1862
1863	const VDIMAGEBACKEND g_CueBackend =
1864	{
1865	/* u32Version */
1866	VD_IMGBACKEND_VERSION,
1867	/* pszBackendName */
1868	"CUE",
1869	/* uBackendCaps */
1870	VD_CAP_FILE \| VD_CAP_VFS,
1871	/* paFileExtensions */
1872	s_aCueFileExtensions,
1873	/* paConfigInfo */
1874	NULL,
1875	/* pfnProbe */
1876	cueProbe,
1877	/* pfnOpen */
1878	cueOpen,
1879	/* pfnCreate */
1880	NULL,
1881	/* pfnRename */
1882	NULL,
1883	/* pfnClose */
1884	cueClose,
1885	/* pfnRead */
1886	cueRead,
1887	/* pfnWrite */
1888	cueWrite,
1889	/* pfnFlush */
1890	cueFlush,
1891	/* pfnDiscard */
1892	NULL,
1893	/* pfnGetVersion */
1894	cueGetVersion,
1895	/* pfnGetFileSize */
1896	cueGetFileSize,
1897	/* pfnGetPCHSGeometry */
1898	cueGetPCHSGeometry,
1899	/* pfnSetPCHSGeometry */
1900	cueSetPCHSGeometry,
1901	/* pfnGetLCHSGeometry */
1902	cueGetLCHSGeometry,
1903	/* pfnSetLCHSGeometry */
1904	cueSetLCHSGeometry,
1905	/* pfnQueryRegions */
1906	cueQueryRegions,
1907	/* pfnRegionListRelease */
1908	cueRegionListRelease,
1909	/* pfnGetImageFlags */
1910	cueGetImageFlags,
1911	/* pfnGetOpenFlags */
1912	cueGetOpenFlags,
1913	/* pfnSetOpenFlags */
1914	cueSetOpenFlags,
1915	/* pfnGetComment */
1916	cueGetComment,
1917	/* pfnSetComment */
1918	cueSetComment,
1919	/* pfnGetUuid */
1920	cueGetUuid,
1921	/* pfnSetUuid */
1922	cueSetUuid,
1923	/* pfnGetModificationUuid */
1924	cueGetModificationUuid,
1925	/* pfnSetModificationUuid */
1926	cueSetModificationUuid,
1927	/* pfnGetParentUuid */
1928	cueGetParentUuid,
1929	/* pfnSetParentUuid */
1930	cueSetParentUuid,
1931	/* pfnGetParentModificationUuid */
1932	cueGetParentModificationUuid,
1933	/* pfnSetParentModificationUuid */
1934	cueSetParentModificationUuid,
1935	/* pfnDump */
1936	cueDump,
1937	/* pfnGetTimestamp */
1938	NULL,
1939	/* pfnGetParentTimestamp */
1940	NULL,
1941	/* pfnSetParentTimestamp */
1942	NULL,
1943	/* pfnGetParentFilename */
1944	NULL,
1945	/* pfnSetParentFilename */
1946	NULL,
1947	/* pfnComposeLocation */
1948	genericFileComposeLocation,
1949	/* pfnComposeName */
1950	genericFileComposeName,
1951	/* pfnCompact */
1952	NULL,
1953	/* pfnResize */
1954	NULL,
1955	/* pfnRepair */
1956	NULL,
1957	/* pfnTraverseMetadata */
1958	NULL,
1959	/* u32VersionEnd */
1960	VD_IMGBACKEND_VERSION
1961	};

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

source: vbox/trunk/src/VBox/Storage/CUE.cpp@ 99749

Download in other formats: