/* ------------------------------------------------------------------ * Copyright (C) 1998-2009 PacketVideo * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either * express or implied. * See the License for the specific language governing permissions * and limitations under the License. * ------------------------------------------------------------------- */ /**************************************************************************************** Portions of this file are derived from the following 3GPP standard: 3GPP TS 26.073 ANSI-C code for the Adaptive Multi-Rate (AMR) speech codec Available from http://www.3gpp.org (C) 2004, 3GPP Organizational Partners (ARIB, ATIS, CCSA, ETSI, TTA, TTC) Permission to distribute, modify and use this file under the standard license terms listed above has been obtained from the copyright holder. ****************************************************************************************/ /* ------------------------------------------------------------------------------ Pathname: ./audio/gsm-amr/c/src/amrdecode.c Date: 05/23/2001 ------------------------------------------------------------------------------ REVISION HISTORY Description: AMRDecode now doesn't call getbits() or put_header_in(). It also now obtains a new bit_offset value from a constant rather than from the returned value of getbits(). Description: AMRDecode now returns byte_offset rather than bit_offset, so the program can access the next frame that is byte aligned rather than packed without padding. Description: The structure types Speech_Decode_FrameState are now passed into amrdecode( ) using void pointers, so that higher level functions don't need to know anything about this structure type. Description: Changed input argument list. Added code to handle incoming DTX frames, and added call to wmf_to_ets function prior to calling GSMFrameDecode. Description: Made the following changes per comments from Phase 2/3 review: 1. Changed all references to bit_offset to byte_offset. Description: Added input_type to the function interface and modified code to check type of conversion that needs to be made. Description: Modified pseudo-code to include IF2 and ETS input formats. Removed byte_offset from input list. Renamed speech_bits to speech_bits_ptr. Description: Added dec_input_format_tab.h in Include section. Modified pseudo-code to use correct table names. Renamed input_type to input_format and speech_bits to speech_bits_ptr. Description: Removed *prev_mode_ptr in the input argument list. Description: Made the following changes per comments from Phase 2/3 review: 1. Removed dec_input_format_tab.h from Include section. 2. Changed type definition of raw_pcm_buffer in the I/O definition section. Description: Renamed WmfBytesPerFrame to WmfDecBytesPerFrame, and If2BytesPerFrame to If2DecBytesPerFrame. Description: Modified code so that the ETS testvectors could be fed directly to this function. Description: Changed '&' to '&&' in the setting of rx_type and mode for AMR_SID < frame_type < NO_DATA case. Description: Added code comments and made some code optimizations per Phase 2/3 review comments. Description: Added conditional compile around the call to GSMFrameDecode to allow amrdecode.c to be used in the ETS reference console. Description: ------------------------------------------------------------------------------ */ /*---------------------------------------------------------------------------- ; INCLUDES ----------------------------------------------------------------------------*/ #include "amrdecode.h" #include "cnst.h" #include "typedef.h" #include "frame.h" #include "sp_dec.h" #include "wmf_to_ets.h" #include "if2_to_ets.h" #include "frame_type_3gpp.h" /*---------------------------------------------------------------------------- ; MACROS ; Define module specific macros here ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; DEFINES ; Include all pre-processor statements here. Include conditional ; compile variables also. ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; LOCAL FUNCTION DEFINITIONS ; Function Prototype declaration ----------------------------------------------------------------------------*/ /*---------------------------------------------------------------------------- ; LOCAL STORE/BUFFER/POINTER DEFINITIONS ; Variable declaration - defined here and used outside this module ----------------------------------------------------------------------------*/ /* ------------------------------------------------------------------------------ FUNCTION NAME: AMRDecode ------------------------------------------------------------------------------ INPUT AND OUTPUT DEFINITIONS Inputs: state_data = pointer to a structure (type void) frame_type = 3GPP frame type (enum Frame_Type_3GPP) speech_bits_ptr = pointer to the beginning of the raw encoded speech bits for the current frame to be decoded (unsigned char) raw_pcm_buffer = pointer to the output pcm outputs array (Word16) input_format = input format used; valid values are AMR_WMF, AMR_IF2, and AMR_ETS (Word16) Outputs: raw_pcm_buffer contains the newly decoded linear PCM speech samples state_data->prev_mode contains the new mode Returns: byte_offset = address offset of the next frame to be processed or error condition flag (-1) (int) Global Variables Used: WmfDecBytesPerFrame = table containing the number of core AMR data bytes used by each codec mode for WMF input format (const int) If2DecBytesPerFrame = table containing the number of core AMR data bytes used by each codec mode for IF2 input format (const int) Local Variables Needed: None ------------------------------------------------------------------------------ FUNCTION DESCRIPTION This function is the top level entry function to the GSM AMR Decoder library. First, it checks the input format type (input_format) to determine the type of de-formattting that needs to be done. If input_format is AMR_WMF, the input data is in WMF (aka, non-IF2) format and the function wmf_to_ets will be called to convert to the ETS format (1 bit/word, where 1 word = 16 bits), and byte_offset will be updated according to the contents of WmfDecBytesPerFrame table. If input_format is AMR_IF2, the input data is in IF2 format [1] and the function if2_to_ets will be called to convert to the ETS format, and byte_offset will be updated according to the contents of If2DecBytesPerFrame table. The codec mode and receive frame type is initialized based on the incoming frame_type. If input_format is AMR_ETS, the input data is in the ETS format. The receive frame type is set to the value in the first location of the buffer pointed to by speech_bits_ptr. Then, the encoded speech parameters in the buffer pointed to by speech_bits is copied to dec_ets_input_bfr and the type will be changed from unsigned char to Word16. Lastly, if the receive frame type is not RX_NO_DATA, the mode is obtained from the buffer pointed to by speech_bits_ptr, offset by MAX_SERIAL_SIZE+1, otherwise, the mode is set to the previous mode (found the in state_data->prev_mode). If input_format is an unsupported format, byte_offset will be set to -1, to indicate an error condition has occurred, and the function will exit. If there are no errors, GSMFrameDecode is called to decode a 20 ms frame. It puts the decoded linear PCM samples in the buffer pointed to by raw_pcm_buffer. Then, the prev_mode field of the structure pointed to by state_data is updated to the current mode. This function returns the new byte_offset value to indicate the address offset of the next speech frame to be decoded. ------------------------------------------------------------------------------ REQUIREMENTS None ------------------------------------------------------------------------------ REFERENCES [1] "AMR Speech Codec Frame Structure", 3GPP TS 26.101 version 4.1.0 Release 4, June 2001 ------------------------------------------------------------------------------ PSEUDO-CODE Note: AMRSID_RXTYPE_BIT_OFFSET = 35 AMRSID_RXMODE_BIT_OFFSET = 36 NUM_AMRSID_RXMODE_BITS = 3 // Set up Decoder state structure pointer Speech_Decode_FrameState *decoder_state = (Speech_Decode_FrameState *) state_data // Determine type of de-formatting // Decode WMF or IF2 frames IF ((input_format == AMR_RX_WMF) | (input_format == AMR_RX_IF2)) THEN IF (input_format == AMR_RX_WMF) THEN // Convert incoming packetized raw WMF data to ETS format CALL wmf_to_ets(frame_type = frame_type input_ptr = speech_bits_ptr output_ptr = &dec_ets_input_bfr) MODIFYING(nothing) RETURNING(nothing) // Address offset of the start of next frame byte_offset = WmfDecBytesPerFrame[frame_type] ELSEIF (input_format == AMR_RX_IF2) THEN // Convert incoming packetized raw IF2 data to ETS format CALL if2_to_ets(frame_type = frame_type input_ptr = speech_bits_ptr output_ptr = &dec_ets_input_bfr) MODIFYING(nothing) RETURNING(nothing) // Address offset of the start of next frame byte_offset = If2DecBytesPerFrame[frame_type] ENDIF // Determine AMR codec mode and AMR RX frame type IF (frame_type <= AMR_122) THEN mode = (enum Mode) frame_type; rx_type = RX_SPEECH_GOOD; ELSEIF (frame_type == AMR_SID) THEN // Clear mode store prior to reading mode info from input buffer mode = 0 FOR i = 0 TO NUM_AMRSID_RXMODE_BITS-1 mode |= (dec_ets_input_bfr[AMRSID_RXMODE_BIT_OFFSET+i] << i) ENDFOR IF (dec_ets_input_bfr[AMRSID_RXTYPE_BIT_OFFSET] == 0) THEN rx_type = RX_SID_FIRST ELSE rx_type = RX_SID_UPDATE ENDIF ELSEIF ((frame_type > AMR_SID) && (frame_type < NO_DATA)) THEN // Use previous mode mode = decoder_state->prev_mode // Unsupported SID frames rx_type = RX_SPEECH_BAD; ELSE // Use previous mode mode = decoder_state->prev_mode // No data received rx_type = RX_NO_DATA; ENDIF // Decode ETS frames ELSEIF (input_format == AMR_RX_ETS) THEN // Change type of pointer to incoming raw ETS data ets_word_ptr = (Word16 *) speech_bits_ptr // Get RX frame type rx_type = (enum RXFrameType) *ets_word_ptr ets_word_ptr = ets_word_ptr + 1 // Copy incoming raw ETS data to dec_ets_input_bfr FOR i = 0 TO MAX_SERIAL_SIZE-1 dec_ets_input_bfr[i] = *ets_word_ptr ets_word_ptr = ets_word_ptr + 1 ENDFOR // Get codec mode IF (rx_type != RX_NO_DATA) THEN mode = (enum Mode) *ets_word_ptr ELSE //Use previous mode if no received data mode = decoder_state->prev_mode ENDIF // Set up byte_offset byte_offset = 2*(MAX_SERIAL_SIZE+2) ELSE // Invalid format, return error code byte_offset = -1 ENDIF // Proceed with decoding frame, if there are no errors IF (byte_offset != -1) THEN // Decode a 20 ms frame CALL GSMFrameDecode( st = decoder_state mode = mode serial = dec_ets_input_bfr, frame_type = rx_type, synth = (Word16 *)raw_pcm_buffer); MODIFYING (nothing) RETURNING (Nothing) // Save mode for next frame decoder_state->prev_mode = mode ENDIF RETURN (byte_offset) ------------------------------------------------------------------------------ RESOURCES USED [optional] When the code is written for a specific target processor the the resources used should be documented below. HEAP MEMORY USED: x bytes STACK MEMORY USED: x bytes CLOCK CYCLES: (cycle count equation for this function) + (variable used to represent cycle count for each subroutine called) where: (cycle count variable) = cycle count for [subroutine name] ------------------------------------------------------------------------------ CAUTION [optional] [State any special notes, constraints or cautions for users of this function] ------------------------------------------------------------------------------ */ Word16 AMRDecode( void *state_data, enum Frame_Type_3GPP frame_type, UWord8 *speech_bits_ptr, Word16 *raw_pcm_buffer, bitstream_format input_format ) { Word16 *ets_word_ptr; enum Mode mode = (enum Mode)MR475; int modeStore; int tempInt; enum RXFrameType rx_type = RX_NO_DATA; Word16 dec_ets_input_bfr[MAX_SERIAL_SIZE]; Word16 i; Word16 byte_offset = -1; /* Type cast state_data to Speech_Decode_FrameState rather than passing * that structure type to this function so the structure make up can't * be viewed from higher level functions than this. */ Speech_Decode_FrameState *decoder_state = (Speech_Decode_FrameState *) state_data; /* Determine type of de-formatting */ /* WMF or IF2 frames */ if ((input_format == MIME_IETF) | (input_format == IF2)) { if (input_format == MIME_IETF) { /* Convert incoming packetized raw WMF data to ETS format */ wmf_to_ets(frame_type, speech_bits_ptr, dec_ets_input_bfr); /* Address offset of the start of next frame */ byte_offset = WmfDecBytesPerFrame[frame_type]; } else /* else has to be input_format IF2 */ { /* Convert incoming packetized raw IF2 data to ETS format */ if2_to_ets(frame_type, speech_bits_ptr, dec_ets_input_bfr); /* Address offset of the start of next frame */ byte_offset = If2DecBytesPerFrame[frame_type]; } /* At this point, input data is in ETS format */ /* Determine AMR codec mode and AMR RX frame type */ if (frame_type <= AMR_122) { mode = (enum Mode) frame_type; rx_type = RX_SPEECH_GOOD; } else if (frame_type == AMR_SID) { /* Clear mode store prior to reading mode info from input buffer */ modeStore = 0; for (i = 0; i < NUM_AMRSID_RXMODE_BITS; i++) { tempInt = dec_ets_input_bfr[AMRSID_RXMODE_BIT_OFFSET+i] << i; modeStore |= tempInt; } mode = (enum Mode) modeStore; /* Get RX frame type */ if (dec_ets_input_bfr[AMRSID_RXTYPE_BIT_OFFSET] == 0) { rx_type = RX_SID_FIRST; } else { rx_type = RX_SID_UPDATE; } } else if (frame_type < AMR_NO_DATA) { /* Invalid frame_type, return error code */ byte_offset = -1; /* !!! */ } else { mode = decoder_state->prev_mode; /* * RX_NO_DATA, generate exponential decay from latest valid frame for the first 6 frames * after that, create silent frames */ rx_type = RX_NO_DATA; } } /* ETS frames */ else if (input_format == ETS) { /* Change type of pointer to incoming raw ETS data */ ets_word_ptr = (Word16 *) speech_bits_ptr; /* Get RX frame type */ rx_type = (enum RXFrameType) * ets_word_ptr; ets_word_ptr++; /* Copy incoming raw ETS data to dec_ets_input_bfr */ for (i = 0; i < MAX_SERIAL_SIZE; i++) { dec_ets_input_bfr[i] = *ets_word_ptr; ets_word_ptr++; } /* Get codec mode */ if (rx_type != RX_NO_DATA) { /* Get mode from input bitstream */ mode = (enum Mode) * ets_word_ptr; } else { /* Use previous mode if no received data */ mode = decoder_state->prev_mode; } /* Set up byte_offset */ byte_offset = 2 * (MAX_SERIAL_SIZE + 2); } else { /* Invalid input format, return error code */ byte_offset = -1; } /* Proceed with decoding frame, if there are no errors */ if (byte_offset != -1) { /* Decode a 20 ms frame */ #ifndef CONSOLE_DECODER_REF /* Use PV version of sp_dec.c */ GSMFrameDecode(decoder_state, mode, dec_ets_input_bfr, rx_type, raw_pcm_buffer); #else /* Use ETS version of sp_dec.c */ Speech_Decode_Frame(decoder_state, mode, dec_ets_input_bfr, rx_type, raw_pcm_buffer); #endif /* Save mode for next frame */ decoder_state->prev_mode = mode; } return (byte_offset); }