# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _vocoder_swig
else:
    import _vocoder_swig

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)



def high_res_timer_now() -> "gr::high_res_timer_type":
    r"""high_res_timer_now() -> gr::high_res_timer_type"""
    return _vocoder_swig.high_res_timer_now()

def high_res_timer_now_perfmon() -> "gr::high_res_timer_type":
    r"""high_res_timer_now_perfmon() -> gr::high_res_timer_type"""
    return _vocoder_swig.high_res_timer_now_perfmon()

def high_res_timer_tps() -> "gr::high_res_timer_type":
    r"""high_res_timer_tps() -> gr::high_res_timer_type"""
    return _vocoder_swig.high_res_timer_tps()

def high_res_timer_epoch() -> "gr::high_res_timer_type":
    r"""high_res_timer_epoch() -> gr::high_res_timer_type"""
    return _vocoder_swig.high_res_timer_epoch()
class alaw_decode_bs(object):
    r"""Proxy of C++ gr::vocoder::alaw_decode_bs class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::vocoder::alaw_decode_bs::sptr":
        r"""make() -> alaw_decode_bs_sptr"""
        return _vocoder_swig.alaw_decode_bs_make()
    __swig_destroy__ = _vocoder_swig.delete_alaw_decode_bs

# Register alaw_decode_bs in _vocoder_swig:
_vocoder_swig.alaw_decode_bs_swigregister(alaw_decode_bs)

def alaw_decode_bs_make() -> "gr::vocoder::alaw_decode_bs::sptr":
    r"""alaw_decode_bs_make() -> alaw_decode_bs_sptr"""
    return _vocoder_swig.alaw_decode_bs_make()

class alaw_encode_sb(object):
    r"""Proxy of C++ gr::vocoder::alaw_encode_sb class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::vocoder::alaw_encode_sb::sptr":
        r"""make() -> alaw_encode_sb_sptr"""
        return _vocoder_swig.alaw_encode_sb_make()
    __swig_destroy__ = _vocoder_swig.delete_alaw_encode_sb

# Register alaw_encode_sb in _vocoder_swig:
_vocoder_swig.alaw_encode_sb_swigregister(alaw_encode_sb)

def alaw_encode_sb_make() -> "gr::vocoder::alaw_encode_sb::sptr":
    r"""alaw_encode_sb_make() -> alaw_encode_sb_sptr"""
    return _vocoder_swig.alaw_encode_sb_make()

class cvsd_decode_bs(object):
    r"""Proxy of C++ gr::vocoder::cvsd_decode_bs class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(min_step: "short"=10, max_step: "short"=1280, step_decay: "double"=0.9990234375, accum_decay: "double"=0.96875, K: "int"=32, J: "int"=4, pos_accum_max: "short"=32767, neg_accum_max: "short"=-32767) -> "gr::vocoder::cvsd_decode_bs::sptr":
        r"""make(short min_step=10, short max_step=1280, double step_decay=0.9990234375, double accum_decay=0.96875, int K=32, int J=4, short pos_accum_max=32767, short neg_accum_max=-32767) -> cvsd_decode_bs_sptr"""
        return _vocoder_swig.cvsd_decode_bs_make(min_step, max_step, step_decay, accum_decay, K, J, pos_accum_max, neg_accum_max)

    def min_step(self) -> "short":
        r"""min_step(cvsd_decode_bs self) -> short"""
        return _vocoder_swig.cvsd_decode_bs_min_step(self)

    def max_step(self) -> "short":
        r"""max_step(cvsd_decode_bs self) -> short"""
        return _vocoder_swig.cvsd_decode_bs_max_step(self)

    def step_decay(self) -> "double":
        r"""step_decay(cvsd_decode_bs self) -> double"""
        return _vocoder_swig.cvsd_decode_bs_step_decay(self)

    def accum_decay(self) -> "double":
        r"""accum_decay(cvsd_decode_bs self) -> double"""
        return _vocoder_swig.cvsd_decode_bs_accum_decay(self)

    def K(self) -> "int":
        r"""K(cvsd_decode_bs self) -> int"""
        return _vocoder_swig.cvsd_decode_bs_K(self)

    def J(self) -> "int":
        r"""J(cvsd_decode_bs self) -> int"""
        return _vocoder_swig.cvsd_decode_bs_J(self)

    def pos_accum_max(self) -> "short":
        r"""pos_accum_max(cvsd_decode_bs self) -> short"""
        return _vocoder_swig.cvsd_decode_bs_pos_accum_max(self)

    def neg_accum_max(self) -> "short":
        r"""neg_accum_max(cvsd_decode_bs self) -> short"""
        return _vocoder_swig.cvsd_decode_bs_neg_accum_max(self)
    __swig_destroy__ = _vocoder_swig.delete_cvsd_decode_bs

# Register cvsd_decode_bs in _vocoder_swig:
_vocoder_swig.cvsd_decode_bs_swigregister(cvsd_decode_bs)

def cvsd_decode_bs_make(min_step: "short"=10, max_step: "short"=1280, step_decay: "double"=0.9990234375, accum_decay: "double"=0.96875, K: "int"=32, J: "int"=4, pos_accum_max: "short"=32767, neg_accum_max: "short"=-32767) -> "gr::vocoder::cvsd_decode_bs::sptr":
    r"""cvsd_decode_bs_make(short min_step=10, short max_step=1280, double step_decay=0.9990234375, double accum_decay=0.96875, int K=32, int J=4, short pos_accum_max=32767, short neg_accum_max=-32767) -> cvsd_decode_bs_sptr"""
    return _vocoder_swig.cvsd_decode_bs_make(min_step, max_step, step_decay, accum_decay, K, J, pos_accum_max, neg_accum_max)

class cvsd_encode_sb(object):
    r"""Proxy of C++ gr::vocoder::cvsd_encode_sb class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(min_step: "short"=10, max_step: "short"=1280, step_decay: "double"=0.9990234375, accum_decay: "double"=0.96875, K: "int"=32, J: "int"=4, pos_accum_max: "short"=32767, neg_accum_max: "short"=-32767) -> "gr::vocoder::cvsd_encode_sb::sptr":
        r"""make(short min_step=10, short max_step=1280, double step_decay=0.9990234375, double accum_decay=0.96875, int K=32, int J=4, short pos_accum_max=32767, short neg_accum_max=-32767) -> cvsd_encode_sb_sptr"""
        return _vocoder_swig.cvsd_encode_sb_make(min_step, max_step, step_decay, accum_decay, K, J, pos_accum_max, neg_accum_max)

    def min_step(self) -> "short":
        r"""min_step(cvsd_encode_sb self) -> short"""
        return _vocoder_swig.cvsd_encode_sb_min_step(self)

    def max_step(self) -> "short":
        r"""max_step(cvsd_encode_sb self) -> short"""
        return _vocoder_swig.cvsd_encode_sb_max_step(self)

    def step_decay(self) -> "double":
        r"""step_decay(cvsd_encode_sb self) -> double"""
        return _vocoder_swig.cvsd_encode_sb_step_decay(self)

    def accum_decay(self) -> "double":
        r"""accum_decay(cvsd_encode_sb self) -> double"""
        return _vocoder_swig.cvsd_encode_sb_accum_decay(self)

    def K(self) -> "int":
        r"""K(cvsd_encode_sb self) -> int"""
        return _vocoder_swig.cvsd_encode_sb_K(self)

    def J(self) -> "int":
        r"""J(cvsd_encode_sb self) -> int"""
        return _vocoder_swig.cvsd_encode_sb_J(self)

    def pos_accum_max(self) -> "short":
        r"""pos_accum_max(cvsd_encode_sb self) -> short"""
        return _vocoder_swig.cvsd_encode_sb_pos_accum_max(self)

    def neg_accum_max(self) -> "short":
        r"""neg_accum_max(cvsd_encode_sb self) -> short"""
        return _vocoder_swig.cvsd_encode_sb_neg_accum_max(self)
    __swig_destroy__ = _vocoder_swig.delete_cvsd_encode_sb

# Register cvsd_encode_sb in _vocoder_swig:
_vocoder_swig.cvsd_encode_sb_swigregister(cvsd_encode_sb)

def cvsd_encode_sb_make(min_step: "short"=10, max_step: "short"=1280, step_decay: "double"=0.9990234375, accum_decay: "double"=0.96875, K: "int"=32, J: "int"=4, pos_accum_max: "short"=32767, neg_accum_max: "short"=-32767) -> "gr::vocoder::cvsd_encode_sb::sptr":
    r"""cvsd_encode_sb_make(short min_step=10, short max_step=1280, double step_decay=0.9990234375, double accum_decay=0.96875, int K=32, int J=4, short pos_accum_max=32767, short neg_accum_max=-32767) -> cvsd_encode_sb_sptr"""
    return _vocoder_swig.cvsd_encode_sb_make(min_step, max_step, step_decay, accum_decay, K, J, pos_accum_max, neg_accum_max)

class g721_decode_bs(object):
    r"""Proxy of C++ gr::vocoder::g721_decode_bs class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::vocoder::g721_decode_bs::sptr":
        r"""make() -> g721_decode_bs_sptr"""
        return _vocoder_swig.g721_decode_bs_make()
    __swig_destroy__ = _vocoder_swig.delete_g721_decode_bs

# Register g721_decode_bs in _vocoder_swig:
_vocoder_swig.g721_decode_bs_swigregister(g721_decode_bs)

def g721_decode_bs_make() -> "gr::vocoder::g721_decode_bs::sptr":
    r"""g721_decode_bs_make() -> g721_decode_bs_sptr"""
    return _vocoder_swig.g721_decode_bs_make()

class g721_encode_sb(object):
    r"""Proxy of C++ gr::vocoder::g721_encode_sb class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::vocoder::g721_encode_sb::sptr":
        r"""make() -> g721_encode_sb_sptr"""
        return _vocoder_swig.g721_encode_sb_make()
    __swig_destroy__ = _vocoder_swig.delete_g721_encode_sb

# Register g721_encode_sb in _vocoder_swig:
_vocoder_swig.g721_encode_sb_swigregister(g721_encode_sb)

def g721_encode_sb_make() -> "gr::vocoder::g721_encode_sb::sptr":
    r"""g721_encode_sb_make() -> g721_encode_sb_sptr"""
    return _vocoder_swig.g721_encode_sb_make()

class g723_24_decode_bs(object):
    r"""Proxy of C++ gr::vocoder::g723_24_decode_bs class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::vocoder::g723_24_decode_bs::sptr":
        r"""make() -> g723_24_decode_bs_sptr"""
        return _vocoder_swig.g723_24_decode_bs_make()
    __swig_destroy__ = _vocoder_swig.delete_g723_24_decode_bs

# Register g723_24_decode_bs in _vocoder_swig:
_vocoder_swig.g723_24_decode_bs_swigregister(g723_24_decode_bs)

def g723_24_decode_bs_make() -> "gr::vocoder::g723_24_decode_bs::sptr":
    r"""g723_24_decode_bs_make() -> g723_24_decode_bs_sptr"""
    return _vocoder_swig.g723_24_decode_bs_make()

class g723_24_encode_sb(object):
    r"""Proxy of C++ gr::vocoder::g723_24_encode_sb class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::vocoder::g723_24_encode_sb::sptr":
        r"""make() -> g723_24_encode_sb_sptr"""
        return _vocoder_swig.g723_24_encode_sb_make()
    __swig_destroy__ = _vocoder_swig.delete_g723_24_encode_sb

# Register g723_24_encode_sb in _vocoder_swig:
_vocoder_swig.g723_24_encode_sb_swigregister(g723_24_encode_sb)

def g723_24_encode_sb_make() -> "gr::vocoder::g723_24_encode_sb::sptr":
    r"""g723_24_encode_sb_make() -> g723_24_encode_sb_sptr"""
    return _vocoder_swig.g723_24_encode_sb_make()

class g723_40_decode_bs(object):
    r"""Proxy of C++ gr::vocoder::g723_40_decode_bs class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::vocoder::g723_40_decode_bs::sptr":
        r"""make() -> g723_40_decode_bs_sptr"""
        return _vocoder_swig.g723_40_decode_bs_make()
    __swig_destroy__ = _vocoder_swig.delete_g723_40_decode_bs

# Register g723_40_decode_bs in _vocoder_swig:
_vocoder_swig.g723_40_decode_bs_swigregister(g723_40_decode_bs)

def g723_40_decode_bs_make() -> "gr::vocoder::g723_40_decode_bs::sptr":
    r"""g723_40_decode_bs_make() -> g723_40_decode_bs_sptr"""
    return _vocoder_swig.g723_40_decode_bs_make()

class g723_40_encode_sb(object):
    r"""Proxy of C++ gr::vocoder::g723_40_encode_sb class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::vocoder::g723_40_encode_sb::sptr":
        r"""make() -> g723_40_encode_sb_sptr"""
        return _vocoder_swig.g723_40_encode_sb_make()
    __swig_destroy__ = _vocoder_swig.delete_g723_40_encode_sb

# Register g723_40_encode_sb in _vocoder_swig:
_vocoder_swig.g723_40_encode_sb_swigregister(g723_40_encode_sb)

def g723_40_encode_sb_make() -> "gr::vocoder::g723_40_encode_sb::sptr":
    r"""g723_40_encode_sb_make() -> g723_40_encode_sb_sptr"""
    return _vocoder_swig.g723_40_encode_sb_make()

class ulaw_decode_bs(object):
    r"""Proxy of C++ gr::vocoder::ulaw_decode_bs class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::vocoder::ulaw_decode_bs::sptr":
        r"""make() -> ulaw_decode_bs_sptr"""
        return _vocoder_swig.ulaw_decode_bs_make()
    __swig_destroy__ = _vocoder_swig.delete_ulaw_decode_bs

# Register ulaw_decode_bs in _vocoder_swig:
_vocoder_swig.ulaw_decode_bs_swigregister(ulaw_decode_bs)

def ulaw_decode_bs_make() -> "gr::vocoder::ulaw_decode_bs::sptr":
    r"""ulaw_decode_bs_make() -> ulaw_decode_bs_sptr"""
    return _vocoder_swig.ulaw_decode_bs_make()

class ulaw_encode_sb(object):
    r"""Proxy of C++ gr::vocoder::ulaw_encode_sb class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make() -> "gr::vocoder::ulaw_encode_sb::sptr":
        r"""make() -> ulaw_encode_sb_sptr"""
        return _vocoder_swig.ulaw_encode_sb_make()
    __swig_destroy__ = _vocoder_swig.delete_ulaw_encode_sb

# Register ulaw_encode_sb in _vocoder_swig:
_vocoder_swig.ulaw_encode_sb_swigregister(ulaw_encode_sb)

def ulaw_encode_sb_make() -> "gr::vocoder::ulaw_encode_sb::sptr":
    r"""ulaw_encode_sb_make() -> ulaw_encode_sb_sptr"""
    return _vocoder_swig.ulaw_encode_sb_make()

