Audiobus: Use your music apps together.

What is Audiobus?Audiobus is an award-winning music app for iPhone and iPad which lets you use your other music apps together. Chain effects on your favourite synth, run the output of apps or Audio Units into an app like GarageBand or Loopy, or select a different audio interface output for each app. Route MIDI between apps — drive a synth from a MIDI sequencer, or add an arpeggiator to your MIDI keyboard — or sync with your external MIDI gear. And control your entire setup from a MIDI controller.

Download on the App Store

Audiobus is the app that makes the rest of your setup better.

MOZAIC - Create your own AU MIDI plugins - OUT NOW!

15960626465103

Comments

  • Selecting a large block of text in the Mozaic editor is easy with a bluetooth keyboard.
    Place the cursor at the start of the part you want to select. Scroll to the last line you want to select. Press shift and place the cursor. So yes, you do need a bluetooth keyboard.
    Think also about all that screen real estate you get by not using the onscreen keyboard.
    Using a smaller font size and placing your iPad in portrait mode also helps.

  • @wim said:
    I use Mozaic exclusively in Audiobus when developing. I suspect that is the reason the editor is more stable for me than others. Never had a single issue with it. Couple of outright Audiobus crashes, but remembering to save at least every 15 minutes seems to cure that. (Memory leak or something?)

    Ok... I just tried Mozaic in Audiobus, and the editor was much more stable that it is for me in AUM.

    So... I'll use Audiobus for learning to program Mozaic.

    :)

  • @Skyblazer said:

    @SimonSomeone said:
    Hello, I'm looking for an app to remap notes in a particular way....

    I plan to add these features to my most recent script, Microtonal Maker...

    Thanks, sounds promising!

  • McDMcD
    edited January 2020

    The NDLR hardware video gives me the motivation for picking out a decent MIDI controller with 8 knobs and 8 pads at a minimum.

    I think we can get more Mozaic scripters to create scripts for knob lovers based on one of these MIDI controllers:

    Novation Launch XL ($150)
    Korg nanoKONTROL Studio (Bluetooth option) ($155)
    PreSonus ATOM Pad Controller ($150)
    Akai Professional MIDImix ($99 and the bank mute buttons might work for pad functions)
    Midi Fighter Twister ($220 but higher build quality and knobs might work as buttons?)
    Behringer X-Touch Mini ($80)
    Akai Professional MPK MINI MK2 MKII ($130 also has keys)
    Samson Graphite M25 ($50 also has some keys)

    Do any standout to you as good candidates to build a lot of scripts for? Would you buy one and help make solid shared code? I use 16 knobs in my first script and I'd love to have precise tactile controls and I think to would bring in a lot of new users.

    Should we optimize for quality, low cost or the right features like Bluetooth. Yamaha BT Midi converters are also an option for an extra $80 if the device support 5-pin MIDI. I suspect I have an older MIDI controller that has 5-pin around here to start testing knob inputs.

  • I just have an Korg nanoKey Studio, which sends out specific notes for its pads and uses specific CCs for its knobs when in default setting. One could use a desktop editor to change settings, but i didn‘t do that.

    .

    And i just did a custom script for @drewinnit for the LaunchControl XL, where i toggle the button states and button LEDs on several templates to the same state via sysex commands when specific CCs (send by the LCXL) arrive. It also monitors the ‚current template‘ and when restoring the AUM session using that script, the LXCL state is synced to the saved state.

    But since it heavily depends on the LCXL settings and i would not only have to describe the scripts functions, but also how to configure each of the AUM channels and how to setup each of the LCXL templates and describe the needed complex midi routing, i didn‘t publish the script :#

    .
    Development wasn‘t easy since i don‘t have a LCXL to test things. @drewinit had to help me out and did lots of tests with a sysex sending simple scripts doing just basic changes to verifiy that my understanding of the manual is correct.

    To debug and test the main script, i then wrote a simple LCXL button simulator mozaic script that reacts to the LED and state sysex like the LXCL would and then lights its pads. Pressing a pad also sends out the CCs that @drewinnit configured for his LCXL. So i could test and simulate interaction of the main script.

  • @_ki said:
    I just have an Korg nanoKey Studio, which sends out specific notes for its pads and uses specific CCs for its knobs when in default setting.

    I'm going to give you extra votes for:
    1) owning the Korg Nanokey already
    2) helping everyone on any topic (see #1)
    3) making the best UI's so why should hardware be any less difficult

    So, the first round of rankings for me (factoring in costs which would grow the pool of
    potential Mozaic users):

    Samson Graphite M25 ($50 also has some keys)
    Behringer X-Touch Mini ($80)
    Korg nanoKONTROL Studio (Bluetooth option) ($155)
    Akai Professional MIDImix ($99 and the bank mute buttons might work for pad functions)
    Akai Professional MPK MINI MK2 MKII ($130 also has keys)
    Novation Launch XL ($150)
    PreSonus ATOM Pad Controller ($150)
    Midi Fighter Twister ($220 but higher build quality and knobs might work as buttons?)

  • @McD Personally, I'm most likely to buy a Midi Fighter Twister, and I already own the MPK Mini MK2. In terms of how popular it is already, the MPK Mini MK2 is the clear winner, and I do own one of those. It's probably not the best build quality. I don't have any ideas for it, beyond programming the joystick to move the XY pad reticle without re-centering, but an app designed specifically for it would definitely be cool. :)

  • @Skyblazer said:
    the MPK Mini MK2 is the clear winner, and I do own one of those.

    Would you help with some audio demo's of scripts if that was the target? That joystick
    is unique on the list I think. I like the Akai build quality.

    Samson Graphite M25 ($50 also has some keys)
    Behringer X-Touch Mini ($80)
    Akai Professional MPK MINI MK2 MKII ($130 also has keys and a joystick)
    Korg nanoKONTROL Studio (Bluetooth option) ($155)
    Arturia MINILAB mkII ($110 with keys)
    Akai Professional MIDImix ($99 and the bank mute buttons might work for pad functions)
    Akai Professional MPK MINI MK2 MKII ($130 also has keys)
    Novation Launch XL ($150)
    PreSonus ATOM Pad Controller ($150)
    Midi Fighter Twister ($220 but higher build quality and knobs might work as buttons?)

    I added Arturia MINILAB mkII ($110 with keys) to the list for additional input.

  • edited January 2020

    as @_ki mentioned, I have the Launchcontrol XL. I would be happy to help test scripts for this.

    I also have the Akai MPK mini (version 1, no joystick) and Korg NanoKey Studio (bluetooth) and would be happy to test for those devices too

  • @McD said:

    @Skyblazer said:
    the MPK Mini MK2 is the clear winner, and I do own one of those.

    Would you help with some audio demo's of scripts if that was the target? That joystick
    is unique on the list I think. I like the Akai build quality.

    Samson Graphite M25 ($50 also has some keys)
    Behringer X-Touch Mini ($80)
    Akai Professional MPK MINI MK2 MKII ($130 also has keys and a joystick)
    Korg nanoKONTROL Studio (Bluetooth option) ($155)
    Arturia MINILAB mkII ($110 with keys)
    Akai Professional MIDImix ($99 and the bank mute buttons might work for pad functions)
    Akai Professional MPK MINI MK2 MKII ($130 also has keys)
    Novation Launch XL ($150)
    PreSonus ATOM Pad Controller ($150)
    Midi Fighter Twister ($220 but higher build quality and knobs might work as buttons?)

    I added Arturia MINILAB mkII ($110 with keys) to the list for additional input.

    I would definitely help with some audio demos, and video. The MK2 does have a desktop-only editor that allows for custom remappings, which for writing general scripts, is both a good thing and a bad thing. But probably 10x as many people own it compared to the other starter MIDI controller options. The Launch Control XL looks like it would pair well with two of the lesser-used Mozaic layouts, and I would consider buying that one too.

    I'm not totally opposed to the idea of making a less expensive, less popular, underdog option like the Samson the "official community option", I just wasn't planning on buying a second cheap MIDI keyboard. So if I got a Samson, it would mostly be to use with Mozaic, whereas some of the other options would be less redundant.

  • I think I'll follow @_ki and get the NanoKey studio. That way I'll be able to get help when I get stuck. I also would like to understand more about Bluetooth MIDI. I also really hate cables, hubs and such dependencies. I can find them in the mess of older cable types. Who kind of idiot would toss a cable? What's that cable used for anyway?

    USB-C is coming.

    There's not much response here so I still think the core audience on this thread is around 10
    and most don't care about this effort. So, I will follow my guru.

    I can imagine I might end up with several of these controllers over time as I learn what features matter to me for knob quality, etc. I'm not going Pro on day one.

    @End // of hardware survey

    @Start // of complaining about the Korg Nanokey

  • _ki_ki
    edited January 2020

    @McD Wait, wait -I didn't say anything about the usability or the fun of using this device.

    There are lots of drawbacks:

    • I don't like the keys of nanoKey Studio - they are loud and not really equally sensitive to playing with different velocities. Their klick distracts me. i can only use them with headphones on - and why did they exchange the black and white keys ?
    • The XY has three types of use, but none really works. The pitchbend and mod mode its hard to control, i have no use for the nodes modes.
    • The drum pads are more like rigid rubber. Strange to drum with your fingers (or I'm too old for this - i would like to play this kind of material with drum sticks but not with fingers)

    My device caught some dust - i don't really use it. I bought it because it was wireless, smaller than the iRig Keys i also own and i thought i would use it with Gadget, which offers direct nanoKey Studio support.

    .

    The iRig Keys are more fun to play, there is a pitch bender and a modwheel -- but no controler knobs to tweak. They don't fit into my bag, but protrude at the top - thatwhy i don't take them with me that often. They come with a special lightning to 7 pin cable and can be powered by the iPad.

  • @_ki said:
    The iRig Key are more fun to play, there is a pitch bender and a modwheel -- but no controler knobs to tweak. It doesn't fit my bag and comes with a special lightning to 7 pin cable.

    I own a bunch of keyboards. But I saw my DJ'ing nephew work an Akai Force and the light went out for that approach to creating music using PAD's and Knobs.

    So, I'll keep the conversation open a bit longer for more input. My gut says:

    Akai Professional MPK MINI MK2 MKII ($130 also has keys)

    More potential users of the resulting scripts based upon the input here.

  • @McD I just watched

    And while looking around, i did find some sysex for the there Arturia MINILAB mkII. They are not mentioned in the manual, but some pepol posted them in the arturia forum. They could be very handy when doing a Mozaic script for it.

    .

    Here the Mozaic code to set the pad colors and to initialize the endless encoders of the "Arturia MiniLab mkII"

    // Code untested since i don't own a Arturia MiniLab mkII
    
    @OnLoad
      Call @InitSysexMessage
    
      for pPad = 0 to 15
        pCol = COL_YELLOW
        Call @SetPadColor
      endfor
    
      pCCVal = 64
      for pKnob = 0 to 17
        Call @SetKnobCC 
      endfor
    @End
    
    @InitSysexMessage
      //           black, red, green,yellow,blue,magenta,cyan, white
      colorVal[] = [0x00, 0x01, 0x04, 0x05, 0x10, 0x11, 0x14, 0x7F]
      sysPad[] = [ 0x00, 0x20, 0x6B, 0x7F, 0x42, 0x02, 0x00, 0x10, 0x00, 0x00]
    
      COL_BLACK   = 0
      COL_RED     = 1
      COL_GREEN   = 2
      COL_YELLOW  = 3
      COL_BLUE    = 4
      COL_MAGENTA = 4
      COL_CYAN    = 6
      COL_WHITE   = 7
    
      // List of controler ids
      controler[00] = [0x30, 0x01, 0x02, 0x09, 0x0B, 0x0C, 0x0D, 0x0E] // knobs 1-8
      controler[08] = [0x33, 0x03, 0x04, 0x0A, 0x05, 0x06, 0x07, 0x08] // knobs 9-16
      controler[16] = [0x32, 0x35] //  Shift knob1 and shift knob 9
    
      sysCCVal[] = [0x00, 0x20, 0x6B, 0x7F, 0x42, 0x02, 0x00, 0x00, 0x00, 0x00]
    @End
    
    @SetPadColor // pPad, pCol
      sysPad[8] = 0x70 + pPad
      sysPad[9] = colorVal[pCol]   // 0 = black  to  7 = white
      SendSysex sysPad, 10
    @End
    
    @SetKnobCC // pKnob, pCCVal
      sysCCVal[8] = controler[pKnob]
      sysCCVal[9] = pCCVal
      SendSysex sysCCVal, 10
    @End
    
  • wimwim
    edited January 2020

    The NanoKey studio doesn’t have the two-way communication that would be needed for lighting up the pads. You can’t send it midi to turn a pad light on or off. If that makes any difference to this discussion.

  • McDMcD
    edited January 2020

    @_ki:

    Can I publish this code for the Tutorial? I'd like to expose Newbies to your Variable naming ideas when I cover Variables. I'll give you credit for the Tips and the Code and tell them it needs testing on real hardware.

  • _ki_ki
    edited January 2020

    You can repost that if you want to. I just used the naming scheme that i implemented in the language highlighter

    • varsInCamelCase
    • _localVariables camelcase starting with _
    • CONSTANTS_ALL_CAPS
    • pParametersCamelCase starting with lowercase p for user event parameters

    other people use other conventions, like underscore between words etc. Its just for readablity if looking back at a script two month later. For the local vars and parameters i had to come up with something i could detect using regular expressions in the highlighter, thats how the prefixes originated

    Mozaic itself has no constants, no local vars or parameters, or variable scopes as in other languages. Every defined variable is accessible everywhere in the script. The variable names are case insensitive, so for Mozaic this_is_a_var and ThIs_IS_a_VaR is the same.

    .

    And i tend to list the parameters of a user event as comment after the event name.
    In initializations of variables that will be used as array, i add the [ ] to their name - like in tables[] = [12,13,14] . It's completely unnecessary to write it that way, but as it doesn't throw a syntax error ... i detected this when i wrote tons of unittest for the language highligter/syntax checker - and at first i flagged empty square brackets as lvars as error, but then i decided that it looks kinda good and hints the array nature

    .

    But i suspect my script is already too advanced for your introduction - it makes use of arrays, uses hex constants, has user events with parameters etc. I think its better to go slower with your readers.

  • Just a suggestion ... perhaps the word “global” could be better chosen to avoid confusion. There is a specific global variable type that is a way to share parameters between instances. I think the sense that you’re using it in is referring to the fact that any variable in a script is available anywhere in the script and is never private to an Event.

    In most languages that wouldn’t be an issue because global just means available everywhere. In Mozaic it takes on an additional meaning.

  • _ki_ki
    edited January 2020

    Thanks. You are right, i'll edited the post to clarify the text.

    BTW: There is a different highlighting for global variables in the syntax highlighter

  • @wim said:
    The NanoKey studio doesn’t have the two-way communication that would be needed for lighting up the pads. You can’t send it midi to turn a pad light on or off. If that makes any difference to this discussion.

    bummer :s
    its probably the same for nanoKontrol studio.
    so no work around i guess?

  • I went with the Akai Professional MPK Mini MKII for the broadest range of control types, nice layout and low cost at $95 (Amazon Used Very Good condition). It was mentioned that there are a lot of them in use by Forum members too.

  • wimwim
    edited January 2020

    @Tamir_Raz_Mataz said:

    @wim said:
    The NanoKey studio doesn’t have the two-way communication that would be needed for lighting up the pads. You can’t send it midi to turn a pad light on or off. If that makes any difference to this discussion.

    bummer :s
    its probably the same for nanoKontrol studio.
    so no work around i guess?

    Nope. Sorry. :|

  • @wim said:
    The NanoKey studio doesn’t have the two-way communication that would be needed for lighting up the pads.

    I need more nite-lites. Deal Breaker.

  • Guys. On the tutorial thread a user has asked this question about an app feasibility and how it might be implemented vis-a-vis data structures and runtime considerations in AUM,

    The user is @horsetrainer who really knows his equine shit

    I have an idea for a Mozaic program. I'll describe on this thread because I'd like to hear some general coding theory about how it might be accomplished (if it's even possible).
    
    The script would work as a Midi Control Change Recorder.
    
    ( Is there a synth that has this feature built-in? )
    
    The idea is to be able to have a patch loaded in a synth, then play a note while manually adjusting Frequency, or Resonance, or Pulse Width, or any CC parameter that can be controlled by a controller (like Mozaic) .
    
    Then be able to "record" your manual adjustment with the Mozaic script. Once it's recorded, every time you press any key to play any note, Mozaic detects a @OnMIDINote Event, and Mozaic sends the synth the recorded manual CC adjustment and the synth applies it to the patch in real time.
    
    This is different from having an LFO modulate a CC parameter, because if you looked at a graphed curve produced by your manual adjustment, it could look like any shape, because it's manually input.
    
    The problem I see creating a Mozaic script to do this, is it could not control a single synth polyphonically. But this could be overcome by loading (say) Three or Four AU instances of the same synth (but each instance having it's own Midi Channel). Then tell Mozaic on each new@OnMIDINote Event, to send each new Midi note you play, out to sequential Midi Channels (The same way the Oberheim SEM created polyphony by using multiple sound modules.)
    
    To me the mind boggling programing issue, would be how to make Array code blocks that could use the output from manually changed knobs in a Mozaic layout, and record the Data in a way that could be recalled.
    
    It seem to me the Mozaic output would be very step-like and not smooth.
    
    But what I wonder is if there is some type of math equation that could take a graph of plotted points, and interpolate it so the synth receives a smooth control change instead of a series of abrupt control change steps.
    
    I'd like to think that with a program like this, you might be able to "record" multiple control changes for various synth parameters, and get consistent groups of complex control changes that would sound really cool.
    
    With a program like this, you could run two Mozaic instances each controlling it's own "synth group".
    
    Then imagine the possibilities for creatively "blending" the combined output from two different "synth groups" each having it's own unique control changes, timed in particular ways to create infinite numbers of unique blending techniques.
    

    Any feedback from the sharper toolset appreciated. The data structures involved and timing details are beyond my abilities. I don't want to commit and just flounder teaching newbies
    so I won't tackle this without a lot of assistance. Are there any scripts that service some of these needs for CC/LFO tools?

  • This is right in line with my current project. At some point I intend to describe in detail how I’m managing recording and playback of midi data with accuracy down to a few milliseconds or less. Although it all appears to be working well, it has that “if it seems too good to be true...” feel to it. More testing and optimization is needed before it would be beneficial to describe how I’m going about it.

    I’m forcing myself not to divert until this project is done, and that will be some time. So if anyone else takes the ball for @horsetrainer’s idea that’ll be great, and really interesting to see how the approach compares to how I would go about it.

  • I can do this one. I already have working code for the automation, so I just need to pair it with the channel rotation script.

    Upon XY change, or pressing record, I just have it start filling two arrays with the current X and Y values, adding a value once every few milliseconds...and then finish recording when a few milliseconds pass without any XY change, or the record button is pressed again. Then, OnMIDINoteOn, I play back the values from the two arrays. The resolution is highest when the recording length is lowest, and vice versa.

    I do have the code to create a version that uses LFOs and stores fewer data points, less frequently, but the simple solution doesn't result in any choppiness, so I'll probably do that one first.

  • edited January 2020

    @Bryan said:
    I just uploaded a new script to https://patchstorage.com/platform/mozaic/ called Scale Compendium.

    This script will quantize incoming MIDI notes to a preset scale, of which 32 are included along with their associated modes. Also included are an assortment of common triads and 7th chords.

    Scales are organized in three banks. There are up to ten scales per bank, with each scale having a number of modes equal to the number of notes in the scale (except for the symmetrical scales, which are a special case).

    Press the SHIFT key to change banks. Use the SCALE knob to select the scale and the MODE knob to select the mode. The KEY knob changes the root note.

    the STYLE knob determines what the script will do when it encounters a note outside the scale. STYLE 1 will filter out all out-of-scale notes; only notes in the scale will sound. STYLE 2 & 3 will move out-of-scale notes to the nearest scale note, but if there are two equally distant notes, STYLE 2 will move to the higher note while STYLE 3 will move to the lower note. STYLE 4 will always move up to the next scale step regardless of distance whereas STYLE 5 will always move down to the previous step. STYLE 6 will quantize toward the root, perfect fifth, or major or minor third whenever possible.

    Hi Bryan,

    I really enjoy using Scale Compendium script. Thanks alot.

    I tried different STYLEs from my Launchpad
    Any solution for playing without :
    1. sometimes same note one after the other
    2. no notes at the end of the scale

    I offer to add a STYLE:
    STYLE 7 will play chromatically(not scale) on (on white and black keys)
    and continues without silent notes at the end of the scale.

    Something like the chromatic mode on Simple Scaler patch but not only for white keys:
    https://patchstorage.com/simple-scaler/

    It would be Styling B)

  • wimwim
    edited January 2020

    @Tamir_Raz_Mataz said:
    Something like the chromatic mode on Simple Scaler patch but not only for white keys:
    https://patchstorage.com/simple-scaler/

    What would be done about the fact that there aren't enough white keys to play all notes? Drop the bottom and/or top of the note range? What would be the "root" note that starts the scale? Would the keys shift according to root note setting? Maybe something like "middle C" (Note 48? Note 60?) is the root and then just count up and down until you run out of white keys?

    I probably don't want to modify simple scaler since it's intended as a functional equivalent of another app that isn't expected to go AU, but I might think about it if some of that was clarified. It wouldn't be a major effort to add, I don't think.

  • edited January 2020

    @_ki I love your transposer script.

    It would be very cool to see a variation on this ( I tried but failed major )

    The nine knobs used for transposition, and the last as a scale lock.

    Like a super xl midi harmonizer/stacker :-)))))

    @_ki said:
    Updated four of my scripts on patchstorage:

  • @topaz Could you please describe in more detail what you are looking for in the request new Mozaic scripts thread ?

    I don't quite get what you mean with:

    The nine knobs used for transposition, and the last as a scale lock.
    Like a super xl midi harmonizer/stacker

    the 'CC Automatable Transposer' script applies the same transpositiopn to all incoming notes and then applies Mozaics scale function if a scale was selected. The lower knobs are used to select the CCs for automation.

    The script itself is quite 'dated', nowadays i would suggest to use the knobs AU parameter directly for automation.

Sign In or Register to comment.