Example #1
0
    def __set_scope(self, a, prop, fr, fo, to):
        to_str = action.abstract_string(to).lower()
        to_val = -1
        to_match = None
        if to_str == 'note':
            to_val = const.scope_pernote
        elif to_str == 'global':
            to_val = const.scope_global
        else:
            to_match = re.match('^channel\s(\d+)$', to_str, re.IGNORECASE)
            if to_match:
                to_val = int(to_match.group(1))
                if to_val < 1 or to_val > 16:
                    return errors.invalid_thing(to_str, 'set')
            else:
                return errors.invalid_thing(to_str, 'set')

        try:
            (iparam, oparam, midi, info) = self.__map_from_for(fr, fo)
            if to_match:
                if oparam != -1:
                    self.__delegate.map_param(
                        iparam, info.clone_with_channelscope(to_val))
                elif midi != -1:
                    self.__delegate.map_midi(
                        iparam, info.clone_with_channelscope(to_val))
            else:
                if oparam != -1:
                    self.__delegate.map_param(iparam,
                                              info.clone_with_scope(to_val))
                elif midi != -1:
                    self.__delegate.map_midi(iparam,
                                             info.clone_with_scope(to_val))
        except RuntimeError, e:
            return e.message
Example #2
0
    def __map_channel(self, subject, cfrom, cto):
        cfrom = int(action.mass_quantity(cfrom))
        cto = int(action.mass_quantity(cto))
        if cfrom < 1 or cfrom > 16:
            return errors.invalid_thing(str(cfrom), 'map')
        if cto < 1 or cto > 16:
            return errors.invalid_thing(str(cto), 'map')

        new_mapping = []
        new_mapping.append((cfrom, cto))
        for m in self.__current_channel_mapping():
            if m[0] != cfrom:
                new_mapping.append(m)

        self.__set_channel_mapping(new_mapping)
Example #3
0
 def __set_bank_change(self, ctx, subj, dummy, val):
     to = action.abstract_wordlist(val)[0]
     to_val = int(to)
     if to_val < 0 or to_val > 127:
         return errors.invalid_thing(to, 'set')
     return piw.trigger(self.host.change_bank(), piw.makelong_nb(to_val,
                                                                 0)), None
Example #4
0
 def __set_midi_control(self, ctx, subj, ctl, val):
     c = action.mass_quantity(ctl)
     to = action.abstract_wordlist(val)[0]
     c_val = int(c)
     to_val = int(to)
     if c_val < 0 or c_val > 127:
         return errors.invalid_thing(c, 'set')
     if to_val < 0 or to_val > 127:
         return errors.invalid_thing(to, 'set')
     return piw.trigger(
         self.host.change_cc(),
         utils.makedict_nb(
             {
                 'ctl': piw.makelong_nb(c_val, 0),
                 'val': piw.makelong_nb(to_val, 0)
             }, 0)), None
Example #5
0
 def __set_program_change(self, ctx, subj, dummy, val):
     to = action.abstract_wordlist(val)[0]
     to_val = int(to)
     if to_val < 0 or to_val > 127:
         return errors.invalid_thing(to, 'set')
     return piw.trigger(self.__midi_from_belcanto.change_program(),
                        piw.makelong_nb(to_val, 0)), None
Example #6
0
    def __firstv(self,subj,voice):
        id = self.crack_voice(voice)
        voice = self[5].get_voice(int(id))
        if voice is None:       
            thing='voice %s' %str(id)
            return async.success(errors.invalid_thing(thing,'first'))

        voice.first()
Example #7
0
    def __select(self,subj,voice):
        id = self.crack_voice(voice)

        if self[5].choose_voice(id):
            return action.nosync_return()

        thing='voice %s' %str(id)
        return async.success(errors.invalid_thing(thing,'select'))
Example #8
0
    def __uncreate_output(self,subj,mass):
        id = int(action.mass_quantity(mass))
        channel = self[2].get_channel(id)

        if channel is None:       
            thing='output %s' %str(id)
            return async.success(errors.invalid_thing(thing,'un create'))

        self[2].del_channel(id)
    def __uncreate(self,subj,channel):
        id = int(action.abstract_string(channel))
        channel = self[1].get_input(id)

        if channel is None:       
            thing='channel %s' %str(id)
            return async.success(errors.invalid_thing(thing,'un create'))

        self[1].del_input(id)
