commit-gnuradio
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Commit-gnuradio] [gnuradio] 90/101: Merge remote-tracking branch 'upstr


From: git
Subject: [Commit-gnuradio] [gnuradio] 90/101: Merge remote-tracking branch 'upstream/next' into gtk3
Date: Thu, 16 Mar 2017 14:58:13 +0000 (UTC)

This is an automated email from the git hooks/post-receive script.

jcorgan pushed a commit to branch python3
in repository gnuradio.

commit 10e7e270773a258b0356bafc3a5bbc4853f38a4c
Merge: 7f25c01 8d80d0a
Author: Sebastian Koslowski <address@hidden>
Date:   Thu Jan 5 20:51:35 2017 +0100

    Merge remote-tracking branch 'upstream/next' into gtk3

 cmake/Modules/GrBoost.cmake                        |  19 +-
 docs/doxygen/Doxyfile.in                           |  12 -
 docs/doxygen/Doxyfile.swig_doc.in                  |  12 -
 gnuradio-runtime/include/gnuradio/logger.h         |  28 +-
 gnuradio-runtime/include/gnuradio/tags.h           |  18 +
 gnuradio-runtime/lib/pmt/pmt.cc                    |  13 +-
 gnuradio-runtime/lib/pmt/pmt_int.h                 |   7 +-
 gr-audio/lib/windows/windows_sink.cc               |  14 +-
 gr-audio/lib/windows/windows_source.cc             |  14 +-
 gr-dtv/lib/dvb/dvb_bbheader_bb_impl.cc             |   2 +-
 gr-dtv/lib/dvb/dvb_bbscrambler_bb_impl.cc          |   3 +-
 gr-dtv/lib/dvb/dvb_bch_bb_impl.cc                  |   2 +-
 gr-dtv/lib/dvb/dvb_ldpc_bb_impl.cc                 |   8 +-
 gr-dtv/lib/dvbs2/dvbs2_modulator_bc_impl.cc        |   1 +
 gr-dtv/lib/dvbs2/dvbs2_physical_cc_impl.cc         |   1 +
 gr-dtv/lib/dvbt2/dvbt2_freqinterleaver_cc_impl.cc  |   2 +
 gr-dtv/lib/dvbt2/dvbt2_modulator_bc_impl.cc        |   2 +-
 gr-uhd/apps/uhd_app.py                             |  85 ++-
 gr-uhd/apps/uhd_fft                                |  24 +-
 gr-uhd/doc/uhd.dox                                 |   8 +-
 gr-uhd/lib/usrp_sink_impl.cc                       |  10 +
 gr-uhd/lib/usrp_source_impl.cc                     |  10 +
 gr-utils/python/modtool/gr-newmod/CMakeLists.txt   |  17 +
 .../modtool/gr-newmod/docs/doxygen/Doxyfile.in     |  12 -
 .../gr-newmod/docs/doxygen/Doxyfile.swig_doc.in    |  12 -
 gr-vocoder/CMakeLists.txt                          |   1 +
 gr-vocoder/examples/CMakeLists.txt                 |   1 +
 gr-vocoder/examples/grfreedv.grc                   | 616 +++++++++++++++++++++
 gr-vocoder/grc/CMakeLists.txt                      |   9 +
 .../grc/{CMakeLists.txt => CMakeLists.txt.orig}    |   0
 gr-vocoder/grc/vocoder_block_tree.xml              |   2 +
 gr-vocoder/grc/vocoder_freedv_rx_ss.xml            |  58 ++
 gr-vocoder/grc/vocoder_freedv_tx_ss.xml            |  57 ++
 gr-vocoder/include/gnuradio/vocoder/CMakeLists.txt |   9 +
 .../{CMakeLists.txt => CMakeLists.txt.orig}        |   0
 gr-vocoder/include/gnuradio/vocoder/freedv_api.h   |  68 +++
 gr-vocoder/include/gnuradio/vocoder/freedv_rx_ss.h |  63 +++
 gr-vocoder/include/gnuradio/vocoder/freedv_tx_ss.h |  59 ++
 gr-vocoder/lib/CMakeLists.txt                      |   7 +
 gr-vocoder/lib/freedv_api.cc                       |  33 ++
 gr-vocoder/lib/freedv_rx_ss_impl.cc                | 146 +++++
 gr-vocoder/lib/freedv_rx_ss_impl.h                 |  81 +++
 gr-vocoder/lib/freedv_tx_ss_impl.cc                |  98 ++++
 gr-vocoder/lib/freedv_tx_ss_impl.h                 |  72 +++
 gr-vocoder/swig/CMakeLists.txt                     |   4 +
 gr-vocoder/swig/vocoder_swig.i                     |  19 +
 grc/core/Block.py                                  |   5 +-
 grc/core/generator/Generator.py                    |   2 +-
 grc/core/utils/epy_block_io.py                     |   8 +-
 49 files changed, 1611 insertions(+), 143 deletions(-)

