FFmpeg  2.6.9
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
eac3dec.c
Go to the documentation of this file.
1 /*
2  * E-AC-3 decoder
3  * Copyright (c) 2007 Bartlomiej Wolowiec <bartek.wolowiec@gmail.com>
4  * Copyright (c) 2008 Justin Ruggles
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /*
24  * There are several features of E-AC-3 that this decoder does not yet support.
25  *
26  * Enhanced Coupling
27  * No known samples exist. If any ever surface, this feature should not be
28  * too difficult to implement.
29  *
30  * Reduced Sample Rates
31  * No known samples exist. The spec also does not give clear information
32  * on how this is to be implemented.
33  *
34  * Dependent Streams
35  * Only the independent stream is currently decoded. Any dependent
36  * streams are skipped. We have only come across two examples of this, and
37  * they are both just test streams, one for HD-DVD and the other for
38  * Blu-ray.
39  *
40  * Transient Pre-noise Processing
41  * This is side information which a decoder should use to reduce artifacts
42  * caused by transients. There are samples which are known to have this
43  * information, but this decoder currently ignores it.
44  */
45 
46 
47 #include "avcodec.h"
48 #include "internal.h"
49 #include "aac_ac3_parser.h"
50 #include "ac3.h"
51 #include "ac3_parser.h"
52 #include "ac3dec.h"
53 #include "ac3dec_data.h"
54 #include "eac3_data.h"
55 
56 /** gain adaptive quantization mode */
57 typedef enum {
62 } EAC3GaqMode;
63 
64 #define EAC3_SR_CODE_REDUCED 3
65 
67 {
68  int bin, bnd, ch, i;
69  uint8_t wrapflag[SPX_MAX_BANDS]={1,0,}, num_copy_sections, copy_sizes[SPX_MAX_BANDS];
70  float rms_energy[SPX_MAX_BANDS];
71 
72  /* Set copy index mapping table. Set wrap flags to apply a notch filter at
73  wrap points later on. */
74  bin = s->spx_dst_start_freq;
75  num_copy_sections = 0;
76  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
77  int copysize;
78  int bandsize = s->spx_band_sizes[bnd];
79  if (bin + bandsize > s->spx_src_start_freq) {
80  copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
81  bin = s->spx_dst_start_freq;
82  wrapflag[bnd] = 1;
83  }
84  for (i = 0; i < bandsize; i += copysize) {
85  if (bin == s->spx_src_start_freq) {
86  copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
87  bin = s->spx_dst_start_freq;
88  }
89  copysize = FFMIN(bandsize - i, s->spx_src_start_freq - bin);
90  bin += copysize;
91  }
92  }
93  copy_sizes[num_copy_sections++] = bin - s->spx_dst_start_freq;
94 
95  for (ch = 1; ch <= s->fbw_channels; ch++) {
96  if (!s->channel_uses_spx[ch])
97  continue;
98 
99  /* Copy coeffs from normal bands to extension bands */
100  bin = s->spx_src_start_freq;
101  for (i = 0; i < num_copy_sections; i++) {
102  memcpy(&s->transform_coeffs[ch][bin],
104  copy_sizes[i]*sizeof(INTFLOAT));
105  bin += copy_sizes[i];
106  }
107 
108  /* Calculate RMS energy for each SPX band. */
109  bin = s->spx_src_start_freq;
110  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
111  int bandsize = s->spx_band_sizes[bnd];
112  float accum = 0.0f;
113  for (i = 0; i < bandsize; i++) {
114  float coeff = s->transform_coeffs[ch][bin++];
115  accum += coeff * coeff;
116  }
117  rms_energy[bnd] = sqrtf(accum / bandsize);
118  }
119 
120  /* Apply a notch filter at transitions between normal and extension
121  bands and at all wrap points. */
122  if (s->spx_atten_code[ch] >= 0) {
123  const float *atten_tab = ff_eac3_spx_atten_tab[s->spx_atten_code[ch]];
124  bin = s->spx_src_start_freq - 2;
125  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
126  if (wrapflag[bnd]) {
127  INTFLOAT *coeffs = &s->transform_coeffs[ch][bin];
128  coeffs[0] *= atten_tab[0];
129  coeffs[1] *= atten_tab[1];
130  coeffs[2] *= atten_tab[2];
131  coeffs[3] *= atten_tab[1];
132  coeffs[4] *= atten_tab[0];
133  }
134  bin += s->spx_band_sizes[bnd];
135  }
136  }
137 
138  /* Apply noise-blended coefficient scaling based on previously
139  calculated RMS energy, blending factors, and SPX coordinates for
140  each band. */
141  bin = s->spx_src_start_freq;
142  for (bnd = 0; bnd < s->num_spx_bands; bnd++) {
143  float nscale = s->spx_noise_blend[ch][bnd] * rms_energy[bnd] * (1.0f / INT32_MIN);
144  float sscale = s->spx_signal_blend[ch][bnd];
145 #if USE_FIXED
146  // spx_noise_blend and spx_signal_blend are both FP.23
147  nscale *= 1.0 / (1<<23);
148  sscale *= 1.0 / (1<<23);
149 #endif
150  for (i = 0; i < s->spx_band_sizes[bnd]; i++) {
151  float noise = nscale * (int32_t)av_lfg_get(&s->dith_state);
152  s->transform_coeffs[ch][bin] *= sscale;
153  s->transform_coeffs[ch][bin++] += noise;
154  }
155  }
156  }
157 }
158 
159 
160 /** lrint(M_SQRT2*cos(2*M_PI/12)*(1<<23)) */
161 #define COEFF_0 10273905LL
162 
163 /** lrint(M_SQRT2*cos(0*M_PI/12)*(1<<23)) = lrint(M_SQRT2*(1<<23)) */
164 #define COEFF_1 11863283LL
165 
166 /** lrint(M_SQRT2*cos(5*M_PI/12)*(1<<23)) */
167 #define COEFF_2 3070444LL
168 
169 /**
170  * Calculate 6-point IDCT of the pre-mantissas.
171  * All calculations are 24-bit fixed-point.
172  */
173 static void idct6(int pre_mant[6])
174 {
175  int tmp;
176  int even0, even1, even2, odd0, odd1, odd2;
177 
178  odd1 = pre_mant[1] - pre_mant[3] - pre_mant[5];
179 
180  even2 = ( pre_mant[2] * COEFF_0) >> 23;
181  tmp = ( pre_mant[4] * COEFF_1) >> 23;
182  odd0 = ((pre_mant[1] + pre_mant[5]) * COEFF_2) >> 23;
183 
184  even0 = pre_mant[0] + (tmp >> 1);
185  even1 = pre_mant[0] - tmp;
186 
187  tmp = even0;
188  even0 = tmp + even2;
189  even2 = tmp - even2;
190 
191  tmp = odd0;
192  odd0 = tmp + pre_mant[1] + pre_mant[3];
193  odd2 = tmp + pre_mant[5] - pre_mant[3];
194 
195  pre_mant[0] = even0 + odd0;
196  pre_mant[1] = even1 + odd1;
197  pre_mant[2] = even2 + odd2;
198  pre_mant[3] = even2 - odd2;
199  pre_mant[4] = even1 - odd1;
200  pre_mant[5] = even0 - odd0;
201 }
202 
204 {
205  int bin, blk, gs;
206  int end_bap, gaq_mode;
207  GetBitContext *gbc = &s->gbc;
208  int gaq_gain[AC3_MAX_COEFS];
209 
210  gaq_mode = get_bits(gbc, 2);
211  end_bap = (gaq_mode < 2) ? 12 : 17;
212 
213  /* if GAQ gain is used, decode gain codes for bins with hebap between
214  8 and end_bap */
215  gs = 0;
216  if (gaq_mode == EAC3_GAQ_12 || gaq_mode == EAC3_GAQ_14) {
217  /* read 1-bit GAQ gain codes */
218  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
219  if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < end_bap)
220  gaq_gain[gs++] = get_bits1(gbc) << (gaq_mode-1);
221  }
222  } else if (gaq_mode == EAC3_GAQ_124) {
223  /* read 1.67-bit GAQ gain codes (3 codes in 5 bits) */
224  int gc = 2;
225  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
226  if (s->bap[ch][bin] > 7 && s->bap[ch][bin] < 17) {
227  if (gc++ == 2) {
228  int group_code = get_bits(gbc, 5);
229  if (group_code > 26) {
230  av_log(s->avctx, AV_LOG_WARNING, "GAQ gain group code out-of-range\n");
231  group_code = 26;
232  }
233  gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][0];
234  gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][1];
235  gaq_gain[gs++] = ff_ac3_ungroup_3_in_5_bits_tab[group_code][2];
236  gc = 0;
237  }
238  }
239  }
240  }
241 
242  gs=0;
243  for (bin = s->start_freq[ch]; bin < s->end_freq[ch]; bin++) {
244  int hebap = s->bap[ch][bin];
245  int bits = ff_eac3_bits_vs_hebap[hebap];
246  if (!hebap) {
247  /* zero-mantissa dithering */
248  for (blk = 0; blk < 6; blk++) {
249  s->pre_mantissa[ch][bin][blk] = (av_lfg_get(&s->dith_state) & 0x7FFFFF) - 0x400000;
250  }
251  } else if (hebap < 8) {
252  /* Vector Quantization */
253  int v = get_bits(gbc, bits);
254  for (blk = 0; blk < 6; blk++) {
255  s->pre_mantissa[ch][bin][blk] = ff_eac3_mantissa_vq[hebap][v][blk] << 8;
256  }
257  } else {
258  /* Gain Adaptive Quantization */
259  int gbits, log_gain;
260  if (gaq_mode != EAC3_GAQ_NO && hebap < end_bap) {
261  log_gain = gaq_gain[gs++];
262  } else {
263  log_gain = 0;
264  }
265  gbits = bits - log_gain;
266 
267  for (blk = 0; blk < 6; blk++) {
268  int mant = get_sbits(gbc, gbits);
269  if (log_gain && mant == -(1 << (gbits-1))) {
270  /* large mantissa */
271  int b;
272  int mbits = bits - (2 - log_gain);
273  mant = get_sbits(gbc, mbits);
274  mant <<= (23 - (mbits - 1));
275  /* remap mantissa value to correct for asymmetric quantization */
276  if (mant >= 0)
277  b = 1 << (23 - log_gain);
278  else
279  b = ff_eac3_gaq_remap_2_4_b[hebap-8][log_gain-1] << 8;
280  mant += ((ff_eac3_gaq_remap_2_4_a[hebap-8][log_gain-1] * (int64_t)mant) >> 15) + b;
281  } else {
282  /* small mantissa, no GAQ, or Gk=1 */
283  mant <<= 24 - bits;
284  if (!log_gain) {
285  /* remap mantissa value for no GAQ or Gk=1 */
286  mant += (ff_eac3_gaq_remap_1[hebap-8] * (int64_t)mant) >> 15;
287  }
288  }
289  s->pre_mantissa[ch][bin][blk] = mant;
290  }
291  }
292  idct6(s->pre_mantissa[ch][bin]);
293  }
294 }
295 
297 {
298  int i, blk, ch;
299  int ac3_exponent_strategy, parse_aht_info, parse_spx_atten_data;
300  int parse_transient_proc_info;
301  int num_cpl_blocks;
302  GetBitContext *gbc = &s->gbc;
303 
304  /* An E-AC-3 stream can have multiple independent streams which the
305  application can select from. each independent stream can also contain
306  dependent streams which are used to add or replace channels. */
308  avpriv_request_sample(s->avctx, "Dependent substream decoding");
310  } else if (s->frame_type == EAC3_FRAME_TYPE_RESERVED) {
311  av_log(s->avctx, AV_LOG_ERROR, "Reserved frame type\n");
313  }
314 
315  /* The substream id indicates which substream this frame belongs to. each
316  independent stream has its own substream id, and the dependent streams
317  associated to an independent stream have matching substream id's. */
318  if (s->substreamid) {
319  /* only decode substream with id=0. skip any additional substreams. */
320  avpriv_request_sample(s->avctx, "Additional substreams");
322  }
323 
325  /* The E-AC-3 specification does not tell how to handle reduced sample
326  rates in bit allocation. The best assumption would be that it is
327  handled like AC-3 DolbyNet, but we cannot be sure until we have a
328  sample which utilizes this feature. */
329  avpriv_request_sample(s->avctx, "Reduced sampling rate");
330  return AVERROR_PATCHWELCOME;
331  }
332  skip_bits(gbc, 5); // skip bitstream id
333 
334  /* volume control params */
335  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
336  skip_bits(gbc, 5); // skip dialog normalization
337  if (get_bits1(gbc)) {
338  skip_bits(gbc, 8); // skip compression gain word
339  }
340  }
341 
342  /* dependent stream channel map */
344  if (get_bits1(gbc)) {
345  skip_bits(gbc, 16); // skip custom channel map
346  }
347  }
348 
349  /* mixing metadata */
350  if (get_bits1(gbc)) {
351  /* center and surround mix levels */
352  if (s->channel_mode > AC3_CHMODE_STEREO) {
353  s->preferred_downmix = get_bits(gbc, 2);
354  if (s->channel_mode & 1) {
355  /* if three front channels exist */
356  s->center_mix_level_ltrt = get_bits(gbc, 3);
357  s->center_mix_level = get_bits(gbc, 3);
358  }
359  if (s->channel_mode & 4) {
360  /* if a surround channel exists */
361  s->surround_mix_level_ltrt = av_clip(get_bits(gbc, 3), 3, 7);
362  s->surround_mix_level = av_clip(get_bits(gbc, 3), 3, 7);
363  }
364  }
365 
366  /* lfe mix level */
367  if (s->lfe_on && (s->lfe_mix_level_exists = get_bits1(gbc))) {
368  s->lfe_mix_level = get_bits(gbc, 5);
369  }
370 
371  /* info for mixing with other streams and substreams */
373  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
374  // TODO: apply program scale factor
375  if (get_bits1(gbc)) {
376  skip_bits(gbc, 6); // skip program scale factor
377  }
378  }
379  if (get_bits1(gbc)) {
380  skip_bits(gbc, 6); // skip external program scale factor
381  }
382  /* skip mixing parameter data */
383  switch(get_bits(gbc, 2)) {
384  case 1: skip_bits(gbc, 5); break;
385  case 2: skip_bits(gbc, 12); break;
386  case 3: {
387  int mix_data_size = (get_bits(gbc, 5) + 2) << 3;
388  skip_bits_long(gbc, mix_data_size);
389  break;
390  }
391  }
392  /* skip pan information for mono or dual mono source */
393  if (s->channel_mode < AC3_CHMODE_STEREO) {
394  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
395  if (get_bits1(gbc)) {
396  /* note: this is not in the ATSC A/52B specification
397  reference: ETSI TS 102 366 V1.1.1
398  section: E.1.3.1.25 */
399  skip_bits(gbc, 8); // skip pan mean direction index
400  skip_bits(gbc, 6); // skip reserved paninfo bits
401  }
402  }
403  }
404  /* skip mixing configuration information */
405  if (get_bits1(gbc)) {
406  for (blk = 0; blk < s->num_blocks; blk++) {
407  if (s->num_blocks == 1 || get_bits1(gbc)) {
408  skip_bits(gbc, 5);
409  }
410  }
411  }
412  }
413  }
414 
415  /* informational metadata */
416  if (get_bits1(gbc)) {
417  s->bitstream_mode = get_bits(gbc, 3);
418  skip_bits(gbc, 2); // skip copyright bit and original bitstream bit
419  if (s->channel_mode == AC3_CHMODE_STEREO) {
420  s->dolby_surround_mode = get_bits(gbc, 2);
421  s->dolby_headphone_mode = get_bits(gbc, 2);
422  }
423  if (s->channel_mode >= AC3_CHMODE_2F2R) {
424  s->dolby_surround_ex_mode = get_bits(gbc, 2);
425  }
426  for (i = 0; i < (s->channel_mode ? 1 : 2); i++) {
427  if (get_bits1(gbc)) {
428  skip_bits(gbc, 8); // skip mix level, room type, and A/D converter type
429  }
430  }
432  skip_bits1(gbc); // skip source sample rate code
433  }
434  }
435 
436  /* converter synchronization flag
437  If frames are less than six blocks, this bit should be turned on
438  once every 6 blocks to indicate the start of a frame set.
439  reference: RFC 4598, Section 2.1.3 Frame Sets */
440  if (s->frame_type == EAC3_FRAME_TYPE_INDEPENDENT && s->num_blocks != 6) {
441  skip_bits1(gbc); // skip converter synchronization flag
442  }
443 
444  /* original frame size code if this stream was converted from AC-3 */
446  (s->num_blocks == 6 || get_bits1(gbc))) {
447  skip_bits(gbc, 6); // skip frame size code
448  }
449 
450  /* additional bitstream info */
451  if (get_bits1(gbc)) {
452  int addbsil = get_bits(gbc, 6);
453  for (i = 0; i < addbsil + 1; i++) {
454  skip_bits(gbc, 8); // skip additional bit stream info
455  }
456  }
457 
458  /* audio frame syntax flags, strategy data, and per-frame data */
459 
460  if (s->num_blocks == 6) {
461  ac3_exponent_strategy = get_bits1(gbc);
462  parse_aht_info = get_bits1(gbc);
463  } else {
464  /* less than 6 blocks, so use AC-3-style exponent strategy syntax, and
465  do not use AHT */
466  ac3_exponent_strategy = 1;
467  parse_aht_info = 0;
468  }
469 
470  s->snr_offset_strategy = get_bits(gbc, 2);
471  parse_transient_proc_info = get_bits1(gbc);
472 
473  s->block_switch_syntax = get_bits1(gbc);
474  if (!s->block_switch_syntax)
475  memset(s->block_switch, 0, sizeof(s->block_switch));
476 
477  s->dither_flag_syntax = get_bits1(gbc);
478  if (!s->dither_flag_syntax) {
479  for (ch = 1; ch <= s->fbw_channels; ch++)
480  s->dither_flag[ch] = 1;
481  }
482  s->dither_flag[CPL_CH] = s->dither_flag[s->lfe_ch] = 0;
483 
485  if (!s->bit_allocation_syntax) {
486  /* set default bit allocation parameters */
492  }
493 
494  s->fast_gain_syntax = get_bits1(gbc);
495  s->dba_syntax = get_bits1(gbc);
496  s->skip_syntax = get_bits1(gbc);
497  parse_spx_atten_data = get_bits1(gbc);
498 
499  /* coupling strategy occurrence and coupling use per block */
500  num_cpl_blocks = 0;
501  if (s->channel_mode > 1) {
502  for (blk = 0; blk < s->num_blocks; blk++) {
503  s->cpl_strategy_exists[blk] = (!blk || get_bits1(gbc));
504  if (s->cpl_strategy_exists[blk]) {
505  s->cpl_in_use[blk] = get_bits1(gbc);
506  } else {
507  s->cpl_in_use[blk] = s->cpl_in_use[blk-1];
508  }
509  num_cpl_blocks += s->cpl_in_use[blk];
510  }
511  } else {
512  memset(s->cpl_in_use, 0, sizeof(s->cpl_in_use));
513  }
514 
515  /* exponent strategy data */
516  if (ac3_exponent_strategy) {
517  /* AC-3-style exponent strategy syntax */
518  for (blk = 0; blk < s->num_blocks; blk++) {
519  for (ch = !s->cpl_in_use[blk]; ch <= s->fbw_channels; ch++) {
520  s->exp_strategy[blk][ch] = get_bits(gbc, 2);
521  }
522  }
523  } else {
524  /* LUT-based exponent strategy syntax */
525  for (ch = !((s->channel_mode > 1) && num_cpl_blocks); ch <= s->fbw_channels; ch++) {
526  int frmchexpstr = get_bits(gbc, 5);
527  for (blk = 0; blk < 6; blk++) {
528  s->exp_strategy[blk][ch] = ff_eac3_frm_expstr[frmchexpstr][blk];
529  }
530  }
531  }
532  /* LFE exponent strategy */
533  if (s->lfe_on) {
534  for (blk = 0; blk < s->num_blocks; blk++) {
535  s->exp_strategy[blk][s->lfe_ch] = get_bits1(gbc);
536  }
537  }
538  /* original exponent strategies if this stream was converted from AC-3 */
540  (s->num_blocks == 6 || get_bits1(gbc))) {
541  skip_bits(gbc, 5 * s->fbw_channels); // skip converter channel exponent strategy
542  }
543 
544  /* determine which channels use AHT */
545  if (parse_aht_info) {
546  /* For AHT to be used, all non-zero blocks must reuse exponents from
547  the first block. Furthermore, for AHT to be used in the coupling
548  channel, all blocks must use coupling and use the same coupling
549  strategy. */
550  s->channel_uses_aht[CPL_CH]=0;
551  for (ch = (num_cpl_blocks != 6); ch <= s->channels; ch++) {
552  int use_aht = 1;
553  for (blk = 1; blk < 6; blk++) {
554  if ((s->exp_strategy[blk][ch] != EXP_REUSE) ||
555  (!ch && s->cpl_strategy_exists[blk])) {
556  use_aht = 0;
557  break;
558  }
559  }
560  s->channel_uses_aht[ch] = use_aht && get_bits1(gbc);
561  }
562  } else {
563  memset(s->channel_uses_aht, 0, sizeof(s->channel_uses_aht));
564  }
565 
566  /* per-frame SNR offset */
567  if (!s->snr_offset_strategy) {
568  int csnroffst = (get_bits(gbc, 6) - 15) << 4;
569  int snroffst = (csnroffst + get_bits(gbc, 4)) << 2;
570  for (ch = 0; ch <= s->channels; ch++)
571  s->snr_offset[ch] = snroffst;
572  }
573 
574  /* transient pre-noise processing data */
575  if (parse_transient_proc_info) {
576  for (ch = 1; ch <= s->fbw_channels; ch++) {
577  if (get_bits1(gbc)) { // channel in transient processing
578  skip_bits(gbc, 10); // skip transient processing location
579  skip_bits(gbc, 8); // skip transient processing length
580  }
581  }
582  }
583 
584  /* spectral extension attenuation data */
585  for (ch = 1; ch <= s->fbw_channels; ch++) {
586  if (parse_spx_atten_data && get_bits1(gbc)) {
587  s->spx_atten_code[ch] = get_bits(gbc, 5);
588  } else {
589  s->spx_atten_code[ch] = -1;
590  }
591  }
592 
593  /* block start information */
594  if (s->num_blocks > 1 && get_bits1(gbc)) {
595  /* reference: Section E2.3.2.27
596  nblkstrtbits = (numblks - 1) * (4 + ceiling(log2(words_per_frame)))
597  The spec does not say what this data is or what it's used for.
598  It is likely the offset of each block within the frame. */
599  int block_start_bits = (s->num_blocks-1) * (4 + av_log2(s->frame_size-2));
600  skip_bits_long(gbc, block_start_bits);
601  avpriv_request_sample(s->avctx, "Block start info");
602  }
603 
604  /* syntax state initialization */
605  for (ch = 1; ch <= s->fbw_channels; ch++) {
606  s->first_spx_coords[ch] = 1;
607  s->first_cpl_coords[ch] = 1;
608  }
609  s->first_cpl_leak = 1;
610 
611  return 0;
612 }