Example #10
0
    def __once(self,ctx,subj,voice):
        id = self.crack_voice(voice)
        voice = self[5].get_voice(id)

        if voice is None:
            thing='voice %s' %str(id)
            return async.success(errors.invalid_thing(thing,'play'))


        return voice.loop_once,None
Example #11
0
    def __do_play_now(self,arg,mode):
        cookie = self.__load(arg,1)

        if not cookie:
            thing= 'take %s' %str(arg)
            return async.success(errors.invalid_thing(thing,'play'))

        f = self.player.player(cookie,mode)
        ff = piw.fastchange(f)
        ff(piw.makefloat_bounded_nb(1,0,0,1,0))
        self.player.unload(cookie,False)
        return action.nosync_return()
Example #12
0
    def __set_high(self, a, prop, fr, fo, to):
        to_str = action.abstract_string(to)
        to_val = float(to_str) / 100.0
        if to_val < 0 or to_val > 1:
            return errors.invalid_thing(to_str, 'set')

        try:
            (iparam, oparam, midi, info) = self.__map_from_for(fr, fo)
            if oparam != -1:
                self.__delegate.map_param(iparam, info.clone_with_hi(to_val))
            elif midi != -1:
                self.__delegate.map_midi(iparam, info.clone_with_hi(to_val))
        except RuntimeError, e:
            return e.message
Example #13
0
    def __remove(self,subj,voice):
        if voice is None:
            voice = self[5].current_voice()
            if not voice:
                return async.success(errors.no_current_voice('','remove'))
            id = voice.voice
        else:
            id = self.crack_voice(voice)

        if self[5].remove_voice(id):
            return action.nosync_return()

        thing='voice %s' %str(id)
        return async.success(errors.invalid_thing(thing,'remove'))
Example #14
0
    def __set_resolution(self, a, prop, fr, fo, to):
        to_str = action.abstract_string(to).lower()
        to_val = int(to_str)
        if to_val != const.resolution_bits_7 and to_val != const.resolution_bits_14:
            return errors.invalid_thing(to_str, 'set')

        try:
            (iparam, oparam, midi, info) = self.__map_from_for(fr, fo)
            if oparam != -1:
                self.__delegate.map_param(iparam,
                                          info.clone_with_resolution(to_val))
            elif midi != -1:
                self.__delegate.map_midi(iparam,
                                         info.clone_with_resolution(to_val))
        except RuntimeError, e:
            return e.message
Example #15
0
    def __repeat(self,subj,arg,mode):
        arg = self.__crack_arg(arg)
        mode = self.__crack_mode(mode)

        print 'repeat mode',mode

        if not self.__schedready:
            return async.success(errors.state_error1('scheduler','use'))

        path = self.library.cookie2file(arg)
        if not path or not os.path.exists(path):
            thing='take %s' % str(arg)
            return async.success(errors.invalid_thing(thing,'repeat'))

        recording = recorder_native.read(path)
        cookie = self.player.load(arg,recording,1)
        delta = recording.get_tag(5).as_float()
        start = recording.get_tag(3).as_float()
        duration = recording.get_tag(4).as_float()
        desc = "take %s every %g song beat" % (arg,duration)
        schema = 'schema("%s",[m(3,%f,%f)])' % (desc,duration,start%duration)

        r = async.Deferred()

        def trigger_ok(trigger):
            print '__repeat:trigger_ok'
            event,status = self.verb_defer(3,(False,trigger,4,mode),trigger,None,self.cookie_arg(arg))
            self[5].update()
            self.player.unload(cookie,False)
            r.succeeded(action.nosync_return())

        def trigger_failed(msg):
            r.failed(msg)

        trigger = self.__scheduler.create_trigger(schema)
        trigger.setCallback(trigger_ok).setErrback(trigger_failed)

        return r
