# Patent

## Title
Dynamical systems approach to LCD overdrive

## Abstract

A method of overdriving LCD panels to improve LCD pixel response time is described that does not rely upon conventional use of overdrive look up tables. The method is based upon modeling the LCD pixels as linear second-order dynamical systems that leads to simple runtime calculations requiring but a small number of stored panel specific constants.

## Background
CROSS REFERENCE TO RELATED APPLICATIONS
The present application claims priority under 35 U.S.C. §119(e) from U.S. Provisional Patent Application No. 60/546,608 entitled “DYNAMICAL SYSTEMS APPROACH TO LCD OVERDRIVE” filed Feb. 20, 2004, the entire disclosure of which is incorporated herein by reference for all purposes.


BACKGROUND
1. Field of the Invention
The invention relates to display devices. More specifically, the invention describes a method and apparatus for enhancing the appearance of motion on an LCD panel display.
2. Overview
Each pixel of an LCD panel can be directed to assume a luminance value discretized to the standard set [0, 1, 2, . . . , 255] where a triplet of such pixels provides the R, G, and B components that make up an arbitrary color which is updated each frame time, typically 1/60th of a second. The problem with LCD pixels is that they respond sluggishly to an input command in that the pixels arrive at their target values only after several frames have elapsed, and the resulting display artifacts—“ghost” images of rapidly moving objects—are disconcerting. Ghosting occurs when the response speed of the LCD is not fast enough to keep up with the frame rate. In this case, the transition from one pixel value to another cannot be attained within the desired frame time since LCDs rely on the ability of the liquid crystal to orient itself under the influence of an electric field. Therefore, since the liquid crystal must physically move in order to change intensity, the viscous nature of the liquid crystal material itself contributes to the appearance of ghosting artifacts.
In order to reduce and/or eliminate this deterioration in image quality, the LC response time is reduced by overdriving the pixel values such that a target pixel value (t) is reached, or almost reached, within a single frame period. In particular, by biasing the input voltage of a given pixel to an overdriven pixel value that exceeds the target pixel value for the current frame, the transition between the starting pixel value and target pixel value is accelerated in such a way that the pixel is driven to the target pixel value within the designated frame period. However, in order to efficiently calculate the overdrive pixel value, LCD overdrive table is commonly used that provides the appropriate overdrive pixel value that corresponds to a start, target pixel pair.
Although the LCD overdrive table is a standard and effective scheme often used in practice; this invention offers an alternative that reduces the ROM table storage requirements and offers a simplified runtime operation.
SUMMARY OF THE DISCLOSURE
In a liquid crystal display (LCD) panel having a number of LCD pixels, a method for providing a LCD pixel response time corresponding to a period of time required for a selected LCD pixel at a starting pixel value to reach a target pixel value.
Each of the LCD pixels is modeled as a second order dynamical system represented as a second order differential equation (m{umlaut over (x)}+k{dot over (x)}+x=p) wherein x, {dot over (x)}, and p represent an LCD pixel strength, an LCD pixel velocity, and an applied LCD pixel command, respectively, and wherein m and k represent an LCD pixel mass and associated pixel damping factor, respectively. The LCD pixel response of the selected pixel under the influence of an imposed command p is calculated based upon the second order differential equation when the selected LCD pixel has an initial LCD pixel strength value of x0 and an associated pixel velocity value of v0.
In yet another embodiment, computer program product for providing a LCD pixel response time corresponding to a period of time required for a selected LCD pixel at a starting pixel value to reach a target pixel value associated with an overdrive pixel value in a liquid crystal display (LCD) panel having a number of LCD pixels is described. The computer program product includes computer code for modeling each of the LCD pixels as a second order dynamical system represented as a second order differential equation (m{umlaut over (x)}+k{dot over (x)}+x=p) wherein x, {dot over (x)} and p represent an LCD pixel strength, an associated pixel velocity, and an applied LCD pixel command, respectively, and wherein m and k represent an LCD pixel mass and associated pixel damping factor, respectively. The computer program product also includes computer code for calculating LCD pixel response data of the selected pixel under the influence of an imposed command p based upon the second order differential equation when the selected LCD pixel has an initial LCD pixel strength value of x0 and an associated pixel velocity value of v0, and computer readable medium for storing the computer code.
In still another embodiment, an apparatus coupled to a liquid crystal display (LCD) panel having a number of LCD pixels for providing an overdrive pixel value associated with a LCD pixel response time corresponding to a period of time required for a selected LCD pixel at a starting pixel value to reach a target pixel value is described. The apparatus includes an overdrive pixel value generator arranged to calculate a LCD pixel response data of a selected pixel under the influence of an imposed command p based upon a second order dynamical system model represented as a second order differential equation (m{umlaut over (x)}+k{dot over (x)}+x=p) wherein x, {dot over (x)} and p represent an LCD pixel strength, an associated pixel velocity, and an applied LCD pixel command, respectively, and wherein m and k represent an LCD pixel mass and associated pixel damping factor, respectively when the selected LCD pixel has an initial LCD pixel strength value of x0 and an associated pixel velocity value of v0.



FIG. 1 shows a standard blending function (namely β(x)=3x2−2x3).
FIG. 2 illustrates a system employed to implement the invention.
FIG. 3 illustrates a process in accordance with the invention.



DETAILED DESCRIPTION OF SELECTED EMBODIMENTS
Reference will now be made in detail to a particular embodiment of the invention an example of which is illustrated in the accompanying drawings. While the invention will be described in conjunction with the particular embodiment, it will be understood that it is not intended to limit the invention to the described embodiment. To the contrary, it is intended to cover alternatives, modifications, and equivalents as may be included within the spirit and scope of the invention as defined by the appended claims.
In order to improve the performance of slow LCD panels, the performance of the LCD panel is first characterized by, for example, taking a series of measurements that show what each pixel will do by the end of one frame time. Such measurements are taken for a representative pixel (or pixels) each being initially at a starting pixel value s that is then commanded toward a target value t (where s and t each take on integer values from 0 to 255). If the pixel value actually attained in one frame time is p, then

p=ƒs(t)  (1)

where ƒs is the one-frame pixel-response function corresponding to a fixed start-pixel s. For example, the one-frame pixel response function ƒs(t) for a pixel having a start pixel value s=32 and a target pixel value t=192 that can only reach a pixel value p=100 is represented as ƒ32(192)=100. For slow panels (where most if not all targets can not be reached within a frame time) maximum effort curves defined by functions




  {
  
     
    
      
        
          
            
              m
              ⁡
              
                (
                s
                )
              
            
            =
            
              
                f
                s
              
              ⁡
              
                (
                0
                )
              
            
          
        
      
      
        
          
            
              M
              ⁡
              
                (
                s
                )
              
            
            =
            
              
                f
                s
              
              ⁡
              
                (
                255
                )
              
            
          
        
      
    
  




give the minimum pixel value and maximum pixel value, respectively, reachable in one frame time as functions of the start pixel s.

It should be noted that for the sake of simplicity, in the remainder of this discussion, any reference to an overdrive table refers to what is known in the art as a standard overdrive table having saturation regions SM and Sm bounded by maximum effort curves M(s) and m(s), respectively. It is well to note, however, that any appropriate overdrive table, such as an extended overdrive table discussed in more detail in co-pending U.S. patent application Ser. No. 11/060,876 by Halfant that is incorporated by reference in its entirety for all purposes, is also well suited for use with the invention.
Therefore, in order to reach a pixel value p that lies within the interval [m(s), M(s)], equation (1) is solved for the argument t that produces pixel value p. The argument t is referred to as the overdrive pixel value that will achieve the goal (i.e., pixel value p) in one frame time. If p<m(s), then the overdrive pixel value is taken as having a best-effort value of 0, with m(s) being the best-effort result achieved. Likewise, if p>M(s) then the overdrive pixel is taken to be 255, with M(s) being the best-effort result. Thus, for a given start pixel s, overdrive function gs can be defined by equation 2 as




  
    
      
        
          
            g
            s
          
          ⁡
          
            (
            p
            )
          
        
        =
        
          {
          
            
              
                
                  0
                  ,
                
              
              
                
                  p
                  <
                  
                    m
                    ⁡
                    
                      (
                      s
                      )
                    
                  
                
              
            
            
              
                
                  
                    
                      f
                      s
                      
                        -
                        1
                      
                    
                    ⁡
                    
                      (
                      p
                      )
                    
                  
                  ,
                
              
              
                
                  
                    m
                    ⁡
                    
                      (
                      s
                      )
                    
                  
                  ≤
                  p
                  ≤
                  
                    M
                    ⁡
                    
                      (
                      s
                      )
                    
                  
                
              
            
            
              
                
                  255
                  ,
                
              
              
                
                  p
                  >
                  
                    M
                    ⁡
                    
                      (
                      s
                      )
                    
                  
                
              
            
          
        
      
    
    
      
        (
        2
        )
      
    
  




In this way, the overdrive pixel value is effective in compelling the pixel to reach its target value in the non-saturation region and M(s) and m(s) in the saturation regions SM and Sm, respectively.
Instead of relying upon a static overdrive table, a dynamical systems approach offers a simple and efficient runtime procedure for estimating an overdrive pixel value that is based on the hypothesis that LCD pixels can be adequately described as second-order linear dynamical systems, or by several such approximations each acting within a sub-region of start-target space. The dynamical systems approach embraces the notion of state, which requires knowledge of intensity (“position”) and velocity for second-order systems, and it shows how the state vector is methodically updated under the action of an imposed pixel force. The order is taken as 2, as shown in the differential equation (3)

m{umlaut over (x)}+kv+x=p  (3)

where x represents the LCD pixel strength or pixel value, v represents the LCD pixel velocity or change of pixel value with respect to time {dot over (x)} (which can be used interchangeably with the term v) and p is the applied pixel voltage which in one embodiment is constant throughout the frame time, and m and k are the mass and damping, respectively, where m represents the “inertia” or resistance that a pixel presents with respect to a change in its pixel value, much like mass in a dynamic system and the damping factor k represents an inherent nature of the LCD pixel (modeled as a dynamic system) that tends to reduce the amplitude of oscillations of that dynamic system. It should be noted that if p is held permanently fixed, then p=x in the steady-state where both {umlaut over (x)} and v, are 0.
The general solution of (3) can be written as the sum of any particular solution and the general solution of the associated homogeneous equation

m{umlaut over (x)}+k{dot over (x)}+x=0  (4)

A particular solution of (3) is seen by inspection to be x=p. General solutions of (4) are found by substitution of the trial solution x=eαt where α is a constant:

mα2eαt+kαeαt+eαt=(mα2+kα+1)eαt=0

Since eαt never vanishes, then α must satisfy the quadratic equation

mα2+kα+1=0  (5)

This admits of two roots:




  
    
      
        
          
            α
            1
          
          =
          
            
              
                -
                k
              
              +
              
                
                  
                    k
                    2
                  
                  -
                  
                    4
                    ⁢
                    m
                  
                
              
            
            
              2
              ⁢
              m
            
          
        
        ,
        
          
            α
            2
          
          =
          
            
              
                -
                k
              
              -
              
                
                  
                    k
                    2
                  
                  -
                  
                    4
                    ⁢
                    m
                  
                
              
            
            
              2
              ⁢
              m
            
          
        
      
    
    
      
        (
        6
        )
      
    
  




If k2−4 m<0 then the roots are complex and the system oscillates about its limiting value. In the case where the damping is high and the mass is small (thus, k2−4m>0) both roots are real and in fact negative, α1 is only slightly negative it is referred to as the “slow root” and determines the system's settling rate whereas α2 is the “fast root” and influences the system's initial response behavior.
Given α1 and α2, the general solution to (3) can be written as

x=c1eα1t+c2eα2t+p  (7)

where the constants c1 and c2 are chosen to fit the initial conditions on x and {dot over (x)} at t=0. Differentiating (7) gives

{dot over (x)}=c1α1eα1t+c2α2eα2t=v  (8)

(note: the symbol “v” is substituted hereinafter for {dot over (x)} with regards to pixel velocity)
Letting x0=x(0) and {dot over (x)}0={dot over (x)}(0)=v(0)=v0, and substituting t=0 into (7) and (8), gives the pair of equations:




  
    
      
        {
        
          
            
              
                
                  x
                  0
                
                =
                
                  
                    c
                    1
                  
                  +
                  
                    c
                    2
                  
                  +
                  p
                
              
            
          
          
            
              
                
                  v
                  0
                
                =
                
                  
                    
                      c
                      1
                    
                    ⁢
                    
                      α
                      1
                    
                  
                  +
                  
                    
                      c
                      2
                    
                    ⁢
                    
                      α
                      2
                    
                  
                
              
            
          
        
      
    
    
      
        (
        9
        )
      
    
  




Solving for c1 and c2 yields




  
    
      
        
          
            c
            1
          
          =
          
            
              
                -
                
                  v
                  0
                
              
              +
              
                
                  α
                  2
                
                ⁡
                
                  (
                  
                    
                      x
                      0
                    
                    -
                    p
                  
                  )
                
              
            
            
              
                α
                2
              
              -
              
                α
                1
              
            
          
        
        ,
        
          
            c
            2
          
          =
          
            
              
                v
                0
              
              -
              
                
                  α
                  1
                
                ⁡
                
                  (
                  
                    
                      x
                      0
                    
                    -
                    p
                  
                  )
                
              
            
            
              
                α
                2
              
              -
              
                α
                1
              
            
          
        
      
    
    
      
        (
        10
        )
      
    
  




This, in conjunction with (7) and (8), is a complete solution that predicts how a pixel, starting at a given value x0 and velocity v0, will evolve under the influence of an imposed command p. Choosing the frame time ( 1/60th second) as the unit of time, the effect at the end of the frame can be resolved by substituting t=1 into (7) and (8):




  
    
      
        {
        
          
            
              
                
                  x
                  1
                
                =
                
                  
                    
                      c
                      1
                    
                    ⁢
                    
                      e
                      
                        α
                        1
                      
                    
                  
                  +
                  
                    
                      c
                      2
                    
                    ⁢
                    
                      e
                      
                        α
                        2
                      
                    
                  
                  +
                  p
                
              
            
          
          
            
              
                
                  v
                  1
                
                =
                
                  
                    
                      c
                      1
                    
                    ⁢
                    
                      α
                      1
                    
                    ⁢
                    
                      e
                      
                        α
                        1
                      
                    
                  
                  +
                  
                    
                      c
                      2
                    
                    ⁢
                    
                      α
                      2
                    
                    ⁢
                    
                      e
                      
                        α
                        2
                      
                    
                  
                
              
            
          
        
      
    
    
      
        (
        11
        )
      
    
  




where c1 and c2 are given by (10). In order to pass from each frame to the next, both x and v must be computed at each step and therefore without a knowledge of both these quantities at the beginning of a frame, the response to the command pixel p imposed during the frame can not be predicted. The constants c1 and c2 given in (10) incorporate runtime data (x, v, p) together with model data (α1, α2) and therefore cannot be stored in a ROM. Equation (11) is rewritten in a form that separates model and runtime variables:




  
    
      
        {
        
          
            
              
                
                  x
                  
                    n
                    +
                    1
                  
                
                =
                
                  
                    Ax
                    n
                  
                  +
                  
                    Bv
                    n
                  
                  +
                  Cp
                
              
            
          
          
            
              
                
                  v
                  
                    n
                    +
                    1
                  
                
                =
                
                  
                    Dx
                    n
                  
                  +
                  
                    Ev
                    n
                  
                  +
                  Fp
                
              
            
          
        
      
    
    
      
        (
        12
        )
      
    
  




This shows the iterative nature going from frame n to n+1 (instead of simply from 0 to 1 as before). The runtime coefficients A, B, . . . , F depend on α1 and α2 (or equivalently, on m and k) and can be stored in a ROM. With m, k given, the roots α1, α2 are determined from equation (6). Substituting the coefficients c1, c2 from equation (10) into equation (11) and collecting terms in x0, v0, and p on the right, gives the expressions




  {
  
     
    
      
        
          
            
              x
              1
            
            =
            
              
                Ax
                0
              
              +
              
                Bv
                0
              
              +
              Cp
            
          
        
      
      
        
          
            
              v
              1
            
            =
            
              
                Dx
                0
              
              +
              
                Ev
                0
              
              +
              Fp
            
          
        
      
    
  




where the runtime coefficients A, B, . . . , F are defined as:




  {
  
     
    
      
        
          
            A
            =
            
              
                
                  
                    α
                    2
                  
                  ⁢
                  
                    e
                    
                      α
                      1
                    
                  
                
                -
                
                  
                    α
                    1
                  
                  ⁢
                  
                    e
                    
                      α
                      2
                    
                  
                
              
              
                
                  α
                  2
                
                -
                
                  α
                  1
                
              
            
          
        
      
      
        
          
            B
            =
            
              
                
                  -
                  
                    e
                    
                      α
                      1
                    
                  
                
                +
                
                  e
                  
                    α
                    2
                  
                
              
              
                
                  α
                  2
                
                -
                
                  α
                  1
                
              
            
          
        
      
      
        
          
            C
            =
            
              
                
                  
                    
                      -
                      
                        α
                        2
                      
                    
                    ⁢
                    
                      e
                      
                        α
                        1
                      
                    
                  
                  +
                  
                    
                      α
                      1
                    
                    ⁢
                    
                      e
                      
                        α
                        2
                      
                    
                  
                
                
                  
                    α
                    2
                  
                  -
                  
                    α
                    1
                  
                
              
              +
              1
            
          
        
      
      
        
          
            D
            =
            
              
                
                  
                    α
                    1
                  
                  ⁢
                  
                    α
                    2
                  
                
                
                  
                    α
                    2
                  
                  -
                  
                    α
                    1
                  
                
              
              ⁢
              
                (
                
                  
                    e
                    
                      α
                      1
                    
                  
                  -
                  
                    e
                    
                      α
                      2
                    
                  
                
                )
              
            
          
        
      
      
        
          
            E
            =
            
              
                
                  
                    -
                    
                      α
                      1
                    
                  
                  ⁢
                  
                    e
                    
                      α
                      1
                    
                  
                
                +
                
                  
                    α
                    2
                  
                  ⁢
                  
                    e
                    
                      α
                      2
                    
                  
                
              
              
                
                  α
                  2
                
                -
                
                  α
                  1
                
              
            
          
        
      
      
        
          
            F
            =
            
              
                
                  
                    α
                    1
                  
                  ⁢
                  
                    α
                    2
                  
                
                
                  
                    α
                    2
                  
                  -
                  
                    α
                    1
                  
                
              
              ⁢
              
                (
                
                  
                    -
                    
                      e
                      
                        α
                        1
                      
                    
                  
                  +
                  
                    e
                    
                      α
                      2
                    
                  
                
                )
              
            
          
        
      
    
  




These are the same coefficients that enter equation (12), for they depend only on α1, α2 (or equivalently on m, k which determine them through (6)), and not on the iteration index—that is, going from 0 to 1 is the same as going from n to n+1.
During runtime, assume an initial “quiescent” state with x0 and v0 both 0 (i.e., steady black screen) and let p1 be the pixel desired for frame 1, or in the general case that starts at frame n with known (or at least predicted) values xn and vn, and that pn+1 is the value that is wanted for frame n+1. That is, in (12) force xn+1=pn+1, which means what is required is a command pixel p that will force the first equation of (12) to take the form pn+1=Axn+Bvn+Cp. In this case, p is just the solution of this equation:




  
    
      
        
          P
          ideal
        
        =
        
          
            1
            C
          
          ⁢
          
            (
            
              
                p
                
                  n
                  +
                  1
                
              
              -
              
                Ax
                n
              
              -
              
                Bv
                n
              
            
            )
          
        
      
    
    
      
        (
        13
        )
      
    
  




(It should be noted that the reciprocal of the constant C is either stored in the ROM or computed once at init time, and is afterwards used as a multiplier.) Since the applied pixel command p must be an integer in the range 0 to 255, equation (13) is replaced with




  
    
      
        p
        =
        
          round
          (
          
            Clamp
            ⁢
            
              {
              
                
                  
                    
                      p
                      
                        n
                        +
                        1
                      
                    
                    -
                    
                      Ax
                      n
                    
                    -
                    
                      Bv
                      n
                    
                  
                  C
                
                ,
                0
                ,
                255
              
              }
            
          
          )
        
      
    
    
      
        (
        14
        )
      
    
  




    
    
        where the Clamp notation has the meaning of clamping its first argument to the range 0 to 255 if necessary. This p is the overdrive pixel which is inserted into (12) to determine the resulting xn+1 and vn+1.
    
    


Given the hypothesis of a linear second-order dynamical system, the defining parameters m and k can be determined by any of a number of standard “system identification” techniques (such as Matlab's Identification Toolbox). Conceptually, numerous candidate pairs of m and k, taken together, are “tried” in the mathematical model, to see which pair of values causes to model to most-nearly match the measured pixel response data.
To illustrate the runtime operation, suppose that a particular panel has been characterized as being approximately a second-order linear dynamical system with m=0.5, k=2.0. Then the runtime coefficients A, B, . . . , F take on the values




  {
  
     
    
      
        
          
            A
            =
            0.6551
          
        
      
      
        
          
            B
            =
            0.1852
          
        
      
      
        
          
            C
            =
            0.3349
          
        
      
      
        
          
            D
            =
            
              -
              0.3704
            
          
        
      
      
        
          
            E
            =
            
              -
              0.0756
            
          
        
      
      
        
          
            F
            =
            0.3704
          
        
      
    
  




Let's use x0=0, v0=0 to represent the initial pixel strength and velocity as appropriate for a video sequence starting with a steady black screen. Let's assume that the first non-black screen calls for the pixel p1 to take the value 128:

p1=128

We use equation (13) to find the ideal input pixel command, pideal, to achieve this result:




  
    p
    ideal
  
  =
  
    
      
        1
        C
      
      ⁢
      
        (
        
          
            p
            1
          
          -
          
            Ax
            o
          
          -
          
            Bv
            0
          
        
        )
      
    
    =
    
      
        128
        0.3349
      
      =
      382.2
    
  




However, as shown in equation (14), this value must be clamped to 255, which is the largest applied pixel command we can issue:

p=round(Clamp(pideal, 0, 255))=255

This is the command input used in the equations (12) to compute the pixel and velocity values achieved at the end of the first frame:




  {
  
     
    
      
        
          
            
              x
              1
            
            =
            
              
                
                  Ax
                  0
                
                +
                
                  Bv
                  0
                
                +
                Cp
              
              =
              
                
                  0
                  +
                  0
                  +
                  
                    0.3349
                    ·
                    255
                  
                
                =
                85.40
              
            
          
        
      
      
        
          
            
              v
              1
            
            =
            
              
                
                  Dx
                  0
                
                +
                
                  Ev
                  0
                
                +
                Fp
              
              =
              
                
                  0
                  +
                  0
                  +
                  
                    0.3704
                    ·
                    255
                  
                
                =
                94.45
              
            
          
        
      
    
  




As we can see, due to the truncation of Pideal we have not come very close to our target pixel value of 128; but we will now use the value we did achieve—85.40—as the starting value for the next iteration. Let's say the required pixel value for the second frame is p2=137. Using the values x1 and v1 just computed, we find the ideal pixel input command, from (13) to be:




   
  
    
      
        
          
            p
            ideal
          
          =
          
            
              1
              C
            
            ⁢
            
              (
              
                
                  p
                  2
                
                -
                
                  Ax
                  1
                
                -
                
                  Bv
                  1
                
              
              )
            
          
        
      
    
    
      
        
          =
          
            
              1
              0.3349
            
            ⁢
            
              (
              
                137
                -
                
                  0.6551
                  ·
                  85.40
                
                -
                
                  0.1852
                  ·
                  94.45
                
              
              )
            
          
        
      
    
    
      
        
          =
          189.8
        
      
    
  




Since pideal does not need to be clamped, we expect to get quite close to our goal of 137 using the rounded command p=190 back in the update equations (12):




   
  
    {
    
      
        
          
            
              x
              2
            
            =
            
              
                Ax
                1
              
              +
              
                Bv
                1
              
              +
              Cp
            
          
        
      
      
        
          
            
              
            
            ⁢
            
              =
              
                
                  0.6651
                  ·
                  85.40
                
                +
                
                  0.1852
                  ·
                  94.45
                
                +
                
                  0.3349
                  ·
                  190
                
              
            
          
        
      
      
        
          
            
              
            
            ⁢
            
              =
              137.1
            
          
        
      
      
        
          
            
              v
              2
            
            =
            
              
                Dx
                1
              
              +
              
                Ev
                1
              
              +
              Fp
            
          
        
      
      
        
          
            
              
            
            ⁢
            
              =
              
                
                  
                    -
                    0.3704
                  
                  ·
                  85.40
                
                -
                
                  0.0756
                  ·
                  94.45
                
                +
                
                  0.3704
                  ·
                  190
                
              
            
          
        
      
      
        
          
            
              
            
            ⁢
            
              =
              31.60
            
          
        
      
    
  




In the same manner, we may use the values x2 and v2 to compute the next overdrive pixel command, p, given any new required third-frame pixel, p3.
The (m, k) pair value that best fits the entire panel may work better for some regions of the staff-target matrix than others. By best fit it is meant the values of m and k that when used in the dynamical model of the LCD pixel provides a corresponding LCD pixel response that most-nearly matches the measured LCD pixel response data for the LCD panel. Typically we can do better if we split the space of start-target pairs into sub-domains and devise separate approximations on each. One obvious separation is along the main diagonal (where start=target): on one side, start<target and we are in the domain of brightening operations; on the other, start<target and we are in the domain of dimming operations. Let's refer to these as domains D1 and D2, respectively.
The approximations (m1, k1) and (m2, k2) on each of these respective domains is a better approximation than that afforded by the original (m, k) which had to accommodate the full scope of start-target operations. We end up with two sets of runtime coefficients:




  {
  
    
      
        
          
            D
            ⁢
            
              
            
            ⁢
            1
            ⁢
            
              :
            
            ⁢
            
              
            
            ⁢
            
              A
              1
            
          
          ,
          
            B
            1
          
          ,
          
            C
            1
          
          ,
          
            D
            1
          
          ,
          
            E
            1
          
          ,
          
            F
            1
          
        
      
    
    
      
        
          
            D
            ⁢
            
              
            
            ⁢
            2
            ⁢
            
              :
            
            ⁢
            
              
            
            ⁢
            
              A
              2
            
          
          ,
          
            B
            2
          
          ,
          
            C
            2
          
          ,
          
            D
            2
          
          ,
          
            E
            2
          
          ,
          
            F
            2
          
        
      
    
  
   




This is easily applied at runtime: if the target pixel is greater than the start pixel, it's a brightening operation and we use the D1 coefficients; in the opposite case of a dimming operation, we use the D2 coefficients.
Further accuracy can be achieved by additional subdivisions of D1 and D2. For example, a panel brightening from the dark region (small start pixel values) may behave more sluggishly (larger m) than when starting from midrange or brighter regions. For illustration, let's use 32 as the separation point, and define two domains:




  {
  
    
      
        
          
            D
            ⁢
            
              
            
            ⁢
            1
            ⁢
            a
            ⁢
            
              :
            
            ⁢
            
              
            
            ⁢
            start
            ⁢
            
              
            
            ⁢
            pixel
          
          <
          32
        
      
    
    
      
        
          
            D
            ⁢
            
              
            
            ⁢
            1
            ⁢
            b
            ⁢
            
              :
            
            ⁢
            
              
            
            ⁢
            start
            ⁢
            
              
            
            ⁢
            pixel
          
          ≥
          32
        
      
    
  
   




These (sub-)domains will determine two parameter pairs, (m1a, k1a) and (m1b, k1b), respectively, each in turn with its own set of derived coefficients:




  {
  
    
      
        
          
            D
            ⁢
            
              
            
            ⁢
            1
            ⁢
            a
            ⁢
            
              :
            
            ⁢
            
              
            
            ⁢
            
              A
              
                1
                ⁢
                a
              
            
          
          ,
          
            B
            
              1
              ⁢
              a
            
          
          ,
          
            C
            
              1
              ⁢
              a
            
          
          ,
          
            D
            
              1
              ⁢
              a
            
          
          ,
          
            E
            
              1
              ⁢
              a
            
          
          ,
          
            F
            
              1
              ⁢
              a
            
          
        
      
    
    
      
        
          
            D
            ⁢
            
              
            
            ⁢
            1
            ⁢
            b
            ⁢
            
              :
            
            ⁢
            
              
            
            ⁢
            
              A
              
                1
                ⁢
                b
              
            
          
          ,
          
            B
            
              1
              ⁢
              b
            
          
          ,
          
            C
            
              1
              ⁢
              b
            
          
          ,
          
            D
            
              1
              ⁢
              b
            
          
          ,
          
            E
            
              1
              ⁢
              b
            
          
          ,
          
            F
            
              1
              ⁢
              b
            
          
        
      
    
  
   




But now there is a potential problem that didn't arise when working just with D1 and D2: visual artifacts may develop due to the sudden switching of coefficients when the start pixels cross the separation value of 32 (either spatially or temporally). This is a standard problem, and is handled by a technique known as blending.
To begin with, we define a transition region over which the blending will occur. In our example, let it span a region extending 5 pixel-values on either side of the separation point; that is, let it extend from T0=32−5=27 to T1=32+5=37. Thus the width of the transition region is 10, and it covers the interval (27, 37). The idea is that brightening operations with a start pixel≦27 will be handled with the D1a coefficients, those with a start pixel≧37 will be handled using the D2 coefficients, but those with a start pixel in the transition region will be handled with a blending of calculations using both sets of coefficients.
One simple approach uses transition coordinates that go from 0 to 1 on the transition region (which in our pixel coordinates goes from 27 to 37). Standard transition coordinates allow the use of standard blending functions such as ,β(x)=3x2−2x3, shown in the FIG. 1.
Assuming a brightening start-target pair with the start pixel, s, lying in the transition region—say, s=30. We'll start by computing the command pixel, p, and updated pixel, x, and velocity, v, using both D1a and D1b coefficients; let's suppose the results are




  {
  
    
      
        
          D
          ⁢
          
            
          
          ⁢
          1
          ⁢
          a
          ⁢
          
            :
          
        
      
      
        
          
            
              p
              a
            
            =
            231
          
          ,
        
      
      
        
          
            
              x
              a
            
            =
            131.4
          
          ,
        
      
      
        
          
            v
            a
          
          =
          78.63
        
      
    
    
      
        
          D
          ⁢
          
            
          
          ⁢
          1
          ⁢
          b
          ⁢
          
            :
          
        
      
      
        
          
            
              p
              b
            
            =
            192
          
          ,
        
      
      
        
          
            
              s
              b
            
            =
            130.7
          
          ,
        
      
      
        
          
            v
            b
          
          =
          105.6
        
      
    
  
   




As to the blending of these results, we begin by converting s to the transition-coordinate equivalent:




  t
  =
  
    
      
        s
        -
        
          T
          0
        
      
      
        
          T
          1
        
        -
        
          T
          0
        
      
    
    =
    
      
        
          30
          -
          27
        
        
          37
          -
          27
        
      
      =
      0.3
    
  




Schematically, the blending will take the form

(D1a)·(1−β(t))+(D1b)·β(t)

and specifically, applying this to the command pixel gives:




   
  
    
      
        
          p
          =
          
          ⁢
          
            
              
                
                  p
                  a
                
                ·
                
                  (
                  
                    1
                    -
                    
                      β
                      ⁡
                      
                        (
                        t
                        )
                      
                    
                  
                  )
                
              
              +
              
                
                  p
                  b
                
                ·
                
                  β
                  ⁡
                  
                    (
                    t
                    )
                  
                
              
            
            =
            
              
                231
                ·
                
                  (
                  
                    1
                    -
                    
                      β
                      ⁡
                      
                        (
                        0.3
                        )
                      
                    
                  
                  )
                
              
              +
              
                192
                ·
                
                  β
                  ⁡
                  
                    (
                    0.3
                    )
                  
                
              
            
          
        
      
    
    
      
        
          =
          
          ⁢
          
            
              
                231
                ·
                0.7840
              
              +
              
                192
                ·
                0.2160
              
            
            =
            222.576
          
        
      
    
  




which we would round to a command pixel=223; the same blending operation also gives us also the updated pixel value and velocity:




   
  
    {
    
       
      
        
          
            
              x
              =
              
                
                  
                    
                      x
                      a
                    
                    ·
                    
                      (
                      
                        1
                        -
                        
                          β
                          ⁡
                          
                            (
                            t
                            )
                          
                        
                      
                      )
                    
                  
                  +
                  
                    
                      x
                      b
                    
                    ·
                    
                      β
                      ⁡
                      
                        (
                        t
                        )
                      
                    
                  
                
                =
                
                  
                    
                      131.4
                      ·
                      0.7840
                    
                    +
                    
                      130.7
                      ·
                      0.2160
                    
                  
                  =
                  131.2488
                
              
            
          
        
        
          
            
              v
              =
              
                
                  
                    
                      v
                      a
                    
                    ·
                    
                      (
                      
                        1
                        -
                        
                          β
                          ⁡
                          
                            (
                            t
                            )
                          
                        
                      
                      )
                    
                  
                  +
                  
                    
                      v
                      b
                    
                    ·
                    
                      β
                      ⁡
                      
                        (
                        t
                        )
                      
                    
                  
                
                =
                
                  
                    
                      78.63
                      ·
                      0.7840
                    
                    +
                    
                      105.6
                      ·
                      0.2160
                    
                  
                  =
                  84.4555
                
              
            
          
        
      
    
  




Thus, the blended command pixel and update values are




  {
  
     
    
      
        
          
            p
            =
            223
          
        
      
      
        
          
            x
            =
            131.2488
          
        
      
      
        
          
            x
            =
            84.4555
          
        
      
    
  




FIG. 2 illustrates a system 200 employed to implement the invention. Computer system 200 is only an example of a graphics system in which the present invention can be implemented. System 200 includes central processing unit (CPU) 210, random access memory (RAM) 220, read only memory (ROM) 225, one or more peripherals 230, graphics controller 460, primary storage devices 240 and 250, and digital display unit 270. CPUs 210 are also coupled to one or more input/output devices 290. Graphics controller 260 generates image data and a corresponding reference signal, and provides both to digital display unit 270. The image data can be generated, for example, based on pixel data received from CPU 210 or from an external encode (not shown). In one embodiment, the image data is provided in RGB format and the reference signal includes the VSYNC and HSYNC signals well known in the art. However, it should be understood that the present invention can be implemented with image, data and/or reference signals in other formats.
FIG. 3 shows a flowchart detailing a process 300 in accordance with an embodiment of the invention. At 302, modeling response of each of the LCD pixels as a second order dynamicalsystem represented as a second order differential equation, at 304, calculating LCD pixel response data of the selected pixel under the influence of an imposed command the applied voltage based upon the second order differential equation, at 306, determining a best fit (m, k) pair values, at 308, Calculating roots (α1α2) of the second order differential equation based upon the best fit (m, k) values, at 310 calculating a set of runtime coefficients {A, B, C, D, E, F}, at 312 computing the next pixel valuen+1 and the next pixel velocity valuen+1 for the a next frame n+1, at 314, calculating an ideal pixel strength with initial condition x=0 and v=0, at 316, calculating an ideal pixel strength Pideal, at 318, Generating the overdrive pixel value based upon a clamped ideal pixel strength Pideal, at 320, using the overdrive pixel value to update the current pixel valuen and the current pixel velocity valuen from a current frame to a next frame.
Although only a few embodiments of the present invention have been described, it should be understood that the present invention may be embodied in many other specific forms without departing from the spirit or the scope of the present invention. The present examples are to be considered as illustrative and not restrictive, and the invention is not to be limited to the details given herein, but may be modified within the scope of the appended claims along with their full scope of equivalents.
While this invention has been described in terms of a particular embodiment, there are alterations, permutations, and equivalents that fall within the scope of this invention. It should also be noted that there are many alternative ways of implementing both the process and apparatus of the present invention. It is therefore intended that the invention be interpreted as including all such alterations, permutations, and equivalents as fall within the true spirit and scope of the present invention.

## Claims

1. In a liquid crystal display (LCD) panel having a number of LCD pixels, a method for providing a LCD pixel response time corresponding to a period of time required for a selected LCD pixel at a starting pixel value to reach a target pixel value associated with an overdrive pixel value, comprising:
modeling response of each of the LCD pixels as a second order dynamical system represented as a second order differential equation (m{umlaut over (x)}+kv+x=p) wherein x, v and p represent an LCD pixel value, an associated change in pixel value with respect to time, and an applied LCD pixel voltage, respectively, and wherein m and k represent an LCD pixel mass and associated pixel damping factor, respectively;
calculating LCD pixel response data of the selected pixel under the influence of the applied voltage p based upon the second order differential equation m{umlaut over (x)}+kv+x=p when the selected LCD pixel has an initial LCD pixel value of x0 and an associated pixel velocity value of v0;
determining a best fit (m, k) pair values, wherein the best fit (m,k) values are those values of m and k that result in a calculated LCD pixel response that most-nearly matches a measured LCD pixel response for the LCD panel; and
calculating α1 and α2 based upon the best fit (m, k) pair values, wherein





  
    
      α
      1
    
    =
    
      
        
          -
          k
        
        +
        
          
            
              k
              2
            
            -
            
              4
              ⁢
              m
            
          
        
      
      
        2
        ⁢
        m
      
    
  
  ,
  
    
      α
      2
    
    =
    
      
        
          -
          k
        
        -
        
          
            
              k
              2
            
            -
            
              4
              ⁢
              m
            
          
        
      
      
        2
        ⁢
        m
      
    
  
  ,




wherein α1 and α2 are roots of the second order differential equation m{umlaut over (x)}+kv+x=p.

2. A method as recited in claim 1, further comprising:
calculating a set of runtime coefficients {A, B, C, D, E, F} as





  {
  
     
    
      
        
          
            A
            =
            
              
                
                  
                    α
                    2
                  
                  ⁢
                  
                    e
                    
                      α
                      1
                    
                  
                
                -
                
                  
                    α
                    1
                  
                  ⁢
                  
                    e
                    
                      α
                      2
                    
                  
                
              
              
                
                  α
                  2
                
                -
                
                  α
                  1
                
              
            
          
        
      
      
        
          
            B
            =
            
              
                
                  -
                  
                    e
                    
                      α
                      1
                    
                  
                
                +
                
                  e
                  
                    α
                    2
                  
                
              
              
                
                  α
                  2
                
                -
                
                  α
                  1
                
              
            
          
        
      
      
        
          
            C
            =
            
              
                
                  
                    
                      -
                      
                        α
                        2
                      
                    
                    ⁢
                    
                      e
                      
                        α
                        1
                      
                    
                  
                  +
                  
                    
                      α
                      1
                    
                    ⁢
                    
                      e
                      
                        α
                        2
                      
                    
                  
                
                
                  
                    α
                    2
                  
                  -
                  
                    α
                    1
                  
                
              
              +
              1
            
          
        
      
      
        
          
            D
            =
            
              
                
                  
                    α
                    1
                  
                  ⁢
                  
                    α
                    2
                  
                
                
                  
                    α
                    2
                  
                  -
                  
                    α
                    1
                  
                
              
              ⁢
              
                (
                
                  
                    e
                    
                      α
                      1
                    
                  
                  -
                  
                    e
                    
                      α
                      2
                    
                  
                
                )
              
            
          
        
      
      
        
          
            E
            =
            
              
                
                  
                    -
                    
                      α
                      1
                    
                  
                  ⁢
                  
                    e
                    
                      α
                      1
                    
                  
                
                +
                
                  
                    α
                    2
                  
                  ⁢
                  
                    e
                    
                      α
                      2
                    
                  
                
              
              
                
                  α
                  2
                
                -
                
                  α
                  1
                
              
            
          
        
      
      
        
          
            F
            =
            
              
                
                  
                    α
                    1
                  
                  ⁢
                  
                    α
                    2
                  
                
                
                  
                    α
                    2
                  
                  -
                  
                    α
                    1
                  
                
              
              ⁢
              
                (
                
                  
                    -
                    
                      e
                      
                        α
                        1
                      
                    
                  
                  +
                  
                    e
                    
                      α
                      2
                    
                  
                
                )
              
            
          
        
      
    
  



wherein the runtime coefficients {A, B, C, D, E, F } are constants used to compute a next pixel value xn+1 from a current pixel value xn and to compute a next pixel velocity value vn+1 from a current pixel velocity value vn.

3. A method as recited in claim 2, further comprising:
computing the next pixel value xn+1 and the next pixel velocity value vn+1 for a next frame n+1 wherein





  {
  
    
      
        
          
            
              x
              
                n
                +
                1
              
            
            =
            
              
                Ax
                n
              
              +
              
                Bv
                n
              
              +
              Cp
            
          
        
      
      
        
          
            
              v
              
                n
                +
                1
              
            
            =
            
              
                Dx
                n
              
              +
              
                Ev
                n
              
              +
              Fp
            
          
        
      
    
    .

4. A method as recited in claim 3 comprising:
assuming an initial state with x0 and v0 both equal to 0.

5. A method as recited in claim 4 wherein based upon the assuming,
calculating an ideal pixel strength





  
    p
    ideal
  
  =
  
    
      1
      C
    
    ⁢
    
      
        (
        
          
            p
            
              n
              +
              1
            
          
          -
          
            Ax
            n
          
          -
          
            Bv
            n
          
        
        )
      
      .

6. A method as recited in claim 5 comprising:
clamping the ideal pixel strength





  
    p
    ideal
  
  =
  
    
      1
      C
    
    ⁢
    
      (
      
        
          p
          
            n
            +
            1
          
        
        -
        
          Ax
          n
        
        -
        
          Bv
          n
        
      
      )
    
  




to within a saturation region of the LCD pixel corresponding to pixel values between 0 and 255; and
rounding the clamped ideal pixel strength to yield the overdrive pixel value.

7. A method as recited in claim 6, further comprising:
using the overdrive pixel value to update the current pixel value xn and the current pixel velocity value vn from a current frame to a next frame.

8. Computer readable medium encoded with computer program product executable by a processor for providing a liquid crystal display (LCD) pixel response time corresponding to a period of time required for a selected LCD pixel at a starting pixel value to reach a target pixel value associated with an overdrive pixel value in an LCD panel having a number of LCD pixels, comprising:
computer code for modeling response of each of the LCD pixels as a second order dynamical system represented as a second order differential equation (m{umlaut over (x)}+kv+x=p) wherein x, v and p represent an LCD pixel value, an associated change in pixel value with respect to time, and an applied LCD pixel voltage, respectively, and wherein m and k represent an LCD pixel mass and associated pixel damping factor, respectively;
computer code for calculating LCD pixel response data of the selected pixel under the influence of an applied voltage p based upon the second order differential equation when the selected LCD pixel has an initial LCD pixel value of x0 and an associated pixel velocity value of v0;
computer code for determining a best fit (m, k) pair value, wherein the best fit (m,k) values are those values of m and k that result in a calculated LCD pixel response that most-nearly matches a measured LCD pixel response for the LCD panel; and
calculating α1 and α2 based upon the best fit (m, k) pair value, wherein





  
    
      α
      1
    
    =
    
      
        
          -
          k
        
        +
        
          
            
              k
              2
            
            -
            
              4
              ⁢
              m
            
          
        
      
      
        2
        ⁢
        m
      
    
  
  ,
  
    
  
  ⁢
  
    
      α
      2
    
    =
    
      
        
          -
          k
        
        -
        
          
            
              k
              2
            
            -
            
              4
              ⁢
              m
            
          
        
      
      
        2
        ⁢
        m
      
    
  
  ,




wherein α1 and α2 are roots of the second order differential equation m{umlaut over (x)}+kv+x=p that models the LCD pixel response.

9. Computer readable medium encoded with computer program product as recited in claim 8, further comprising:
calculating a set of runtime coefficients {A, B, C, D, E, F} as





  {
  
     
    
      
        
          
            A
            =
            
              
                
                  
                    α
                    2
                  
                  ⁢
                  
                    e
                    
                      α
                      1
                    
                  
                
                -
                
                  
                    α
                    1
                  
                  ⁢
                  
                    e
                    
                      α
                      2
                    
                  
                
              
              
                
                  α
                  2
                
                -
                
                  α
                  1
                
              
            
          
        
      
      
        
          
            B
            =
            
              
                
                  -
                  
                    e
                    
                      α
                      1
                    
                  
                
                +
                
                  e
                  
                    α
                    2
                  
                
              
              
                
                  α
                  2
                
                -
                
                  α
                  1
                
              
            
          
        
      
      
        
          
            C
            =
            
              
                
                  
                    
                      -
                      
                        α
                        2
                      
                    
                    ⁢
                    
                      e
                      
                        α
                        1
                      
                    
                  
                  +
                  
                    
                      α
                      1
                    
                    ⁢
                    
                      e
                      
                        α
                        2
                      
                    
                  
                
                
                  
                    α
                    2
                  
                  -
                  
                    α
                    1
                  
                
              
              +
              1
            
          
        
      
      
        
          
            D
            =
            
              
                
                  
                    α
                    1
                  
                  ⁢
                  
                    α
                    2
                  
                
                
                  
                    α
                    2
                  
                  -
                  
                    α
                    1
                  
                
              
              ⁢
              
                (
                
                  
                    e
                    
                      α
                      1
                    
                  
                  -
                  
                    e
                    
                      α
                      2
                    
                  
                
                )
              
            
          
        
      
      
        
          
            E
            =
            
              
                
                  
                    -
                    
                      α
                      1
                    
                  
                  ⁢
                  
                    e
                    
                      α
                      1
                    
                  
                
                +
                
                  
                    α
                    2
                  
                  ⁢
                  
                    e
                    
                      α
                      2
                    
                  
                
              
              
                
                  α
                  2
                
                -
                
                  α
                  1
                
              
            
          
        
      
      
        
          
            F
            =
            
              
                
                  
                    α
                    1
                  
                  ⁢
                  
                    α
                    2
                  
                
                
                  
                    α
                    2
                  
                  -
                  
                    α
                    1
                  
                
              
              ⁢
              
                (
                
                  
                    -
                    
                      e
                      
                        α
                        1
                      
                    
                  
                  +
                  
                    e
                    
                      α
                      2
                    
                  
                
                )
              
            
          
        
      
    
  



wherein the runtime coefficients {A, B, C, D, E, F} are constants used to compute a next pixel value xn+1 from a current pixel value xn and to compute a next pixel velocity value vn+1 from a current pixel velocity value vn.

10. Computer readable medium encoded with computer program product as recited in claim 9, further comprising:
computing the next pixel value xn+1 and the next pixel velocity value vn+1 for a frame n+1





  wherein
  ⁢
  
    
  
  ⁢
  
    {
    
      
        
          
            x
            
              n
              +
              1
            
          
          =
          
            
              A
              ×
              
                x
                n
              
            
            +
            
              B
              ×
              
                v
                n
              
            
            +
            
              C
              ×
              p
            
          
        
        
          
            v
            
              n
              +
              1
            
          
          =
          
            
              D
              ×
              
                x
                n
              
            
            +
            
              E
              ×
              
                v
                n
              
            
            +
            
              F
              ×
              p
            
          
        
      
      .

11. Computer readable medium encoded with computer program product as recited in claim 10 comprising:
assuming an initialstate with x0 and v0 both equal to 0.

12. Computer readable medium encoded with computer program product as recited in claim 11 wherein based upon the assuming,
calculating an ideal pixel strength





  
    p
    ideal
  
  =
  
    
      1
      C
    
    ⁢
    
      
        (
        
          
            p
            
              n
              +
              1
            
          
          -
          
            A
            ×
            
              x
              n
            
          
          -
          
            B
            ×
            
              v
              n
            
          
        
        )
      
      .

13. Computer readable medium encoded with computer program product as recited in claim 12 comprising:
clamping the ideal pixel strength





  
    p
    ideal
  
  =
  
    
      1
      C
    
    ⁢
    
      (
      
        
          p
          
            n
            +
            1
          
        
        -
        
          A
          ×
          
            x
            n
          
        
        -
        
          B
          ×
          
            v
            n
          
        
      
      )
    
  




to within a saturation region of the LCD pixel corresponding to pixel values between 0 and 255; and
rounding the clamped ideal pixel strength to yield the overdrive pixel value.

14. Computer readable medium encoded with computer program product as recited in claim 13, further comprising:
using the overdrive pixel value to update the current pixel value xn and the current pixel velocity value vn from a current frame to a next frame.