parrocchetto/firmware.X/src/G726APack.c

/**************************************************************************
*  
*             ITU-T SOFTWARE TOOLS' GENERAL PUBLIC LICENSE                  
*
*  This "General Public License" is published in the Annex 1 of the
*  ITU-T Recommendation on "SOFTWARE TOOLS FOR HOMOGENITY OF RESULTS
*  IN THE STANDARDIZATION PROCESS OF SPEECH AND AUDIO CODERS",
*  approved in Geneva, 2000.
*
*  TERMS AND CONDITIONS
*
*  1. This License Agreement applies to any module or other work
*  related to the ITU-T Software Tool Library, and developed by the
*  User's Group on Software Tools. The "Module", below, refers to any
*  such module or work, and a "work based on the Module" means either
*  the Module or any work containing the Module or a portion of it,
*  either verbatim or with modifications.  Each licensee is addressed
*  as "you".
*
*  2. You may copy and distribute verbatim copies of the Module's
*  source code as you receive it, in any medium, provided that you:
*  -  conspicuously and appropriately publish on each copy an appropriate
*     copyright notice and disclaimer of warranty;
*  -  keep intact all the notices that refer to this General Public
*     License and to the absence of any warranty; and
*  -  give any other recipients of the Module a copy of this General
*     Public License along with the Module.
*  You may charge a fee for the physical act of transferring a copy.
*
*  3. You may modify your copy or copies of the Module or any portion
*  of it, and copy and distribute such modifications under the terms
*  of Paragraph 1 above, provided that you also do the following:
*
*      o  cause the modified files to carry prominent notices stating
*      that you changed the files and the date of any change; and
*
*      o  cause the whole of any work that you distribute or publish,
*      that in whole or in part contains the Module or any part
*      thereof, either with or without modifications, to be licensed
*      at no charge to all third parties under the terms of this
*      General Public License (except that you may choose to grant
*      warranty protection to some or all third parties, at your
*      option).
*
*      o  If the modified module normally reads commands interactively
*      when run, you must cause it, when started running for such
*      interactive use in the simplest and most usual way, to print or
*      display an announcement including an appropriate copyright
*      notice and a notice that there is no warranty (or else, saying
*      that you provide a warranty) and that users may redistribute
*      the module under these conditions, and telling the user how to
*      view a copy of this General Public License.
*
*  You may charge a fee for the physical act of transferring a copy,
*  and you may at your option offer warranty protection in exchange
*  for a fee.
*
*  Mere aggregation of another independent work with the Module (or
*  its derivative) on a volume of a storage or distribution medium
*  does not bring the other work under the scope of these terms.
*
*  4.  You may copy and distribute the Module (or a portion or
*  derivative of it, under Paragraph 2) in object code or executable
*  form under the terms of Paragraphs 1 and 2 above provided that you
*  also do one of the following:
*
*      o  accompany it with the complete corresponding machine-
*      readable source code, which must be distributed under the terms
*      of Paragraphs 1 and 2 above; or,
*
*      o  accompany it with a written offer, valid for at least three
*      years, to give any third party free (except for a nominal
*      charge for the cost of distribution) a complete machine-
*      readable copy of the corresponding source code, to be
*      distributed under the terms of Paragraphs 1 and 2 above; or,
*
*      o  accompany it with the information you received as to where
*      the corresponding source code may be obtained.  (This
*      alternative is allowed only for noncommercial distribution and
*      only if you received the module in object code or executable
*      form alone.) 
*
*  Source code for a work means the preferred form of the work for
*  making modifications to it.  For an executable file, complete
*  source code means all the source code for all modules it contains;
*  but, as a special exception, it need not include source code for
*  modules which are standard libraries that accompany the operating
*  system on which the executable file runs, or for standard header
*  files or definitions files that accompany that operating system.
*
*  5.  You may not copy, modify, sublicense, distribute or transfer
*  the Module except as expressly provided under this General Public
*  License. Any attempt otherwise to copy, modify, sublicense,
*  distribute or transfer the Module is void, and will automatically
*  terminate your rights to use the Module under this License. 
*  However, parties who have received copies, or rights to use copies,
*  from you under this General Public License will not have their
*  licenses terminated so long as such parties remain in full
*  compliance.
*
*  6.  By copying, distributing or modifying the Module (or any work
*  based on the Module) you indicate your acceptance of this license
*  to do so, and all its terms and conditions.
*
*  7.  Each time you redistribute the Module (or any work based on the
*  Module), the recipient automatically receives a license from the
*  original licensor to copy, distribute or modify the Module subject
*  to these terms and conditions.  You may not impose any further
*  restrictions on the recipients' exercise of the rights granted
*  herein.
*
*  8.  The ITU-T may publish revised and/or new versions of this
*  General Public License from time to time.  Such new versions will
*  be similar in spirit to the present version, but may differ in
*  detail to address new problems or concerns.
*
*  Each version is given a distinguishing version number. If the
*  Module specifies a version number of the license which applies to
*  it and "any later version", you have the option of following the
*  terms and conditions either of that version or of any later version
*  published by the ITU-T. If the Module does not specify a version
*  number of the license, you may choose any version ever published by
*  the ITU-T.
*
*  9.  If you wish to incorporate parts of the Module into other free
*  modules whose distribution conditions are different, write to the
*  author to ask for permission.  For software which is copyrighted by
*  the ITU-T, write to the ITU-T Secretariat; exceptions may be made
*  for this. This decision will be guided by the two goals of
*  preserving the free status of all derivatives of this free software
*  and of promoting the sharing and reuse of software generally.
*
*
*  NO WARRANTY
*
*  10. BECAUSE THE MODULE IS LICENSED FREE OF CHARGE, THERE IS NO
*  WARRANTY FOR THE MODULE, TO THE EXTENT PERMITTED BY APPLICABLE LAW. 
*  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS
*  AND/OR OTHER PARTIES PROVIDE THE MODULE "AS IS" WITHOUT WARRANTY OF
*  ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED
*  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
*  PARTICULAR PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND
*  PERFORMANCE OF THE MODULE IS WITH YOU.  SHOULD THE MODULE PROVE
*  DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR
*  OR CORRECTION.
*
*  11. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
*  WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY
*  MODIFY AND/OR REDISTRIBUTE THE MODULE AS PERMITTED ABOVE, BE LIABLE
*  TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
*  CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
*  THE MODULE (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
*  RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR
*  A FAILURE OF THE MODULE TO OPERATE WITH ANY OTHER MODULES), EVEN IF
*  SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
*  SUCH DAMAGES.
*
*  END OF TERMS AND CONDITIONS
***************************************************************************/
#include "G726APack.h"

