# Created by Octave 3.8.2, Sat Sep 27 14:07:44 2014 UTC <root@rama>
# name: cache
# type: cell
# rows: 3
# columns: 17
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
Contents


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1087
 LTFAT - Block processing

  Zdenek Prusa, 2013 - 2014.

  Basic methods
    BLOCK          - Setup a new block-stream
    BLOCKDEVICES   - List available audio I/O devices
    BLOCKREAD      - Read samples from file/device
    BLOCKPLAY      - Play block (sound output)
    BLOCKPANEL     - Block-stream control GUI
    BLOCKPANELGET   - Obtain parameter(s) from GUI
    BLOCKDONE      - Closes block-stream and frees resources

  Block-adapted transforms
    BLOCKFRAMEACCEL     - Prepare a frame for a block-stream processing
    BLOCKFRAMEPAIRACCEL - Prepare a pair of frames for a block-stream processing
    BLOCKANA            - Block analysis
    BLOCKSYN            - Block synthesis

  Running visualisation
    BLOCKFIGURE   - Initialize figure for redrawing
    BLOCKPLOT     - Append coefficients to the running plot

  Helper functions
    BLOCK_FWT      - FWT processing
    BLOCK_IFWT     - IFWT processing

  For help, bug reports, suggestions etc. please send email to
  ltfat-help@lists.sourceforge.net

   Url: http://ltfat.sourceforge.net/doc/blockproc/Contents.php



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
 LTFAT - Block processing



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
block


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3206
 -- Function: block
     BLOCK  Initialize block stream
        Usage: block(source);

        Input parameters:
           source    : Block stream input.
           fs        : Sampling rate.
        Output parameters:
           fs        : Sampling rate.
           classid   : Data type.

        BLOCK(source) initializes block data stream from source which
        can be one of the following (the letter-case is ignored for strings):

           'file.wav'      name of a wav file

           'dialog'        shows the file dialog to choose a wav file.

           'rec'           input is taken from a microphone/auxilary input

           'playrec'       loopbacks the input to the output

           data            input data as columns of a matrix for each input
                             channel

        BLOCK accepts the following optional flags and key-value pairs

           'L',L                Block length - default is 1024. Specifying L
                                  fixes the buffer length, which cannot be
                                  changed in the loop.

           'devid',dev          Whenever more input/output devices are present
                                  in your system, 'devid' can be used to
                                  specify one. For the 'playrec' option the
                                  devId should be a two element vector
                                  [playDevid, recDevid]. List of the installed
                                  devices and their IDs can be obtained by
                                  BLOCKDEVICES.

           'playch',playch      If device supports more output channels, 'playch'
                                  can be used to specify which should be used. E.g.
                                  for two channel device, [1,2] is used to specify
                                  both channels.

           'recch',recch        If device supports more input channels, 'recch'
                                  can be used to specify which should be used.

           'outfile','file.wav' Processed sound data is stored in a new wav
                                  file. NOT IMPLEMENTED YET!

           'nbuf',nbuf          Max number of buffers to be preloaded. Helps
                                  avoiding glitches, but increases delay.


           'loadind',loadind    How to show the load indicator. loadind can
                                  be the following

                                   'nobar'   Suppresses any load display.

                                   'bar'     Displays ascii load bar in command
                                             line (Does not work in Octave).

                                   obj       Java object which have a public
                                             method updateBar(double).

        Optional flag groups

           'noloop', 'loop'     Plays the input in a loop.

           'single', 'double'   Data type to be used.

           'online', 'offline'  Allows offline processing for data or wav
                                inputs. NOT IMPELMENTED YET!


     *Url*: <http://ltfat.sourceforge.net/doc/blockproc/block.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
BLOCK  Initialize block stream
   Usage: block(source);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
block_fwt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 751
 -- Function: block_fwt
     BLOCK_FWT FWT func. wrapper for a block processing
        Usage: c = block_fwt( f, h, J);

        Input parameters:
              f     : Input data.
              h     : Analysis Wavelet Filterbank.
              J     : Number of filterbank iterations.

        Output parameters:
              c      : Coefficient vector.

        c = BLOCK_FWT(f,h,J) acceppts suitably extended block of data f*
        and produces correct coefficients. f is expected to be a collumn vector
        or a matrix and the processing is done column-wise.

        Function should be independent of block_interface.


     *Url*: <http://ltfat.sourceforge.net/doc/blockproc/block_fwt.php>

     See also: block, blockread, blockplay.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
