kits/media/ParameterWeb.cpp

190 	const uint8 *buffer = static_cast<const uint8 *>(*_buffer);
191 	uint8 length = *buffer++;
199 	memcpy(string, buffer, length);
204 	*_buffer = static_cast<const void *>(buffer + length);
239 	uint8 *buffer = static_cast<uint8 *>(*_buffer);
244 	*buffer++ = static_cast<uint8>(length);
246 		memcpy(buffer, string, length);
247 		buffer += length;
250 	*_buffer = static_cast<void *>(buffer);
257 	const uint8 *buffer = static_cast<const uint8 *>(*_buffer);
259 	buffer += bytes;
261 	*_buffer = static_cast<const void *>(buffer);
322 size_left(ssize_t size, const void *bufferStart, const void *buffer)
324 	return size - static_cast<ssize_t>((const uint8 *)buffer - (const uint8 *)bufferStart);
504 BParameterWeb::Flatten(void* buffer, ssize_t size) const
508 	if (buffer == NULL)
515 	void* bufferStart = buffer;
517 	write_to_buffer<int32>(&buffer, kParameterWebMagic);
518 	write_to_buffer<int32>(&buffer, kCurrentParameterWebVersion);
520 	// flatten all groups into this buffer
523 	write_to_buffer<int32>(&buffer, count);
525 	write_to_buffer<media_node>(&buffer, fNode);
536 		if (groupSize > size_left(size, bufferStart, buffer)) {
537 			ERROR("BParameterWeb::Flatten(): buffer too small\n");
541 		write_to_buffer<ssize_t>(&buffer, groupSize);
544 		status_t status = group->Flatten(buffer, groupSize);
548 		skip_in_buffer(&buffer, groupSize);
563 BParameterWeb::Unflatten(type_code code, const void* buffer, ssize_t size)
572 	if (buffer == NULL) {
573 		ERROR("BParameterWeb::Unflatten(): NULL buffer pointer\n");
577 	// if the buffer is smaller than the size needed to read the
585 	const void* bufferStart = buffer;
587 	uint32 magic = read_from_buffer<uint32>(&buffer);
599 	int32 version = read_from_buffer_swap32<int32>(&buffer, isSwapped);
611 	int32 count = read_from_buffer_swap32<int32>(&buffer, isSwapped);
613 	fNode = read_from_buffer<media_node>(&buffer);
619 			= read_pointer_from_buffer_swap<ssize_t>(&buffer, isSwapped);
620 		if (groupSize > size_left(size, bufferStart, buffer)) {
621 			ERROR("BParameterWeb::Unflatten(): buffer too small\n");
626 		status_t status = group->Unflatten(group->TypeCode(), buffer,
634 		skip_in_buffer(&buffer, groupSize);
929 BParameterGroup::Flatten(void* buffer, ssize_t size) const
933 	if (buffer == NULL) {
934 		ERROR("BParameterGroup::Flatten buffer is NULL\n");
947 		write_to_buffer<int32>(&buffer, kBufferGroupMagic);
948 		write_to_buffer<uint32>(&buffer, fFlags);
950 		write_to_buffer<int32>(&buffer, kBufferGroupMagicNoFlags);
952 	write_string_to_buffer(&buffer, fName);
955 	write_to_buffer<int32>(&buffer, count);
964 		write_to_buffer<BParameter*>(&buffer, parameter);
965 		write_to_buffer<BParameter::media_parameter_type>(&buffer,
968 		// flatten parameter into this buffer
971 		write_to_buffer<ssize_t>(&buffer, parameterSize);
973 		status_t status = parameter->Flatten(buffer, parameterSize);
974 			// we have only that much bytes left to write in this buffer
978 		skip_in_buffer(&buffer, parameterSize);
982 	write_to_buffer<int32>(&buffer, count);
992 		write_to_buffer<BParameterGroup*>(&buffer, group);
993 		write_to_buffer<type_code>(&buffer, group->TypeCode());
995 		// flatten sub group into this buffer
998 		write_to_buffer<ssize_t>(&buffer, groupSize);
1000 		status_t status = group->Flatten(buffer, groupSize);
1001 			// we have only that much bytes left to write in this buffer
1005 		skip_in_buffer(&buffer, groupSize);
1020 BParameterGroup::Unflatten(type_code code, const void* buffer, ssize_t size)
1029 	if (buffer == NULL) {
1030 		ERROR("BParameterGroup::Unflatten() buffer is NULL\n");
1034 	// if the buffer is smaller than the size needed to read the
1041 	const void* bufferStart = buffer;
1042 		// used to compute the rest length of the buffer when needed
1044 	uint32 magic = read_from_buffer<uint32>(&buffer);
1054 		fFlags = read_from_buffer_swap32<int32>(&buffer, isSwapped);
1060 	if (read_string_from_buffer(&buffer, &fName,
1061 			size - (ssize_t)((uint8*)buffer - (uint8*)bufferStart)) < B_OK)
1077 	int32 count = read_from_buffer_swap32<int32>(&buffer, isSwapped);
1079 			> size_left(size, bufferStart, buffer))
1084 		if (size_left(size, bufferStart, buffer) < (ssize_t)(
1091 			&buffer, isSwapped);
1093 			= read_from_buffer_swap32<BParameter::media_parameter_type>(&buffer,
1096 		ssize_t parameterSize = read_pointer_from_buffer_swap<ssize_t>(&buffer,
1098 		if (parameterSize > size_left(size, bufferStart, buffer))
1107 		status_t status = parameter->Unflatten(parameter->TypeCode(), buffer,
1115 		skip_in_buffer(&buffer, parameterSize);
1129 	count = read_from_buffer_swap32<int32>(&buffer, isSwapped);
1131 			> size_left(size, bufferStart, buffer))
1136 		if (size_left(size, bufferStart, buffer) < (ssize_t)(
1143 			BParameterGroup*>(&buffer, isSwapped);
1144 		type_code type = read_from_buffer_swap32<type_code>(&buffer, isSwapped);
1147 			= read_pointer_from_buffer_swap<ssize_t>(&buffer, isSwapped);
1148 		if (groupSize > size_left(size, bufferStart, buffer))
1157 		status_t status = group->Unflatten(type, buffer, groupSize);
1164 		skip_in_buffer(&buffer, groupSize);
1276 BParameter::GetValue(void* buffer, size_t* _size, bigtime_t* _when)
1280 	if (buffer == NULL || _size == NULL)
1324 		// we don't want to copy more than the buffer provides
1328 		memcpy(buffer, data, size);
1349 BParameter::SetValue(const void* buffer, size_t size, bigtime_t when)
1353 	if (buffer == 0)
1388 	memcpy(data, buffer, size);
1558 BParameter::Flatten(void* buffer, ssize_t size) const
1562 	if (buffer == NULL) {
1563 		ERROR("BParameter::Flatten buffer is NULL\n");
1575 	write_to_buffer<uint32>(&buffer, kParameterMagic);
1576 	write_to_buffer<ssize_t>(&buffer, actualSize);
1577 	write_to_buffer<int32>(&buffer, fID);
1579 	write_string_to_buffer(&buffer, fName);
1580 	write_string_to_buffer(&buffer, fKind);
1581 	write_string_to_buffer(&buffer, fUnit);
1585 	write_to_buffer<ssize_t>(&buffer, count);
1588 		memcpy(buffer, fInputs->Items(), sizeof(BParameter*) * count);
1589 		skip_in_buffer(&buffer, sizeof(BParameter*) * count);
1594 	write_to_buffer<ssize_t>(&buffer, count);
1597 		memcpy(buffer, fOutputs->Items(), sizeof(BParameter*) * count);
1598 		skip_in_buffer(&buffer, sizeof(BParameter*) * count);
1601 	write_to_buffer<media_type>(&buffer, fMediaType);
1602 	write_to_buffer<int32>(&buffer, fChannels);
1603 	write_to_buffer<uint32>(&buffer, fFlags);
1617 BParameter::Unflatten(type_code code, const void* buffer, ssize_t size)
1626 	if (buffer == NULL) {
1627 		ERROR("BParameter::Unflatten(): buffer is NULL\n");
1631 	// if the buffer is smaller than the size needed to read the
1638 	const void* bufferStart = buffer;
1642 	uint32 magic = read_from_buffer<uint32>(&buffer);
1652 	ssize_t parameterSize = read_pointer_from_buffer_swap<ssize_t>(&buffer,
1655 		ERROR("BParameter::Unflatten(): buffer too small (%ld > %ld)\n",
1679 	fID = read_from_buffer_swap32<int32>(&buffer, fSwapDetected);
1681 	if (read_string_from_buffer(&buffer, &fName,
1682 				size_left(size, bufferStart, buffer)) < B_OK
1683 		|| read_string_from_buffer(&buffer, &fKind,
1684 				size_left(size, bufferStart, buffer)) < B_OK
1685 		|| read_string_from_buffer(&buffer, &fUnit,
1686 				size_left(size, bufferStart, buffer)) < B_OK)
1694 	ssize_t count = read_pointer_from_buffer_swap<ssize_t>(&buffer,
1700 			&buffer, fSwapDetected));
1705 	count = read_pointer_from_buffer_swap<ssize_t>(&buffer, fSwapDetected);
1710 			&buffer, fSwapDetected));
1713 	fMediaType = read_from_buffer_swap32<media_type>(&buffer, fSwapDetected);
1714 	fChannels = read_from_buffer_swap32<int32>(&buffer, fSwapDetected);
1715 	fFlags = read_from_buffer_swap32<uint32>(&buffer, fSwapDetected);
1882 BContinuousParameter::Flatten(void* buffer, ssize_t size) const
1886 	if (buffer == NULL) {
1887 		ERROR("BContinuousParameter::Flatten(): buffer is NULL\n");
1897 	status_t status = BParameter::Flatten(buffer, size);
1905 	skip_in_buffer(&buffer, parameterSize);
1907 	write_to_buffer<float>(&buffer, fMinimum);
1908 	write_to_buffer<float>(&buffer, fMaximum);
1909 	write_to_buffer<float>(&buffer, fStepping);
1910 	write_to_buffer<response>(&buffer, fResponse);
1911 	write_to_buffer<float>(&buffer, fFactor);
1912 	write_to_buffer<float>(&buffer, fOffset);
1919 BContinuousParameter::Unflatten(type_code code, const void* buffer,
1924 	// we try to check if the buffer size is long enough to hold an object
1932 	if (buffer == NULL) {
1933 		ERROR("BContinuousParameter::Unflatten buffer is NULL\n");
1937 	// if the buffer is smaller than the size needed to read the
1944 	status_t status = BParameter::Unflatten(code, buffer, size);
1952 	skip_in_buffer(&buffer, parameterSize);
1955 		ERROR("BContinuousParameter::Unflatten(): buffer too small\n");
1959 	fMinimum = read_from_buffer_swap32<float>(&buffer, SwapOnUnflatten());
1960 	fMaximum = read_from_buffer_swap32<float>(&buffer, SwapOnUnflatten());
1961 	fStepping = read_from_buffer_swap32<float>(&buffer, SwapOnUnflatten());
1962 	fResponse = read_from_buffer_swap32<response>(&buffer, SwapOnUnflatten());
1963 	fFactor = read_from_buffer_swap32<float>(&buffer, SwapOnUnflatten());
1964 	fOffset = read_from_buffer_swap32<float>(&buffer, SwapOnUnflatten());
2126 BDiscreteParameter::Flatten(void* buffer, ssize_t size) const
2130 	if (buffer == NULL) {
2131 		ERROR("BDiscreteParameter::Flatten(): buffer is NULL\n");
2142 	status_t status = BParameter::Flatten(buffer, size);
2148 	skip_in_buffer(&buffer, parameterSize);
2151 	write_to_buffer<int32>(&buffer, count);
2158 		write_string_to_buffer(&buffer, selection);
2159 		write_to_buffer<int32>(&buffer, value ? *value : 0);
2167 BDiscreteParameter::Unflatten(type_code code, const void* buffer, ssize_t size)
2176 	if (buffer == NULL) {
2177 		ERROR("BDiscreteParameter::Unflatten(): buffer is NULL\n");
2181 	// if the buffer is smaller than the size needed to read the
2188 	const void* bufferStart = buffer;
2190 	status_t status = BParameter::Unflatten(code, buffer, size);
2197 	skip_in_buffer(&buffer, parameterSize);
2200 		ERROR("BDiscreteParameter::Unflatten(): buffer too small\n");
2204 	int32 count = read_from_buffer_swap32<int32>(&buffer, SwapOnUnflatten());
2211 		if (read_string_from_buffer(&buffer, &name, size_left(size, bufferStart,
2212 				buffer)) < B_OK)
2215 		if (size_left(size, bufferStart, buffer) < (int)sizeof(int32)) {
2220 		int32 value = read_from_buffer_swap32<int32>(&buffer,
2278 BTextParameter::Flatten(void* buffer, ssize_t size) const
2280 	if (buffer == NULL) {
2281 		ERROR("BTextParameter::Flatten(): buffer is NULL\n");
2291 	status_t status = BParameter::Flatten(buffer, size);
2299 	skip_in_buffer(&buffer, parameterSize);
2301 	write_to_buffer<uint32>(&buffer, fMaxBytes);
2308 BTextParameter::Unflatten(type_code code, const void* buffer, ssize_t size)
2310 	// we try to check if the buffer size is long enough to hold an object
2318 	if (buffer == NULL) {
2319 		ERROR("BTextParameter::Unflatten buffer is NULL\n");
2328 	status_t status = BParameter::Unflatten(code, buffer, size);
2335 	skip_in_buffer(&buffer, parameterSize);
2338 		ERROR("BTextParameter::Unflatten(): buffer too small\n");
2342 	fMaxBytes = read_from_buffer_swap32<uint32>(&buffer, SwapOnUnflatten());
2381 BNullParameter::Flatten(void* buffer, ssize_t size) const
2383 	return BParameter::Flatten(buffer, size);
2388 BNullParameter::Unflatten(type_code code, const void* buffer, ssize_t size)
2390 	return BParameter::Unflatten(code, buffer, size);