marytts.signalproc.process

Class FrameOverlapAddSource

java.lang.Object

marytts.util.data.BaseDoubleDataSource

marytts.util.data.BufferedDoubleDataSource

marytts.util.data.BlockwiseDoubleDataSource

marytts.signalproc.process.FrameOverlapAddSource

All Implemented Interfaces:

DoubleDataSource

Direct Known Subclasses:

FramewiseMerger, NaiveVocoder, PhaseVocoder, Robotiser

public class FrameOverlapAddSource
extends BlockwiseDoubleDataSource

Compute the overlap-add of a framewise-processed input signal, with optional time stretching (in subclasses). The OLA algorithm works as follows. 1. Assuming an input frameshift of 1/12th of the frame length, and a signal length equal to (frame length+4*frameshift), we cover the input data as follows: (+=valid data points, -=zero, |=valid data point at start/end of input)

     ---|++++++++
      --|+++++++++
       -|++++++++++
        |+++++++++++
         ++++++++++++
          ++++++++++++
           ++++++++++++
            +++++++++++|
             ++++++++++|-
              +++++++++|--
               ++++++++|---
 

With a synthesis frameshift of 1/4th of the frame length, implying that four frames need to be overlapped to reconstruct the signal, this becomes:

          ---|++++++++
             --|+++++++++
                -|++++++++++    
                   |+++++++++++ *** first usable
                      ++++++++++++
                         ++++++++++++
                            ++++++++++++
                               +++++++++++| 
                                  ++++++++++|- 
                                     +++++++++|--
                                        ++++++++|--- *** last usable: first 3 of this
 

It can be seen that three times the input frameshift needs to be zero-padded before the signal, and discarded to reach proper signal reconstruction. Similarly, the last frame to be used is the one to which three times the input shift has been zero-padded; only the first output frameshift samples of it can be used. 2. Assuming an input frameshift of 1/24th of the frame length, and a signal length equal to (frame length+4*frameshift), we cover the input data as follows: (+=valid data points, -=zero, |=valid data point at start/end of input)

 --------|+++++++++++++++
  -------|++++++++++++++++
   ------|+++++++++++++++++
    -----|++++++++++++++++++
     ----|+++++++++++++++++++
      ---|++++++++++++++++++++
       --|+++++++++++++++++++++
        -|++++++++++++++++++++++
         |+++++++++++++++++++++++
          ++++++++++++++++++++++++
           ++++++++++++++++++++++++
            ++++++++++++++++++++++++
             +++++++++++++++++++++++|
              ++++++++++++++++++++++|-
               +++++++++++++++++++++|--
                ++++++++++++++++++++|---
                 +++++++++++++++++++|----
                  ++++++++++++++++++|-----
                   +++++++++++++++++|------
                    ++++++++++++++++|-------
                     +++++++++++++++|--------
 

With a synthesis frameshift of 1/8th of the frame length, implying that eight frames need to be overlapped to reconstruct the signal, this becomes:

 -------|++++++++++++++++
    ------|+++++++++++++++++
       -----|++++++++++++++++++
          ----|+++++++++++++++++++
             ---|++++++++++++++++++++
                --|+++++++++++++++++++++
                   -|++++++++++++++++++++++    
                      |+++++++++++++++++++++++ *** first usable
                         ++++++++++++++++++++++++
                            ++++++++++++++++++++++++
                               ++++++++++++++++++++++++
                                  +++++++++++++++++++++++|
                                     ++++++++++++++++++++++|- 
                                        +++++++++++++++++++++|--
                                           ++++++++++++++++++++|---
                                              +++++++++++++++++++|---- 
                                                 ++++++++++++++++++|-----
                                                    +++++++++++++++++|------
                                                       ++++++++++++++++|------- *** last usable: first 3 of this
 

It can be seen that seven times the input frameshift needs to be zero-padded before the signal, and discarded to reach proper signal reconstruction. Similarly, the last frame to be used is the one to which seven times the input shift has been zero-padded; only the first output frameshift samples of it can be used. 3. Assuming an input frameshift of 1/3rd of the frame length, and a signal length equal to (frame length+4*frameshift), we cover the input data as follows: (+=valid data points, -=zero, |=valid data point at start/end of input)

  --------|+++
      ----|+++++++
          |+++++++++++
              ++++++++++++
                  ++++++++++++
                      ++++++++++++
                          +++++++++++|
                              +++++++|----
                                  +++|--------
 

With a synthesis frameshift of 1/4th of the frame length, implying that four frames need to be overlapped to reconstruct the signal, this becomes:

    --------|+++
       ----|+++++++
          |+++++++++++
             ++++++++++++ *** first usable
                ++++++++++++
                   ++++++++++++
                      +++++++++++|
                         +++++++|----
                            +++|-------- *** last usable: first 3 of this
 

It can be seen that only two times the input frameshift needs to be zero-padded before the signal; nevertheless, the first three frames need to be procesesed but discarded to reach proper signal reconstruction. Similarly, the last frame to be used is the one to which two times the input shift has been zero-padded; only the first output frameshift samples of it can be used. 4. Assuming an input frameshift of 1/2rd of the frame length, and a signal length equal to (frame length+4*frameshift), we cover the input data as follows: (+=valid data points, -=zero, |=valid data point at start/end of input)

    ------|+++++
          |+++++++++++
                ++++++++++++
                      ++++++++++++
                            ++++++++++++
                                  +++++++++++|
                                        +++++|------
 

With a synthesis frameshift of 1/4th of the frame length, implying that four frames need to be overlapped to reconstruct the signal, this becomes:

       ------|+++++
          |+++++++++++
             ++++++++++++
                ++++++++++++ *** first usable
                   ++++++++++++
                      +++++++++++|
                         +++++|------ *** last usable: first 3 of this
 

It can be seen that only two times the input frameshift needs to be zero-padded before the signal; nevertheless, the first three frames need to be procesesed but discarded to reach proper signal reconstruction. Similarly, the last frame to be used is the one to which two times the input shift has been zero-padded; only the first output frameshift samples of it can be used. Generalising: May ro be the output overlap ratio, ro = output frameshift / framelength, and ri be the input overlap ratio, ri = input frameshift / framelength, then n = 1/(1-ro) is the number of frames to be overlapped so that the signal is reconstructed. The amount of zeroes to be padded before and after the signal is (n-1)*input frameshift, or in the case of speeding up, (m-1)*input frameshift where m = 1/ri. (n-1) frames must be read and discarded before the actual data. If the signal length can be described as l = framelength + n*frameshift, exactly output frameshift samples are to be used from the last frame. If the signal is a bit shorter, i.e. l = framelength + n*frameshift - delta, then (output frameshift - delta) samples can be read from the last frame.

Author:

Marc Schröder

Field Summary

Fields

Modifier and Type	Field and Description
static int	DEFAULT_WINDOWTYPE
protected FrameProvider	frameProvider
protected double[]	memory
protected Window	outputWindow
protected InlineDataProcessor	processor

Fields inherited from class marytts.util.data.BlockwiseDoubleDataSource

blockSize

Fields inherited from class marytts.util.data.BufferedDoubleDataSource

buf, dataProcessor, DEFAULT_BUFFERSIZE, readPos, writePos

Fields inherited from class marytts.util.data.BaseDoubleDataSource

dataLength, inputSource

Fields inherited from interface marytts.util.data.DoubleDataSource

NOT_SPECIFIED

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	FrameOverlapAddSource() Default constructor for subclasses who want to call initialise() themselves.
	FrameOverlapAddSource(DoubleDataSource inputSource, int windowType, boolean applySynthesisWindow, int frameLength, int samplingRate, InlineDataProcessor processor)
	FrameOverlapAddSource(DoubleDataSource inputSource, int frameLength, int samplingRate, InlineDataProcessor processor)