diff --cc grc/core/Block.py
index 9a1d72c,fba9371..bca17d4
--- a/grc/core/Block.py
+++ b/grc/core/Block.py
@@@ -487,293 -826,27 +487,296 @@@ class Block(Element)
          Args:
              n: the nested data odict
          """
 -        my_hash = 0
 -        while self.get_hash() != my_hash:
 -            params_n = n.findall('param')
 -            for param_n in params_n:
 -                key = param_n.find('key')
 -                value = param_n.find('value')
 -                # The key must exist in this block's params
 -                if key in self.get_param_keys():
 -                    self.get_param(key).set_value(value)
 +        param_data = {p['key']: p['value'] for p in n.get('param', [])}
 +
 +        for key in self.states:
 +            try:
 +                self.states[key] = ast.literal_eval(param_data.pop(key))
 +            except (KeyError, SyntaxError, ValueError):
 +                pass
 +
 +        def get_hash():
 +            return hash(tuple(hash(v) for v in self.params.values()))
 +
 +        pre_rewrite_hash = -1
 +        while pre_rewrite_hash != get_hash():
 +            for key, value in six.iteritems(param_data):
 +                try:
 +                    self.params[key].set_value(value)
 +                except KeyError:
 +                    continue
              # Store hash and call rewrite
 -            my_hash = self.get_hash()
 +            pre_rewrite_hash = get_hash()
              self.rewrite()
 -        bussinks = n.findall('bus_sink')
 -        if len(bussinks) > 0 and not self._bussify_sink:
 -            self.bussify({'name': 'bus', 'type': 'bus'}, 'sink')
 -        elif len(bussinks) > 0:
 -            self.bussify({'name': 'bus', 'type': 'bus'}, 'sink')
 -            self.bussify({'name': 'bus', 'type': 'bus'}, 'sink')
 -        bussrcs = n.findall('bus_source')
 -        if len(bussrcs) > 0 and not self._bussify_source:
 -            self.bussify({'name': 'bus', 'type': 'bus'}, 'source')
 -        elif len(bussrcs) > 0:
 -            self.bussify({'name': 'bus', 'type': 'bus'}, 'source')
 -            self.bussify({'name': 'bus', 'type': 'bus'}, 'source')
 +
 +        self._import_bus_stuff(n)
 +
 +    ##############################################
 +    # Bus ports stuff
 +    ##############################################
 +
 +    def get_bus_structure(self, direction):
 +        bus_structure = 
self.resolve_dependencies(self._bus_structure[direction])
 +        if not bus_structure:
 +            return
 +        try:
 +            return self.parent_flowgraph.evaluate(bus_structure)
 +        except:
 +            return
 +
 +    @staticmethod
 +    def back_ofthe_bus(portlist):
 +        portlist.sort(key=lambda p: p._type == 'bus')
 +
 +    @staticmethod
 +    def filter_bus_port(ports):
 +        buslist = [p for p in ports if p._type == 'bus']
 +        return buslist or ports
 +
 +    def _import_bus_stuff(self, n):
 +        bus_sinks = n.get('bus_sink', [])
 +        if len(bus_sinks) > 0 and not self._bussify_sink:
 +            self.bussify('sink')
 +        elif len(bus_sinks) > 0:
 +            self.bussify('sink')
 +            self.bussify('sink')
 +        bus_sources = n.get('bus_source', [])
 +        if len(bus_sources) > 0 and not self._bussify_source:
 +            self.bussify('source')
 +        elif len(bus_sources) > 0:
 +            self.bussify('source')
 +            self.bussify('source')
 +
 +    def form_bus_structure(self, direc):
 +        ports = self.sources if direc == 'source' else self.sinks
 +        struct = self.get_bus_structure(direc)
 +
 +        if not struct:
 +            struct = [list(range(len(ports)))]
 +
 +        elif any(isinstance(p.get_nports(), int) for p in ports):
 +            last = 0
 +            structlet = []
 +            for port in ports:
 +                nports = port.get_nports()
 +                if not isinstance(nports, int):
 +                    continue
 +                structlet.extend(a + last for a in range(nports))
 +                last += nports
 +            struct = [structlet]
 +
 +        self.current_bus_structure[direc] = struct
 +        return struct
 +
 +    def bussify(self, direc):
 +        ports = self.sources if direc == 'source' else self.sinks
 +
 +        for elt in ports:
 +            for connect in elt.get_connections():
 +                self.parent.remove_element(connect)
 +
 +        if ports and all('bus' != p.get_type() for p in ports):
 +            struct = self.current_bus_structure[direc] = 
self.form_bus_structure(direc)
 +            n = {'type': 'bus'}
 +            if ports[0].get_nports():
 +                n['nports'] = '1'
 +
 +            for i, structlet in enumerate(struct):
 +                name = 'bus{}#{}'.format(i, len(structlet))
 +                port = self.parent_platform.get_new_port(
 +                    self, direction=direc, key=str(len(ports)), name=name, 
**n)
 +                ports.append(port)
 +        elif any('bus' == p.get_type() for p in ports):
 +            get_p_gui = self.get_sources_gui if direc == 'source' else 
self.get_sinks_gui
 +            for elt in get_p_gui():
 +                ports.remove(elt)
 +            self.current_bus_structure[direc] = ''
 +
 +    def _init_bus_ports(self, n):
 +        self.current_bus_structure = {'source': '', 'sink': ''}
 +        self._bus_structure = {'source': n.get('bus_structure_source', ''),
 +                               'sink': n.get('bus_structure_sink', '')}
 +        self._bussify_sink = n.get('bus_sink')
 +        self._bussify_source = n.get('bus_source')
 +        if self._bussify_sink:
 +            self.bussify('sink')
 +        if self._bussify_source:
 +            self.bussify('source')
 +
 +    def _rewrite_bus_ports(self):
 +        return  # fixme: probably broken
 +
 +        def doit(ports, ports_gui, direc):
 +            if not self.current_bus_structure[direc]:
 +                return
 +
 +            bus_structure = self.form_bus_structure(direc)
 +            for port in ports_gui[len(bus_structure):]:
 +                for connect in port.get_connections():
 +                    self.parent_flowgraph.remove_element(connect)
 +                ports.remove(port)
 +
 +            port_factory = self.parent_platform.get_new_port
 +
 +            if len(ports_gui) < len(bus_structure):
 +                for i in range(len(ports_gui), len(bus_structure)):
 +                    port = port_factory(self, direction=direc, key=str(1 + i),
 +                                        name='bus', type='bus')
 +                    ports.append(port)
 +
 +        doit(self.sources, self.get_sources_gui(), 'source')
 +        doit(self.sinks, self.get_sinks_gui(), 'sink')
 +
 +        if 'bus' in [a.get_type() for a in self.get_sources_gui()]:
 +            for i in range(len(self.get_sources_gui())):
 +                if not self.get_sources_gui()[i].get_connections():
 +                    continue
 +                source = self.get_sources_gui()[i]
 +                sink = []
 +
 +                for j in range(len(source.get_connections())):
 +                    sink.append(source.get_connections()[j].sink_port)
 +                for elt in source.get_connections():
 +                    self.parent_flowgraph.remove_element(elt)
 +                for j in sink:
 +                    self.parent_flowgraph.connect(source, j)
 +
 +
 +class EPyBlock(Block):
 +
 +    def __init__(self, flow_graph, **n):
 +        super(EPyBlock, self).__init__(flow_graph, **n)
 +        self._epy_source_hash = -1  # for epy blocks
 +        self._epy_reload_error = None
 +
 +    def rewrite(self):
 +        Element.rewrite(self)
 +
 +        param_blk = self.params['_io_cache']
 +        param_src = self.params['_source_code']
 +
 +        src = param_src.get_value()
 +        src_hash = hash((self.get_id(), src))
 +        if src_hash == self._epy_source_hash:
 +            return
 +
 +        try:
 +            blk_io = utils.epy_block_io.extract(src)
 +
 +        except Exception as e:
 +            self._epy_reload_error = ValueError(str(e))
 +            try:  # Load last working block io
 +                blk_io_args = eval(param_blk.get_value())
 +                if len(blk_io_args) == 6:
 +                    blk_io_args += ([],)  # add empty callbacks
 +                blk_io = utils.epy_block_io.BlockIO(*blk_io_args)
 +            except Exception:
 +                return
 +        else:
 +            self._epy_reload_error = None  # Clear previous errors
 +            param_blk.set_value(repr(tuple(blk_io)))
 +
 +        # print "Rewriting embedded python block {!r}".format(self.get_id())
 +
 +        self._epy_source_hash = src_hash
 +        self.name = blk_io.name or blk_io.cls
 +        self._doc = blk_io.doc
 +        self._imports[0] = 'import ' + self.get_id()
 +        self._make = '{0}.{1}({2})'.format(self.get_id(), blk_io.cls, ', 
'.join(
 +            '{0}=${{ {0} }}'.format(key) for key, _ in blk_io.params))
 +        self._callbacks = ['{0} = ${{ {0} }}'.format(attr) for attr in 
blk_io.callbacks]
 +        self._update_params(blk_io.params)
 +        self._update_ports('in', self.sinks, blk_io.sinks, 'sink')
 +        self._update_ports('out', self.sources, blk_io.sources, 'source')
 +
 +        super(EPyBlock, self).rewrite()
 +
 +    def _update_params(self, params_in_src):
 +        param_factory = self.parent_platform.get_new_param
 +        params = {}
 +        for param in list(self.params):
 +            if hasattr(param, '__epy_param__'):
 +                params[param.key] = param
 +                del self.params[param.key]
 +
 +        for key, value in params_in_src:
 +            try:
 +                param = params[key]
 +                if param.default == param.value:
 +                    param.set_value(value)
 +                param.default = str(value)
 +            except KeyError:  # need to make a new param
 +                param = param_factory(
 +                    parent=self,  key=key, type='raw', value=value,
 +                    name=key.replace('_', ' ').title(),
 +                )
 +                setattr(param, '__epy_param__', True)
 +            self.params[key] = param
 +
 +    def _update_ports(self, label, ports, port_specs, direction):
 +        port_factory = self.parent_platform.get_new_port
 +        ports_to_remove = list(ports)
 +        iter_ports = iter(ports)
 +        ports_new = []
 +        port_current = next(iter_ports, None)
-         for key, port_type in port_specs:
++        for key, port_type, vlen in port_specs:
 +            reuse_port = (
 +                port_current is not None and
 +                port_current.get_type() == port_type and
++                port_current.get_vlen() == vlen and
 +                (key.isdigit() or port_current.key == key)
 +            )
 +            if reuse_port:
 +                ports_to_remove.remove(port_current)
 +                port, port_current = port_current, next(iter_ports, None)
 +            else:
 +                n = dict(name=label + str(key), type=port_type, key=key)
 +                if port_type == 'message':
 +                    n['name'] = key
 +                    n['optional'] = '1'
++                if vlen > 1:
++                    n['vlen'] = str(vlen)
 +                port = port_factory(self, direction=direction, **n)
 +            ports_new.append(port)
 +        # replace old port list with new one
 +        del ports[:]
 +        ports.extend(ports_new)
 +        # remove excess port connections
 +        for port in ports_to_remove:
 +            for connection in port.get_connections():
 +                self.parent_flowgraph.remove_element(connection)
 +
 +    def validate(self):
 +        super(EPyBlock, self).validate()
 +        if self._epy_reload_error:
 +            
self.params['_source_code'].add_error_message(str(self._epy_reload_error))
 +
 +
 +class DummyBlock(Block):
 +
 +    is_dummy_block = True
 +    build_in_param_keys = 'id alias affinity minoutbuf maxoutbuf comment'
 +
 +    def __init__(self, parent, key, missing_key, params_n):
 +        super(DummyBlock, self).__init__(parent=parent, key=missing_key, 
name='Missing Block')
 +        param_factory = self.parent_platform.get_new_param
 +        for param_n in params_n:
 +            key = param_n['key']
 +            self.params.setdefault(key, param_factory(self, key=key, 
name=key, type='string'))
 +
 +    def is_valid(self):
 +        return False
 +
 +    @property
 +    def enabled(self):
 +        return False
 +
 +    def add_missing_port(self, key, dir):
 +        port = self.parent_platform.get_new_port(
 +            parent=self, direction=dir, key=key, name='?', type='',
 +        )
 +        if port.is_source:
 +            self.sources.append(port)
 +        else:
 +            self.sinks.append(port)
 +        return port



reply via email to

[Prev in Thread] Current Thread [Next in Thread]