• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include "webrtc/modules/audio_coding/codecs/isac/bandwidth_info.h"
22 #include "webrtc/modules/audio_coding/codecs/isac/main/include/isac.h"
23 #include "webrtc/modules/audio_coding/codecs/isac/main/source/settings.h"
24 #include "webrtc/typedefs.h"
25 
26 typedef struct Bitstreamstruct {
27 
28   uint8_t   stream[STREAM_SIZE_MAX];
29   uint32_t  W_upper;
30   uint32_t  streamval;
31   uint32_t  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   int32_t    prev_frame_length;
153 
154   /* Previous RTP timestamp from received
155      packet (in samples relative beginning)                           */
156   int32_t    prev_rec_rtp_number;
157 
158   /* Send timestamp for previous packet (in ms using timeGetTime())   */
159   uint32_t    prev_rec_send_ts;
160 
161   /* Arrival time for previous packet (in ms using timeGetTime())     */
162   uint32_t    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   uint32_t    last_update_ts;
169 
170   /* Time sinse the last reduction (in ms)                            */
171   uint32_t    last_reduction_ts;
172 
173   /* How many times the estimate was update in the beginning          */
174   int32_t    count_tot_updates_rec;
175 
176   /* The estimated bottle neck rate from there to here (in bits/s)    */
177   int32_t  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   uint32_t start_wait_period;
216 
217   int in_wait_period;
218 
219   int change_to_WB;
220 
221   uint32_t                 senderTimestamp;
222   uint32_t                 receiverTimestamp;
223   //enum IsacSamplingRate incomingStreamSampFreq;
224   uint16_t                 numConsecLatePkts;
225   float                        consecLatency;
226   int16_t                  inWaitLatePkts;
227 
228   IsacBandwidthInfo external_bw_info;
229 } BwEstimatorstr;
230 
231 
232 typedef struct {
233 
234   /* boolean, flags if previous packet exceeded B.N. */
235   int    PrevExceed;
236   /* ms */
237   int    ExceedAgo;
238   /* packets left to send in current burst */
239   int    BurstCounter;
240   /* packets */
241   int    InitCounter;
242   /* ms remaining in buffer when next packet will be sent */
243   double StillBuffered;
244 
245 } RateModel;
246 
247 
248 typedef struct {
249 
250   unsigned int SpaceAlloced;
251   unsigned int MaxPermAlloced;
252   double Tmp0[MAXFFTSIZE];
253   double Tmp1[MAXFFTSIZE];
254   double Tmp2[MAXFFTSIZE];
255   double Tmp3[MAXFFTSIZE];
256   int Perm[MAXFFTSIZE];
257   int factor [NFACTOR];
258 
259 } FFTstr;
260 
261 
262 /* The following strutc is used to store data from encoding, to make it
263    fast and easy to construct a new bitstream with a different Bandwidth
264    estimate. All values (except framelength and minBytes) is double size to
265    handle 60 ms of data.
266 */
267 typedef struct {
268 
269   /* Used to keep track of if it is first or second part of 60 msec packet */
270   int         startIdx;
271 
272   /* Frame length in samples */
273   int16_t framelength;
274 
275   /* Pitch Gain */
276   int         pitchGain_index[2];
277 
278   /* Pitch Lag */
279   double      meanGain[2];
280   int         pitchIndex[PITCH_SUBFRAMES*2];
281 
282   /* LPC */
283   int         LPCindex_s[108*2]; /* KLT_ORDER_SHAPE = 108 */
284   int         LPCindex_g[12*2];  /* KLT_ORDER_GAIN = 12 */
285   double      LPCcoeffs_lo[(ORDERLO+1)*SUBFRAMES*2];
286   double      LPCcoeffs_hi[(ORDERHI+1)*SUBFRAMES*2];
287 
288   /* Encode Spec */
289   int16_t fre[FRAMESAMPLES];
290   int16_t fim[FRAMESAMPLES];
291   int16_t AvgPitchGain[2];
292 
293   /* Used in adaptive mode only */
294   int         minBytes;
295 
296 } IsacSaveEncoderData;
297 
298 
299 typedef struct {
300 
301   int         indexLPCShape[UB_LPC_ORDER * UB16_LPC_VEC_PER_FRAME];
302   double      lpcGain[SUBFRAMES<<1];
303   int         lpcGainIndex[SUBFRAMES<<1];
304 
305   Bitstr      bitStreamObj;
306 
307   int16_t realFFT[FRAMESAMPLES_HALF];
308   int16_t imagFFT[FRAMESAMPLES_HALF];
309 } ISACUBSaveEncDataStruct;
310 
311 
312 
313 typedef struct {
314 
315   Bitstr              bitstr_obj;
316   MaskFiltstr         maskfiltstr_obj;
317   PreFiltBankstr      prefiltbankstr_obj;
318   PitchFiltstr        pitchfiltstr_obj;
319   PitchAnalysisStruct pitchanalysisstr_obj;
320   FFTstr              fftstr_obj;
321   IsacSaveEncoderData SaveEnc_obj;
322 
323   int                 buffer_index;
324   int16_t         current_framesamples;
325 
326   float               data_buffer_float[FRAMESAMPLES_30ms];
327 
328   int                 frame_nb;
329   double              bottleneck;
330   int16_t         new_framelength;
331   double              s2nr;
332 
333   /* Maximum allowed number of bits for a 30 msec packet */
334   int16_t         payloadLimitBytes30;
335   /* Maximum allowed number of bits for a 30 msec packet */
336   int16_t         payloadLimitBytes60;
337   /* Maximum allowed number of bits for both 30 and 60 msec packet */
338   int16_t         maxPayloadBytes;
339   /* Maximum allowed rate in bytes per 30 msec packet */
340   int16_t         maxRateInBytes;
341 
342   /*---
343     If set to 1 iSAC will not addapt the frame-size, if used in
344     channel-adaptive mode. The initial value will be used for all rates.
345     ---*/
346   int16_t         enforceFrameSize;
347 
348   /*-----
349     This records the BWE index the encoder injected into the bit-stream.
350     It will be used in RCU. The same BWE index of main payload will be in
351     the redundant payload. We can not retrive it from BWE because it is
352     a recursive procedure (WebRtcIsac_GetDownlinkBwJitIndexImpl) and has to be
353     called only once per each encode.
354     -----*/
355   int16_t         lastBWIdx;
356 } ISACLBEncStruct;
357 
358 typedef struct {
359 
360   Bitstr                  bitstr_obj;
361   MaskFiltstr             maskfiltstr_obj;
362   PreFiltBankstr          prefiltbankstr_obj;
363   FFTstr                  fftstr_obj;
364   ISACUBSaveEncDataStruct SaveEnc_obj;
365 
366   int                     buffer_index;
367   float                   data_buffer_float[MAX_FRAMESAMPLES +
368                                             LB_TOTAL_DELAY_SAMPLES];
369   double                  bottleneck;
370   /* Maximum allowed number of bits for a 30 msec packet */
371   //int16_t        payloadLimitBytes30;
372   /* Maximum allowed number of bits for both 30 and 60 msec packet */
373   //int16_t        maxPayloadBytes;
374   int16_t             maxPayloadSizeBytes;
375 
376   double                  lastLPCVec[UB_LPC_ORDER];
377   int16_t             numBytesUsed;
378   int16_t             lastJitterInfo;
379 } ISACUBEncStruct;
380 
381 
382 
383 typedef struct {
384 
385   Bitstr          bitstr_obj;
386   MaskFiltstr     maskfiltstr_obj;
387   PostFiltBankstr postfiltbankstr_obj;
388   PitchFiltstr    pitchfiltstr_obj;
389   FFTstr          fftstr_obj;
390 
391 } ISACLBDecStruct;
392 
393 typedef struct {
394 
395   Bitstr          bitstr_obj;
396   MaskFiltstr     maskfiltstr_obj;
397   PostFiltBankstr postfiltbankstr_obj;
398   FFTstr          fftstr_obj;
399 
400 } ISACUBDecStruct;
401 
402 
403 
404 typedef struct {
405 
406   ISACLBEncStruct ISACencLB_obj;
407   ISACLBDecStruct ISACdecLB_obj;
408 } ISACLBStruct;
409 
410 
411 typedef struct {
412 
413   ISACUBEncStruct ISACencUB_obj;
414   ISACUBDecStruct ISACdecUB_obj;
415 } ISACUBStruct;
416 
417 /*
418   This struct is used to take a snapshot of the entropy coder and LPC gains
419   right before encoding LPC gains. This allows us to go back to that state
420   if we like to limit the payload size.
421 */
422 typedef struct {
423   /* 6 lower-band & 6 upper-band */
424   double       loFiltGain[SUBFRAMES];
425   double       hiFiltGain[SUBFRAMES];
426   /* Upper boundary of interval W */
427   uint32_t W_upper;
428   uint32_t streamval;
429   /* Index to the current position in bytestream */
430   uint32_t stream_index;
431   uint8_t  stream[3];
432 } transcode_obj;
433 
434 typedef struct {
435   // TODO(kwiberg): The size of these tables could be reduced by storing floats
436   // instead of doubles, and by making use of the identity cos(x) =
437   // sin(x+pi/2). They could also be made global constants that we fill in at
438   // compile time.
439   double costab1[FRAMESAMPLES_HALF];
440   double sintab1[FRAMESAMPLES_HALF];
441   double costab2[FRAMESAMPLES_QUARTER];
442   double sintab2[FRAMESAMPLES_QUARTER];
443 } TransformTables;
444 
445 typedef struct {
446   // lower-band codec instance
447   ISACLBStruct              instLB;
448   // upper-band codec instance
449   ISACUBStruct              instUB;
450 
451   // Bandwidth Estimator and model for the rate.
452   BwEstimatorstr            bwestimator_obj;
453   RateModel                 rate_data_obj;
454   double                    MaxDelay;
455 
456   /* 0 = adaptive; 1 = instantaneous */
457   int16_t               codingMode;
458 
459   // overall bottleneck of the codec
460   int32_t               bottleneck;
461 
462   // QMF Filter state
463   int32_t               analysisFBState1[FB_STATE_SIZE_WORD32];
464   int32_t               analysisFBState2[FB_STATE_SIZE_WORD32];
465   int32_t               synthesisFBState1[FB_STATE_SIZE_WORD32];
466   int32_t               synthesisFBState2[FB_STATE_SIZE_WORD32];
467 
468   // Error Code
469   int16_t               errorCode;
470 
471   // bandwidth of the encoded audio 8, 12 or 16 kHz
472   enum ISACBandwidth        bandwidthKHz;
473   // Sampling rate of audio, encoder and decode,  8 or 16 kHz
474   enum IsacSamplingRate encoderSamplingRateKHz;
475   enum IsacSamplingRate decoderSamplingRateKHz;
476   // Flag to keep track of initializations, lower & upper-band
477   // encoder and decoder.
478   int16_t               initFlag;
479 
480   // Flag to to indicate signal bandwidth switch
481   int16_t               resetFlag_8kHz;
482 
483   // Maximum allowed rate, measured in Bytes per 30 ms.
484   int16_t               maxRateBytesPer30Ms;
485   // Maximum allowed payload-size, measured in Bytes.
486   int16_t               maxPayloadSizeBytes;
487   /* The expected sampling rate of the input signal. Valid values are 16000
488    * and 32000. This is not the operation sampling rate of the codec. */
489   uint16_t in_sample_rate_hz;
490 
491   // Trig tables for WebRtcIsac_Time2Spec and WebRtcIsac_Spec2time.
492   TransformTables transform_tables;
493 } ISACMainStruct;
494 
495 #endif /* WEBRTC_MODULES_AUDIO_CODING_CODECS_ISAC_MAIN_SOURCE_STRUCTS_H_ */
496