Method Summary

Methods

Modifier and Type	Method and Description
protected int	getBlockSize() Provide the size of the next block.
protected int	getInputFrameshift(int outputFrameshift)
protected double[]	getNextFrame() Get the next frame of input data.
boolean	hasMoreData() Whether or not any more data can be read from this data source.
protected void	initialise(DoubleDataSource inputSource, int windowType, boolean applySynthesisWindow, int frameLength, int samplingRate, InlineDataProcessor processor) To be called by constructor in order to set up this frame overlap add source.
static void	main(String[] args)
protected void	prepareBlock() Prepare one block of data for output.
protected int	readBlock(double[] target, int targetPos) Provide a block of data.

Methods inherited from class marytts.util.data.BlockwiseDoubleDataSource

readIntoBuffer

Methods inherited from class marytts.util.data.BufferedDoubleDataSource

available, bufferSpaceLeft, compact, currentlyInBuffer, getData, increaseBufferSize

Methods inherited from class marytts.util.data.BaseDoubleDataSource

getAllData, getData, getData, getDataLength

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

DEFAULT_WINDOWTYPE

public static final int DEFAULT_WINDOWTYPE

See Also:

Constant Field Values

frameProvider

protected FrameProvider frameProvider

outputWindow

protected Window outputWindow

memory

protected double[] memory

processor

protected InlineDataProcessor processor

Constructor Detail

FrameOverlapAddSource

protected FrameOverlapAddSource()

Default constructor for subclasses who want to call initialise() themselves.

FrameOverlapAddSource

public FrameOverlapAddSource(DoubleDataSource inputSource,
                     int frameLength,
                     int samplingRate,
                     InlineDataProcessor processor)

FrameOverlapAddSource

public FrameOverlapAddSource(DoubleDataSource inputSource,
                     int windowType,
                     boolean applySynthesisWindow,
                     int frameLength,
                     int samplingRate,
                     InlineDataProcessor processor)

Method Detail

initialise

protected void initialise(DoubleDataSource inputSource,
              int windowType,
              boolean applySynthesisWindow,
              int frameLength,
              int samplingRate,
              InlineDataProcessor processor)

To be called by constructor in order to set up this frame overlap add source.

Parameters:

inputSource - input source

windowType - window type

applySynthesisWindow - apply synthesis window

frameLength - frame length

samplingRate - sampling rate

processor - processor

getNextFrame

protected double[] getNextFrame()

Get the next frame of input data. This method is called by prepareBlock() when preparing the output data to be read. This implementation simply reads the data from the frameProvider.

Returns:

the next frame of frameProvider

prepareBlock

protected void prepareBlock()

Prepare one block of data for output. This method is called from the superclass before readBlock() is called.

Overrides:

prepareBlock in class BlockwiseDoubleDataSource

getBlockSize

protected int getBlockSize()

Description copied from class: BlockwiseDoubleDataSource

Provide the size of the next block. This implementation returns the fixed blocksize given in the constructor. Subclasses may want to override this method.

Overrides:

getBlockSize in class BlockwiseDoubleDataSource

Returns:

blocksize

readBlock

protected int readBlock(double[] target,
            int targetPos)

Provide a block of data. This method is called from the superclass when data is requested. Note that prepareBlock() will be called before this.

Overrides:

readBlock in class BlockwiseDoubleDataSource

Parameters:

target - target

targetPos - pos

Returns:

number of values written into target from position pos

getInputFrameshift

protected int getInputFrameshift(int outputFrameshift)

hasMoreData

public boolean hasMoreData()

Description copied from class: BufferedDoubleDataSource

Whether or not any more data can be read from this data source.

Specified by:

hasMoreData in interface DoubleDataSource

Overrides:

hasMoreData in class BufferedDoubleDataSource

Returns:

true if another call to getData() will return data, false otherwise.

main

public static void main(String[] args)
                 throws Exception

Throws:

Exception