aud_daf_parser.c

最新MTK手机软件源码

/*****************************************************************************
*  Copyright Statement:
*  --------------------
*  This software is protected by Copyright and the information contained
*  herein is confidential. The software may not be copied and the information
*  contained herein may not be used or disclosed except with the written
*  permission of MediaTek Inc. (C) 2005
*
*  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
*  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
*  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
*  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
*  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
*  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
*  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
*  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
*  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
*  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
*  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
*  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
*
*  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
*  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
*  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
*  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
*  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE. 
*
*  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
*  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
*  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
*  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
*  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
*
*****************************************************************************/

/*******************************************************************************
* Filename:
* ---------
*  daf_parser.c
*
* Project:
* --------
*   MAUI
*
* Description:
* ------------
*   daf parsing process
*
* Author:
* -------
*  Tim Chen
*
*==============================================================================
*           HISTORY
* Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!! 
 *------------------------------------------------------------------------------
 * $Log$
 *
 * removed!
 * removed!
 * 
 *
 * removed!
 * removed!
 * 
 *
 * removed!
 * removed!
 * 
 *
 * removed!
 * removed!
 * 
 *
 * removed!
 * removed!
 * 
 *
 * removed!
 * removed!
 * 
 *
 * removed!
 * removed!
 * 
 *
 * removed!
 * removed!
 * 
 *
 * removed!
 * removed!
 * 
 *
 *------------------------------------------------------------------------------
* Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!! 
*==============================================================================
*******************************************************************************/
#ifndef MED_NOT_PRESENT

#include "med_global.h"

#ifdef __RICH_AUDIO_PROFILE__

#include "aud_daf_parser.h"
#include "drm_gprot.h"
#include "med_main.h"

/* import from other files */
#include "l1audio.h"
#include "FSAL.h"

extern id3_tag_struct id3_tag;                              /* from aud_id3_parser.c */
extern kal_int16 med_get_media_type(kal_wchar *file_name);  /* from med_utility.c */

#define MED_PARSE_DAF   /* currently used by mmadaf.c */

#ifdef MED_PARSE_DAF
/* DAF_VERSION_1 */
kal_uint16 const DAF_V1_BITRATE_TAB[3][15] = 
{
    {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448},     /* Layer I */
    {0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384},        /* Layer II */
    {0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320}, /* Layer III */
};

/* DAF_VERSION_2, DAF_VERSION_2_5 */
kal_uint16 const DAF_V2_BITRATE_TAB[2][15] = 
{
    {0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256},        /* Layer I */
    {0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160}      /* Layer II & III */
};

kal_uint16 const DAF_SAMPLERATE_TAB[3] = {44100, 48000, 32000};


/*****************************************************************************
 * FUNCTION
 *  daf_parse_frame_header
 * DESCRIPTION
 *  this function will try to parse frame header from current input stream position to
 *  the range of DAF_FRAME_CHECK_SIZE so even if the target is not a valid daf file,
 *  the processing time is bounded.
 *  
 *  syncword             11 bits
 *  version              2 bits
 *  layer                2 bits
 *  protection(CRC) bit     1 bit
 *  bitrate index           4 bits
 *  sampling frequency index   2 bits
 *  padding bit          1 bit
 *  private bit          1 bit
 *  channel mode            2 bits
 *  mode extension       2 bits
 *  copyright               1 bit
 *  original/home           1 bit
 *  emphasis             2 bits
 * PARAMETERS
 *  data        [?]     
 *  header      [?]     
 * RETURNS
 *  kal_int32
 *****************************************************************************/
