/[svn]/linuxsampler/trunk/src/engines/EngineBase.h
ViewVC logotype

Diff of /linuxsampler/trunk/src/engines/EngineBase.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3697 by schoenebeck, Sat Jan 4 12:09:45 2020 UTC revision 3699 by schoenebeck, Sat Jan 4 14:07:02 2020 UTC
# Line 1747  namespace LinuxSampler { Line 1747  namespace LinuxSampler {
1747                          }                          }
1748                          break;                          break;
1749                      }                      }
1750                        case 96: { // data increment (data entry +1)
1751                            //dmsg(1,("DATA INC\n"));
1752                            if (pChannel->GetMidiRpnParameter() >= 0) { // RPN parameter number was sent previously ...
1753                                pChannel->SetMidiRpnData(
1754                                    pChannel->GetMidiRpnData() + 1
1755                                );
1756                                bIsRpn = true;
1757    
1758                                int ch = itControlChangeEvent->Param.CC.Channel;
1759                                int param = pChannel->GetMidiRpnParameter();
1760                                int value = pChannel->GetMidiRpnData();
1761    
1762                                // transform event type: CC event -> RPN event
1763                                itControlChangeEvent->Type = Event::type_rpn;
1764                                itControlChangeEvent->Param.RPN.Channel = ch;
1765                                itControlChangeEvent->Param.RPN.Parameter = param;
1766                                itControlChangeEvent->Param.RPN.Value = value;
1767    
1768                                // if there's a RPN script handler, run it ...
1769                                if (pChannel->pScript->handlerRpn) {
1770                                    const event_id_t eventID =
1771                                        pEventPool->getID(itControlChangeEvent);
1772                                    // run the RPN script handler
1773                                    ProcessEventByScript(
1774                                        pChannel, itControlChangeEvent,
1775                                        pChannel->pScript->handlerRpn
1776                                    );
1777                                    // if RPN event was dropped by script, abort
1778                                    // here to avoid hard coded RPN processing below
1779                                    if (!pEventPool->fromID(eventID))
1780                                        break;
1781                                }
1782    
1783                                // do the actual (hard-coded) RPN value change processing
1784                                ProcessHardcodedRpn(pEngineChannel, itControlChangeEvent);
1785    
1786                            } else if (pChannel->GetMidiNrpnParameter() >= 0) { // NRPN parameter number was sent previously ...
1787                                pChannel->SetMidiNrpnData(
1788                                    pChannel->GetMidiNrpnData() + 1
1789                                );
1790                                bIsNrpn = true;
1791    
1792                                int ch = itControlChangeEvent->Param.CC.Channel;
1793                                int param = pChannel->GetMidiNrpnParameter();
1794                                int value = pChannel->GetMidiNrpnData();
1795    
1796                                // transform event type: CC event -> NRPN event
1797                                itControlChangeEvent->Type = Event::type_nrpn;
1798                                itControlChangeEvent->Param.NRPN.Channel = ch;
1799                                itControlChangeEvent->Param.NRPN.Parameter = param;
1800                                itControlChangeEvent->Param.NRPN.Value = value;
1801    
1802                                // if there's a NRPN script handler, run it ...
1803                                if (pChannel->pScript->handlerNrpn) {
1804                                    const event_id_t eventID =
1805                                        pEventPool->getID(itControlChangeEvent);
1806                                    // run the NRPN script handler
1807                                    ProcessEventByScript(
1808                                        pChannel, itControlChangeEvent,
1809                                        pChannel->pScript->handlerNrpn
1810                                    );
1811                                    // if NRPN event was dropped by script, abort
1812                                    // here to avoid hard coded NRPN processing below
1813                                    if (!pEventPool->fromID(eventID))
1814                                        break;
1815                                }
1816    
1817                                // do the actual (hard-coded) NRPN value change processing
1818                                ProcessHardcodedNrpn(pEngineChannel, itControlChangeEvent);
1819                            }
1820                            break;
1821                        }
1822                        case 97: { // data decrement (data entry -1)
1823                            //dmsg(1,("DATA DEC\n"));
1824                            if (pChannel->GetMidiRpnParameter() >= 0) { // RPN parameter number was sent previously ...
1825                                pChannel->SetMidiRpnData(
1826                                    pChannel->GetMidiRpnData() - 1
1827                                );
1828                                bIsRpn = true;
1829    
1830                                int ch = itControlChangeEvent->Param.CC.Channel;
1831                                int param = pChannel->GetMidiRpnParameter();
1832                                int value = pChannel->GetMidiRpnData();
1833    
1834                                // transform event type: CC event -> RPN event
1835                                itControlChangeEvent->Type = Event::type_rpn;
1836                                itControlChangeEvent->Param.RPN.Channel = ch;
1837                                itControlChangeEvent->Param.RPN.Parameter = param;
1838                                itControlChangeEvent->Param.RPN.Value = value;
1839    
1840                                // if there's a RPN script handler, run it ...
1841                                if (pChannel->pScript->handlerRpn) {
1842                                    const event_id_t eventID =
1843                                        pEventPool->getID(itControlChangeEvent);
1844                                    // run the RPN script handler
1845                                    ProcessEventByScript(
1846                                        pChannel, itControlChangeEvent,
1847                                        pChannel->pScript->handlerRpn
1848                                    );
1849                                    // if RPN event was dropped by script, abort
1850                                    // here to avoid hard coded RPN processing below
1851                                    if (!pEventPool->fromID(eventID))
1852                                        break;
1853                                }
1854    
1855                                // do the actual (hard-coded) RPN value change processing
1856                                ProcessHardcodedRpn(pEngineChannel, itControlChangeEvent);
1857    
1858                            } else if (pChannel->GetMidiNrpnParameter() >= 0) { // NRPN parameter number was sent previously ...
1859                                pChannel->SetMidiNrpnData(
1860                                    pChannel->GetMidiNrpnData() - 1
1861                                );
1862                                bIsNrpn = true;
1863    
1864                                int ch = itControlChangeEvent->Param.CC.Channel;
1865                                int param = pChannel->GetMidiNrpnParameter();
1866                                int value = pChannel->GetMidiNrpnData();
1867    
1868                                // transform event type: CC event -> NRPN event
1869                                itControlChangeEvent->Type = Event::type_nrpn;
1870                                itControlChangeEvent->Param.NRPN.Channel = ch;
1871                                itControlChangeEvent->Param.NRPN.Parameter = param;
1872                                itControlChangeEvent->Param.NRPN.Value = value;
1873    
1874                                // if there's a NRPN script handler, run it ...
1875                                if (pChannel->pScript->handlerNrpn) {
1876                                    const event_id_t eventID =
1877                                        pEventPool->getID(itControlChangeEvent);
1878                                    // run the NRPN script handler
1879                                    ProcessEventByScript(
1880                                        pChannel, itControlChangeEvent,
1881                                        pChannel->pScript->handlerNrpn
1882                                    );
1883                                    // if NRPN event was dropped by script, abort
1884                                    // here to avoid hard coded NRPN processing below
1885                                    if (!pEventPool->fromID(eventID))
1886                                        break;
1887                                }
1888    
1889                                // do the actual (hard-coded) NRPN value change processing
1890                                ProcessHardcodedNrpn(pEngineChannel, itControlChangeEvent);
1891                            }
1892                            break;
1893                        }
1894                      case 98: { // NRPN parameter LSB                      case 98: { // NRPN parameter LSB
1895                          dmsg(4,("NRPN LSB %d\n", itControlChangeEvent->Param.CC.Value));                          dmsg(4,("NRPN LSB %d\n", itControlChangeEvent->Param.CC.Value));
1896                          bIsNrpn = true;                          bIsNrpn = true;

Legend:
Removed from v.3697  
changed lines
  Added in v.3699

  ViewVC Help
Powered by ViewVC