# Patent

## Title
Method and apparatus for generating a candidate code-vector to code an informational signal

## Abstract

A method (1100) and apparatus (100) generate a candidate code-vector to code an information signal. The method can include producing (1110) a weighted target vector from an input signal. The method can include processing (1120) the weighted target vector through an inverse weighting function to create a residual domain target vector. The method can include performing (1130) a first search process on the residual domain target vector to obtain an initial fixed codebook code-vector. The method can include performing (1140) a second search process over a subset of possible codebook code-vectors for a low weighted-domain error to produce a final fixed codebook code-vector. The subset of possible codebook code-vectors can be based on the initial fixed codebook code-vector. The method can include generating (1150) a codeword representative of the final fixed codebook code-vector. The codeword can be for use by a decoder to generate an approximation of the input signal.

## Background
CROSS REFERENCE TO RELATED APPLICATIONS
This application claims priority from U.S. patent application Ser. No. 13/439,121, entitled “Method and Apparatus for Generating a Candidate Code-Vector to Code an Informational Signal” by James P. Ashley and Udar Mittal filed Apr. 4, 2012. This related application is assigned to the assignee of the present application and is hereby incorporated herein in its entirety by this reference thereto.
BACKGROUND
1. Field
The present disclosure relates, in general, to signal compression systems and, more particularly, to Code Excited Linear Prediction (CELP)-type speech coding systems.
2. Introduction
Compression of digital speech and audio signals is well known. Compression is generally required to efficiently transmit signals over a communications channel or to compress the signals for storage on a digital media device, such as a solid-state memory device or computer hard disk. Although many compression techniques exist, one method that has remained very popular for digital speech coding is known as Code Excited Linear Prediction (CELP), which is one of a family of “analysis-by-synthesis” coding algorithms. Analysis-by-synthesis generally refers to a coding process by which multiple parameters of a digital model are used to synthesize a set of candidate signals that are compared to an input signal and analyzed for distortion. A set of parameters that yields a lowest distortion is then either transmitted or stored, and eventually used to reconstruct an estimate of the original input signal. CELP is a particular analysis-by-synthesis method that uses one or more codebooks where each codebook essentially includes sets of code-vectors that are retrieved from the codebook in response to a codebook index.
For example, FIG. 12 is a block diagram of a CELP encoder 1200 of the prior art. In CELP encoder 1200, an input signal s(n), such as a speech signal, is applied to a Linear Predictive Coding (LPC) analysis block 1201, where linear predictive coding is used to estimate a short-term spectral envelope. The resulting spectral parameters are denoted by the transfer function A(z). The spectral parameters are applied to an LPC Quantization block 1202 that quantizes the spectral parameters to produce quantized spectral parameters Aq that are suitable for use in a multiplexer 1208. The quantized spectral parameters Aq are then conveyed to multiplexer 1208, and the multiplexer 1208 produces a coded bitstream based on the quantized spectral parameters and a set of codebook-related parameters, τ, β, k, and γ, that are determined by a squared error minimization/parameter quantization block 1207.
The quantized spectral, or Linear Predictive, parameters are also conveyed locally to an LPC synthesis filter 1205 that has a corresponding transfer function 1/Aq(z). LPC synthesis filter 1205 also receives a combined excitation signal u(n) from a first combiner 1210 and produces an estimate of the input signal s(n) based on the quantized spectral parameters Aq and the combined excitation signal u(n). Combined excitation signal u(n) is produced as follows. An adaptive codebook code-vector cτ is selected from an adaptive codebook (ACB) 1203 based on an index parameter τ and the combined excitation signal from the previous subframe u(n-L). The adaptive codebook code-vector cτ is then weighted based on a gain parameter β 1230 and the weighted adaptive codebook code-vector is conveyed to first combiner 1210. A fixed codebook code-vector ck is selected from a fixed codebook (FCB) 1204 based on an index parameter k. The fixed codebook code-vector ck is then weighted based on a gain parameter γ 1240 and is also conveyed to first combiner 1210. First combiner 1210 then produces combined excitation signal u(n) by combining the weighted version of adaptive codebook code-vector cτ with the weighted version of fixed codebook code-vector ck.
LPC synthesis filter 1205 conveys the input signal estimate ŝ(n) to a second combiner 1212. The second combiner 1212 also receives input signal s(n) and subtracts the estimate of the input signal ŝ(n) from the input signal s(n). The difference between input signal s(n) and the input signal estimate ŝ(n) is applied to a perceptual error weighting filter 1206, which filter produces a perceptually weighted error signal e(n) based on the difference between ŝ(n) and s(n) and a weighting function W(z). Perceptually weighted error signal e(n) is then conveyed to squared error minimization/parameter quantization block 1207. Squared error minimization/parameter quantization block 1207 uses the error signal e(n) to determine an optimal set of codebook-related parameters τ, β, k, and γ that produce the best estimate s(n) of the input signal s(n).
FIG. 13 is a block diagram of a decoder 1300 of the prior art that corresponds to the encoder 1200. As one of ordinary skilled in the art realizes, the coded bitstream produced by the encoder 1200 is used by a demultiplexer 1308 in the decoder 1300 to decode the optimal set of codebook-related parameters, τ, β 1330, k, and γ 1340. The decoder 1300 uses a process that is identical to the synthesis process performed by encoder 1200, by using an adaptive codebook 1303, a fixed codebook 1304, signals u(n) and u(n-L), code-vectors cτ and ck, and a LPC synthesis filter 1305 to generate output speech. Thus, if the coded bitstream produced by the encoder 1200 is received by the decoder 1300 without errors, the speech ŝ(n) output by the decoder 1300 can be reconstructed as an exact duplicate of the input speech estimate ŝ(n) produced by the encoder 1200.
While the CELP encoder 1200 is conceptually useful, it is not a practical implementation of an encoder where it is desirable to keep computational complexity as low as possible. As a result, FIG. 14 is a block diagram of an exemplary encoder 1400 of the prior art that utilizes an equivalent, and yet more practical, system compared to the encoding system illustrated by encoder 1200. To better understand the relationship between the encoder 1200 and the encoder 1400, it is beneficial to look at the mathematical derivation of encoder 1400 from encoder 1200. For the convenience of the reader, the variables are given in terms of their z-transforms.
From FIG. 12, it can be seen that the perceptual error weighting filter 1206 produces the weighted error signal e(n) based on a difference between the input signal and the estimated input signal, that is:

E(z)=W(z)(S(z)(S(z)−Ŝ(z))  (1)

From this expression, the weighting function W(z) can be distributed and the input signal estimate ŝ(n) can be decomposed into the filtered sum of the weighted codebook code-vectors:




  
    
      
        
          E
          ⁡
          
            (
            z
            )
          
        
        =
        
          
            
              W
              ⁡
              
                (
                z
                )
              
            
            ⁢
            
              S
              ⁡
              
                (
                z
                )
              
            
          
          -
          
            
              
                W
                ⁡
                
                  (
                  z
                  )
                
              
              
                
                  A
                  q
                
                ⁡
                
                  (
                  z
                  )
                
              
            
            ⁢
            
              (
              
                
                  β
                  ⁢
                  
                    
                  
                  ⁢
                  
                    
                      C
                      τ
                    
                    ⁡
                    
                      (
                      z
                      )
                    
                  
                
                +
                
                  γ
                  ⁢
                  
                    
                  
                  ⁢
                  
                    
                      C
                      k
                    
                    ⁡
                    
                      (
                      z
                      )
                    
                  
                
              
              )
            
          
        
      
    
    
      
        (
        2
        )
      
    
  




The term W(z)S(z) corresponds to a weighted version of the input signal. By letting the weighted input signal W(z)S(z) be defined as Sw(z)=W(z)S(z) and by further letting the weighted synthesis filter 1205 of the encoder 1200 now be defined by a transfer function H(z)=W(z)/Aq(z), Equation 2 can rewritten as follows:

E(z)=Sw(z)−H(z)(βCτ(z)+γCk(z))  (3)

By using z-transform notation, filter states need not be explicitly defined. Now proceeding using vector notation, where the vector length L is a length of a current speech input subframe, Equation 3 can be rewritten as follows by using the superposition principle:

e=sw−H(βcτ+γck)−hzir,  (4)

where:

    
    
        H is the L×L zero-state weighted synthesis convolution matrix formed from an impulse response of a weighted synthesis filter h(n), such as synthesis filters 1415 and 1405, and corresponding to a transfer function Hzs(z) or H(z), which matrix can be represented as:
    
    






  
    
      
        
          H
          =
          
            [
            
              
                
                  
                    h
                    ⁡
                    
                      (
                      0
                      )
                    
                  
                
                
                  0
                
                
                  ...
                
                
                  0
                
              
              
                
                  
                    h
                    ⁡
                    
                      (
                      1
                      )
                    
                  
                
                
                  
                    h
                    ⁡
                    
                      (
                      0
                      )
                    
                  
                
                
                  ...
                
                
                  0
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    h
                    ⁡
                    
                      (
                      
                        L
                        -
                        1
                      
                      )
                    
                  
                
                
                  
                    h
                    ⁡
                    
                      (
                      
                        L
                        -
                        2
                      
                      )
                    
                  
                
                
                  ...
                
                
                  
                    h
                    ⁡
                    
                      (
                      0
                      )
                    
                  
                
              
            
            ]
          
        
        ,
      
    
    
      
        (
        5
        )
      
    
  




    
    
        hzir is a L×1 zero-input response of H(z) that is due to a state from a previous speech input subframe,
        sw is the L×1 perceptually weighted input signal,
        β is the scalar adaptive codebook (ACB) gain,
        cτ is the L×1 ACB code-vector indicated by index τ,
        γ is the scalar fixed codebook (FCB) gain, and
        ck is the L×1 FCB code-vector indicated by index k.
    
    


By distributing H, and letting the input target vector xw=sw−hzir, the following expression can be obtained:

e=xw−βHcτ−γHck  (6)

Equation 6 represents the perceptually weighted error (or distortion) vector e(n) produced by a third combiner 1408 of encoder 1400 and coupled by the combiner 1408 to a squared error minimization/parameter quantization block 1407.
From the expression above, a formula can be derived for minimization of a weighted version of the perceptually weighted error, that is, ∥e∥2, by squared error minimization/parameter quantization block 1407. A norm of the squared error is given as:

ε=∥e∥2=∥xw−βHcτ−γHck∥2  (7)

Note that ∥e∥2 may also be written as ∥e∥2=Σn=0L-1e2(n) or ∥e∥2=eTe, where eT is the vector transpose of e, and is presumed to be a column vector.

Due to complexity limitations, practical implementations of speech coding systems typically minimize the squared error in a sequential fashion. That is, the adaptive codebook (ACB) component is optimized first by assuming the fixed codebook (FCB) contribution is zero, and then the FCB component is optimized using the given (previously optimized) ACB component. The ACB/FCB gains, that is, codebook-related parameters β and γ, may or may not be re-optimized, that is, quantized, given the sequentially selected ACB/FCB code-vectors cτ and ck.
The theory for performing such an example of a sequential optimization process is as follows. First, the norm of the squared error as provided in Equation 7 is modified by setting γ=0, and then expanded to produce:

ε=∥xw−βHcτ∥2=xxTxw−2βxwTHcτ+β2cτTHTHcτ  (8)

Minimization of the squared error is then determined by taking the partial derivative of ε with respect to β and setting the quantity to zero:




  
    
      
        
          
            ∂
            ɛ
          
          
            ∂
            β
          
        
        =
        
          
            
              
                x
                w
                T
              
              ⁢
              
                Hc
                τ
              
            
            -
            
              β
              ⁢
              
                
              
              ⁢
              
                c
                τ
                T
              
              ⁢
              
                H
                T
              
              ⁢
              
                Hc
                τ
              
            
          
          =
          0
        
      
    
    
      
        (
        9
        )
      
    
  




This yields an optimal ACB gain:




  
    
      
        β
        =
        
          
            
              x
              w
              T
            
            ⁢
            
              Hc
              τ
            
          
          
            
              c
              τ
              T
            
            ⁢
            
              H
              T
            
            ⁢
            
              Hc
              τ
            
          
        
      
    
    
      
        (
        10
        )
      
    
  




Substituting the optimal ACB gain back into Equation 8 gives:




  
    
      
        
          
            τ
            *
          
          =
          
            
              argmin
              τ
            
            ⁢
            
              {
              
                
                  
                    x
                    w
                    T
                  
                  ⁢
                  
                    x
                    w
                  
                
                -
                
                  
                    
                      (
                      
                        
                          x
                          w
                          T
                        
                        ⁢
                        
                          Hc
                          τ
                        
                      
                      )
                    
                    2
                  
                  
                    
                      c
                      τ
                      T
                    
                    ⁢
                    
                      H
                      T
                    
                    ⁢
                    
                      Hc
                      τ
                    
                  
                
              
              }
            
          
        
        ,
      
    
    
      
        (
        11
        )
      
    
  




where τ* is an optimal ACB index parameter, that is, an ACB index parameter that minimizes the bracketed expression. Typically, τ is a parameter related to a range of expected values of the pitch lag (or fundamental frequency) of the input signal, and is constrained to a limited set of values that can be represented by a relatively small number of bits. Since xw is not dependent on τ, Equation 11 can be rewritten as follows:





  
    
      
        
          τ
          *
        
        =
        
          
            argmax
            τ
          
          ⁢
          
            {
            
              
                
                  (
                  
                    
                      x
                      w
                      T
                    
                    ⁢
                    
                      Hc
                      τ
                    
                  
                  )
                
                2
              
              
                
                  c
                  τ
                  T
                
                ⁢
                
                  H
                  T
                
                ⁢
                
                  Hc
                  τ
                
              
            
            }
          
        
      
    
    
      
        (
        12
        )
      
    
  




Now, by letting yτ equal the ACB code-vector cτ filtered by weighted synthesis filter 1415, that is, yτ=Hcτ, Equation 13 can be simplified to:




  
    
      
        
          
            τ
            *
          
          =
          
            
              argmax
              τ
            
            ⁢
            
              {
              
                
                  
                    (
                    
                      
                        x
                        w
                        T
                      
                      ⁢
                      
                        y
                        τ
                      
                    
                    )
                  
                  2
                
                
                  
                    y
                    τ
                    T
                  
                  ⁢
                  
                    y
                    τ
                  
                
              
              }
            
          
        
        ,
      
    
    
      
        (
        13
        )
      
    
  




and likewise, Equation 10 can be simplified to:





  
    
      
        β
        =
        
          
            
              x
              w
              T
            
            ⁢
            
              y
              τ
            
          
          
            
              y
              τ
              T
            
            ⁢
            
              y
              τ
            
          
        
      
    
    
      
        (
        14
        )
      
    
  




Thus Equations 13 and 14 represent the two expressions necessary to determine the optimal ACB index τ and ACB gain β in a sequential manner. These expressions can now be used to determine the optimal FCB index and gain expressions. First, from FIG. 14, it can be seen that a second combiner 1406 produces a vector x2, where x2=xw−βHcτ. The vector xw (or xw(n)) is produced by a first combiner 1404 that subtracts a filtered past synthetic excitation signal hzir(n), after filtering past synthetic excitation signal u(n-L) by a weighted synthesis zero input response Hzir(z) filter 1401, from an output sw(n) of a perceptual error weighting filter W(z) 1402 of input speech signal s(n). The term βHcτ is a filtered and weighted version of ACB code-vector cτ, that is, ACB code-vector cτ filtered by zero state weighted synthesis filter Hzs(z) 1415 to generate y(n) and then weighted based on ACB gain parameter β 1430. Substituting the expression x2=xw−βHcτ into Equation 7 yields:

ε=∥2−γHck∥2,  (15)

where γHck is a filtered and weighted version of FCB code-vector ck, that is, FCB code-vector ck filtered by zero state weighted synthesis filter Hzs(z) 1405 and then weighted based on FCB gain parameter γ 1440. Similar to the above derivation of the optimal ACB index parameter τ*, it is apparent that:





  
    
      
        
          
            k
            *
          
          =
          
            
              argmax
              k
            
            ⁢
            
              {
              
                
                  
                    (
                    
                      
                        x
                        2
                        T
                      
                      ⁢
                      
                        Hc
                        k
                      
                    
                    )
                  
                  2
                
                
                  
                    c
                    k
                    T
                  
                  ⁢
                  
                    H
                    T
                  
                  ⁢
                  
                    Hc
                    k
                  
                
              
              }
            
          
        
        ,
      
    
    
      
        (
        16
        )
      
    
  




where k* is an optimal FCB index parameter, that is, an FCB index parameter that maximizes the bracketed expression. By grouping terms that are not dependent on k, that is, by letting d2T=x2TH and Φ=HTH, Equation 16 can be simplified to:





  
    
      
        
          
            k
            *
          
          =
          
            
              argmax
              k
            
            ⁢
            
              {
              
                
                  
                    (
                    
                      
                        d
                        2
                        T
                      
                      ⁢
                      
                        c
                        k
                      
                    
                    )
                  
                  2
                
                
                  
                    c
                    k
                    T
                  
                  ⁢
                  Φ
                  ⁢
                  
                    
                  
                  ⁢
                  
                    c
                    k
                  
                
              
              }
            
          
        
        ,
      
    
    
      
        (
        17
        )
      
    
  




in which the optimal FCB gain γ is given as:





  
    
      
        γ
        =
        
          
            
              
                d
                2
                T
              
              ⁢
              
                c
                k
              
            
            
              
                c
                k
                T
              
              ⁢
              Φ
              ⁢
              
                
              
              ⁢
              
                c
                k
              
            
          
          .
        
      
    
    
      
        (
        18
        )
      
    
  




The encoder 1400 provides a method and apparatus for determining the optimal excitation vector-related parameters τ, β, k, and γ. Unfortunately, higher bit rate CELP coding typically requires higher computational complexity due to a larger number of codebook entries that require error evaluation in the closed loop processing. Thus, there is an opportunity for generating a candidate code-vector to reduce the computational complexity to code an information signal.



BRIEF DESCRIPTION OF THE DRAWINGS
FIG. 1 is an example block diagram of at least a portion of a coder, such as a portion of the coder in FIG. 12, according to one embodiment;
FIG. 2 is an example block diagram of a FCB candidate code-vector generator according to one embodiment;
FIG. 3 is an example illustration of a flowchart outlining the operation of a coder according to one embodiment;
FIG. 4 is an example illustration of a flowchart outlining candidate code-vector construction operation of a coder according to one embodiment;
FIG. 5 is an example illustration of two conceptual candidate code-vectors ck[i] according to one embodiment;
FIG. 6 is an example illustration of a flowchart outlining the operation of a coder according to one embodiment;
FIG. 7 is an example illustration of a flowchart outlining the operation of a coder according to one embodiment;
FIG. 8 is an example illustration of a flowchart outlining the operation of a coder according to one embodiment;
FIG. 9 is an example illustration of a flowchart outlining the operation of a coder according to one embodiment;
FIG. 10 is an example block diagram of the fixed codebook candidate code-vector generator from FIG. 1 according to one embodiment;
FIG. 11 is an example illustration of a flowchart outlining the operation of a coder according to one embodiment;
FIG. 12 is a block diagram of a Code Excited Linear Prediction (CELP) encoder of the prior art;
FIG. 13 is a block diagram of a CELP decoder of the prior art; and
FIG. 14 is a block diagram of another CELP encoder of the prior art.



DETAILED DESCRIPTION
As discussed above, higher bit rate CELP coding typically requires higher computational complexity due to a larger number of codebook entries that require error evaluation in the closed loop processing. Embodiments of the present disclosure can solve a problem of searching higher bit rate codebooks by providing for pre-quantizer candidate generation in a Code Excited Linear Prediction (CELP) speech coder. Embodiments can address the problem by generating a set of initial FCB candidates through direct quantization of a set of vectors formed using inverse weighting functions and the FCB target signal and then evaluating a weighted error of those initial candidates to produce a better overall code-vector. Embodiments can also apply variable weights to vectors and can sum the weighted vectors as part of preselecting candidate code-vectors. Embodiments can additionally generate a set of initial fixed codebook candidates through direct quantization of a set of vectors formed using inverse weighting functions and the fixed codebook target signal and then evaluate the weighted errors of that initial set of candidates to produce a better overall code-vector. Other embodiments can also generate a set of initial FCB candidates through direct quantization of a set of vectors formed using inverse weighting functions and the FCB target signal, and then evaluating a weighted error of those initial candidates to determine a better initial weighting function for a given pre-quantizer function.
To achieve the above benefits, a method and apparatus can generate a candidate code-vector to code an information signal. The method can include producing a weighted target vector from an input signal. The method can include processing the weighted target vector through an inverse weighting function to create a residual domain target vector. The method can include performing a first search process on the residual domain target vector to obtain an initial fixed codebook code-vector. The method can include performing a second search process over a subset of possible codebook code-vectors for a low weighted-domain error to produce a final fixed codebook code-vector. The subset of possible codebook code-vectors can be based on the initial fixed codebook code-vector. The method can include generating a codeword representative of the final fixed codebook code-vector. The codeword can be for use by a decoder to generate an approximation of the input signal.
FIG. 1 is an example block diagram of at least a portion of a coder apparatus 100, such as a portion of the coder 1200, according to one embodiment. The coder 100 can include an input 122, a target vector generator 124, a FCB candidate code-vector generator 110, a FCB 104, a zero state weighted synthesis filter H equivalent 105, an error minimization block 107, a first gain parameter γ weighting block 141, a combiner 108, and an output 126. The coder 100 can also include a second zero state weighted synthesis filter H equivalent 115, a second error minimization block 117, a second gain parameter γ weighting block 142, and a second combiner 118.
The zero state weighted synthesis filter equivalent 105, the error minimization block 107, and the combiner 108, as well as the second zero state weighted synthesis filter H equivalent 115, the second error minimization block 117, and the second combiner 118 can operate similarly to the zero state weighted synthesis filter 1405, the squared error minimization parameter quantizer 1407, and the combiner 1408, respectively, as illustrated in FIG. 14. Note that a zero state weighted synthesis filter H is not actually implemented, but rather a mathematical equivalent is implemented as discussed with respect to Eqs. 16, 17, and 18. A codebook, such as the FCB 104, can include of a set of pulse amplitude and position combinations. Each pulse amplitude and position combination can define L different positions and can include both zero-amplitude pulses and non-zero-amplitude pulses assigned to respective positions p=1, 2, . . . , L−1 of the combination.
In operation, the input 122 can receive and may process an input signal s(n). The input signal s(n) can be a digital or analog input signal. The input can be received wirelessly, through a hard-wired connection, from a storage medium, from a microphone, or otherwise received. For example, the input signal s(n) can be based on an audible signal, such as speech. The target vector generator 124 can receive the input signal s(n) from the input 122 and can produce a target vector x2 from the input signal s(n).
The FCB candidate code-vector generator 110 can receive the target vector x2 and can construct a set of candidate code-vectors ck[i] and an inverse weighting function ƒ(x2,i), where i can be an index for the candidate code-vectors ck[i] where 0≦i<N, and N is at least one. The set of candidate code-vectors ck[i] can be based on the target vector x2 and can be based on the inverse weighting function. The inverse weighting function can remove weighting from the target vector x2 in some manner. For example, an inverse weighting function can be based on




  
    
      f
      ⁡
      
        (
        
          
            x
            2
          
          ,
          i
        
        )
      
    
    =
    
      
        
          a
          i
        
        ⁢
        
          r
          
            
            r
            
          
        
      
      +
      
        
          b
          i
        
        ⁢
        
          
            d
            2
          
          
            
            
              d
              2
            
            
          
        
      
    
  
  ,




described below, or can be other inverse weighting functions described below. Additionally, the FCB 104 may also use the inverse weighting function result as a means of further reducing the search complexity, for example, by searching only a subset of the total pulse/position combinations.

The error minimization block 117 may also select one of a plurality of candidate code-vectors ck[i] with lower squared sum value of ei as cki*. That is, after the best candidate code-vector cki* is found by way of square error minimization, the fixed codebook 104 may use cki* as an initial “seed” code-vector which may be iterated upon. The inverse weighting function result ƒ(x2, i*) may also be used in this process to help reduce search complexity. Thus, i* can represent the index value of the optimum candidate code-vector ck[i]. If the coder 100 does not include the second zero state weighted synthesis filter H equivalent 115, the second error minimization block 117, the second gain parameter γ weighting block 142, and the second combiner 118, the remaining blocks can perform the corresponding functions. For example, the error minimization block 107 can provide the indices i of the candidate code-vectors and the index value i* of the optimum candidate code-vector and the zero state weighted synthesis filter 105 can receive the candidate code-vectors ck[i] (not shown).
According to an example embodiment, the FCB candidate code-vector generator 110 can construct the set of candidate code-vectors ck[i] based on the target vector x2, based on an inverse filtered vector, and based on a backward filtered vector as described below. The set of candidate code-vectors ck[i] can also be based on the target vector x2 and based on a sum of a weighted inverse filtered vector and weighted backward filtered vector as described below.
In the case where the number of candidate code-vectors is greater than one (N>1 and 0≦i<N), the error minimization block 117 can evaluate an error vector ei associated with each of the plurality of candidate code-vectors ck[i]. The error vector can be analyzed to select a single FCB code-vector ck[i*], where the FCB code-vector ck[i*] can be one of the candidate code-vectors ck[i]. The squared error minimization/parameter quantization block 107 can generate a codeword k representative of the FCB code-vector ck[i]. The codeword k can be used by a decoder to generate an approximation ŝ(n) of the input signal s(n). The error minimization block 107 or another element can output the codeword k at the output 126 by transmitting the codeword k and/or storing the codeword k. For example, the error minimization block 117 may generate and output the codeword k.
Each candidate code-vector ck[i] can be processed as if it were generated by the FCB 104 by filtering it through the zero state weighted synthesis filter 105 for each candidate ck[i]. The FCB candidate code-vector generator 110 can evaluate an error value associated with each iteration of the plurality of candidate code-vectors ck[i] from the plurality of times to produce a FCB code-vector ck based on the candidate code-vector ck[i] with the lowest error value.
According to some embodiments, there can be multiple inverse functions ƒ(x2,i), where 0<=i<N and N>1, evaluated for every frame of speech. Multiple ƒ(x2,i) outputs can be used to determine a codebook output, which can be ck[i] or ck. Additionally, ck[i] can be a starting point for determining ck, where ck[i] can allow for fewer iterations of k and can allow for a better overall result by avoiding settling on a local minima and missing a more global minimum error ε.
FIG. 2 is an example block diagram of the FCB candidate code-vector generator 110 according to one embodiment. The FCB candidate code-vector generator 110 can include an inverse filter 210, a backward filter 220, and another processing block for a FCB candidate code-vector generator 230.
The FCB candidate code-vector generator 110 can construct a set of candidate code-vectors ck[i], where i can be an index for the candidate code-vectors ck[i]. The set of candidate code-vectors ck[i] can be based on the target vector x2 and can be based on an inverse weighting function, such as ƒ(x2,i). The inverse weighting function can be based on an inverse filtered vector and the inverse filter 210 can construct the inverse filtered vector from the target vector x2. For example, the inverse filtered vector can be constructed based on r=H−1x2, where r can be the inverse filtered vector, where H−1 can be a zero-state weighted synthesis convolution matrix formed from an impulse response of a weighted synthesis filter, and where x2 can be the target vector. Other variations are described in other embodiments.
The inverse weighting function can be based on a backward filtered vector, and the backward filter 220 can construct the backward filtered vector from the target vector x2. For example, the backward filtered vector can be constructed based on d2=HTx2, where d2 can be the backward filtered vector, where HT can be a transpose of a zero-state weighted synthesis convolution matrix formed from an impulse response of a weighted synthesis filter, and where x2 can be the target vector. Other variations are described in other embodiments.
According to an example embodiment, recalling Eq. 15 from the Background that

ε=∥x2−γHck∥2,  (19)

if the FCB code-vector is given as:





  
    
      
        
          
            c
            k
          
          =
          
            
              1
              γ
            
            ⁢
            
              H
              
                -
                1
              
            
            ⁢
            
              x
              2
            
          
        
        ,
      
    
    
      
        (
        20
        )
      
    
  




then the error ε can tend to zero and the input signal s(n) and a corresponding coded output signal ŝ(n) can be identical. Since this is not practical for low rate speech coding systems, only a crude approximation of Eq. 20 is typically generated. U.S. Pat. No. 5,754,976 to Adoul, hereby incorporated by reference, discloses one example of the usage of the inverse filtered target signal r=H−1x2 as a method for low bit rate pre-selection of the pulse amplitudes of the code-vector ck.

One of the problems in evaluating the error term ε in Eq. 19 is that, while the error ε is evaluated in the weighted synthesis domain, the FCB code-vector ck is generated in the residual domain. Thus, a direct PCM-like quantization of the right hand term in Eq. 20 does not generally produce the minimum possible error in Eq. 19, due to the quantization error generation being in the residual domain as opposed to the weighted synthesis domain. More specifically, the expression:




  
    
      
        
          
            c
            k
          
          =
          
            
              Q
              P
            
            ⁢
            
              {
              
                
                  1
                  γ
                
                ⁢
                
                  H
                  
                    -
                    1
                  
                
                ⁢
                
                  x
                  2
                
              
              }
            
          
        
        ,
      
    
    
      
        (
        21
        )
      
    
  




where QP{ } is a P-bit quantization operator, does not generally lead to the global minimum weighted error since the error due to QP{ } is a residual domain error. In order to achieve the lowest possible error in the weighted synthesis domain, many iterations of ck may be necessary to minimize the error ε of Eq. 19. Various embodiments of the present disclosure described below can address this problem by reducing the iterations and by reducing the residual domain error.

First, an i-th pre-quantizer candidate ck[i] can be generated by the FCB candidate code-vector generator 110 using the expression

ck[i]=QP{ƒ(x2,i)}, 0≦i<N,  (22)

where ƒ(x2,i) can be some function of the target vector, and N can be the number of pre-quantizer candidates. This expression can be a generalized form for generating a plurality of pre-quantizer candidates that can be assessed for error in the weighted domain. An example of such a function is given as:





  
    
      
        
          
            f
            ⁡
            
              (
              
                
                  x
                  2
                
                ,
                i
              
              )
            
          
          =
          
            
              
                a
                i
              
              ⁢
              
                r
                
                  
                  r
                  
                
              
            
            +
            
              
                b
                i
              
              ⁢
              
                
                  d
                  2
                
                
                  
                  
                    d
                    2
                  
                  
                
              
            
          
        
        ,
      
    
    
      
        (
        23
        )
      
    
  




where r=H−1x2 is the inverse filtered target signal, d2=HTx2 is the backward filtered target as calculated/defined in Eq. 17, and ai and bi are a set of respective weighting coefficients for iteration i. Here, ∥r∥ can be a norm of the residual domain vector r, such as the inverse filtered target vector r, given by ∥r∥=√{square root over (rTr)}, and likewise ∥d2∥=√{square root over (d2Td2)}. The effect of coefficients ai and bi, can be to produce a weighted sum of the inverse and backward filtered target vectors, which can then form the set of pre-quantizer candidate vectors.

Embodiments of the present disclosure can allow various coefficient functions to be incorporated into the weighting of the normalized vectors in Eq. 23. For example, the functions:




  
    
      
        
          
            a
            i
          
          =
          
            1
            -
            
              i
              /
              
                (
                
                  N
                  -
                  1
                
                )
              
            
          
        
        ,
        
          

        
        ⁢
        
          
            b
            i
          
          =
          
            i
            /
            
              (
              
                N
                -
                1
              
              )
            
          
        
        ,
        
          

        
        ⁢
        
          0
          ≤
          i
          <
          N
        
        ,
      
    
    
      
        (
        24
        )
      
    
  




where candidates can have a linear distribution of values over a given range. As an example, if N=4, the sets of coefficients can be: ai ε{1.0, 0.667, 0.333, 0.0}, and bi ε{0.0, 0.333, 0.667, 1.0}. Another example may incorporate the results of a training algorithm, such as the Linde-Buzo-Gray (or LBG) algorithm, where many values of a and b can be evaluated offline using a training database, and then choosing a, and b, based on the statistical distributions. Such methods for training are well known in the art. Other functions can also be possible. For example, the following function may be found to be beneficial for certain classes of signals:

ƒ(x2,i)=air+birlpf,  (25)

where rlpf can be a low pass filtered version of r. Alternatively, the LPF characteristic may be altered as a function of i:

ƒ(x2,i)=Bir,  (26)

where Bi may be a class of linear phase filtering characteristics intended to shape the residual domain quantization error in a way that more closely resembles that of the error in the weighted domain. Yet another method may involve specifying a family of inverse perceptual weighting functions that may also shape the error in a way that is beneficial in shaping the residual domain error:

ƒ(x2,i)=H−1x2,  (27)

The weighted signal can then be quantified into a form that can be utilized by the particular FCB coding process. U.S. Pat. No. 5,754,976 to Adoul and U.S. Pat. No. 6,236,960 to Peng, hereby incorporated by reference, disclose coding methods that use unit magnitude pulse codebooks that are algebraic in nature. That is, the codebooks are generated on the fly, as opposed to being stored in memory, searching various pulse position and amplitude combinations, finding a low error pulse combination, and then coding the positions and amplitudes using combinatorial techniques to form a codeword k that is subsequently used by a decoder to regenerate ck and further generate an approximation ŝ(n) of the input signal s(n).
According to one embodiment, the codebook disclosed in U.S. Pat. No. 6,236,960 can be used to quantify the inverse weighted signal into a form that can be utilized by the particular FCB coding process. The i-th pre-quantizer candidate ck[i] may be obtained from Eq. 22 by iteratively adjusting a gain term gQ as:




  
    
      
        
          
            c
            k
            
              [
              i
              ]
            
          
          =
          
            
              
                round
                ⁡
                
                  (
                  
                    
                      g
                      Q
                    
                    ⁢
                    
                      f
                      ⁡
                      
                        (
                        
                          
                            x
                            2
                          
                          ,
                          i
                        
                        )
                      
                    
                  
                  )
                
              
              ⁢
              
                :
              
              ⁢
              
                
                  ∑
                  n
                
                ⁢
                
                  
                  
                    
                      c
                      k
                      
                        [
                        i
                        ]
                      
                    
                    ⁡
                    
                      (
                      n
                      )
                    
                  
                  
                
              
            
            =
            m
          
        
        ,
      
    
    
      
        (
        28
        )
      
    
  




where the round( ) operator rounds the respective vector elements of gQƒ(x2,i) to the nearest integer value, where n represents the n-th element of vector ck[i], and m is the total number of unit magnitude pulses. This expression describes a process of selecting gQ such that the total number of unit amplitude pulses in ck[i] equals m.

It is also not necessary for ck[i*] to contain the exact number of pulses as allowed by the FCB. For example, the FCB configuration may allow ck to contain 20 pulses, but the pre-quantizer stage may use only 10 or 15 pulses. The remaining pulses can be placed by the post search, which will be described later with respect to FIG. 9. In another case, the pre-quantizer stage may place more pulses than allowed by the FCB configuration. In this embodiment, the post search may remove pulses in a way that attempts to minimize the weighted error. In one embodiment, however, the number of pulses in the pre-quantizer vector can be generally equal to the number of pulses allowed by a particular FCB configuration. In this case, the post search may involve removing a unit magnitude pulse from one position and placing the pulse at a different location that results in a lower weighted error. This process may be repeated until the codebook converges or until a predetermined maximum number of iterations is reached.
To further expand on the above embodiments where the candidate code-vectors ck[i] and the eventual FCB output vector ck may or may not contain the same number of unit magnitude pulses, another embodiment exists where the candidate codebook for generating ck[i] may be different than the codebook for generating ck. That is, the best candidate ck[i*] may generally be used to reduce complexity or improve overall performance of the resulting code-vector ck, by using ck[i*] as a means for determining the best inverse function ƒ(x2,i*), and then proceeding to use ƒ(x2,i*) as a means for searching a second codebook c′k. Such an example may include using a Factorial Pulse Coded (FPC) codebook for generating ck[i*], and then using a traditional ACELP codebook to generate c′k, wherein the inverse function ƒ(x2,i*) is used in the secondary codebook search c′k, and the candidate code-vectors ck[i] are discarded. In this way, for example, the pre-selection of pulse signs for the secondary codebook c′k may be based on a plurality of inverse functions ƒ(x2,i), and not directly on the candidate code-vectors ck[i]. This embodiment may allow performance improvement to existing codecs that use a specific codebook design, while maintaining interoperability and backward compatibility.
In another embodiment, a very large value of N may be used. For example, if N=100, then the weighting coefficients [ai bi] can span a very high resolution set, and can result in a solution that will yield optimal results.
According to U.S. Pat. No. 7,054,807 to Mittal, which is hereby incorporated by reference, the ACB/FCB parameters may be jointly optimized. The joint optimization can also be used for evaluation of N pre-quantizer candidates. Now Eq. 17 can become:




  
    
      
        
          
            i
            *
          
          =
          
            
              argmax
              
                0
                ≤
                i
                <
                N
              
            
            ⁢
            
              {
              
                
                  
                    (
                    
                      
                        d
                        2
                        T
                      
                      ⁢
                      
                        c
                        k
                        
                          [
                          i
                          ]
                        
                      
                    
                    )
                  
                  2
                
                
                  
                    c
                    k
                    
                      
                        [
                        i
                        ]
                      
                      ⁢
                      T
                    
                  
                  ⁢
                  
                    Φ
                    ′
                  
                  ⁢
                  
                    c
                    k
                    
                      [
                      i
                      ]
                    
                  
                
              
              }
            
          
        
        ,
      
    
    
      
        (
        29
        )
      
    
  




where Φ′=Φ−yyT and where y can be a scaled backward filtered ACB excitation. Now i* may be determined through brute force computation:





  
    
      
        
          
            i
            *
          
          =
          
            
              argmax
              
                0
                ≤
                i
                <
                N
              
            
            ⁢
            
              {
              
                
                  
                    (
                    
                      
                        x
                        2
                        T
                      
                      ⁢
                      
                        y
                        2
                        
                          [
                          i
                          ]
                        
                      
                    
                    )
                  
                  2
                
                
                  
                    
                      y
                      2
                      
                        
                          [
                          i
                          ]
                        
                        T
                      
                    
                    ⁢
                    
                      y
                      2
                      
                        [
                        i
                        ]
                      
                    
                  
                  -
                  
                    
                      (
                      
                        
                          y
                          T
                        
                        ⁢
                        
                          c
                          k
                          
                            [
                            i
                            ]
                          
                        
                      
                      )
                    
                    2
                  
                
              
              }
            
          
        
        ,
      
    
    
      
        (
        30
        )
      
    
  




where y2[i]=Hck[i] can be the i-th pre-quantizer candidate filtered though the zero state weighted synthesis filter 105 and yTck[i] can be a correlation between the i-th pre-quantizer candidate and the scaled backward filtered ACB excitation.

FIG. 3 is an example illustration of a flowchart 300 outlining the operation of the coder 100 according to one embodiment. The flowchart 300 illustrates a method that can include the embodiments disclosed above.
At 310, a target vector x2 can be generated from a received input signal s(n). The input signal s(n) can be based on an audible speech input signal. At 320, a plurality of inverse weighting functions ƒ(x2,i) can be constructed based on the target vector x2. Optionally, a plurality of candidate code-vectors ck[i] can also be constructed based on the target vector x2 and inverse weighting functions ƒ(x2,i). The plurality of inverse weighting functions ƒ(x2,i) (and/or plurality of candidate code-vectors ck[i]) can be constructed based on an inverse filtered vector and based on a backward filtered vector along with the target vector x2. The plurality of inverse weighting functions ƒ(x2,i) (and/or plurality of candidate code-vectors ck[i]) can also be constructed based on a sum of a weighted inverse filtered vector and a weighted backward filtered vector along with the target vector x2.
At 330, an error value ε associated with each code-vector of the plurality of inverse weighting functions ƒ(x2,i) (and/or plurality of candidate code-vectors ck[i]) can be evaluated to produce a fixed codebook code-vector ck. For example, errors ε[i] of ck[i] can be evaluated to produce ck[i*], then ck[i*] can be used as a basis for further searching on ck. Note that the value k can be the ultimate codebook index that is output.
At 340, a codeword k representative of the fixed codebook code-vector ck can be generated, where the codeword can be used by a decoder to generate an approximation ŝ(n) of the input signal s(n). At 350, the codeword k can be output. For example, the codeword k can be a fixed codebook index parameter codeword k that can be output by transmitting the fixed codebook index parameter k and/or storing the fixed codebook index parameter k.
FIG. 4 is an example illustration of a flowchart 400 outlining the operation of block 320 of FIG. 3 according to one embodiment. At 410, an inverse filtered vector r can be constructed from the target vector x2. The inverse weighting function ƒ(x2, i) of block 320 can be based on the inverse filtered vector r constructed from the target vector x2. The inverse filtered vector r can be constructed based on r=H−1x2, where r can be the inverse filtered vector, where H−1 can be a zero-state weighted synthesis convolution matrix formed from an impulse response of a weighted synthesis filter, and where x2 can be the target vector. Other variations are described in other embodiments above.
At 420, a backward filtered vector d2 can be constructed from the target vector x2. The inverse weighting function ƒ(x2, i) of block 320 can be based on the backward filtered vector d2 constructed from the target vector x2. The backward filtered vector d2 can be constructed based on d2=HTx2, where d2 can be the backward filtered vector, where HT can be a transpose of a zero-state weighted synthesis convolution matrix formed from an impulse response of a weighted synthesis filter, and where x2 can be the target vector. Other variations are described in other embodiments above.
At 430, a plurality of inverse weighting functions ƒ(x2,i) (and/or plurality of candidate code-vectors ck[i]) can be constructed based on a weighting of the inverse filtered vector r and a weighting of the backward filtered vector d2, where the weighting can be different for each of the associated candidate code-vectors ck[i]. For example, the weighting can be based on




  
    f
    ⁡
    
      (
      
        
          x
          2
        
        ,
        i
      
      )
    
  
  =
  
    
      
        a
        i
      
      ⁢
      
        r
        
          
          r
          
        
      
    
    +
    
      
        b
        i
      
      ⁢
      
        
          d
          2
        
        
          
          
            d
            2
          
          
        
      
    
  




or other weighting described above.

FIG. 5 is an example illustration 500 of two conceptual candidate code-vectors ck[i] for i=1 and i=2 according to one embodiment. The candidate code-vectors ck[1] and ck[2] can correspond to factorial pulse coded vectors for different functions ƒ(x2, 1) and ƒ(x2, 2) of a target vector. As discussed above, one of the candidate code-vectors, ck[i], can be used as a basis for choosing codeword ck that generates a fixed codebook index parameter k. The fixed codebook index parameter k can identify, at least in part, a set of pulse amplitude and position combinations, such as including a pulse amplitude 510 and a position 520, in a codebook. Each pulse amplitude and position combination can define L different positions and can include both zero-amplitude pulses and non-zero-amplitude pulses assigned to respective positions p=0, 1, 2, . . . L−1 of the combination. The set of pulse amplitude and position combinations can be used for functions ƒ(x2, 1) and ƒ(x2, 2) for a chosen candidate code-vector ck[i*], such as, for example, code-vector ck[1]. The illustration 500 is only intended as a conceptual example and does not correspond to any actual number of pulses, positions of pulses, code-vectors, or signals.
FIG. 6 is an example illustration of a flowchart 600 outlining the operation of the coder 100 according to one embodiment. The functions of flowchart 600 may be implemented within the fixed codebook candidate code-vector generator 110. The flowchart 600 illustrates a method that can include the embodiments disclosed above.
At 610, the return value of function ƒ(x2,i) can be redefined as a residual domain target vector b, where vector b is a different variable from the b, weighting coefficient. At 620, a scalar gain value gQ can be initialized to some value, and in this case, an estimate can be used based on an average of the vector magnitudes:




  
    
      
        
          g
          Q
        
        =
        
          
            1
            m
          
          ⁢
          
            
              ∑
              
                n
                =
                0
              
              
                L
                -
                1
              
            
            ⁢
            
              
              
                b
                ⁡
                
                  (
                  n
                  )
                
              
              
            
          
        
      
    
    
      
        (
        31
        )
      
    
  




where m can be the total or desired number of unit magnitude pulses, L can be the vector length, and b(n) can be the nth element of the residual domain target vector b. At 630, an iterative search process can begin by which the gain value gQ can be varied to produce a pre-quantizer candidate ck[i] that can contain the appropriate number of unit magnitude pulses m, the positions of which correspond to a low residual domain error, i.e., ∥gQck[i]−b∥2 can be a minimum. Given the initialization above, ck[i] can be generated according to:





  
    
      
        
          c
          k
          
            [
            i
            ]
          
        
        =
        
          round
          ⁡
          
            (
            
              b
              
                g
                Q
              
            
            )
          
        
      
    
    
      
        (
        32
        )
      
    
  




If it is determined at 640 and 650 that the above operation results in the number of unit amplitude pulses in ck[i] being m, that is:





  
    
      
        
          
            
              ∑
              n
            
            ⁢
            
              
              
                
                  c
                  k
                  
                    [
                    i
                    ]
                  
                
                ⁡
                
                  (
                  n
                  )
                
              
              
            
          
          =
          m
        
        ,
      
    
    
      
        (
        33
        )
      
    
  




then at 660 the process is complete. Otherwise, the gain value gQ is appropriately altered and the process is repeated. For example, if it is determined at 650 that the result is





  
    
      
        ∑
        n
      
      ⁢
      
        
        
          
            c
            k
            
              [
              i
              ]
            
          
          ⁡
          
            (
            n
            )
          
        
        
      
    
    >
    m
  
  ,




then gQ can be increased at 670 so that fewer unit magnitude pulses m are generated when repeating Eq. 32. Likewise, if it is determined at 640 that





  
    
      
        ∑
        n
      
      ⁢
      
        
        
          
            c
            k
            
              [
              i
              ]
            
          
          ⁡
          
            (
            n
            )
          
        
        
      
    
    <
    m
  
  ,




then gQ can be decreased at 680 so that fewer unit magnitude pulses m are generated when repeating Eq. 32.

As one may notice, the method described above involves jointly quantizing a plurality of elements within the residual domain target vector b to produce an initial codebook candidate vector ck[i] through an iterative search process. The functions of flowchart 700 may be implemented within the fixed codebook candidate code-vector generator 110, and this flowchart 700 may occur after the flowchart 400 of FIG. 4.
Many other ways of determining an initial codebook candidate value ck[i] from the residual domain target vector b=ƒ(x2,i) exist. For example, a median search based quantization method may be employed that may be more efficient. This can be an iterative process involving finding an optimum pulse configuration satisfying the pulse sum constraint for a given gain and then finding an optimum gain for the optimum pulse configuration. A practical example of such a median search based quantization is given in ITU-T Recommendation G.718 entitled “Frame error robust narrow-band and wideband embedded variable bit-rate coding of speech and audio from 8-32 kbit/s”, section 6.11.6.2.4, pp. 153, which is hereby incorporated by reference.
FIG. 7 is an example illustration of a flowchart 700 outlining the operation of the coder 100 according to one embodiment. This method of the flowchart 700 can tend to minimize the residual domain error ∥g{circumflex over (b)}−b∥2. This flowchart 700 may occur after the flowchart 400 of FIG. 4. In this embodiment, a median based Vector Quantization (VQ) search process is used to obtain the output vector ck[i]={circumflex over (b)} from the residual domain target vector b=ƒ(x2,i) from 710. The main parameter for the search is the sum of pulse magnitudes m. If m<L, a maximum of m out of the L locations of the output vector {circumflex over (b)} will be non-zero. Moreover, if the length of the vector b is significantly greater than the sum of pulse magnitudes m, the VQ search technique may be performed on a “collapsed” vector bd from 720, where bd can correspond to the largest of the m absolute values of b. For example, from FIG. 5, the vector b=ƒ(x2, i) can be collapsed to the eleven (m=11) elements which have a magnitude component large enough to contain a pulse. So let md be the mth largest value of |b|, i.e., there are m elements in |b| such that |b(n)≧md. The vector

bd={|b(n)|:|b(n)|≧md,b(n)εb}  (34)

is therefore an m-dimensional vector whose elements are the m largest magnitude elements of vector b. The index and signs of components of b which form bd are stored as Ib and σb. Otherwise, the vector may simply be defined as:

bd=|b|,  (35)

where the signs of b may be stored in σb.

At 730, the initial gain g for finding the optimum vector may be given by:




  
    
      
        g
        =
        
          
            1
            m
          
          ⁢
          
            
              ∑
              
                n
                =
                0
              
              
                m
                -
                1
              
            
            ⁢
            
              
                b
                d
              
              ⁡
              
                (
                n
                )
              
            
          
        
      
    
    
      
        (
        36
        )
      
    
  




where bd (n) can be the nth element of vector bd. At 740, to obtain the optimum vector satisfying the Factorial Pulse Coding (FPC) constraint (i.e., the sum of integral valued pulse magnitudes within a vector is a constant), for a given gain g, first an intermediate output vector y given by





  
    
      
        
          
            y
            ⁡
            
              (
              n
              )
            
          
          =
          
            round
            ⁡
            
              (
              
                
                  
                    b
                    d
                  
                  ⁡
                  
                    (
                    n
                    )
                  
                
                g
              
              )
            
          
        
        ,
        
          

        
        ⁢
        
          0
          ≤
          n
          <
          m
        
        ,
      
    
    
      
        (
        37
        )
      
    
  




is obtained. The resulting vector y may or may not satisfy the FPC constraint. At 750, to ensure that the FPC constraint is satisfied, the following definition is made:





  
    
      
        
          S
          y
        
        =
        
          
            ∑
            
              n
              =
              0
            
            
              m
              -
              1
            
          
          ⁢
          
            y
            ⁡
            
              (
              n
              )
            
          
        
      
    
    
      
        (
        38
        )
      
    
  




At 760, if the definition results in Sy=m, then the VQ search process may optionally expand the vector at 762 and can finish at 764 with a pre-quantizer candidate cki*.
If Sy≠m, then an error vector can be generated of the form:

Ey=bd−gy.  (39)

At 770, depending on whether Sy is greater than or less than m, the intermediate vector is modified to generate a vector satisfying the FPC constraint. For example, if Sy is greater than m, then at 772 Sy−m pulses in y can be removed. The locations j of pulses which are to be removed can be identified as

j={n:ey(n)≦medianl(Ey,Sy−m)},  (40)

where Ey={ey(0), ey(1), . . . , ey(m−1)}. One pulse is removed from y at each of the above locations, which correspond to the locations of the Sy−m smallest error values. While removing a pulse at a location j, it is made sure that yj is non-zero at that location; otherwise the magnitude of the next smallest error location may be reduced.

If, on the other hand, Sy<m, then, at 774, m−Sy pulses can be added to y. The location of these pulses can be obtained as:

j={n:ey(n)≧medianh(Ey,m−Sy)},  (41)

which can correspond to the locations of the m−Sy largest error values. The modification steps can ensure that the FPC constraint is satisfied for vector y. At 780, the optimum gain g for vector y can be recomputed as:





  
    
      
        g
        =
        
          
            
              
                ∑
                
                  n
                  =
                  0
                
                
                  m
                  -
                  1
                
              
              ⁢
              
                
                  
                    b
                    d
                  
                  ⁡
                  
                    (
                    n
                    )
                  
                
                ⁢
                
                  y
                  ⁡
                  
                    (
                    n
                    )
                  
                
              
            
            
              
                ∑
                
                  n
                  =
                  0
                
                
                  m
                  -
                  1
                
              
              ⁢
              
                
                  y
                  2
                
                ⁡
                
                  (
                  n
                  )
                
              
            
          
          .
        
      
    
    
      
        (
        42
        )
      
    
  




and the steps 740 and 750 can be repeated. After Sy=m, at 764, the intermediate output vector y can then be used to form the L dimension output vector ck[i]=1; by remapping y using the indexes Ib and signs σb. That is:





  
    
      
        
          
            b
            ^
          
          ⁡
          
            (
            j
            )
          
        
        =
        
          {
          
            
              
                
                  
                    
                      
                        
                          
                            σ
                            b
                          
                          ⁡
                          
                            (
                            j
                            )
                          
                        
                        ⁢
                        
                          y
                          ⁡
                          
                            (
                            i
                            )
                          
                        
                      
                      ;
                    
                  
                  
                    
                      
                        j
                        ∈
                        
                          I
                          b
                        
                      
                      ,
                      
                        i
                        ∈
                        
                          {
                          
                            0
                            ,
                            ...
                            ⁢
                            
                              
                            
                            ,
                            
                              m
                              -
                              1
                            
                          
                          }
                        
                      
                    
                  
                
                
                  
                    
                      0
                      ;
                    
                  
                  
                    
                      otherwise
                      ,
                    
                  
                
              
              ⁢
              
                

              
              ⁢
              0
            
            ≤
            j
            <
            
              L
              .
            
          
        
      
    
    
      
        (
        43
        )
      
    
  




In the case where the number of pulses m is not significantly more than the vector length L, the above expression may simply be:

{circumflex over (b)}(j)=σb(j)y(j);0≦j<L  (44)

FIG. 8 is an example illustration of a flowchart 800 outlining the operation of the coder 100 according to one embodiment. Instead of stopping when Sy=m per FIG. 7 step 760, FIG. 8 iterates pulse repositioning until a predetermined condition is met. For example, the search process may be terminated after a predetermined number of iterations have been performed. As above, this method can tend to minimize the residual domain error ∥g{circumflex over (b)}−b∥2. In this embodiment, a median based Vector Quantization (VQ) search process is used to obtain the output vector ck[i]={circumflex over (b)} from the residual domain target vector b=ƒ(x2,i) from 805. The main parameter for the search can be the sum of pulse magnitudes m. If m<L, a maximum of m out of the L locations of the output vector {circumflex over (b)} will be non-zero. Moreover, if the length of the vector L is significantly greater than the sum of pulse magnitudes m, the VQ search technique may be performed on a “collapsed” vector bd from 810, where bd can correspond to the largest of the m absolute values of b, such as described with respect to element 720 in FIG. 7.
In the subsequent description, medianh(E, k) and medianl(E, k) can refer to the kth higher and kth lower median of vector E, respectively, that is:

medianh(E,k)=max(md):({e(n):e(n)≧md,e(n)εE})=k  (45)

and

medianl(E,k)=min(md):({e(n):e(n)≦md,e(n)εE})=k  (46)

where  is a cardinality operator which counts the number of elements in a set.

Using this definition of the kth high and low median values of a given set E, the following iterative process can involve finding an optimum pulse configuration satisfying the FPC constraint for a given gain, and then finding the optimum gain for the optimum pulse configuration. As in the example above, this method also tends to minimize the residual domain error ∥g{circumflex over (b)}−b∥2. At 815, the initial gain g for finding the optimum vector b may be given by Eq. 36:




  
    
      
        g
        =
        
          
            1
            m
          
          ⁢
          
            
              ∑
              
                n
                =
                0
              
              
                m
                -
                1
              
            
            ⁢
            
              
                b
                d
              
              ⁡
              
                (
                n
                )
              
            
          
        
      
    
    
      
        (
        47
        )
      
    
  




where bb(n) is the nth element of vector bd.

To obtain the optimum vector satisfying the FPC constraint (i.e., the sum of integral valued pulse magnitudes within a vector is a constant) for a given gain g, first at 820, an intermediate output vector y is obtained according to Eq. 37:




  
    
      
        
          
            y
            ⁡
            
              (
              n
              )
            
          
          =
          
            round
            ⁡
            
              (
              
                
                  
                    b
                    d
                  
                  ⁡
                  
                    (
                    n
                    )
                  
                
                g
              
              )
            
          
        
        ,
        
          

        
        ⁢
        
          0
          ≤
          n
          <
          
            m
            .
          
        
      
    
    
      
        (
        48
        )
      
    
  




The resulting vector y may or may not satisfy FPC constraint. To ensure that the FPC constraint is satisfied, at 825 the following definition is made per Eq. 38:





  
    
      
        
          S
          y
        
        =
        
          
            ∑
            
              n
              =
              0
            
            
              m
              -
              1
            
          
          ⁢
          
            y
            ⁡
            
              (
              n
              )
            
          
        
      
    
    
      
        (
        49
        )
      
    
  




and the following error vector is generated of the form of Eq. 39:

Ey=bd−gy  (50)

Now depending on whether Sy is greater than or equal to or less than m at 830, the intermediate vector is modified to generate a vector satisfying the FPC constraint. If SY≧m, then Sy−m pulses in Y are removed at 835. The locations j of pulses which are to be removed are identified from Eq. 40 as

j={n:ey(n)≦medianl(Ey,Sy−m)},  (51)

where Ey={ey(0), ey(1), . . . , ey(m−1)}. One pulse can be removed from y at each of the above locations, which correspond to the locations of the Sy−m smallest error values. While removing a pulse at a location j, it is made sure that yj is non-zero at that location, otherwise the magnitude of the next smallest error location may be reduced. If, on the other hand, Sy<m, then m−Sy pulses can be added to y at 840. The location of these pulses can be obtained from Eq. 41 as:

j={n:ey(n)≧medianh(Ey,m−Sy)},  (52)

which correspond to the locations of the m-Sy largest error values. The modification steps ensure that the FPC constraint is satisfied for vector y.

If the iterations are not complete at 845, at 850, the optimum gain g for vector y can be recomputed per Eq. 42 as:




  
    
      
        g
        =
        
          
            
              
                ∑
                
                  n
                  =
                  0
                
                
                  m
                  -
                  1
                
              
              ⁢
              
                
                  
                    b
                    d
                  
                  ⁡
                  
                    (
                    n
                    )
                  
                
                ⁢
                
                  y
                  ⁡
                  
                    (
                    n
                    )
                  
                
              
            
            
              
                ∑
                
                  n
                  =
                  0
                
                
                  m
                  -
                  1
                
              
              ⁢
              
                
                  y
                  2
                
                ⁡
                
                  (
                  n
                  )
                
              
            
          
          .
        
      
    
    
      
        (
        53
        )
      
    
  




and the steps 820 and 825 are repeated. In an unlikely event that after a predetermined number of iterations through 845, the output vector y does not satisfy the FPC constraint, then the vector y may be further modified by adding or removing pulses. The location of the pulses which are to be added or removed can be identified by:

j={n:ey(n)=ml},  (54)

where vector Ey is calculated in Eq. 50 and ml is the lower median calculated in Eq. 46. The vector b can be optionally expanded at 855. At 860, the intermediate output vector can then be used to form the L dimension output vector ck[i]={circumflex over (b)} by remapping y using the indexes Ib and signs σb. That is, like Eq. 43:





  
    
      
        
          
            b
            ^
          
          ⁡
          
            (
            j
            )
          
        
        =
        
          {
          
            
              
                
                  
                    
                      
                        
                          σ
                          b
                        
                        ⁡
                        
                          (
                          j
                          )
                        
                      
                      ⁢
                      
                        y
                        ⁡
                        
                          (
                          i
                          )
                        
                      
                    
                    ;
                  
                
                
                  
                    
                      j
                      ∈
                      
                        I
                        b
                      
                    
                    ,
                    
                      i
                      ∈
                      
                        {
                        
                          0
                          ,
                          ...
                          ⁢
                          
                            
                          
                          ,
                          
                            m
                            -
                            1
                          
                        
                        }
                      
                    
                  
                
              
              
                
                  
                    0
                    ;
                  
                
                
                  otherwise
                
              
            
            ,
            
              

            
            ⁢
            
              0
              ≤
              j
              <
              
                L
                .
              
            
          
        
      
    
    
      
        (
        55
        )
      
    
  




In the case where the number of pulses m is not significantly more than the vector length L, the above expression may simply be like Eq. 44:

{circumflex over (b)}(j)=σb(j)y(j);0≦j<L.  (56)

It should be noted that while the median based VQ search can be based on a very efficient search methodology, other methods are possible. For example, in the above procedure, it may be possible to employ a brute force method for finding the largest or smallest elements of the error vector Ey that may not have the same computational complexity benefits as the median based VQ search; however, the end result may be identical or nearly identical in terms of performance. In addition, the search methods in FIG. 7 and FIG. 8 may be combined to improve overall efficiency. For example, the termination test step 760 may be placed between steps 825 and 830, and then coupled to block 855 in the event that the search has converged (Sy=m). This allows complexity to be limited through fixed means (block 845), or by convergence to the optimum number of pulses per 760 of FIG. 7.
Moving on, the N different pre-quantizer candidates may be evaluated according to the following expression (which is based on Eq. 17):




  
    
      
        
          
            i
            *
          
          =
          
            
              argmax
              
                0
                ≤
                i
                <
                N
              
            
            ⁢
            
              {
              
                
                  
                    (
                    
                      
                        d
                        2
                        T
                      
                      ⁢
                      
                        c
                        k
                        
                          [
                          i
                          ]
                        
                      
                    
                    )
                  
                  2
                
                
                  
                    c
                    k
                    
                      
                        [
                        i
                        ]
                      
                      ⁢
                      T
                    
                  
                  ⁢
                  
                    Φc
                    k
                    
                      [
                      i
                      ]
                    
                  
                
              
              }
            
          
        
        ,
      
    
    
      
        (
        57
        )
      
    
  




where ck[i] can be substituted for ck, and the best candidate i* out of N candidates can be selected. Alternatively, I may be determined through brute force computation:





  
    
      
        
          
            i
            *
          
          =
          
            
              argmax
              
                0
                ≤
                i
                <
                N
              
            
            ⁢
            
              {
              
                
                  
                    (
                    
                      
                        x
                        2
                        T
                      
                      ⁢
                      
                        y
                        2
                        
                          [
                          i
                          ]
                        
                      
                    
                    )
                  
                  2
                
                
                  
                    y
                    2
                    
                      
                        [
                        i
                        ]
                      
                      ⁢
                      T
                    
                  
                  ⁢
                  
                    y
                    2
                    
                      [
                      i
                      ]
                    
                  
                
              
              }
            
          
        
        ,
      
    
    
      
        (
        58
        )
      
    
  




where y2[i]=Hck[i] and can be the i-th pre-quantizer candidate filtered though the zero state weighted synthesis filter 105. The latter method may be used for complexity reasons, especially when the number of non-zero positions in the pre-quantizer candidate, ck[i], is relatively high or when the different pre-quantizer candidates have very different pulse locations. In those cases, the efficient search techniques described in the prior art do not necessarily hold. The two methods given in Eqs. 57 and 58, however, are equivalent.

After the best pre-quantizer candidate ck[i*] is selected, a post-search may be conducted to refine the pulse positions, and/or the signs, so that the overall weighted error is reduced further. The post-search may be one described by Eq. 57. In this case, the numerator and denominator of Eq. 57 may be initialized by letting ck=ck[i*], and then iterating on k to reduce the weighted error. This is described in more detail below.
After ck is initialized, a new error metric ε can be defined based on Eq. 17 as:




  
    
      
        
          ɛ
          =
          
            
              
                (
                
                  
                    d
                    2
                    T
                  
                  ⁢
                  
                    c
                    k
                  
                
                )
              
              2
            
            
              
                c
                k
                T
              
              ⁢
              Φ
              ⁢
              
                
              
              ⁢
              
                c
                k
              
            
          
        
        ,
      
    
    
      
        (
        59
        )
      
    
  




which can be maximized (per Eq. 17) to find a low error value. During the post-search, ck can be iterated by defining a vector containing a single pulse cm that is subtracted from ck, and defining another vector cp containing a single pulse that is added back in at a different location. This can be expressed as c′k=ck−cm+cp. If this expression is plugged into Eq. 59, a second error metric ε′ can be defined as:





  
    
      
        
          
            
              
                ɛ
                ′
              
              =
              
              ⁢
              
                
                  
                    (
                    
                      
                        d
                        2
                        T
                      
                      ⁢
                      
                        c
                        k
                        ′
                      
                    
                    )
                  
                  2
                
                
                  
                    c
                    k
                    
                      ′
                      ⁢
                      
                        
                      
                      ⁢
                      T
                    
                  
                  ⁢
                  Φ
                  ⁢
                  
                    
                  
                  ⁢
                  
                    c
                    k
                    ′
                  
                
              
            
          
        
        
          
            
              =
              
              ⁢
              
                
                  
                    
                      (
                      
                        
                          d
                          2
                          T
                        
                        ⁡
                        
                          (
                          
                            
                              c
                              k
                            
                            -
                            
                              c
                              m
                            
                            +
                            
                              c
                              p
                            
                          
                          )
                        
                      
                      )
                    
                    2
                  
                  
                    
                      
                        (
                        
                          
                            c
                            k
                          
                          -
                          
                            c
                            m
                          
                          +
                          
                            c
                            p
                          
                        
                        )
                      
                      T
                    
                    ⁢
                    
                      Φ
                      ⁡
                      
                        (
                        
                          
                            c
                            k
                          
                          -
                          
                            c
                            m
                          
                          +
                          
                            c
                            p
                          
                        
                        )
                      
                    
                  
                
                .
              
            
          
        
      
    
    
      
        (
        60
        )
      
    
  




FIG. 9 is an example illustration of a flowchart 900 outlining the operation of the coder 100 according to one embodiment. The functions of flowchart 900 may be implemented within the FCB loop of FIG. 1 (i.e., fixed codebook 104, zero state weighted synthesis H equivalent 105, weighting block 141, combiner 108, error minimization block 107, and output 126). The flowchart 900 shows one example of a post-search strategy that uses the above idea. For example, a pulse at each position nm can be removed one at a time, replaced by a single pulse at a time, over all possible positions 0≦np<L, and evaluated for a low error value. At 905, the post-search strategy begins. At 910, the code-vector ck is initialized by letting ck=ck[i*]. At 915, the error metric ε is initialized according to Eq. 59. The first (i.e., “outer”) loop is then initialized, which controls the pulses that are effectively removed from code-vector ck. For example, the outer loop can run through nm positions from zero to L−1 in the code-vector ck. At 917, nm can be set to zero. At 920, the method can determine whether the last position L−1 has been processed. If it has, at 925, the post-search can finish. If the last position L−1 has not been processed, at 930, the method can check whether or not a pulse exists in code-vector ck at position nm. If a pulse does not exist at position nm, then the position nm is incremented through 920 until a non-zero position in code-vector ck is found at 930. If a non-zero position is found, nm can be incremented at 932 and the process can continue at 920.
After a non-zero position is found, the vector cm can be formed, which can be defined at 935 as:




  
    
      
        
          
            c
            m
          
          ⁡
          
            (
            n
            )
          
        
        =
        
          {
          
            
              
                
                  
                    
                      sgn
                      ⁡
                      
                        (
                        
                          
                            c
                            k
                          
                          ⁡
                          
                            (
                            n
                            )
                          
                        
                        )
                      
                    
                    ;
                  
                
                
                  
                    n
                    =
                    
                      n
                      m
                    
                  
                
              
              
                
                  
                    0
                    ;
                  
                
                
                  otherwise
                
              
            
            ,
            
              

            
            ⁢
            
              0
              ≤
              n
              <
              L
            
            ,
          
        
      
    
    
      
        (
        61
        )
      
    
  




where sgn(ck(n)) can be the signum function (+1 or −1) of the respective vector element of code-vector ck. At 940, the method can use vector cm to initialize the value of the “addition vector” csave, which will be discussed next. The second (“inner”) loop is then started, which is used to determine if a particular pulse (defined by cm) may be used somewhere else more effectively to reduce the overall error value. As such, the pulse is added by way of vector cm. The outer loop can run through np positions from zero to L−1 in the code-vector ck. At 917, np can be set to zero. At 945, the method can determine whether the last position L−1 has been processed. If it has, at 950, all positions have been exhausted, and the new best code-vector ck is updated as ck←ck−cm+csave and the method can return to 920. If the last position L−1 has not been processed, at 955, the method can define the pulses cp to add to vector cm as:





  
    
      
        
          
            c
            p
          
          ⁡
          
            (
            n
            )
          
        
        =
        
          {
          
            
              
                
                  
                    
                      sgn
                      ⁡
                      
                        (
                        
                          
                            c
                            k
                          
                          ⁡
                          
                            (
                            n
                            )
                          
                        
                        )
                      
                    
                    ;
                  
                
                
                  
                    n
                    =
                    
                      n
                      p
                    
                  
                
              
              
                
                  
                    0
                    ;
                  
                
                
                  otherwise
                
              
            
            ,
            
              

            
            ⁢
            
              0
              ≤
              n
              <
              L
            
            ,
          
        
      
    
    
      
        (
        62
        )
      
    
  




where np can be the position defined by the inner loop. At 960, the second error metric ε′ can be calculated for the modified code-vector c′k=ck−cm+cp according to Eq. 60. At 965, if the second error metric produces a better result than the original, i.e., ε′>ε, then at 970 the new “best” error metric is saved, along with the new “best” position vector csave, such as the pulse location cp. At 975, np can be incremented.

Again, at 950, all positions have been exhausted, then the new best code-vector ck is updated as ck←ck−cm+csave. In the case where no new “best” position vector is generated, then the proper initialization of csave=cm guarantees that code-vector ck will be unmodified. At 920, the process is then repeated for all iterations defined by the outer loop, e.g., 0≦nm<L.
As one skilled in the art may observe, the above example may be computationally prohibitive on a modern signal processing device because of, among other things, the presence of Eq. 60 in the innermost loop at step 960. As such, the example of the flowchart 900 is intended for illustrative purposes only. A computationally feasible, yet equivalent, example of this process is now described. Referring back to Eq. 60, the terms of this expression can be expanded as:




  
    
      
        
          ɛ
          ′
        
        =
        
          
            
              
                (
                
                  
                    
                      d
                      2
                      T
                    
                    ⁢
                    
                      c
                      k
                    
                  
                  -
                  
                    
                      d
                      2
                      T
                    
                    ⁢
                    
                      c
                      m
                    
                  
                  +
                  
                    
                      d
                      2
                      T
                    
                    ⁢
                    
                      c
                      p
                    
                  
                
                )
              
              2
            
            
              
                
                  c
                  k
                  T
                
                ⁢
                Φ
                ⁢
                
                  
                
                ⁢
                
                  c
                  k
                
              
              +
              
                
                  c
                  m
                  T
                
                ⁢
                Φ
                ⁢
                
                  
                
                ⁢
                
                  c
                  m
                
              
              -
              
                2
                ⁢
                
                  c
                  k
                  T
                
                ⁢
                Φ
                ⁢
                
                  
                
                ⁢
                
                  c
                  m
                
              
              +
              
                
                  c
                  p
                  T
                
                ⁢
                Φ
                ⁢
                
                  
                
                ⁢
                
                  c
                  p
                
              
              -
              
                2
                ⁢
                
                  
                
                ⁢
                
                  c
                  m
                  T
                
                ⁢
                Φ
                ⁢
                
                  
                
                ⁢
                
                  c
                  p
                
              
              +
              
                2
                ⁢
                
                  c
                  k
                  T
                
                ⁢
                Φ
                ⁢
                
                  
                
                ⁢
                
                  c
                  p
                
              
            
          
          .
        
      
    
    
      
        (
        63
        )
      
    
  




As defined for this example, since cm and cp contain only one unit magnitude pulse each, then Eq. 63 can be rewritten as:





  
    
      
        
          ɛ
          ′
        
        =
        
          
            
              (
              
                
                  
                    d
                    2
                    T
                  
                  ⁢
                  
                    c
                    k
                  
                
                -
                
                  
                    d
                    2
                  
                  ⁡
                  
                    (
                    
                      n
                      m
                    
                    )
                  
                
                +
                
                  
                    d
                    2
                  
                  ⁡
                  
                    (
                    
                      n
                      p
                    
                    )
                  
                
              
              )
            
            2
          
          
            
              
                
                  
                    
                      c
                      k
                      T
                    
                    ⁢
                    Φ
                    ⁢
                    
                      
                    
                    ⁢
                    
                      c
                      k
                    
                  
                  +
                  
                    φ
                    ⁡
                    
                      (
                      
                        
                          n
                          m
                        
                        ,
                        
                          n
                          m
                        
                      
                      )
                    
                  
                  -
                  
                    2
                    ⁢
                    
                      c
                      k
                      T
                    
                    ⁢
                    Φ
                    ⁢
                    
                      (
                      
                        n
                        m
                      
                      )
                    
                  
                  +
                
              
            
            
              
                
                  
                    φ
                    ⁢
                    
                      (
                      
                        
                          n
                          p
                        
                        ,
                        
                          n
                          p
                        
                      
                      )
                    
                  
                  -
                  
                    2
                    ⁢
                    
                      φ
                      ⁡
                      
                        (
                        
                          
                            n
                            m
                          
                          ,
                          
                            n
                            p
                          
                        
                        )
                      
                    
                  
                  +
                  
                    2
                    ⁢
                    
                      c
                      k
                      T
                    
                    ⁢
                    
                      Φ
                      ⁡
                      
                        (
                        
                          n
                          p
                        
                        )
                      
                    
                  
                
              
            
          
        
      
    
    
      
        (
        64
        )
      
    
  




where np and nm are the positions of the single pulses within cp and cm, respectively, and where Φ(np) and Φ(nm) are the respective np and nm-th column vectors of the correlation matrix Φ. (Recall from the Background that Φ=HTH, which supports the zero state weighted synthesis H equivalency.) Now looking at where in the process each of the terms can be generated, the following expression, after some rearrangement of terms, shows how most of terms in the inner loop have relatively low complexity, using just a few scalar operations:





  
    
      
        
          ɛ
          ′
        
        =
        
          
            
              
                (
                
                  
                    
                      
                        d
                        2
                        T
                      
                      ⁢
                      
                        c
                        k
                      
                    
                    
                      {
                      Initialization
                    
                  
                  -
                  
                    
                      
                        d
                        2
                      
                      ⁡
                      
                        (
                        
                          n
                          m
                        
                        )
                      
                    
                    
                      {
                      OuterLoop
                    
                  
                  +
                  
                    
                      
                        d
                        2
                      
                      ⁡
                      
                        (
                        
                          n
                          p
                        
                        )
                      
                    
                    
                      {
                      InnerLoop
                    
                  
                
                )
              
              2
            
            
              
                
                  
                    
                      
                        
                          c
                          k
                          T
                        
                        ⁢
                        Φ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          c
                          k
                        
                      
                      
                        }
                        Initialization
                      
                    
                    -
                    
                      
                        
                          2
                          ⁢
                          
                            c
                            k
                            T
                          
                          ⁢
                          
                            Φ
                            ⁡
                            
                              (
                              
                                n
                                m
                              
                              )
                            
                          
                        
                        +
                        
                          φ
                          ⁡
                          
                            (
                            
                              
                                n
                                m
                              
                              ,
                              
                                n
                                m
                              
                            
                            )
                          
                        
                      
                      
                        }
                        OuterLoop
                      
                    
                    +
                  
                
              
              
                
                  
                    
                      
                        2
                        ⁢
                        
                          c
                          k
                          T
                        
                        ⁢
                        
                          Φ
                          ⁡
                          
                            (
                            
                              n
                              p
                            
                            )
                          
                        
                      
                      +
                      
                        φ
                        ⁡
                        
                          (
                          
                            
                              n
                              p
                            
                            ,
                            
                              n
                              p
                            
                          
                          )
                        
                      
                      -
                      
                        2
                        ⁢
                        
                          φ
                          ⁡
                          
                            (
                            
                              
                                n
                                m
                              
                              ,
                              
                                n
                                p
                              
                            
                            )
                          
                        
                      
                    
                    InnerLoop
                  
                
              
            
          
          .
        
      
    
    
      
        (
        65
        )
      
    
  




However, both the inner and outer loops still contain vector terms in the denominator. As another example, these terms can be pre-computed and stored in arrays, and then updated as code-vector ck evolves. For example, a temporary storage vector s can be defined as:

s(n)=2ckTΦ(n),0≦n<L,  (66)

which can then be indexed (as a lookup table) during the inner/outer loop processing. This can then be applied to Eq. 65 to yield:





  
    
      
        
          
            ɛ
            ′
          
          =
          
            
              
                (
                
                  
                    
                      
                        d
                        2
                        T
                      
                      ⁢
                      
                        c
                        k
                      
                    
                    
                      {
                      Initialization
                    
                  
                  -
                  
                    
                      
                        d
                        2
                      
                      ⁡
                      
                        (
                        
                          n
                          m
                        
                        )
                      
                    
                    
                      {
                      OuterLoop
                    
                  
                  +
                  
                    
                      
                        d
                        2
                      
                      ⁡
                      
                        (
                        
                          n
                          p
                        
                        )
                      
                    
                    
                      {
                      InnerLoop
                    
                  
                
                )
              
              2
            
            
              
                
                  
                    
                      
                        
                          c
                          k
                          T
                        
                        ⁢
                        Φ
                        ⁢
                        
                          
                        
                        ⁢
                        
                          c
                          k
                        
                      
                      
                        }
                        Initialization
                      
                    
                    -
                    
                      
                        
                          s
                          ⁢
                          
                            (
                            
                              n
                              m
                            
                            )
                          
                        
                        +
                        
                          φ
                          ⁡
                          
                            (
                            
                              
                                n
                                m
                              
                              ,
                              
                                n
                                m
                              
                            
                            )
                          
                        
                      
                      
                        }
                        OuterLoop
                      
                    
                    +
                  
                
              
              
                
                  
                    
                      
                        s
                        ⁡
                        
                          (
                          
                            n
                            p
                          
                          )
                        
                      
                      +
                      
                        φ
                        ⁡
                        
                          (
                          
                            
                              n
                              p
                            
                            ,
                            
                              n
                              p
                            
                          
                          )
                        
                      
                      -
                      
                        2
                        ⁢
                        
                          φ
                          ⁡
                          
                            (
                            
                              
                                n
                                m
                              
                              ,
                              
                                n
                                p
                              
                            
                            )
                          
                        
                      
                    
                    
                      }
                      InnerLoop
                    
                  
                
              
            
          
        
        ,
      
    
    
      
        (
        67
        )
      
    
  




which now reduces all inner/outer loop to scalar operations involving indexing of pre-computed vector/matrix quantities.

For the embodiments above, it can seen that the computational complexity of the combined pre-quantizer candidate search followed by the post-search can be significantly lower than a brute force exhaustive search over all possible codebook code-vectors. For example, if an FPC codebook (from Peng) is used, and is given to be 20 pulses spread over 64 positions, then the total number of pulse combinations would be 6.56×1023. This number of combinations is impractical to search using any known hardware in a real-time system. However, near optimal performance can be achieved by a combination of the pre-quantizer candidate search and the example post search, which can move some or all of the 20 pulses across each of the 64 positions after the pre-quantizer candidate cki* is determined. When using the disclosed method, only a small number (for example, 20×64=1280) of search iterations defined by Eq. 65 may be required to obtain near optimal performance. Furthermore, as previously noted, all grouping of independent variables can be pre-computed outside of the innermost computation loops, so that overall complexity can be held very low.
FIG. 10 is an example block diagram of a fixed codebook code-vector generator 1000, which may be implemented within the fixed codebook candidate code-vector generator 110 from FIG. 1, according to one embodiment. The fixed codebook candidate code-vector generator 1000 can perform the operations of the methods disclosed above with respect to FIGS. 6, 7, 8, and 9. The fixed codebook candidate code-vector generator 1000 can include an inverse weighting function generator 1010, a vector quantizer 1020, a post search 1030, and a codeword generator 1040.
The fixed codebook code-vector generator 1000 can produce a final fixed codebook code-vector ck based on a code-vector cki* from a set of candidate code-vectors ck[i]. The fixed codebook code-vector generator 1000 can construct the set of candidate code-vectors ck[i], where i can be an index for the candidate code-vectors ck[i]. The set of candidate code-vectors ck[i] can be based on a weighted target vector x2 and can be based on an inverse weighting function, such as ƒ(x2,i).
For example, the fixed codebook code-vector generator 1000 can process the weighted target vector x2 through an inverse weighting function ƒ(x2, i) to create a residual domain target vector b. According to one embodiment, the inverse weighting function generator 1010 can process the weighted target vector x2 through the inverse weighting function ƒ(x2, i) to create the residual domain target vector b. The fixed codebook code-vector generator 1000 can obtain the inverse weighting function ƒ(x2, i) based on the weighted target vector x2. The residual domain target vector b may not truly be or may not only be in the residual domain as the inverse weighting function ƒ(x2, i) may include different features. For example, the residual domain target vector b may be an inverse weighting result, a pitch removed residual target vector, or any other target vector that results from the inverse weighting function ƒ(x2, i).
The fixed codebook code-vector generator 1000, which may be implemented in the fixed codebook candidate code-vector generator 110 of the coder 100, can use the vector quantizer 1020 to perform a first search process on the residual domain target vector b to obtain an initial fixed codebook code-vector cki. The fixed codebook candidate code-vector cki can have a pre-determined number of unit magnitude pulses m per FIGS. 6 and 7. The fixed codebook code-vector generator 1000 can perform the first search process on the residual domain target vector b for a low residual domain error to obtain the initial fixed codebook code-vector cki. The coder 100 can perform the first search process by vector quantizing the residual domain target vector b to obtain the initial fixed codebook code-vector cki, where the initial fixed codebook code-vector cki can include a pre-determined number m of unit magnitude pulses. The coder 100 can perform a first search process, or vector quantize, the residual domain target vector b according to the processes illustrated in flowcharts 600, 700, or 800 and according to other processes disclosed in the above embodiments.
For example, the fixed codebook code-vector generator 1000 can vector quantize the residual domain target vector, or otherwise search to obtain an initial fixed codebook candidate code-vector cki*, where the quantization error can be evaluated in the residual domain. The initial fixed codebook candidate code-vector cki*can include a pre-determined number of unit magnitude pulses m. For example, the vector quantizer 1020 can vector quantize the residual domain target vector b to obtain the initial fixed codebook code-vector cki*. The vector quantizer 1020 can use the methods illustrated in the flowcharts 600, 700, and 800 and other methods to vector quantize the residual domain target vector b. Vector quantizing can include jointly quantizing two or more elements of the residual domain target vector b to obtain the initial fixed codebook code-vector cki. Vector quantization or the first search can include rounding a gain term applied to vector elements of the inverse weighting function to select a gain term such that a total number of unit amplitude pulses in the fixed codebook code-vector can equal a given number. Vector quantization or the first search can include performing a median search quantization including finding an optimum pulse configuration satisfying a pulse sum constraint for a given gain and finding an optimum gain for the optimum pulse configuration. Vector quantization or the first search can include using a factorial pulse coded codebook to determine the fixed codebook code-vector. Vector quantization or the first search can also include any other method of vector quantization.
The fixed codebook code-vector generator 1000 can use the post search 1030 implementing flowchart 900 to perform a second search process over a subset of possible codebook code-vectors for a low weighted-domain error to produce a final fixed codebook code-vector ck. The final fixed codebook code-vector ck can have a different number of pulses than the initial fixed codebook code-vector cki. The subset of possible codebook code-vectors can be based on the initial fixed codebook code-vector cki. The fixed codebook code-vector generator 1000 can perform the second search process by iterating the initial fixed codebook code-vector cki through a zero state weighted synthesis filter equivalent 105 using a fixed codebook a plurality of times and by evaluating at least one error value associated with each iteration of the initial fixed codebook code-vector cki from the plurality of times to produce a final fixed codebook code-vector ck based on an initial fixed codebook code-vector with a low error value. The second search process can include using a factorial pulse coded codebook to determine the final fixed codebook code-vector ck. The second search process can also include the process illustrated in the flowchart 900 or can include other processes disclosed in the above embodiments.
For example, the fixed codebook code-vector generator 1000 can perform a post search on the fixed codebook candidate code-vector cki to determine a final fixed codebook candidate code-vector ck. The vector quantizer 1020 can perform a first search process on the residual domain target vector b for low residual domain error to obtain an initial fixed codebook code-vector cki. The first search process can be based on the processes illustrated in FIGS. 6-8 or based on any other search process that can obtain an initial fixed codebook code-vector. The post search 1030 can perform a second search process, such as the post search process of FIG. 9, over a subset of possible codebook code-vectors for a low weighted-domain error to produce a final fixed codebook code-vector ck. The subset of possible codebook code-vectors can be based on the initial fixed codebook code-vector cki. The post search 1030 can determine a final fixed codebook candidate code-vector ck from the second search process. For example, the second search process can be based on the process illustrated in FIG. 9 or can be based on any other search process that can obtain a final fixed codebook candidate code-vector.
The codeword generator 1040 can generate a codeword k representative of the final fixed codebook code-vector ck. The codeword k can be used by a decoder to generate an approximation ŝ(n) of the input signal s(n).
According to a related embodiment, the fixed codebook code-vector generator 1000 can vector quantize the residual domain target vector b to obtain an initial fixed codebook code-vector cki*. The initial fixed codebook code-vector cki* can have a pre-determined number of unit magnitude pulses m. The fixed codebook code-vector generator 1000 can search a subset of possible codebook code-vectors based on the initial fixed codebook code-vector cki* for a low weighted-domain error to produce a final fixed codebook code-vector ck. The final fixed codebook code-vector ck can have a different number of pulses than the initial fixed codebook code-vector cki*.
As another example, target vector generator 124 of FIG. 1 can produce a weighted target vector x2 from the input signal s(n). The fixed codebook candidate code-vector generator 1000 can process the weighted target vector x2 through an inverse weighting function ƒ(x2,i) to create a residual domain target vector b. The fixed codebook candidate code-vector generator 1000 can perform a first search process on the residual domain target vector b for a low residual domain error to obtain an initial fixed codebook code-vector cki*. The fixed codebook candidate code-vector generator 1000 can perform a second search process over a subset of possible codebook code-vectors for a low weighted-domain error to produce a final fixed codebook code-vector cki. The subset of possible codebook code-vectors can be based on the initial fixed codebook code-vector cki*. As an example, the vector quantizer 1020 can perform the first search process according to the processes illustrated in FIGS. 6-8 and the post search 1030 can perform the second search processes according to the process illustrated in FIG. 9.
According to another example, the fixed codebook candidate code-vector generator 1000 can process the target vector x2 through a plurality of inverse weighting functions ƒ(x2, i) to create N residual domain target vectors b. The fixed codebook candidate code-vector generator 1000 can vector quantize the plurality of residual domain target vectors b to obtain a plurality of initial fixed codebook code-vectors cki*, wherein each initial fixed codebook code-vector cki* can have a pre-determined number of unit magnitude pulses m. The fixed codebook candidate code-vector generator 1000 can evaluate an error value ε associated with each initial fixed codebook code-vector cki* to produce a final fixed codebook code-vector ck.
According to another example, the fixed codebook candidate code-vector generator 1000 can vector quantize the residual domain target vector b to obtain an initial fixed codebook code-vector cki. The initial fixed codebook code-vector cki can have a predetermined number of unit magnitude pulses m. The fixed codebook candidate code-vector generator 1000 can iterate the initial fixed codebook code-vector cki using a fixed codebook through a zero state weighted synthesis filter a plurality of times, such as discussed with respect to FIG. 9. The fixed codebook candidate code-vector generator 1000 evaluates at least one error value associated with each iteration of the initial fixed codebook code-vector cki from the plurality of times to produce a final fixed codebook code-vector ck based on an initial fixed codebook code-vector cki with a low error value.
FIG. 11 is an example illustration of a flowchart 1100 outlining the operation of a coder, such as the coder 100, according to one embodiment. Elements 1120, 1130, and 1140 of the flowchart 1100 can illustrate operations of the fixed codebook code-vector generator 1000 from FIG. 10, which may be implemented using the fixed codebook candidate code-vector generator 110 and the FCB loop (i.e., fixed codebook 104, zero state weighted synthesis H equivalent 105, weighting block 141, combiner 108, error minimization block 107, and output 126) from FIG. 1. At 1110, the target vector generator 124 of the coder 100 can produce a weighted target vector x2 from an input signal s(n). At 1120, the fixed codebook code-vector generator 1000 within the fixed codebook candidate code-vector generator 110 of the coder 100 can process weighted the target vector x2 through an inverse weighting function ƒ(x2, i) to create a residual domain target vector b. The coder 100 can obtain an inverse weighting function based on the weighted target vector x2 to process the weighted target vector through the obtained inverse weighting function to create the residual domain target vector. See FIG. 2 and accompanying text.
At 1130, the fixed codebook code-vector generator 1000 within the fixed codebook candidate code-vector generator 110 of the coder 100 can perform a first search process on the residual domain target vector b to obtain an initial fixed codebook code-vector cki. See FIGS. 6, 7, and 8 and accompanying text. The fixed codebook candidate code-vector cki can have a pre-determined number of unit magnitude pulses m. The coder 100 can perform the first search process on the residual domain target vector b for a low residual domain error to obtain the initial fixed codebook code-vector cki. The coder 100 can perform the first search process by vector quantizing the residual domain target vector b to obtain the initial fixed codebook code-vector cki, where the initial fixed codebook code-vector cki can include a pre-determined number of unit magnitude pulses. The coder 100 can perform a first search process or vector quantize the residual domain target vector b according to the processes illustrated in flowcharts 600, 700, or 800 and according to other processes disclosed in the above embodiments.
The first search process can include rounding a gain term applied to vector elements of the inverse weighting function to select a gain term such that a total number of unit amplitude pulses in the initial fixed codebook code-vector equals a given number. The first search process can include performing a median search quantization including finding an optimum pulse configuration satisfying a pulse sum constraint for a given gain and including finding an optimum gain for the optimum pulse configuration. The first search process can also include any other search or vector quantization process that obtains an initial fixed codebook code-vector.
At 1140, the FCB loop (i.e., fixed codebook 104, zero state weighted synthesis H equivalent 105, weighting block 141, combiner 108, error minimization block 107, and output 126) of the coder 100 can perform a second search process using flowchart 900 over a subset of possible codebook code-vectors based on the initial fixed codebook code-vector cki to look for a low weighted-domain error and produce a final fixed codebook code-vector ck. The final fixed codebook code-vector ck can have a different number of pulses than the initial fixed codebook code-vector cki. The subset of possible codebook code-vectors can be based on the initial fixed codebook code-vector cki. The coder 100 can perform the second search process by iterating the initial fixed codebook code-vector cki through a zero state weighted synthesis filter equivalent using a fixed codebook a plurality of times and by evaluating at least one error value associated with each iteration of the initial fixed codebook code-vector cki from the plurality of times to produce a final fixed codebook code-vector ck based on an initial fixed codebook code-vector with a low error value. The second search process can include using a factorial pulse coded codebook to determine the final fixed codebook code-vector ck. The second search process can also include the process illustrated in the flowchart 900 or can include other processes disclosed in the above embodiments.
At 1150, squared error minimization/parameter quantization block 107 of the coder 100 can generate an output 126 with a codeword k representative of the final fixed codebook code-vector ck. The coder 100 can output the codeword by at least one of: transmitting the codeword and storing the codeword. The codeword k can be used by a decoder to generate an approximation of the input signal s(n).
The coder 100 can process, at 1120, the target vector x2 through a plurality of inverse weighting functions ƒ(x2, i) to create a plurality of residual domain target vectors b. The coder 100 can perform, at 1130, the first search process on the plurality of residual domain target vectors b to obtain a plurality of initial fixed codebook code-vectors cki where each initial fixed codebook code-vector cki can include a pre-determined number of unit magnitude pulses. The coder 100 can perform the second search process over a subset of possible codebook code-vectors for a low weighted-domain error based on an error value ε associated with each initial fixed codebook code-vector of the subset of possible codebook code-vectors to produce a final fixed codebook code-vector ck. The subset of possible codebook code-vectors is based on the plurality of initial fixed codebook code-vectors cki. The flowchart 1100 can also incorporate other features and processes described in other embodiments, such performed by the codebook candidate code-vector generator 1000.
While this disclosure has been described with specific embodiments thereof, it is evident that many alternatives, modifications, and variations will be apparent to those skilled in the art. For example, various components of the embodiments may be interchanged, added, or substituted in the other embodiments. Also, all of the elements of each figure are not necessary for operation of the disclosed embodiments. For example, one of ordinary skill in the art of the disclosed embodiments would be enabled to make and use the teachings of the disclosure by simply employing the elements of the independent claims. Accordingly, the embodiments of the disclosure as set forth herein are intended to be illustrative, not limiting. Various changes may be made without departing from the spirit and scope of the disclosure.
In this document, relational terms such as “first,” “second,” and the like may be used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. The term “coupled,” unless otherwise modified, implies that elements may be connected together, but does not require a direct connection. For example, elements may be connected through one or more intervening elements. Furthermore, two elements may be coupled by using physical connections between the elements, by using electrical signals between the elements, by using radio frequency signals between the elements, by using optical signals between the elements, by providing functional interaction between the elements, or by otherwise relating two elements together. Also, relational terms, such as “top,” “bottom,” “front,” “back,” “horizontal,” “vertical,” and the like may be used solely to distinguish a spatial orientation of elements relative to each other and without necessarily implying a spatial orientation relative to any other physical coordinate system. The terms “comprises,” “comprising,” or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. An element proceeded by “a,” “an,” or the like does not, without more constraints, preclude the existence of additional identical elements in the process, method, article, or apparatus that comprises the element. Also, the term “another” is defined as at least a second or more. The terms “including,” “having,” and the like, as used herein, are defined as “comprising.”

## Claims

1. A method for processing an input signal comprising:
producing a weighted target vector from the input signal;
processing the weighted target vector through an inverse weighting function to create a residual domain target vector;
performing a first search process on the residual domain target vector to obtain an initial fixed codebook code-vector;
performing a second search process over a subset of possible codebook code-vectors for a low weighted-domain error to produce a final fixed codebook code-vector, wherein the subset of possible codebook code-vectors is based on the initial fixed codebook code-vector;
generating a codeword representative of the final fixed codebook code-vector to generate an approximation of the input signal; and outputting the codeword by at least one of: transmitting the codeword over a communications channel and storing the codeword on a digital media device.

2. The method according to claim 1, wherein the performing the first search process includes performing a first search on the residual domain target vector for a low residual domain error to obtain the initial fixed codebook code-vector.

3. The method according to claim 1, wherein the performing the first search process includes vector quantizing the residual domain target vector to obtain the initial fixed codebook code-vector, where the initial fixed codebook code-vector includes a pre-determined number of unit magnitude pulses.

4. The method of claim 1, wherein the initial fixed codebook code-vector comprises a different number of pulses than the final fixed codebook code-vector.

5. The method of claim 1, further comprising obtaining the inverse weighting function based on the weighted target vector,
wherein the processing comprises processing the weighted target vector through the obtained inverse weighting function to create the residual domain target vector.

6. The method of claim 1,
wherein the processing comprises:
processing the weighted target vector through a set of inverse weighting functions to create a set of residual domain target vectors,
wherein the performing a first search process comprises:
performing a first search on the set of residual domain target vectors to obtain a set of initial fixed codebook code-vectors where each initial fixed codebook code-vector includes a pre-determined number of unit magnitude pulses, and
wherein the performing a second search process comprises:
performing a second search over the subset of possible codebook code-vectors for the low weighted-domain error based on an error value associated with each initial fixed codebook code-vector of the subset of possible codebook code-vectors to produce the final fixed codebook code-vector, where the subset of possible codebook code-vectors is based on the set of initial fixed codebook code-vectors.

7. The method of claim 1, wherein the performing a second search process comprises:
iterating the initial fixed codebook code-vector using a fixed codebook equivalently processed through a zero state weighted synthesis filter a plurality of times; and
evaluating at least one error value associated with each iteration of the initial fixed codebook code-vector from the plurality of times to produce the final fixed codebook code-vector based on an initial fixed codebook code-vector with a low error value.

8. The method of claim 1, wherein the performing a first search process includes rounding a gain term applied to vector elements of an inverse weighting function output to select a gain term such that a total number of unit amplitude pulses in the initial fixed codebook code-vector equals a given number.

9. The method of claim 1, wherein the performing the first search process includes performing a median search quantization including:
finding an optimum pulse configuration satisfying a pulse sum constraint for a given gain; and
finding an optimum gain for the optimum pulse configuration.

10. The method of claim 1, wherein the performing the second search process includes using a factorial pulse coded codebook to determine the final fixed codebook code-vector.

11. An apparatus comprising:
an input configured to receive an input signal;
a target vector generator configured to produce a weighted target vector from the input signal;
an inverse weighting function generator configured to process the weighted target vector through an inverse weighting function to create a residual domain target vector;
a fixed codebook candidate code-vector generator configured to perform a first search process on the residual domain target vector to obtain an initial fixed codebook code-vector and configured to perform a second search process over a subset of possible codebook code-vectors for a low weighted-domain error to produce a final fixed codebook code-vector, wherein the subset of possible codebook code-vectors is based on the initial fixed codebook code-vector; and
a codeword generator configured to generate a codeword representative of the final fixed codebook code-vector to generate an approximation of the input signal; and
an output configured to output the codeword, wherein the output is configured to output the codeword by at least one of: transmitting the codeword over a communications channel and storing the codeword on a digital media device.

12. The apparatus of claim 11, wherein the fixed codebook candidate code-vector generator includes a vector quantizer configured to perform the first search process by vector quantizing the residual domain target vector to obtain the initial fixed codebook code-vector, where the initial fixed codebook code-vector includes a pre-determined number of unit magnitude pulses.

13. The apparatus according to claim 11, wherein the fixed codebook candidate code-vector generator performs the first search process by performing a first search on the residual domain target vector for a low residual domain error to obtain the initial fixed codebook code-vector.

14. The apparatus of claim 11 wherein the initial fixed codebook code-vector includes a different number of pulses than the final fixed codebook code-vector.

15. The apparatus of claim 11,
wherein the fixed codebook candidate code-vector generator is configured to obtain the inverse weighting function based on the weighted target vector, and
wherein the fixed codebook candidate code-vector generator processes the weighted target vector through the obtained inverse weighting function to create the residual domain target vector.

16. The apparatus of claim 11,
wherein the fixed codebook candidate code-vector generator processes the weighted target vector through a set of inverse weighting functions to create a set of residual domain target vectors,
wherein the fixed codebook candidate code-vector generator performs the first search process on the set of residual domain target vectors to obtain a set of initial fixed codebook code-vectors, where each initial fixed codebook code-vector includes a pre-determined number of unit magnitude pulses, and
wherein the fixed codebook candidate code-vector generator performs the second search process over the subset of possible codebook code-vectors for the low weighted-domain error based on an error value associated with each initial fixed codebook code-vector of the subset of possible codebook code-vectors to produce the final fixed codebook code-vector, where the subset of possible codebook code-vectors is based on the set of initial fixed codebook code-vectors.

17. The apparatus of claim 11,
wherein the fixed codebook candidate code-vector generator is configured to perform the second search process by iterating the initial fixed codebook code-vector using a fixed codebook equivalently processed through a zero state weighted synthesis filter a plurality of times, and evaluating at least one error value associated with each iteration of the initial fixed codebook code-vector from the plurality of times to produce the final fixed codebook code-vector based on an initial fixed codebook code-vector with a low error value.

18. The apparatus of claim 11, wherein the fixed codebook candidate code-vector generator is configured to perform the first search process by rounding a gain term applied to vector elements of the inverse weighting function to select a gain term such that a total number of unit amplitude pulses in the final fixed codebook code-vector equals a given number.

19. The apparatus of claim 11, wherein the fixed codebook candidate code-vector generator is configured to perform the first search process by finding an optimum pulse configuration satisfying a pulse sum constraint for a given gain, and finding an optimum gain for the optimum pulse configuration.

20. The apparatus of claim 11, wherein the fixed codebook candidate code-vector generator is configured perform the second search process by using a factorial pulse coded codebook to determine the final fixed codebook code-vector.