Transcription Course Generator

The transcription course generator is used to create courses that help you learn how to transcribe passages of music onto your ear and your instrument(s). This page explains how they are configured and set up. For more information on the methodology and instructions, see the course instructions page.

Specification

The specification for the course configuration for transcription courses:

#![allow(unused)]
fn main() {
/// The configuration used to generate a transcription course.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TranscriptionConfig {
    /// The dependencies on other transcription courses. Specifying these dependencies here instead
    /// of the [CourseManifest] allows Trane to generate more fine-grained dependencies.
    #[serde(default)]
    pub transcription_dependencies: Vec<Ustr>,

    /// The directory where the passages are stored as JSON files whose contents are serialized
    /// [TranscriptionPassages] objects.
    ///
    /// The directory can be written relative to the root of the course or as an absolute path. The
    /// first option is recommended. An empty value will safely default to not reading any files.
    #[serde(default)]
    #[serde(skip_serializing_if = "String::is_empty")]
    pub passage_directory: String,

    /// A list of passages to include in the course in addition to the ones in the passage
    /// directory. Useful for adding passages directly in the course manifest.
    #[serde(default)]
    pub inlined_passages: Vec<TranscriptionPassages>,

    /// If true, the course will skip creating the singing lesson. This is useful when the course
    /// contains backing tracks that have no melodies, for example. Both the singing and the
    /// advanced singing lessons will be skipped. Because other transcription courses that depend on
    /// this lesson will use the singing lesson to create the dependency, the lesson will be
    /// created, but will be empty.
    #[serde(default)]
    pub skip_singing_lessons: bool,

    /// If true, the course will skip the advanced singing and transcription lessons. This is useful
    /// when there are copies of the same recording for every key, which makes the need for the
    /// advanced lessons obsolete.
    #[serde(default)]
    pub skip_advanced_lessons: bool,
}
}

The specification for how the passages are declared:

#![allow(unused)]
fn main() {
/// A collection of passages from a track that can be used for a transcription course.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct TranscriptionPassages {
    /// The asset to transcribe.
    pub asset: TranscriptionAsset,

    /// The ranges `[start, end]` of the passages to transcribe. Stored as a map mapping a unique ID
    /// to the start and end of the passage. A map is used instead of a list because reordering the
    /// passages would change the resulting exercise IDs.
    ///
    /// If the map is empty, one passage is assumed to cover the entire asset and the ID for the
    /// exercises will not include a passage ID.
    #[serde(default)]
    #[serde(skip_serializing_if = "HashMap::is_empty")]
    pub intervals: HashMap<usize, (String, String)>,
}
}

The specification for how the transcription assets (the description of the song to transcribe) are declared:

#![allow(unused)]
fn main() {
/// An asset used for the transcription course generator.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub enum TranscriptionAsset {
    /// A track of recorded music that is not included along with the course. Used to reference
    /// commercial music for which there is no legal way to distribute the audio.
    Track {
        /// A unique short ID for the asset. This value will be used to generate the exercise IDs.
        short_id: String,

        /// The name of the track to use for transcription.
        track_name: String,

        /// The name of the artist(s) who performs the track.
        #[serde(default)]
        #[serde(skip_serializing_if = "Option::is_none")]
        artist_name: Option<String>,

        /// The name of the album in which the track appears.
        #[serde(default)]
        #[serde(skip_serializing_if = "Option::is_none")]
        album_name: Option<String>,

        /// The duration of the track.
        #[serde(default)]
        #[serde(skip_serializing_if = "Option::is_none")]
        duration: Option<String>,

        /// A link to an external copy (e.g., YouTube link) of the track.
        #[serde(default)]
        #[serde(skip_serializing_if = "Option::is_none")]
        external_link: Option<TranscriptionLink>,
    },
}
}

The specification for how the external links are declared:

#![allow(unused)]
fn main() {
/// A link to an external resource for a transcription asset.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub enum TranscriptionLink {
    /// A link to a YouTube video.
    YouTube(String),
}

impl TranscriptionLink {
    /// Returns the URL of the link.
    #[must_use]
    pub fn url(&self) -> &str {
        match self {
            TranscriptionLink::YouTube(url) => url,
        }
    }
}
}

The transcription courses allow you to specify which instruments you want to use for the courses in the user preferences. Refer to the User Preferences page for more details.

The specification for the user preferences for the transcription course is as follows:

#![allow(unused)]
fn main() {
/// Settings for generating a new transcription course that are specific to a user.
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TranscriptionPreferences {
    /// The list of instruments the user wants to practice. Note that changing the instrument ID
    /// will change the IDs of the exercises and lose your progress, so it should be chosen
    /// carefully before you start practicing.
    #[serde(default)]
    pub instruments: Vec<Instrument>,

    /// A path used to download transcription assets to the local filesystem. If not specified,
    /// assets cannot be downloaded.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub download_path: Option<String>,

    /// An alias for the download path. This is useful when the download path is a long path or it's
    /// accessible from multiple locations (e.g., Windows and a terminal running on the WSL). Only
    /// used to present the download path to the user.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub download_path_alias: Option<String>,
}
}

These preferences require that you declare the instruments that you want to use for the transcription. The specification for them is:

#![allow(unused)]
fn main() {
/// Describes an instrument that can be used to practice in a generated course.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Instrument {
    /// The name of the instrument. For example, "Tenor Saxophone".
    pub name: String,

    /// An ID for this instrument used to generate lesson IDs. For example, "tenor_saxophone".
    pub id: String,
}
}

Example courses

Here are a few examples of existing transcription courses:

The Trane Book

Transcription Course Generator

Specification

Example courses