class alaw_decode_bs_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::alaw_decode_bs > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(alaw_decode_bs_sptr self) -> alaw_decode_bs_sptr
        __init__(alaw_decode_bs_sptr self, alaw_decode_bs p) -> alaw_decode_bs_sptr
        """
        _vocoder_swig.alaw_decode_bs_sptr_swiginit(self, _vocoder_swig.new_alaw_decode_bs_sptr(*args))

    def __deref__(self) -> "gr::vocoder::alaw_decode_bs *":
        r"""__deref__(alaw_decode_bs_sptr self) -> alaw_decode_bs"""
        return _vocoder_swig.alaw_decode_bs_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_alaw_decode_bs_sptr

    def make(self) -> "gr::vocoder::alaw_decode_bs::sptr":
        r"""make(alaw_decode_bs_sptr self) -> alaw_decode_bs_sptr"""
        return _vocoder_swig.alaw_decode_bs_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(alaw_decode_bs_sptr self) -> unsigned int"""
        return _vocoder_swig.alaw_decode_bs_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(alaw_decode_bs_sptr self, int which, int delay)
        declare_sample_delay(alaw_decode_bs_sptr self, unsigned int delay)
        """
        return _vocoder_swig.alaw_decode_bs_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(alaw_decode_bs_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.alaw_decode_bs_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(alaw_decode_bs_sptr self, int multiple)"""
        return _vocoder_swig.alaw_decode_bs_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(alaw_decode_bs_sptr self) -> int"""
        return _vocoder_swig.alaw_decode_bs_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(alaw_decode_bs_sptr self) -> double"""
        return _vocoder_swig.alaw_decode_bs_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(alaw_decode_bs_sptr self) -> uint64_t"""
        return _vocoder_swig.alaw_decode_bs_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(alaw_decode_bs_sptr self) -> uint64_t"""
        return _vocoder_swig.alaw_decode_bs_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(alaw_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.alaw_decode_bs_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(alaw_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.alaw_decode_bs_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(alaw_decode_bs_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.alaw_decode_bs_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(alaw_decode_bs_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.alaw_decode_bs_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(alaw_decode_bs_sptr self, std::string level)"""
        return _vocoder_swig.alaw_decode_bs_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(alaw_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.alaw_decode_bs_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(alaw_decode_bs_sptr self) -> int"""
        return _vocoder_swig.alaw_decode_bs_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(alaw_decode_bs_sptr self, int m)"""
        return _vocoder_swig.alaw_decode_bs_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(alaw_decode_bs_sptr self)"""
        return _vocoder_swig.alaw_decode_bs_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(alaw_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.alaw_decode_bs_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(alaw_decode_bs_sptr self, int m)"""
        return _vocoder_swig.alaw_decode_bs_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(alaw_decode_bs_sptr self) -> int"""
        return _vocoder_swig.alaw_decode_bs_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(alaw_decode_bs_sptr self, int i) -> long"""
        return _vocoder_swig.alaw_decode_bs_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(alaw_decode_bs_sptr self, long max_output_buffer)
        set_max_output_buffer(alaw_decode_bs_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.alaw_decode_bs_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(alaw_decode_bs_sptr self, int i) -> long"""
        return _vocoder_swig.alaw_decode_bs_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(alaw_decode_bs_sptr self, long min_output_buffer)
        set_min_output_buffer(alaw_decode_bs_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.alaw_decode_bs_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(alaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.alaw_decode_bs_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(alaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.alaw_decode_bs_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(alaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.alaw_decode_bs_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(alaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.alaw_decode_bs_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(alaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.alaw_decode_bs_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(alaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.alaw_decode_bs_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(alaw_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full(alaw_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.alaw_decode_bs_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(alaw_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full_avg(alaw_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.alaw_decode_bs_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(alaw_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full_var(alaw_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.alaw_decode_bs_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(alaw_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full(alaw_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.alaw_decode_bs_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(alaw_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full_avg(alaw_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.alaw_decode_bs_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(alaw_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full_var(alaw_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.alaw_decode_bs_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(alaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.alaw_decode_bs_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(alaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.alaw_decode_bs_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(alaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.alaw_decode_bs_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(alaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.alaw_decode_bs_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(alaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.alaw_decode_bs_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(alaw_decode_bs_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.alaw_decode_bs_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(alaw_decode_bs_sptr self)"""
        return _vocoder_swig.alaw_decode_bs_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(alaw_decode_bs_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.alaw_decode_bs_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(alaw_decode_bs_sptr self) -> int"""
        return _vocoder_swig.alaw_decode_bs_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(alaw_decode_bs_sptr self) -> int"""
        return _vocoder_swig.alaw_decode_bs_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(alaw_decode_bs_sptr self, int priority) -> int"""
        return _vocoder_swig.alaw_decode_bs_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(alaw_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.alaw_decode_bs_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(alaw_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.alaw_decode_bs_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(alaw_decode_bs_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.alaw_decode_bs_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(alaw_decode_bs_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.alaw_decode_bs_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(alaw_decode_bs_sptr self) -> long"""
        return _vocoder_swig.alaw_decode_bs_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(alaw_decode_bs_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.alaw_decode_bs_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(alaw_decode_bs_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.alaw_decode_bs_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(alaw_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.alaw_decode_bs_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(alaw_decode_bs_sptr self, std::string name)"""
        return _vocoder_swig.alaw_decode_bs_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(alaw_decode_bs_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.alaw_decode_bs_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(alaw_decode_bs_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.alaw_decode_bs_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(alaw_decode_bs_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.alaw_decode_bs_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(alaw_decode_bs_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.alaw_decode_bs_sptr_message_subscribers(self, which_port)

# Register alaw_decode_bs_sptr in _vocoder_swig:
_vocoder_swig.alaw_decode_bs_sptr_swigregister(alaw_decode_bs_sptr)


alaw_decode_bs_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
alaw_decode_bs = alaw_decode_bs.make;

class alaw_encode_sb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::alaw_encode_sb > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(alaw_encode_sb_sptr self) -> alaw_encode_sb_sptr
        __init__(alaw_encode_sb_sptr self, alaw_encode_sb p) -> alaw_encode_sb_sptr
        """
        _vocoder_swig.alaw_encode_sb_sptr_swiginit(self, _vocoder_swig.new_alaw_encode_sb_sptr(*args))

    def __deref__(self) -> "gr::vocoder::alaw_encode_sb *":
        r"""__deref__(alaw_encode_sb_sptr self) -> alaw_encode_sb"""
        return _vocoder_swig.alaw_encode_sb_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_alaw_encode_sb_sptr

    def make(self) -> "gr::vocoder::alaw_encode_sb::sptr":
        r"""make(alaw_encode_sb_sptr self) -> alaw_encode_sb_sptr"""
        return _vocoder_swig.alaw_encode_sb_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(alaw_encode_sb_sptr self) -> unsigned int"""
        return _vocoder_swig.alaw_encode_sb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(alaw_encode_sb_sptr self, int which, int delay)
        declare_sample_delay(alaw_encode_sb_sptr self, unsigned int delay)
        """
        return _vocoder_swig.alaw_encode_sb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(alaw_encode_sb_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.alaw_encode_sb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(alaw_encode_sb_sptr self, int multiple)"""
        return _vocoder_swig.alaw_encode_sb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(alaw_encode_sb_sptr self) -> int"""
        return _vocoder_swig.alaw_encode_sb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(alaw_encode_sb_sptr self) -> double"""
        return _vocoder_swig.alaw_encode_sb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(alaw_encode_sb_sptr self) -> uint64_t"""
        return _vocoder_swig.alaw_encode_sb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(alaw_encode_sb_sptr self) -> uint64_t"""
        return _vocoder_swig.alaw_encode_sb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(alaw_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.alaw_encode_sb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(alaw_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.alaw_encode_sb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(alaw_encode_sb_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.alaw_encode_sb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(alaw_encode_sb_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.alaw_encode_sb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(alaw_encode_sb_sptr self, std::string level)"""
        return _vocoder_swig.alaw_encode_sb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(alaw_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.alaw_encode_sb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(alaw_encode_sb_sptr self) -> int"""
        return _vocoder_swig.alaw_encode_sb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(alaw_encode_sb_sptr self, int m)"""
        return _vocoder_swig.alaw_encode_sb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(alaw_encode_sb_sptr self)"""
        return _vocoder_swig.alaw_encode_sb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(alaw_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.alaw_encode_sb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(alaw_encode_sb_sptr self, int m)"""
        return _vocoder_swig.alaw_encode_sb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(alaw_encode_sb_sptr self) -> int"""
        return _vocoder_swig.alaw_encode_sb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(alaw_encode_sb_sptr self, int i) -> long"""
        return _vocoder_swig.alaw_encode_sb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(alaw_encode_sb_sptr self, long max_output_buffer)
        set_max_output_buffer(alaw_encode_sb_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.alaw_encode_sb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(alaw_encode_sb_sptr self, int i) -> long"""
        return _vocoder_swig.alaw_encode_sb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(alaw_encode_sb_sptr self, long min_output_buffer)
        set_min_output_buffer(alaw_encode_sb_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.alaw_encode_sb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(alaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.alaw_encode_sb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(alaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.alaw_encode_sb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(alaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.alaw_encode_sb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(alaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.alaw_encode_sb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(alaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.alaw_encode_sb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(alaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.alaw_encode_sb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(alaw_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full(alaw_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.alaw_encode_sb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(alaw_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full_avg(alaw_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.alaw_encode_sb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(alaw_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full_var(alaw_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.alaw_encode_sb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(alaw_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full(alaw_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.alaw_encode_sb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(alaw_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full_avg(alaw_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.alaw_encode_sb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(alaw_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full_var(alaw_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.alaw_encode_sb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(alaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.alaw_encode_sb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(alaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.alaw_encode_sb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(alaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.alaw_encode_sb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(alaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.alaw_encode_sb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(alaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.alaw_encode_sb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(alaw_encode_sb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.alaw_encode_sb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(alaw_encode_sb_sptr self)"""
        return _vocoder_swig.alaw_encode_sb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(alaw_encode_sb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.alaw_encode_sb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(alaw_encode_sb_sptr self) -> int"""
        return _vocoder_swig.alaw_encode_sb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(alaw_encode_sb_sptr self) -> int"""
        return _vocoder_swig.alaw_encode_sb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(alaw_encode_sb_sptr self, int priority) -> int"""
        return _vocoder_swig.alaw_encode_sb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(alaw_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.alaw_encode_sb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(alaw_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.alaw_encode_sb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(alaw_encode_sb_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.alaw_encode_sb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(alaw_encode_sb_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.alaw_encode_sb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(alaw_encode_sb_sptr self) -> long"""
        return _vocoder_swig.alaw_encode_sb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(alaw_encode_sb_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.alaw_encode_sb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(alaw_encode_sb_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.alaw_encode_sb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(alaw_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.alaw_encode_sb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(alaw_encode_sb_sptr self, std::string name)"""
        return _vocoder_swig.alaw_encode_sb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(alaw_encode_sb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.alaw_encode_sb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(alaw_encode_sb_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.alaw_encode_sb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(alaw_encode_sb_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.alaw_encode_sb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(alaw_encode_sb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.alaw_encode_sb_sptr_message_subscribers(self, which_port)

# Register alaw_encode_sb_sptr in _vocoder_swig:
_vocoder_swig.alaw_encode_sb_sptr_swigregister(alaw_encode_sb_sptr)


alaw_encode_sb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
alaw_encode_sb = alaw_encode_sb.make;

class cvsd_decode_bs_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::cvsd_decode_bs > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(cvsd_decode_bs_sptr self) -> cvsd_decode_bs_sptr
        __init__(cvsd_decode_bs_sptr self, cvsd_decode_bs p) -> cvsd_decode_bs_sptr
        """
        _vocoder_swig.cvsd_decode_bs_sptr_swiginit(self, _vocoder_swig.new_cvsd_decode_bs_sptr(*args))

    def __deref__(self) -> "gr::vocoder::cvsd_decode_bs *":
        r"""__deref__(cvsd_decode_bs_sptr self) -> cvsd_decode_bs"""
        return _vocoder_swig.cvsd_decode_bs_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_cvsd_decode_bs_sptr

    def make(self, min_step: "short"=10, max_step: "short"=1280, step_decay: "double"=0.9990234375, accum_decay: "double"=0.96875, K: "int"=32, J: "int"=4, pos_accum_max: "short"=32767, neg_accum_max: "short"=-32767) -> "gr::vocoder::cvsd_decode_bs::sptr":
        r"""make(cvsd_decode_bs_sptr self, short min_step=10, short max_step=1280, double step_decay=0.9990234375, double accum_decay=0.96875, int K=32, int J=4, short pos_accum_max=32767, short neg_accum_max=-32767) -> cvsd_decode_bs_sptr"""
        return _vocoder_swig.cvsd_decode_bs_sptr_make(self, min_step, max_step, step_decay, accum_decay, K, J, pos_accum_max, neg_accum_max)

    def min_step(self) -> "short":
        r"""min_step(cvsd_decode_bs_sptr self) -> short"""
        return _vocoder_swig.cvsd_decode_bs_sptr_min_step(self)

    def max_step(self) -> "short":
        r"""max_step(cvsd_decode_bs_sptr self) -> short"""
        return _vocoder_swig.cvsd_decode_bs_sptr_max_step(self)

    def step_decay(self) -> "double":
        r"""step_decay(cvsd_decode_bs_sptr self) -> double"""
        return _vocoder_swig.cvsd_decode_bs_sptr_step_decay(self)

    def accum_decay(self) -> "double":
        r"""accum_decay(cvsd_decode_bs_sptr self) -> double"""
        return _vocoder_swig.cvsd_decode_bs_sptr_accum_decay(self)

    def K(self) -> "int":
        r"""K(cvsd_decode_bs_sptr self) -> int"""
        return _vocoder_swig.cvsd_decode_bs_sptr_K(self)

    def J(self) -> "int":
        r"""J(cvsd_decode_bs_sptr self) -> int"""
        return _vocoder_swig.cvsd_decode_bs_sptr_J(self)

    def pos_accum_max(self) -> "short":
        r"""pos_accum_max(cvsd_decode_bs_sptr self) -> short"""
        return _vocoder_swig.cvsd_decode_bs_sptr_pos_accum_max(self)

    def neg_accum_max(self) -> "short":
        r"""neg_accum_max(cvsd_decode_bs_sptr self) -> short"""
        return _vocoder_swig.cvsd_decode_bs_sptr_neg_accum_max(self)

    def history(self) -> "unsigned int":
        r"""history(cvsd_decode_bs_sptr self) -> unsigned int"""
        return _vocoder_swig.cvsd_decode_bs_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(cvsd_decode_bs_sptr self, int which, int delay)
        declare_sample_delay(cvsd_decode_bs_sptr self, unsigned int delay)
        """
        return _vocoder_swig.cvsd_decode_bs_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(cvsd_decode_bs_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.cvsd_decode_bs_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(cvsd_decode_bs_sptr self, int multiple)"""
        return _vocoder_swig.cvsd_decode_bs_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(cvsd_decode_bs_sptr self) -> int"""
        return _vocoder_swig.cvsd_decode_bs_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(cvsd_decode_bs_sptr self) -> double"""
        return _vocoder_swig.cvsd_decode_bs_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(cvsd_decode_bs_sptr self) -> uint64_t"""
        return _vocoder_swig.cvsd_decode_bs_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(cvsd_decode_bs_sptr self) -> uint64_t"""
        return _vocoder_swig.cvsd_decode_bs_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(cvsd_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.cvsd_decode_bs_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(cvsd_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.cvsd_decode_bs_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(cvsd_decode_bs_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.cvsd_decode_bs_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(cvsd_decode_bs_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.cvsd_decode_bs_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(cvsd_decode_bs_sptr self, std::string level)"""
        return _vocoder_swig.cvsd_decode_bs_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(cvsd_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.cvsd_decode_bs_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(cvsd_decode_bs_sptr self) -> int"""
        return _vocoder_swig.cvsd_decode_bs_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(cvsd_decode_bs_sptr self, int m)"""
        return _vocoder_swig.cvsd_decode_bs_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(cvsd_decode_bs_sptr self)"""
        return _vocoder_swig.cvsd_decode_bs_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(cvsd_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.cvsd_decode_bs_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(cvsd_decode_bs_sptr self, int m)"""
        return _vocoder_swig.cvsd_decode_bs_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(cvsd_decode_bs_sptr self) -> int"""
        return _vocoder_swig.cvsd_decode_bs_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(cvsd_decode_bs_sptr self, int i) -> long"""
        return _vocoder_swig.cvsd_decode_bs_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(cvsd_decode_bs_sptr self, long max_output_buffer)
        set_max_output_buffer(cvsd_decode_bs_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.cvsd_decode_bs_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(cvsd_decode_bs_sptr self, int i) -> long"""
        return _vocoder_swig.cvsd_decode_bs_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(cvsd_decode_bs_sptr self, long min_output_buffer)
        set_min_output_buffer(cvsd_decode_bs_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.cvsd_decode_bs_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(cvsd_decode_bs_sptr self) -> float"""
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(cvsd_decode_bs_sptr self) -> float"""
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(cvsd_decode_bs_sptr self) -> float"""
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(cvsd_decode_bs_sptr self) -> float"""
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(cvsd_decode_bs_sptr self) -> float"""
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(cvsd_decode_bs_sptr self) -> float"""
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(cvsd_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full(cvsd_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(cvsd_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full_avg(cvsd_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(cvsd_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full_var(cvsd_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(cvsd_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full(cvsd_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(cvsd_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full_avg(cvsd_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(cvsd_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full_var(cvsd_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(cvsd_decode_bs_sptr self) -> float"""
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(cvsd_decode_bs_sptr self) -> float"""
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(cvsd_decode_bs_sptr self) -> float"""
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(cvsd_decode_bs_sptr self) -> float"""
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(cvsd_decode_bs_sptr self) -> float"""
        return _vocoder_swig.cvsd_decode_bs_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(cvsd_decode_bs_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.cvsd_decode_bs_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(cvsd_decode_bs_sptr self)"""
        return _vocoder_swig.cvsd_decode_bs_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(cvsd_decode_bs_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.cvsd_decode_bs_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(cvsd_decode_bs_sptr self) -> int"""
        return _vocoder_swig.cvsd_decode_bs_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(cvsd_decode_bs_sptr self) -> int"""
        return _vocoder_swig.cvsd_decode_bs_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(cvsd_decode_bs_sptr self, int priority) -> int"""
        return _vocoder_swig.cvsd_decode_bs_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(cvsd_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.cvsd_decode_bs_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(cvsd_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.cvsd_decode_bs_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(cvsd_decode_bs_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.cvsd_decode_bs_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(cvsd_decode_bs_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.cvsd_decode_bs_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(cvsd_decode_bs_sptr self) -> long"""
        return _vocoder_swig.cvsd_decode_bs_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(cvsd_decode_bs_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.cvsd_decode_bs_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(cvsd_decode_bs_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.cvsd_decode_bs_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(cvsd_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.cvsd_decode_bs_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(cvsd_decode_bs_sptr self, std::string name)"""
        return _vocoder_swig.cvsd_decode_bs_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(cvsd_decode_bs_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.cvsd_decode_bs_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(cvsd_decode_bs_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.cvsd_decode_bs_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(cvsd_decode_bs_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.cvsd_decode_bs_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(cvsd_decode_bs_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.cvsd_decode_bs_sptr_message_subscribers(self, which_port)

# Register cvsd_decode_bs_sptr in _vocoder_swig:
_vocoder_swig.cvsd_decode_bs_sptr_swigregister(cvsd_decode_bs_sptr)


cvsd_decode_bs_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
cvsd_decode_bs = cvsd_decode_bs.make;

class cvsd_encode_sb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::cvsd_encode_sb > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(cvsd_encode_sb_sptr self) -> cvsd_encode_sb_sptr
        __init__(cvsd_encode_sb_sptr self, cvsd_encode_sb p) -> cvsd_encode_sb_sptr
        """
        _vocoder_swig.cvsd_encode_sb_sptr_swiginit(self, _vocoder_swig.new_cvsd_encode_sb_sptr(*args))

    def __deref__(self) -> "gr::vocoder::cvsd_encode_sb *":
        r"""__deref__(cvsd_encode_sb_sptr self) -> cvsd_encode_sb"""
        return _vocoder_swig.cvsd_encode_sb_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_cvsd_encode_sb_sptr

    def make(self, min_step: "short"=10, max_step: "short"=1280, step_decay: "double"=0.9990234375, accum_decay: "double"=0.96875, K: "int"=32, J: "int"=4, pos_accum_max: "short"=32767, neg_accum_max: "short"=-32767) -> "gr::vocoder::cvsd_encode_sb::sptr":
        r"""make(cvsd_encode_sb_sptr self, short min_step=10, short max_step=1280, double step_decay=0.9990234375, double accum_decay=0.96875, int K=32, int J=4, short pos_accum_max=32767, short neg_accum_max=-32767) -> cvsd_encode_sb_sptr"""
        return _vocoder_swig.cvsd_encode_sb_sptr_make(self, min_step, max_step, step_decay, accum_decay, K, J, pos_accum_max, neg_accum_max)

    def min_step(self) -> "short":
        r"""min_step(cvsd_encode_sb_sptr self) -> short"""
        return _vocoder_swig.cvsd_encode_sb_sptr_min_step(self)

    def max_step(self) -> "short":
        r"""max_step(cvsd_encode_sb_sptr self) -> short"""
        return _vocoder_swig.cvsd_encode_sb_sptr_max_step(self)

    def step_decay(self) -> "double":
        r"""step_decay(cvsd_encode_sb_sptr self) -> double"""
        return _vocoder_swig.cvsd_encode_sb_sptr_step_decay(self)

    def accum_decay(self) -> "double":
        r"""accum_decay(cvsd_encode_sb_sptr self) -> double"""
        return _vocoder_swig.cvsd_encode_sb_sptr_accum_decay(self)

    def K(self) -> "int":
        r"""K(cvsd_encode_sb_sptr self) -> int"""
        return _vocoder_swig.cvsd_encode_sb_sptr_K(self)

    def J(self) -> "int":
        r"""J(cvsd_encode_sb_sptr self) -> int"""
        return _vocoder_swig.cvsd_encode_sb_sptr_J(self)

    def pos_accum_max(self) -> "short":
        r"""pos_accum_max(cvsd_encode_sb_sptr self) -> short"""
        return _vocoder_swig.cvsd_encode_sb_sptr_pos_accum_max(self)

    def neg_accum_max(self) -> "short":
        r"""neg_accum_max(cvsd_encode_sb_sptr self) -> short"""
        return _vocoder_swig.cvsd_encode_sb_sptr_neg_accum_max(self)

    def history(self) -> "unsigned int":
        r"""history(cvsd_encode_sb_sptr self) -> unsigned int"""
        return _vocoder_swig.cvsd_encode_sb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(cvsd_encode_sb_sptr self, int which, int delay)
        declare_sample_delay(cvsd_encode_sb_sptr self, unsigned int delay)
        """
        return _vocoder_swig.cvsd_encode_sb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(cvsd_encode_sb_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.cvsd_encode_sb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(cvsd_encode_sb_sptr self, int multiple)"""
        return _vocoder_swig.cvsd_encode_sb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(cvsd_encode_sb_sptr self) -> int"""
        return _vocoder_swig.cvsd_encode_sb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(cvsd_encode_sb_sptr self) -> double"""
        return _vocoder_swig.cvsd_encode_sb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(cvsd_encode_sb_sptr self) -> uint64_t"""
        return _vocoder_swig.cvsd_encode_sb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(cvsd_encode_sb_sptr self) -> uint64_t"""
        return _vocoder_swig.cvsd_encode_sb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(cvsd_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.cvsd_encode_sb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(cvsd_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.cvsd_encode_sb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(cvsd_encode_sb_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.cvsd_encode_sb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(cvsd_encode_sb_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.cvsd_encode_sb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(cvsd_encode_sb_sptr self, std::string level)"""
        return _vocoder_swig.cvsd_encode_sb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(cvsd_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.cvsd_encode_sb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(cvsd_encode_sb_sptr self) -> int"""
        return _vocoder_swig.cvsd_encode_sb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(cvsd_encode_sb_sptr self, int m)"""
        return _vocoder_swig.cvsd_encode_sb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(cvsd_encode_sb_sptr self)"""
        return _vocoder_swig.cvsd_encode_sb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(cvsd_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.cvsd_encode_sb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(cvsd_encode_sb_sptr self, int m)"""
        return _vocoder_swig.cvsd_encode_sb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(cvsd_encode_sb_sptr self) -> int"""
        return _vocoder_swig.cvsd_encode_sb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(cvsd_encode_sb_sptr self, int i) -> long"""
        return _vocoder_swig.cvsd_encode_sb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(cvsd_encode_sb_sptr self, long max_output_buffer)
        set_max_output_buffer(cvsd_encode_sb_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.cvsd_encode_sb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(cvsd_encode_sb_sptr self, int i) -> long"""
        return _vocoder_swig.cvsd_encode_sb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(cvsd_encode_sb_sptr self, long min_output_buffer)
        set_min_output_buffer(cvsd_encode_sb_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.cvsd_encode_sb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(cvsd_encode_sb_sptr self) -> float"""
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(cvsd_encode_sb_sptr self) -> float"""
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(cvsd_encode_sb_sptr self) -> float"""
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(cvsd_encode_sb_sptr self) -> float"""
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(cvsd_encode_sb_sptr self) -> float"""
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(cvsd_encode_sb_sptr self) -> float"""
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(cvsd_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full(cvsd_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(cvsd_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full_avg(cvsd_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(cvsd_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full_var(cvsd_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(cvsd_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full(cvsd_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(cvsd_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full_avg(cvsd_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(cvsd_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full_var(cvsd_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(cvsd_encode_sb_sptr self) -> float"""
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(cvsd_encode_sb_sptr self) -> float"""
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(cvsd_encode_sb_sptr self) -> float"""
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(cvsd_encode_sb_sptr self) -> float"""
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(cvsd_encode_sb_sptr self) -> float"""
        return _vocoder_swig.cvsd_encode_sb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(cvsd_encode_sb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.cvsd_encode_sb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(cvsd_encode_sb_sptr self)"""
        return _vocoder_swig.cvsd_encode_sb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(cvsd_encode_sb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.cvsd_encode_sb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(cvsd_encode_sb_sptr self) -> int"""
        return _vocoder_swig.cvsd_encode_sb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(cvsd_encode_sb_sptr self) -> int"""
        return _vocoder_swig.cvsd_encode_sb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(cvsd_encode_sb_sptr self, int priority) -> int"""
        return _vocoder_swig.cvsd_encode_sb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(cvsd_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.cvsd_encode_sb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(cvsd_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.cvsd_encode_sb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(cvsd_encode_sb_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.cvsd_encode_sb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(cvsd_encode_sb_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.cvsd_encode_sb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(cvsd_encode_sb_sptr self) -> long"""
        return _vocoder_swig.cvsd_encode_sb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(cvsd_encode_sb_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.cvsd_encode_sb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(cvsd_encode_sb_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.cvsd_encode_sb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(cvsd_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.cvsd_encode_sb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(cvsd_encode_sb_sptr self, std::string name)"""
        return _vocoder_swig.cvsd_encode_sb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(cvsd_encode_sb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.cvsd_encode_sb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(cvsd_encode_sb_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.cvsd_encode_sb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(cvsd_encode_sb_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.cvsd_encode_sb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(cvsd_encode_sb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.cvsd_encode_sb_sptr_message_subscribers(self, which_port)

# Register cvsd_encode_sb_sptr in _vocoder_swig:
_vocoder_swig.cvsd_encode_sb_sptr_swigregister(cvsd_encode_sb_sptr)


cvsd_encode_sb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
cvsd_encode_sb = cvsd_encode_sb.make;

class g721_decode_bs_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::g721_decode_bs > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(g721_decode_bs_sptr self) -> g721_decode_bs_sptr
        __init__(g721_decode_bs_sptr self, g721_decode_bs p) -> g721_decode_bs_sptr
        """
        _vocoder_swig.g721_decode_bs_sptr_swiginit(self, _vocoder_swig.new_g721_decode_bs_sptr(*args))

    def __deref__(self) -> "gr::vocoder::g721_decode_bs *":
        r"""__deref__(g721_decode_bs_sptr self) -> g721_decode_bs"""
        return _vocoder_swig.g721_decode_bs_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_g721_decode_bs_sptr

    def make(self) -> "gr::vocoder::g721_decode_bs::sptr":
        r"""make(g721_decode_bs_sptr self) -> g721_decode_bs_sptr"""
        return _vocoder_swig.g721_decode_bs_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(g721_decode_bs_sptr self) -> unsigned int"""
        return _vocoder_swig.g721_decode_bs_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(g721_decode_bs_sptr self, int which, int delay)
        declare_sample_delay(g721_decode_bs_sptr self, unsigned int delay)
        """
        return _vocoder_swig.g721_decode_bs_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(g721_decode_bs_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.g721_decode_bs_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(g721_decode_bs_sptr self, int multiple)"""
        return _vocoder_swig.g721_decode_bs_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(g721_decode_bs_sptr self) -> int"""
        return _vocoder_swig.g721_decode_bs_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(g721_decode_bs_sptr self) -> double"""
        return _vocoder_swig.g721_decode_bs_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(g721_decode_bs_sptr self) -> uint64_t"""
        return _vocoder_swig.g721_decode_bs_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(g721_decode_bs_sptr self) -> uint64_t"""
        return _vocoder_swig.g721_decode_bs_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(g721_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.g721_decode_bs_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(g721_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.g721_decode_bs_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(g721_decode_bs_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.g721_decode_bs_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(g721_decode_bs_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.g721_decode_bs_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(g721_decode_bs_sptr self, std::string level)"""
        return _vocoder_swig.g721_decode_bs_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(g721_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.g721_decode_bs_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(g721_decode_bs_sptr self) -> int"""
        return _vocoder_swig.g721_decode_bs_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(g721_decode_bs_sptr self, int m)"""
        return _vocoder_swig.g721_decode_bs_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(g721_decode_bs_sptr self)"""
        return _vocoder_swig.g721_decode_bs_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(g721_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.g721_decode_bs_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(g721_decode_bs_sptr self, int m)"""
        return _vocoder_swig.g721_decode_bs_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(g721_decode_bs_sptr self) -> int"""
        return _vocoder_swig.g721_decode_bs_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(g721_decode_bs_sptr self, int i) -> long"""
        return _vocoder_swig.g721_decode_bs_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(g721_decode_bs_sptr self, long max_output_buffer)
        set_max_output_buffer(g721_decode_bs_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.g721_decode_bs_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(g721_decode_bs_sptr self, int i) -> long"""
        return _vocoder_swig.g721_decode_bs_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(g721_decode_bs_sptr self, long min_output_buffer)
        set_min_output_buffer(g721_decode_bs_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.g721_decode_bs_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(g721_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g721_decode_bs_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(g721_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g721_decode_bs_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(g721_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g721_decode_bs_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(g721_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g721_decode_bs_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(g721_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g721_decode_bs_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(g721_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g721_decode_bs_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(g721_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full(g721_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g721_decode_bs_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(g721_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full_avg(g721_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g721_decode_bs_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(g721_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full_var(g721_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g721_decode_bs_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(g721_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full(g721_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g721_decode_bs_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(g721_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full_avg(g721_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g721_decode_bs_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(g721_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full_var(g721_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g721_decode_bs_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(g721_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g721_decode_bs_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(g721_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g721_decode_bs_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(g721_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g721_decode_bs_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(g721_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g721_decode_bs_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(g721_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g721_decode_bs_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(g721_decode_bs_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.g721_decode_bs_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(g721_decode_bs_sptr self)"""
        return _vocoder_swig.g721_decode_bs_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(g721_decode_bs_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.g721_decode_bs_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(g721_decode_bs_sptr self) -> int"""
        return _vocoder_swig.g721_decode_bs_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(g721_decode_bs_sptr self) -> int"""
        return _vocoder_swig.g721_decode_bs_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(g721_decode_bs_sptr self, int priority) -> int"""
        return _vocoder_swig.g721_decode_bs_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(g721_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.g721_decode_bs_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(g721_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.g721_decode_bs_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(g721_decode_bs_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.g721_decode_bs_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(g721_decode_bs_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.g721_decode_bs_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(g721_decode_bs_sptr self) -> long"""
        return _vocoder_swig.g721_decode_bs_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(g721_decode_bs_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.g721_decode_bs_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(g721_decode_bs_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.g721_decode_bs_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(g721_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.g721_decode_bs_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(g721_decode_bs_sptr self, std::string name)"""
        return _vocoder_swig.g721_decode_bs_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(g721_decode_bs_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.g721_decode_bs_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(g721_decode_bs_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.g721_decode_bs_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(g721_decode_bs_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.g721_decode_bs_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(g721_decode_bs_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.g721_decode_bs_sptr_message_subscribers(self, which_port)

# Register g721_decode_bs_sptr in _vocoder_swig:
_vocoder_swig.g721_decode_bs_sptr_swigregister(g721_decode_bs_sptr)


g721_decode_bs_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
g721_decode_bs = g721_decode_bs.make;

class g721_encode_sb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::g721_encode_sb > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(g721_encode_sb_sptr self) -> g721_encode_sb_sptr
        __init__(g721_encode_sb_sptr self, g721_encode_sb p) -> g721_encode_sb_sptr
        """
        _vocoder_swig.g721_encode_sb_sptr_swiginit(self, _vocoder_swig.new_g721_encode_sb_sptr(*args))

    def __deref__(self) -> "gr::vocoder::g721_encode_sb *":
        r"""__deref__(g721_encode_sb_sptr self) -> g721_encode_sb"""
        return _vocoder_swig.g721_encode_sb_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_g721_encode_sb_sptr

    def make(self) -> "gr::vocoder::g721_encode_sb::sptr":
        r"""make(g721_encode_sb_sptr self) -> g721_encode_sb_sptr"""
        return _vocoder_swig.g721_encode_sb_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(g721_encode_sb_sptr self) -> unsigned int"""
        return _vocoder_swig.g721_encode_sb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(g721_encode_sb_sptr self, int which, int delay)
        declare_sample_delay(g721_encode_sb_sptr self, unsigned int delay)
        """
        return _vocoder_swig.g721_encode_sb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(g721_encode_sb_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.g721_encode_sb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(g721_encode_sb_sptr self, int multiple)"""
        return _vocoder_swig.g721_encode_sb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(g721_encode_sb_sptr self) -> int"""
        return _vocoder_swig.g721_encode_sb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(g721_encode_sb_sptr self) -> double"""
        return _vocoder_swig.g721_encode_sb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(g721_encode_sb_sptr self) -> uint64_t"""
        return _vocoder_swig.g721_encode_sb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(g721_encode_sb_sptr self) -> uint64_t"""
        return _vocoder_swig.g721_encode_sb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(g721_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.g721_encode_sb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(g721_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.g721_encode_sb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(g721_encode_sb_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.g721_encode_sb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(g721_encode_sb_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.g721_encode_sb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(g721_encode_sb_sptr self, std::string level)"""
        return _vocoder_swig.g721_encode_sb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(g721_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.g721_encode_sb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(g721_encode_sb_sptr self) -> int"""
        return _vocoder_swig.g721_encode_sb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(g721_encode_sb_sptr self, int m)"""
        return _vocoder_swig.g721_encode_sb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(g721_encode_sb_sptr self)"""
        return _vocoder_swig.g721_encode_sb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(g721_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.g721_encode_sb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(g721_encode_sb_sptr self, int m)"""
        return _vocoder_swig.g721_encode_sb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(g721_encode_sb_sptr self) -> int"""
        return _vocoder_swig.g721_encode_sb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(g721_encode_sb_sptr self, int i) -> long"""
        return _vocoder_swig.g721_encode_sb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(g721_encode_sb_sptr self, long max_output_buffer)
        set_max_output_buffer(g721_encode_sb_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.g721_encode_sb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(g721_encode_sb_sptr self, int i) -> long"""
        return _vocoder_swig.g721_encode_sb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(g721_encode_sb_sptr self, long min_output_buffer)
        set_min_output_buffer(g721_encode_sb_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.g721_encode_sb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(g721_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g721_encode_sb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(g721_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g721_encode_sb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(g721_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g721_encode_sb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(g721_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g721_encode_sb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(g721_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g721_encode_sb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(g721_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g721_encode_sb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(g721_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full(g721_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g721_encode_sb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(g721_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full_avg(g721_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g721_encode_sb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(g721_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full_var(g721_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g721_encode_sb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(g721_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full(g721_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g721_encode_sb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(g721_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full_avg(g721_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g721_encode_sb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(g721_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full_var(g721_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g721_encode_sb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(g721_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g721_encode_sb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(g721_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g721_encode_sb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(g721_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g721_encode_sb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(g721_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g721_encode_sb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(g721_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g721_encode_sb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(g721_encode_sb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.g721_encode_sb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(g721_encode_sb_sptr self)"""
        return _vocoder_swig.g721_encode_sb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(g721_encode_sb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.g721_encode_sb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(g721_encode_sb_sptr self) -> int"""
        return _vocoder_swig.g721_encode_sb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(g721_encode_sb_sptr self) -> int"""
        return _vocoder_swig.g721_encode_sb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(g721_encode_sb_sptr self, int priority) -> int"""
        return _vocoder_swig.g721_encode_sb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(g721_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.g721_encode_sb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(g721_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.g721_encode_sb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(g721_encode_sb_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.g721_encode_sb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(g721_encode_sb_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.g721_encode_sb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(g721_encode_sb_sptr self) -> long"""
        return _vocoder_swig.g721_encode_sb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(g721_encode_sb_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.g721_encode_sb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(g721_encode_sb_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.g721_encode_sb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(g721_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.g721_encode_sb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(g721_encode_sb_sptr self, std::string name)"""
        return _vocoder_swig.g721_encode_sb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(g721_encode_sb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.g721_encode_sb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(g721_encode_sb_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.g721_encode_sb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(g721_encode_sb_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.g721_encode_sb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(g721_encode_sb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.g721_encode_sb_sptr_message_subscribers(self, which_port)

# Register g721_encode_sb_sptr in _vocoder_swig:
_vocoder_swig.g721_encode_sb_sptr_swigregister(g721_encode_sb_sptr)


g721_encode_sb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
g721_encode_sb = g721_encode_sb.make;

class g723_24_decode_bs_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::g723_24_decode_bs > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(g723_24_decode_bs_sptr self) -> g723_24_decode_bs_sptr
        __init__(g723_24_decode_bs_sptr self, g723_24_decode_bs p) -> g723_24_decode_bs_sptr
        """
        _vocoder_swig.g723_24_decode_bs_sptr_swiginit(self, _vocoder_swig.new_g723_24_decode_bs_sptr(*args))

    def __deref__(self) -> "gr::vocoder::g723_24_decode_bs *":
        r"""__deref__(g723_24_decode_bs_sptr self) -> g723_24_decode_bs"""
        return _vocoder_swig.g723_24_decode_bs_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_g723_24_decode_bs_sptr

    def make(self) -> "gr::vocoder::g723_24_decode_bs::sptr":
        r"""make(g723_24_decode_bs_sptr self) -> g723_24_decode_bs_sptr"""
        return _vocoder_swig.g723_24_decode_bs_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(g723_24_decode_bs_sptr self) -> unsigned int"""
        return _vocoder_swig.g723_24_decode_bs_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(g723_24_decode_bs_sptr self, int which, int delay)
        declare_sample_delay(g723_24_decode_bs_sptr self, unsigned int delay)
        """
        return _vocoder_swig.g723_24_decode_bs_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(g723_24_decode_bs_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.g723_24_decode_bs_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(g723_24_decode_bs_sptr self, int multiple)"""
        return _vocoder_swig.g723_24_decode_bs_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(g723_24_decode_bs_sptr self) -> int"""
        return _vocoder_swig.g723_24_decode_bs_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(g723_24_decode_bs_sptr self) -> double"""
        return _vocoder_swig.g723_24_decode_bs_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(g723_24_decode_bs_sptr self) -> uint64_t"""
        return _vocoder_swig.g723_24_decode_bs_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(g723_24_decode_bs_sptr self) -> uint64_t"""
        return _vocoder_swig.g723_24_decode_bs_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(g723_24_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.g723_24_decode_bs_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(g723_24_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.g723_24_decode_bs_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(g723_24_decode_bs_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.g723_24_decode_bs_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(g723_24_decode_bs_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.g723_24_decode_bs_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(g723_24_decode_bs_sptr self, std::string level)"""
        return _vocoder_swig.g723_24_decode_bs_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(g723_24_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.g723_24_decode_bs_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(g723_24_decode_bs_sptr self) -> int"""
        return _vocoder_swig.g723_24_decode_bs_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(g723_24_decode_bs_sptr self, int m)"""
        return _vocoder_swig.g723_24_decode_bs_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(g723_24_decode_bs_sptr self)"""
        return _vocoder_swig.g723_24_decode_bs_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(g723_24_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.g723_24_decode_bs_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(g723_24_decode_bs_sptr self, int m)"""
        return _vocoder_swig.g723_24_decode_bs_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(g723_24_decode_bs_sptr self) -> int"""
        return _vocoder_swig.g723_24_decode_bs_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(g723_24_decode_bs_sptr self, int i) -> long"""
        return _vocoder_swig.g723_24_decode_bs_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(g723_24_decode_bs_sptr self, long max_output_buffer)
        set_max_output_buffer(g723_24_decode_bs_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.g723_24_decode_bs_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(g723_24_decode_bs_sptr self, int i) -> long"""
        return _vocoder_swig.g723_24_decode_bs_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(g723_24_decode_bs_sptr self, long min_output_buffer)
        set_min_output_buffer(g723_24_decode_bs_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.g723_24_decode_bs_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(g723_24_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(g723_24_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(g723_24_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(g723_24_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(g723_24_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(g723_24_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(g723_24_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full(g723_24_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(g723_24_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full_avg(g723_24_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(g723_24_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full_var(g723_24_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(g723_24_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full(g723_24_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(g723_24_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full_avg(g723_24_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(g723_24_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full_var(g723_24_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(g723_24_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(g723_24_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(g723_24_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(g723_24_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(g723_24_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_24_decode_bs_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(g723_24_decode_bs_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.g723_24_decode_bs_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(g723_24_decode_bs_sptr self)"""
        return _vocoder_swig.g723_24_decode_bs_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(g723_24_decode_bs_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.g723_24_decode_bs_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(g723_24_decode_bs_sptr self) -> int"""
        return _vocoder_swig.g723_24_decode_bs_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(g723_24_decode_bs_sptr self) -> int"""
        return _vocoder_swig.g723_24_decode_bs_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(g723_24_decode_bs_sptr self, int priority) -> int"""
        return _vocoder_swig.g723_24_decode_bs_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(g723_24_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.g723_24_decode_bs_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(g723_24_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.g723_24_decode_bs_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(g723_24_decode_bs_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.g723_24_decode_bs_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(g723_24_decode_bs_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.g723_24_decode_bs_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(g723_24_decode_bs_sptr self) -> long"""
        return _vocoder_swig.g723_24_decode_bs_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(g723_24_decode_bs_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.g723_24_decode_bs_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(g723_24_decode_bs_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.g723_24_decode_bs_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(g723_24_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.g723_24_decode_bs_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(g723_24_decode_bs_sptr self, std::string name)"""
        return _vocoder_swig.g723_24_decode_bs_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(g723_24_decode_bs_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.g723_24_decode_bs_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(g723_24_decode_bs_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.g723_24_decode_bs_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(g723_24_decode_bs_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.g723_24_decode_bs_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(g723_24_decode_bs_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.g723_24_decode_bs_sptr_message_subscribers(self, which_port)

# Register g723_24_decode_bs_sptr in _vocoder_swig:
_vocoder_swig.g723_24_decode_bs_sptr_swigregister(g723_24_decode_bs_sptr)


g723_24_decode_bs_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
g723_24_decode_bs = g723_24_decode_bs.make;

class g723_24_encode_sb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::g723_24_encode_sb > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(g723_24_encode_sb_sptr self) -> g723_24_encode_sb_sptr
        __init__(g723_24_encode_sb_sptr self, g723_24_encode_sb p) -> g723_24_encode_sb_sptr
        """
        _vocoder_swig.g723_24_encode_sb_sptr_swiginit(self, _vocoder_swig.new_g723_24_encode_sb_sptr(*args))

    def __deref__(self) -> "gr::vocoder::g723_24_encode_sb *":
        r"""__deref__(g723_24_encode_sb_sptr self) -> g723_24_encode_sb"""
        return _vocoder_swig.g723_24_encode_sb_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_g723_24_encode_sb_sptr

    def make(self) -> "gr::vocoder::g723_24_encode_sb::sptr":
        r"""make(g723_24_encode_sb_sptr self) -> g723_24_encode_sb_sptr"""
        return _vocoder_swig.g723_24_encode_sb_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(g723_24_encode_sb_sptr self) -> unsigned int"""
        return _vocoder_swig.g723_24_encode_sb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(g723_24_encode_sb_sptr self, int which, int delay)
        declare_sample_delay(g723_24_encode_sb_sptr self, unsigned int delay)
        """
        return _vocoder_swig.g723_24_encode_sb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(g723_24_encode_sb_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.g723_24_encode_sb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(g723_24_encode_sb_sptr self, int multiple)"""
        return _vocoder_swig.g723_24_encode_sb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(g723_24_encode_sb_sptr self) -> int"""
        return _vocoder_swig.g723_24_encode_sb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(g723_24_encode_sb_sptr self) -> double"""
        return _vocoder_swig.g723_24_encode_sb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(g723_24_encode_sb_sptr self) -> uint64_t"""
        return _vocoder_swig.g723_24_encode_sb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(g723_24_encode_sb_sptr self) -> uint64_t"""
        return _vocoder_swig.g723_24_encode_sb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(g723_24_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.g723_24_encode_sb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(g723_24_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.g723_24_encode_sb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(g723_24_encode_sb_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.g723_24_encode_sb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(g723_24_encode_sb_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.g723_24_encode_sb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(g723_24_encode_sb_sptr self, std::string level)"""
        return _vocoder_swig.g723_24_encode_sb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(g723_24_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.g723_24_encode_sb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(g723_24_encode_sb_sptr self) -> int"""
        return _vocoder_swig.g723_24_encode_sb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(g723_24_encode_sb_sptr self, int m)"""
        return _vocoder_swig.g723_24_encode_sb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(g723_24_encode_sb_sptr self)"""
        return _vocoder_swig.g723_24_encode_sb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(g723_24_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.g723_24_encode_sb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(g723_24_encode_sb_sptr self, int m)"""
        return _vocoder_swig.g723_24_encode_sb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(g723_24_encode_sb_sptr self) -> int"""
        return _vocoder_swig.g723_24_encode_sb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(g723_24_encode_sb_sptr self, int i) -> long"""
        return _vocoder_swig.g723_24_encode_sb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(g723_24_encode_sb_sptr self, long max_output_buffer)
        set_max_output_buffer(g723_24_encode_sb_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.g723_24_encode_sb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(g723_24_encode_sb_sptr self, int i) -> long"""
        return _vocoder_swig.g723_24_encode_sb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(g723_24_encode_sb_sptr self, long min_output_buffer)
        set_min_output_buffer(g723_24_encode_sb_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.g723_24_encode_sb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(g723_24_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(g723_24_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(g723_24_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(g723_24_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(g723_24_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(g723_24_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(g723_24_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full(g723_24_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(g723_24_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full_avg(g723_24_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(g723_24_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full_var(g723_24_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(g723_24_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full(g723_24_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(g723_24_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full_avg(g723_24_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(g723_24_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full_var(g723_24_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(g723_24_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(g723_24_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(g723_24_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(g723_24_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(g723_24_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_24_encode_sb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(g723_24_encode_sb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.g723_24_encode_sb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(g723_24_encode_sb_sptr self)"""
        return _vocoder_swig.g723_24_encode_sb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(g723_24_encode_sb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.g723_24_encode_sb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(g723_24_encode_sb_sptr self) -> int"""
        return _vocoder_swig.g723_24_encode_sb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(g723_24_encode_sb_sptr self) -> int"""
        return _vocoder_swig.g723_24_encode_sb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(g723_24_encode_sb_sptr self, int priority) -> int"""
        return _vocoder_swig.g723_24_encode_sb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(g723_24_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.g723_24_encode_sb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(g723_24_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.g723_24_encode_sb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(g723_24_encode_sb_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.g723_24_encode_sb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(g723_24_encode_sb_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.g723_24_encode_sb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(g723_24_encode_sb_sptr self) -> long"""
        return _vocoder_swig.g723_24_encode_sb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(g723_24_encode_sb_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.g723_24_encode_sb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(g723_24_encode_sb_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.g723_24_encode_sb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(g723_24_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.g723_24_encode_sb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(g723_24_encode_sb_sptr self, std::string name)"""
        return _vocoder_swig.g723_24_encode_sb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(g723_24_encode_sb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.g723_24_encode_sb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(g723_24_encode_sb_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.g723_24_encode_sb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(g723_24_encode_sb_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.g723_24_encode_sb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(g723_24_encode_sb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.g723_24_encode_sb_sptr_message_subscribers(self, which_port)

# Register g723_24_encode_sb_sptr in _vocoder_swig:
_vocoder_swig.g723_24_encode_sb_sptr_swigregister(g723_24_encode_sb_sptr)


g723_24_encode_sb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
g723_24_encode_sb = g723_24_encode_sb.make;

class g723_40_decode_bs_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::g723_40_decode_bs > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(g723_40_decode_bs_sptr self) -> g723_40_decode_bs_sptr
        __init__(g723_40_decode_bs_sptr self, g723_40_decode_bs p) -> g723_40_decode_bs_sptr
        """
        _vocoder_swig.g723_40_decode_bs_sptr_swiginit(self, _vocoder_swig.new_g723_40_decode_bs_sptr(*args))

    def __deref__(self) -> "gr::vocoder::g723_40_decode_bs *":
        r"""__deref__(g723_40_decode_bs_sptr self) -> g723_40_decode_bs"""
        return _vocoder_swig.g723_40_decode_bs_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_g723_40_decode_bs_sptr

    def make(self) -> "gr::vocoder::g723_40_decode_bs::sptr":
        r"""make(g723_40_decode_bs_sptr self) -> g723_40_decode_bs_sptr"""
        return _vocoder_swig.g723_40_decode_bs_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(g723_40_decode_bs_sptr self) -> unsigned int"""
        return _vocoder_swig.g723_40_decode_bs_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(g723_40_decode_bs_sptr self, int which, int delay)
        declare_sample_delay(g723_40_decode_bs_sptr self, unsigned int delay)
        """
        return _vocoder_swig.g723_40_decode_bs_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(g723_40_decode_bs_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.g723_40_decode_bs_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(g723_40_decode_bs_sptr self, int multiple)"""
        return _vocoder_swig.g723_40_decode_bs_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(g723_40_decode_bs_sptr self) -> int"""
        return _vocoder_swig.g723_40_decode_bs_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(g723_40_decode_bs_sptr self) -> double"""
        return _vocoder_swig.g723_40_decode_bs_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(g723_40_decode_bs_sptr self) -> uint64_t"""
        return _vocoder_swig.g723_40_decode_bs_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(g723_40_decode_bs_sptr self) -> uint64_t"""
        return _vocoder_swig.g723_40_decode_bs_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(g723_40_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.g723_40_decode_bs_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(g723_40_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.g723_40_decode_bs_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(g723_40_decode_bs_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.g723_40_decode_bs_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(g723_40_decode_bs_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.g723_40_decode_bs_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(g723_40_decode_bs_sptr self, std::string level)"""
        return _vocoder_swig.g723_40_decode_bs_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(g723_40_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.g723_40_decode_bs_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(g723_40_decode_bs_sptr self) -> int"""
        return _vocoder_swig.g723_40_decode_bs_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(g723_40_decode_bs_sptr self, int m)"""
        return _vocoder_swig.g723_40_decode_bs_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(g723_40_decode_bs_sptr self)"""
        return _vocoder_swig.g723_40_decode_bs_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(g723_40_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.g723_40_decode_bs_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(g723_40_decode_bs_sptr self, int m)"""
        return _vocoder_swig.g723_40_decode_bs_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(g723_40_decode_bs_sptr self) -> int"""
        return _vocoder_swig.g723_40_decode_bs_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(g723_40_decode_bs_sptr self, int i) -> long"""
        return _vocoder_swig.g723_40_decode_bs_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(g723_40_decode_bs_sptr self, long max_output_buffer)
        set_max_output_buffer(g723_40_decode_bs_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.g723_40_decode_bs_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(g723_40_decode_bs_sptr self, int i) -> long"""
        return _vocoder_swig.g723_40_decode_bs_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(g723_40_decode_bs_sptr self, long min_output_buffer)
        set_min_output_buffer(g723_40_decode_bs_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.g723_40_decode_bs_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(g723_40_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(g723_40_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(g723_40_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(g723_40_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(g723_40_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(g723_40_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(g723_40_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full(g723_40_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(g723_40_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full_avg(g723_40_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(g723_40_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full_var(g723_40_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(g723_40_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full(g723_40_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(g723_40_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full_avg(g723_40_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(g723_40_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full_var(g723_40_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(g723_40_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(g723_40_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(g723_40_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(g723_40_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(g723_40_decode_bs_sptr self) -> float"""
        return _vocoder_swig.g723_40_decode_bs_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(g723_40_decode_bs_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.g723_40_decode_bs_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(g723_40_decode_bs_sptr self)"""
        return _vocoder_swig.g723_40_decode_bs_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(g723_40_decode_bs_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.g723_40_decode_bs_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(g723_40_decode_bs_sptr self) -> int"""
        return _vocoder_swig.g723_40_decode_bs_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(g723_40_decode_bs_sptr self) -> int"""
        return _vocoder_swig.g723_40_decode_bs_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(g723_40_decode_bs_sptr self, int priority) -> int"""
        return _vocoder_swig.g723_40_decode_bs_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(g723_40_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.g723_40_decode_bs_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(g723_40_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.g723_40_decode_bs_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(g723_40_decode_bs_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.g723_40_decode_bs_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(g723_40_decode_bs_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.g723_40_decode_bs_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(g723_40_decode_bs_sptr self) -> long"""
        return _vocoder_swig.g723_40_decode_bs_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(g723_40_decode_bs_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.g723_40_decode_bs_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(g723_40_decode_bs_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.g723_40_decode_bs_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(g723_40_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.g723_40_decode_bs_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(g723_40_decode_bs_sptr self, std::string name)"""
        return _vocoder_swig.g723_40_decode_bs_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(g723_40_decode_bs_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.g723_40_decode_bs_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(g723_40_decode_bs_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.g723_40_decode_bs_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(g723_40_decode_bs_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.g723_40_decode_bs_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(g723_40_decode_bs_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.g723_40_decode_bs_sptr_message_subscribers(self, which_port)

# Register g723_40_decode_bs_sptr in _vocoder_swig:
_vocoder_swig.g723_40_decode_bs_sptr_swigregister(g723_40_decode_bs_sptr)


g723_40_decode_bs_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
g723_40_decode_bs = g723_40_decode_bs.make;

class g723_40_encode_sb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::g723_40_encode_sb > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(g723_40_encode_sb_sptr self) -> g723_40_encode_sb_sptr
        __init__(g723_40_encode_sb_sptr self, g723_40_encode_sb p) -> g723_40_encode_sb_sptr
        """
        _vocoder_swig.g723_40_encode_sb_sptr_swiginit(self, _vocoder_swig.new_g723_40_encode_sb_sptr(*args))

    def __deref__(self) -> "gr::vocoder::g723_40_encode_sb *":
        r"""__deref__(g723_40_encode_sb_sptr self) -> g723_40_encode_sb"""
        return _vocoder_swig.g723_40_encode_sb_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_g723_40_encode_sb_sptr

    def make(self) -> "gr::vocoder::g723_40_encode_sb::sptr":
        r"""make(g723_40_encode_sb_sptr self) -> g723_40_encode_sb_sptr"""
        return _vocoder_swig.g723_40_encode_sb_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(g723_40_encode_sb_sptr self) -> unsigned int"""
        return _vocoder_swig.g723_40_encode_sb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(g723_40_encode_sb_sptr self, int which, int delay)
        declare_sample_delay(g723_40_encode_sb_sptr self, unsigned int delay)
        """
        return _vocoder_swig.g723_40_encode_sb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(g723_40_encode_sb_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.g723_40_encode_sb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(g723_40_encode_sb_sptr self, int multiple)"""
        return _vocoder_swig.g723_40_encode_sb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(g723_40_encode_sb_sptr self) -> int"""
        return _vocoder_swig.g723_40_encode_sb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(g723_40_encode_sb_sptr self) -> double"""
        return _vocoder_swig.g723_40_encode_sb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(g723_40_encode_sb_sptr self) -> uint64_t"""
        return _vocoder_swig.g723_40_encode_sb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(g723_40_encode_sb_sptr self) -> uint64_t"""
        return _vocoder_swig.g723_40_encode_sb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(g723_40_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.g723_40_encode_sb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(g723_40_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.g723_40_encode_sb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(g723_40_encode_sb_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.g723_40_encode_sb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(g723_40_encode_sb_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.g723_40_encode_sb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(g723_40_encode_sb_sptr self, std::string level)"""
        return _vocoder_swig.g723_40_encode_sb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(g723_40_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.g723_40_encode_sb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(g723_40_encode_sb_sptr self) -> int"""
        return _vocoder_swig.g723_40_encode_sb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(g723_40_encode_sb_sptr self, int m)"""
        return _vocoder_swig.g723_40_encode_sb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(g723_40_encode_sb_sptr self)"""
        return _vocoder_swig.g723_40_encode_sb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(g723_40_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.g723_40_encode_sb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(g723_40_encode_sb_sptr self, int m)"""
        return _vocoder_swig.g723_40_encode_sb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(g723_40_encode_sb_sptr self) -> int"""
        return _vocoder_swig.g723_40_encode_sb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(g723_40_encode_sb_sptr self, int i) -> long"""
        return _vocoder_swig.g723_40_encode_sb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(g723_40_encode_sb_sptr self, long max_output_buffer)
        set_max_output_buffer(g723_40_encode_sb_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.g723_40_encode_sb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(g723_40_encode_sb_sptr self, int i) -> long"""
        return _vocoder_swig.g723_40_encode_sb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(g723_40_encode_sb_sptr self, long min_output_buffer)
        set_min_output_buffer(g723_40_encode_sb_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.g723_40_encode_sb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(g723_40_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(g723_40_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(g723_40_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(g723_40_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(g723_40_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(g723_40_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(g723_40_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full(g723_40_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(g723_40_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full_avg(g723_40_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(g723_40_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full_var(g723_40_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(g723_40_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full(g723_40_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(g723_40_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full_avg(g723_40_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(g723_40_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full_var(g723_40_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(g723_40_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(g723_40_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(g723_40_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(g723_40_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(g723_40_encode_sb_sptr self) -> float"""
        return _vocoder_swig.g723_40_encode_sb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(g723_40_encode_sb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.g723_40_encode_sb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(g723_40_encode_sb_sptr self)"""
        return _vocoder_swig.g723_40_encode_sb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(g723_40_encode_sb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.g723_40_encode_sb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(g723_40_encode_sb_sptr self) -> int"""
        return _vocoder_swig.g723_40_encode_sb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(g723_40_encode_sb_sptr self) -> int"""
        return _vocoder_swig.g723_40_encode_sb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(g723_40_encode_sb_sptr self, int priority) -> int"""
        return _vocoder_swig.g723_40_encode_sb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(g723_40_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.g723_40_encode_sb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(g723_40_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.g723_40_encode_sb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(g723_40_encode_sb_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.g723_40_encode_sb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(g723_40_encode_sb_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.g723_40_encode_sb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(g723_40_encode_sb_sptr self) -> long"""
        return _vocoder_swig.g723_40_encode_sb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(g723_40_encode_sb_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.g723_40_encode_sb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(g723_40_encode_sb_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.g723_40_encode_sb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(g723_40_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.g723_40_encode_sb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(g723_40_encode_sb_sptr self, std::string name)"""
        return _vocoder_swig.g723_40_encode_sb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(g723_40_encode_sb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.g723_40_encode_sb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(g723_40_encode_sb_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.g723_40_encode_sb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(g723_40_encode_sb_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.g723_40_encode_sb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(g723_40_encode_sb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.g723_40_encode_sb_sptr_message_subscribers(self, which_port)

# Register g723_40_encode_sb_sptr in _vocoder_swig:
_vocoder_swig.g723_40_encode_sb_sptr_swigregister(g723_40_encode_sb_sptr)


g723_40_encode_sb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
g723_40_encode_sb = g723_40_encode_sb.make;

class ulaw_decode_bs_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::ulaw_decode_bs > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(ulaw_decode_bs_sptr self) -> ulaw_decode_bs_sptr
        __init__(ulaw_decode_bs_sptr self, ulaw_decode_bs p) -> ulaw_decode_bs_sptr
        """
        _vocoder_swig.ulaw_decode_bs_sptr_swiginit(self, _vocoder_swig.new_ulaw_decode_bs_sptr(*args))

    def __deref__(self) -> "gr::vocoder::ulaw_decode_bs *":
        r"""__deref__(ulaw_decode_bs_sptr self) -> ulaw_decode_bs"""
        return _vocoder_swig.ulaw_decode_bs_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_ulaw_decode_bs_sptr

    def make(self) -> "gr::vocoder::ulaw_decode_bs::sptr":
        r"""make(ulaw_decode_bs_sptr self) -> ulaw_decode_bs_sptr"""
        return _vocoder_swig.ulaw_decode_bs_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(ulaw_decode_bs_sptr self) -> unsigned int"""
        return _vocoder_swig.ulaw_decode_bs_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ulaw_decode_bs_sptr self, int which, int delay)
        declare_sample_delay(ulaw_decode_bs_sptr self, unsigned int delay)
        """
        return _vocoder_swig.ulaw_decode_bs_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ulaw_decode_bs_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.ulaw_decode_bs_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ulaw_decode_bs_sptr self, int multiple)"""
        return _vocoder_swig.ulaw_decode_bs_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ulaw_decode_bs_sptr self) -> int"""
        return _vocoder_swig.ulaw_decode_bs_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ulaw_decode_bs_sptr self) -> double"""
        return _vocoder_swig.ulaw_decode_bs_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ulaw_decode_bs_sptr self) -> uint64_t"""
        return _vocoder_swig.ulaw_decode_bs_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ulaw_decode_bs_sptr self) -> uint64_t"""
        return _vocoder_swig.ulaw_decode_bs_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ulaw_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.ulaw_decode_bs_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ulaw_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.ulaw_decode_bs_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ulaw_decode_bs_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.ulaw_decode_bs_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ulaw_decode_bs_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.ulaw_decode_bs_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ulaw_decode_bs_sptr self, std::string level)"""
        return _vocoder_swig.ulaw_decode_bs_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ulaw_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.ulaw_decode_bs_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ulaw_decode_bs_sptr self) -> int"""
        return _vocoder_swig.ulaw_decode_bs_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ulaw_decode_bs_sptr self, int m)"""
        return _vocoder_swig.ulaw_decode_bs_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ulaw_decode_bs_sptr self)"""
        return _vocoder_swig.ulaw_decode_bs_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ulaw_decode_bs_sptr self) -> bool"""
        return _vocoder_swig.ulaw_decode_bs_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ulaw_decode_bs_sptr self, int m)"""
        return _vocoder_swig.ulaw_decode_bs_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ulaw_decode_bs_sptr self) -> int"""
        return _vocoder_swig.ulaw_decode_bs_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ulaw_decode_bs_sptr self, int i) -> long"""
        return _vocoder_swig.ulaw_decode_bs_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ulaw_decode_bs_sptr self, long max_output_buffer)
        set_max_output_buffer(ulaw_decode_bs_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.ulaw_decode_bs_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ulaw_decode_bs_sptr self, int i) -> long"""
        return _vocoder_swig.ulaw_decode_bs_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ulaw_decode_bs_sptr self, long min_output_buffer)
        set_min_output_buffer(ulaw_decode_bs_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.ulaw_decode_bs_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ulaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ulaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ulaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ulaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ulaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ulaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(ulaw_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full(ulaw_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(ulaw_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full_avg(ulaw_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(ulaw_decode_bs_sptr self, int which) -> float
        pc_input_buffers_full_var(ulaw_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(ulaw_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full(ulaw_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(ulaw_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full_avg(ulaw_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(ulaw_decode_bs_sptr self, int which) -> float
        pc_output_buffers_full_var(ulaw_decode_bs_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ulaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ulaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ulaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ulaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ulaw_decode_bs_sptr self) -> float"""
        return _vocoder_swig.ulaw_decode_bs_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ulaw_decode_bs_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.ulaw_decode_bs_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ulaw_decode_bs_sptr self)"""
        return _vocoder_swig.ulaw_decode_bs_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ulaw_decode_bs_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.ulaw_decode_bs_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ulaw_decode_bs_sptr self) -> int"""
        return _vocoder_swig.ulaw_decode_bs_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ulaw_decode_bs_sptr self) -> int"""
        return _vocoder_swig.ulaw_decode_bs_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ulaw_decode_bs_sptr self, int priority) -> int"""
        return _vocoder_swig.ulaw_decode_bs_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ulaw_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.ulaw_decode_bs_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ulaw_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.ulaw_decode_bs_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ulaw_decode_bs_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.ulaw_decode_bs_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ulaw_decode_bs_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.ulaw_decode_bs_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ulaw_decode_bs_sptr self) -> long"""
        return _vocoder_swig.ulaw_decode_bs_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ulaw_decode_bs_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.ulaw_decode_bs_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ulaw_decode_bs_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.ulaw_decode_bs_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ulaw_decode_bs_sptr self) -> std::string"""
        return _vocoder_swig.ulaw_decode_bs_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ulaw_decode_bs_sptr self, std::string name)"""
        return _vocoder_swig.ulaw_decode_bs_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ulaw_decode_bs_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.ulaw_decode_bs_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ulaw_decode_bs_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.ulaw_decode_bs_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ulaw_decode_bs_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.ulaw_decode_bs_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ulaw_decode_bs_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.ulaw_decode_bs_sptr_message_subscribers(self, which_port)

# Register ulaw_decode_bs_sptr in _vocoder_swig:
_vocoder_swig.ulaw_decode_bs_sptr_swigregister(ulaw_decode_bs_sptr)


ulaw_decode_bs_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
ulaw_decode_bs = ulaw_decode_bs.make;

class ulaw_encode_sb_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::ulaw_encode_sb > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(ulaw_encode_sb_sptr self) -> ulaw_encode_sb_sptr
        __init__(ulaw_encode_sb_sptr self, ulaw_encode_sb p) -> ulaw_encode_sb_sptr
        """
        _vocoder_swig.ulaw_encode_sb_sptr_swiginit(self, _vocoder_swig.new_ulaw_encode_sb_sptr(*args))

    def __deref__(self) -> "gr::vocoder::ulaw_encode_sb *":
        r"""__deref__(ulaw_encode_sb_sptr self) -> ulaw_encode_sb"""
        return _vocoder_swig.ulaw_encode_sb_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_ulaw_encode_sb_sptr

    def make(self) -> "gr::vocoder::ulaw_encode_sb::sptr":
        r"""make(ulaw_encode_sb_sptr self) -> ulaw_encode_sb_sptr"""
        return _vocoder_swig.ulaw_encode_sb_sptr_make(self)

    def history(self) -> "unsigned int":
        r"""history(ulaw_encode_sb_sptr self) -> unsigned int"""
        return _vocoder_swig.ulaw_encode_sb_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(ulaw_encode_sb_sptr self, int which, int delay)
        declare_sample_delay(ulaw_encode_sb_sptr self, unsigned int delay)
        """
        return _vocoder_swig.ulaw_encode_sb_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(ulaw_encode_sb_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.ulaw_encode_sb_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(ulaw_encode_sb_sptr self, int multiple)"""
        return _vocoder_swig.ulaw_encode_sb_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(ulaw_encode_sb_sptr self) -> int"""
        return _vocoder_swig.ulaw_encode_sb_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(ulaw_encode_sb_sptr self) -> double"""
        return _vocoder_swig.ulaw_encode_sb_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(ulaw_encode_sb_sptr self) -> uint64_t"""
        return _vocoder_swig.ulaw_encode_sb_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(ulaw_encode_sb_sptr self) -> uint64_t"""
        return _vocoder_swig.ulaw_encode_sb_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(ulaw_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.ulaw_encode_sb_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(ulaw_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.ulaw_encode_sb_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(ulaw_encode_sb_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.ulaw_encode_sb_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(ulaw_encode_sb_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.ulaw_encode_sb_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(ulaw_encode_sb_sptr self, std::string level)"""
        return _vocoder_swig.ulaw_encode_sb_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(ulaw_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.ulaw_encode_sb_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(ulaw_encode_sb_sptr self) -> int"""
        return _vocoder_swig.ulaw_encode_sb_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(ulaw_encode_sb_sptr self, int m)"""
        return _vocoder_swig.ulaw_encode_sb_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(ulaw_encode_sb_sptr self)"""
        return _vocoder_swig.ulaw_encode_sb_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(ulaw_encode_sb_sptr self) -> bool"""
        return _vocoder_swig.ulaw_encode_sb_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(ulaw_encode_sb_sptr self, int m)"""
        return _vocoder_swig.ulaw_encode_sb_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(ulaw_encode_sb_sptr self) -> int"""
        return _vocoder_swig.ulaw_encode_sb_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(ulaw_encode_sb_sptr self, int i) -> long"""
        return _vocoder_swig.ulaw_encode_sb_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(ulaw_encode_sb_sptr self, long max_output_buffer)
        set_max_output_buffer(ulaw_encode_sb_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.ulaw_encode_sb_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(ulaw_encode_sb_sptr self, int i) -> long"""
        return _vocoder_swig.ulaw_encode_sb_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(ulaw_encode_sb_sptr self, long min_output_buffer)
        set_min_output_buffer(ulaw_encode_sb_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.ulaw_encode_sb_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(ulaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(ulaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(ulaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(ulaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(ulaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(ulaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(ulaw_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full(ulaw_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(ulaw_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full_avg(ulaw_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(ulaw_encode_sb_sptr self, int which) -> float
        pc_input_buffers_full_var(ulaw_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(ulaw_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full(ulaw_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(ulaw_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full_avg(ulaw_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(ulaw_encode_sb_sptr self, int which) -> float
        pc_output_buffers_full_var(ulaw_encode_sb_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(ulaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(ulaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(ulaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(ulaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(ulaw_encode_sb_sptr self) -> float"""
        return _vocoder_swig.ulaw_encode_sb_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(ulaw_encode_sb_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.ulaw_encode_sb_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(ulaw_encode_sb_sptr self)"""
        return _vocoder_swig.ulaw_encode_sb_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(ulaw_encode_sb_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.ulaw_encode_sb_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(ulaw_encode_sb_sptr self) -> int"""
        return _vocoder_swig.ulaw_encode_sb_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(ulaw_encode_sb_sptr self) -> int"""
        return _vocoder_swig.ulaw_encode_sb_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(ulaw_encode_sb_sptr self, int priority) -> int"""
        return _vocoder_swig.ulaw_encode_sb_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(ulaw_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.ulaw_encode_sb_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(ulaw_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.ulaw_encode_sb_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(ulaw_encode_sb_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.ulaw_encode_sb_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(ulaw_encode_sb_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.ulaw_encode_sb_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(ulaw_encode_sb_sptr self) -> long"""
        return _vocoder_swig.ulaw_encode_sb_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(ulaw_encode_sb_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.ulaw_encode_sb_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(ulaw_encode_sb_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.ulaw_encode_sb_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(ulaw_encode_sb_sptr self) -> std::string"""
        return _vocoder_swig.ulaw_encode_sb_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(ulaw_encode_sb_sptr self, std::string name)"""
        return _vocoder_swig.ulaw_encode_sb_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(ulaw_encode_sb_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.ulaw_encode_sb_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(ulaw_encode_sb_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.ulaw_encode_sb_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(ulaw_encode_sb_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.ulaw_encode_sb_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(ulaw_encode_sb_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.ulaw_encode_sb_sptr_message_subscribers(self, which_port)

# Register ulaw_encode_sb_sptr in _vocoder_swig:
_vocoder_swig.ulaw_encode_sb_sptr_swigregister(ulaw_encode_sb_sptr)


ulaw_encode_sb_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
ulaw_encode_sb = ulaw_encode_sb.make;

CODEC2_MODE_3200 = _vocoder_swig.CODEC2_MODE_3200

CODEC2_MODE_2400 = _vocoder_swig.CODEC2_MODE_2400

CODEC2_MODE_1600 = _vocoder_swig.CODEC2_MODE_1600

CODEC2_MODE_1400 = _vocoder_swig.CODEC2_MODE_1400

CODEC2_MODE_1300 = _vocoder_swig.CODEC2_MODE_1300

CODEC2_MODE_1200 = _vocoder_swig.CODEC2_MODE_1200

CODEC2_MODE_700 = _vocoder_swig.CODEC2_MODE_700

CODEC2_MODE_700B = _vocoder_swig.CODEC2_MODE_700B

CODEC2_MODE_700C = _vocoder_swig.CODEC2_MODE_700C

CODEC2_MODE_450 = _vocoder_swig.CODEC2_MODE_450

CODEC2_MODE_450PWB = _vocoder_swig.CODEC2_MODE_450PWB

CODEC2_MODE_EN_DEFAULT = _vocoder_swig.CODEC2_MODE_EN_DEFAULT

CODEC2_MODE_3200_EN = _vocoder_swig.CODEC2_MODE_3200_EN

CODEC2_MODE_2400_EN = _vocoder_swig.CODEC2_MODE_2400_EN

CODEC2_MODE_1600_EN = _vocoder_swig.CODEC2_MODE_1600_EN

CODEC2_MODE_1400_EN = _vocoder_swig.CODEC2_MODE_1400_EN

CODEC2_MODE_1300_EN = _vocoder_swig.CODEC2_MODE_1300_EN

CODEC2_MODE_1200_EN = _vocoder_swig.CODEC2_MODE_1200_EN

CODEC2_MODE_700_EN = _vocoder_swig.CODEC2_MODE_700_EN

CODEC2_MODE_700B_EN = _vocoder_swig.CODEC2_MODE_700B_EN

CODEC2_MODE_700C_EN = _vocoder_swig.CODEC2_MODE_700C_EN

CODEC2_MODE_450_EN = _vocoder_swig.CODEC2_MODE_450_EN

CODEC2_MODE_450PWB_EN = _vocoder_swig.CODEC2_MODE_450PWB_EN


def codec2_create(mode: "int") -> "CODEC2 *":
    r"""codec2_create(int mode) -> CODEC2 *"""
    return _vocoder_swig.codec2_create(mode)

def codec2_destroy(codec2_state: "CODEC2 *") -> "void":
    r"""codec2_destroy(CODEC2 * codec2_state)"""
    return _vocoder_swig.codec2_destroy(codec2_state)

def codec2_encode(codec2_state: "CODEC2 *", bits: "unsigned char *", speech_in: "short []") -> "void":
    r"""codec2_encode(CODEC2 * codec2_state, unsigned char * bits, short [] speech_in)"""
    return _vocoder_swig.codec2_encode(codec2_state, bits, speech_in)

def codec2_decode(codec2_state: "CODEC2 *", speech_out: "short []", bits: "unsigned char const *") -> "void":
    r"""codec2_decode(CODEC2 * codec2_state, short [] speech_out, unsigned char const * bits)"""
    return _vocoder_swig.codec2_decode(codec2_state, speech_out, bits)

def codec2_decode_ber(codec2_state: "CODEC2 *", speech_out: "short []", bits: "unsigned char const *", ber_est: "float") -> "void":
    r"""codec2_decode_ber(CODEC2 * codec2_state, short [] speech_out, unsigned char const * bits, float ber_est)"""
    return _vocoder_swig.codec2_decode_ber(codec2_state, speech_out, bits, ber_est)

def codec2_samples_per_frame(codec2_state: "CODEC2 *") -> "int":
    r"""codec2_samples_per_frame(CODEC2 * codec2_state) -> int"""
    return _vocoder_swig.codec2_samples_per_frame(codec2_state)

def codec2_bits_per_frame(codec2_state: "CODEC2 *") -> "int":
    r"""codec2_bits_per_frame(CODEC2 * codec2_state) -> int"""
    return _vocoder_swig.codec2_bits_per_frame(codec2_state)

def codec2_set_lpc_post_filter(codec2_state: "CODEC2 *", enable: "int", bass_boost: "int", beta: "float", gamma: "float") -> "void":
    r"""codec2_set_lpc_post_filter(CODEC2 * codec2_state, int enable, int bass_boost, float beta, float gamma)"""
    return _vocoder_swig.codec2_set_lpc_post_filter(codec2_state, enable, bass_boost, beta, gamma)

def codec2_get_spare_bit_index(codec2_state: "CODEC2 *") -> "int":
    r"""codec2_get_spare_bit_index(CODEC2 * codec2_state) -> int"""
    return _vocoder_swig.codec2_get_spare_bit_index(codec2_state)

def codec2_rebuild_spare_bit(codec2_state: "CODEC2 *", unpacked_bits: "int []") -> "int":
    r"""codec2_rebuild_spare_bit(CODEC2 * codec2_state, int [] unpacked_bits) -> int"""
    return _vocoder_swig.codec2_rebuild_spare_bit(codec2_state, unpacked_bits)

def codec2_set_natural_or_gray(codec2_state: "CODEC2 *", gray: "int") -> "void":
    r"""codec2_set_natural_or_gray(CODEC2 * codec2_state, int gray)"""
    return _vocoder_swig.codec2_set_natural_or_gray(codec2_state, gray)

def codec2_set_softdec(c2: "CODEC2 *", softdec: "float *") -> "void":
    r"""codec2_set_softdec(CODEC2 * c2, float * softdec)"""
    return _vocoder_swig.codec2_set_softdec(c2, softdec)

def codec2_get_energy(codec2_state: "CODEC2 *", bits: "unsigned char const *") -> "float":
    r"""codec2_get_energy(CODEC2 * codec2_state, unsigned char const * bits) -> float"""
    return _vocoder_swig.codec2_get_energy(codec2_state, bits)

def codec2_open_mlfeat(codec2_state: "CODEC2 *", filename: "char *") -> "void":
    r"""codec2_open_mlfeat(CODEC2 * codec2_state, char * filename)"""
    return _vocoder_swig.codec2_open_mlfeat(codec2_state, filename)

def codec2_load_codebook(codec2_state: "CODEC2 *", num: "int", filename: "char *") -> "void":
    r"""codec2_load_codebook(CODEC2 * codec2_state, int num, char * filename)"""
    return _vocoder_swig.codec2_load_codebook(codec2_state, num, filename)

def codec2_get_var(codec2_state: "CODEC2 *") -> "float":
    r"""codec2_get_var(CODEC2 * codec2_state) -> float"""
    return _vocoder_swig.codec2_get_var(codec2_state)

def codec2_enable_user_ratek(codec2_state: "CODEC2 *", K: "int *") -> "float *":
    r"""codec2_enable_user_ratek(CODEC2 * codec2_state, int * K) -> float *"""
    return _vocoder_swig.codec2_enable_user_ratek(codec2_state, K)

def codec2_700c_post_filter(codec2_state: "CODEC2 *", en: "int") -> "void":
    r"""codec2_700c_post_filter(CODEC2 * codec2_state, int en)"""
    return _vocoder_swig.codec2_700c_post_filter(codec2_state, en)

def codec2_700c_eq(codec2_state: "CODEC2 *", en: "int") -> "void":
    r"""codec2_700c_eq(CODEC2 * codec2_state, int en)"""
    return _vocoder_swig.codec2_700c_eq(codec2_state, en)
class codec2(object):
    r"""Proxy of C++ gr::vocoder::codec2 class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    MODE_3200 = _vocoder_swig.codec2_MODE_3200
    
    MODE_2400 = _vocoder_swig.codec2_MODE_2400
    
    MODE_1600 = _vocoder_swig.codec2_MODE_1600
    
    MODE_1400 = _vocoder_swig.codec2_MODE_1400
    
    MODE_1300 = _vocoder_swig.codec2_MODE_1300
    
    MODE_1200 = _vocoder_swig.codec2_MODE_1200
    
    MODE_700 = _vocoder_swig.codec2_MODE_700
    
    MODE_700B = _vocoder_swig.codec2_MODE_700B
    
    MODE_700C = _vocoder_swig.codec2_MODE_700C
    

    def __init__(self):
        r"""__init__(codec2 self) -> codec2"""
        _vocoder_swig.codec2_swiginit(self, _vocoder_swig.new_codec2())
    __swig_destroy__ = _vocoder_swig.delete_codec2

# Register codec2 in _vocoder_swig:
_vocoder_swig.codec2_swigregister(codec2)

class codec2_decode_ps(object):
    r"""Proxy of C++ gr::vocoder::codec2_decode_ps class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make(*args, **kwargs) -> "gr::vocoder::codec2_decode_ps::sptr":
        r"""make(int mode=MODE_2400) -> codec2_decode_ps_sptr"""
        return _vocoder_swig.codec2_decode_ps_make(*args, **kwargs)
    __swig_destroy__ = _vocoder_swig.delete_codec2_decode_ps

# Register codec2_decode_ps in _vocoder_swig:
_vocoder_swig.codec2_decode_ps_swigregister(codec2_decode_ps)

def codec2_decode_ps_make(*args, **kwargs) -> "gr::vocoder::codec2_decode_ps::sptr":
    r"""codec2_decode_ps_make(int mode=MODE_2400) -> codec2_decode_ps_sptr"""
    return _vocoder_swig.codec2_decode_ps_make(*args, **kwargs)

class codec2_encode_sp(object):
    r"""Proxy of C++ gr::vocoder::codec2_encode_sp class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make(*args, **kwargs) -> "gr::vocoder::codec2_encode_sp::sptr":
        r"""make(int mode=MODE_2400) -> codec2_encode_sp_sptr"""
        return _vocoder_swig.codec2_encode_sp_make(*args, **kwargs)
    __swig_destroy__ = _vocoder_swig.delete_codec2_encode_sp

# Register codec2_encode_sp in _vocoder_swig:
_vocoder_swig.codec2_encode_sp_swigregister(codec2_encode_sp)

def codec2_encode_sp_make(*args, **kwargs) -> "gr::vocoder::codec2_encode_sp::sptr":
    r"""codec2_encode_sp_make(int mode=MODE_2400) -> codec2_encode_sp_sptr"""
    return _vocoder_swig.codec2_encode_sp_make(*args, **kwargs)

class codec2_decode_ps_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::codec2_decode_ps > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(codec2_decode_ps_sptr self) -> codec2_decode_ps_sptr
        __init__(codec2_decode_ps_sptr self, codec2_decode_ps p) -> codec2_decode_ps_sptr
        """
        _vocoder_swig.codec2_decode_ps_sptr_swiginit(self, _vocoder_swig.new_codec2_decode_ps_sptr(*args))

    def __deref__(self) -> "gr::vocoder::codec2_decode_ps *":
        r"""__deref__(codec2_decode_ps_sptr self) -> codec2_decode_ps"""
        return _vocoder_swig.codec2_decode_ps_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_codec2_decode_ps_sptr

    def make(self, *args, **kwargs) -> "gr::vocoder::codec2_decode_ps::sptr":
        r"""make(codec2_decode_ps_sptr self, int mode=MODE_2400) -> codec2_decode_ps_sptr"""
        return _vocoder_swig.codec2_decode_ps_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(codec2_decode_ps_sptr self) -> unsigned int"""
        return _vocoder_swig.codec2_decode_ps_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(codec2_decode_ps_sptr self, int which, int delay)
        declare_sample_delay(codec2_decode_ps_sptr self, unsigned int delay)
        """
        return _vocoder_swig.codec2_decode_ps_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(codec2_decode_ps_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.codec2_decode_ps_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(codec2_decode_ps_sptr self, int multiple)"""
        return _vocoder_swig.codec2_decode_ps_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(codec2_decode_ps_sptr self) -> int"""
        return _vocoder_swig.codec2_decode_ps_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(codec2_decode_ps_sptr self) -> double"""
        return _vocoder_swig.codec2_decode_ps_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(codec2_decode_ps_sptr self) -> uint64_t"""
        return _vocoder_swig.codec2_decode_ps_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(codec2_decode_ps_sptr self) -> uint64_t"""
        return _vocoder_swig.codec2_decode_ps_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(codec2_decode_ps_sptr self) -> bool"""
        return _vocoder_swig.codec2_decode_ps_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(codec2_decode_ps_sptr self) -> bool"""
        return _vocoder_swig.codec2_decode_ps_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(codec2_decode_ps_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.codec2_decode_ps_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(codec2_decode_ps_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.codec2_decode_ps_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(codec2_decode_ps_sptr self, std::string level)"""
        return _vocoder_swig.codec2_decode_ps_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(codec2_decode_ps_sptr self) -> std::string"""
        return _vocoder_swig.codec2_decode_ps_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(codec2_decode_ps_sptr self) -> int"""
        return _vocoder_swig.codec2_decode_ps_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(codec2_decode_ps_sptr self, int m)"""
        return _vocoder_swig.codec2_decode_ps_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(codec2_decode_ps_sptr self)"""
        return _vocoder_swig.codec2_decode_ps_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(codec2_decode_ps_sptr self) -> bool"""
        return _vocoder_swig.codec2_decode_ps_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(codec2_decode_ps_sptr self, int m)"""
        return _vocoder_swig.codec2_decode_ps_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(codec2_decode_ps_sptr self) -> int"""
        return _vocoder_swig.codec2_decode_ps_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(codec2_decode_ps_sptr self, int i) -> long"""
        return _vocoder_swig.codec2_decode_ps_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(codec2_decode_ps_sptr self, long max_output_buffer)
        set_max_output_buffer(codec2_decode_ps_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.codec2_decode_ps_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(codec2_decode_ps_sptr self, int i) -> long"""
        return _vocoder_swig.codec2_decode_ps_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(codec2_decode_ps_sptr self, long min_output_buffer)
        set_min_output_buffer(codec2_decode_ps_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.codec2_decode_ps_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(codec2_decode_ps_sptr self) -> float"""
        return _vocoder_swig.codec2_decode_ps_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(codec2_decode_ps_sptr self) -> float"""
        return _vocoder_swig.codec2_decode_ps_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(codec2_decode_ps_sptr self) -> float"""
        return _vocoder_swig.codec2_decode_ps_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(codec2_decode_ps_sptr self) -> float"""
        return _vocoder_swig.codec2_decode_ps_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(codec2_decode_ps_sptr self) -> float"""
        return _vocoder_swig.codec2_decode_ps_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(codec2_decode_ps_sptr self) -> float"""
        return _vocoder_swig.codec2_decode_ps_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(codec2_decode_ps_sptr self, int which) -> float
        pc_input_buffers_full(codec2_decode_ps_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.codec2_decode_ps_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(codec2_decode_ps_sptr self, int which) -> float
        pc_input_buffers_full_avg(codec2_decode_ps_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.codec2_decode_ps_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(codec2_decode_ps_sptr self, int which) -> float
        pc_input_buffers_full_var(codec2_decode_ps_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.codec2_decode_ps_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(codec2_decode_ps_sptr self, int which) -> float
        pc_output_buffers_full(codec2_decode_ps_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.codec2_decode_ps_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(codec2_decode_ps_sptr self, int which) -> float
        pc_output_buffers_full_avg(codec2_decode_ps_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.codec2_decode_ps_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(codec2_decode_ps_sptr self, int which) -> float
        pc_output_buffers_full_var(codec2_decode_ps_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.codec2_decode_ps_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(codec2_decode_ps_sptr self) -> float"""
        return _vocoder_swig.codec2_decode_ps_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(codec2_decode_ps_sptr self) -> float"""
        return _vocoder_swig.codec2_decode_ps_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(codec2_decode_ps_sptr self) -> float"""
        return _vocoder_swig.codec2_decode_ps_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(codec2_decode_ps_sptr self) -> float"""
        return _vocoder_swig.codec2_decode_ps_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(codec2_decode_ps_sptr self) -> float"""
        return _vocoder_swig.codec2_decode_ps_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(codec2_decode_ps_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.codec2_decode_ps_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(codec2_decode_ps_sptr self)"""
        return _vocoder_swig.codec2_decode_ps_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(codec2_decode_ps_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.codec2_decode_ps_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(codec2_decode_ps_sptr self) -> int"""
        return _vocoder_swig.codec2_decode_ps_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(codec2_decode_ps_sptr self) -> int"""
        return _vocoder_swig.codec2_decode_ps_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(codec2_decode_ps_sptr self, int priority) -> int"""
        return _vocoder_swig.codec2_decode_ps_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(codec2_decode_ps_sptr self) -> std::string"""
        return _vocoder_swig.codec2_decode_ps_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(codec2_decode_ps_sptr self) -> std::string"""
        return _vocoder_swig.codec2_decode_ps_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(codec2_decode_ps_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.codec2_decode_ps_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(codec2_decode_ps_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.codec2_decode_ps_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(codec2_decode_ps_sptr self) -> long"""
        return _vocoder_swig.codec2_decode_ps_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(codec2_decode_ps_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.codec2_decode_ps_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(codec2_decode_ps_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.codec2_decode_ps_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(codec2_decode_ps_sptr self) -> std::string"""
        return _vocoder_swig.codec2_decode_ps_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(codec2_decode_ps_sptr self, std::string name)"""
        return _vocoder_swig.codec2_decode_ps_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(codec2_decode_ps_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.codec2_decode_ps_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(codec2_decode_ps_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.codec2_decode_ps_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(codec2_decode_ps_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.codec2_decode_ps_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(codec2_decode_ps_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.codec2_decode_ps_sptr_message_subscribers(self, which_port)

# Register codec2_decode_ps_sptr in _vocoder_swig:
_vocoder_swig.codec2_decode_ps_sptr_swigregister(codec2_decode_ps_sptr)


codec2_decode_ps_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
codec2_decode_ps = codec2_decode_ps.make;

class codec2_encode_sp_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::codec2_encode_sp > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(codec2_encode_sp_sptr self) -> codec2_encode_sp_sptr
        __init__(codec2_encode_sp_sptr self, codec2_encode_sp p) -> codec2_encode_sp_sptr
        """
        _vocoder_swig.codec2_encode_sp_sptr_swiginit(self, _vocoder_swig.new_codec2_encode_sp_sptr(*args))

    def __deref__(self) -> "gr::vocoder::codec2_encode_sp *":
        r"""__deref__(codec2_encode_sp_sptr self) -> codec2_encode_sp"""
        return _vocoder_swig.codec2_encode_sp_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_codec2_encode_sp_sptr

    def make(self, *args, **kwargs) -> "gr::vocoder::codec2_encode_sp::sptr":
        r"""make(codec2_encode_sp_sptr self, int mode=MODE_2400) -> codec2_encode_sp_sptr"""
        return _vocoder_swig.codec2_encode_sp_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(codec2_encode_sp_sptr self) -> unsigned int"""
        return _vocoder_swig.codec2_encode_sp_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(codec2_encode_sp_sptr self, int which, int delay)
        declare_sample_delay(codec2_encode_sp_sptr self, unsigned int delay)
        """
        return _vocoder_swig.codec2_encode_sp_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(codec2_encode_sp_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.codec2_encode_sp_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(codec2_encode_sp_sptr self, int multiple)"""
        return _vocoder_swig.codec2_encode_sp_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(codec2_encode_sp_sptr self) -> int"""
        return _vocoder_swig.codec2_encode_sp_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(codec2_encode_sp_sptr self) -> double"""
        return _vocoder_swig.codec2_encode_sp_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(codec2_encode_sp_sptr self) -> uint64_t"""
        return _vocoder_swig.codec2_encode_sp_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(codec2_encode_sp_sptr self) -> uint64_t"""
        return _vocoder_swig.codec2_encode_sp_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(codec2_encode_sp_sptr self) -> bool"""
        return _vocoder_swig.codec2_encode_sp_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(codec2_encode_sp_sptr self) -> bool"""
        return _vocoder_swig.codec2_encode_sp_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(codec2_encode_sp_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.codec2_encode_sp_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(codec2_encode_sp_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.codec2_encode_sp_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(codec2_encode_sp_sptr self, std::string level)"""
        return _vocoder_swig.codec2_encode_sp_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(codec2_encode_sp_sptr self) -> std::string"""
        return _vocoder_swig.codec2_encode_sp_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(codec2_encode_sp_sptr self) -> int"""
        return _vocoder_swig.codec2_encode_sp_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(codec2_encode_sp_sptr self, int m)"""
        return _vocoder_swig.codec2_encode_sp_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(codec2_encode_sp_sptr self)"""
        return _vocoder_swig.codec2_encode_sp_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(codec2_encode_sp_sptr self) -> bool"""
        return _vocoder_swig.codec2_encode_sp_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(codec2_encode_sp_sptr self, int m)"""
        return _vocoder_swig.codec2_encode_sp_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(codec2_encode_sp_sptr self) -> int"""
        return _vocoder_swig.codec2_encode_sp_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(codec2_encode_sp_sptr self, int i) -> long"""
        return _vocoder_swig.codec2_encode_sp_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(codec2_encode_sp_sptr self, long max_output_buffer)
        set_max_output_buffer(codec2_encode_sp_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.codec2_encode_sp_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(codec2_encode_sp_sptr self, int i) -> long"""
        return _vocoder_swig.codec2_encode_sp_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(codec2_encode_sp_sptr self, long min_output_buffer)
        set_min_output_buffer(codec2_encode_sp_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.codec2_encode_sp_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(codec2_encode_sp_sptr self) -> float"""
        return _vocoder_swig.codec2_encode_sp_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(codec2_encode_sp_sptr self) -> float"""
        return _vocoder_swig.codec2_encode_sp_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(codec2_encode_sp_sptr self) -> float"""
        return _vocoder_swig.codec2_encode_sp_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(codec2_encode_sp_sptr self) -> float"""
        return _vocoder_swig.codec2_encode_sp_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(codec2_encode_sp_sptr self) -> float"""
        return _vocoder_swig.codec2_encode_sp_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(codec2_encode_sp_sptr self) -> float"""
        return _vocoder_swig.codec2_encode_sp_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(codec2_encode_sp_sptr self, int which) -> float
        pc_input_buffers_full(codec2_encode_sp_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.codec2_encode_sp_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(codec2_encode_sp_sptr self, int which) -> float
        pc_input_buffers_full_avg(codec2_encode_sp_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.codec2_encode_sp_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(codec2_encode_sp_sptr self, int which) -> float
        pc_input_buffers_full_var(codec2_encode_sp_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.codec2_encode_sp_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(codec2_encode_sp_sptr self, int which) -> float
        pc_output_buffers_full(codec2_encode_sp_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.codec2_encode_sp_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(codec2_encode_sp_sptr self, int which) -> float
        pc_output_buffers_full_avg(codec2_encode_sp_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.codec2_encode_sp_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(codec2_encode_sp_sptr self, int which) -> float
        pc_output_buffers_full_var(codec2_encode_sp_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.codec2_encode_sp_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(codec2_encode_sp_sptr self) -> float"""
        return _vocoder_swig.codec2_encode_sp_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(codec2_encode_sp_sptr self) -> float"""
        return _vocoder_swig.codec2_encode_sp_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(codec2_encode_sp_sptr self) -> float"""
        return _vocoder_swig.codec2_encode_sp_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(codec2_encode_sp_sptr self) -> float"""
        return _vocoder_swig.codec2_encode_sp_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(codec2_encode_sp_sptr self) -> float"""
        return _vocoder_swig.codec2_encode_sp_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(codec2_encode_sp_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.codec2_encode_sp_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(codec2_encode_sp_sptr self)"""
        return _vocoder_swig.codec2_encode_sp_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(codec2_encode_sp_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.codec2_encode_sp_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(codec2_encode_sp_sptr self) -> int"""
        return _vocoder_swig.codec2_encode_sp_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(codec2_encode_sp_sptr self) -> int"""
        return _vocoder_swig.codec2_encode_sp_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(codec2_encode_sp_sptr self, int priority) -> int"""
        return _vocoder_swig.codec2_encode_sp_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(codec2_encode_sp_sptr self) -> std::string"""
        return _vocoder_swig.codec2_encode_sp_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(codec2_encode_sp_sptr self) -> std::string"""
        return _vocoder_swig.codec2_encode_sp_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(codec2_encode_sp_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.codec2_encode_sp_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(codec2_encode_sp_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.codec2_encode_sp_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(codec2_encode_sp_sptr self) -> long"""
        return _vocoder_swig.codec2_encode_sp_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(codec2_encode_sp_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.codec2_encode_sp_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(codec2_encode_sp_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.codec2_encode_sp_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(codec2_encode_sp_sptr self) -> std::string"""
        return _vocoder_swig.codec2_encode_sp_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(codec2_encode_sp_sptr self, std::string name)"""
        return _vocoder_swig.codec2_encode_sp_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(codec2_encode_sp_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.codec2_encode_sp_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(codec2_encode_sp_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.codec2_encode_sp_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(codec2_encode_sp_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.codec2_encode_sp_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(codec2_encode_sp_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.codec2_encode_sp_sptr_message_subscribers(self, which_port)

# Register codec2_encode_sp_sptr in _vocoder_swig:
_vocoder_swig.codec2_encode_sp_sptr_swigregister(codec2_encode_sp_sptr)


codec2_encode_sp_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
codec2_encode_sp = codec2_encode_sp.make;

FREEDV_MODE_1600 = _vocoder_swig.FREEDV_MODE_1600

FREEDV_MODE_700 = _vocoder_swig.FREEDV_MODE_700

FREEDV_MODE_700B = _vocoder_swig.FREEDV_MODE_700B

FREEDV_MODE_2400A = _vocoder_swig.FREEDV_MODE_2400A

FREEDV_MODE_2400B = _vocoder_swig.FREEDV_MODE_2400B

FREEDV_MODE_800XA = _vocoder_swig.FREEDV_MODE_800XA

FREEDV_MODE_700C = _vocoder_swig.FREEDV_MODE_700C

FREEDV_MODE_700D = _vocoder_swig.FREEDV_MODE_700D

FREEDV_MODE_2020 = _vocoder_swig.FREEDV_MODE_2020

FREEDV_MODE_EN_DEFAULT = _vocoder_swig.FREEDV_MODE_EN_DEFAULT

FREEDV_MODE_1600_EN = _vocoder_swig.FREEDV_MODE_1600_EN

FREEDV_MODE_700_EN = _vocoder_swig.FREEDV_MODE_700_EN

FREEDV_MODE_700B_EN = _vocoder_swig.FREEDV_MODE_700B_EN

FREEDV_MODE_700C_EN = _vocoder_swig.FREEDV_MODE_700C_EN

FREEDV_MODE_700D_EN = _vocoder_swig.FREEDV_MODE_700D_EN

FREEDV_MODE_2400A_EN = _vocoder_swig.FREEDV_MODE_2400A_EN

FREEDV_MODE_2400B_EN = _vocoder_swig.FREEDV_MODE_2400B_EN

FREEDV_MODE_800XA_EN = _vocoder_swig.FREEDV_MODE_800XA_EN

FREEDV_MODE_2020_EN = _vocoder_swig.FREEDV_MODE_2020_EN

FREEDV_SYNC_UNSYNC = _vocoder_swig.FREEDV_SYNC_UNSYNC

FREEDV_SYNC_AUTO = _vocoder_swig.FREEDV_SYNC_AUTO

FREEDV_SYNC_MANUAL = _vocoder_swig.FREEDV_SYNC_MANUAL

class freedv_advanced(object):
    r"""Proxy of C++ freedv_advanced class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    interleave_frames = property(_vocoder_swig.freedv_advanced_interleave_frames_get, _vocoder_swig.freedv_advanced_interleave_frames_set, doc=r"""interleave_frames : int""")

    def __init__(self):
        r"""__init__(freedv_advanced self) -> freedv_advanced"""
        _vocoder_swig.freedv_advanced_swiginit(self, _vocoder_swig.new_freedv_advanced())
    __swig_destroy__ = _vocoder_swig.delete_freedv_advanced

# Register freedv_advanced in _vocoder_swig:
_vocoder_swig.freedv_advanced_swigregister(freedv_advanced)


def freedv_open(mode: "int") -> "freedv *":
    r"""freedv_open(int mode) -> freedv *"""
    return _vocoder_swig.freedv_open(mode)

def freedv_open_advanced(mode: "int", adv: "freedv_advanced") -> "freedv *":
    r"""freedv_open_advanced(int mode, freedv_advanced adv) -> freedv *"""
    return _vocoder_swig.freedv_open_advanced(mode, adv)

def freedv_close(freedv: "freedv *") -> "void":
    r"""freedv_close(freedv * freedv)"""
    return _vocoder_swig.freedv_close(freedv)

def freedv_tx(freedv: "freedv *", mod_out: "short []", speech_in: "short []") -> "void":
    r"""freedv_tx(freedv * freedv, short [] mod_out, short [] speech_in)"""
    return _vocoder_swig.freedv_tx(freedv, mod_out, speech_in)

def freedv_comptx(freedv: "freedv *", mod_out: "COMP []", speech_in: "short []") -> "void":
    r"""freedv_comptx(freedv * freedv, COMP [] mod_out, short [] speech_in)"""
    return _vocoder_swig.freedv_comptx(freedv, mod_out, speech_in)

def freedv_codectx(f: "freedv *", mod_out: "short []", packed_codec_bits: "unsigned char *") -> "void":
    r"""freedv_codectx(freedv * f, short [] mod_out, unsigned char * packed_codec_bits)"""
    return _vocoder_swig.freedv_codectx(f, mod_out, packed_codec_bits)

def freedv_datatx(f: "freedv *", mod_out: "short []") -> "void":
    r"""freedv_datatx(freedv * f, short [] mod_out)"""
    return _vocoder_swig.freedv_datatx(f, mod_out)

def freedv_data_ntxframes(freedv: "freedv *") -> "int":
    r"""freedv_data_ntxframes(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_data_ntxframes(freedv)

def freedv_nin(freedv: "freedv *") -> "int":
    r"""freedv_nin(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_nin(freedv)

def freedv_rx(freedv: "freedv *", speech_out: "short []", demod_in: "short []") -> "int":
    r"""freedv_rx(freedv * freedv, short [] speech_out, short [] demod_in) -> int"""
    return _vocoder_swig.freedv_rx(freedv, speech_out, demod_in)

def freedv_shortrx(freedv: "freedv *", speech_out: "short []", demod_in: "short []", gain: "float") -> "int":
    r"""freedv_shortrx(freedv * freedv, short [] speech_out, short [] demod_in, float gain) -> int"""
    return _vocoder_swig.freedv_shortrx(freedv, speech_out, demod_in, gain)

def freedv_floatrx(freedv: "freedv *", speech_out: "short []", demod_in: "float []") -> "int":
    r"""freedv_floatrx(freedv * freedv, short [] speech_out, float [] demod_in) -> int"""
    return _vocoder_swig.freedv_floatrx(freedv, speech_out, demod_in)

def freedv_comprx(freedv: "freedv *", speech_out: "short []", demod_in: "COMP []") -> "int":
    r"""freedv_comprx(freedv * freedv, short [] speech_out, COMP [] demod_in) -> int"""
    return _vocoder_swig.freedv_comprx(freedv, speech_out, demod_in)

def freedv_codecrx(freedv: "freedv *", packed_codec_bits: "unsigned char *", demod_in: "short []") -> "int":
    r"""freedv_codecrx(freedv * freedv, unsigned char * packed_codec_bits, short [] demod_in) -> int"""
    return _vocoder_swig.freedv_codecrx(freedv, packed_codec_bits, demod_in)

def freedv_set_callback_txt(freedv: "freedv *", rx: "freedv_callback_rx", tx: "freedv_callback_tx", callback_state: "void *") -> "void":
    r"""freedv_set_callback_txt(freedv * freedv, freedv_callback_rx rx, freedv_callback_tx tx, void * callback_state)"""
    return _vocoder_swig.freedv_set_callback_txt(freedv, rx, tx, callback_state)

def freedv_set_callback_protocol(freedv: "freedv *", rx: "freedv_callback_protorx", tx: "freedv_callback_prototx", callback_state: "void *") -> "void":
    r"""freedv_set_callback_protocol(freedv * freedv, freedv_callback_protorx rx, freedv_callback_prototx tx, void * callback_state)"""
    return _vocoder_swig.freedv_set_callback_protocol(freedv, rx, tx, callback_state)

def freedv_set_callback_data(freedv: "freedv *", datarx: "freedv_callback_datarx", datatx: "freedv_callback_datatx", callback_state: "void *") -> "void":
    r"""freedv_set_callback_data(freedv * freedv, freedv_callback_datarx datarx, freedv_callback_datatx datatx, void * callback_state)"""
    return _vocoder_swig.freedv_set_callback_data(freedv, datarx, datatx, callback_state)

def freedv_set_test_frames(freedv: "freedv *", test_frames: "int") -> "void":
    r"""freedv_set_test_frames(freedv * freedv, int test_frames)"""
    return _vocoder_swig.freedv_set_test_frames(freedv, test_frames)

def freedv_set_test_frames_diversity(freedv: "freedv *", test_frames_diversity: "int") -> "void":
    r"""freedv_set_test_frames_diversity(freedv * freedv, int test_frames_diversity)"""
    return _vocoder_swig.freedv_set_test_frames_diversity(freedv, test_frames_diversity)

def freedv_set_squelch_en(freedv: "freedv *", squelch_en: "int") -> "void":
    r"""freedv_set_squelch_en(freedv * freedv, int squelch_en)"""
    return _vocoder_swig.freedv_set_squelch_en(freedv, squelch_en)

def freedv_set_snr_squelch_thresh(freedv: "freedv *", snr_squelch_thresh: "float") -> "void":
    r"""freedv_set_snr_squelch_thresh(freedv * freedv, float snr_squelch_thresh)"""
    return _vocoder_swig.freedv_set_snr_squelch_thresh(freedv, snr_squelch_thresh)

def freedv_set_total_bit_errors(freedv: "freedv *", val: "int") -> "void":
    r"""freedv_set_total_bit_errors(freedv * freedv, int val)"""
    return _vocoder_swig.freedv_set_total_bit_errors(freedv, val)

def freedv_set_total_bits(freedv: "freedv *", val: "int") -> "void":
    r"""freedv_set_total_bits(freedv * freedv, int val)"""
    return _vocoder_swig.freedv_set_total_bits(freedv, val)

def freedv_set_total_bit_errors_coded(freedv: "freedv *", val: "int") -> "void":
    r"""freedv_set_total_bit_errors_coded(freedv * freedv, int val)"""
    return _vocoder_swig.freedv_set_total_bit_errors_coded(freedv, val)

def freedv_set_total_bits_coded(freedv: "freedv *", val: "int") -> "void":
    r"""freedv_set_total_bits_coded(freedv * freedv, int val)"""
    return _vocoder_swig.freedv_set_total_bits_coded(freedv, val)

def freedv_set_callback_error_pattern(freedv: "freedv *", cb: "freedv_calback_error_pattern", state: "void *") -> "void":
    r"""freedv_set_callback_error_pattern(freedv * freedv, freedv_calback_error_pattern cb, void * state)"""
    return _vocoder_swig.freedv_set_callback_error_pattern(freedv, cb, state)

def freedv_set_varicode_code_num(freedv: "freedv *", val: "int") -> "void":
    r"""freedv_set_varicode_code_num(freedv * freedv, int val)"""
    return _vocoder_swig.freedv_set_varicode_code_num(freedv, val)

def freedv_set_data_header(freedv: "freedv *", header: "unsigned char *") -> "void":
    r"""freedv_set_data_header(freedv * freedv, unsigned char * header)"""
    return _vocoder_swig.freedv_set_data_header(freedv, header)

def freedv_set_alt_modem_samp_rate(freedv: "freedv *", samp_rate: "int") -> "int":
    r"""freedv_set_alt_modem_samp_rate(freedv * freedv, int samp_rate) -> int"""
    return _vocoder_swig.freedv_set_alt_modem_samp_rate(freedv, samp_rate)

def freedv_set_carrier_ampl(freedv: "freedv *", c: "int", ampl: "float") -> "void":
    r"""freedv_set_carrier_ampl(freedv * freedv, int c, float ampl)"""
    return _vocoder_swig.freedv_set_carrier_ampl(freedv, c, ampl)

def freedv_set_sync(freedv: "freedv *", sync_cmd: "int") -> "void":
    r"""freedv_set_sync(freedv * freedv, int sync_cmd)"""
    return _vocoder_swig.freedv_set_sync(freedv, sync_cmd)

def freedv_set_verbose(freedv: "freedv *", verbosity: "int") -> "void":
    r"""freedv_set_verbose(freedv * freedv, int verbosity)"""
    return _vocoder_swig.freedv_set_verbose(freedv, verbosity)

def freedv_set_tx_bpf(freedv: "freedv *", val: "int") -> "void":
    r"""freedv_set_tx_bpf(freedv * freedv, int val)"""
    return _vocoder_swig.freedv_set_tx_bpf(freedv, val)

def freedv_set_dpsk(freedv: "freedv *", val: "int") -> "void":
    r"""freedv_set_dpsk(freedv * freedv, int val)"""
    return _vocoder_swig.freedv_set_dpsk(freedv, val)

def freedv_set_ext_vco(f: "freedv *", val: "int") -> "void":
    r"""freedv_set_ext_vco(freedv * f, int val)"""
    return _vocoder_swig.freedv_set_ext_vco(f, val)

def freedv_set_phase_est_bandwidth_mode(f: "freedv *", val: "int") -> "void":
    r"""freedv_set_phase_est_bandwidth_mode(freedv * f, int val)"""
    return _vocoder_swig.freedv_set_phase_est_bandwidth_mode(f, val)

def freedv_set_eq(f: "freedv *", val: "int") -> "void":
    r"""freedv_set_eq(freedv * f, int val)"""
    return _vocoder_swig.freedv_set_eq(f, val)

def freedv_get_version() -> "int":
    r"""freedv_get_version() -> int"""
    return _vocoder_swig.freedv_get_version()

def freedv_get_mode(freedv: "freedv *") -> "int":
    r"""freedv_get_mode(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_mode(freedv)

def freedv_get_modem_stats(freedv: "freedv *", sync: "int *", snr_est: "float *") -> "void":
    r"""freedv_get_modem_stats(freedv * freedv, int * sync, float * snr_est)"""
    return _vocoder_swig.freedv_get_modem_stats(freedv, sync, snr_est)

def freedv_get_modem_extended_stats(freedv: "freedv *", stats: "MODEM_STATS *") -> "void":
    r"""freedv_get_modem_extended_stats(freedv * freedv, MODEM_STATS * stats)"""
    return _vocoder_swig.freedv_get_modem_extended_stats(freedv, stats)

def freedv_get_test_frames(freedv: "freedv *") -> "int":
    r"""freedv_get_test_frames(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_test_frames(freedv)

def freedv_get_n_speech_samples(freedv: "freedv *") -> "int":
    r"""freedv_get_n_speech_samples(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_n_speech_samples(freedv)

def freedv_get_modem_sample_rate(freedv: "freedv *") -> "int":
    r"""freedv_get_modem_sample_rate(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_modem_sample_rate(freedv)

def freedv_get_modem_symbol_rate(freedv: "freedv *") -> "int":
    r"""freedv_get_modem_symbol_rate(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_modem_symbol_rate(freedv)

def freedv_get_n_max_modem_samples(freedv: "freedv *") -> "int":
    r"""freedv_get_n_max_modem_samples(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_n_max_modem_samples(freedv)

def freedv_get_n_nom_modem_samples(freedv: "freedv *") -> "int":
    r"""freedv_get_n_nom_modem_samples(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_n_nom_modem_samples(freedv)

def freedv_get_total_bits(freedv: "freedv *") -> "int":
    r"""freedv_get_total_bits(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_total_bits(freedv)

def freedv_get_total_bit_errors(freedv: "freedv *") -> "int":
    r"""freedv_get_total_bit_errors(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_total_bit_errors(freedv)

def freedv_get_total_bits_coded(freedv: "freedv *") -> "int":
    r"""freedv_get_total_bits_coded(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_total_bits_coded(freedv)

def freedv_get_total_bit_errors_coded(freedv: "freedv *") -> "int":
    r"""freedv_get_total_bit_errors_coded(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_total_bit_errors_coded(freedv)

def freedv_get_sync(freedv: "freedv *") -> "int":
    r"""freedv_get_sync(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_sync(freedv)

def freedv_get_sync_interleaver(freedv: "freedv *") -> "int":
    r"""freedv_get_sync_interleaver(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_sync_interleaver(freedv)

def freedv_get_fsk(f: "freedv *") -> "FSK *":
    r"""freedv_get_fsk(freedv * f) -> FSK *"""
    return _vocoder_swig.freedv_get_fsk(f)

def freedv_get_codec2(freedv: "freedv *") -> "CODEC2 *":
    r"""freedv_get_codec2(freedv * freedv) -> CODEC2 *"""
    return _vocoder_swig.freedv_get_codec2(freedv)

def freedv_get_n_codec_bits(freedv: "freedv *") -> "int":
    r"""freedv_get_n_codec_bits(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_n_codec_bits(freedv)

def freedv_get_sz_error_pattern(freedv: "freedv *") -> "int":
    r"""freedv_get_sz_error_pattern(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_sz_error_pattern(freedv)

def freedv_get_protocol_bits(freedv: "freedv *") -> "int":
    r"""freedv_get_protocol_bits(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_protocol_bits(freedv)

def freedv_get_speech_sample_rate(freedv: "freedv *") -> "int":
    r"""freedv_get_speech_sample_rate(freedv * freedv) -> int"""
    return _vocoder_swig.freedv_get_speech_sample_rate(freedv)
class freedv_api(object):
    r"""Proxy of C++ gr::vocoder::freedv_api class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    MODE_1600 = _vocoder_swig.freedv_api_MODE_1600
    
    MODE_700 = _vocoder_swig.freedv_api_MODE_700
    
    MODE_700B = _vocoder_swig.freedv_api_MODE_700B
    
    MODE_2400A = _vocoder_swig.freedv_api_MODE_2400A
    
    MODE_2400B = _vocoder_swig.freedv_api_MODE_2400B
    
    MODE_800XA = _vocoder_swig.freedv_api_MODE_800XA
    
    MODE_700C = _vocoder_swig.freedv_api_MODE_700C
    
    MODE_700D = _vocoder_swig.freedv_api_MODE_700D
    
    SYNC_UNSYNC = _vocoder_swig.freedv_api_SYNC_UNSYNC
    
    SYNC_AUTO = _vocoder_swig.freedv_api_SYNC_AUTO
    
    SYNC_MANUAL = _vocoder_swig.freedv_api_SYNC_MANUAL
    

    def __init__(self):
        r"""__init__(freedv_api self) -> freedv_api"""
        _vocoder_swig.freedv_api_swiginit(self, _vocoder_swig.new_freedv_api())
    __swig_destroy__ = _vocoder_swig.delete_freedv_api

# Register freedv_api in _vocoder_swig:
_vocoder_swig.freedv_api_swigregister(freedv_api)

class freedv_rx_ss(object):
    r"""Proxy of C++ gr::vocoder::freedv_rx_ss class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    @staticmethod
    def make(*args, **kwargs) -> "gr::vocoder::freedv_rx_ss::sptr":
        r"""make(int mode=MODE_1600, float squelch_thresh=-100.0, int interleave_frames=1) -> freedv_rx_ss_sptr"""
        return _vocoder_swig.freedv_rx_ss_make(*args, **kwargs)

    def set_squelch_thresh(self, squelch_thresh: "float") -> "void":
        r"""set_squelch_thresh(freedv_rx_ss self, float squelch_thresh)"""
        return _vocoder_swig.freedv_rx_ss_set_squelch_thresh(self, squelch_thresh)

    def squelch_thresh(self) -> "float":
        r"""squelch_thresh(freedv_rx_ss self) -> float"""
        return _vocoder_swig.freedv_rx_ss_squelch_thresh(self)

    def set_squelch_en(self, squelch_enable: "bool") -> "void":
        r"""set_squelch_en(freedv_rx_ss self, bool squelch_enable)"""
        return _vocoder_swig.freedv_rx_ss_set_squelch_en(self, squelch_enable)
    __swig_destroy__ = _vocoder_swig.delete_freedv_rx_ss

# Register freedv_rx_ss in _vocoder_swig:
_vocoder_swig.freedv_rx_ss_swigregister(freedv_rx_ss)

def freedv_rx_ss_make(*args, **kwargs) -> "gr::vocoder::freedv_rx_ss::sptr":
    r"""freedv_rx_ss_make(int mode=MODE_1600, float squelch_thresh=-100.0, int interleave_frames=1) -> freedv_rx_ss_sptr"""
    return _vocoder_swig.freedv_rx_ss_make(*args, **kwargs)

class freedv_tx_ss(object):
    r"""Proxy of C++ gr::vocoder::freedv_tx_ss class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr

    @staticmethod
    def make(*args, **kwargs) -> "gr::vocoder::freedv_tx_ss::sptr":
        r"""make(int mode=MODE_1600, std::string const msg_txt="GNU Radio", int interleave_frames=1) -> freedv_tx_ss_sptr"""
        return _vocoder_swig.freedv_tx_ss_make(*args, **kwargs)
    __swig_destroy__ = _vocoder_swig.delete_freedv_tx_ss

# Register freedv_tx_ss in _vocoder_swig:
_vocoder_swig.freedv_tx_ss_swigregister(freedv_tx_ss)

def freedv_tx_ss_make(*args, **kwargs) -> "gr::vocoder::freedv_tx_ss::sptr":
    r"""freedv_tx_ss_make(int mode=MODE_1600, std::string const msg_txt="GNU Radio", int interleave_frames=1) -> freedv_tx_ss_sptr"""
    return _vocoder_swig.freedv_tx_ss_make(*args, **kwargs)

class freedv_rx_ss_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::freedv_rx_ss > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(freedv_rx_ss_sptr self) -> freedv_rx_ss_sptr
        __init__(freedv_rx_ss_sptr self, freedv_rx_ss p) -> freedv_rx_ss_sptr
        """
        _vocoder_swig.freedv_rx_ss_sptr_swiginit(self, _vocoder_swig.new_freedv_rx_ss_sptr(*args))

    def __deref__(self) -> "gr::vocoder::freedv_rx_ss *":
        r"""__deref__(freedv_rx_ss_sptr self) -> freedv_rx_ss"""
        return _vocoder_swig.freedv_rx_ss_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_freedv_rx_ss_sptr

    def make(self, *args, **kwargs) -> "gr::vocoder::freedv_rx_ss::sptr":
        r"""make(freedv_rx_ss_sptr self, int mode=MODE_1600, float squelch_thresh=-100.0, int interleave_frames=1) -> freedv_rx_ss_sptr"""
        return _vocoder_swig.freedv_rx_ss_sptr_make(self, *args, **kwargs)

    def set_squelch_thresh(self, squelch_thresh: "float") -> "void":
        r"""set_squelch_thresh(freedv_rx_ss_sptr self, float squelch_thresh)"""
        return _vocoder_swig.freedv_rx_ss_sptr_set_squelch_thresh(self, squelch_thresh)

    def squelch_thresh(self) -> "float":
        r"""squelch_thresh(freedv_rx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_rx_ss_sptr_squelch_thresh(self)

    def set_squelch_en(self, squelch_enable: "bool") -> "void":
        r"""set_squelch_en(freedv_rx_ss_sptr self, bool squelch_enable)"""
        return _vocoder_swig.freedv_rx_ss_sptr_set_squelch_en(self, squelch_enable)

    def history(self) -> "unsigned int":
        r"""history(freedv_rx_ss_sptr self) -> unsigned int"""
        return _vocoder_swig.freedv_rx_ss_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(freedv_rx_ss_sptr self, int which, int delay)
        declare_sample_delay(freedv_rx_ss_sptr self, unsigned int delay)
        """
        return _vocoder_swig.freedv_rx_ss_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(freedv_rx_ss_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.freedv_rx_ss_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(freedv_rx_ss_sptr self, int multiple)"""
        return _vocoder_swig.freedv_rx_ss_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(freedv_rx_ss_sptr self) -> int"""
        return _vocoder_swig.freedv_rx_ss_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(freedv_rx_ss_sptr self) -> double"""
        return _vocoder_swig.freedv_rx_ss_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(freedv_rx_ss_sptr self) -> uint64_t"""
        return _vocoder_swig.freedv_rx_ss_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(freedv_rx_ss_sptr self) -> uint64_t"""
        return _vocoder_swig.freedv_rx_ss_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(freedv_rx_ss_sptr self) -> bool"""
        return _vocoder_swig.freedv_rx_ss_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(freedv_rx_ss_sptr self) -> bool"""
        return _vocoder_swig.freedv_rx_ss_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(freedv_rx_ss_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.freedv_rx_ss_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(freedv_rx_ss_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.freedv_rx_ss_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(freedv_rx_ss_sptr self, std::string level)"""
        return _vocoder_swig.freedv_rx_ss_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(freedv_rx_ss_sptr self) -> std::string"""
        return _vocoder_swig.freedv_rx_ss_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(freedv_rx_ss_sptr self) -> int"""
        return _vocoder_swig.freedv_rx_ss_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(freedv_rx_ss_sptr self, int m)"""
        return _vocoder_swig.freedv_rx_ss_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(freedv_rx_ss_sptr self)"""
        return _vocoder_swig.freedv_rx_ss_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(freedv_rx_ss_sptr self) -> bool"""
        return _vocoder_swig.freedv_rx_ss_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(freedv_rx_ss_sptr self, int m)"""
        return _vocoder_swig.freedv_rx_ss_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(freedv_rx_ss_sptr self) -> int"""
        return _vocoder_swig.freedv_rx_ss_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(freedv_rx_ss_sptr self, int i) -> long"""
        return _vocoder_swig.freedv_rx_ss_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(freedv_rx_ss_sptr self, long max_output_buffer)
        set_max_output_buffer(freedv_rx_ss_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.freedv_rx_ss_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(freedv_rx_ss_sptr self, int i) -> long"""
        return _vocoder_swig.freedv_rx_ss_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(freedv_rx_ss_sptr self, long min_output_buffer)
        set_min_output_buffer(freedv_rx_ss_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.freedv_rx_ss_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(freedv_rx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_rx_ss_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(freedv_rx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_rx_ss_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(freedv_rx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_rx_ss_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(freedv_rx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_rx_ss_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(freedv_rx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_rx_ss_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(freedv_rx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_rx_ss_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(freedv_rx_ss_sptr self, int which) -> float
        pc_input_buffers_full(freedv_rx_ss_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.freedv_rx_ss_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(freedv_rx_ss_sptr self, int which) -> float
        pc_input_buffers_full_avg(freedv_rx_ss_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.freedv_rx_ss_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(freedv_rx_ss_sptr self, int which) -> float
        pc_input_buffers_full_var(freedv_rx_ss_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.freedv_rx_ss_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(freedv_rx_ss_sptr self, int which) -> float
        pc_output_buffers_full(freedv_rx_ss_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.freedv_rx_ss_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(freedv_rx_ss_sptr self, int which) -> float
        pc_output_buffers_full_avg(freedv_rx_ss_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.freedv_rx_ss_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(freedv_rx_ss_sptr self, int which) -> float
        pc_output_buffers_full_var(freedv_rx_ss_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.freedv_rx_ss_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(freedv_rx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_rx_ss_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(freedv_rx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_rx_ss_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(freedv_rx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_rx_ss_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(freedv_rx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_rx_ss_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(freedv_rx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_rx_ss_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(freedv_rx_ss_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.freedv_rx_ss_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(freedv_rx_ss_sptr self)"""
        return _vocoder_swig.freedv_rx_ss_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(freedv_rx_ss_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.freedv_rx_ss_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(freedv_rx_ss_sptr self) -> int"""
        return _vocoder_swig.freedv_rx_ss_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(freedv_rx_ss_sptr self) -> int"""
        return _vocoder_swig.freedv_rx_ss_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(freedv_rx_ss_sptr self, int priority) -> int"""
        return _vocoder_swig.freedv_rx_ss_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(freedv_rx_ss_sptr self) -> std::string"""
        return _vocoder_swig.freedv_rx_ss_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(freedv_rx_ss_sptr self) -> std::string"""
        return _vocoder_swig.freedv_rx_ss_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(freedv_rx_ss_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.freedv_rx_ss_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(freedv_rx_ss_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.freedv_rx_ss_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(freedv_rx_ss_sptr self) -> long"""
        return _vocoder_swig.freedv_rx_ss_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(freedv_rx_ss_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.freedv_rx_ss_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(freedv_rx_ss_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.freedv_rx_ss_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(freedv_rx_ss_sptr self) -> std::string"""
        return _vocoder_swig.freedv_rx_ss_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(freedv_rx_ss_sptr self, std::string name)"""
        return _vocoder_swig.freedv_rx_ss_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(freedv_rx_ss_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.freedv_rx_ss_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(freedv_rx_ss_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.freedv_rx_ss_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(freedv_rx_ss_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.freedv_rx_ss_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(freedv_rx_ss_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.freedv_rx_ss_sptr_message_subscribers(self, which_port)

# Register freedv_rx_ss_sptr in _vocoder_swig:
_vocoder_swig.freedv_rx_ss_sptr_swigregister(freedv_rx_ss_sptr)


freedv_rx_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
freedv_rx_ss = freedv_rx_ss.make;

class freedv_tx_ss_sptr(object):
    r"""Proxy of C++ boost::shared_ptr< gr::vocoder::freedv_tx_ss > class."""

    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        __init__(freedv_tx_ss_sptr self) -> freedv_tx_ss_sptr
        __init__(freedv_tx_ss_sptr self, freedv_tx_ss p) -> freedv_tx_ss_sptr
        """
        _vocoder_swig.freedv_tx_ss_sptr_swiginit(self, _vocoder_swig.new_freedv_tx_ss_sptr(*args))

    def __deref__(self) -> "gr::vocoder::freedv_tx_ss *":
        r"""__deref__(freedv_tx_ss_sptr self) -> freedv_tx_ss"""
        return _vocoder_swig.freedv_tx_ss_sptr___deref__(self)
    __swig_destroy__ = _vocoder_swig.delete_freedv_tx_ss_sptr

    def make(self, *args, **kwargs) -> "gr::vocoder::freedv_tx_ss::sptr":
        r"""make(freedv_tx_ss_sptr self, int mode=MODE_1600, std::string const msg_txt="GNU Radio", int interleave_frames=1) -> freedv_tx_ss_sptr"""
        return _vocoder_swig.freedv_tx_ss_sptr_make(self, *args, **kwargs)

    def history(self) -> "unsigned int":
        r"""history(freedv_tx_ss_sptr self) -> unsigned int"""
        return _vocoder_swig.freedv_tx_ss_sptr_history(self)

    def declare_sample_delay(self, *args) -> "void":
        r"""
        declare_sample_delay(freedv_tx_ss_sptr self, int which, int delay)
        declare_sample_delay(freedv_tx_ss_sptr self, unsigned int delay)
        """
        return _vocoder_swig.freedv_tx_ss_sptr_declare_sample_delay(self, *args)

    def sample_delay(self, which: "int") -> "unsigned int":
        r"""sample_delay(freedv_tx_ss_sptr self, int which) -> unsigned int"""
        return _vocoder_swig.freedv_tx_ss_sptr_sample_delay(self, which)

    def set_output_multiple(self, multiple: "int") -> "void":
        r"""set_output_multiple(freedv_tx_ss_sptr self, int multiple)"""
        return _vocoder_swig.freedv_tx_ss_sptr_set_output_multiple(self, multiple)

    def output_multiple(self) -> "int":
        r"""output_multiple(freedv_tx_ss_sptr self) -> int"""
        return _vocoder_swig.freedv_tx_ss_sptr_output_multiple(self)

    def relative_rate(self) -> "double":
        r"""relative_rate(freedv_tx_ss_sptr self) -> double"""
        return _vocoder_swig.freedv_tx_ss_sptr_relative_rate(self)

    def relative_rate_i(self) -> "uint64_t":
        r"""relative_rate_i(freedv_tx_ss_sptr self) -> uint64_t"""
        return _vocoder_swig.freedv_tx_ss_sptr_relative_rate_i(self)

    def relative_rate_d(self) -> "uint64_t":
        r"""relative_rate_d(freedv_tx_ss_sptr self) -> uint64_t"""
        return _vocoder_swig.freedv_tx_ss_sptr_relative_rate_d(self)

    def start(self) -> "bool":
        r"""start(freedv_tx_ss_sptr self) -> bool"""
        return _vocoder_swig.freedv_tx_ss_sptr_start(self)

    def stop(self) -> "bool":
        r"""stop(freedv_tx_ss_sptr self) -> bool"""
        return _vocoder_swig.freedv_tx_ss_sptr_stop(self)

    def nitems_read(self, which_input: "unsigned int") -> "uint64_t":
        r"""nitems_read(freedv_tx_ss_sptr self, unsigned int which_input) -> uint64_t"""
        return _vocoder_swig.freedv_tx_ss_sptr_nitems_read(self, which_input)

    def nitems_written(self, which_output: "unsigned int") -> "uint64_t":
        r"""nitems_written(freedv_tx_ss_sptr self, unsigned int which_output) -> uint64_t"""
        return _vocoder_swig.freedv_tx_ss_sptr_nitems_written(self, which_output)

    def set_log_level(self, level: "std::string") -> "void":
        r"""set_log_level(freedv_tx_ss_sptr self, std::string level)"""
        return _vocoder_swig.freedv_tx_ss_sptr_set_log_level(self, level)

    def log_level(self) -> "std::string":
        r"""log_level(freedv_tx_ss_sptr self) -> std::string"""
        return _vocoder_swig.freedv_tx_ss_sptr_log_level(self)

    def max_noutput_items(self) -> "int":
        r"""max_noutput_items(freedv_tx_ss_sptr self) -> int"""
        return _vocoder_swig.freedv_tx_ss_sptr_max_noutput_items(self)

    def set_max_noutput_items(self, m: "int") -> "void":
        r"""set_max_noutput_items(freedv_tx_ss_sptr self, int m)"""
        return _vocoder_swig.freedv_tx_ss_sptr_set_max_noutput_items(self, m)

    def unset_max_noutput_items(self) -> "void":
        r"""unset_max_noutput_items(freedv_tx_ss_sptr self)"""
        return _vocoder_swig.freedv_tx_ss_sptr_unset_max_noutput_items(self)

    def is_set_max_noutput_items(self) -> "bool":
        r"""is_set_max_noutput_items(freedv_tx_ss_sptr self) -> bool"""
        return _vocoder_swig.freedv_tx_ss_sptr_is_set_max_noutput_items(self)

    def set_min_noutput_items(self, m: "int") -> "void":
        r"""set_min_noutput_items(freedv_tx_ss_sptr self, int m)"""
        return _vocoder_swig.freedv_tx_ss_sptr_set_min_noutput_items(self, m)

    def min_noutput_items(self) -> "int":
        r"""min_noutput_items(freedv_tx_ss_sptr self) -> int"""
        return _vocoder_swig.freedv_tx_ss_sptr_min_noutput_items(self)

    def max_output_buffer(self, i: "int") -> "long":
        r"""max_output_buffer(freedv_tx_ss_sptr self, int i) -> long"""
        return _vocoder_swig.freedv_tx_ss_sptr_max_output_buffer(self, i)

    def set_max_output_buffer(self, *args) -> "void":
        r"""
        set_max_output_buffer(freedv_tx_ss_sptr self, long max_output_buffer)
        set_max_output_buffer(freedv_tx_ss_sptr self, int port, long max_output_buffer)
        """
        return _vocoder_swig.freedv_tx_ss_sptr_set_max_output_buffer(self, *args)

    def min_output_buffer(self, i: "int") -> "long":
        r"""min_output_buffer(freedv_tx_ss_sptr self, int i) -> long"""
        return _vocoder_swig.freedv_tx_ss_sptr_min_output_buffer(self, i)

    def set_min_output_buffer(self, *args) -> "void":
        r"""
        set_min_output_buffer(freedv_tx_ss_sptr self, long min_output_buffer)
        set_min_output_buffer(freedv_tx_ss_sptr self, int port, long min_output_buffer)
        """
        return _vocoder_swig.freedv_tx_ss_sptr_set_min_output_buffer(self, *args)

    def pc_noutput_items(self) -> "float":
        r"""pc_noutput_items(freedv_tx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_tx_ss_sptr_pc_noutput_items(self)

    def pc_noutput_items_avg(self) -> "float":
        r"""pc_noutput_items_avg(freedv_tx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_tx_ss_sptr_pc_noutput_items_avg(self)

    def pc_noutput_items_var(self) -> "float":
        r"""pc_noutput_items_var(freedv_tx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_tx_ss_sptr_pc_noutput_items_var(self)

    def pc_nproduced(self) -> "float":
        r"""pc_nproduced(freedv_tx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_tx_ss_sptr_pc_nproduced(self)

    def pc_nproduced_avg(self) -> "float":
        r"""pc_nproduced_avg(freedv_tx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_tx_ss_sptr_pc_nproduced_avg(self)

    def pc_nproduced_var(self) -> "float":
        r"""pc_nproduced_var(freedv_tx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_tx_ss_sptr_pc_nproduced_var(self)

    def pc_input_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full(freedv_tx_ss_sptr self, int which) -> float
        pc_input_buffers_full(freedv_tx_ss_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.freedv_tx_ss_sptr_pc_input_buffers_full(self, *args)

    def pc_input_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_avg(freedv_tx_ss_sptr self, int which) -> float
        pc_input_buffers_full_avg(freedv_tx_ss_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.freedv_tx_ss_sptr_pc_input_buffers_full_avg(self, *args)

    def pc_input_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_input_buffers_full_var(freedv_tx_ss_sptr self, int which) -> float
        pc_input_buffers_full_var(freedv_tx_ss_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.freedv_tx_ss_sptr_pc_input_buffers_full_var(self, *args)

    def pc_output_buffers_full(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full(freedv_tx_ss_sptr self, int which) -> float
        pc_output_buffers_full(freedv_tx_ss_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.freedv_tx_ss_sptr_pc_output_buffers_full(self, *args)

    def pc_output_buffers_full_avg(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_avg(freedv_tx_ss_sptr self, int which) -> float
        pc_output_buffers_full_avg(freedv_tx_ss_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.freedv_tx_ss_sptr_pc_output_buffers_full_avg(self, *args)

    def pc_output_buffers_full_var(self, *args) -> "std::vector< float,std::allocator< float > >":
        r"""
        pc_output_buffers_full_var(freedv_tx_ss_sptr self, int which) -> float
        pc_output_buffers_full_var(freedv_tx_ss_sptr self) -> pmt_vector_float
        """
        return _vocoder_swig.freedv_tx_ss_sptr_pc_output_buffers_full_var(self, *args)

    def pc_work_time(self) -> "float":
        r"""pc_work_time(freedv_tx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_tx_ss_sptr_pc_work_time(self)

    def pc_work_time_avg(self) -> "float":
        r"""pc_work_time_avg(freedv_tx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_tx_ss_sptr_pc_work_time_avg(self)

    def pc_work_time_var(self) -> "float":
        r"""pc_work_time_var(freedv_tx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_tx_ss_sptr_pc_work_time_var(self)

    def pc_work_time_total(self) -> "float":
        r"""pc_work_time_total(freedv_tx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_tx_ss_sptr_pc_work_time_total(self)

    def pc_throughput_avg(self) -> "float":
        r"""pc_throughput_avg(freedv_tx_ss_sptr self) -> float"""
        return _vocoder_swig.freedv_tx_ss_sptr_pc_throughput_avg(self)

    def set_processor_affinity(self, mask: "std::vector< int,std::allocator< int > > const &") -> "void":
        r"""set_processor_affinity(freedv_tx_ss_sptr self, std::vector< int,std::allocator< int > > const & mask)"""
        return _vocoder_swig.freedv_tx_ss_sptr_set_processor_affinity(self, mask)

    def unset_processor_affinity(self) -> "void":
        r"""unset_processor_affinity(freedv_tx_ss_sptr self)"""
        return _vocoder_swig.freedv_tx_ss_sptr_unset_processor_affinity(self)

    def processor_affinity(self) -> "std::vector< int,std::allocator< int > >":
        r"""processor_affinity(freedv_tx_ss_sptr self) -> std::vector< int,std::allocator< int > >"""
        return _vocoder_swig.freedv_tx_ss_sptr_processor_affinity(self)

    def active_thread_priority(self) -> "int":
        r"""active_thread_priority(freedv_tx_ss_sptr self) -> int"""
        return _vocoder_swig.freedv_tx_ss_sptr_active_thread_priority(self)

    def thread_priority(self) -> "int":
        r"""thread_priority(freedv_tx_ss_sptr self) -> int"""
        return _vocoder_swig.freedv_tx_ss_sptr_thread_priority(self)

    def set_thread_priority(self, priority: "int") -> "int":
        r"""set_thread_priority(freedv_tx_ss_sptr self, int priority) -> int"""
        return _vocoder_swig.freedv_tx_ss_sptr_set_thread_priority(self, priority)

    def name(self) -> "std::string":
        r"""name(freedv_tx_ss_sptr self) -> std::string"""
        return _vocoder_swig.freedv_tx_ss_sptr_name(self)

    def symbol_name(self) -> "std::string":
        r"""symbol_name(freedv_tx_ss_sptr self) -> std::string"""
        return _vocoder_swig.freedv_tx_ss_sptr_symbol_name(self)

    def input_signature(self) -> "gr::io_signature::sptr":
        r"""input_signature(freedv_tx_ss_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.freedv_tx_ss_sptr_input_signature(self)

    def output_signature(self) -> "gr::io_signature::sptr":
        r"""output_signature(freedv_tx_ss_sptr self) -> io_signature_sptr"""
        return _vocoder_swig.freedv_tx_ss_sptr_output_signature(self)

    def unique_id(self) -> "long":
        r"""unique_id(freedv_tx_ss_sptr self) -> long"""
        return _vocoder_swig.freedv_tx_ss_sptr_unique_id(self)

    def to_basic_block(self) -> "gr::basic_block_sptr":
        r"""to_basic_block(freedv_tx_ss_sptr self) -> basic_block_sptr"""
        return _vocoder_swig.freedv_tx_ss_sptr_to_basic_block(self)

    def check_topology(self, ninputs: "int", noutputs: "int") -> "bool":
        r"""check_topology(freedv_tx_ss_sptr self, int ninputs, int noutputs) -> bool"""
        return _vocoder_swig.freedv_tx_ss_sptr_check_topology(self, ninputs, noutputs)

    def alias(self) -> "std::string":
        r"""alias(freedv_tx_ss_sptr self) -> std::string"""
        return _vocoder_swig.freedv_tx_ss_sptr_alias(self)

    def set_block_alias(self, name: "std::string") -> "void":
        r"""set_block_alias(freedv_tx_ss_sptr self, std::string name)"""
        return _vocoder_swig.freedv_tx_ss_sptr_set_block_alias(self, name)

    def _post(self, which_port: "swig_pmt_ptr", msg: "swig_pmt_ptr") -> "void":
        r"""_post(freedv_tx_ss_sptr self, swig_pmt_ptr which_port, swig_pmt_ptr msg)"""
        return _vocoder_swig.freedv_tx_ss_sptr__post(self, which_port, msg)

    def message_ports_in(self) -> "pmt::pmt_t":
        r"""message_ports_in(freedv_tx_ss_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.freedv_tx_ss_sptr_message_ports_in(self)

    def message_ports_out(self) -> "pmt::pmt_t":
        r"""message_ports_out(freedv_tx_ss_sptr self) -> swig_pmt_ptr"""
        return _vocoder_swig.freedv_tx_ss_sptr_message_ports_out(self)

    def message_subscribers(self, which_port: "swig_pmt_ptr") -> "pmt::pmt_t":
        r"""message_subscribers(freedv_tx_ss_sptr self, swig_pmt_ptr which_port) -> swig_pmt_ptr"""
        return _vocoder_swig.freedv_tx_ss_sptr_message_subscribers(self, which_port)

# Register freedv_tx_ss_sptr in _vocoder_swig:
_vocoder_swig.freedv_tx_ss_sptr_swigregister(freedv_tx_ss_sptr)


freedv_tx_ss_sptr.__repr__ = lambda self: "<gr_block %s (%d)>" % (self.name(), self.unique_id())
freedv_tx_ss = freedv_tx_ss.make;