int G726APack(unsigned char * src, void * dest, int nSrcSamples, G726A_BIT_RATES rate)
{
    unsigned int packedWord;
    unsigned int shiftedEncSample;
    int sample;
    int samplesPerPackedWord;
    unsigned int * packedWordDest = (unsigned int *) dest;
    int subFrameIndex;
    int packedSampleIndex;

    if (nSrcSamples <= 0)
    {
        /* Nothing to do. */
        return(0);
    }

    switch(rate)
    {
        case G726A_16KBPS:
            
            /* For 16Kbps, each encoded sample is 2 bits. So
             * a 16 bit word can pack 8 encoded samples.
             */
            
            samplesPerPackedWord = 8;
            break;

        case G726A_24KBPS:

            /* For 24Kbps, each encoded sample is 3 bits. So
             * a 16 bit word can pack 5 encoded samples.
             */
               
            samplesPerPackedWord = 5;
            break;
    
        case G726A_32KBPS:

            /* For 32Kbps, each encoded sample is 4 bits. So
             * a 16 bit word can pack 4 encoded samples.
             */
               
            samplesPerPackedWord = 4;
            break;
        
        case G726A_40KBPS:

            /* For 40Kbps, each encoded sample is 5 bits. So
             * a 16 bit word can pack 3 encoded samples.
             */
               
            samplesPerPackedWord = 3;
            break;

        default:
            /* Unknown rate */
            return(0);
    }

    /* Perform the packing */

    sample = 0;
    packedWord = 0;
    subFrameIndex = 0;
    packedSampleIndex = 0;

    while (sample < nSrcSamples)
    {
        shiftedEncSample = src[sample];
        shiftedEncSample = shiftedEncSample << (subFrameIndex * rate);
        packedWord = packedWord | shiftedEncSample;
        subFrameIndex ++;
        sample ++;

        if(subFrameIndex == samplesPerPackedWord)
        {
            /* This means that the maximum number of
             * encoded samples were encoded in this
             * 16 bit word. Store the 16 bit sample
             * and get ready for the next word.
             */

            packedWordDest[packedSampleIndex] = packedWord;
            subFrameIndex = 0;
            packedSampleIndex ++;
            packedWord = 0;
        }
    }
    
    /* Check if any samples are left over. This happens if the
     * total encoded samples is not a integral multiple of the
     * number of encoded bits per sample.*/
    
    if(subFrameIndex != 0)
    {
        packedWordDest[packedSampleIndex] = packedWord;
        packedSampleIndex ++;
    }

    /* Return the number of bytes written */
    return(packedSampleIndex * 2);

}  

int G726AUnpack(void * src, unsigned char * dest, int nSrcSamples, G726A_BIT_RATES rate)
{
    int samplesPerPackedWord;
    unsigned int * packedWordArray = (unsigned int *)src;
    unsigned int packedWord;
    unsigned char unpacked;
    int subFrameIndex;
    int sample;
    int packedWordIndex;
    int mask;

    switch(rate)
    {
        case G726A_16KBPS:
            
            /* For 16Kbps, each encoded sample is 2 bits. So
             * a 16 bit word can pack 8 encoded samples.
             */
            
            samplesPerPackedWord = 8;
            mask = 0x3;
            break;

        case G726A_24KBPS:

            /* For 24Kbps, each encoded sample is 3 bits. So
             * a 16 bit word can pack 5 encoded samples.
             */
               
            samplesPerPackedWord = 5;
            mask = 0x7;
            break;
    
        case G726A_32KBPS:

            /* For 32Kbps, each encoded sample is 4 bits. So
             * a 16 bit word can pack 4 encoded samples.
             */
               
            samplesPerPackedWord = 4;
            mask = 0xF;
            break;
        
        case G726A_40KBPS:

            /* For 40Kbps, each encoded sample is 5 bits. So
             * a 16 bit word can pack 3 encoded samples.
             */
               
            samplesPerPackedWord = 3;
            mask = 0x1F;
            break;

        default:
            /* Unknown rate */
            return(0);
    }

    packedWordIndex = 0;
    sample = 0;
    packedWord = packedWordArray[packedWordIndex];
    subFrameIndex = 0;
    while(sample < nSrcSamples)
    {
        unpacked = (packedWord >> (subFrameIndex * rate));
        unpacked = unpacked & mask;
        dest[sample] = unpacked;
        sample ++;
        subFrameIndex ++;

        if(subFrameIndex == samplesPerPackedWord)
        {
            subFrameIndex = 0;
            packedWordIndex ++;
            packedWord = packedWordArray[packedWordIndex];
        }
    }
    
    return(sample);
    
}