NAME

       wav2gig - Create GigaStudio (.gig) file from a set of WAV files.

SYNOPSIS

       wav2gig [ OPTIONS ] GIG_FILE WAV_FILE_OR_DIR_1 [ WAV_FILE_OR_DIR_2 ... ]

DESCRIPTION

       Takes  a  list of wave (.wav) files and / or directories containing wave files as argument(s) and creates
       one new GigaStudio / GigaSampler (.gig) file for those samples.

       The created GigaStudio (.gig) file will contain the given input samples. The  samples'  meta  information
       (as  far  as  available)  like root note (a.k.a 'unity note'), fine tune, loop points, loop type and loop
       play count are automatically extracted from the input wave (.wav) files and applied accordingly.

       Additionally this tool creates exactly one instrument inside the newly created GigaStudio (.gig) file and
       tries to automatically map the samples in a meaningful way to that instrument. As the wave (.wav)  format
       currently  does  not  support  many  of the meta information required for this particular task, this tool
       tries to extract the required (missing) information from the individual sample's file name for being able
       to map the samples accordingly. See SAMPLE NAMES below for details on the assumed naming scheme for input
       sample files and how to override that default  naming  scheme  by  providing  custom  regular  expression
       patterns.

OPTIONS

        GIG_FILE
              GigaStudio / GigaSampler (.gig) filename to be created

        WAV_FILE_OR_DIR_1
              Filename or directory containing wave (.wav) file(s)

        WAV_FILE_OR_DIR_2
              Filename or directory containing wave (.wav) file(s)

        -r    Recurse through all subdirectories of provided input WAV directories.

        -f    Overwrite output GigaStudio (.gig) file in case it already exists.

        -v    Print version and exit.

        --dry-run
              Scan input sample (.wav) files, but exit before creating any .gig file.

        --verbose
              Increase amount of info being shown.

        --regex-name1 PATTERN
              Regular expression for overriding the NAME1 part of the input sample file name scheme.

              Defaults to '([^-\]+) - [^-]+ - [^-]+ - [^-]+ - [^.]+'.

        --regex-name2 PATTERN
              Regular expression for overriding the NAME2 part of the input sample file name scheme.

              Defaults to '[^-\]+ - ([^-]+) - [^-]+ - [^-]+ - [^.]+'.

        --regex-velocity-nr PATTERN
              Regular expression for overriding the VELOCITY_NR part of the input sample file name scheme.

              Defaults to '[^-\]+ - [^-]+ - ([^-]+) - [^-]+ - [^.]+'.

        --regex-note-nr PATTERN
              Regular expression for overriding the NOTE_NR part of the input sample file name scheme.

              Defaults to '[^-\]+ - [^-]+ - [^-]+ - ([^-]+) - [^.]+'.

        --regex-note-name PATTERN
              Regular expression for overriding the NOTE_NAME part of the input sample file name scheme.

              Defaults to '[^-\]+ - [^-]+ - [^-]+ - [^-]+ - ([^.]+)'.

SAMPLE NAMES

       By  default  this  tool  assumes  the following input sample file naming scheme for automatically mapping
       samples to regions on the keyboard, as well as mapping them to velocity splits adequately:

       'NAME1 - NAME2 - VELOCITY_NR - NOTE_NR - NOTE_NAME.wav'

       Which are interpreted in the following way:

        NAME1 Primary name of the sample (e.g. "Violin").

              This is not interpreted for sample mapping, but it will be used to assemble the final sample  name
              inside the GigaStudio (.gig) file.

              You may use --regex-name1 to override this part of the naming scheme.

        NAME2 Secondary name of the sample (e.g. "Cresc").

              This is currently ignored, but might be used in future.

              You may use --regex-name2 to override this part of the naming scheme.

        VELOCITY_NR
              MIDI Velocity number of the sample (e.g. "18").

              This informtion will be used to automatically create velocity splits.

              You may use --regex-velocity-nr to override this part of the naming scheme.

        NOTE_NR
              MIDI Note number of the sample (e.g. "021" for note a-1).

              This  informtion  will  be  used  to automatically map the sample to a region on the keyboard. The
              sample's root note (a.k.a. "unity note") is taken directly from the .wav file content, however  if
              the  .wav file content does not contain a root note information then  NOTE_NR is used as root note
              as well.

              You may use --regex-note-nr to override this part of the naming scheme.

        NOTE_NAME
              Note name of the sample (e.g. "a-1").

              This is not interpreted for sample mapping, but it will be used to assemble the final sample  name
              inside the GigaStudio (.gig) file.

              You may use --regex-note-name to override this part of the naming scheme.

       This  tool  utilizes  the regular expressions library provided by C++ (introduced with the C++11 standard
       revision).  Each custom regular expression (abbreviated as 'RegEx' from now on below) passed  to  one  of
       the  --regex-*  options must contain exactly one active RegEx 'capture group' which is denoted in regular
       expressions by a pair of round brackets like:

       (PATTERN)

       So the 'capture group' marks the portion in the overall filename string that is going  to  be  exctracted
       for  the  respective  component of the filename schema.  If additional RegEx group(s) are needed to build
       the overall RegEx pattern, then those other group(s) must be defined as 'passive groups' denoted in RegEx
       patterns by an additional question mark and colon like this:

       (?:PATTERN)

       Keep in mind that RegEx scanners behave 'greedy' by default, which means by default they try to match the
       longest string possible according to your defined RegEx pattern. If  that's  not  desired  then  you  may
       either  override  the  required  parts of your RegEx pattern to behave 'non-greedy' such that those parts
       would match for the  shortest  string  possible  instead,  or  alternatively  consider  using  the  RegEx
       'alternation' operator, which is denoted in regular expressions by a vertical bar character like:

       PATTERN1|PATTERN2|PATTERN3

       The  RegEx  'alternation'  operator  is  sometimes more intuitive, because it tries to match the provided
       patterns strictly in order from left to right. So it would first try to match the first pattern, and only
       if no match with the first pattern was possible (independent of string length) it would then try to match
       the second pattern, and so on.

SEE ALSO

       gig2mono(1), gigextract(1), gigdump(1), gigmerge(1) korg2gig(1)

BUGS

       Check and report bugs at http://bugs.linuxsampler.org

Author

       Application and manual page written by Christian Schoenebeck <cuse@users.sf.net>

libgig 4.4.1                                       03 Sep 2021                                        wav2gig(1)