KSPROPERTY_AUDIO_LINEAR_BUFFER_POSITION (Windows Drivers)
KSPROPERTY_AUDIO_LINEAR_BUFFER_POSITION
Expand the table of content
KSPROPERTY_AUDIO_LINEAR_BUFFER_POSITION
The KSPROPERTY_AUDIO_LINEAR_BUFFER_POSITION property request retrieves a number that represents the number of bytes that the DMA has fetched from the audio buffer since the beginning of the stream.
Usage Summary Table
GetSetTargetProperty descriptor typeProperty value type
Node via Pin instance
ULONGULONG
Return Value
The KSPROPERTY_AUDIO_LINEAR_BUFFER_POSITION property request returns STATUS_SUCCESS to indicate that it has completed successfully. Otherwise, the request returns an appropriate error status code.
Requirements
IN THIS ARTICLE
Is this page helpful?
Additional feedback?
1500 characters remaining
Thank you!
We appreciate your feedback.Linear rendering refers to the process of rendering a scene with all inputs being linear. Normally textures exist with gamma correction pre-applied to them, which means that when the textures are sampled in a material the values are not linear. If these textures are used in the usual equations for e.g. lighting and image effect it will lead to slightly wrong results as the equations are calculated in a non-linear space.
Linear rendering ensures that both inputs and outputs of a shader are in the correct color space which results in a more correct outcome.
Gamma Pipeline
In the gamma rendering pipeline all colors and textures are sampled in gamma space, ie, gamma correction is not removed from images or colors before they are used in a shader. Albeit these values being in gamma space, all shader calculations treat their input as if it was in linear space, and additionally, when writing the shader outputs to memory, no gamma correction is applied to the final pixel. Much of the time this looks acceptable as the two wrongs go some way to cancelling each other out. But it is not correct.
Linear Pipeline
If linear rendering is enabled then inputs to the shader program are supplied with the gamma correction removed from them. For colors this conversion is applied implicitly if you are in linear space. Textures are sampled using hardware sRGB the source texture is supplied in gamma space and then on sampling in the graphics hardware the result is converted automatically. These inputs are then supplied to the shader and lighting occurs as it normally would. When writing the resulting value to the framebuffer, it will either be gamma corrected or left in linear space for la this depends on the current rendering configuration.
Differences Between Linear and Gamma Rendering
When using linear rendering, input values to the shader equations are different than in gamma space. This means that e.g. lights striking surfaces will have a different response curve and image effects will behave differently than in the gamma pipeline.
Light Falloff
The falloff from distance- and normal-based lighting is changed in two ways. Firstly when rendering in linear mode, the additional gamma correction that is performed will make a light’s radius appear larger. Secondly lighting edges will also be harsher. This more correctly models lighting intensity falloff on surfaces.
Linear Intensity Response
When you are using gamma rendering, the colors and textures that are supplied to a shader have a gamma correction applied to them. When they are used in a shader the colors of high luminance are actually brighter then they should be for linear lighting. This means that as light intensity increases the surface will get brighter in a non linear way. This leads to lighting that can be too bright in many places, and can also give models and scenes a washed-out feel. When you are using linear rendering, the response from the surface remains linear as the light intensity increases. This leads to much more realistic surface shading and a much nicer color response in the surface.
Infinite 3D Head Scan by Lee Perry-Smith is licensed under a Creative Commons Attribution 3.0 Unported License. Available from: http://www.ir-ltd.net/
Linear and Gamma Blending
When performing blending into the framebuffer, the blending occurs in the color space of the framebuffer. When using gamma rendering, this means that non-linear colors get blended together. This is incorrect. When using linear space rendering, blending occurs in linear space. This is correct and gives the expected results.
Using Linear Rendering
Linear rendering gives a different look to the rendered scene. When you have authored a project for rendering in gamma space, at first it will most likely not look correct if you change to linear rendering. Because of this, if you move to linear rendering from gamma rendering it may take some time to update the project so that it looks as good as before, but the switch ultimately enables more consistent and realistic rendering. That being said, enabling linear rendering in Unity is simple: It is implemented on a per-project basis and is exposed in the Player Settings which can be located at Edit -& Project Settings -& Player -& Other Settings
Lightmapping
When you are using linear rendering, all lighting and textures are linearized, which means that the values passed to the lightmapper also need to be modified. Thus, when you switch between gamma and linear rendering, you will need to rebake lightmaps. This happens automatically when Unity’s lighting is set to auto bake (which is the default).
Supported Platforms
Linear rendering is not supported on all platforms. The build targets that currently support the feature are:
Windows, Mac and Linux (standalone and web player)
Xbox 360, Xbox One
PlayStation 3 and 4
Even though the desktop platforms generally support linear rendering, in some cases it may be disabled due to graphics driver issues. You can check this by looking at QualitySettings.desiredColorSpace and QualitySettings.activeColorSpace. If the desired color space is linear but the active color space is gamma then the player has fallen back to gamma space. This can be used to inform the user that the application will not look correct for them or to force an exit from the player.
Linear and Non HDR
When you are not using HDR, a special framebuffer type is used that supports sRGB read and sRGB write (Degamma on read, Gamma on write). This means that just like a texture, the values in the framebuffer are gamma corrected. When this framebuffer is used for blending or bound as texture, the values have the gamma removed before being used. When these buffers are written to, the value that is being written is converted from linear space to gamma space. If you are rendering in linear mode then all post-process effects will have their source and target buffers created with sRGB reading and writing enabled so that post-processing and post-process blending occurs in linear space.
Linear and HDR
When using HDR, rendering is performed into floating point buffers. These buffers have enough resolution not to require conversion to and from gamma space whenever the buffer is accessed. This means that when rendering in linear mode, the render targets you use will store the colors in linear space. Therefore, all blending and post process effects will implicitly be performed in linear space. When the backbuffer is written to, gamma correction is applied.
Legacy GUI and Linear Authored Textures
Rendering elements of the
is always done in gamma space. This means that, for the legacy GUI system, GUI textures should not have their gamma removed on read. This can be achieved in two ways:
Set the texture type to GUI in the texture importer
Check the ‘Bypass sRGB Sampling’ checkbox in the advanced texture importer
It is also important that lookup textures, masks, and other textures whose RGB values mean something specific and have no gamma correction applied to them should bypass sRGB sampling. This will cause the sampled texture not to remove gamma before it is used in the shader, and calculations will be done with the same value as is stored on disk.From Wikipedia, the free encyclopedia
This article is about systems as studied in systems theory. For a set of linear equations, see . For the concept in algebraic geometry, see .
This article does not
any . Please help
by . Unsourced material may be challenged and . (December 2009) ()
A linear system is a
based on the use of a . Linear systems typically exhibit features and properties that are much simpler than the
case. As a mathematical abstraction or idealization, linear systems find important applications in
theory, , and . For example, the propagation medium for wireless communication systems can often be modeled by linear systems.
can be described by an operator,
{\displaystyle H}
, that maps an input,
{\displaystyle x(t)}
, as a function of
{\displaystyle t}
to an output,
{\displaystyle y(t)}
, a type of
description. Linear systems satisfy the property of . Given two valid inputs
{\displaystyle x_{1}(t)\,}
{\displaystyle x_{2}(t)\,}
as well as their respective outputs
{\displaystyle y_{1}(t)=H\left\{x_{1}(t)\right\}}
{\displaystyle y_{2}(t)=H\left\{x_{2}(t)\right\}}
then a linear system must satisfy
{\displaystyle \alpha y_{1}(t)+\beta y_{2}(t)=H\left\{\alpha x_{1}(t)+\beta x_{2}(t)\right\}}
{\displaystyle \alpha \,}
{\displaystyle \beta \,}
The system is then defined by the equation
{\displaystyle H(x(t))=y(t)}
{\displaystyle y(t)}
is some arbitrary function of time, and
{\displaystyle x(t)}
is the system state. Given
{\displaystyle y(t)}
{\displaystyle H}
{\displaystyle x(t)}
can be solved for. For example, a simple harmonic oscillator obeys the differential equation:
{\displaystyle m{\frac {d^{2}(x)}{dt^{2}}}=-kx}
{\displaystyle H(x(t))=m{\frac {d^{2}(x(t))}{dt^{2}}}+kx(t)}
{\displaystyle H}
is a linear operator. Letting
{\displaystyle y(t)=0}
, we can rewrite the differential equation as
{\displaystyle H(x(t))=y(t)}
, which shows that a simple harmonic oscillator is a linear system.
The behavior of the resulting system subjected to a complex input can be described as a sum of responses to simpler inputs. In nonlinear systems, there is no such relation. This mathematical property makes the solution of modelling equations simpler than many nonlinear systems. For
systems this is the basis of the
methods (see ), which describe a general input function
{\displaystyle x(t)}
in terms of unit
systems are well adapted to analysis using the
case, and the
case (especially in computer implementations).
Another perspective is that solutions to linear systems comprise a system of
which act like
in the geometric sense.
A common use of linear models is to describe a nonlinear system by . This is usually done for mathematical convenience.
The time-varying impulse response h(t2,t1) of a linear system is defined as the response of the system at time t = t2 to a single
applied at time t = t1. In other words, if the input x(t) to a linear system is
{\displaystyle x(t)=\delta (t-t_{1})\,}
where δ(t) represents the , and the corresponding response y(t) of the system is
{\displaystyle y(t)|_{t=t_{2}}=h(t_{2},t_{1})\,}
then the function h(t2,t1) is the time-varying impulse response of the system. Since the system cannot respond before the input is applied the following causality condition must be satisfied:
{\displaystyle h(t_{2},t_{1})=0,t_{2}&t_{1}}
The output of any general continuous-time linear system is related to the input by an integral which may be written over a doubly infinite range because of the causality condition:
{\displaystyle y(t)=\int _{-\infty }^{t}h(t,t')x(t')dt'=\int _{-\infty }^{\infty }h(t,t')x(t')dt'}
If the properties of the system do not depend on the time at which it is operated then it is said to be time-invariant and h() is a function only of the time difference τ = t-t' which is zero for τ&0 (namely t&t'). By redefinition of h() it is then possible to write the input-output relation equivalently in any of the ways,
{\displaystyle y(t)=\int _{-\infty }^{t}h(t-t')x(t')dt'=\int _{-\infty }^{\infty }h(t-t')x(t')dt'=\int _{-\infty }^{\infty }h(\tau )x(t-\tau )d\tau =\int _{0}^{\infty }h(\tau )x(t-\tau )d\tau }
Linear time-invariant systems are most commonly characterized by the Laplace transform of the impulse response function called the transfer function which is:
{\displaystyle H(s)=\int _{0}^{\infty }h(t)e^{-st}\,dt.}
In applications this is usually a rational algebraic function of s. Because h(t) is zero for negative t, the integral may equally be written over the doubly infinite range and putting s = iω follows the formula for the frequency response function:
{\displaystyle H(i\omega )=\int _{-\infty }^{\infty }h(t)e^{-i\omega t}dt}
The output of any discrete time linear system is related to the input by the time-varying convolution sum:
{\displaystyle y[n]=\sum _{m=-\infty }^{n}{h[n,m]x[m]}=\sum _{m=-\infty }^{\infty }{h[n,m]x[m]}}
or equivalently for a time-invariant system on redefining h(),
{\displaystyle y[n]=\sum _{k=0}^{\infty }{h[k]x[n-k]}=\sum _{k=-\infty }^{\infty }{h[k]x[n-k]}}
{\displaystyle k=n-m\,}
represents the lag time between the stimulus at time m and the response at time n.
: Hidden categories:}