// common header file shared by both the code and resource compilers

/*

    How this works:

    In uLaw, 14-bits of linear sampling is reduced to 8 bits of logarithmic data.

    It is used on North American and Japanese phone systems, and is coming into use

    for voice data interchange, for PBXs, voicemail, MIME (Internet standard for multimedia mail),

    and Internet Talk Radio. µLaw sounds are almost always encoded at 8000, 8012, or 8012.8210513

    samples/sec. 8000 because it is the specified standard for phones, and 8012.8210513

    (and rounded to 8012) because it is apparently the actual rate used in domestic digital phone switches.

    ---------------------------

    U-LAW and A-LAW definitions

    ---------------------------

    [Adapted from information provided by duggan@cc.gatech.edu (Rick

    Duggan) and davep@zenobia.phys.unsw.EDU.AU (David Perry)]

    u-LAW (really mu-LAW) is

              sgn(m)   (     |m |)       |m |

       y=    ------- ln( 1+ u|--|)       |--| =< 1

             ln(1+u)   (     |mp|)       |mp|

    A-LAW is

         |     A    (m )                 |m |    1

         |  ------- (--)                 |--| =< -

         |  1+ln A  (mp)                 |mp|    A

       y=|

         | sgn(m) (        |m |)    1    |m |

         | ------ ( 1+ ln A|--|)    - =< |--| =< 1

         | 1+ln A (        |mp|)    A    |mp|

    Values of u=100 and 255, A=87.6, mp is the Peak message value, m is the current quantised message value.

    (The formulae get simpler if you substitute x for m/mp and sgn(x) for sgn(m); then -1 <= x <= 1.)

    Converting from u-LAW to A-LAW is in a sense "lossy" since there are quantizing errors introduced in

    the conversion.

    "..the u-LAW used in North America and Japan, and the A-LAW used in Europe and the rest of the world

    and international routes.."

    References:

    Modern Digital and Analog Communication Systems, B.P.Lathi., 2nd ed. ISBN 0-03-027933-X

    Transmission Systems for Communications

    Fifth Edition

    by Members of the Technical Staff at Bell Telephone Laboratories

    Bell Telephone Laboratories, Incorporated

    Copyright 1959, 1964, 1970, 1982

*/

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// resource IDs

#define kSoundDecompressorResID         1000        // ID of decompressor 'thng', code resources, and table

#define kSoundCompressorResID           2000        // ID of compressor 'thng', code resources, and table

#define kSoundCodecNameStringResID      1000        // ID of codec name

#define kSoundCodecInfoStringResID      1001        // ID of codec info string

#define kSoundComponentIconResID        1000        // ID of codec icon

#define kSoundComponentManufacturer     '????'      // your company's OSType

#define kCodecFormat                    kULawCompression

#define kSoundDecompressorVersion       0x00050000  // Use a higher version to overide the default component

#define kSoundCompressorVersion         0x00050000  // Use a higher version to overide the default component

#define k16BitTableResType              'Wtab'      // resource type for a 16 bit array

#define k8BitTableResType               'Btab'      // resource type for a 8 bit array

// resource names will be created for debug versions

#ifdef _DEBUG

#define ULawDecompressorName            "µLaw Decompressor"

#define ULawCompressorName              "µLaw Compressor"

#else

#define ULawDecompressorName            ""

#define ULawCompressorName              ""

#endif

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// code constants

#define kMaxOutputSamples       1024        /* approximate no. samples in output buffer */

#define kULawBlockSamples       1           /* no. samples in a block */

#define kULawBlockBytes         1           /* no. bytes in a block */

#define kULawBytesPerSample     2           /* no. bytes in decompressed sample */

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

// failure handling macros

/*

    Some macros used to check for errors and also to allow for

    handling them by using a goto statement.  This makes the source

    code easier to read.  It will break into the debugger with a

    message showing the condition that caused the failure.  In some

    of the macros the debug message is removed but goto remains.  In

    other macros all of it is removed when doing a non-debug build.

    Note that these macros use the "\p" construct for creating

    Pascal strings at compile time.  Most non-Mac compilers do

    not recognize this, give a warning, and put 'p' as the first

    character of the string.  You can ignore the warning because

    the non-Mac version of DebugStr deals with this just fine.

    For Microsoft's Visual C++, we suppress the warning below.

*/

#if defined(_MSC_VER) && !defined(__MWERKS__) 

    // Visual C++ from Microsoft

    #pragma warning(disable:4129) // unrecognized character escape sequence

#endif

// This checks for the exception, and if true then goto handler

#ifdef _DEBUG

#define FailIf(cond, handler)                               \

    if (cond) {                                             \

        DebugStr((ConstStr255Param)"\p"#cond " goto " #handler);    \

        goto handler;                                       \

    } else 0

#else

#define FailIf(cond, handler)                               \

    if (cond) {                                             \

        goto handler;                                       \

    } else 0

#endif

// This checks for the exception, and if true do the action and goto handler

#ifdef _DEBUG

#define FailWithAction(cond, action, handler)               \

    if (cond) {                                             \

        DebugStr((ConstStr255Param)"\p"#cond " goto " #handler);    \

        { action; }                                         \

        goto handler;                                       \

    } else 0

#else

#define FailWithAction(cond, action, handler)               \

    if (cond) {                                             \

        { action; }                                         \

        goto handler;                                       \

    } else 0

#endif

// This will insert debugging code in the application to check conditions

// and displays the condition in the debugger if true.  This code is

// completely removed in non-debug builds.

#ifdef _DEBUG

#define FailMessage(cond)                                   \

    if (cond)                                               \

        DebugStr((ConstStr255Param)"\p"#cond);              \

    else 0

#else

#define FailMessage(cond)

#endif

// This allows you to test for the result of a condition (i.e. CloseComponent)

// and break if it returns a non zero result, otherwise it ignores the result.

// When a non-debug build is done, the result is ignored.

#ifdef _DEBUG

#define ErrorMessage(cond)                                  \

    if (cond)                                               \

        DebugStr((ConstStr255Param)"\p"#cond);              \

    else 0

#else

#define ErrorMessage(cond)      cond

#endif

// This will display a given message in the debugger, this code is completely

// removed in non-debug builds.

#ifdef _DEBUG

#define DebugMessage(s)         DebugString((ConstStr255Param)s)

#else

#define DebugMessage(s)

#endif