Example #16
0
    def __play_aue(self,subj,arg,a,u,e,mode):
        #print 'play aue',arg
        arg = self.__crack_arg(arg)
        mode = self.__crack_mode(mode)
        #print '->',arg

        a = tsm(a)
        u = tsm(u)
        e = tsm(e)

        if not self.__schedready:
            return async.success(errors.state_error1('scheduler','use'))

        path = self.library.cookie2file(arg)
        if not path or not os.path.exists(path):
            thing='take %s' %str(arg)
            return async.success(errors.invalid_thing(thing,'play'))
        recording = recorder_native.read(path)
        cookie = self.player.load(arg,recording,1)
        delta = recording.get_tag(5).as_float()
        schema = schedproxy.make_schema(a,u,e,delta,prefix='take %s' % arg)

        #print 'playback',arg,'delta=',delta,'schema',schema
        r = async.Deferred()

        def trigger_ok(trigger):
            print '__play_aue:trigger_ok'
            event,status = self.verb_defer(3,(False,trigger,4,mode),trigger,None,self.cookie_arg(arg))
            self.player.unload(cookie,False)
            r.succeeded(action.nosync_return())

        def trigger_failed(msg):
            r.failed(msg)

        trigger = self.__scheduler.create_trigger(schema)
        trigger.setCallback(trigger_ok).setErrback(trigger_failed)

        return r
Example #17
0
    def __set_curve(self, a, prop, fr, fo, to):
        to_str = action.abstract_string(to).lower()

        if 'linear' == to_str:
            to_val = 0
        elif 'cubic' == to_str:
            to_val = 1
        elif 'quadratic' == to_str:
            to_val = 2
        elif 'step' == to_str:
            to_val = 3
        else:
            return errors.invalid_thing(to_str, 'set')

        try:
            (iparam, oparam, midi, info) = self.__map_from_for(fr, fo)
            if oparam != -1:
                self.__delegate.map_param(iparam,
                                          info.clone_with_curve(to_val))
            elif midi != -1:
                self.__delegate.map_midi(iparam, info.clone_with_curve(to_val))
        except RuntimeError, e:
            return e.message
Example #18
0
    def __map_from_for(self, fr, fo):
        from_str = action.abstract_string(fr)
        for_str = action.abstract_string(fo).lower()

        iparam_number = 0
        oparam_number = -1
        midi_number = -1

        # determine the input parameter number
        from_match = re.match('^parameter\s+(\d+)$', from_str, re.IGNORECASE)
        if not from_match:
            for i in range(1, 17):
                param_name = self[i].get_property_string('name')
                param_ordinal = self[i].get_property_long('ordinal')
                if param_ordinal:
                    param_name = param_name + ' ' + str(param_ordinal)
                if from_str.lower() == param_name.lower():
                    iparam_number = i
                    break
        else:
            iparam_number = int(from_match.group(1))

        if iparam_number < 1 or iparam_number > 16:
            raise RuntimeError(errors.invalid_thing(from_str, 'map'))

        # determine the output parameter or midi mapping
        oparam_match = re.match('^\d+$', for_str, re.IGNORECASE)
        midi_match = re.match('^midi\s(\d+)$', for_str, re.IGNORECASE)
        if oparam_match:
            oparam_number = int(oparam_match.group(0))
        elif midi_match:
            midi_number = int(midi_match.group(1))
        else:
            if for_str == "polyphonic aftertouch":
                midi_number = 128
            elif for_str == "program change":
                midi_number = 129
            elif for_str == "channel aftertouch":
                midi_number = 130
            elif for_str == "pitch wheel":
                midi_number = 131
            elif for_str == "legato trigger":
                midi_number = 132

        # validate the results
        if oparam_number < 0 and (midi_number < 0 or midi_number > 131):
            raise RuntimeError(errors.invalid_thing(for_str, 'map'))

        print 'iparam:', iparam_number, 'oparam:', oparam_number, 'midi:', midi_number

        info = None
        if oparam_number != -1:
            if self.__delegate.is_mapped_param(iparam_number, oparam_number):
                info = self.__delegate.get_info_param(iparam_number,
                                                      oparam_number)
            else:
                info = piw.mapping_info(oparam_number)
        elif midi_number != -1:
            if self.__delegate.is_mapped_midi(iparam_number, midi_number):
                info = self.__delegate.get_info_midi(iparam_number,
                                                     midi_number)
            else:
                info = piw.mapping_info(midi_number)

        return (iparam_number, oparam_number, midi_number, info)