Navigation

← Previous Changeset
Next Changeset →

Changeset 203

Timestamp:

12/09/06 15:30:50 (2 years ago)

Author:

dconrad

Message:

Support for using data handlers that don't support 64-bit functions with Matroska.

Files:

trunk/DataHandlerCallback.cpp (modified) (11 diffs)
trunk/DataHandlerCallback.h (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/DataHandlerCallback.cpp

r119	r203
48	48	{
49	49	closeHandler = false;
50		mDataReader = mDataWriter = NULL;
	50	supportsWideOffsets = true;
	51	this->dataHandler = NULL;
	52	mCurrentPosition = 0;
	53	this->aMode = aMode;
51	54
52	55	switch (aMode)
53	56	{
54	57	case MODE_READ:
55		~~mDataReader = dataHandler;~~
56		~~break;~~
57
58	58	case MODE_WRITE:
59		~~mDataWrit~~er = dataHandler;
	59	this->dataHandler = dataHandler;
60	60	break;
61	61
…	…
65	65	}
66	66
67		mCurrentPosition = 0;
	67	// figure out if we support wide offesets
	68	getFileSize();
68	69	}
69	70
…	…
74	75
75	76	closeHandler = true;
76		mDataReader = mDataWriter = NULL;
77
78		switch (aMode)
79		{
80		case MODE_READ:
	77	supportsWideOffsets = true;
	78	dataHComponent = NULL;
	79	mCurrentPosition = 0;
	80	this->aMode = aMode;
	81
	82	if (aMode == MODE_READ)
81	83	dataHComponent = GetDataHandler(dataRef, dataRefType, kDataHCanRead);
82		err = OpenAComponent(dataHComponent, &mDataReader);
83		if (err) {
84		stringstream Msg;
85		Msg << "Error opening data handler component " << err;
86		throw CRTError(Msg.str());
87		}
88
89		err = DataHSetDataRef(mDataReader, dataRef);
90		if (err) {
91		stringstream Msg;
92		Msg << "Error setting data handler ref " << err;
93		throw CRTError(Msg.str());
94		}
95
96		err = DataHOpenForRead(mDataReader);
	84	else if (aMode == MODE_WRITE)
	85	dataHComponent = GetDataHandler(dataRef, dataRefType, kDataHCanWrite);
	86	else
	87	throw 0;
	88
	89	err = OpenAComponent(dataHComponent, &dataHandler);
	90	if (err) {
	91	stringstream Msg;
	92	Msg << "Error opening data handler component " << err;
	93	throw CRTError(Msg.str());
	94	}
	95
	96	err = DataHSetDataRef(dataHandler, dataRef);
	97	if (err) {
	98	stringstream Msg;
	99	Msg << "Error setting data handler ref " << err;
	100	throw CRTError(Msg.str());
	101	}
	102
	103	if (aMode == MODE_READ) {
	104	err = DataHOpenForRead(dataHandler);
97	105	if (err) {
98	106	stringstream Msg;
…	…
100	108	throw CRTError(Msg.str());
101	109	}
102
103		break;
104		case MODE_WRITE:
105		dataHComponent = GetDataHandler(dataRef, dataRefType, kDataHCanWrite);
106		err = OpenAComponent(dataHComponent, &mDataWriter);
107		if (err) {
108		stringstream Msg;
109		Msg << "Error opening data handler component " << err;
110		throw CRTError(Msg.str());
111		}
112
113		err = DataHSetDataRef(mDataWriter, dataRef);
114		if (err) {
115		stringstream Msg;
116		Msg << "Error setting data handler ref " << err;
117		throw CRTError(Msg.str());
118		}
119
120		err = DataHOpenForWrite(mDataWriter);
	110	} else if (aMode == MODE_WRITE) {
	111	err = DataHOpenForWrite(dataHandler);
121	112	if (err) {
122	113	stringstream Msg;
…	…
124	115	throw CRTError(Msg.str());
125	116	}
	117	} else {
	118	throw 0;
	119	}
	120
	121	// figure out if we support wide offesets
	122	getFileSize();
	123	}
	124
	125
	126	DataHandlerCallback::~DataHandlerCallback() throw()
	127	{
	128	close();
	129	}
	130
	131
	132
	133	uint32 DataHandlerCallback::read(void *Buffer, size_t Size)
	134	{
	135	assert(dataHandler != 0);
	136
	137	ComponentResult err = noErr;
	138
	139	if (supportsWideOffsets) {
	140	wide wideOffset = SInt64ToWide(mCurrentPosition);
126	141
127		break;
128		default:
129		throw 0;
130		}
131
132		mCurrentPosition = 0;
133		}
134
135
136		DataHandlerCallback::~DataHandlerCallback() throw()
137		{
138		close();
139		}
140
141
142
143		uint32 DataHandlerCallback::read(void *Buffer, size_t Size)
144		{
145		assert(mDataReader != 0);
146
147		ComponentResult err = noErr;
148		wide wideOffset = SInt64ToWide((SInt64) mCurrentPosition);
149
150		err = DataHScheduleData64(mDataReader, (Ptr)Buffer, &wideOffset, Size, 0, NULL, NULL);
	142	err = DataHScheduleData64(dataHandler, (Ptr)Buffer, &wideOffset, Size, 0, NULL, NULL);
	143	} else {
	144	err = DataHScheduleData(dataHandler, (Ptr)Buffer, mCurrentPosition, Size, 0, NULL, NULL);
	145	}
	146
151	147	if (err) {
152	148	stringstream Msg;
…	…
162	158	void DataHandlerCallback::setFilePointer(int64 Offset, LIBEBML_NAMESPACE::seek_mode Mode)
163	159	{
164		~~assert(mDataReader != NULL \|\| mDataWriter != NULL);~~
165
166	160	assert(Offset <= LONG_MAX);
167	161	assert(Offset >= LONG_MIN);
168	162
169	163	assert(Mode==SEEK_CUR\|\|Mode==SEEK_END\|\|Mode==SEEK_SET);
170
171		~~ComponentInstance dataHandler = mDataReader != NULL ? mDataReader : mDataWriter;~~
172	164
173	165	switch ( Mode )
…	…
178	170	case SEEK_END:
179	171	// I think this is what seeking this way does (was ftell(File))
180		wide filesize;
181		DataHGetFileSize64(dataHandler, &filesize);
182		mCurrentPosition = WideToSInt64(filesize) + Offset;
	172	mCurrentPosition = getFileSize() + Offset;
183	173	break;
184	174	case SEEK_SET:
…	…
190	180	size_t DataHandlerCallback::write(const void *Buffer, size_t Size)
191	181	{
192		assert(~~mDataWrit~~er != NULL);
	182	assert(dataHandler != NULL);
193	183
194	184	ComponentResult err = noErr;
195		wide wideOffset = SInt64ToWide((SInt64) mCurrentPosition);
196
197		err = DataHWrite64(mDataWriter, (Ptr)Buffer, &wideOffset, Size, NULL, 0);
	185
	186	if (supportsWideOffsets) {
	187	wide wideOffset = SInt64ToWide(mCurrentPosition);
	188
	189	err = DataHWrite64(dataHandler, (Ptr)Buffer, &wideOffset, Size, NULL, 0);
	190	} else {
	191	err = DataHWrite(dataHandler, (Ptr)Buffer, mCurrentPosition, Size, NULL, 0);
	192	}
	193
198	194	if (err) {
199	195	stringstream Msg;
…	…
209	205	uint64 DataHandlerCallback::getFilePointer()
210	206	{
211		assert(~~mDataReader != NULL \|\| mDataWrit~~er != NULL);
	207	assert(dataHandler != NULL);
212	208
213	209	return mCurrentPosition;
…	…
217	213	{
218	214	if (closeHandler) {
219		if (mDataReader) {
220		DataHCloseForRead(mDataReader);
221		mDataReader = NULL;
222		}
223		if (mDataWriter) {
224		DataHCloseForWrite(mDataWriter);
225		mDataWriter = NULL;
226		}
	215	if (aMode == MODE_READ)
	216	DataHCloseForRead(dataHandler);
	217	else if (aMode == MODE_WRITE)
	218	DataHCloseForWrite(dataHandler);
	219	dataHandler = NULL;
227	220	}
228	221	}
…	…
230	223	SInt64 DataHandlerCallback::getFileSize()
231	224	{
232		wide filesize;
233		if (mDataReader)
234		DataHGetFileSize64(mDataReader,&filesize);
235		else if (mDataWriter)
236		DataHGetFileSize64(mDataWriter,&filesize);
237
238		return WideToSInt64(filesize);
239		}
	225	ComponentResult err = noErr;
	226	SInt64 filesize;
	227	wide wideFilesize;
	228
	229	err = DataHGetFileSize64(dataHandler, &wideFilesize);
	230	if (err == noErr) {
	231	supportsWideOffsets = true;
	232	filesize = WideToSInt64(wideFilesize);
	233	} else {
	234	long size32;
	235	supportsWideOffsets = false;
	236	DataHGetFileSize(dataHandler, &size32);
	237	filesize = size32;
	238	}
	239
	240	return filesize;
	241	}

trunk/DataHandlerCallback.h

r174	r203
53	53	{
54	54	private:
55		ComponentInstance mDataReader;
56		ComponentInstance mDataWriter;
57		uint64 mCurrentPosition;
	55	ComponentInstance dataHandler;
	56	uint64 mCurrentPosition;
58	57	bool closeHandler;
	58	bool supportsWideOffsets;
	59	open_mode aMode;
59	60
60	61	public:

Navigation

Changeset 203

Legend:

trunk/DataHandlerCallback.cpp

trunk/DataHandlerCallback.h

Download in other formats: