text: /*
   * SpanDSP - a series of DSP components for telephony
   *
   * data_modems.c - the analogue modem set for data processing
   *
   * Written by Steve Underwood <steveu@coppice.org>
   *
   * Copyright (C) 2003, 2005, 2006, 2008, 2011, 2013 Steve Underwood
   *
   * All rights reserved.
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License version 2.1,
   * as published by the Free Software Foundation.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this program; if not, write to the Free Software
   * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   */
  
  /*! \file */
  
  #if defined(HAVE_CONFIG_H)
  #include "config.h"
  #endif
  
  #include <inttypes.h>
  #include <stdlib.h>
  #include <stdio.h>
  #include <string.h>
  #if defined(HAVE_TGMATH_H)
  #include <tgmath.h>
  #endif
  #if defined(HAVE_MATH_H)
  #include <math.h>
  #endif
  #if defined(HAVE_STDBOOL_H)
  #include <stdbool.h>
  #else
  #include "spandsp/stdbool.h"
  #endif
  #include "floating_fudge.h"
  #include <assert.h>
  #include <fcntl.h>
  #include <time.h>
  #if defined(LOG_FAX_AUDIO)
  #include <unistd.h>
  #endif
  
  #include "spandsp/telephony.h"
  #include "spandsp/alloc.h"
  #include "spandsp/logging.h"
  #include "spandsp/bit_operations.h"
  #include "spandsp/dc_restore.h"
  #include "spandsp/queue.h"
  #include "spandsp/power_meter.h"
  #include "spandsp/complex.h"
  #include "spandsp/tone_detect.h"
  #include "spandsp/tone_generate.h"
  #include "spandsp/async.h"
  #include "spandsp/silence_gen.h"
  #include "spandsp/fsk.h"
  #include "spandsp/v29rx.h"
  #include "spandsp/v22bis.h"
  #if defined(SPANDSP_SUPPORT_V32BIS)
  #include "spandsp/v17tx.h"
  #include "spandsp/v17rx.h"
  #include "spandsp/modem_echo.h"
  #include "spandsp/v32bis.h"
  #endif
  #if defined(SPANDSP_SUPPORT_V34)
  #include "spandsp/bitstream.h"
  #include "spandsp/v34.h"
  #endif
  #include "spandsp/super_tone_rx.h"
  #include "spandsp/modem_connect_tones.h"
  #include "spandsp/hdlc.h"
  #include "spandsp/v42.h"
  #include "spandsp/v42bis.h"
  #include "spandsp/v8.h"
  #include "spandsp/data_modems.h"
  
  #include "spandsp/private/logging.h"
  #include "spandsp/private/silence_gen.h"
  #include "spandsp/private/power_meter.h"
  #include "spandsp/private/fsk.h"
  #include "spandsp/private/v22bis.h"
  #if defined(SPANDSP_SUPPORT_V32BIS)
  #include "spandsp/private/v17tx.h"
  #include "spandsp/private/v17rx.h"
  #include "spandsp/private/modem_echo.h"
  #include "spandsp/private/v32bis.h"
  #endif
  #if defined(SPANDSP_SUPPORT_V34)
  #include "spandsp/private/bitstream.h"
  #include "spandsp/private/v34.h"
  #endif
  #include "spandsp/private/modem_connect_tones.h"
  #include "spandsp/private/hdlc.h"
  #include "spandsp/private/v42.h"
  #include "spandsp/private/v42bis.h"
  #include "spandsp/private/v8.h"
  #include "spandsp/private/async.h"
  #include "spandsp/private/data_modems.h"
  
  SPAN_DECLARE(const char *) data_modems_modulation_to_str(int modulation_scheme)
  {
      switch (modulation_scheme)
      {
      case DATA_MODEM_NONE:
          return "None";
      case DATA_MODEM_FLUSH:
          return "Flush";
      case DATA_MODEM_SILENCE:
          return "Silence";
      case DATA_MODEM_CED_TONE:
          return "CED";
      case DATA_MODEM_CNG_TONE:
          return "CNG";
      case DATA_MODEM_V8:
          return "V.8";
      case DATA_MODEM_BELL103:
          return "B103 duplex";
      case DATA_MODEM_BELL202:
          return "B202 duplex";
      case DATA_MODEM_V21:
          return "V.21 duplex";
      case DATA_MODEM_V23:
          return "V.23 duplex";
      case DATA_MODEM_V22BIS:
          return "V.22/V.22bis duplex";
      case DATA_MODEM_V32BIS:
          return "V.32/V.32bis duplex";
      case DATA_MODEM_V34:
          return "V.34 duplex";
      }
      return "???";
  }
  /*- End of function --------------------------------------------------------*/
  
  SPAN_DECLARE(logging_state_t *) data_modems_get_logging_state(data_modems_state_t *s)
  {
      return &s->logging;
  }
  /*- End of function --------------------------------------------------------*/
  
  static int async_get_byte(void *user_data)
  {
      data_modems_state_t *s;
      uint8_t msg[1];
  
      s = (data_modems_state_t *) user_data;
      s->get_msg(s->user_data, msg, 1);
      return msg[0];
  }
  /*- End of function --------------------------------------------------------*/
  
  static void async_put_byte(void *user_data, int byte)
  {
      data_modems_state_t *s;
      uint8_t msg[1];
  
      s = (data_modems_state_t *) user_data;
      msg[0] = byte;
      if (byte < 0)
          s->put_msg(s->user_data,  msg, byte);
      s->put_msg(s->user_data,  msg, 1);
  }
  /*- End of function --------------------------------------------------------*/
  
  static void tone_callback(void *user_data, int tone, int level, int delay)
  {
      printf("%s declared (%ddBm0)\n", modem_connect_tone_to_str(tone), level);
  }
  /*- End of function --------------------------------------------------------*/
  
  static void log_supported_modulations(data_modems_state_t *s, int modulation_schemes)
  {
      const char *comma;
      int i;
  
      comma = "";
      span_log(&s->logging, SPAN_LOG_FLOW, "    ");
      for (i = 0;  i < 32;  i++)
      {
          if ((modulation_schemes & (1 << i)))
          {
              span_log(&s->logging, SPAN_LOG_FLOW | SPAN_LOG_SUPPRESS_LABELLING, "%s%s", comma, v8_modulation_to_str(modulation_schemes & (1 << i)));
              comma = ", ";
          }
      }
      span_log(&s->logging, SPAN_LOG_FLOW | SPAN_LOG_SUPPRESS_LABELLING, " supported\n");
  }
  /*- End of function --------------------------------------------------------*/
  
  static void v8_handler(void *user_data, v8_parms_t *result)
  {
      data_modems_state_t *s;
  
      s = (data_modems_state_t *) user_data;
      switch (result->status)
      {
      case V8_STATUS_IN_PROGRESS:
          span_log(&s->logging, SPAN_LOG_FLOW, "V.8 negotiation in progress\n");
          return;
      case V8_STATUS_V8_OFFERED:
          span_log(&s->logging, SPAN_LOG_FLOW, "V.8 offered by the other party\n");
          break;
      case V8_STATUS_V8_CALL:
          span_log(&s->logging, SPAN_LOG_FLOW, "V.8 call negotiation successful\n");
          break;
      case V8_STATUS_NON_V8_CALL:
          span_log(&s->logging, SPAN_LOG_FLOW, "Non-V.8 call negotiation successful\n");
          break;
      case V8_STATUS_FAILED:
          span_log(&s->logging, SPAN_LOG_FLOW, "V.8 call negotiation failed\n");
          return;
      default:
          span_log(&s->logging, SPAN_LOG_FLOW, "Unexpected V.8 status %d\n", result->status);
          break;
      }
      /*endswitch*/
  
      span_log(&s->logging, SPAN_LOG_FLOW, "  Modem connect tone '%s' (%d)\n", modem_connect_tone_to_str(result->modem_connect_tone), result->modem_connect_tone);
      span_log(&s->logging, SPAN_LOG_FLOW, "  Call function '%s' (%d)\n", v8_call_function_to_str(result->call_function), result->call_function);
      span_log(&s->logging, SPAN_LOG_FLOW, "  Far end modulations 0x%X\n", result->modulations);
      log_supported_modulations(s, result->modulations);
      span_log(&s->logging, SPAN_LOG_FLOW, "  Protocol '%s' (%d)\n", v8_protocol_to_str(result->protocol), result->protocol);
      span_log(&s->logging, SPAN_LOG_FLOW, "  PSTN access '%s' (%d)\n", v8_pstn_access_to_str(result->pstn_access), result->pstn_access);
      span_log(&s->logging, SPAN_LOG_FLOW, "  PCM modem availability '%s' (%d)\n", v8_pcm_modem_availability_to_str(result->pcm_modem_availability), result->pcm_modem_availability);
      if (result->t66 >= 0)
          span_log(&s->logging, SPAN_LOG_FLOW, "  T.66 '%s' (%d)\n", v8_t66_to_str(result->t66), result->t66);
      /*endif*/
      if (result->nsf >= 0)
          span_log(&s->logging, SPAN_LOG_FLOW, "  NSF %d\n", result->nsf);
      /*endif*/
  
      switch (result->status)
      {
      case V8_STATUS_V8_OFFERED:
          /* V.8 mode has been offered. */
          span_log(&s->logging, SPAN_LOG_FLOW, "  Offered\n");
          /* We now need to edit the offered list of usable modem modulations to reflect
             the set of modulations both ends share */
          //result->call_function = V8_CALL_T30_TX;
          result->modulations &= (V8_MOD_V21
                                | V8_MOD_V22
                                | V8_MOD_V23HDX
                                | V8_MOD_V23
  #if defined(SPANDSP_SUPPORT_V32BIS)
                                | V8_MOD_V32
  #endif
  #if defined(SPANDSP_SUPPORT_V34)
                                | V8_MOD_V34
  #endif
                                | 0);
          span_log(&s->logging, SPAN_LOG_FLOW, "  Mutual modulations 0x%X\n", result->modulations);
          log_supported_modulations(s, result->modulations);
          break;
      case V8_STATUS_V8_CALL:
          span_log(&s->logging, SPAN_LOG_FLOW, "  Call\n");
          if (result->call_function == V8_CALL_V_SERIES)
          {
              /* Negotiations OK */
              if (result->protocol == V8_PROTOCOL_LAPM_V42)
              {
              }
              /*endif*/
  
  #if defined(SPANDSP_SUPPORT_V34)
              if ((result->modulations & V8_MOD_V34))
              {
                  s->queued_baud_rate = 2400;
                  s->queued_bit_rate = 28800;
                  s->queued_modem = DATA_MODEM_V34;
              }
              else
  #endif
  #if defined(SPANDSP_SUPPORT_V32BIS)
              if ((result->modulations & V8_MOD_V32))
              {
                  s->queued_baud_rate = 2400;
                  s->queued_bit_rate = 14400;
                  s->queued_modem = DATA_MODEM_V32BIS;
              }
              else
  #endif
              if ((result->modulations & V8_MOD_V22))
              {
                  s->queued_baud_rate = 600;
                  s->queued_bit_rate = 2400;
                  s->queued_modem = DATA_MODEM_V22BIS;
              }
              else if ((result->modulations & V8_MOD_V21))
              {
                  s->queued_baud_rate = 300;
                  s->queued_bit_rate = 300;
                  s->queued_modem = DATA_MODEM_V21;
              }
              else
              {
                  s->queued_modem = DATA_MODEM_NONE;
              }
              /*endif*/
              span_log(&s->logging, SPAN_LOG_FLOW, "  Negotiated modulation '%s' %d\n", data_modems_modulation_to_str(s->queued_modem), s->queued_modem);
          }
          /*endif*/
          break;
      case V8_STATUS_NON_V8_CALL:
          span_log(&s->logging, SPAN_LOG_FLOW, "  Non-V.8 call\n");
          s->queued_modem = DATA_MODEM_V22BIS;
          break;
      default:
          span_log(&s->logging, SPAN_LOG_FLOW, "  Huh? %d\n", result->status);
          break;
      }
      /*endswitch*/
  }
  /*- End of function --------------------------------------------------------*/
  
  SPAN_DECLARE(void) data_modems_set_async_mode(data_modems_state_t *s,
                                                int data_bits,
                                                int parity_bit,
                                                int stop_bits)
  {
      async_tx_init(&s->async_tx,
                    data_bits,
                    parity_bit,
                    stop_bits,
                    s->use_v14,
                    &async_get_byte,
                    s);
      async_rx_init(&s->async_rx,
                    data_bits,
                    parity_bit,
                    stop_bits,
                    s->use_v14,
                    &async_put_byte,
                    s);
  }
  /*- End of function --------------------------------------------------------*/
  
  SPAN_DECLARE(void) data_modems_set_modem_type(data_modems_state_t *s, int which, int baud_rate, int bit_rate)
  {
      const fsk_spec_t *fsk_rx_spec;
      const fsk_spec_t *fsk_tx_spec;
      v8_parms_t v8_parms;
      logging_state_t *logging;
      int level;
  
      switch (which)
      {
      case DATA_MODEM_SILENCE:
          s->rx_handler = (span_rx_handler_t) &span_dummy_rx;
          s->rx_fillin_handler = (span_rx_fillin_handler_t) &span_dummy_rx_fillin;
          s->rx_user_data = NULL;
          s->tx_handler = (span_tx_handler_t) &silence_gen;
          s->tx_user_data = &s->modems.silence_gen;
          silence_gen_init(&s->modems.silence_gen, 0);
          break;
      case DATA_MODEM_CNG_TONE:
          s->rx_handler = (span_rx_handler_t) &modem_connect_tones_rx;
          s->rx_fillin_handler = (span_rx_fillin_handler_t) &span_dummy_rx_fillin;
          s->rx_user_data = &s->modems.tones.rx;
          s->tx_handler = (span_tx_handler_t) &modem_connect_tones_tx;
          s->tx_user_data = &s->modems.tones.tx;
          modem_connect_tones_rx_init(&s->modems.tones.rx,
                                      MODEM_CONNECT_TONES_FAX_CNG,
                                      tone_callback,
                                      s);
          modem_connect_tones_tx_init(&s->modems.tones.tx, MODEM_CONNECT_TONES_FAX_CNG);
          break;
      case DATA_MODEM_V8:
          s->rx_handler = (span_rx_handler_t) &v8_rx;
          s->rx_fillin_handler = (span_rx_fillin_handler_t) &span_dummy_rx_fillin;
          s->rx_user_data = &s->modems.v8;
          s->tx_handler = (span_tx_handler_t) &v8_tx;
          s->tx_user_data = &s->modems.v8;
          if (s->calling_party)
              v8_parms.modem_connect_tone = MODEM_CONNECT_TONES_NONE;
          else
              v8_parms.modem_connect_tone = MODEM_CONNECT_TONES_ANSAM_PR;
          v8_parms.send_ci = false;
          v8_parms.v92 = -1;
          v8_parms.call_function = V8_CALL_V_SERIES;
  #if 0
          v8_parms.modulations = V8_MOD_V17
                               | V8_MOD_V21
                               | V8_MOD_V22
                               | V8_MOD_V23HDX
                               | V8_MOD_V23
                               | V8_MOD_V27TER
                               | V8_MOD_V29
                               | 0;
          v8_parms.protocol = V8_PROTOCOL_LAPM_V42;
  #elif 1
          v8_parms.modulations = V8_MOD_V21
                               | V8_MOD_V22
                               | V8_MOD_V23HDX
                               | V8_MOD_V23
  #if defined(SPANDSP_SUPPORT_V32BIS)
                               | V8_MOD_V32
  #endif
  #if defined(SPANDSP_SUPPORT_V34)
                               | V8_MOD_V34
  #endif
                               | 0;
          v8_parms.protocol = V8_PROTOCOL_LAPM_V42;
  #endif
          v8_parms.pcm_modem_availability = 0;
          v8_parms.pstn_access = 0;
          v8_parms.nsf = -1;
          v8_parms.t66 = -1;
          v8_init(&s->modems.v8, s->calling_party, &v8_parms, v8_handler, (void *) s);
      logging = v8_get_logging_state(&s->modems.v8);
      level = span_log_get_level(&s->logging);
      span_log_set_level(logging, level);
      span_log_set_tag(logging, "V.8");
          break;
      case DATA_MODEM_BELL103:
          s->rx_handler = (span_rx_handler_t) &fsk_rx;
          s->rx_fillin_handler = (span_rx_fillin_handler_t) &fsk_rx_fillin;
          s->rx_user_data = &s->modems.fsk.rx;
          s->tx_handler = (span_tx_handler_t) &fsk_tx;
          s->tx_user_data = &s->modems.fsk.tx;
          if (s->calling_party)
          {
              fsk_rx_spec = &preset_fsk_specs[FSK_BELL103CH2];
              fsk_tx_spec = &preset_fsk_specs[FSK_BELL103CH1];
          }
          else
          {
              fsk_rx_spec = &preset_fsk_specs[FSK_BELL103CH1];
              fsk_tx_spec = &preset_fsk_specs[FSK_BELL103CH2];
          }
          fsk_rx_init(&s->modems.fsk.rx, fsk_rx_spec, FSK_FRAME_MODE_SYNC, s->put_bit, s->put_user_data);
          fsk_tx_init(&s->modems.fsk.tx, fsk_tx_spec, s->get_bit, s->get_user_data);
          break;
      case DATA_MODEM_V21:
          s->rx_handler = (span_rx_handler_t) &fsk_rx;
          s->rx_fillin_handler = (span_rx_fillin_handler_t) &fsk_rx_fillin;
          s->rx_user_data = &s->modems.fsk.rx;
          s->tx_handler = (span_tx_handler_t) &fsk_tx;
          s->tx_user_data = &s->modems.fsk.tx;
          if (s->calling_party)
          {
              fsk_rx_spec = &preset_fsk_specs[FSK_V21CH2];
              fsk_tx_spec = &preset_fsk_specs[FSK_V21CH1];
          }
          else
          {
              fsk_rx_spec = &preset_fsk_specs[FSK_V21CH1];
              fsk_tx_spec = &preset_fsk_specs[FSK_V21CH2];
          }
          fsk_rx_init(&s->modems.fsk.rx, fsk_rx_spec, FSK_FRAME_MODE_SYNC, s->put_bit, s->put_user_data);
          fsk_tx_init(&s->modems.fsk.tx, fsk_tx_spec, s->get_bit, s->get_user_data);
          break;
      case DATA_MODEM_BELL202:
          s->rx_handler = (span_rx_handler_t) &fsk_rx;
          s->rx_fillin_handler = (span_rx_fillin_handler_t) &fsk_rx_fillin;
          s->rx_user_data = &s->modems.fsk.rx;
          s->tx_handler = (span_tx_handler_t) &fsk_tx;
          s->tx_user_data = &s->modems.fsk.tx;
          fsk_rx_spec = &preset_fsk_specs[FSK_BELL202];
          fsk_tx_spec = &preset_fsk_specs[FSK_BELL202];
          fsk_rx_init(&s->modems.fsk.rx, fsk_rx_spec, FSK_FRAME_MODE_SYNC, s->put_bit, s->put_user_data);
          fsk_tx_init(&s->modems.fsk.tx, fsk_tx_spec, s->get_bit, s->get_user_data);
          break;
      case DATA_MODEM_V23:
          s->rx_handler = (span_rx_handler_t) &fsk_rx;
          s->rx_fillin_handler = (span_rx_fillin_handler_t) &fsk_rx_fillin;
          s->rx_user_data = &s->modems.fsk.rx;
          s->tx_handler = (span_tx_handler_t) &fsk_tx;
          s->tx_user_data = &s->modems.fsk.tx;
          if (s->calling_party)
          {
              fsk_rx_spec = &preset_fsk_specs[FSK_V23CH2];
              fsk_tx_spec = &preset_fsk_specs[FSK_V23CH1];
          }
          else
          {
              fsk_rx_spec = &preset_fsk_specs[FSK_V23CH1];
              fsk_tx_spec = &preset_fsk_specs[FSK_V23CH2];
          }
          fsk_rx_init(&s->modems.fsk.rx, fsk_rx_spec, FSK_FRAME_MODE_SYNC, s->put_bit, s->put_user_data);
          fsk_tx_init(&s->modems.fsk.tx, fsk_tx_spec, s->get_bit, s->get_user_data);
          break;
      case DATA_MODEM_V22BIS:
          s->rx_handler = (span_rx_handler_t) &v22bis_rx;
          s->rx_fillin_handler = (span_rx_fillin_handler_t) &v22bis_rx_fillin;
          s->rx_user_data = &s->modems.v22bis;
          s->tx_handler = (span_tx_handler_t) &v22bis_tx;
          s->tx_user_data = &s->modems.v22bis;
          v22bis_init(&s->modems.v22bis, bit_rate, 0, s->calling_party, s->get_bit, s->get_user_data, s->put_bit, s->put_user_data);
      logging = v22bis_get_logging_state(&s->modems.v22bis);
      level = span_log_get_level(&s->logging);
      span_log_set_level(logging, level);
      span_log_set_tag(logging, "V.22bis");
          break;
  #if defined(SPANDSP_SUPPORT_V32BIS)
      case DATA_MODEM_V32BIS:
          s->rx_handler = (span_rx_handler_t) &v32bis_rx;
          s->rx_fillin_handler = (span_rx_fillin_handler_t) &v32bis_rx_fillin;
          s->rx_user_data = &s->modems.v32bis;
          s->tx_handler = (span_tx_handler_t) &v32bis_tx;
          s->tx_user_data = &s->modems.v32bis;
          v32bis_init(&s->modems.v32bis, bit_rate, s->calling_party, s->get_bit, s->get_user_data, s->put_bit, s->put_user_data);
      logging = v32bis_get_logging_state(&s->modems.v32bis);
      level = span_log_get_level(&s->logging);
      span_log_set_level(logging, level);
      span_log_set_tag(logging, "V.32bis");
          break;
  #endif
  #if defined(SPANDSP_SUPPORT_V34)
      case DATA_MODEM_V34:
          s->rx_handler = (span_rx_handler_t) &v34_rx;
          s->rx_fillin_handler = (span_rx_fillin_handler_t) &v34_rx_fillin;
          s->rx_user_data = &s->modems.v34;
          s->tx_handler = (span_tx_handler_t) &v34_tx;
          s->tx_user_data = &s->modems.v34;
          v34_init(&s->modems.v34, baud_rate, bit_rate, s->calling_party, true, s->get_bit, s->get_user_data, s->put_bit, s->put_user_data);
      logging = v34_get_logging_state(&s->modems.v34);
      level = span_log_get_level(&s->logging);
      span_log_set_level(logging, level);
      span_log_set_tag(logging, "V.34");
          break;
  #endif
      }
      s->current_modem = which;
  }
  /*- End of function --------------------------------------------------------*/
  
  SPAN_DECLARE(int) data_modems_rx(data_modems_state_t *s, const int16_t amp[], int len)
  {
      int res;
  
      if (s->rx_handler == NULL)
          return len;
      res = s->rx_handler(s->rx_user_data, amp, len);
      if (s->current_modem != s->queued_modem)
          data_modems_set_modem_type(s, s->queued_modem, s->queued_baud_rate, s->queued_bit_rate);
      return res;
  }
  /*- End of function --------------------------------------------------------*/
  
  SPAN_DECLARE(int) data_modems_rx_fillin(data_modems_state_t *s, int len)
  {
      if (s->rx_fillin_handler == NULL)
          return len;
      return s->rx_fillin_handler(s->rx_user_data, len);
  }
  /*- End of function --------------------------------------------------------*/
  
  SPAN_DECLARE(int) data_modems_tx(data_modems_state_t *s, int16_t amp[], int max_len)
  {
      int len;
  
      for (len = 0;  len < max_len;  )
      {
          if (s->tx_handler == NULL)
              break;
          len += s->tx_handler(s->tx_user_data, &amp[len], max_len - len);
      }
      return len;
  }
  /*- End of function --------------------------------------------------------*/
  
  SPAN_DECLARE(int) data_modems_restart(data_modems_state_t *s)
  {
      return 0;
  }
  /*- End of function --------------------------------------------------------*/
  
  SPAN_DECLARE(data_modems_state_t *) data_modems_init(data_modems_state_t *s,
                                                       bool calling_party,
                                                       put_msg_func_t put_msg,
                                                       get_msg_func_t get_msg,
                                                       void *user_data)
  {
      if (s == NULL)
      {
          if ((s = (data_modems_state_t *) span_alloc(sizeof(*s))) == NULL)
              return NULL;
      }
      memset(s, 0, sizeof(*s));
      span_log_init(&s->logging, SPAN_LOG_NONE, NULL);
      span_log_set_protocol(&s->logging, "Modem");
  
      dc_restore_init(&s->dc_restore);
  
      s->put_msg = put_msg;
      s->get_msg = get_msg;
      s->user_data = user_data;
  
      v42bis_init(&s->v42bis, 3, 512, 6, NULL, s, 512, put_msg, s, 512);
      v42_init(&s->v42, true, true, NULL, (put_msg_func_t) v42bis_decompress, &s->v42bis);
  
      data_modems_set_async_mode(s, 8, 1, 1);
  
      s->get_bit = async_tx_get_bit;
      s->get_user_data = &s->async_tx;
      s->put_bit = async_rx_put_bit;
      s->put_user_data = &s->async_rx;
  
      s->calling_party = calling_party;
  
      data_modems_set_modem_type(s, DATA_MODEM_V8, 0, 0);
      s->queued_modem = s->current_modem;
  
      s->rx_signal_present = false;
      return s;
  }
  /*- End of function --------------------------------------------------------*/
  
  SPAN_DECLARE(int) data_modems_release(data_modems_state_t *s)
  {
      return 0;
  }
  /*- End of function --------------------------------------------------------*/
  
  SPAN_DECLARE(int) data_modems_free(data_modems_state_t *s)
  {
      if (s)
          span_free(s);
      return 0;
  }
  /*- End of function --------------------------------------------------------*/
  /*- End of file ------------------------------------------------------------*/
  