blob: 7523ad6e4a0267184d977e3cb70f82b813b511a4 [file] [log] [blame]
* Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
* structs.h
* This header file contains all the structs used in the ISAC codec
#include "typedefs.h"
#include "settings.h"
#include "isac.h"
typedef struct Bitstreamstruct {
WebRtc_UWord8 stream[STREAM_SIZE_MAX];
WebRtc_UWord32 W_upper;
WebRtc_UWord32 streamval;
WebRtc_UWord32 stream_index;
} Bitstr;
typedef struct {
double DataBufferLo[WINLEN];
double DataBufferHi[WINLEN];
double CorrBufLo[ORDERLO+1];
double CorrBufHi[ORDERHI+1];
float PreStateLoF[ORDERLO+1];
float PreStateLoG[ORDERLO+1];
float PreStateHiF[ORDERHI+1];
float PreStateHiG[ORDERHI+1];
float PostStateLoF[ORDERLO+1];
float PostStateLoG[ORDERLO+1];
float PostStateHiF[ORDERHI+1];
float PostStateHiG[ORDERHI+1];
double OldEnergy;
} MaskFiltstr;
typedef struct {
//state vectors for each of the two analysis filters
double INSTAT1[2*(QORDER-1)];
double INSTAT2[2*(QORDER-1)];
double INSTATLA1[2*(QORDER-1)];
double INSTATLA2[2*(QORDER-1)];
float INSTAT1_float[2*(QORDER-1)];
float INSTAT2_float[2*(QORDER-1)];
float INSTATLA1_float[2*(QORDER-1)];
float INSTATLA2_float[2*(QORDER-1)];
/* High pass filter */
double HPstates[HPORDER];
float HPstates_float[HPORDER];
} PreFiltBankstr;
typedef struct {
//state vectors for each of the two analysis filters
/* High pass filter */
double HPstates1[HPORDER];
double HPstates2[HPORDER];
float STATE_0_LOWER_float[2*POSTQORDER];
float STATE_0_UPPER_float[2*POSTQORDER];
float HPstates1_float[HPORDER];
float HPstates2_float[HPORDER];
} PostFiltBankstr;
typedef struct {
//data buffer for pitch filter
double ubuf[PITCH_BUFFSIZE];
//low pass state vector
double ystate[PITCH_DAMPORDER];
//old lag and gain
double oldlagp[1];
double oldgainp[1];
} PitchFiltstr;
typedef struct {
//data buffer
double buffer[PITCH_WLPCBUFLEN];
//state vectors
double istate[PITCH_WLPCORDER];
double weostate[PITCH_WLPCORDER];
double whostate[PITCH_WLPCORDER];
//LPC window -> should be a global array because constant
double window[PITCH_WLPCWINLEN];
} WeightFiltstr;
typedef struct {
//for inital estimator
double dec_buffer[PITCH_CORR_LEN2 + PITCH_CORR_STEP2 +
double decimator_state[2*ALLPASSSECTIONS+1];
double hp_state[2];
double whitened_buf[QLOOKAHEAD];
double inbuf[QLOOKAHEAD];
PitchFiltstr PFstr_wght;
PitchFiltstr PFstr;
WeightFiltstr Wghtstr;
} PitchAnalysisStruct;
/* Have instance of struct together with other iSAC structs */
typedef struct {
/* Previous frame length (in ms) */
WebRtc_Word32 prev_frame_length;
/* Previous RTP timestamp from received
packet (in samples relative beginning) */
WebRtc_Word32 prev_rec_rtp_number;
/* Send timestamp for previous packet (in ms using timeGetTime()) */
WebRtc_UWord32 prev_rec_send_ts;
/* Arrival time for previous packet (in ms using timeGetTime()) */
WebRtc_UWord32 prev_rec_arr_ts;
/* rate of previous packet, derived from RTP timestamps (in bits/s) */
float prev_rec_rtp_rate;
/* Time sinse the last update of the BN estimate (in ms) */
WebRtc_UWord32 last_update_ts;
/* Time sinse the last reduction (in ms) */
WebRtc_UWord32 last_reduction_ts;
/* How many times the estimate was update in the beginning */
WebRtc_Word32 count_tot_updates_rec;
/* The estimated bottle neck rate from there to here (in bits/s) */
WebRtc_Word32 rec_bw;
float rec_bw_inv;
float rec_bw_avg;
float rec_bw_avg_Q;
/* The estimated mean absolute jitter value,
as seen on this side (in ms) */
float rec_jitter;
float rec_jitter_short_term;
float rec_jitter_short_term_abs;
float rec_max_delay;
float rec_max_delay_avg_Q;
/* (assumed) bitrate for headers (bps) */
float rec_header_rate;
/* The estimated bottle neck rate from here to there (in bits/s) */
float send_bw_avg;
/* The estimated mean absolute jitter value, as seen on
the other siee (in ms) */
float send_max_delay_avg;
// number of packets received since last update
int num_pkts_rec;
int num_consec_rec_pkts_over_30k;
// flag for marking that a high speed network has been
// detected downstream
int hsn_detect_rec;
int num_consec_snt_pkts_over_30k;
// flag for marking that a high speed network has
// been detected upstream
int hsn_detect_snd;
WebRtc_UWord32 start_wait_period;
int in_wait_period;
int change_to_WB;
WebRtc_UWord32 senderTimestamp;
WebRtc_UWord32 receiverTimestamp;
//enum IsacSamplingRate incomingStreamSampFreq;
WebRtc_UWord16 numConsecLatePkts;
float consecLatency;
WebRtc_Word16 inWaitLatePkts;
} BwEstimatorstr;
typedef struct {
/* boolean, flags if previous packet exceeded B.N. */
int PrevExceed;
/* ms */
int ExceedAgo;
/* packets left to send in current burst */
int BurstCounter;
/* packets */
int InitCounter;
/* ms remaining in buffer when next packet will be sent */
double StillBuffered;
} RateModel;
typedef struct {
unsigned int SpaceAlloced;
unsigned int MaxPermAlloced;
double Tmp0[MAXFFTSIZE];
double Tmp1[MAXFFTSIZE];
double Tmp2[MAXFFTSIZE];
double Tmp3[MAXFFTSIZE];
int factor [NFACTOR];
} FFTstr;
/* The following strutc is used to store data from encoding, to make it
fast and easy to construct a new bitstream with a different Bandwidth
estimate. All values (except framelength and minBytes) is double size to
handle 60 ms of data.
typedef struct {
/* Used to keep track of if it is first or second part of 60 msec packet */
int startIdx;
/* Frame length in samples */
WebRtc_Word16 framelength;
/* Pitch Gain */
int pitchGain_index[2];
/* Pitch Lag */
double meanGain[2];
int pitchIndex[PITCH_SUBFRAMES*2];
/* LPC */
int LPCmodel[2];
int LPCindex_s[108*2]; /* KLT_ORDER_SHAPE = 108 */
int LPCindex_g[12*2]; /* KLT_ORDER_GAIN = 12 */
double LPCcoeffs_lo[(ORDERLO+1)*SUBFRAMES*2];
double LPCcoeffs_hi[(ORDERHI+1)*SUBFRAMES*2];
/* Encode Spec */
WebRtc_Word16 fre[FRAMESAMPLES];
WebRtc_Word16 fim[FRAMESAMPLES];
WebRtc_Word16 AvgPitchGain[2];
/* Used in adaptive mode only */
int minBytes;
} ISAC_SaveEncData_t;
typedef struct {
double lpcGain[SUBFRAMES<<1];
int lpcGainIndex[SUBFRAMES<<1];
Bitstr bitStreamObj;
} ISACUBSaveEncDataStruct;
typedef struct {
Bitstr bitstr_obj;
MaskFiltstr maskfiltstr_obj;
PreFiltBankstr prefiltbankstr_obj;
PitchFiltstr pitchfiltstr_obj;
PitchAnalysisStruct pitchanalysisstr_obj;
FFTstr fftstr_obj;
ISAC_SaveEncData_t SaveEnc_obj;
int buffer_index;
WebRtc_Word16 current_framesamples;
float data_buffer_float[FRAMESAMPLES_30ms];
int frame_nb;
double bottleneck;
WebRtc_Word16 new_framelength;
double s2nr;
/* Maximum allowed number of bits for a 30 msec packet */
WebRtc_Word16 payloadLimitBytes30;
/* Maximum allowed number of bits for a 30 msec packet */
WebRtc_Word16 payloadLimitBytes60;
/* Maximum allowed number of bits for both 30 and 60 msec packet */
WebRtc_Word16 maxPayloadBytes;
/* Maximum allowed rate in bytes per 30 msec packet */
WebRtc_Word16 maxRateInBytes;
If set to 1 iSAC will not addapt the frame-size, if used in
channel-adaptive mode. The initial value will be used for all rates.
WebRtc_Word16 enforceFrameSize;
This records the BWE index the encoder injected into the bit-stream.
It will be used in RCU. The same BWE index of main paylaod will be in
the redundant payload. We can not retrive it from BWE because it is
a recursive procedure (WebRtcIsac_GetDownlinkBwJitIndexImpl) and has to be
called only once per each encode.
WebRtc_Word16 lastBWIdx;
} ISACLBEncStruct;
typedef struct {
Bitstr bitstr_obj;
MaskFiltstr maskfiltstr_obj;
PreFiltBankstr prefiltbankstr_obj;
FFTstr fftstr_obj;
ISACUBSaveEncDataStruct SaveEnc_obj;
int buffer_index;
float data_buffer_float[MAX_FRAMESAMPLES +
double bottleneck;
/* Maximum allowed number of bits for a 30 msec packet */
//WebRtc_Word16 payloadLimitBytes30;
/* Maximum allowed number of bits for both 30 and 60 msec packet */
//WebRtc_Word16 maxPayloadBytes;
WebRtc_Word16 maxPayloadSizeBytes;
double lastLPCVec[UB_LPC_ORDER];
WebRtc_Word16 numBytesUsed;
WebRtc_Word16 lastJitterInfo;
} ISACUBEncStruct;
typedef struct {
Bitstr bitstr_obj;
MaskFiltstr maskfiltstr_obj;
PostFiltBankstr postfiltbankstr_obj;
PitchFiltstr pitchfiltstr_obj;
FFTstr fftstr_obj;
} ISACLBDecStruct;
typedef struct {
Bitstr bitstr_obj;
MaskFiltstr maskfiltstr_obj;
PostFiltBankstr postfiltbankstr_obj;
FFTstr fftstr_obj;
} ISACUBDecStruct;
typedef struct {
ISACLBEncStruct ISACencLB_obj;
ISACLBDecStruct ISACdecLB_obj;
} ISACLBStruct;
typedef struct {
ISACUBEncStruct ISACencUB_obj;
ISACUBDecStruct ISACdecUB_obj;
} ISACUBStruct;
This struct is used to take a snapshot of the entropy coder and LPC gains
right before encoding LPC gains. This allows us to go back to that state
if we like to limit the payload size.
typedef struct {
/* 6 lower-band & 6 upper-band */
double loFiltGain[SUBFRAMES];
double hiFiltGain[SUBFRAMES];
/* Upper boundary of interval W */
WebRtc_UWord32 W_upper;
WebRtc_UWord32 streamval;
/* Index to the current position in bytestream */
WebRtc_UWord32 stream_index;
WebRtc_UWord8 stream[3];
} transcode_obj;
typedef struct {
// lower-band codec instance
ISACLBStruct instLB;
// upper-band codec instance
ISACUBStruct instUB;
// Bandwidth Estimator and model for the rate.
BwEstimatorstr bwestimator_obj;
RateModel rate_data_obj;
double MaxDelay;
/* 0 = adaptive; 1 = instantaneous */
WebRtc_Word16 codingMode;
// overall bottleneck of the codec
WebRtc_Word32 bottleneck;
// QMF Filter state
WebRtc_Word32 analysisFBState1[FB_STATE_SIZE_WORD32];
WebRtc_Word32 analysisFBState2[FB_STATE_SIZE_WORD32];
WebRtc_Word32 synthesisFBState1[FB_STATE_SIZE_WORD32];
WebRtc_Word32 synthesisFBState2[FB_STATE_SIZE_WORD32];
// Error Code
WebRtc_Word16 errorCode;
// bandwidth of the encoded audio 8, 12 or 16 kHz
enum ISACBandwidth bandwidthKHz;
// Sampling rate of audio, encoder and decode, 8 or 16 kHz
enum IsacSamplingRate encoderSamplingRateKHz;
enum IsacSamplingRate decoderSamplingRateKHz;
// Flag to keep track of initializations, lower & upper-band
// encoder and decoder.
WebRtc_Word16 initFlag;
// Flag to to indicate signal bandwidth switch
WebRtc_Word16 resetFlag_8kHz;
// Maximum allowed rate, measured in Bytes per 30 ms.
WebRtc_Word16 maxRateBytesPer30Ms;
// Maximum allowed payload-size, measured in Bytes.
WebRtc_Word16 maxPayloadSizeBytes;
} ISACMainStruct;