CUE.cpp@ 67954

Last change on this file since 67954 was 67874, checked in by vboxsync, 7 years ago
Storage/CUE: Fixed VINF_SUCCESS when the file is too big, should return VERR_VD_INVALID_SIZE. CUE sometimes ended up with things it doesn't grok (no idea why this wasn't happen more frequently).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 63.7 KB

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

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

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

Download in other formats: