Namespaces
namespace	detail
	interleaved_range_get_raw_data, planar_range_get_raw_data - return pointers to the raw data (the samples) of a basic homogeneous range.
Classes
struct	error_type
	A tag denoting incompatible arguments. More...
struct	binary_operation_obj
	A generic binary operation on rangesUse this class as a convenience superclass when defining an operation for any image ranges. More...
struct	bit_aligned_frame_iterator
	An iterator over non-byte-aligned frames. More...
struct	const_iterator_type< bit_aligned_frame_iterator< NonAlignedFrameReference > >
struct	iterator_is_mutable< bit_aligned_frame_iterator< NonAlignedFrameReference > >
struct	is_iterator_adaptor< bit_aligned_frame_iterator< NonAlignedFrameReference > >
struct	channel_space_type< bit_aligned_frame_iterator< NonAlignedFrameReference > >
struct	sample_mapping_type< bit_aligned_frame_iterator< NonAlignedFrameReference > >
struct	is_planar< bit_aligned_frame_iterator< NonAlignedFrameReference > >
struct	byte_to_memunit< bit_aligned_frame_iterator< NonAlignedFrameReference > >
struct	dynamic_step_type< bit_aligned_frame_iterator< NonAlignedFrameReference > >
struct	iterator_type_from_frame< const bit_aligned_frame_reference< B, C, L, M >, false, false, false >
struct	iterator_type_from_frame< const bit_aligned_frame_reference< B, C, L, M >, false, false, true >
struct	iterator_type_from_frame< bit_aligned_frame_reference< B, C, L, M >, IsPlanar, IsStep, IsMutable >
class	bit_range
	bit_range More...
struct	bit_aligned_frame_reference
	FrameBasedModel. More...
struct	kth_element_type< bit_aligned_frame_reference< BitField, SampleBitSizes, L, IsMutable >, K >
struct	kth_element_reference_type< bit_aligned_frame_reference< B, C, L, M >, K >
struct	kth_element_const_reference_type< bit_aligned_frame_reference< B, C, L, M >, K >
struct	is_frame< bit_aligned_frame_reference< B, C, L, M > >
	Metafunction predicate that flags bit_aligned_frame_reference as a model of FrameConcept. More...
struct	channel_space_type< bit_aligned_frame_reference< B, C, L, M > >
struct	sample_mapping_type< bit_aligned_frame_reference< B, C, L, M > >
struct	is_planar< bit_aligned_frame_reference< B, C, L, M > >
struct	frame_reference_type< const packed_dynamic_sample_reference< BitField, NumBits, false >, Layout, false, false >
struct	frame_reference_type< const packed_dynamic_sample_reference< BitField, NumBits, true >, Layout, false, true >
class	buffer
	container interface over buffer range. More...
struct	sample_type< buffer< Frame, IsPlanar, Alloc > >
struct	channel_space_type< buffer< Frame, IsPlanar, Alloc > >
struct	sample_mapping_type< buffer< Frame, IsPlanar, Alloc > >
struct	is_planar< buffer< Frame, IsPlanar, Alloc > >
class	buffer_range
	A lightweight object that interprets memory as a 1D array of frames. More...
struct	sample_type< buffer_range< I > >
struct	channel_space_type< buffer_range< I > >
struct	sample_mapping_type< buffer_range< I > >
struct	is_planar< buffer_range< I > >
struct	dynamic_step_type< buffer_range< L > >
class	channel_convert_deref_fn
struct	channel_converted_range_type
	Returns the type of a range that does channel conversion upon dereferencing its frames. More...
struct	nth_sample_range_type
	Given a source buffer range type Range, returns the type of an buffer range over a single sample of RangeIf the samples in the source range are adjacent in memory (such as planar non-step range or single-sample range) then the return range is a single-sample non-step range. More...
struct	kth_sample_range_type
	Given a source buffer range type Range, returns the type of an buffer range over a given sample of Range. More...
struct	kth_element_type< const ChannelBase, K >
struct	kth_element_reference_type< const ChannelBase, K >
struct	kth_element_const_reference_type< const ChannelBase, K >
struct	kth_element_type< detail::homogeneous_channel_base< Element, Layout, K1 >, K >
struct	kth_element_reference_type< detail::homogeneous_channel_base< Element, Layout, K1 >, K >
struct	kth_element_const_reference_type< detail::homogeneous_channel_base< Element, Layout, K1 >, K >
struct	size
	Returns an MPL integral type specifying the number of elements in a channel base. More...
struct	kth_semantic_element_type
	Specifies the type of the K-th semantic element of a channel base. More...
struct	kth_semantic_element_reference_type
	Specifies the return type of the mutable semantic_at_c<K>(channel_base);. More...
struct	kth_semantic_element_const_reference_type
	Specifies the return type of the constant semantic_at_c<K>(channel_base);. More...
struct	contains_channel
	A predicate metafunction determining whether a given channel base contains a given channel. More...
struct	channel_index_type
struct	channel_element_type
	Specifies the type of the element associated with a given channel tag. More...
struct	channel_element_reference_type
	Specifies the return type of the mutable element accessor by channel name, get_channel(channel_base, Channel());. More...
struct	channel_element_const_reference_type
	Specifies the return type of the constant element accessor by channel name, get_channel(channel_base, Channel());. More...
struct	element_type
	Specifies the element type of a homogeneous channel base. More...
struct	element_reference_type
	Specifies the return type of the mutable element accessor sound::at_c of a homogeneous channel base. More...
struct	element_const_reference_type
	Specifies the return type of the constant element accessor sound::at_c of a homogeneous channel base. More...
struct	default_channel_converter_impl
	Channel Convertion function object. More...
struct	default_channel_converter_impl< C, C >
	When the channel space is the same, channel convertion performs sample depth conversion. More...
struct	default_channel_converter_impl< mono_space, stereo_space >
	Mono to Stereo. More...
struct	default_channel_converter_impl< stereo_space, mono_space >
	Stereo to Mono. More...
struct	default_channel_converter
struct	ChannelSpaceConcept
	Channel space type concept. More...
struct	channel_spaces_are_compatible
struct	ChannelSpacesCompatibleConcept
	Two channel spaces are compatible if they are the same. More...
struct	SampleMappingConcept
	Sample mapping concept. More...
struct	SampleConcept
	A sample is the building block of a channel. More...
struct	MutableSampleConcept
	A sample that allows for modifying its value. More...
struct	SampleValueConcept
	A sample that supports default construction. More...
struct	samples_are_compatible
	Predicate metafunction returning whether two samples are compatibleSamples are considered compatible if their value types (ignoring constness and references) are the same. More...
struct	SamplesCompatibleConcept
	Samples are compatible if their associated value types (ignoring constness and references) are the same. More...
struct	SampleConvertibleConcept
	A sample is convertible to another one if the `sample_convert` algorithm is defined for the two samples. More...
struct	ChannelBaseConcept
	Channel Base Concepts. More...
struct	MutableChannelBaseConcept
	Channel base which allows for modifying its elements. More...
struct	ChannelBaseValueConcept
	Channel base that also has a default-constructor. More...
struct	HomogeneousChannelBaseConcept
	Channel base whose elements all have the same type. More...
struct	MutableHomogeneousChannelBaseConcept
	Homogeneous channel base that allows for modifying its elements. More...
struct	HomogeneousChannelBaseValueConcept
	Homogeneous channel base that also has a default constructor. More...
struct	ChannelBasesCompatibleConcept
	Two channel bases are compatible if they have the same channel space and their elements are compatible, semantic-pairwise. More...
struct	FrameBasedConcept
	Concept for all frame-based Psynth constructs, such as frames, iterators, ranges and buffers whose value type is a frame. More...
struct	HomogeneousFrameBasedConcept
	Concept for homogeneous frame-based Psynth constructs. More...
struct	FrameConcept
	A set of samples coincidents in time. More...
struct	MutableFrameConcept
	Frame concept that allows for changing its samples. More...
struct	HomogeneousFrameConcept
	Homogeneous frame concept. More...
struct	MutableHomogeneousFrameConcept
	Homogeneous frame concept that allows for changing its samples. More...
struct	FrameValueConcept
	Frame concept that is a base::Regular type. More...
struct	HomogeneousFrameValueConcept
	Homogeneous frame concept that is a base::Regular type. More...
struct	frames_are_compatible
	Returns whether two frames are compatible. More...
struct	FramesCompatibleConcept
	Concept for frame compatibility. More...
struct	FrameConvertibleConcept
	Frame convertible concept. More...
struct	FrameDereferenceAdaptorConcept
	Represents a unary function object that can be invoked upon dereferencing a frame iterator. More...
struct	FrameDereferenceAdaptorArchetype
struct	HasDynamicStepTypeConcept
	Concept for iterators, locators and ranges that can define a type just like the given iterator/locator/range, except it supports runtime specified step along the X navigation. More...
struct	FrameIteratorConcept
	Psynth's iterators must also provide the following metafunctions: More...
struct	MutableFrameIteratorConcept
	Frame iterator that allows for changing its frame. More...
struct	MemoryBasedIteratorConcept
struct	StepIteratorConcept
	Step iterator concept. More...
struct	MutableStepIteratorConcept
	Step iterator that allows for modifying its current value. More...
struct	IteratorAdaptorConcept
	In addition to Psynth iterator requirements, Psynth iterator adaptors must provide the following metafunctions: More...
struct	MutableIteratorAdaptorConcept
	Iterator adaptor that is mutable. More...
struct	RandomAccessBufferRangeConcept
struct	BufferRangeConcept
	Psynth's 1-dimensional range over immutable Psynth frames. More...
struct	MutableRandomAccessBufferRangeConcept
	N-dimensional range over mutable values. More...
struct	MutableBufferRangeConcept
	Psynth's 2-dimensional range over mutable Psynth frames. More...
struct	ranges_are_compatible
	Returns whether two ranges are compatible. More...
struct	RangesCompatibleConcept
	Ranges are compatible if they have the same channel spaces and compatible sample values. More...
struct	RandomAccessBufferConcept
	N-dimensional container of values. More...
struct	BufferConcept
	2-dimensional buffer whose value type models FrameValueConcept More...
struct	devicen_channel
	unnamed color More...
struct	devicen_space< 1 >
	unnamed color space of one channel More...
struct	devicen_space< 2 >
	unnamed color space of two channels More...
struct	devicen_space< 3 >
	unnamed color space of three channels More...
struct	devicen_space< 4 >
	unnamed color space of four channels More...
struct	devicen_space< 5 >
	unnamed color space of five channels More...
struct	devicen_layout
	unnamed color layout of up to five channels More...
class	dynamic_buffer
	Represents a run-time specified buffer. More...
class	dynamic_buffer_range
	Represents a run-time specified buffer range. More...
struct	dynamic_step_type< dynamic_buffer_range< IVTypes > >
struct	nth_sample_range_type< dynamic_buffer_range< RangeTypes > >
	Given a runtime source buffer range, returns the type of a runtime buffer range over a single sample of the source range. More...
struct	channel_converted_range_type< dynamic_buffer_range< RangeTypes >, DstP, CC >
	Returns the type of a runtime-specified range, channel-converted to a given frame type with user specified channel converter. More...
struct	channel_converted_range_type< dynamic_buffer_range< RangeTypes >, DstP >
	Returns the type of a runtime-specified range, channel-converted to a given frame type with the default coor converter. More...
class	dynamic_ring_buffer
class	dynamic_ring_buffer_range
struct	remove_const_and_reference
struct	channel_space_type< const FrameBased >
struct	sample_mapping_type< const FrameBased >
struct	sample_type< const FrameBased >
struct	is_planar< const FrameBased >
struct	is_frame
struct	is_frame< const T >
struct	num_samples
	Returns the number of samples of a frame-based GIL construct. More...
struct	frame
struct	kth_element_type< frame< SampleValue, Layout >, K >
struct	kth_element_reference_type< frame< SampleValue, Layout >, K >
struct	kth_element_reference_type< const frame< SampleValue, Layout >, K >
struct	kth_element_const_reference_type< frame< SampleValue, Layout >, K >
struct	is_frame< frame< SampleValue, Layout > >
struct	channel_space_type< frame< SampleValue, Layout > >
struct	sample_mapping_type< frame< SampleValue, Layout > >
struct	is_planar< frame< SampleValue, Layout > >
struct	sample_type< frame< SampleValue, Layout > >
struct	is_iterator_adaptor
	metafunction predicate determining whether the given iterator is a plain one or an adaptor over another iterator. More...
struct	const_iterator_type< T * >
	The default implementation when the iterator is a C pointer is to use the standard constness semantics. More...
struct	const_iterator_type< const T * >
struct	iterator_is_mutable
	Metafunction predicate returning whether the given iterator allows for changing its values. More...
struct	iterator_is_mutable< T * >
	The default implementation when the iterator is a C pointer is to use the standard constness semantics. More...
struct	iterator_is_mutable< const T * >
struct	dynamic_step_type< Frame * >
struct	dynamic_step_type< const Frame * >
struct	channel_space_type< Frame * >
struct	channel_space_type< const Frame * >
struct	sample_mapping_type< Frame * >
struct	sample_mapping_type< const Frame * >
struct	is_planar< Frame * >
struct	is_planar< const Frame * >
struct	sample_type< Frame * >
struct	sample_type< const Frame * >
struct	byte_to_memunit
	Support for frame iterator movement measured in memory units (bytes or bits) as opposed to frame type. More...
class	dereference_iterator_adaptor
	An adaptor over an existing iterator that provides for custom filter on dereferencing the object. More...
struct	const_iterator_type< dereference_iterator_adaptor< I, DFn > >
struct	iterator_is_mutable< dereference_iterator_adaptor< I, DFn > >
struct	is_iterator_adaptor< dereference_iterator_adaptor< I, DFn > >
struct	iterator_adaptor_get_base< dereference_iterator_adaptor< I, DFn > >
struct	iterator_adaptor_rebind< dereference_iterator_adaptor< I, DFn >, NewBaseIterator >
struct	channel_space_type< dereference_iterator_adaptor< I, DFn > >
struct	sample_mapping_type< dereference_iterator_adaptor< I, DFn > >
struct	is_planar< dereference_iterator_adaptor< I, DFn > >
struct	sample_type< dereference_iterator_adaptor< I, DFn > >
struct	byte_to_memunit< dereference_iterator_adaptor< Iterator, DFn > >
struct	dynamic_step_type< dereference_iterator_adaptor< Iterator, DFn > >
struct	iterator_add_deref
	Returns the type (and creates an instance) of an iterator that invokes the given dereference adaptor upon dereferencing. More...
struct	iterator_add_deref< dereference_iterator_adaptor< Iterator, PrevDeref >, Deref >
	For dereference iterator adaptors, compose the new function object after the old one. More...
struct	frame_reference_is_basic
struct	frame_reference_is_basic< frame< T, L > & >
struct	frame_reference_is_basic< const frame< T, L > & >
struct	frame_reference_is_basic< planar_frame_reference< TR, Cs > >
struct	frame_reference_is_basic< const planar_frame_reference< TR, Cs > >
struct	iterator_is_basic
	Determines if a given frame iterator is basic. More...
struct	iterator_is_basic< frame< T, L > * >
struct	iterator_is_basic< const frame< T, L > * >
struct	iterator_is_basic< planar_frame_iterator< T *, Cs > >
struct	iterator_is_basic< planar_frame_iterator< const T *, Cs > >
struct	iterator_is_basic< memory_based_step_iterator< frame< T, L > * > >
struct	iterator_is_basic< memory_based_step_iterator< const frame< T, L > * > >
struct	iterator_is_basic< memory_based_step_iterator< planar_frame_iterator< T *, Cs > > >
struct	iterator_is_basic< memory_based_step_iterator< planar_frame_iterator< const T *, Cs > > >
struct	range_is_basic
	Basic ranges must be over basic locators. More...
struct	range_is_basic< buffer_range< Loc > >
struct	buffer_is_basic
	Basic buffers must use basic ranges and std::allocator of char. More...
struct	buffer_is_basic< buffer< Frame, IsPlanar, Alloc > >
struct	iterator_is_step
	Determines if the given iterator has a step that could be set dynamically. More...
struct	range_is_step
	Determines if the given locator has a step that can be set dynamically. More...
struct	frame_reference_is_proxy
	Determines whether the given frame reference is a proxy class or a native C++ reference. More...
struct	frame_is_reference
	Given a model of a frame, determines whether the model represents a frame reference (as opposed to frame value) More...
struct	frame_reference_is_mutable
	Determines if the given frame reference is mutable (i.e. More...
struct	frame_reference_is_mutable< const R & >
struct	range_is_mutable
	Determines if the given range is mutable (i.e. More...
struct	frame_reference_type
struct	frame_reference_type< T, L, false, true >
struct	frame_reference_type< T, L, false, false >
struct	frame_reference_type< T, L, true, true >
struct	frame_reference_type< T, L, true, false >
struct	iterator_type_from_frame
	Returns the type of a frame iterator given the frame type, whether it operates on planar data, whether it is a step iterator, and whether it is mutable. More...
struct	iterator_type_from_frame< Frame, false, false, true >
struct	iterator_type_from_frame< Frame, false, false, false >
struct	iterator_type_from_frame< Frame, true, false, true >
struct	iterator_type_from_frame< Frame, true, false, false >
struct	iterator_type_from_frame< Frame, IsPlanar, true, IsMutable >
struct	iterator_type
	Returns the type of a homogeneous iterator given the sample type, layout, whether it operates on planar data, whether it is a step iterator, and whether it is mutable. More...
struct	iterator_type< T, L, false, false, true >
struct	iterator_type< T, L, false, false, false >
struct	iterator_type< T, L, true, false, true >
struct	iterator_type< T, L, true, false, false >
struct	iterator_type< T, L, IsPlanar, true, IsMutable >
struct	type_from_iterator
	Given a frame iterator defining access to frames along a row, returns the types of the corresponding built-in step_iterator, xy_locator, buffer_range. More...
struct	packed_frame_type
	Returns the type of a packed frame given its bitfield type, the bit size of its samples and its layout. More...
struct	packed_buffer_type
struct	packed_buffer1_type
	Returns the type of a single-sample buffer given its bitfield type, the bit size of its sample and its layout. More...
struct	packed_buffer2_type
	Returns the type of a two sample buffer given its bitfield type, the bit size of its samples and its layout. More...
struct	packed_buffer3_type
	Returns the type of a three sample buffer given its bitfield type, the bit size of its samples and its layout. More...
struct	packed_buffer4_type
	Returns the type of a four sample buffer given its bitfield type, the bit size of its samples and its layout. More...
struct	packed_buffer5_type
	Returns the type of a five sample buffer given its bitfield type, the bit size of its samples and its layout. More...
struct	bit_aligned_buffer_type
	Returns the type of a packed buffer whose frames may not be byte aligned. More...
struct	bit_aligned_buffer1_type
	Returns the type of a single-sample bit-aligned buffer given the bit size of its sample and its layout. More...
struct	bit_aligned_buffer2_type
	Returns the type of a two sample bit-aligned buffer given the bit size of its samples and its layout. More...
struct	bit_aligned_buffer3_type
	Returns the type of a three sample bit-aligned buffer given the bit size of its samples and its layout. More...
struct	bit_aligned_buffer4_type
	Returns the type of a four sample bit-aligned buffer given the bit size of its samples and its layout. More...
struct	bit_aligned_buffer5_type
	Returns the type of a five sample bit-aligned buffer given the bit size of its samples and its layout. More...
struct	frame_value_type
	Returns the type of a homogeneous frame given the sample type and layout. More...
struct	frame_value_type< packed_dynamic_sample_reference< BitField, NumBits, IsMutable >, Layout >
struct	frame_value_type< const packed_dynamic_sample_reference< BitField, NumBits, IsMutable >, Layout >
struct	frame_value_type< packed_sample_reference< BitField, FirstBit, NumBits, IsMutable >, Layout >
struct	frame_value_type< const packed_sample_reference< BitField, FirstBit, NumBits, IsMutable >, Layout >
struct	frame_value_type< packed_sample_value< NumBits >, Layout >
struct	range_type
	Returns the type of a homogeneous range given the sample type, layout, whether it operates on planar data and whether it has a step horizontally. More...
struct	buffer_type
	Returns the type of a homogeneous buffer given the sample type, layout, and whether it operates on planar data. More...
struct	range_type_from_frame
	Returns the type of a range the frame type, whether it operates on planar data and whether it has a step horizontally. More...
class	derived_frame_reference_type
	Constructs a frame reference type from a source frame reference type by changing some of the properties. More...
class	derived_iterator_type
	Constructs a frame iterator type from a source frame iterator type by changing some of the properties. More...
class	derived_range_type
	Constructs an buffer range type from a source range type by changing some of the properties. More...
class	derived_buffer_type
	Constructs a homogeneous buffer type from a source buffer type by changing some of the properties. More...
struct	buffer_range_type
	Returns the buffer_range type of a Range. More...
struct	buffer_range_type< buffer< Frame, Planar, Alloc > >
struct	buffer_from_range
	Returns a buffer type that can hold data of a given buffer_range type with the same representation. More...
struct	mono_channel
	mono_channel More...
struct	packed_frame
	Heterogeneous frame value whose sample references can be constructed from the frame bitfield and their index. More...
struct	kth_element_type< packed_frame< BitField, SampleRefVec, Layout >, K >
struct	kth_element_reference_type< packed_frame< BitField, SampleRefVec, Layout >, K >
struct	kth_element_const_reference_type< packed_frame< BitField, SampleRefVec, Layout >, K >
struct	is_frame< packed_frame< BitField, SampleRefVec, Layout > >
struct	channel_space_type< packed_frame< P, C, Layout > >
struct	sample_mapping_type< packed_frame< P, C, Layout > >
struct	is_planar< packed_frame< P, C, Layout > >
struct	iterator_is_mutable< packed_frame< P, C, L > * >
struct	iterator_is_mutable< const packed_frame< P, C, L > * >
struct	planar_frame_iterator
	An iterator over planar frames. More...
struct	const_iterator_type< planar_frame_iterator< IC, C > >
struct	iterator_is_mutable< planar_frame_iterator< IC, C > >
	The default implementation when the iterator is a C pointer is to use the standard constness semantics. More...
struct	kth_element_type< planar_frame_iterator< IC, C >, K >
struct	kth_element_reference_type< planar_frame_iterator< IC, C >, K >
struct	kth_element_const_reference_type< planar_frame_iterator< IC, C >, K >
struct	channel_space_type< planar_frame_iterator< IC, C > >
struct	sample_mapping_type< planar_frame_iterator< IC, C > >
struct	is_planar< planar_frame_iterator< IC, C > >
struct	sample_type< planar_frame_iterator< IC, C > >
struct	memunit_advance_fn
struct	dynamic_step_type< planar_frame_iterator< IC, C > >
struct	planar_frame_reference
	FrameBasedModel. More...
struct	kth_element_type< planar_frame_reference< SampleReference, ChannelSpace >, K >
struct	kth_element_reference_type< planar_frame_reference< SampleReference, ChannelSpace >, K >
struct	kth_element_const_reference_type< planar_frame_reference< SampleReference, ChannelSpace >, K >
struct	is_frame< planar_frame_reference< SampleReference, ChannelSpace > >
	Metafunction predicate that flags planar_frame_reference as a model of FrameConcept. More...
struct	channel_space_type< planar_frame_reference< SampleReference, ChannelSpace > >
	Specifies the channel space type of a planar frame reference. More...
struct	sample_mapping_type< planar_frame_reference< SampleReference, ChannelSpace > >
	Specifies the channel space type of a planar frame reference. More...
struct	is_planar< planar_frame_reference< SampleReference, ChannelSpace > >
	Specifies that planar_frame_reference represents a planar construct. More...
struct	sample_type< planar_frame_reference< SampleReference, ChannelSpace > >
	Specifies the channel space type of a planar frame reference. More...
struct	back_left_channel
struct	back_right_channel
	Back Right. More...
class	ring_buffer_base
class	ring_buffer
struct	sample_type< ring_buffer< Buffer > >
struct	channel_space_type< ring_buffer< Buffer > >
struct	sample_mapping_type< ring_buffer< Buffer > >
struct	is_planar< ring_buffer< Buffer > >
class	ring_buffer_range_base
class	ring_buffer_range
struct	const_ring_buffer_range
struct	sample_type< ring_buffer_range< Range > >
struct	channel_space_type< ring_buffer_range< Range > >
struct	sample_mapping_type< ring_buffer_range< Range > >
struct	is_planar< ring_buffer_range< Range > >
class	sample_traits
	Traits for samples. More...
struct	sample_traits< T & >
struct	sample_traits< const T & >
struct	scoped_sample_value
	A sample adaptor that modifies the range of the source sample. More...
struct	float_zero
struct	float_one
struct	float_minus_one
struct	float_half
class	packed_sample_value
	The value of a subbyte sample. More...
class	packed_sample_reference< BitField, FirstBit, NumBits, false >
	A constant subbyte sample reference whose bit offset is fixed at compile time. More...
class	packed_sample_reference< BitField, FirstBit, NumBits, true >
	A mutable subbyte sample reference whose bit offset is fixed at compile time. More...
class	packed_dynamic_sample_reference< BitField, NumBits, false >
	Models a constant subbyte sample reference whose bit offset is a runtime parameter. More...
class	packed_dynamic_sample_reference< BitField, NumBits, true >
	Models a mutable subbyte sample reference whose bit offset is a runtime parameter. More...
struct	sample_converter_unsigned
	sample_converter_unsigned More...
struct	sample_converter_unsigned< T, T >
	Converting a sample to itself - identity operation. More...
struct	sample_converter_unsigned< bits32f, DstSampleV >
	bits32f conversion More...
struct	sample_converter_unsigned< SrcSampleV, bits32f >
struct	sample_converter_unsigned< bits32f, bits32f >
struct	sample_converter_unsigned< bits32, bits32f >
	32 bit <-> float sample conversion More...
struct	sample_converter_unsigned< bits32f, bits32 >
	32 bit <-> float sample conversion More...
struct	sample_converter
	A unary function object converting between sample types. More...
struct	default_sample_converter
	Same as sample_converter, except it takes the destination sample by reference, which allows us to move the templates from the class level to the method level. More...
struct	sample_multiplier_unsigned
	This is the default implementation. Performance specializatons are provided. More...
struct	sample_multiplier_unsigned< bits8 >
	Specialization of sample_multiply for 8-bit unsigned samples. More...
struct	sample_multiplier_unsigned< bits16 >
	Specialization of sample_multiply for 16-bit unsigned samples. More...
struct	sample_multiplier_unsigned< bits32f >
	Specialization of sample_multiply for float 0..1 samples. More...
struct	sample_multiplier
	A function object to multiply two samples. More...
struct	sample_multiplier< bits32f >
struct	memunit_step_fn
	function object that returns the memory unit distance between two iterators and advances a given iterator a given number of mem units (bytes or bits) More...
class	memory_based_step_iterator
	Iterator with dynamically specified step in memory units (bytes or bits). More...
struct	const_iterator_type< memory_based_step_iterator< Iterator > >
struct	iterator_is_mutable< memory_based_step_iterator< Iterator > >
struct	is_iterator_adaptor< memory_based_step_iterator< Iterator > >
struct	iterator_adaptor_get_base< memory_based_step_iterator< Iterator > >
struct	iterator_adaptor_rebind< memory_based_step_iterator< Iterator >, NewBaseIterator >
struct	channel_space_type< memory_based_step_iterator< Iterator > >
struct	sample_mapping_type< memory_based_step_iterator< Iterator > >
struct	is_planar< memory_based_step_iterator< Iterator > >
struct	sample_type< memory_based_step_iterator< Iterator > >
struct	byte_to_memunit< memory_based_step_iterator< Iterator > >
struct	dynamic_step_type< memory_based_step_iterator< Iterator > >
struct	iterator_add_deref< memory_based_step_iterator< Iterator >, Deref >
struct	left_channel
struct	right_channel
	Right. More...
struct	center_channel
	Center. More...
struct	deref_base
	Helper base class for pixel dereference adaptors. More...
class	deref_compose
	Composes two dereference function objects. More...
struct	layout
	Represents a channel space and ordering of samples in memory. More...
class	variant
	Represents a concrete instance of a run-time specified type from a set of types. More...
Typedefs
typedef boost::mpl::vector1 < mono_channel >	mono_space
typedef layout< mono_space >	mono_layout
typedef boost::mpl::vector4 < left_channel, right_channel, back_left_channel, back_right_channel >	quad_space
typedef layout< quad_space >	quad_layout
typedef boost::uint8_t	bits8
typedef boost::uint16_t	bits16
typedef boost::uint32_t	bits32
typedef boost::int8_t	bits8s
typedef boost::int16_t	bits16s
typedef boost::int32_t	bits32s
typedef scoped_sample_value < float, float_zero, float_one, float_half >	bits32f
typedef scoped_sample_value < float, float_minus_one, float_one, float_zero >	bits32sf
typedef boost::mpl::vector2 < left_channel, right_channel >	stereo_space
typedef layout< stereo_space >	stereo_layout
typedef layout< stereo_space, boost::mpl::vector2_c< int, 1, 0 > >	rlstereo_layout
typedef boost::mpl::vector5 < left_channel, right_channel, center_channel, back_right_channel, back_left_channel >	surround_space
typedef layout< surround_space >	surround_layout
Enumerations
enum	ring_buffer_error { none, underrun, overrun }
	Error codes for a read pointer. More...
Functions
template<typename Range1 , typename Range2 >
PSYNTH_FORCEINLINE void	copy_frames (const Range1 &src, const Range2 &dst)
	std::copy for image ranges
template<typename V1 , typename V2 , typename CC >
PSYNTH_FORCEINLINE void	copy_and_convert_frames (const V1 &src, const V2 &dst, CC cc)
template<typename Range1 , typename Range2 >
PSYNTH_FORCEINLINE void	copy_and_convert_frames (const Range1 &src, const Range2 &dst)
template<typename Range , typename Value >
PSYNTH_FORCEINLINE void	fill_frames (const Range &buf_range, const Value &val)
	std::fill for image ranges
template<typename Range , typename Value >
PSYNTH_FORCEINLINE void	fill_frames (Range &buf_range, const Value &val)
	std::fill for image ranges
template<typename Range >
PSYNTH_FORCEINLINE void	destruct_frames (const Range &buf_range)
	Invokes the in-place destructor on every frame of the range.
template<typename Range , typename Value >
PSYNTH_FORCEINLINE void	uninitialized_fill_frames (const Range &buf_range, const Value &val)
	std::uninitialized_fill for image ranges.
template<typename Range >
PSYNTH_FORCEINLINE void	default_construct_frames (const Range &buf_range)
	Invokes the in-place default constructor on every frame of the (uninitialized) range.
template<typename Range1 , typename Range2 >
PSYNTH_FORCEINLINE void	uninitialized_copy_frames (const Range1 &range1, const Range2 &range2)
	std::uninitialized_copy for image ranges.
template<typename V , typename F >
PSYNTH_FORCEINLINE F	for_each_frame (const V &buf, F fun)
template<typename Range , typename F >
PSYNTH_FORCEINLINE F	for_each_frame_position (const Range &buf, F fun)
template<typename Range , typename F >
PSYNTH_FORCEINLINE void	generate_frames (const Range &v, F fun)
template<typename I1 , typename I2 >
PSYNTH_FORCEINLINE bool	equal_n (I1 i1, std::ptrdiff_t n, I2 i2)
template<typename Range1 , typename Range2 >
PSYNTH_FORCEINLINE bool	equal_frames (const Range1 &v1, const Range2 &v2)
	std::equal for image ranges
template<typename Range1 , typename Range2 , typename F >
PSYNTH_FORCEINLINE F	transform_frames (const Range1 &src, const Range2 &dst, F fun)
template<typename Range1 , typename Range2 , typename Range3 , typename F >
PSYNTH_FORCEINLINE F	transform_frames (const Range1 &src1, const Range2 &src2, const Range3 &dst, F fun)
	transform_frames with two sources
template<typename Range1 , typename Range2 , typename F >
PSYNTH_FORCEINLINE F	transform_frame_positions (const Range1 &src, const Range2 &dst, F fun)
template<typename Range1 , typename Range2 , typename Range3 , typename F >
PSYNTH_FORCEINLINE F	transform_frame_positions (const Range1 &src1, const Range2 &src2, const Range3 &dst, F fun)
	transform_frame_positions with two sources
template<typename Types , typename UnaryOp >
PSYNTH_FORCEINLINE UnaryOp::result_type	apply_operation (variant< Types > &arg, UnaryOp op)
	Invokes a generic mutable operation (represented as a unary function object) on a variant.
template<typename Types , typename UnaryOp >
PSYNTH_FORCEINLINE UnaryOp::result_type	apply_operation (const variant< Types > &arg, UnaryOp op)
	Invokes a generic constant operation (represented as a unary function object) on a variant.
template<typename Types1 , typename Types2 , typename BinaryOp >
PSYNTH_FORCEINLINE BinaryOp::result_type	apply_operation (const variant< Types1 > &arg1, const variant< Types2 > &arg2, BinaryOp op)
	Invokes a generic constant operation (represented as a binary function object) on two variants.
template<typename Types , typename Bits , typename Op >
Op::result_type PSYNTH_FORCEINLINE	apply_operation_basec (const Bits &bits, std::size_t index, Op op)
template<typename Types , typename Bits , typename Op >
Op::result_type PSYNTH_FORCEINLINE	apply_operation_base (Bits &bits, std::size_t index, Op op)
template<typename NonAlignedFrameReference >
std::ptrdiff_t	memunit_step (const bit_aligned_frame_iterator< NonAlignedFrameReference > &)
template<typename NonAlignedFrameReference >
std::ptrdiff_t	memunit_distance (const bit_aligned_frame_iterator< NonAlignedFrameReference > &p1, const bit_aligned_frame_iterator< NonAlignedFrameReference > &p2)
template<typename NonAlignedFrameReference >
void	memunit_advance (bit_aligned_frame_iterator< NonAlignedFrameReference > &p, std::ptrdiff_t diff)
template<typename NonAlignedFrameReference >
bit_aligned_frame_iterator < NonAlignedFrameReference >	memunit_advanced (const bit_aligned_frame_iterator< NonAlignedFrameReference > &p, std::ptrdiff_t diff)
template<typename NonAlignedFrameReference >
NonAlignedFrameReference	memunit_advanced_ref (bit_aligned_frame_iterator< NonAlignedFrameReference > it, std::ptrdiff_t diff)
template<int K, typename BitField , typename SampleBitSizes , typename L , bool Mutable>
kth_element_reference_type < bit_aligned_frame_reference < BitField, SampleBitSizes, L, Mutable >, K >::type	at_c (const bit_aligned_frame_reference< BitField, SampleBitSizes, L, Mutable > &p)
	at_c required by MutableChannelBaseConcept
template<typename Frame , bool IsPlanar, typename Alloc >
void	swap (buffer< Frame, IsPlanar, Alloc > &buf1, buffer< Frame, IsPlanar, Alloc > &buf2)
template<typename Frame1 , bool IsPlanar1, typename Alloc1 , typename Frame2 , bool IsPlanar2, typename Alloc2 >
bool	operator== (const buffer< Frame1, IsPlanar1, Alloc1 > &buf1, const buffer< Frame2, IsPlanar2, Alloc2 > &buf2)
template<typename Frame1 , bool IsPlanar1, typename Alloc1 , typename Frame2 , bool IsPlanar2, typename Alloc2 >
bool	operator!= (const buffer< Frame1, IsPlanar1, Alloc1 > &buf1, const buffer< Frame2, IsPlanar2, Alloc2 > &buf2)
template<typename I2 >
void	swap (buffer_range< I2 > &x, buffer_range< I2 > &y)
template<typename Iterator >
type_from_iterator< Iterator > ::range	interleaved_range (std::size_t size, Iterator frames)
	Constructing buffer ranges from raw interleaved frame data.
template<typename HomogeneousRange >
detail::sample_pointer_type < HomogeneousRange >::type	interleaved_range_get_raw_data (const HomogeneousRange &range)
	Returns C pointer to the the samples of an interleaved homogeneous range.
template<typename HomogeneousRange >
detail::sample_pointer_type < HomogeneousRange >::type	planar_range_get_raw_data (const HomogeneousRange &range, int plane_index)
	Returns C pointer to the the samples of a given channel plane of a planar homogeneous range.
template<typename DstP , typename Range , typename CC >
channel_converted_range_type < Range, DstP, CC >::type	channel_converted_range (const Range &src, CC cc)
	range of a different channel space with a user defined channel-converter
template<typename DstP , typename Range >
channel_converted_range_type < Range, DstP >::type	channel_converted_range (const Range &src)
	overload of generic channel_converted_range with the default channel-converter
template<typename Range >
dynamic_step_type< Range >::type	flipped_range (const Range &src)
template<typename Range >
buffer_range_type< Range >::type	sub_range (const Range &src, size_t start, size_t size)
template<typename Range >
dynamic_step_type< Range >::type	sub_sampled_range (const Range &src, typename Range::size_type step)
template<typename Range >
nth_sample_range_type< Range > ::type	nth_sample_range (const Range &src, int n)
template<int K, typename Range >
kth_sample_range_type< K, Range >::type	kth_sample_range (const Range &src)
template<typename P >
P *	memunit_advanced (const P *p, std::ptrdiff_t diff)
template<int K, typename ChannelBase >
boost::disable_if < boost::is_const< ChannelBase > , typename kth_semantic_element_reference_type < ChannelBase, K >::type > ::type	semantic_at_c (ChannelBase &p)
	A mutable accessor to the K-th semantic element of a channel base.
template<int K, typename ChannelBase >
kth_semantic_element_const_reference_type < ChannelBase, K >::type	semantic_at_c (const ChannelBase &p)
	A constant accessor to the K-th semantic element of a channel base.
template<int K, typename E , typename L , int N>
boost::add_reference< E >::type	at_c (detail::homogeneous_channel_base< E, L, N > &p)
	Provides mutable access to the K-th element, in physical order.
template<int K, typename E , typename L , int N>
boost::add_reference< typename boost::add_const< E >::type > ::type	at_c (const detail::homogeneous_channel_base< E, L, N > &p)
	TODO: Check why this results into ambiguous.
template<typename E , typename L , int N>
void	swap (detail::homogeneous_channel_base< E, L, N > &x, detail::homogeneous_channel_base< E, L, N > &y)
template<typename ChannelBase , typename Channel >
channel_element_reference_type < ChannelBase, Channel >::type	get_channel (ChannelBase &cb, Channel=Channel())
	Mutable accessor to the element associated with a given channel name.
template<typename ChannelBase , typename Channel >
channel_element_const_reference_type < ChannelBase, Channel >::type	get_channel (const ChannelBase &cb, Channel=Channel())
	Constant accessor to the element associated with a given channel name.
template<typename P >
PSYNTH_FORCEINLINE element_const_reference_type < P >::type	static_max (const P &p)
template<typename P >
PSYNTH_FORCEINLINE element_reference_type< P > ::type	static_max (P &p)
template<typename P >
PSYNTH_FORCEINLINE element_const_reference_type < P >::type	static_min (const P &p)
template<typename P >
PSYNTH_FORCEINLINE element_reference_type< P > ::type	static_min (P &p)
template<typename P1 , typename P2 >
PSYNTH_FORCEINLINE bool	static_equal (const P1 &p1, const P2 &p2)
template<typename Src , typename Dst >
PSYNTH_FORCEINLINE void	static_copy (const Src &src, Dst &dst)
template<typename P , typename V >
PSYNTH_FORCEINLINE void	static_fill (P &p, const V &v)
template<typename P1 , typename Op >
PSYNTH_FORCEINLINE void	static_generate (P1 &dst, Op op)
template<typename Src , typename Dst , typename Op >
PSYNTH_FORCEINLINE Op	static_transform (Src &src, Dst &dst, Op op)
template<typename Src , typename Dst , typename Op >
PSYNTH_FORCEINLINE Op	static_transform (const Src &src, Dst &dst, Op op)
template<typename P2 , typename P3 , typename Dst , typename Op >
PSYNTH_FORCEINLINE Op	static_transform (P2 &p2, P3 &p3, Dst &dst, Op op)
template<typename P2 , typename P3 , typename Dst , typename Op >
PSYNTH_FORCEINLINE Op	static_transform (P2 &p2, const P3 &p3, Dst &dst, Op op)
template<typename P2 , typename P3 , typename Dst , typename Op >
PSYNTH_FORCEINLINE Op	static_transform (const P2 &p2, P3 &p3, Dst &dst, Op op)
template<typename P2 , typename P3 , typename Dst , typename Op >
PSYNTH_FORCEINLINE Op	static_transform (const P2 &p2, const P3 &p3, Dst &dst, Op op)
template<typename P1 , typename Op >
PSYNTH_FORCEINLINE Op	static_for_each (P1 &p1, Op op)
template<typename P1 , typename Op >
PSYNTH_FORCEINLINE Op	static_for_each (const P1 &p1, Op op)
template<typename P1 , typename P2 , typename Op >
PSYNTH_FORCEINLINE Op	static_for_each (P1 &p1, P2 &p2, Op op)
template<typename P1 , typename P2 , typename Op >
PSYNTH_FORCEINLINE Op	static_for_each (P1 &p1, const P2 &p2, Op op)
template<typename P1 , typename P2 , typename Op >
PSYNTH_FORCEINLINE Op	static_for_each (const P1 &p1, P2 &p2, Op op)
template<typename P1 , typename P2 , typename Op >
PSYNTH_FORCEINLINE Op	static_for_each (const P1 &p1, const P2 &p2, Op op)
template<typename P1 , typename P2 , typename P3 , typename Op >
PSYNTH_FORCEINLINE Op	static_for_each (P1 &p1, P2 &p2, P3 &p3, Op op)
template<typename P1 , typename P2 , typename P3 , typename Op >
PSYNTH_FORCEINLINE Op	static_for_each (P1 &p1, P2 &p2, const P3 &p3, Op op)
template<typename P1 , typename P2 , typename P3 , typename Op >
PSYNTH_FORCEINLINE Op	static_for_each (P1 &p1, const P2 &p2, P3 &p3, Op op)
template<typename P1 , typename P2 , typename P3 , typename Op >
PSYNTH_FORCEINLINE Op	static_for_each (P1 &p1, const P2 &p2, const P3 &p3, Op op)
template<typename P1 , typename P2 , typename P3 , typename Op >
PSYNTH_FORCEINLINE Op	static_for_each (const P1 &p1, P2 &p2, P3 &p3, Op op)
template<typename P1 , typename P2 , typename P3 , typename Op >
PSYNTH_FORCEINLINE Op	static_for_each (const P1 &p1, P2 &p2, const P3 &p3, Op op)
template<typename P1 , typename P2 , typename P3 , typename Op >
PSYNTH_FORCEINLINE Op	static_for_each (const P1 &p1, const P2 &p2, P3 &p3, Op op)
template<typename P1 , typename P2 , typename P3 , typename Op >
PSYNTH_FORCEINLINE Op	static_for_each (const P1 &p1, const P2 &p2, const P3 &p3, Op op)
template<typename SrcP , typename DstP >
void	channel_convert (const SrcP &src, DstP &dst)
	helper function for converting one frame to another using GIL default channel-converters
template<typename SrcP , typename DstP >
DstP	channel_convert (const SrcP &src)
template<typename IC >
type_from_iterator < planar_frame_iterator< IC, devicen_space< 2 > > >::range	planar_devicen_range (std::size_t size, IC c0, IC c1)
	from 2-channel planar data
template<typename Types1 , typename Range2 >
bool	equal_frames (const dynamic_buffer_range< Types1 > &src, const Range2 &dst)
template<typename Types1 , typename Range2 >
bool	equal_frames (const dynamic_buffer< Types1 > &src, const Range2 &dst)
template<typename Range1 , typename Types2 >
bool	equal_frames (const Range1 &src, const dynamic_buffer_range< Types2 > &dst)
template<typename Types1 , typename Types2 >
bool	equal_frames (const dynamic_buffer_range< Types1 > &src, const dynamic_buffer_range< Types2 > &dst)
template<typename Types1 , typename Range2 >
void	copy_frames (const dynamic_buffer_range< Types1 > &src, const Range2 &dst)
template<typename Range1 , typename Types2 >
void	copy_frames (const Range1 &src, const dynamic_buffer_range< Types2 > &dst)
template<typename Types1 , typename Types2 >
void	copy_frames (const dynamic_buffer_range< Types1 > &src, const dynamic_buffer_range< Types2 > &dst)
template<typename Types1 , typename Range2 , typename CC >
void	copy_and_convert_frames (const dynamic_buffer_range< Types1 > &src, const Range2 &dst, CC cc)
template<typename Types1 , typename Range2 >
void	copy_and_convert_frames (const dynamic_buffer_range< Types1 > &src, const Range2 &dst)
template<typename Range1 , typename Types2 , typename CC >
void	copy_and_convert_frames (const Range1 &src, const dynamic_buffer_range< Types2 > &dst, CC cc)
template<typename Range1 , typename Types2 >
void	copy_and_convert_frames (const Range1 &src, const dynamic_buffer_range< Types2 > &dst)
template<typename Types1 , typename Types2 , typename CC >
void	copy_and_convert_frames (const dynamic_buffer_range< Types1 > &src, const dynamic_buffer_range< Types2 > &dst, CC cc)
template<typename Types1 , typename Types2 >
void	copy_and_convert_frames (const dynamic_buffer_range< Types1 > &src, const dynamic_buffer_range< Types2 > &dst)
template<typename Types , typename Value >
void	fill_frames (const dynamic_buffer_range< Types > &range, const Value &val)
	fill_frames for any buffer range.
template<typename Types , typename Value >
void	fill_frames (dynamic_buffer< Types > &range, const Value &val)
	fill_frames for any buffer range.
template<typename RangeTypes >
dynamic_step_type < dynamic_buffer_range < RangeTypes > >::type	flipped_range (const dynamic_buffer_range< RangeTypes > &src)
template<typename RangeTypes >
dynamic_buffer_range< RangeTypes >	sub_range (const dynamic_buffer_range< RangeTypes > &src, size_t start, size_t size)
template<typename RangeTypes >
dynamic_step_type < dynamic_buffer_range < RangeTypes > >::type	sub_sampled_range (const dynamic_buffer_range< RangeTypes > &src, std::ptrdiff_t step)
template<typename RangeTypes >
nth_sample_range_type < dynamic_buffer_range < RangeTypes > >::type	nth_sample_range (const dynamic_buffer_range< RangeTypes > &src, int n)
template<typename DstP , typename RangeTypes , typename CC >
channel_converted_range_type < dynamic_buffer_range < RangeTypes >, DstP, CC > ::type	channel_converted_range (const dynamic_buffer_range< RangeTypes > &src, CC cc)
	overload of generic channel_converted_range with user defined channel-converter
template<typename DstP , typename RangeTypes >
channel_converted_range_type < dynamic_buffer_range < RangeTypes >, DstP >::type	channel_converted_range (const dynamic_buffer_range< RangeTypes > &src)
	overload of generic channel_converted_range with the default channel-converter
template<typename DstP , typename RangeTypes , typename CC >
channel_converted_range_type < dynamic_buffer_range < RangeTypes >, DstP, CC > ::type	dynamic_channel_converted_range (const dynamic_buffer_range< RangeTypes > &src, CC cc)
	overload of generic channel_converted_range with user defined channel-converter
template<typename DstP , typename RangeTypes >
channel_converted_range_type < dynamic_buffer_range < RangeTypes >, DstP >::type	dynamic_channel_converted_range (const dynamic_buffer_range< RangeTypes > &src)
	overload of generic channel_converted_range with the default channel-converter
template<typename B >
const dynamic_ring_buffer< B > ::range &	range (dynamic_ring_buffer< B > &buf)
template<typename B >
const dynamic_ring_buffer< B > ::const_range	const_range (const dynamic_ring_buffer< B > &buf)
template<typename dstT , typename srcT >
sample_traits< dstT >::value_type	sample_convert (const srcT &val)
template<int K, typename P , typename C , typename L >
kth_element_reference_type < packed_frame< P, C, L >, K > ::type	at_c (packed_frame< P, C, L > &p)
template<int K, typename P , typename C , typename L >
kth_element_const_reference_type < packed_frame< P, C, L >, K > ::type	at_c (const packed_frame< P, C, L > &p)
template<int K, typename B , typename C , typename L , bool M>
kth_element_reference_type < bit_aligned_frame_reference < B, C, L, M >, K >::type	at_c (const bit_aligned_frame_reference< B, C, L, M > &p)
template<typename P >
std::ptrdiff_t	memunit_step (const P *)
template<typename P >
std::ptrdiff_t	memunit_distance (const P p1, const P p2)
template<typename P >
void	memunit_advance (P *&p, std::ptrdiff_t diff)
template<typename P >
P &	memunit_advanced_ref (P *p, std::ptrdiff_t diff)
	memunit_advanced_ref (shortcut to advancing a pointer by a given number of memunits and taking the reference in case the compiler is not smart enough)
template<typename Iterator , typename DFn >
std::iterator_traits< Iterator > ::difference_type	memunit_step (const dereference_iterator_adaptor< Iterator, DFn > &p)
template<typename Iterator , typename DFn >
std::iterator_traits< Iterator > ::difference_type	memunit_distance (const dereference_iterator_adaptor< Iterator, DFn > &p1, const dereference_iterator_adaptor< Iterator, DFn > &p2)
template<typename Iterator , typename DFn >
void	memunit_advance (dereference_iterator_adaptor< Iterator, DFn > &p, typename std::iterator_traits< Iterator >::difference_type diff)
template<typename Iterator , typename DFn >
dereference_iterator_adaptor < Iterator, DFn >	memunit_advanced (const dereference_iterator_adaptor< Iterator, DFn > &p, typename std::iterator_traits< Iterator >::difference_type diff)
template<typename Iterator , typename DFn >
std::iterator_traits < dereference_iterator_adaptor < Iterator, DFn > >::reference	memunit_advanced_ref (const dereference_iterator_adaptor< Iterator, DFn > &p, typename std::iterator_traits< Iterator >::difference_type diff)
template<typename S , typename L >
std::ostream &	operator<< (std::ostream &os, const frame< S, L > &f)
template<typename P , typename C , typename L , bool M>
std::ostream &	operator<< (std::ostream &os, const bit_aligned_frame_reference< P, C, L, M > &f)
template<typename Ref >
std::ostream &	operator<< (std::ostream &os, const bit_aligned_frame_iterator< Ref > &f)
template<typename P , typename C , typename L >
std::ostream &	operator<< (std::ostream &os, const packed_frame< P, C, L > &f)
template<typename S , typename L >
std::ostream &	operator<< (std::ostream &os, const planar_frame_reference< S, L > &f)
template<typename S , typename L >
std::ostream &	operator<< (std::ostream &os, const planar_frame_iterator< S, L > &f)
template<typename F , bool P, typename A >
std::ostream &	operator<< (std::ostream &os, const buffer< F, P, A > &f)
template<typename I >
std::ostream &	operator<< (std::ostream &os, const buffer_range< I > &f)
template<typename IC , typename C >
std::ptrdiff_t	memunit_step (const planar_frame_iterator< IC, C > &)
template<typename IC , typename C >
std::ptrdiff_t	memunit_distance (const planar_frame_iterator< IC, C > &p1, const planar_frame_iterator< IC, C > &p2)
template<typename IC , typename C >
void	memunit_advance (planar_frame_iterator< IC, C > &p, std::ptrdiff_t diff)
template<typename IC , typename C >
planar_frame_iterator< IC, C >	memunit_advanced (const planar_frame_iterator< IC, C > &p, std::ptrdiff_t diff)
template<typename SamplePtr , typename ChannelSpace >
planar_frame_reference < typename std::iterator_traits < SamplePtr >::reference, ChannelSpace >	memunit_advanced_ref (const planar_frame_iterator< SamplePtr, ChannelSpace > &ptr, std::ptrdiff_t diff)
template<typename IC >
type_from_iterator < planar_frame_iterator< IC, quad_space > >::range	planar_quad_range (std::size_t size, IC l, IC r, IC bl, IC br)
	from raw quad planar data
template<typename B >
ring_buffer< B >::range &	range (ring_buffer< B > &buf)
template<typename B >
const ring_buffer< B >::const_range	const_range (const ring_buffer< B > &buf)
template<typename DstSample , typename SrcSample >
sample_traits< DstSample > ::value_type	sample_convert (const SrcSample &src)
	Converting from one sample type to another.
template<typename Sample >
sample_traits< Sample >::value_type	sample_multiply (Sample a, Sample b)
	A function multiplying two samples.
template<typename Sample >
sample_traits< Sample >::value_type	sample_invert (Sample x)
	Default implementation.
template<typename Iterator >
std::ptrdiff_t	memunit_step (const memory_based_step_iterator< Iterator > &p)
template<typename Iterator >
std::ptrdiff_t	memunit_distance (const memory_based_step_iterator< Iterator > &p1, const memory_based_step_iterator< Iterator > &p2)
template<typename Iterator >
void	memunit_advance (memory_based_step_iterator< Iterator > &p, std::ptrdiff_t diff)
template<typename Iterator >
memory_based_step_iterator < Iterator >	memunit_advanced (const memory_based_step_iterator< Iterator > &p, std::ptrdiff_t diff)
template<typename Iterator >
std::iterator_traits< Iterator > ::reference	memunit_advanced_ref (const memory_based_step_iterator< Iterator > &p, std::ptrdiff_t diff)
template<typename I >
dynamic_step_type< I >::type	make_step_iterator (const I &it, std::ptrdiff_t step)
	Constructs a step iterator from a base iterator and a step.
template<typename IC >
type_from_iterator < planar_frame_iterator< IC, stereo_space > >::range	planar_stereo_range (std::size_t size, IC l, IC r)
	from raw stereo planar data
template<typename IC >
type_from_iterator < planar_frame_iterator< IC, surround_space > >::range	planar_surround_range (std::size_t size, IC l, IC r, IC c, IC bl, IC br)
	from raw surround planar data
std::ptrdiff_t	iround (float x)
std::ptrdiff_t	iround (double x)
std::ptrdiff_t	ifloor (float x)
std::ptrdiff_t	ifloor (double x)
std::ptrdiff_t	iceil (float x)
std::ptrdiff_t	iceil (double x)
template<typename T >
T	align (T val, std::size_t alignment)
template<typename OutPtr , typename In >
PSYNTH_FORCEINLINE OutPtr	psynth_reinterpret_cast (In *p)
template<typename OutPtr , typename In >
PSYNTH_FORCEINLINE const OutPtr	psynth_reinterpret_cast_c (const In *p)
template<typename Value , typename T1 , typename T2 >
void	swap_proxy (T1 &left, T2 &right)
	A version of swap that also works with reference proxy objects.
bool	little_endian ()
	Run-time detection of whether the underlying architecture is little endian.
bool	big_endian ()
	Run-time detection of whether the underlying architecture is big endian.
template<typename Types >
void	swap (variant< Types > &x, variant< Types > &y)
template<typename Types >
bool	operator== (const variant< Types > &x, const variant< Types > &y)
template<typename C >
bool	operator!= (const variant< C > &x, const variant< C > &y)
range, const_range
Get an buffer range from a run-time instantiated buffer Returns the non-constant-pixel range of any buffer. The returned range is any range.
template<typename Frame , bool IsPlanar, typename Alloc >
const buffer< Frame, IsPlanar, Alloc >::range &	range (buffer< Frame, IsPlanar, Alloc > &buf)
template<typename Frame , bool IsPlanar, typename Alloc >
const buffer< Frame, IsPlanar, Alloc >::const_range	const_range (const buffer< Frame, IsPlanar, Alloc > &buf)
	Returns the constant-frame range of an buffer.
template<typename Types >
PSYNTH_FORCEINLINE dynamic_buffer< Types >::range	range (dynamic_buffer< Types > &buf)
template<typename Types >
PSYNTH_FORCEINLINE dynamic_buffer< Types > ::const_range	const_range (const dynamic_buffer< Types > &buf)
	Returns the constant-pixel range of any buffer.

Typedef Documentation

typedef boost::mpl::vector1< mono_channel > psynth::sound::mono_space

typedef layout<quad_space> psynth::sound::quad_layout

typedef boost::mpl::vector4< left_channel, right_channel, back_left_channel, back_right_channel> psynth::sound::quad_space

typedef layout<stereo_space, boost::mpl::vector2_c<int, 1, 0> > psynth::sound::rlstereo_layout

typedef layout<stereo_space> psynth::sound::stereo_layout

typedef boost::mpl::vector2<left_channel, right_channel> psynth::sound::stereo_space

typedef layout<surround_space> psynth::sound::surround_layout

typedef boost::mpl::vector5< left_channel, right_channel, center_channel, back_right_channel, back_left_channel> psynth::sound::surround_space

Enumeration Type Documentation

enum psynth::sound::ring_buffer_error

Error codes for a read pointer.

Enumerator:

none

No error.

underrun

An underrun has ocurred.

This means that there has been too much data written overwritting data thas has not been previously read.

overrun

An overrun has ocurred.

This means that the reader has read more data that the one actually in the buffer.

Function Documentation

template<typename T >

T psynth::sound::align	(	T	val,
		std::size_t	alignment
	)		`[inline]`

template<typename Types , typename UnaryOp >

PSYNTH_FORCEINLINE UnaryOp::result_type psynth::sound::apply_operation	(	variant< Types > &	arg,
		UnaryOp	op
	)

Invokes a generic mutable operation (represented as a unary function object) on a variant.

template<typename Types , typename UnaryOp >

PSYNTH_FORCEINLINE UnaryOp::result_type psynth::sound::apply_operation	(	const variant< Types > &	arg,
		UnaryOp	op
	)

Invokes a generic constant operation (represented as a unary function object) on a variant.

template<typename Types1 , typename Types2 , typename BinaryOp >

PSYNTH_FORCEINLINE BinaryOp::result_type psynth::sound::apply_operation	(	const variant< Types1 > &	arg1,
		const variant< Types2 > &	arg2,
		BinaryOp	op
	)

Invokes a generic constant operation (represented as a binary function object) on two variants.

template<typename Types , typename Bits , typename Op >

Op::result_type PSYNTH_FORCEINLINE psynth::sound::apply_operation_base	(	Bits &	bits,
		std::size_t	index,
		Op	op
	)

template<typename Types , typename Bits , typename Op >

Op::result_type PSYNTH_FORCEINLINE psynth::sound::apply_operation_basec	(	const Bits &	bits,
		std::size_t	index,
		Op	op
	)

template<int K, typename BitField , typename SampleBitSizes , typename L , bool Mutable>

kth_element_reference_type< bit_aligned_frame_reference<BitField,SampleBitSizes,L,Mutable>,K>::type psynth::sound::at_c ( const bit_aligned_frame_reference< BitField, SampleBitSizes, L, Mutable > & p ) [inline]

at_c required by MutableChannelBaseConcept

template<int K, typename P , typename C , typename L >

kth_element_reference_type< packed_frame< P, C, L >, K >::type psynth::sound::at_c ( packed_frame< P, C, L > & p ) [inline]

template<int K, typename P , typename C , typename L >

kth_element_const_reference_type< packed_frame< P, C, L >, K >::type psynth::sound::at_c ( const packed_frame< P, C, L > & p ) [inline]

template<int K, typename B , typename C , typename L , bool M>

kth_element_reference_type< bit_aligned_frame_reference<B,C,L,M>, K>::type psynth::sound::at_c ( const bit_aligned_frame_reference< B, C, L, M > & p ) [inline]

bool psynth::sound::big_endian ( ) [inline]

Run-time detection of whether the underlying architecture is big endian.

template<typename SrcP , typename DstP >

void psynth::sound::channel_convert	(	const SrcP &	src,
		DstP &	dst
	)		`[inline]`

helper function for converting one frame to another using GIL default channel-converters

where ScrP models HomogeneousFrameConcept DstP models HomogeneousFrameValueConcept

template<typename SrcP , typename DstP >

DstP psynth::sound::channel_convert ( const SrcP & src ) [inline]

template<typename B >

const ring_buffer::const_range psynth::sound::const_range ( const ring_buffer & buf )

template<typename Frame , bool IsPlanar, typename Alloc >

const buffer<Frame, IsPlanar, Alloc>::const_range psynth::sound::const_range ( const buffer< Frame, IsPlanar, Alloc > & buf ) [inline]

Returns the constant-frame range of an buffer.

template<typename Types >

PSYNTH_FORCEINLINE dynamic_buffer<Types>::const_range psynth::sound::const_range ( const dynamic_buffer< Types > & buf )

Returns the constant-pixel range of any buffer.

The returned range is any range.

template<typename B >

const dynamic_ring_buffer::const_range psynth::sound::const_range ( const dynamic_ring_buffer & buf )

template<typename Types1 , typename Range2 , typename CC >

void psynth::sound::copy_and_convert_frames	(	const dynamic_buffer_range< Types1 > &	src,
		const Range2 &	dst,
		CC	cc
	)

template<typename Types1 , typename Range2 >

void psynth::sound::copy_and_convert_frames	(	const dynamic_buffer_range< Types1 > &	src,
		const Range2 &	dst
	)

template<typename Range1 , typename Types2 , typename CC >

void psynth::sound::copy_and_convert_frames	(	const Range1 &	src,
		const dynamic_buffer_range< Types2 > &	dst,
		CC	cc
	)

template<typename Range1 , typename Types2 >

void psynth::sound::copy_and_convert_frames	(	const Range1 &	src,
		const dynamic_buffer_range< Types2 > &	dst
	)

template<typename Types1 , typename Types2 , typename CC >

void psynth::sound::copy_and_convert_frames	(	const dynamic_buffer_range< Types1 > &	src,
		const dynamic_buffer_range< Types2 > &	dst,
		CC	cc
	)

template<typename Types1 , typename Types2 >

void psynth::sound::copy_and_convert_frames	(	const dynamic_buffer_range< Types1 > &	src,
		const dynamic_buffer_range< Types2 > &	dst
	)

template<typename Types1 , typename Range2 >

void psynth::sound::copy_frames	(	const dynamic_buffer_range< Types1 > &	src,
		const Range2 &	dst
	)

template<typename Range1 , typename Types2 >

void psynth::sound::copy_frames	(	const Range1 &	src,
		const dynamic_buffer_range< Types2 > &	dst
	)

template<typename Types1 , typename Types2 >

void psynth::sound::copy_frames	(	const dynamic_buffer_range< Types1 > &	src,
		const dynamic_buffer_range< Types2 > &	dst
	)

template<typename Range >

PSYNTH_FORCEINLINE void psynth::sound::destruct_frames ( const Range & buf_range )

Invokes the in-place destructor on every frame of the range.

template<typename Types1 , typename Range2 >

bool psynth::sound::equal_frames	(	const dynamic_buffer_range< Types1 > &	src,
		const Range2 &	dst
	)

template<typename Types1 , typename Range2 >

bool psynth::sound::equal_frames	(	const dynamic_buffer< Types1 > &	src,
		const Range2 &	dst
	)

template<typename Types1 , typename Types2 >

bool psynth::sound::equal_frames	(	const dynamic_buffer_range< Types1 > &	src,
		const dynamic_buffer_range< Types2 > &	dst
	)

template<typename Range1 , typename Types2 >

bool psynth::sound::equal_frames	(	const Range1 &	src,
		const dynamic_buffer_range< Types2 > &	dst
	)

template<typename I1 , typename I2 >

PSYNTH_FORCEINLINE bool psynth::sound::equal_n	(	I1	i1,
		std::ptrdiff_t	n,
		I2	i2
	)

template<typename Types , typename Value >

void psynth::sound::fill_frames	(	const dynamic_buffer_range< Types > &	range,
		const Value &	val
	)

fill_frames for any buffer range.

The frame to fill with must be compatible with the current range

template<typename Types , typename Value >

void psynth::sound::fill_frames	(	dynamic_buffer< Types > &	range,
		const Value &	val
	)

fill_frames for any buffer range.

The frame to fill with must be compatible with the current range

template<typename Range >

dynamic_step_type<Range>::type psynth::sound::flipped_range ( const Range & src ) [inline]

template<typename RangeTypes >

dynamic_step_type<dynamic_buffer_range<RangeTypes> >::type psynth::sound::flipped_range ( const dynamic_buffer_range< RangeTypes > & src ) [inline]

template<typename V , typename F >

PSYNTH_FORCEINLINE F psynth::sound::for_each_frame	(	const V &	buf,
		F	fun
	)

template<typename Range , typename F >

PSYNTH_FORCEINLINE F psynth::sound::for_each_frame_position	(	const Range &	buf,
		F	fun
	)

template<typename Range , typename F >

PSYNTH_FORCEINLINE void psynth::sound::generate_frames	(	const Range &	v,
		F	fun
	)

std::ptrdiff_t psynth::sound::iceil ( float x ) [inline]

std::ptrdiff_t psynth::sound::iceil ( double x ) [inline]

std::ptrdiff_t psynth::sound::ifloor ( double x ) [inline]

std::ptrdiff_t psynth::sound::ifloor ( float x ) [inline]

std::ptrdiff_t psynth::sound::iround ( float x ) [inline]

std::ptrdiff_t psynth::sound::iround ( double x ) [inline]

bool psynth::sound::little_endian ( ) [inline]

Run-time detection of whether the underlying architecture is little endian.

template<typename I >

dynamic_step_type< I >::type psynth::sound::make_step_iterator	(	const I &	it,
		std::ptrdiff_t	step
	)

Constructs a step iterator from a base iterator and a step.

To construct a step iterator from a given iterator Iterator and a given step, if Iterator does not already have a dynamic step, we wrap it in a memory_based_step_iterator. Otherwise we do a compile-time traversal of the chain of iterator adaptors to locate the step iterator and then set it step to the new one.

The step iterator of Iterator is not always memory_based_step_iterator<Iterator>. For example, Iterator may already be a memory_based_step_iterator, in which case it will be inefficient to stack them; we can obtain the same result by multiplying their steps. Note that for Iterator to be a step iterator it does not necessarily have to have the form memory_based_step_iterator<J>. The step iterator can be wrapped inside another iterator. Also, it may not have the type memory_based_step_iterator, but it could be a user-provided type.

template<typename IC , typename C >

void psynth::sound::memunit_advance	(	planar_frame_iterator< IC, C > &	p,
		std::ptrdiff_t	diff
	)		`[inline]`

template<typename Iterator >

void psynth::sound::memunit_advance	(	memory_based_step_iterator< Iterator > &	p,
		std::ptrdiff_t	diff
	)		`[inline]`

template<typename NonAlignedFrameReference >

void psynth::sound::memunit_advance	(	bit_aligned_frame_iterator< NonAlignedFrameReference > &	p,
		std::ptrdiff_t	diff
	)		`[inline]`

template<typename P >

void psynth::sound::memunit_advance	(	P *&	p,
		std::ptrdiff_t	diff
	)		`[inline]`

template<typename Iterator , typename DFn >

void psynth::sound::memunit_advance	(	dereference_iterator_adaptor< Iterator, DFn > &	p,
		typename std::iterator_traits< Iterator >::difference_type	diff
	)		`[inline]`

template<typename IC , typename C >

planar_frame_iterator<IC,C> psynth::sound::memunit_advanced	(	const planar_frame_iterator< IC, C > &	p,
		std::ptrdiff_t	diff
	)		`[inline]`

template<typename Iterator >

memory_based_step_iterator<Iterator> psynth::sound::memunit_advanced	(	const memory_based_step_iterator< Iterator > &	p,
		std::ptrdiff_t	diff
	)		`[inline]`

template<typename P >

P * psynth::sound::memunit_advanced	(	const P *	p,
		std::ptrdiff_t	diff
	)		`[inline]`

template<typename NonAlignedFrameReference >

bit_aligned_frame_iterator<NonAlignedFrameReference> psynth::sound::memunit_advanced	(	const bit_aligned_frame_iterator< NonAlignedFrameReference > &	p,
		std::ptrdiff_t	diff
	)		`[inline]`

template<typename Iterator , typename DFn >

dereference_iterator_adaptor<Iterator,DFn> psynth::sound::memunit_advanced	(	const dereference_iterator_adaptor< Iterator, DFn > &	p,
		typename std::iterator_traits< Iterator >::difference_type	diff
	)		`[inline]`

template<typename SamplePtr , typename ChannelSpace >

planar_frame_reference<typename std::iterator_traits<SamplePtr>::reference, ChannelSpace> psynth::sound::memunit_advanced_ref	(	const planar_frame_iterator< SamplePtr, ChannelSpace > &	ptr,
		std::ptrdiff_t	diff
	)		`[inline]`

template<typename Iterator >

std::iterator_traits<Iterator>::reference psynth::sound::memunit_advanced_ref	(	const memory_based_step_iterator< Iterator > &	p,
		std::ptrdiff_t	diff
	)		`[inline]`

template<typename NonAlignedFrameReference >

NonAlignedFrameReference psynth::sound::memunit_advanced_ref	(	bit_aligned_frame_iterator< NonAlignedFrameReference >	it,
		std::ptrdiff_t	diff
	)		`[inline]`

template<typename P >

P& psynth::sound::memunit_advanced_ref	(	P *	p,
		std::ptrdiff_t	diff
	)		`[inline]`

memunit_advanced_ref (shortcut to advancing a pointer by a given number of memunits and taking the reference in case the compiler is not smart enough)

template<typename Iterator , typename DFn >

std::iterator_traits< dereference_iterator_adaptor<Iterator,DFn> >::reference psynth::sound::memunit_advanced_ref	(	const dereference_iterator_adaptor< Iterator, DFn > &	p,
		typename std::iterator_traits< Iterator >::difference_type	diff
	)		`[inline]`

template<typename IC , typename C >

std::ptrdiff_t psynth::sound::memunit_distance	(	const planar_frame_iterator< IC, C > &	p1,
		const planar_frame_iterator< IC, C > &	p2
	)		`[inline]`

template<typename Iterator >

std::ptrdiff_t psynth::sound::memunit_distance	(	const memory_based_step_iterator< Iterator > &	p1,
		const memory_based_step_iterator< Iterator > &	p2
	)		`[inline]`

template<typename NonAlignedFrameReference >

std::ptrdiff_t psynth::sound::memunit_distance	(	const bit_aligned_frame_iterator< NonAlignedFrameReference > &	p1,
		const bit_aligned_frame_iterator< NonAlignedFrameReference > &	p2
	)		`[inline]`

template<typename P >

std::ptrdiff_t psynth::sound::memunit_distance	(	const P *	p1,
		const P *	p2
	)		`[inline]`

template<typename Iterator , typename DFn >

std::iterator_traits<Iterator>::difference_type psynth::sound::memunit_distance	(	const dereference_iterator_adaptor< Iterator, DFn > &	p1,
		const dereference_iterator_adaptor< Iterator, DFn > &	p2
	)		`[inline]`

template<typename IC , typename C >

std::ptrdiff_t psynth::sound::memunit_step ( const planar_frame_iterator< IC, C > & ) [inline]

template<typename Iterator >

std::ptrdiff_t psynth::sound::memunit_step ( const memory_based_step_iterator< Iterator > & p ) [inline]

template<typename NonAlignedFrameReference >

std::ptrdiff_t psynth::sound::memunit_step ( const bit_aligned_frame_iterator< NonAlignedFrameReference > & ) [inline]

template<typename P >

std::ptrdiff_t psynth::sound::memunit_step ( const P * ) [inline]

template<typename Iterator , typename DFn >

std::iterator_traits<Iterator>::difference_type psynth::sound::memunit_step ( const dereference_iterator_adaptor< Iterator, DFn > & p ) [inline]

template<typename Frame1 , bool IsPlanar1, typename Alloc1 , typename Frame2 , bool IsPlanar2, typename Alloc2 >

bool psynth::sound::operator!=	(	const buffer< Frame1, IsPlanar1, Alloc1 > &	buf1,
		const buffer< Frame2, IsPlanar2, Alloc2 > &	buf2
	)

template<typename C >

bool psynth::sound::operator!=	(	const variant< C > &	x,
		const variant< C > &	y
	)		`[inline]`

template<typename Ref >

std::ostream& psynth::sound::operator<<	(	std::ostream &	os,
		const bit_aligned_frame_iterator< Ref > &	f
	)

template<typename P , typename C , typename L >

std::ostream& psynth::sound::operator<<	(	std::ostream &	os,
		const packed_frame< P, C, L > &	f
	)

template<typename S , typename L >

std::ostream& psynth::sound::operator<<	(	std::ostream &	os,
		const planar_frame_reference< S, L > &	f
	)

template<typename I >

std::ostream& psynth::sound::operator<<	(	std::ostream &	os,
		const buffer_range< I > &	f
	)

template<typename P , typename C , typename L , bool M>

std::ostream& psynth::sound::operator<<	(	std::ostream &	os,
		const bit_aligned_frame_reference< P, C, L, M > &	f
	)

template<typename F , bool P, typename A >

std::ostream& psynth::sound::operator<<	(	std::ostream &	os,
		const buffer< F, P, A > &	f
	)

template<typename S , typename L >

std::ostream& psynth::sound::operator<<	(	std::ostream &	os,
		const planar_frame_iterator< S, L > &	f
	)

template<typename S , typename L >

std::ostream& psynth::sound::operator<<	(	std::ostream &	os,
		const frame< S, L > &	f
	)

template<typename Frame1 , bool IsPlanar1, typename Alloc1 , typename Frame2 , bool IsPlanar2, typename Alloc2 >

bool psynth::sound::operator==	(	const buffer< Frame1, IsPlanar1, Alloc1 > &	buf1,
		const buffer< Frame2, IsPlanar2, Alloc2 > &	buf2
	)

template<typename Types >

bool psynth::sound::operator==	(	const variant< Types > &	x,
		const variant< Types > &	y
	)		`[inline]`

template<typename IC >

type_from_iterator< planar_frame_iterator<IC,devicen_space<2> > >::range psynth::sound::planar_devicen_range	(	std::size_t	size,
		IC	c0,
		IC	c1
	)		`[inline]`

from 2-channel planar data

template<typename IC >

type_from_iterator< planar_frame_iterator<IC, quad_space> >::range psynth::sound::planar_quad_range	(	std::size_t	size,
		IC	l,
		IC	r,
		IC	bl,
		IC	br
	)		`[inline]`

from raw quad planar data

template<typename IC >

type_from_iterator<planar_frame_iterator<IC, stereo_space> >::range psynth::sound::planar_stereo_range	(	std::size_t	size,
		IC	l,
		IC	r
	)		`[inline]`

from raw stereo planar data

template<typename OutPtr , typename In >

PSYNTH_FORCEINLINE OutPtr psynth::sound::psynth_reinterpret_cast ( In * p )

template<typename OutPtr , typename In >

PSYNTH_FORCEINLINE const OutPtr psynth::sound::psynth_reinterpret_cast_c ( const In * p )

template<typename Frame , bool IsPlanar, typename Alloc >

const buffer<Frame, IsPlanar, Alloc>::range& psynth::sound::range ( buffer< Frame, IsPlanar, Alloc > & buf ) [inline]

template<typename Types >

PSYNTH_FORCEINLINE dynamic_buffer<Types>::range psynth::sound::range ( dynamic_buffer< Types > & buf )

template<typename B >

ring_buffer::range& psynth::sound::range ( ring_buffer & buf )

Todo:: This returns non-const reference because writing to a ring_buffer_range mutates the internal range state.

Does this has bad consecuences? Is this the best alternative?

template<typename B >

const dynamic_ring_buffer::range& psynth::sound::range ( dynamic_ring_buffer & buf )

template<typename dstT , typename srcT >

sample_traits<dstT>::value_type psynth::sound::sample_convert ( const srcT & val )

template<typename Range >

buffer_range_type<Range>::type psynth::sound::sub_range	(	const Range &	src,
		size_t	start,
		size_t	size
	)		`[inline]`

template<typename Range >

dynamic_step_type<Range>::type psynth::sound::sub_sampled_range	(	const Range &	src,
		typename Range::size_type	step
	)		`[inline]`

template<typename Frame , bool IsPlanar, typename Alloc >

void psynth::sound::swap	(	buffer< Frame, IsPlanar, Alloc > &	buf1,
		buffer< Frame, IsPlanar, Alloc > &	buf2
	)

template<typename Types >

void psynth::sound::swap	(	variant< Types > &	x,
		variant< Types > &	y
	)

template<typename E , typename L , int N>

void psynth::sound::swap	(	detail::homogeneous_channel_base< E, L, N > &	x,
		detail::homogeneous_channel_base< E, L, N > &	y
	)		`[inline]`

template<typename I2 >

void psynth::sound::swap	(	buffer_range< I2 > &	x,
		buffer_range< I2 > &	y
	)		`[inline]`

template<typename Value , typename T1 , typename T2 >

void psynth::sound::swap_proxy	(	T1 &	left,
		T2 &	right
	)

A version of swap that also works with reference proxy objects.

template<typename Range1 , typename Range2 , typename F >

PSYNTH_FORCEINLINE F psynth::sound::transform_frame_positions	(	const Range1 &	src,
		const Range2 &	dst,
		F	fun
	)

template<typename Range1 , typename Range2 , typename F >

PSYNTH_FORCEINLINE F psynth::sound::transform_frames	(	const Range1 &	src,
		const Range2 &	dst,
		F	fun
	)

template<typename Range1 , typename Range2 >

PSYNTH_FORCEINLINE void psynth::sound::uninitialized_copy_frames	(	const Range1 &	range1,
		const Range2 &	range2
	)

std::uninitialized_copy for image ranges.

Does not support planar heterogeneous ranges. If an exception is thrown destructs any in-place copy-constructed objects

Namespaces

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

Enumeration Type Documentation

Function Documentation