Render a whole score
doseedo_render_scorePlays a whole arrangement you wrote in one call — film scoring, orchestral arrangement, background music, a song or instrumental (a film cue, a string quartet, a big-band chart): each part played by its doseedo instrument, one stem per part from bar 1 at your tempo, plus a summed mix. Input ONE of: parts[] ({name, instrument, timbre_preset?, lora_id?, players?, notes[]} — doseedo_instruments calls), midi_url (multi-track SMF), or musicxml_url (notation played as marked, at concert pitch). A file's parts are matched by name, then GM program; name any part with instruments {"": {instrument, timbre_preset?, players?}}. A chord on a one-line instrument is split into voices (one stem each). ★ SECTIONS: an instrument is ONE player; give a part players: N (2–8) and its line is played by N different players, summed into ONE section stem — an orchestra = violins I / II, violas, cellos, basses as five parts with players 6 / 6 / 4 / 4 / 3, horns 2–4 in unison; a choir = S/A/T/B parts on "choir" (an opera SATB chorus by default, or YOUR singer: parts[].timbre_audio_url), which SINGS parts[].lyrics ("Ooh" without), players 4–8 (recipe "choir"); a solo: no players. The WHOLE orchestra in one call: ≤ 32 lines and ≤ 96 player rows (players: N = N rows), any instruments together, ≤ 600 s. Drums: the drum model is a real kit, drum_engine "oneshot" a drum machine. Synths: synth_role + synth_genre. Timing: bpm and/or tempo_map ([{beat, bpm}]; doseedo_tempo_map lands film hits on downbeats). Result: parts[{name, instrument, url, fit, timbre, lora, players}] — fit.verdict / coverage = did it PLAY its notes (a failed part is re-rolled once; fit.rolls.missed = a roll not played as one), lora.applied = its adapter played — plus mix_url. Next: doseedo_mix {from_job}, then doseedo_session_from_stems {from_job, mix_job}. Async: job_id → doseedo_wait_task (~1–4 min). Cancel: a render that has not reached the GPU yet is stopped and its credits refunded; one already rendering finishes on the GPU (its credits are spent), the job ends as canceled and the output is discarded.
Tool call template
This tool declares no required parameters. Add optional parameters from the input schema as needed.
{
"id": 1,
"jsonrpc": "2.0",
"method": "tools/call",
"params": {
"arguments": {},
"name": "doseedo_render_score"
}
}Input Schema
| Name | Required | Description | Default |
|---|---|---|---|
| bpm | No | Tempo of the parts (10–400). Required with parts[] unless tempo_map is given; on a file it sets the speed and keeps the score's fermatas / rit. / tempo changes. | |
| mix | No | Ignored: every render bounces a summed mix of its parts (mix_url) — on a free plan the mix is what the render hands back. | |
| name | No | Optional: a name for this job's files, e.g. "rainy-loop-3". Every file it returns downloads as <name>_<part>.<ext> (rainy-loop-3_Celesta.wav, rainy-loop-3_rough-mix.wav; one take: rainy-loop-3.wav), so the user can find them. Give each job its own name (a second take: "rainy-loop-3b"). Default: doseedo-<last 6 characters of the job id>. | |
| seed | No | Random seed (reuse to re-render close to the same performance). | |
| tune | No | Light intonation on every winds / brass / strings part (default true): held, clearly pitched notes the model rendered 15–85 cents off are moved toward their written pitch, to a small natural residual — attacks, vibrato and fast notes as played. Receipt: parts[].tune. false = every part as rendered (or parts[].tune false for one). | |
| parts | No | The parts you wrote: [{name?, instrument, timbre_preset?, lora_id?, players?, lyrics?, notes:[{pitch, start_beats, duration_beats, velocity?, lyric?}], dynamics?}] — beats from bar 1, concert pitch. lyrics / lyric: a choir part's words. instrument/timbre_preset = a doseedo_instruments call. players = how many play the line: 1 (default) a soloist, 2–8 a SECTION (e.g. Violins I players 6). | |
| vaefix | No | VAE spectral corrector on every winds / brass / strings part (default true): the decoder's low-mid fog under each instrument's register is trimmed, mic hiss removed only where present. Receipt: parts[].vaefix. false = every decode as rendered (or parts[].vaefix false for one). | |
| midi_url | No | Alternative to parts: a multi-track Standard MIDI File (≤ 2 MiB) — a doseedo result link or a public https URL. Channel 10 = drums: the kit, or the one percussion instrument a part is named for (Bass Drum, Cymbals, Bass Drum & Cymbals, Triangle…). A track's CC11 lane (CC1 on a wind / brass / string / bass part) is its written dynamics: a held note swells as it says. | |
| generator | No | Alternative to parts: a BAND GENERATOR plays the piece — no notes written by you. Its id ("jazz") or {id, seed?, bars? | seconds?, key?, lead?, band?, theme?, changes?, song?, only?, layers?, dynamics?, hits?, lay_out?, thin?, texture?, articulation?, builds?, ending?, intro?, first_bar_at_seconds?, swing?, solo_swing?}: the generator writes every part (drums, bass, piano and a lead for jazz — lead: "none" = the rhythm section alone, a bed under dialogue; "scat" = sung) in its genre, with its own form and changes, at this call's bpm / tempo_map; length = bars, or seconds, or duration_seconds. DIRECT it in seconds from the piece's start (turned into beats on your tempo_map) or in beats: dynamics [{at_seconds, level: none|low|medium|high|peak, ramp?}] — the band follows it bar by bar; ramp: true = the level is REACHED there, moving evenly from the mark before (a crescendo, a falling away); hits [{at_seconds, kind?: light|medium|full}] — the band lands that moment together (a cut, a punchline): full = everyone with a crash, medium = the rhythm section, light = one stroke; who = only those parts land it, stroke = the one drum of the kit that sounds (kick, snare, rim, clap, hat, open hat, crash, tom, high tom, floor tom); lay_out [{from_seconds?, to_seconds?, who?, only?}] — who RESTS where: no name = the lead (dialogue) while the rhythm section plays on; who = the parts that rest (a part's name, a family — strings, brass, winds, keys, percussion — "rhythm", "lead", "all" for a silence — a hit on its first beat is the stop chord, choked); only = the parts that play on while everyone else rests; no from_seconds = from the start (a part ENTERING at to_seconds), no to_seconds = to the end (a part LEAVING); thin [{from_seconds?, to_seconds?, to?: beats|halves|bars, who?}] — who plays THINNER there (under a voice, a low stretch): the named parts, or everyone but the tune, keep only what they play on the beat, on the bar's two halves, or on the bar line; texture [{from_seconds?, to_seconds?, who, plays? | level?, value?}] — WHAT a part plays there (whole bars), always the style's own writing for that part: plays held (a pad) | pedal (a drone) | pulse | arpeggio | ostinato | walk | stabs | comp | line, a drum part four_on_the_floor | backbeat | half_time | ride | light | full, value eighths | sixteenths … for an even one; the part's bars are replaced by bars the style wrote for it over the same chords (these bars at another level, or another stretch of the piece) that ARE that texture; level instead of plays = the part as the style plays it at that level while the band stays where it is. A texture the style does not play on that part is not applied — the answer's direction.texture says what the part can play (doseedo_generators {direction: {textures: true}} lists it up front); articulation [{from_seconds?, to_seconds?, who, style}] — HOW the named parts are played over that stretch: style legato | staccato | marcato | accent | spiccato | tenuto | portato | espressivo | senza_vibrato … (a part's articulation styles; a list is several), laid on those parts as a passage — no note changes; neither time = the whole piece. Pizzicato, tremolo, harmonics and mutes are another sound (a band player's instrument or timbre_preset), not a style; builds [{into_seconds, beats?, drop?}] — a build into a moment: everyone swells and the drums roll over the beats before it (one bar by default), drop: true = the bass and bass drum leave the last beat empty; ending {kind: cut|button|ring|fade, at_seconds?} — cut = nothing sounds from there on (a hard out), button = one short hit and nothing after, ring = a last chord held to the end, fade = the band falls away into a soft held chord; intro: false — it starts on the tune; first_bar_at_seconds — the piece begins MID-BAR, its first bar line that far in (a fixed doseedo_tempo_map's music_offset_s: its bar lines are then where the map landed your hits, and the piece still starts on the cue's first frame). A hit with cut: true is a picture cut to MARK: struck on the beat the cut falls on, left out where it falls between beats. YOUR OWN BAND: band [{instrument, timbre_preset?, name?, chair?: drums|bass|comp|lead|extra, players?, timbre_audio_url?}] — who is seated, in place of the generator's own players, each as a part takes it (doseedo_instruments): the style is written for THESE instruments and each comes back called exactly so; timbre_audio_url = that player's own SOUND, a recording whose tone it takes on as a part's timbre_audio_url does (a brighter or darker recording moves the take's tone the same way), matched to the part by the player's name. A player the style has no chair for is a guest (guests in the answer): it plays only what you give it — the theme, where a statement names it. YOUR OWN MUSIC, arranged by the generator (a score's theme and chords): theme {notes: [[pitch, beat, beats, velocity], …], statements?, also?} — the tune, beats from its first bar line; the generator's own tune comes out and yours goes in, every note as written. With no statements it is said wherever the generator's tune was, on whoever had it; statements [{at_seconds, on?, from_beat?, beats?, octave?, transpose?, stretch?, name?}] say where and by whom (on = part names as lay_out takes them; from_beat / beats = a part of it — its head, a fragment; octave; transpose in semitones; stretch 2 = notes twice as long; name = another tune from also {name: notes}; mode: major | minor = that statement in the PARALLEL mode of the theme's tonic — its third, sixth and seventh moved, nothing else; harmony [{on, at}] = parts that play the statement WITH its carrier, in its rhythm, at third_below | third_above | sixth_below | sixth_above | octave_below | octave_above — in the key, on a chord tone where a note is long or on a strong beat, never a second from the tune and never across it). changes "Dm | Bb | Gm | A" — your chords, one cell a bar ("Dm G7" = two in a bar), as a loop, or [{at_seconds, changes}]; played bar after bar as given, so a statement placed on the loop's first bar is over its first chord. A theme with no changes is HARMONISED (the chords go to the tune; the tune is never changed), in key or the key the tune is in. FEEL (swung styles; left out, each piece and soloist draws its own as records do): swing light|medium|hard — the band's eighths; solo_swing straight|light|medium|hard — the soloist's ("straight" = even eighths laid back over the swing). STYLE TRANSFER — song: {melody: [[pitch, beat, beats], …], changes: "C | Am | F | G7" (one cell a bar, the WHOLE song), sections: [{label, bars, energy?}], meter?, bpm?, key?, phrasing?, answers?: [[pitch, beat, beats], …] (the band's answers to the tune, in its rests: a chair of the genre plays them), answer_by?, lines?: [[pitch, beat, beats], …] (the song's own instrumental figures — a riff, two voices in thirds: a colour of the genre plays them where the song does, its rhythm section playing the genre), line_by?} plays YOUR SONG in this genre and keeps it exactly: its length, its sections, its chart bar for bar and every note of its tune from bar one (every pitch, in order, sung in the genre's phrasing: an eighth early where the genre pushes the beat or its band pushes the change, its eighths swung in a swing; phrasing: "as written" keeps every onset exactly); the generator decides only how its chairs play it (lead: "none" = the genre's rhythm section without the tune; "backing" = its whole backing, every chair but the tune's, for a singer). A melody alone is harmonised; chords alone get the genre's own tune; parts: [{name, notes}] (a MIDI arrangement) is read for its tune and chart. A genre in another metre (a waltz, 6/8, 12/8) plays the song re-metered by the meter-change rule and says what moved. only: "bass" | ["bass", "drums"] returns just those parts — the genre's line for one stem, written with the whole band. SEVERAL STYLES, ONE PIECE — layers: [{id, only?, band?, lead?, seed?}] (1–3): other band generators play THIS piece with it, each as a song in its own style (the same bars, sections, chords and tempo) and each giving its own parts: an 80s synth band with a process piece's mallets and clarinets and a meditation's drone is {id: "synthwave", layers: [{id: "minimalism", only: ["Mallets", "winds"]}, {id: "meditation", only: "Drone"}]}. only = the parts or a family it gives (left out: all but its drums and bass, the host keeping the floor); lead = the instrument that carries the tune in that style ("flute", "bansuri"; the host's lead leaves). Names two styles share come back apart ("Pad (ambient)"); a lay_out / thin / texture / articulation / hit that names parts goes to the style that has them, a family or "all" to every style. The same seed is the same piece: doseedo_generators {generator, …} shows it (free) before you render. Result: parts as for any score, plus generator {id, seed, bars, key, form, changes, direction: what was applied, song: what was kept}. | |
| score_key | No | Alternative to parts: a score file on YOUR machine — doseedo_get_upload_url {filename: "cue.mid" | "cue.musicxml" | "cue.mscz"} → PUT the file → its score_key (kept 24 h). A big score sent as a file, not as notes in this call. | |
| score_url | No | Alternative to parts: a score file URL — MIDI, MusicXML or a MuseScore .mscz / .mscx, told apart by its content. | |
| tempo_map | No | Tempo changes [{beat, bpm}] (first point at beat 0). Overrides a file's own tempo. | |
| band_decode | No | ON by default (false = the plain decode): every part whose instrument the band decoder table gives a model (guitars, acoustic and electric piano, cello, arco double bass) has its takes' 1–7 kHz rebuilt by that model (see doseedo_render_midi band_decode) — a band generator's parts included; every other part (drums, bass, horns, winds) is left as rendered. A score with no such part is left as rendered; a guitar part played on tape at a speed with no band model (tape −12: a bossa's nylon) keeps its plain decode — receipt band_decode {applied, decodes, ms, why_not, tape_plain}. | |
| dsp_doubles | No | How a SECTION's players 2..N are made (parts[].players). Default: shared for a LARGE ORCHESTRA (2+ string / brass / wind / choir sections of 3+ players, 10+ players in them), off for anything smaller (off = each player its own GPU render). shared = where every player of a section would hear ONE recording (a high passage on tape, an adapter's own reference, one recording of yours), players 2..N are made from player 1 on the CPU — its notes, its own intonation, timing and tone — instead of a render each; two parts of one instrument in unison stop being one take twice. all = every section that way (fastest; players with recordings of their own lose their spread). Receipt: parts[].players.dsp_doubles. | |
| instruments | No | Name the instrument for any part: {"Violin I": {"instrument": "violin", "players": 6}, "2": {"instrument": "acoustic_guitar", "timbre_preset": "koto:preset1"}, "Choir": {"instrument": "choir", "players": 6, "lyrics": "Glo-ri-a"}} — key = the part name or its 0-based index; players makes a MIDI / MusicXML part a section, lyrics gives a sung part its words (as parts[].lyrics), timbre_audio_url / timbre_audio_urls its own singer or sound (as parts[]: {"Soprano": {"timbre_audio_url": "https://…/singer.wav"}}), drum_engine "oneshot" (+ drum_genre) plays a file's drum part on a one-shot kit ({"Drums": {"drum_engine": "oneshot"}} — no instrument keeps the part's own). Wins over the name/program match. | |
| articulation | No | The SCORE-WIDE articulation layer, under every part's own (parts[].articulation / instruments rows, applied after it): a master curve or a tutti passage legato for all. Same shape as parts[].articulation: HOW the part is played, a passage at a time — no per-note work needed: a style for the whole part ("legato"), passages [{from, to, style?, dynamics?}] (beats from bar 1, [from, to)), or {style?, passages?, notes?: [{at, pitch?, style?, vibrato?, hairpin?, curve?, bend?}], curve?: [[beat, dB], …], unit?: "beats"|"seconds"}. Styles: legato tenuto portato staccato staccatissimo spiccato accent marcato sfz fp swell crescendo decrescendo espressivo molto_vibrato senza_vibrato breathy growl bright dark fall doit scoop gliss (aliases: slur, short, >, ^, sf, cresc, dim, subtone, glissando…; a list combines them). A sentence where a name goes ("short, warm, no vibrato") is read for its lengths, vibrato and tone only (receipt described); an accent, a hairpin or a bend is named on its passage or note. dynamics: "mf", or a hairpin over the span "p<f", "f>p", "p<f>p" (ppp…fff). curve = a RELATIVE level curve (±18 dB) added to every note under it: a master / section swell over existing dynamics. Any span or note may also set vibrato, vibrato_rate, bright, breath, rough (0–1) and attack ("slur" | "tongue" | 0–1); a note: hairpin "<" ">" "<>", curve (its level 0–127 through it), bend (semitones through it). Later passages / notes win field by field; curves add. On an instrument with an articulation model (doseedo_instruments articulation) the part plays on that model (vibrato, colour, attacks, in-note shapes); elsewhere lengths, accents, dynamics, curves and bends still apply. On a GUITAR (electric, or a steel-string acoustic) a LINE (a lead, a riff, a fill: one note at a time) plays on its model: bright is the drive (0 clean, straight into the board … 1 driven) and attack is the pick (0 a hammer-on or pull-off … 1 a hard pick); a chord part keeps the preset's own playing. SOLO: "solo" (or solo: true on the map) plays the part as a soloist — vibrato grows into its sustained notes after the attack, a sustained note before a rest dies away instead of stopping, it breathes in its rests; render_score does this by itself for the ONE melodic line sounding while it plays (solo: false stops it; solo: {vibrato?, vibrato_rate? 0–1, delay?, min_note?, tail? seconds, share? 0–10, lane_below? s, irregular? 0–2} tunes it). Receipt: articulation {model, played_by, marked, styles, described?, solo?: {by, played, vibrato, tails}}. | |
| musicxml_url | No | Alternative to parts: a MusicXML score (.musicxml / .xml / .mxl, ≤ 8 MiB) exported from Dorico, Sibelius, Finale, MuseScore, or written by you — or a MuseScore file itself (.mscz / .mscx), read with all its markings. | |
| time_signature | No | Meter, e.g. "4/4" (default, or the file's). | |
| idempotency_key | No | Optional. Any unique string for THIS request (e.g. a UUID). Re-sending the same call with the same key after a timeout returns the same job instead of starting a second one. | |
| duration_seconds | No | Render length (default: the last note + 2 s; ≤ 600). |