kal_bool daf_parse_frame_header(kal_uint8 *data, daf_header_struct *header)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    kal_uint8 rate_index, version, layer;
    kal_uint8 slot_bytes;
    kal_uint32 frame_slots;
    kal_uint32 temp;
    kal_uint32 bitcount = 0;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    /* check syncword */
    temp = (kal_uint32) aud_get_bits(data, &bitcount, 8) << 3;
    temp |= (kal_uint32) aud_get_bits(data, &bitcount, 3);
    if (temp != 0x7FF)  /* 111 1111 1111 */
    {
        return KAL_FALSE;
    }

    /* version */
    version = 3 - aud_get_bits(data, &bitcount, 2);
    if (version == DAF_VERSION_NONE)
    {
        return KAL_FALSE;
    }
    header->version = version;

    /* layer */
    layer = 3 - aud_get_bits(data, &bitcount, 2);
    if (layer == DAF_LAYER_NONE)
    {
        return KAL_FALSE;
    }
    header->layer = layer;

    /* protection(CRC) bit */
    aud_get_bits(data, &bitcount, 1);

    /* bitrate index */
    rate_index = aud_get_bits(data, &bitcount, 4);
    if (rate_index == 15)   /* bad */
    {
        return KAL_FALSE;
    }
    switch (version)
    {
        case DAF_VERSION_1:
            header->bitrate = DAF_V1_BITRATE_TAB[layer][rate_index];    /* kbps */
            break;
        case DAF_VERSION_2:
        case DAF_VERSION_2_5:
            header->bitrate = DAF_V2_BITRATE_TAB[(layer + 1) >> 1][rate_index]; /* kbps */
            break;
    }
    header->bitrate *= 1000;    /* bps */

    /* sampling frequency index */
    rate_index = aud_get_bits(data, &bitcount, 2);
    if (rate_index == 3)    /* reserved */
    {
        return KAL_FALSE;
    }
    header->sample_rate = DAF_SAMPLERATE_TAB[rate_index];
    switch (version)
    {
        case DAF_VERSION_2:
            header->sample_rate >>= 1;
            break;
        case DAF_VERSION_2_5:
            header->sample_rate >>= 2;
            break;
    }

    /* padding bit */
    header->padding = aud_get_bits(data, &bitcount, 1);

    /* private bit */
    aud_get_bits(data, &bitcount, 1);

    /* channel mode */
    header->channel_num = (aud_get_bits(data, &bitcount, 2) == 3) ? 1 : 2;

    /* mode extension */
    aud_get_bits(data, &bitcount, 2);

    /* copyright */
    aud_get_bits(data, &bitcount, 1);

    /* original/home */
    aud_get_bits(data, &bitcount, 1);

    /* emphasis */
    if (aud_get_bits(data, &bitcount, 2) == 2)  /* reserved */
    {
        return KAL_FALSE;
    }

    /* calculate frame length */
    if (header->bitrate != 0)
    {
        slot_bytes = 1;
        if (layer == DAF_LAYER_I)
        {
            frame_slots = 12;
            slot_bytes = 4;
        }
        else if ((layer == DAF_LAYER_III) && (version == DAF_VERSION_2 || version == DAF_VERSION_2_5))
        {
            frame_slots = 72;
        }
        else
        {
            frame_slots = 144;
        }

        header->min_frame_size = (frame_slots * header->bitrate / header->sample_rate) * slot_bytes;
        header->max_frame_size = header->min_frame_size + slot_bytes;
    }
    return KAL_TRUE;
}


/*****************************************************************************
 * FUNCTION
 *  daf_find_next_frame
 * DESCRIPTION
 *  
 * PARAMETERS
 *  input_stream        [?]         
 *  header              [?]         
 *  move_offset         [IN]        
 * RETURNS
 *  kal_bool
 *****************************************************************************/
kal_bool daf_find_next_frame(
            audio_input_stream_struct *input_stream,
            daf_header_struct *header,
            kal_uint32 move_offset)
{
    /*----------------------------------------------------------------*/
    /* Local Variables                                                */
    /*----------------------------------------------------------------*/
    daf_header_struct free_bitrate_header;
    kal_uint32 round, read_size;
    kal_uint32 sample_rate, bitrate, frame_slots, channel_num;
    kal_uint8 layer, version, slot_bytes;
    kal_uint8 *ptr, *end;
    kal_uint8 result = DAF_FIND_FRAME_FALSE;

    /*----------------------------------------------------------------*/
    /* Code Body                                                      */
    /*----------------------------------------------------------------*/
    for (round = 0; result != DAF_FIND_FRAME_TRUE; round++)
    {
        /* check if it is out of searching range */
        if (input_stream->total_load > input_stream->skip + DAF_FRAME_CHECK_SIZE)
        {
            return KAL_FALSE;
        }

        /* refill data */
        audio_input_stream_read(input_stream, 0);
        read_size = input_stream->tail - input_stream->ptr;
        if (round == 0)
        {
            if (read_size < 4 + move_offset)    /* we need at least 4 + move_offset bytes to check frame header */
            {
                return KAL_FALSE;   /* eof */
            }
            input_stream->ptr += move_offset;
        }
        else if (read_size < 4) /* we need at least 4 bytes to check frame header */
        {
            return KAL_FALSE;   /* eof */
        }

        if (result == DAF_FIND_FRAME_FREE_BITRATE)
        {
            /* search next frame for calculating free bitrate */
            bitrate = 0;
            version = header->version;
            layer = header->layer;
            sample_rate = header->sample_rate;
            channel_num = header->channel_num;
            for (ptr = input_stream->ptr + 4, end = input_stream->tail - 4; ptr <= end; ptr++)
            {
                /* check if ptr reference to a valid frame header */
                if (daf_parse_frame_header(ptr, &free_bitrate_header))
                {
                    if (version == free_bitrate_header.version &&
                        layer == free_bitrate_header.layer &&
                        sample_rate == free_bitrate_header.sample_rate &&
                        bitrate == free_bitrate_header.bitrate && channel_num == free_bitrate_header.channel_num)
                    {
                        slot_bytes = 1;
                        if (layer == DAF_LAYER_I)
                        {
                            frame_slots = 12;
                            slot_bytes = 4;
                        }