BLOCK_FWT FWT func.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
block_ifwt


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 227
 -- Function: block_ifwt
     BLOCK_IFWT IFWT wrapper for blockstream processing
        Usage: f=block_ifwt(c,g,J,Lb);

        f = BLOCK_IFWT(c,g,J,Lb)
     *Url*: <http://ltfat.sourceforge.net/doc/blockproc/block_ifwt.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
BLOCK_IFWT IFWT wrapper for blockstream processing
   Usage: f=block_ifwt(c,g,J,



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
blockana


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1172
 -- Function: blockana
     BLOCKANA Blockwise analysis interface
        Usage: c=blockana(F, f)

        Input parameters:
           Fa   : Analysis frame object.
           f    : Block of signal.
           fola : Explicitly defined overlap
        Output parameters:
           c    : Block coefficients.
           fola : Stored overlap

        c=BLOCKANA(Fa,f) calculates the coefficients c of the signal block f using
        the frame defined by F. The block overlaps are handled according to the
        F.blokalg. Assuming BLOCKANA is called in the loop only once, fola*
        can be omitted and the overlaps are handled in the background
        automatically.


        References:
          N. Holighaus, M. Doerfler, G. A. Velasco, and T. Grill. A framework for
          invertible, real-time constant-Q transforms. IEEE Transactions on
          Audio, Speech and Language Processing, 21(4):775 -785, 2013.

          Z. Průša. Segmentwise Discrete Wavelet Transform. PhD thesis, Brno
          University of Technology, Brno, 2012.

     *Url*: <http://ltfat.sourceforge.net/doc/blockproc/blockana.php>

     See also: block, blocksyn, blockplay.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
BLOCKANA Blockwise analysis interface
   Usage: c=blockana(F, f)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
blockdevices


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 378
 -- Function: blockdevices
     BLOCKDEVICES Lists audio devices
        Usage: devs = blockdevices();

        BLOCKDEVICES lists the available audio input and output devices. The
        ID can be used in the BLOCK function to specify which device should
        be used.

     *Url*:
     <http://ltfat.sourceforge.net/doc/blockproc/blockdevices.php>

     See also: block.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
BLOCKDEVICES Lists audio devices
   Usage: devs = blockdevices();



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
blockdone


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 494
 -- Function: blockdone
     BLOCKDONE  Destroy the current blockstream
        Usage: blockdone();

        BLOCKDONE() closes the current blockstream. The function resets
        the playrec tool and clear all buffers in block_interface.

        BLOCKDONE(p1,p2,...) in addition tries to call close methods on
        all input arguments which are JAVA objects (which are passed by reference).


     *Url*: <http://ltfat.sourceforge.net/doc/blockproc/blockdone.php>

     See also: block.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
BLOCKDONE  Destroy the current blockstream
   Usage: blockdone();



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
blockfigure


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 907
 -- Function: blockfigure
     BLOCKFIGURE Block figure object
        Usage: p=blockfigure();
               p=blockfigure('cm',cmaps);

        Output parameters:
              p     : JAVA object of the class net.sourceforge.ltfat.SpectFrame

        p=BLOCKFIGURE() initializes a JAVA object for the BLOCKPLOT
        routine.

        Optional key-value pairs:

           'cm',cmaps   : Custom colormap (a L x3 matrix) or colormaps
                            (cell array of matrixes).

        The function takes in the additional optional arguments:

            'location',location:   Window inital position. location
                                     has to be 2 element row vector [x,y]
                                     defining distance from the top-left
                                     corner of the screen.
     *Url*: <http://ltfat.sourceforge.net/doc/blockproc/blockfigure.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
BLOCKFIGURE Block figure object
   Usage: p=blockfigure();
          p=blockfigu



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
blockframeaccel


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1009
 -- Function: blockframeaccel
     BLOCKFRAMEACCEL Precompute structures for block processing
        Usage: F = blockframeaccel(F,Lb);

        F=BLOCKFRAMEACCEL(F,Lb) has to be called for each frame object prior to
        entering the main loop where BLOCKANA and BLOCKSYN are called.
        The function works entirely like FRAMEACCEL but in addition, it prepares
        structures for the processing of a consecutive stream of blocks.

           'sliwin',sliwin   : Slicing window. sliwin have to be a window
                                 of length 2Lb or a string accepted
                                 by the FIRWIN function. It is used only in
                                 the slicing window approach. The default is
                                 'hann'.

           'zpad',zpad   : Number of zero samples the block will be padded
                             after it is windowed by a slicing window.
     *Url*:
     <http://ltfat.sourceforge.net/doc/blockproc/blockframeaccel.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
BLOCKFRAMEACCEL Precompute structures for block processing
   Usage: F = blockfr



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
blockframepairaccel


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1417
 -- Function: blockframepairaccel
     BLOCKFRAMEPAIRACCEL Precompute structures for block processing
        Usage: F = blockframepairaccel(Fa,Fs,Lb);

        [Fao,Fso]=BLOCKFRAMEPAIRACCEL(Fa,Fs,Lb) works similar to
        BLOCKFRAMEACCEL with a pair of frames. The only difference from
        calling BLOCKFRAMEACCEL separatelly for each frame is correct
        default choice of the slicing windows. Frame objects Fa,Fs will be
        accelerated for length 2*Lb.

        The following optional arguments are recognized:

           'anasliwin',anasliwin  : Analysis slicing window. sliwin have to
                                      be a window of length 2Lb or a string
                                      accepted by the FIRWIN function. It is
                                      used only in the slicing window approach.
                                      The default is 'hann'.

           'synsliwin',synsliwin  : Synthesis slicing window. The same as the
                                      previous one holds. The default is 'rect'.

           'zpad',zpad   : Number of zero samples the block will be padded
                             after it is windowed by a slicing window. Note the
                             frames will be accelerated for length
                             2*Lb+2*kv.zpad.

     *Url*:
     <http://ltfat.sourceforge.net/doc/blockproc/blockframepairaccel.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
BLOCKFRAMEPAIRACCEL Precompute structures for block processing
   Usage: F = blo



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
blockpanel


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1040
 -- Function: blockpanel
     BLOCKPANEL Control panel
        Usage: blockpanel(params)

        Input parameters:
           params: Cell-array of parameters specifications.

        Output parameters:
           p : Control panel Java object

        BLOCKPANEL(params) creates a Java object containing GUI for changing
        parameters during the playback. params should be a cell-array, whose
        elements are another cell array of the following format:

           {'var','label',minVal,maxVal,defVal,valCount}

        Example:

        params = {
                    {'G','Gain',-20,20,0,21}
                 }

        The function takes in the additional optional arguments:

            'location',location:   Window initial position. location
                                     has to be 2 element row vector [x,y]
                                     defining distance from the top-left
                                     corner of the screen.
     *Url*: <http://ltfat.sourceforge.net/doc/blockproc/blockpanel.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
BLOCKPANEL Control panel
   Usage: blockpanel(params)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
blockpanelget


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 942
 -- Function: blockpanelget
     BLOCKPANELGET Get parameters from GUI
        Usage: [par,...] = blockpanelget(p,spar,...)

        Input parameters:
              p    : JAVA object
              spar : String. Name of the parameter.

        Output parameters:
              par  : Single value or vector of parameters.

        par = BLOCKPANELGET(p,'spar') gets a current value of the parameter
        'spar' from the GUI specified in p.
        par = BLOCKPANELGET(p,'spar1','spar2','spar3') gets current values
        of the parameters 'spar1', 'spar2' and 'spar3' from the GUI and
        stores them in a vector p.
        [par1,par2,par3] = BLOCKPANELGET(p,'spar1','spar2','spar3') gets
        current values of the parameters 'spar1', 'spar2' and 'spar3'
        from the GUI and stores them in the separate variables par1,par2
        and par3.

     *Url*:
     <http://ltfat.sourceforge.net/doc/blockproc/blockpanelget.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
BLOCKPANELGET Get parameters from GUI
   Usage: [par,...] = blockpanelget(p,spar



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
blockplay


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 436
 -- Function: blockplay
     BLOCKPLAY Schedules block to be played
        Usage: blockplay(L)

        Input parameters:
           f    : Samples.

        Function schedules samples in f to be played. Since playrec handles
        playing and recording in a single command, the actual relay of samples
        to playrec is done in the next call of BLOCKREAD.
     *Url*: <http://ltfat.sourceforge.net/doc/blockproc/blockplay.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
BLOCKPLAY Schedules block to be played
   Usage: blockplay(L)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
blockplot


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1229
 -- Function: blockplot
     BLOCKPLOT Plot block coefficients
        Usage: blockplot(p,F,c);

        Input parameters:
              p     : JAVA object of the class net.sourceforge.ltfat.SpectFrame.
              F     : Frame object.
              c     : Block coefficients.
              cola  : (Optional) overlap from previous block.

        Output parameters:
              cola  : Overlap to the next block.

        BLOCKPLOT(p,F,c) appends the block coefficients c to the running
        coefficient plot in p. The coefficients must have been obtained by
        c=blockana(F,...). The format of c is changed to a rectangular
        layout according to the type of F.

        BLOCKPLOT(p,[],c) does the same, but expects c to be already
        formatted matrix of real numbers. The matrix dimensions are not
        restricted, but it will be shrinked or expanded to a vertical
        strip in the sliding image.

        cola=BLOCKPLOT(p,F,c,cola) does the same, but adds cola to the
        first respective coefficients in c and returns last coefficients from
        c. This is only relevant for the sliced window blocking approach.

     *Url*: <http://ltfat.sourceforge.net/doc/blockproc/blockplot.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
BLOCKPLOT Plot block coefficients
   Usage: blockplot(p,F,c);



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
blockprocinit


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 169
 -- Function: blockprocinit
      Add entry to the dynamic classpath if JVM is present.
     *Url*:
     <http://ltfat.sourceforge.net/doc/blockproc/blockprocinit.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
 Add entry to the dynamic classpath if JVM is present.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
blockread


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 549
 -- Function: blockread
     BLOCKREAD Read one block from input
        Usage: blockread(L)

        Input parameters:
           L    : Number of samples.
        Output parameters:
           f     : Samples.
           valid : Input data valid flag.

        Function also control the playback, so it does not have to rely on
        whether the user called BLOCKPLAY.

        Block streaming uses several buffers to compensate for the processing
        delay variation.
     *Url*: <http://ltfat.sourceforge.net/doc/blockproc/blockread.php>




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
BLOCKREAD Read one block from input
   Usage: blockread(L)



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
blocksyn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1554
 -- Function: blocksyn
     BLOCKSYN Blockwise synthesis interface
        Usage: blocksyn(F, c, Lb)

        Input parameters:
           F    : Synthesis frame object.
           c    : Coefficients of a block.
           Lb   : Length of the block.
           fola : Explicitly defined overlap.
        Output parameters:
           fhat : Reconstructed block of signal.
           fola : Stored overlap.

        fhat=BLOCKSYN(F,c,Lb) reconstructs the signal block fhat from the
        coefficients c using the frame defined by F. If some overlap is used,
        it is stored internally using BLOCK_INTERFACE. Nothe that the function is
        capable of handling overlaps internally only for a single call
        to the function in the blockproc. loop.%

        [fhat,fola]=BLOCKSYN(F,c,Lb,fola) does the same, but the block algorithm
        uses fola to read and store overlap explicitly. fola can be empty.

        *Note:* To get perfect reconstruction, the synthesis frame F must
        be a dual frame of the analysis frame used in BLOCKANA.


        References:
          N. Holighaus, M. Doerfler, G. A. Velasco, and T. Grill. A framework for
          invertible, real-time constant-Q transforms. IEEE Transactions on
          Audio, Speech and Language Processing, 21(4):775 -785, 2013.

          Z. Průša. Segmentwise Discrete Wavelet Transform. PhD thesis, Brno
          University of Technology, Brno, 2012.

     *Url*: <http://ltfat.sourceforge.net/doc/blockproc/blocksyn.php>

     See also: block, blockana, framedual.




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
BLOCKSYN Blockwise synthesis interface
   Usage: blocksyn(F, c, Lb)





