1 /*
2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3  *
4  *  Use of this source code is governed by a BSD-style license
5  *  that can be found in the LICENSE file in the root of the source
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 /*
12  * structs.h
13  *
14  * This header file contains all the structs used in the ISAC codec
15  *
16  */
17 
18 #ifndef WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_STRUCTS_H_
19 #define WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_STRUCTS_H_
20 
21 
22 #include "typedefs.h"
23 #include "settings.h"
24 #include "isac.h"
25 
26 typedef struct Bitstreamstruct {
27 
28   WebRtc_UWord8   stream[STREAM_SIZE_MAX];
29   WebRtc_UWord32  W_upper;
30   WebRtc_UWord32  streamval;
31   WebRtc_UWord32  stream_index;
32 
33 } Bitstr;
34 
35 typedef struct {
36 
37   double    DataBufferLo[WINLEN];
38   double    DataBufferHi[WINLEN];
39 
40   double    CorrBufLo[ORDERLO+1];
41   double    CorrBufHi[ORDERHI+1];
42 
43   float    PreStateLoF[ORDERLO+1];
44   float    PreStateLoG[ORDERLO+1];
45   float    PreStateHiF[ORDERHI+1];
46   float    PreStateHiG[ORDERHI+1];
47   float    PostStateLoF[ORDERLO+1];
48   float    PostStateLoG[ORDERLO+1];
49   float    PostStateHiF[ORDERHI+1];
50   float    PostStateHiG[ORDERHI+1];
51 
52   double    OldEnergy;
53 
54 } MaskFiltstr;
55 
56 
57 typedef struct {
58 
59   //state vectors for each of the two analysis filters
60   double    INSTAT1[2*(QORDER-1)];
61   double    INSTAT2[2*(QORDER-1)];
62   double    INSTATLA1[2*(QORDER-1)];
63   double    INSTATLA2[2*(QORDER-1)];
64   double    INLABUF1[QLOOKAHEAD];
65   double    INLABUF2[QLOOKAHEAD];
66 
67   float    INSTAT1_float[2*(QORDER-1)];
68   float    INSTAT2_float[2*(QORDER-1)];
69   float    INSTATLA1_float[2*(QORDER-1)];
70   float    INSTATLA2_float[2*(QORDER-1)];
71   float    INLABUF1_float[QLOOKAHEAD];
72   float    INLABUF2_float[QLOOKAHEAD];
73 
74   /* High pass filter */
75   double    HPstates[HPORDER];
76   float    HPstates_float[HPORDER];
77 
78 } PreFiltBankstr;
79 
80 
81 typedef struct {
82 
83   //state vectors for each of the two analysis filters
84   double    STATE_0_LOWER[2*POSTQORDER];
85   double    STATE_0_UPPER[2*POSTQORDER];
86 
87   /* High pass filter */
88   double    HPstates1[HPORDER];
89   double    HPstates2[HPORDER];
90 
91   float    STATE_0_LOWER_float[2*POSTQORDER];
92   float    STATE_0_UPPER_float[2*POSTQORDER];
93 
94   float    HPstates1_float[HPORDER];
95   float    HPstates2_float[HPORDER];
96 
97 } PostFiltBankstr;
98 
99 typedef struct {
100 
101   //data buffer for pitch filter
102   double    ubuf[PITCH_BUFFSIZE];
103 
104   //low pass state vector
105   double    ystate[PITCH_DAMPORDER];
106 
107   //old lag and gain
108   double    oldlagp[1];
109   double    oldgainp[1];
110 
111 } PitchFiltstr;
112 
113 typedef struct {
114 
115   //data buffer
116   double    buffer[PITCH_WLPCBUFLEN];
117 
118   //state vectors
119   double    istate[PITCH_WLPCORDER];
120   double    weostate[PITCH_WLPCORDER];
121   double    whostate[PITCH_WLPCORDER];
122 
123   //LPC window   -> should be a global array because constant
124   double    window[PITCH_WLPCWINLEN];
125 
126 } WeightFiltstr;
127 
128 typedef struct {
129 
130   //for inital estimator
131   double         dec_buffer[PITCH_CORR_LEN2 + PITCH_CORR_STEP2 +
132                             PITCH_MAX_LAG/2 - PITCH_FRAME_LEN/2+2];
133   double        decimator_state[2*ALLPASSSECTIONS+1];
134   double        hp_state[2];
135 
136   double        whitened_buf[QLOOKAHEAD];
137 
138   double        inbuf[QLOOKAHEAD];
139 
140   PitchFiltstr  PFstr_wght;
141   PitchFiltstr  PFstr;
142   WeightFiltstr Wghtstr;
143 
144 } PitchAnalysisStruct;
145 
146 
147 
148 /* Have instance of struct together with other iSAC structs */
149 typedef struct {
150 
151   /* Previous frame length (in ms)                                    */
152   WebRtc_Word32    prev_frame_length;
153 
154   /* Previous RTP timestamp from received
155      packet (in samples relative beginning)                           */
156   WebRtc_Word32    prev_rec_rtp_number;
157 
158   /* Send timestamp for previous packet (in ms using timeGetTime())   */
159   WebRtc_UWord32    prev_rec_send_ts;
160 
161   /* Arrival time for previous packet (in ms using timeGetTime())     */
162   WebRtc_UWord32    prev_rec_arr_ts;
163 
164   /* rate of previous packet, derived from RTP timestamps (in bits/s) */
165   float   prev_rec_rtp_rate;
166 
167   /* Time sinse the last update of the BN estimate (in ms)            */
168   WebRtc_UWord32    last_update_ts;
169 
170   /* Time sinse the last reduction (in ms)                            */
171   WebRtc_UWord32    last_reduction_ts;
172 
173   /* How many times the estimate was update in the beginning          */
174   WebRtc_Word32    count_tot_updates_rec;
175 
176   /* The estimated bottle neck rate from there to here (in bits/s)    */
177   WebRtc_Word32  rec_bw;
178   float   rec_bw_inv;
179   float   rec_bw_avg;
180   float   rec_bw_avg_Q;
181 
182   /* The estimated mean absolute jitter value,
183      as seen on this side (in ms)                                     */
184   float   rec_jitter;
185   float   rec_jitter_short_term;
186   float   rec_jitter_short_term_abs;
187   float   rec_max_delay;
188   float   rec_max_delay_avg_Q;
189 
190   /* (assumed) bitrate for headers (bps)                              */
191   float   rec_header_rate;
192 
193   /* The estimated bottle neck rate from here to there (in bits/s)    */
194   float    send_bw_avg;
195 
196   /* The estimated mean absolute jitter value, as seen on
197      the other siee (in ms)                                           */
198   float   send_max_delay_avg;
199 
200   // number of packets received since last update
201   int num_pkts_rec;
202 
203   int num_consec_rec_pkts_over_30k;
204 
205   // flag for marking that a high speed network has been
206   // detected downstream
207   int hsn_detect_rec;
208 
209   int num_consec_snt_pkts_over_30k;
210 
211   // flag for marking that a high speed network has
212   // been detected upstream
213   int hsn_detect_snd;
214 
215   WebRtc_UWord32 start_wait_period;
216 
217   int in_wait_period;
218 
219   int change_to_WB;
220 
221   WebRtc_UWord32                 senderTimestamp;
222   WebRtc_UWord32                 receiverTimestamp;
223   //enum IsacSamplingRate incomingStreamSampFreq;
224   WebRtc_UWord16                 numConsecLatePkts;
225   float                        consecLatency;
226   WebRtc_Word16                  inWaitLatePkts;
227 } BwEstimatorstr;
228 
229 
230 typedef struct {
231 
232   /* boolean, flags if previous packet exceeded B.N. */
233   int    PrevExceed;
234   /* ms */
235   int    ExceedAgo;
236   /* packets left to send in current burst */
237   int    BurstCounter;
238   /* packets */
239   int    InitCounter;
240   /* ms remaining in buffer when next packet will be sent */
241   double StillBuffered;
242 
243 } RateModel;
244 
245 
246 typedef struct {
247 
248   unsigned int SpaceAlloced;
249   unsigned int MaxPermAlloced;
250   double Tmp0[MAXFFTSIZE];
251   double Tmp1[MAXFFTSIZE];
252   double Tmp2[MAXFFTSIZE];
253   double Tmp3[MAXFFTSIZE];
254   int Perm[MAXFFTSIZE];
255   int factor [NFACTOR];
256 
257 } FFTstr;
258 
259 
260 /* The following strutc is used to store data from encoding, to make it
261    fast and easy to construct a new bitstream with a different Bandwidth
262    estimate. All values (except framelength and minBytes) is double size to
263    handle 60 ms of data.
264 */
265 typedef struct {
266 
267   /* Used to keep track of if it is first or second part of 60 msec packet */
268   int         startIdx;
269 
270   /* Frame length in samples */
271   WebRtc_Word16 framelength;
272 
273   /* Pitch Gain */
274   int         pitchGain_index[2];
275 
276   /* Pitch Lag */
277   double      meanGain[2];
278   int         pitchIndex[PITCH_SUBFRAMES*2];
279 
280   /* LPC */
281   int         LPCindex_s[108*2]; /* KLT_ORDER_SHAPE = 108 */
282   int         LPCindex_g[12*2];  /* KLT_ORDER_GAIN = 12 */
283   double      LPCcoeffs_lo[(ORDERLO+1)*SUBFRAMES*2];
284   double      LPCcoeffs_hi[(ORDERHI+1)*SUBFRAMES*2];
285 
286   /* Encode Spec */
287   WebRtc_Word16 fre[FRAMESAMPLES];
288   WebRtc_Word16 fim[FRAMESAMPLES];
289   WebRtc_Word16 AvgPitchGain[2];
290 
291   /* Used in adaptive mode only */
292   int         minBytes;
293 
294 } ISAC_SaveEncData_t;
295 
296 
297 typedef struct {
298 
299   int         indexLPCShape[UB_LPC_ORDER * UB16_LPC_VEC_PER_FRAME];
300   double      lpcGain[SUBFRAMES<<1];
301   int         lpcGainIndex[SUBFRAMES<<1];
302 
303   Bitstr      bitStreamObj;
304 
305   WebRtc_Word16 realFFT[FRAMESAMPLES_HALF];
306   WebRtc_Word16 imagFFT[FRAMESAMPLES_HALF];
307 } ISACUBSaveEncDataStruct;
308 
309 
310 
311 typedef struct {
312 
313   Bitstr              bitstr_obj;
314   MaskFiltstr         maskfiltstr_obj;
315   PreFiltBankstr      prefiltbankstr_obj;
316   PitchFiltstr        pitchfiltstr_obj;
317   PitchAnalysisStruct pitchanalysisstr_obj;
318   FFTstr              fftstr_obj;
319   ISAC_SaveEncData_t  SaveEnc_obj;
320 
321   int                 buffer_index;
322   WebRtc_Word16         current_framesamples;
323 
324   float               data_buffer_float[FRAMESAMPLES_30ms];
325 
326   int                 frame_nb;
327   double              bottleneck;
328   WebRtc_Word16         new_framelength;
329   double              s2nr;
330 
331   /* Maximum allowed number of bits for a 30 msec packet */
332   WebRtc_Word16         payloadLimitBytes30;
333   /* Maximum allowed number of bits for a 30 msec packet */
334   WebRtc_Word16         payloadLimitBytes60;
335   /* Maximum allowed number of bits for both 30 and 60 msec packet */
336   WebRtc_Word16         maxPayloadBytes;
337   /* Maximum allowed rate in bytes per 30 msec packet */
338   WebRtc_Word16         maxRateInBytes;
339 
340   /*---
341     If set to 1 iSAC will not addapt the frame-size, if used in
342     channel-adaptive mode. The initial value will be used for all rates.
343     ---*/
344   WebRtc_Word16         enforceFrameSize;
345 
346   /*-----
347     This records the BWE index the encoder injected into the bit-stream.
348     It will be used in RCU. The same BWE index of main paylaod will be in
349     the redundant payload. We can not retrive it from BWE because it is
350     a recursive procedure (WebRtcIsac_GetDownlinkBwJitIndexImpl) and has to be
351     called only once per each encode.
352     -----*/
353   WebRtc_Word16         lastBWIdx;
354 } ISACLBEncStruct;
355 
356 typedef struct {
357 
358   Bitstr                  bitstr_obj;
359   MaskFiltstr             maskfiltstr_obj;
360   PreFiltBankstr          prefiltbankstr_obj;
361   FFTstr                  fftstr_obj;
362   ISACUBSaveEncDataStruct SaveEnc_obj;
363 
364   int                     buffer_index;
365   float                   data_buffer_float[MAX_FRAMESAMPLES +
366                                             LB_TOTAL_DELAY_SAMPLES];
367   double                  bottleneck;
368   /* Maximum allowed number of bits for a 30 msec packet */
369   //WebRtc_Word16        payloadLimitBytes30;
370   /* Maximum allowed number of bits for both 30 and 60 msec packet */
371   //WebRtc_Word16        maxPayloadBytes;
372   WebRtc_Word16             maxPayloadSizeBytes;
373 
374   double                  lastLPCVec[UB_LPC_ORDER];
375   WebRtc_Word16             numBytesUsed;
376   WebRtc_Word16             lastJitterInfo;
377 } ISACUBEncStruct;
378 
379 
380 
381 typedef struct {
382 
383   Bitstr          bitstr_obj;
384   MaskFiltstr     maskfiltstr_obj;
385   PostFiltBankstr postfiltbankstr_obj;
386   PitchFiltstr    pitchfiltstr_obj;
387   FFTstr          fftstr_obj;
388 
389 } ISACLBDecStruct;
390 
391 typedef struct {
392 
393   Bitstr          bitstr_obj;
394   MaskFiltstr     maskfiltstr_obj;
395   PostFiltBankstr postfiltbankstr_obj;
396   FFTstr          fftstr_obj;
397 
398 } ISACUBDecStruct;
399 
400 
401 
402 typedef struct {
403 
404   ISACLBEncStruct ISACencLB_obj;
405   ISACLBDecStruct ISACdecLB_obj;
406 } ISACLBStruct;
407 
408 
409 typedef struct {
410 
411   ISACUBEncStruct ISACencUB_obj;
412   ISACUBDecStruct ISACdecUB_obj;
413 } ISACUBStruct;
414 
415 /*
416   This struct is used to take a snapshot of the entropy coder and LPC gains
417   right before encoding LPC gains. This allows us to go back to that state
418   if we like to limit the payload size.
419 */
420 typedef struct {
421   /* 6 lower-band & 6 upper-band */
422   double       loFiltGain[SUBFRAMES];
423   double       hiFiltGain[SUBFRAMES];
424   /* Upper boundary of interval W */
425   WebRtc_UWord32 W_upper;
426   WebRtc_UWord32 streamval;
427   /* Index to the current position in bytestream */
428   WebRtc_UWord32 stream_index;
429   WebRtc_UWord8  stream[3];
430 } transcode_obj;
431 
432 
433 typedef struct {
434   // lower-band codec instance
435   ISACLBStruct              instLB;
436   // upper-band codec instance
437   ISACUBStruct              instUB;
438 
439   // Bandwidth Estimator and model for the rate.
440   BwEstimatorstr            bwestimator_obj;
441   RateModel                 rate_data_obj;
442   double                    MaxDelay;
443 
444   /* 0 = adaptive; 1 = instantaneous */
445   WebRtc_Word16               codingMode;
446 
447   // overall bottleneck of the codec
448   WebRtc_Word32               bottleneck;
449 
450   // QMF Filter state
451   WebRtc_Word32               analysisFBState1[FB_STATE_SIZE_WORD32];
452   WebRtc_Word32               analysisFBState2[FB_STATE_SIZE_WORD32];
453   WebRtc_Word32               synthesisFBState1[FB_STATE_SIZE_WORD32];
454   WebRtc_Word32               synthesisFBState2[FB_STATE_SIZE_WORD32];
455 
456   // Error Code
457   WebRtc_Word16               errorCode;
458 
459   // bandwidth of the encoded audio 8, 12 or 16 kHz
460   enum ISACBandwidth        bandwidthKHz;
461   // Sampling rate of audio, encoder and decode,  8 or 16 kHz
462   enum IsacSamplingRate encoderSamplingRateKHz;
463   enum IsacSamplingRate decoderSamplingRateKHz;
464   // Flag to keep track of initializations, lower & upper-band
465   // encoder and decoder.
466   WebRtc_Word16               initFlag;
467 
468   // Flag to to indicate signal bandwidth switch
469   WebRtc_Word16               resetFlag_8kHz;
470 
471   // Maximum allowed rate, measured in Bytes per 30 ms.
472   WebRtc_Word16               maxRateBytesPer30Ms;
473   // Maximum allowed payload-size, measured in Bytes.
474   WebRtc_Word16               maxPayloadSizeBytes;
475 } ISACMainStruct;
476 
477 #endif /* WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_STRUCTS_H_ */
478