Upload folder using huggingface_hub

6.0.0/audio/Example.svelte

@@ -0,0 +1,19 @@
+<script lang="ts">
+	export let value: string | null;
+	export let type: "gallery" | "table";
+	export let selected = false;
+</script>
+
+<div
+	class:table={type === "table"}
+	class:gallery={type === "gallery"}
+	class:selected
+>
+	{value ? value : ""}
+</div>
+
+<style>
+	.gallery {
+		padding: var(--size-1) var(--size-2);
+	}
+</style>

6.0.0/audio/Index.svelte

@@ -0,0 +1,237 @@
+<svelte:options accessors={true} />
+
+<script lang="ts">
+	import { tick } from "svelte";
+	import { Gradio } from "@gradio/utils";
+	import { StatusTracker } from "@gradio/statustracker";
+	import type { LoadingStatus } from "@gradio/statustracker";
+	import { onMount } from "svelte";
+
+	import StaticAudio from "./static/StaticAudio.svelte";
+	import InteractiveAudio from "./interactive/InteractiveAudio.svelte";
+	import { Block, UploadText } from "@gradio/atoms";
+	import type { AudioEvents, AudioProps } from "./shared/types";
+
+	let props = $props();
+	let upload_promise = $state<Promise<any>>();
+
+	props.props.stream_every = 0.1; // default to 0.1s stream interval
+
+	class AudioGradio extends Gradio<AudioEvents, AudioProps> {
+		async get_data() {
+			if (upload_promise) {
+				await upload_promise;
+				await tick();
+			}
+
+			const data = await super.get_data();
+
+			return data;
+		}
+	}
+
+	const gradio = new AudioGradio(props);
+	let label = $derived(gradio.shared.label || gradio.i18n("audio.audio"));
+	let minimal = $derived(
+		(props as any).minimal ?? (gradio.props as any).minimal ?? false
+	);
+
+	// let uploading = $state(false);
+	let active_source = $derived.by(() =>
+		gradio.props.sources ? gradio.props.sources[0] : null
+	);
+	let initial_value = gradio.props.value;
+
+	const handle_reset_value = (): void => {
+		if (initial_value === null || gradio.props.value === initial_value) {
+			return;
+		}
+		gradio.props.value = initial_value;
+	};
+
+	let dragging: boolean;
+
+	let color_accent = "darkorange";
+
+	let waveform_settings = $derived({
+		height: 50,
+		barWidth: 2,
+		barGap: 3,
+		cursorWidth: 2,
+		cursorColor: "#ddd5e9",
+		autoplay: gradio.props.autoplay,
+		barRadius: 10,
+		dragToSeek: true,
+		normalize: true,
+		minPxPerSec: 20
+	});
+
+	const trim_region_settings = {
+		color: gradio.props.waveform_options.trim_region_color,
+		drag: true,
+		resize: true
+	};
+
+	function set_trim_region_colour(): void {
+		document.documentElement.style.setProperty(
+			"--trim-region-color",
+			trim_region_settings.color || color_accent
+		);
+	}
+
+	function handle_error({ detail }: CustomEvent<string>): void {
+		const [level, status] = detail.includes("Invalid file type")
+			? ["warning", "complete"]
+			: ["error", "error"];
+		if (gradio.shared.loading_status) {
+			gradio.shared.loading_status.status = status as LoadingStatus["status"];
+			gradio.shared.loading_status.message = detail;
+		}
+		gradio.dispatch(level as "error" | "warning", detail);
+	}
+
+	let old_value = $state(gradio.props.value);
+	$effect(() => {
+		if (old_value != gradio.props.value) {
+			old_value = gradio.props.value;
+			gradio.dispatch("change");
+		}
+	});
+
+	onMount(() => {
+		color_accent = getComputedStyle(document?.documentElement).getPropertyValue(
+			"--color-accent"
+		);
+		set_trim_region_colour();
+		waveform_settings.waveColor =
+			gradio.props.waveform_options.waveform_color || "#9ca3af";
+		waveform_settings.progressColor =
+			gradio.props.waveform_options.waveform_progress_color || color_accent;
+		waveform_settings.mediaControls =
+			gradio.props.waveform_options.show_controls;
+		waveform_settings.sampleRate =
+			gradio.props.waveform_options.sample_rate || 44100;
+	});
+</script>
+
+{#if !gradio.shared.interactive}
+	<Block
+		variant={"solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		allow_overflow={false}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		visible={gradio.shared.visible}
+		container={gradio.shared.container}
+		scale={gradio.shared.scale}
+		min_width={gradio.shared.min_width}
+	>
+		<StatusTracker
+			autoscroll={gradio.shared.autoscroll}
+			i18n={gradio.i18n}
+			{...gradio.shared.loading_status}
+			on_clear_status={() =>
+				gradio.dispatch("clear_status", gradio.shared.loading_status)}
+		/>
+
+		<StaticAudio
+			i18n={gradio.i18n}
+			show_label={gradio.shared.show_label}
+			buttons={gradio.props.buttons ?? ["download", "share"]}
+			value={gradio.props.value}
+			subtitles={gradio.props.subtitles}
+			{label}
+			loop={gradio.props.loop}
+			{waveform_settings}
+			waveform_options={gradio.props.waveform_options}
+			editable={gradio.props.editable}
+			{minimal}
+			on:share={(e) => gradio.dispatch("share", e.detail)}
+			on:error={(e) => gradio.dispatch("error", e.detail)}
+			on:play={() => gradio.dispatch("play")}
+			on:pause={() => gradio.dispatch("pause")}
+			on:stop={() => gradio.dispatch("stop")}
+		/>
+	</Block>
+{:else}
+	<Block
+		variant={gradio.props.value === null && active_source === "upload"
+			? "dashed"
+			: "solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		allow_overflow={false}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		visible={gradio.shared.visible}
+		container={gradio.shared.container}
+		scale={gradio.shared.scale}
+		min_width={gradio.shared.min_width}
+	>
+		<StatusTracker
+			autoscroll={gradio.shared.autoscroll}
+			i18n={gradio.i18n}
+			{...gradio.shared.loading_status}
+			on_clear_status={() =>
+				gradio.dispatch("clear_status", gradio.shared.loading_status)}
+		/>
+		<InteractiveAudio
+			bind:upload_promise
+			bind:initial_value
+			{label}
+			show_label={gradio.shared.show_label}
+			buttons={gradio.props.buttons ?? []}
+			value={gradio.props.value}
+			subtitles={gradio.props.subtitles}
+			on:change={({ detail }) => (gradio.props.value = detail)}
+			on:stream={({ detail }) => {
+				gradio.props.value = detail;
+				gradio.dispatch("stream", gradio.props.value);
+			}}
+			on:drag={({ detail }) => (dragging = detail)}
+			root={gradio.shared.root}
+			sources={gradio.props.sources}
+			{active_source}
+			pending={gradio.shared.loading_status.pending}
+			streaming={gradio.props.streaming}
+			bind:recording={gradio.props.recording}
+			loop={gradio.props.loop}
+			max_file_size={gradio.shared.max_file_size}
+			{handle_reset_value}
+			editable={gradio.props.editable}
+			bind:dragging
+			on:edit={() => gradio.dispatch("edit")}
+			on:play={() => gradio.dispatch("play")}
+			on:pause={() => gradio.dispatch("pause")}
+			on:stop={() => gradio.dispatch("stop")}
+			on:start_recording={() => gradio.dispatch("start_recording")}
+			on:pause_recording={() => gradio.dispatch("pause_recording")}
+			on:stop_recording={(e) => {
+				gradio.dispatch("stop_recording");
+				gradio.dispatch("input");
+			}}
+			on:upload={() => {
+				gradio.dispatch("upload");
+				gradio.dispatch("input");
+			}}
+			on:clear={() => {
+				gradio.dispatch("clear");
+				gradio.dispatch("input");
+			}}
+			on:error={handle_error}
+			on:close_stream={() => gradio.dispatch("close_stream", "stream")}
+			i18n={gradio.i18n}
+			{waveform_settings}
+			waveform_options={gradio.props.waveform_options}
+			{trim_region_settings}
+			stream_every={gradio.props.stream_every}
+			stream_state={gradio.shared.loading_status.stream_state}
+			upload={(...args) => gradio.shared.client.upload(...args)}
+			stream_handler={(...args) => gradio.shared.client.stream(...args)}
+			time_limit={gradio.shared.loading_status.time_limit}
+		>
+			<UploadText i18n={gradio.i18n} type="audio" />
+		</InteractiveAudio>
+	</Block>
+{/if}

6.0.0/audio/index.ts

@@ -0,0 +1,7 @@
+import { default as Index } from "./Index.svelte";
+export default Index;
+export { default as BaseStaticAudio } from "./static/StaticAudio.svelte";
+export { default as BaseInteractiveAudio } from "./interactive/InteractiveAudio.svelte";
+export { default as BasePlayer } from "./player/AudioPlayer.svelte";
+export type { WaveformOptions } from "./shared/types";
+export { default as BaseExample } from "./Example.svelte";

6.0.0/audio/interactive/InteractiveAudio.svelte

@@ -0,0 +1,334 @@
+<script lang="ts">
+	import { onDestroy, createEventDispatcher, tick } from "svelte";
+	import { Upload, ModifyUpload } from "@gradio/upload";
+	import { prepare_files, type FileData, type Client } from "@gradio/client";
+	import { BlockLabel } from "@gradio/atoms";
+	import { Music } from "@gradio/icons";
+	import { StreamingBar } from "@gradio/statustracker";
+	import AudioPlayer from "../player/AudioPlayer.svelte";
+
+	import type { IBlobEvent, IMediaRecorder } from "extendable-media-recorder";
+	import type { I18nFormatter } from "js/core/src/gradio_helper";
+	import AudioRecorder from "../recorder/AudioRecorder.svelte";
+	import StreamAudio from "../streaming/StreamAudio.svelte";
+	import { init_media_recorder } from "../streaming/media_recorder";
+	import type { IMediaRecorderConstructor } from "extendable-media-recorder";
+	import { SelectSource } from "@gradio/atoms";
+	import type { WaveformOptions, SubtitleData } from "../shared/types";
+
+	export let value: null | FileData = null;
+	export let subtitles: null | FileData | SubtitleData[] = null;
+	export let label: string;
+	export let root: string;
+	export let loop: boolean;
+	export let show_label = true;
+	export let buttons: string[] = ["download", "share"];
+	export let sources:
+		| ["microphone"]
+		| ["upload"]
+		| ["microphone", "upload"]
+		| ["upload", "microphone"] = ["microphone", "upload"];
+	export let pending = false;
+	export let streaming = false;
+	export let i18n: I18nFormatter;
+	export let waveform_settings: Record<string, any>;
+	export let trim_region_settings = {};
+	export let waveform_options: WaveformOptions = {};
+	export let dragging: boolean;
+	export let active_source: "microphone" | "upload";
+	export let handle_reset_value: () => void = () => {};
+	export let editable = true;
+	export let max_file_size: number | null = null;
+	export let upload: Client["upload"];
+	export let stream_handler: Client["stream"];
+	export let stream_every: number = 0.1;
+	export let uploading = false;
+	export let recording = false;
+	export let class_name = "";
+	export let upload_promise: Promise<any> | null = null;
+	export let initial_value: FileData | null = null;
+
+	export let time_limit: number | null = null;
+	export let stream_state: "open" | "waiting" | "closed" = "closed";
+
+	$: dispatch("drag", dragging);
+
+	// TODO: make use of this
+	// export let type: "normal" | "numpy" = "normal";
+	let recorder: IMediaRecorder;
+	let mode = "";
+	let header: Uint8Array | undefined = undefined;
+	let pending_stream: Uint8Array[] = [];
+	let submit_pending_stream_on_pending_end = false;
+	let inited = false;
+	let streaming_media_recorder: IMediaRecorderConstructor;
+
+	const NUM_HEADER_BYTES = 44;
+	let audio_chunks: Blob[] = [];
+	const is_browser = typeof window !== "undefined";
+	if (is_browser && streaming) {
+		init_media_recorder().then((a) => {
+			streaming_media_recorder = a;
+		});
+	}
+
+	const dispatch = createEventDispatcher<{
+		change: FileData | null;
+		stream: FileData;
+		edit: never;
+		play: never;
+		pause: never;
+		stop: never;
+		end: never;
+		drag: boolean;
+		error: string;
+		upload: FileData;
+		clear: undefined;
+		start_recording: undefined;
+		pause_recording: undefined;
+		stop_recording: undefined;
+		close_stream: undefined;
+	}>();
+
+	const to_blob_parts = (parts: Uint8Array[] | Blob[]): BlobPart[] =>
+		parts.map((part) => {
+			if (part instanceof Blob) return part;
+			return part.slice();
+		});
+
+	const dispatch_blob = async (
+		blobs: Uint8Array[] | Blob[],
+		event: "stream" | "change" | "stop_recording"
+	): Promise<void> => {
+		let _audio_blob = new File(to_blob_parts(blobs), "audio.wav", {
+			type: "audio/wav"
+		});
+		if (_audio_blob.size === 0) {
+			return;
+		}
+		const val = await prepare_files([_audio_blob], event === "stream");
+		initial_value = value;
+		value = (
+			(await upload(val, root, undefined, max_file_size || undefined))?.filter(
+				Boolean
+			) as FileData[]
+		)[0];
+		dispatch(event, value);
+	};
+
+	onDestroy(() => {
+		if (streaming && recorder && recorder.state !== "inactive") {
+			recorder.stop();
+		}
+	});
+
+	async function prepare_audio(): Promise<void> {
+		let stream: MediaStream | null;
+
+		try {
+			stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+		} catch (err) {
+			if (!navigator.mediaDevices) {
+				dispatch("error", i18n("audio.no_device_support"));
+				return;
+			}
+			if (err instanceof DOMException && err.name == "NotAllowedError") {
+				dispatch("error", i18n("audio.allow_recording_access"));
+				return;
+			}
+			throw err;
+		}
+		if (stream == null) return;
+		if (streaming) {
+			recorder = new streaming_media_recorder(stream, {
+				mimeType: "audio/wav"
+			});
+
+			recorder.addEventListener("dataavailable", handle_chunk);
+		} else {
+			recorder = new MediaRecorder(stream);
+			recorder.addEventListener("dataavailable", (event) => {
+				audio_chunks.push(event.data);
+			});
+		}
+		recorder.addEventListener("stop", async () => {
+			recording = false;
+			recorder.stop();
+			await dispatch_blob(audio_chunks, "change");
+			await dispatch_blob(audio_chunks, "stop_recording");
+			audio_chunks = [];
+		});
+		inited = true;
+	}
+
+	async function handle_chunk(event: IBlobEvent): Promise<void> {
+		let buffer = await event.data.arrayBuffer();
+		let payload = new Uint8Array(buffer);
+		if (!header) {
+			header = new Uint8Array(buffer.slice(0, NUM_HEADER_BYTES));
+			payload = new Uint8Array(buffer.slice(NUM_HEADER_BYTES));
+		}
+		if (pending) {
+			pending_stream.push(payload);
+		} else {
+			let blobParts = [header].concat(pending_stream, [payload]);
+			if (!recording || stream_state === "waiting") return;
+			dispatch_blob(blobParts, "stream");
+			pending_stream = [];
+		}
+	}
+
+	$: if (submit_pending_stream_on_pending_end && pending === false) {
+		submit_pending_stream_on_pending_end = false;
+		if (header && pending_stream) {
+			let blobParts: Uint8Array[] = [header].concat(pending_stream);
+			pending_stream = [];
+			dispatch_blob(blobParts, "stream");
+		}
+	}
+
+	async function record(): Promise<void> {
+		recording = true;
+		dispatch("start_recording");
+		if (!inited) await prepare_audio();
+
+		header = undefined;
+		if (streaming && recorder.state != "recording") {
+			recorder.start(stream_every * 1000);
+		}
+	}
+
+	function clear(): void {
+		dispatch("change", null);
+		dispatch("clear");
+		mode = "";
+		value = null;
+	}
+
+	function handle_load({ detail }: { detail: FileData }): void {
+		value = detail;
+		dispatch("change", detail);
+		dispatch("upload", detail);
+	}
+
+	async function stop(): Promise<void> {
+		recording = false;
+
+		if (streaming) {
+			dispatch("close_stream");
+			dispatch("stop_recording");
+			recorder.stop();
+
+			if (pending) {
+				submit_pending_stream_on_pending_end = true;
+			}
+			dispatch_blob(audio_chunks, "stop_recording");
+			dispatch("clear");
+			mode = "";
+		}
+	}
+
+	$: if (!recording && recorder) stop();
+	$: if (recording && recorder) record();
+</script>
+
+<BlockLabel
+	{show_label}
+	Icon={Music}
+	float={active_source === "upload" && value === null}
+	label={label || i18n("audio.audio")}
+/>
+<div
+	class="audio-container {class_name}"
+	data-testid={label ? "waveform-" + label : "unlabelled-audio"}
+>
+	<StreamingBar {time_limit} />
+	{#if value === null || streaming}
+		{#if active_source === "microphone"}
+			<ModifyUpload {i18n} on:clear={clear} />
+			{#if streaming}
+				<StreamAudio
+					{record}
+					{recording}
+					{stop}
+					{i18n}
+					{waveform_settings}
+					{waveform_options}
+					waiting={stream_state === "waiting"}
+				/>
+			{:else}
+				<AudioRecorder
+					bind:mode
+					{i18n}
+					{editable}
+					{recording}
+					{dispatch_blob}
+					{waveform_settings}
+					{waveform_options}
+					{handle_reset_value}
+					on:start_recording
+					on:pause_recording
+					on:stop_recording
+				/>
+			{/if}
+		{:else if active_source === "upload"}
+			<!-- explicitly listed out audio mimetypes due to iOS bug not recognizing audio/* -->
+			<Upload
+				bind:upload_promise
+				filetype="audio/aac,audio/midi,audio/mpeg,audio/ogg,audio/wav,audio/x-wav,audio/opus,audio/webm,audio/flac,audio/vnd.rn-realaudio,audio/x-ms-wma,audio/x-aiff,audio/amr,audio/*"
+				on:load={handle_load}
+				bind:dragging
+				bind:uploading
+				on:error={({ detail }) => dispatch("error", detail)}
+				{root}
+				{max_file_size}
+				{upload}
+				{stream_handler}
+				aria_label={i18n("audio.drop_to_upload")}
+			>
+				<slot />
+			</Upload>
+		{/if}
+	{:else}
+		<ModifyUpload
+			{i18n}
+			on:clear={clear}
+			on:edit={() => (mode = "edit")}
+			download={buttons === null
+				? value.url
+				: buttons.includes("download")
+					? value.url
+					: null}
+		/>
+
+		<AudioPlayer
+			bind:mode
+			{value}
+			subtitles={Array.isArray(subtitles) ? subtitles : subtitles?.url}
+			{label}
+			{i18n}
+			{dispatch_blob}
+			{waveform_settings}
+			{waveform_options}
+			{trim_region_settings}
+			{handle_reset_value}
+			{editable}
+			{loop}
+			interactive
+			on:stop
+			on:play
+			on:pause
+			on:edit
+		/>
+	{/if}
+	<SelectSource {sources} bind:active_source handle_clear={clear} />
+</div>
+
+<style>
+	.audio-container {
+		height: calc(var(--size-full) - var(--size-6));
+		display: flex;
+		flex-direction: column;
+		justify-content: space-between;
+	}
+</style>

6.0.0/audio/package.json

@@ -0,0 +1,60 @@
+{
+	"name": "@gradio/audio",
+	"version": "0.20.0",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"dependencies": {
+		"@gradio/atoms": "workspace:^",
+		"@gradio/button": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"extendable-media-recorder": "9.0.0",
+		"extendable-media-recorder-wav-encoder": "7.0.76",
+		"hls.js": "1.5.13",
+		"resize-observer-polyfill": "1.5.1",
+		"svelte-range-slider-pips": "4.1.0",
+		"wavesurfer.js": "7.11.0"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"main_changeset": true,
+	"main": "index.ts",
+	"exports": {
+		"./package.json": "./package.json",
+		".": {
+			"gradio": "./index.ts",
+			"svelte": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./example": {
+			"gradio": "./Example.svelte",
+			"svelte": "./dist/Example.svelte",
+			"types": "./dist/Example.svelte.d.ts"
+		},
+		"./shared": {
+			"gradio": "./shared/index.ts",
+			"svelte": "./dist/shared/index.js",
+			"types": "./dist/shared/index.d.ts"
+		},
+		"./base": {
+			"gradio": "./static/StaticAudio.svelte",
+			"svelte": "./dist/static/StaticAudio.svelte",
+			"types": "./dist/static/StaticAudio.svelte.d.ts"
+		}
+	},
+	"peerDependencies": {
+		"svelte": "^5.43.4"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/audio"
+	}
+}

6.0.0/audio/player/AudioPlayer.svelte

@@ -0,0 +1,468 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import { Music } from "@gradio/icons";
+	import { format_time, type I18nFormatter } from "@gradio/utils";
+	import WaveSurfer from "wavesurfer.js";
+	import { skip_audio, process_audio } from "../shared/utils";
+	import WaveformControls from "../shared/WaveformControls.svelte";
+	import { Empty } from "@gradio/atoms";
+	import type { FileData } from "@gradio/client";
+	import type { WaveformOptions, SubtitleData } from "../shared/types";
+	import { createEventDispatcher } from "svelte";
+
+	import Hls from "hls.js";
+
+	export let value: null | FileData = null;
+	export let subtitles: null | string | SubtitleData[] = null;
+	$: url = value?.url;
+	export let label: string;
+	export let i18n: I18nFormatter;
+	export let dispatch_blob: (
+		blobs: Uint8Array[] | Blob[],
+		event: "stream" | "change" | "stop_recording"
+	) => Promise<void> = () => Promise.resolve();
+	export let interactive = false;
+	export let editable = true;
+	export let trim_region_settings = {};
+	export let waveform_settings: Record<string, any>;
+	export let waveform_options: WaveformOptions;
+	export let mode = "";
+	export let loop: boolean;
+	export let handle_reset_value: () => void = () => {};
+
+	let container: HTMLDivElement;
+	let waveform: WaveSurfer | undefined;
+	let waveform_component_wrapper: HTMLDivElement;
+	let playing = false;
+
+	let subtitle_container: HTMLDivElement;
+
+	let timeRef: HTMLTimeElement;
+	let durationRef: HTMLTimeElement;
+	let audio_duration: number;
+
+	let trimDuration = 0;
+
+	let show_volume_slider = false;
+	let audio_player: HTMLAudioElement;
+
+	let stream_active = false;
+	let subtitles_toggle = true;
+	let subtitle_event_handlers: (() => void)[] = [];
+
+	const dispatch = createEventDispatcher<{
+		stop: undefined;
+		play: undefined;
+		pause: undefined;
+		edit: undefined;
+		end: undefined;
+		load: undefined;
+	}>();
+
+	$: use_waveform =
+		waveform_options.show_recording_waveform && !value?.is_stream;
+
+	const create_waveform = (): void => {
+		waveform = WaveSurfer.create({
+			container: container,
+			...waveform_settings
+		});
+
+		if (subtitles && waveform) {
+			if (subtitles_toggle) {
+				add_subtitles_to_waveform(waveform, subtitles);
+			} else {
+				hide_subtitles();
+			}
+		}
+
+		if (value?.url && waveform) {
+			waveform.load(value?.url);
+		}
+
+		waveform?.on("decode", (duration: any) => {
+			audio_duration = duration;
+			durationRef && (durationRef.textContent = format_time(duration));
+		});
+
+		waveform?.on(
+			"timeupdate",
+			(currentTime: any) =>
+				timeRef && (timeRef.textContent = format_time(currentTime))
+		);
+
+		waveform?.on("interaction", () => {
+			const currentTime = waveform?.getCurrentTime() || 0;
+			timeRef && (timeRef.textContent = format_time(currentTime));
+		});
+
+		waveform?.on("ready", () => {
+			if (!waveform_settings.autoplay) {
+				waveform?.stop();
+			} else {
+				waveform?.play();
+			}
+		});
+
+		waveform?.on("finish", () => {
+			if (loop) {
+				waveform?.play();
+			} else {
+				playing = false;
+				dispatch("stop");
+			}
+		});
+		waveform?.on("pause", () => {
+			playing = false;
+			dispatch("pause");
+		});
+		waveform?.on("play", () => {
+			playing = true;
+			dispatch("play");
+		});
+
+		waveform?.on("load", () => {
+			dispatch("load");
+		});
+	};
+
+	$: if (use_waveform && container !== undefined && container !== null) {
+		if (waveform !== undefined) waveform.destroy();
+		container.innerHTML = "";
+		create_waveform();
+		playing = false;
+	}
+
+	const handle_trim_audio = async (
+		start: number,
+		end: number
+	): Promise<void> => {
+		mode = "";
+		const decodedData = waveform?.getDecodedData();
+		if (decodedData)
+			await process_audio(
+				decodedData,
+				start,
+				end,
+				waveform_settings.sampleRate
+			).then(async (trimmedBlob: Uint8Array) => {
+				await dispatch_blob([trimmedBlob], "change");
+				waveform?.destroy();
+				container.innerHTML = "";
+			});
+		dispatch("edit");
+	};
+
+	async function load_audio(data: string): Promise<void> {
+		stream_active = false;
+
+		if (waveform_options.show_recording_waveform) {
+			waveform?.load(data);
+		} else if (audio_player) {
+			audio_player.src = data;
+		}
+	}
+
+	$: if (subtitles && waveform) {
+		if (subtitles_toggle) {
+			add_subtitles_to_waveform(waveform, subtitles);
+		} else {
+			hide_subtitles();
+		}
+	}
+
+	function load_stream(value: FileData | null): void {
+		if (!value || !value.is_stream || !value.url) return;
+
+		if (Hls.isSupported() && !stream_active) {
+			// Set config to start playback after 1 second of data received
+			const hls = new Hls({
+				maxBufferLength: 1,
+				maxMaxBufferLength: 1,
+				lowLatencyMode: true
+			});
+			hls.loadSource(value.url);
+			hls.attachMedia(audio_player);
+			hls.on(Hls.Events.MANIFEST_PARSED, function () {
+				if (waveform_settings.autoplay) audio_player.play();
+			});
+			hls.on(Hls.Events.ERROR, function (event, data) {
+				console.error("HLS error:", event, data);
+				if (data.fatal) {
+					switch (data.type) {
+						case Hls.ErrorTypes.NETWORK_ERROR:
+							console.error(
+								"Fatal network error encountered, trying to recover"
+							);
+							hls.startLoad();
+							break;
+						case Hls.ErrorTypes.MEDIA_ERROR:
+							console.error("Fatal media error encountered, trying to recover");
+							hls.recoverMediaError();
+							break;
+						default:
+							console.error("Fatal error, cannot recover");
+							hls.destroy();
+							break;
+					}
+				}
+			});
+			stream_active = true;
+		} else if (!stream_active) {
+			audio_player.src = value.url;
+			if (waveform_settings.autoplay) audio_player.play();
+			stream_active = true;
+		}
+	}
+
+	$: if (audio_player && url) {
+		load_audio(url);
+	}
+
+	$: if (audio_player && value?.is_stream) {
+		load_stream(value);
+	}
+
+	onMount(() => {
+		window.addEventListener("keydown", (e) => {
+			if (!waveform || show_volume_slider) return;
+
+			const is_focused_in_waveform =
+				waveform_component_wrapper &&
+				waveform_component_wrapper.contains(document.activeElement);
+			if (!is_focused_in_waveform) return;
+			if (e.key === "ArrowRight" && mode !== "edit") {
+				skip_audio(waveform, 0.1);
+			} else if (e.key === "ArrowLeft" && mode !== "edit") {
+				skip_audio(waveform, -0.1);
+			}
+		});
+	});
+
+	async function add_subtitles_to_waveform(
+		wavesurfer: WaveSurfer,
+		subtitle_data: string | SubtitleData[]
+	): Promise<void> {
+		clear_subtitles();
+		try {
+			let subtitles: SubtitleData[];
+			if (Array.isArray(subtitle_data)) {
+				subtitles = subtitle_data;
+			} else {
+				const response = await fetch(subtitle_data);
+				const subtitle_content = await response.text();
+				subtitles = parse_subtitles(subtitle_content);
+			}
+
+			if (subtitles.length > 0) {
+				let current_subtitle = "";
+				if (subtitle_container) {
+					subtitle_container.style.display = "";
+					const audioProcessHandler = (time: number): void => {
+						const subtitle = subtitles.find(
+							(s) => time >= s.start && time <= s.end
+						);
+						if (subtitle && subtitle.text !== current_subtitle) {
+							current_subtitle = subtitle.text;
+							subtitle_container.textContent = current_subtitle;
+						} else if (!subtitle && current_subtitle !== "") {
+							current_subtitle = "";
+							subtitle_container.textContent = "";
+						}
+					};
+					wavesurfer.on("audioprocess", audioProcessHandler);
+					subtitle_event_handlers.push(() => {
+						wavesurfer.un("audioprocess", audioProcessHandler);
+					});
+				}
+			}
+		} catch (error) {}
+	}
+
+	function hide_subtitles(): void {
+		if (subtitle_container) {
+			subtitle_container.style.display = "none";
+		}
+	}
+
+	function clear_subtitles(): void {
+		if (subtitle_container) {
+			subtitle_container.textContent = "";
+		}
+		subtitle_event_handlers.forEach((handler) => handler());
+		subtitle_event_handlers = [];
+	}
+
+	function parse_subtitles(subtitle_content: string): SubtitleData[] {
+		const lines = subtitle_content.split("\n");
+		const subtitles: SubtitleData[] = [];
+
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i].trim();
+			if (line.includes(" --> ")) {
+				const [start_time, end_time] = line.split(" --> ");
+				const start = parse_time_to_seconds(start_time);
+				const end = parse_time_to_seconds(end_time);
+
+				let text = "";
+				for (let j = i + 1; j < lines.length && lines[j].trim() !== ""; j++) {
+					if (text) text += " ";
+					text += lines[j].trim();
+				}
+
+				if (text) {
+					subtitles.push({ start, end, text });
+				}
+			}
+		}
+
+		return subtitles;
+	}
+
+	function parse_time_to_seconds(time_str: string): number {
+		const parts = time_str.split(":");
+		if (parts.length === 3) {
+			const hours = parseInt(parts[0]);
+			const minutes = parseInt(parts[1]);
+			const seconds = parseFloat(parts[2]);
+			return hours * 3600 + minutes * 60 + seconds;
+		}
+		return 0;
+	}
+</script>
+
+<audio
+	class="standard-player"
+	class:hidden={use_waveform}
+	controls
+	autoplay={waveform_settings.autoplay}
+	on:load
+	bind:this={audio_player}
+	on:ended={() => dispatch("stop")}
+	on:play={() => dispatch("play")}
+	preload="metadata"
+/>
+{#if value === null}
+	<Empty size="small">
+		<Music />
+	</Empty>
+{:else if use_waveform}
+	<div
+		class="component-wrapper"
+		data-testid={label ? "waveform-" + label : "unlabelled-audio"}
+		bind:this={waveform_component_wrapper}
+	>
+		<div class="waveform-container">
+			<div
+				id="waveform"
+				bind:this={container}
+				style:height={container ? null : "58px"}
+			/>
+		</div>
+
+		<div class="timestamps">
+			<time bind:this={timeRef} id="time">0:00</time>
+			<div>
+				{#if mode === "edit" && trimDuration > 0}
+					<time id="trim-duration">{format_time(trimDuration)}</time>
+				{/if}
+				<time bind:this={durationRef} id="duration">0:00</time>
+			</div>
+		</div>
+
+		<div
+			bind:this={subtitle_container}
+			class="subtitle-display"
+			data-testid="subtitle-display"
+		></div>
+
+		<WaveformControls
+			{container}
+			{waveform}
+			{playing}
+			{audio_duration}
+			{i18n}
+			{interactive}
+			{handle_trim_audio}
+			bind:mode
+			bind:trimDuration
+			bind:show_volume_slider
+			bind:subtitles_toggle
+			show_redo={interactive}
+			{handle_reset_value}
+			{waveform_options}
+			{trim_region_settings}
+			{editable}
+			show_subtitles={subtitles !== null}
+		/>
+	</div>
+{/if}
+
+<style>
+	.component-wrapper {
+		padding: var(--size-3);
+		width: 100%;
+	}
+
+	:global(::part(wrapper)) {
+		margin-bottom: var(--size-2);
+	}
+
+	.timestamps {
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+		width: 100%;
+		padding: var(--size-1) 0;
+	}
+
+	#time {
+		color: var(--neutral-400);
+	}
+
+	#duration {
+		color: var(--neutral-400);
+	}
+
+	#trim-duration {
+		color: var(--color-accent);
+		margin-right: var(--spacing-sm);
+	}
+	.waveform-container {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: var(--size-full);
+	}
+
+	#waveform {
+		width: 100%;
+		height: 100%;
+		position: relative;
+	}
+
+	.standard-player {
+		width: 100%;
+		padding: var(--size-2);
+	}
+
+	.subtitle-display {
+		color: var(--text-secondary);
+		font-size: var(--text-lg);
+		text-align: center;
+		max-width: 600px;
+		line-height: 1.3;
+		min-height: var(--size-4);
+		font-family: var(--font-sans);
+		font-weight: normal;
+		margin: var(--size-2) auto;
+		padding: var(--size-1) var(--size-2);
+		border-radius: 2px;
+		transition: opacity 0.2s ease-in-out;
+	}
+
+	.hidden,
+	.subtitle-display:empty {
+		display: none;
+	}
+</style>

6.0.0/audio/recorder/AudioRecorder.svelte

@@ -0,0 +1,293 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import type { I18nFormatter } from "@gradio/utils";
+	import { createEventDispatcher } from "svelte";
+	import WaveSurfer from "wavesurfer.js";
+	import { skip_audio, process_audio } from "../shared/utils";
+	import WSRecord from "wavesurfer.js/dist/plugins/record.js";
+	import WaveformControls from "../shared/WaveformControls.svelte";
+	import WaveformRecordControls from "../shared/WaveformRecordControls.svelte";
+	import RecordPlugin from "wavesurfer.js/dist/plugins/record.js";
+	import type { WaveformOptions } from "../shared/types";
+	import { format_time } from "@gradio/utils";
+
+	export let mode: string;
+	export let i18n: I18nFormatter;
+	export let dispatch_blob: (
+		blobs: Uint8Array[] | Blob[],
+		event: "stream" | "change" | "stop_recording"
+	) => Promise<void> | undefined;
+	export let waveform_settings: Record<string, any>;
+	export let waveform_options: WaveformOptions = {
+		show_recording_waveform: true
+	};
+	export let handle_reset_value: () => void;
+	export let editable = true;
+	export let recording = false;
+
+	let micWaveform: WaveSurfer;
+	let recordingWaveform: WaveSurfer;
+	let playing = false;
+
+	let recordingContainer: HTMLDivElement;
+	let microphoneContainer: HTMLDivElement;
+
+	let record: WSRecord;
+	let recordedAudio: string | null = null;
+
+	// timestamps
+	let timeRef: HTMLTimeElement;
+	let durationRef: HTMLTimeElement;
+	let audio_duration: number;
+	let seconds = 0;
+	let interval: NodeJS.Timeout;
+	let timing = false;
+	// trimming
+	let trimDuration = 0;
+
+	const start_interval = (): void => {
+		clearInterval(interval);
+		interval = setInterval(() => {
+			seconds++;
+		}, 1000);
+	};
+
+	const dispatch = createEventDispatcher<{
+		start_recording: undefined;
+		pause_recording: undefined;
+		stop_recording: undefined;
+		stop: undefined;
+		play: undefined;
+		pause: undefined;
+		end: undefined;
+		edit: undefined;
+	}>();
+
+	function record_start_callback(): void {
+		start_interval();
+		timing = true;
+		dispatch("start_recording");
+		if (waveform_options.show_recording_waveform) {
+			let waveformCanvas = microphoneContainer;
+			if (waveformCanvas) waveformCanvas.style.display = "block";
+		}
+	}
+
+	async function record_end_callback(blob: Blob): Promise<void> {
+		seconds = 0;
+		timing = false;
+		clearInterval(interval);
+		try {
+			const array_buffer = await blob.arrayBuffer();
+			const context = new AudioContext({
+				sampleRate: waveform_settings.sampleRate
+			});
+			const audio_buffer = await context.decodeAudioData(array_buffer);
+
+			if (audio_buffer)
+				await process_audio(audio_buffer).then(async (audio: Uint8Array) => {
+					await dispatch_blob([audio], "change");
+					await dispatch_blob([audio], "stop_recording");
+				});
+		} catch (e) {
+			console.error(e);
+		}
+	}
+
+	$: record?.on("record-resume", () => {
+		start_interval();
+	});
+
+	$: recordingWaveform?.on("decode", (duration: any) => {
+		audio_duration = duration;
+		durationRef && (durationRef.textContent = format_time(duration));
+	});
+
+	$: recordingWaveform?.on(
+		"timeupdate",
+		(currentTime: any) =>
+			timeRef && (timeRef.textContent = format_time(currentTime))
+	);
+
+	$: recordingWaveform?.on("pause", () => {
+		dispatch("pause");
+		playing = false;
+	});
+
+	$: recordingWaveform?.on("play", () => {
+		dispatch("play");
+		playing = true;
+	});
+
+	$: recordingWaveform?.on("finish", () => {
+		dispatch("stop");
+		playing = false;
+	});
+
+	let record_mounted = false;
+
+	const create_mic_waveform = (): void => {
+		if (microphoneContainer) microphoneContainer.innerHTML = "";
+		if (micWaveform !== undefined) micWaveform.destroy();
+		if (!microphoneContainer) return;
+		micWaveform = WaveSurfer.create({
+			...waveform_settings,
+			normalize: false,
+			container: microphoneContainer
+		});
+
+		record = micWaveform.registerPlugin(RecordPlugin.create());
+		record?.on("record-end", record_end_callback);
+		record?.on("record-start", record_start_callback);
+		record?.on("record-pause", () => {
+			dispatch("pause_recording");
+			clearInterval(interval);
+		});
+
+		record?.on("record-end", (blob) => {
+			recordedAudio = URL.createObjectURL(blob);
+
+			const microphone = microphoneContainer;
+			const recording = recordingContainer;
+
+			if (microphone) microphone.style.display = "none";
+			if (recording && recordedAudio) {
+				recording.innerHTML = "";
+				create_recording_waveform();
+			}
+		});
+		record_mounted = true;
+	};
+
+	const create_recording_waveform = (): void => {
+		let recording = recordingContainer;
+		if (!recordedAudio || !recording) return;
+		recordingWaveform = WaveSurfer.create({
+			container: recording,
+			url: recordedAudio,
+			...waveform_settings
+		});
+	};
+
+	const handle_trim_audio = async (
+		start: number,
+		end: number
+	): Promise<void> => {
+		mode = "edit";
+		const decodedData = recordingWaveform.getDecodedData();
+		if (decodedData)
+			await process_audio(decodedData, start, end).then(
+				async (trimmedAudio: Uint8Array) => {
+					await dispatch_blob([trimmedAudio], "change");
+					await dispatch_blob([trimmedAudio], "stop_recording");
+					recordingWaveform.destroy();
+					create_recording_waveform();
+				}
+			);
+		dispatch("edit");
+	};
+
+	onMount(() => {
+		create_mic_waveform();
+
+		window.addEventListener("keydown", (e) => {
+			const is_focused_in_waveform =
+				recordingContainer &&
+				recordingContainer.contains(document.activeElement);
+			if (!is_focused_in_waveform) return;
+			if (e.key === "ArrowRight") {
+				skip_audio(recordingWaveform, 0.1);
+			} else if (e.key === "ArrowLeft") {
+				skip_audio(recordingWaveform, -0.1);
+			}
+		});
+	});
+</script>
+
+<div class="component-wrapper">
+	<div
+		class="microphone"
+		bind:this={microphoneContainer}
+		data-testid="microphone-waveform"
+	/>
+	<div bind:this={recordingContainer} data-testid="recording-waveform" />
+
+	{#if (timing || recordedAudio) && waveform_options.show_recording_waveform}
+		<div class="timestamps">
+			<time bind:this={timeRef} class="time">0:00</time>
+			<div>
+				{#if mode === "edit" && trimDuration > 0}
+					<time class="trim-duration">{format_time(trimDuration)}</time>
+				{/if}
+				{#if timing}
+					<time class="duration">{format_time(seconds)}</time>
+				{:else}
+					<time bind:this={durationRef} class="duration">0:00</time>
+				{/if}
+			</div>
+		</div>
+	{/if}
+
+	{#if microphoneContainer && !recordedAudio && record_mounted}
+		<WaveformRecordControls
+			bind:record
+			{i18n}
+			{timing}
+			{recording}
+			show_recording_waveform={waveform_options.show_recording_waveform}
+			record_time={format_time(seconds)}
+		/>
+	{/if}
+
+	{#if recordingWaveform && recordedAudio}
+		<WaveformControls
+			bind:waveform={recordingWaveform}
+			container={recordingContainer}
+			{playing}
+			{audio_duration}
+			{i18n}
+			{editable}
+			interactive={true}
+			{handle_trim_audio}
+			bind:trimDuration
+			bind:mode
+			show_redo
+			{handle_reset_value}
+			{waveform_options}
+		/>
+	{/if}
+</div>
+
+<style>
+	.microphone {
+		width: 100%;
+		display: none;
+	}
+
+	.component-wrapper {
+		padding: var(--size-3);
+		width: 100%;
+	}
+
+	.timestamps {
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+		width: 100%;
+		padding: var(--size-1) 0;
+		margin: var(--spacing-md) 0;
+	}
+
+	.time {
+		color: var(--neutral-400);
+	}
+
+	.duration {
+		color: var(--neutral-400);
+	}
+
+	.trim-duration {
+		color: var(--color-accent);
+		margin-right: var(--spacing-sm);
+	}
+</style>

6.0.0/audio/shared/Audio.svelte

@@ -0,0 +1,20 @@
+<script lang="ts">
+	import type { HTMLAudioAttributes } from "svelte/elements";
+	import { createEventDispatcher } from "svelte";
+	interface Props extends HTMLAudioAttributes {
+		"data-testid"?: string;
+	}
+	type $$Props = Props;
+
+	export let src: HTMLAudioAttributes["src"] = undefined;
+
+	const dispatch = createEventDispatcher();
+</script>
+
+<audio
+	{src}
+	{...$$restProps}
+	on:play={dispatch.bind(null, "play")}
+	on:pause={dispatch.bind(null, "pause")}
+	on:ended={dispatch.bind(null, "ended")}
+/>

6.0.0/audio/shared/DeviceSelect.svelte

@@ -0,0 +1,71 @@
+<script lang="ts">
+	import RecordPlugin from "wavesurfer.js/dist/plugins/record.js";
+	import type { I18nFormatter } from "@gradio/utils";
+	import { createEventDispatcher } from "svelte";
+
+	export let i18n: I18nFormatter;
+	export let micDevices: MediaDeviceInfo[] = [];
+
+	const dispatch = createEventDispatcher<{
+		error: string;
+	}>();
+
+	$: if (typeof window !== "undefined") {
+		try {
+			let tempDevices: MediaDeviceInfo[] = [];
+			RecordPlugin.getAvailableAudioDevices().then(
+				(devices: MediaDeviceInfo[]) => {
+					micDevices = devices;
+					devices.forEach((device) => {
+						if (device.deviceId) {
+							tempDevices.push(device);
+						}
+					});
+					micDevices = tempDevices;
+				}
+			);
+		} catch (err) {
+			if (err instanceof DOMException && err.name == "NotAllowedError") {
+				dispatch("error", i18n("audio.allow_recording_access"));
+			}
+			throw err;
+		}
+	}
+</script>
+
+<select
+	class="mic-select"
+	aria-label="Select input device"
+	disabled={micDevices.length === 0}
+>
+	{#if micDevices.length === 0}
+		<option value="">{i18n("audio.no_microphone")}</option>
+	{:else}
+		{#each micDevices as micDevice}
+			<option value={micDevice.deviceId}>{micDevice.label}</option>
+		{/each}
+	{/if}
+</select>
+
+<style>
+	.mic-select {
+		height: var(--size-8);
+		background: var(--block-background-fill);
+		padding: 0px var(--spacing-xxl);
+		border-radius: var(--button-large-radius);
+		font-size: var(--text-md);
+		border: 1px solid var(--block-border-color);
+		gap: var(--size-1);
+	}
+
+	select {
+		text-overflow: ellipsis;
+		max-width: var(--size-40);
+	}
+
+	@media (max-width: 375px) {
+		select {
+			width: 100%;
+		}
+	}
+</style>

6.0.0/audio/shared/MinimalAudioPlayer.svelte

@@ -0,0 +1,184 @@
+<script lang="ts">
+	import { onMount, onDestroy } from "svelte";
+	import WaveSurfer from "wavesurfer.js";
+	import type { FileData } from "@gradio/client";
+	import { format_time } from "@gradio/utils";
+
+	export let value: FileData;
+	export let label: string;
+	export let loop = false;
+
+	let container: HTMLDivElement;
+	let waveform: WaveSurfer | undefined;
+	let playing = false;
+	let duration = 0;
+	let currentTime = 0;
+	let waveform_ready = false;
+
+	$: resolved_src = value.url;
+
+	const create_waveform = async (): Promise<void> => {
+		if (!container || !resolved_src || waveform_ready) return;
+
+		if (waveform) {
+			waveform.destroy();
+		}
+
+		const accentColor =
+			getComputedStyle(document.documentElement).getPropertyValue(
+				"--color-accent"
+			) || "#ff7c00";
+
+		waveform = WaveSurfer.create({
+			container,
+			height: 32,
+			waveColor: "rgba(128, 128, 128, 0.5)",
+			progressColor: accentColor,
+			cursorColor: "transparent",
+			barWidth: 2,
+			barGap: 2,
+			barRadius: 2,
+			normalize: true,
+			interact: true,
+			dragToSeek: true,
+			hideScrollbar: true
+		});
+
+		waveform.on("play", () => (playing = true));
+		waveform.on("pause", () => (playing = false));
+		waveform.on("ready", () => {
+			duration = waveform?.getDuration() || 0;
+			waveform_ready = true;
+		});
+		waveform.on("audioprocess", () => {
+			currentTime = waveform?.getCurrentTime() || 0;
+		});
+		waveform.on("interaction", () => {
+			currentTime = waveform?.getCurrentTime() || 0;
+		});
+		waveform.on("finish", () => {
+			playing = false;
+			if (loop) {
+				waveform?.play();
+			}
+		});
+
+		await waveform.load(resolved_src);
+	};
+
+	onMount(async () => {
+		await create_waveform();
+	});
+
+	onDestroy(() => {
+		if (waveform) {
+			waveform.destroy();
+		}
+	});
+
+	const togglePlay = (): void => {
+		if (waveform) {
+			waveform.playPause();
+		}
+	};
+</script>
+
+<div
+	class="minimal-audio-player"
+	aria-label={label || "Audio"}
+	data-testid={label && typeof label === "string" && label.trim()
+		? "waveform-" + label
+		: "unlabelled-audio"}
+>
+	<button
+		class="play-btn"
+		on:click={togglePlay}
+		aria-label={playing ? "Pause" : "Play"}
+	>
+		{#if playing}
+			<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+				<rect x="6" y="5" width="4" height="14" rx="1" fill="currentColor" />
+				<rect x="14" y="5" width="4" height="14" rx="1" fill="currentColor" />
+			</svg>
+		{:else}
+			<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+				<path
+					d="M8 5.74537C8 5.06444 8.77346 4.64713 9.35139 5.02248L18.0227 10.2771C18.5518 10.6219 18.5518 11.3781 18.0227 11.7229L9.35139 16.9775C8.77346 17.3529 8 16.9356 8 16.2546V5.74537Z"
+					fill="currentColor"
+				/>
+			</svg>
+		{/if}
+	</button>
+
+	<div class="waveform-wrapper" bind:this={container}></div>
+
+	<div class="timestamp">{format_time(playing ? currentTime : duration)}</div>
+</div>
+
+<style>
+	.minimal-audio-player {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-sm);
+		border-radius: var(--radius-sm);
+		width: var(--size-52);
+		padding: var(--spacing-sm);
+	}
+
+	.play-btn {
+		display: inline-flex;
+		align-items: center;
+		justify-content: center;
+		padding: 0;
+		border: none;
+		background: none;
+		color: var(--body-text-color);
+		opacity: 0.7;
+		cursor: pointer;
+		border-radius: 50%;
+		transition: all 0.2s ease;
+		flex-shrink: 0;
+	}
+
+	.play-btn:hover {
+		color: var(--color-accent);
+		opacity: 1;
+	}
+
+	.play-btn:active {
+		transform: scale(0.95);
+	}
+
+	.play-btn svg {
+		width: var(--size-5);
+		height: var(--size-5);
+		display: block;
+	}
+
+	.waveform-wrapper {
+		flex: 1 1 auto;
+		cursor: pointer;
+		width: auto;
+	}
+
+	.waveform-wrapper :global(::part(wrapper)) {
+		margin-bottom: 0;
+	}
+
+	.timestamp {
+		font-size: 13px;
+		font-weight: 500;
+		color: var(--body-text-color);
+		opacity: 0.7;
+		font-variant-numeric: tabular-nums;
+		flex-shrink: 0;
+		min-width: 40px;
+		text-align: center;
+	}
+
+	@media (prefers-reduced-motion: reduce) {
+		.play-btn {
+			transition: none;
+		}
+	}
+</style>

6.0.0/audio/shared/MinimalAudioRecorder.svelte

@@ -0,0 +1,357 @@
+<script lang="ts">
+	import { onMount, onDestroy, createEventDispatcher, tick } from "svelte";
+	import WaveSurfer from "wavesurfer.js";
+	import RecordPlugin from "wavesurfer.js/dist/plugins/record.js";
+	import { format_time } from "@gradio/utils";
+	import { process_audio } from "./utils";
+	import { prepare_files, type FileData, type Client } from "@gradio/client";
+	import { Square } from "@gradio/icons";
+
+	export let label: string;
+	export let waveform_settings: Record<string, any> = {};
+	export let recording = false;
+	export let upload: Client["upload"];
+	export let root: string;
+	export let max_file_size: number | null = null;
+	export let upload_promise: Promise<any> | null = null;
+
+	const dispatch = createEventDispatcher<{
+		change: FileData;
+		stop_recording: undefined;
+		clear: undefined;
+	}>();
+
+	let container: HTMLDivElement;
+	let waveform: WaveSurfer | undefined;
+	let record: RecordPlugin | undefined;
+	let seconds = 0;
+	let interval: NodeJS.Timeout;
+	let is_recording = false;
+	let has_started = false;
+	let mic_devices: MediaDeviceInfo[] = [];
+	let selected_device_id: string = "";
+	let show_device_selection = false;
+
+	const start_interval = (): void => {
+		clearInterval(interval);
+		interval = setInterval(() => {
+			seconds++;
+		}, 1000);
+	};
+
+	const create_waveform = async (): Promise<void> => {
+		if (!container) return;
+
+		if (waveform) {
+			waveform.destroy();
+		}
+
+		const accentColor =
+			getComputedStyle(document.documentElement).getPropertyValue(
+				"--color-accent"
+			) || "#ff7c00";
+
+		waveform = WaveSurfer.create({
+			container,
+			height: 32,
+			waveColor: "rgba(128, 128, 128, 0.5)",
+			progressColor: accentColor,
+			cursorColor: "transparent",
+			barWidth: 2,
+			barGap: 2,
+			barRadius: 2,
+			interact: false,
+			hideScrollbar: true,
+			...waveform_settings
+		});
+
+		record = waveform.registerPlugin(
+			RecordPlugin.create({
+				scrollingWaveform: true,
+				scrollingWaveformWindow: 7,
+				renderRecordedAudio: false
+			})
+		);
+
+		record.on("record-start", () => {
+			start_interval();
+			is_recording = true;
+			has_started = true;
+		});
+
+		record.on("record-end", async (blob: Blob) => {
+			clearInterval(interval);
+			is_recording = false;
+
+			upload_promise = (async () => {
+				try {
+					const array_buffer = await blob.arrayBuffer();
+					const context = new AudioContext({
+						sampleRate: waveform_settings.sampleRate || 44100
+					});
+					const audio_buffer = await context.decodeAudioData(array_buffer);
+
+					if (audio_buffer) {
+						const audio = await process_audio(audio_buffer);
+						const audio_blob = new File([audio], "audio.wav", {
+							type: "audio/wav"
+						});
+
+						const prepared_files = await prepare_files([audio_blob], false);
+						const uploaded_files = await upload(
+							prepared_files,
+							root,
+							undefined,
+							max_file_size || undefined
+						);
+						const file_data = uploaded_files?.[0];
+
+						if (file_data) {
+							dispatch("change", file_data);
+						}
+					}
+				} catch (e) {
+					console.error("Error processing audio:", e);
+				} finally {
+					dispatch("stop_recording");
+					upload_promise = null;
+				}
+			})();
+
+			await upload_promise;
+		});
+	};
+
+	onMount(async () => {
+		try {
+			const devices = await RecordPlugin.getAvailableAudioDevices();
+			mic_devices = devices.filter((device) => device.deviceId);
+			if (mic_devices.length > 0) {
+				selected_device_id = mic_devices[0].deviceId;
+			}
+
+			if (mic_devices.length > 1) {
+				show_device_selection = true;
+			} else {
+				await create_waveform();
+			}
+		} catch (err) {
+			await create_waveform();
+		}
+	});
+
+	onDestroy(() => {
+		clearInterval(interval);
+		if (record) {
+			record.stopMic();
+		}
+		if (waveform) {
+			waveform.destroy();
+		}
+	});
+
+	$: if (
+		recording &&
+		!is_recording &&
+		record &&
+		has_started === false &&
+		mic_devices.length <= 1
+	) {
+		record.startMic({ deviceId: selected_device_id }).then(() => {
+			record?.startRecording();
+		});
+	} else if (!recording && is_recording && record) {
+		record.stopRecording();
+		seconds = 0;
+	}
+
+	async function startRecording(): Promise<void> {
+		show_device_selection = false;
+		has_started = true;
+
+		await tick();
+		await create_waveform();
+
+		if (!record) return;
+
+		try {
+			await record.startMic({ deviceId: selected_device_id });
+			record.startRecording();
+		} catch (err) {
+			console.error("Error starting recording:", err);
+			show_device_selection = mic_devices.length > 1;
+			has_started = false;
+			recording = false;
+		}
+	}
+</script>
+
+<div
+	class="minimal-audio-recorder"
+	aria-label={label || "Audio Recorder"}
+	data-testid="minimal-audio-recorder"
+>
+	{#if show_device_selection}
+		<div class="device-selection-wrapper">
+			{#if mic_devices.length > 1}
+				<select
+					bind:value={selected_device_id}
+					class="device-select-large"
+					aria-label="Select input device"
+				>
+					{#each mic_devices as device}
+						<option value={device.deviceId}>{device.label}</option>
+					{/each}
+				</select>
+			{/if}
+			<button
+				class="record-button"
+				on:click={startRecording}
+				aria-label="Start recording"
+			>
+			</button>
+		</div>
+	{:else}
+		<div class="waveform-wrapper" bind:this={container}></div>
+		<div class="timestamp">{format_time(seconds)}</div>
+		<button
+			class="stop-button"
+			on:click={() => {
+				recording = false;
+			}}
+			aria-label="Stop recording"
+		>
+			<Square />
+		</button>
+	{/if}
+</div>
+
+<style>
+	.minimal-audio-recorder {
+		display: flex;
+		align-items: center;
+		gap: var(--spacing-sm);
+		border-radius: var(--radius-sm);
+		width: 100%;
+		padding: var(--spacing-sm);
+	}
+
+	.device-selection-wrapper {
+		display: flex;
+		flex-direction: row;
+		align-items: center;
+		justify-content: center;
+		gap: var(--spacing-md);
+		width: 100%;
+	}
+
+	.waveform-wrapper {
+		flex: 1 1 auto;
+		min-width: 0;
+		width: 100%;
+	}
+
+	.waveform-wrapper :global(::part(wrapper)) {
+		margin-bottom: 0;
+	}
+
+	.timestamp {
+		font-size: 13px;
+		font-weight: 500;
+		color: var(--body-text-color);
+		opacity: 0.7;
+		font-variant-numeric: tabular-nums;
+		flex-shrink: 0;
+		min-width: 40px;
+		text-align: center;
+	}
+
+	.device-select-large {
+		max-width: var(--size-60);
+		font-size: var(--text-sm);
+		padding: var(--spacing-sm) var(--spacing-md);
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--radius-md);
+		background: var(--background-fill-secondary);
+		color: var(--body-text-color);
+		cursor: pointer;
+		height: var(--size-9);
+	}
+
+	.record-button {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		height: var(--size-9);
+		width: var(--size-9);
+		padding: 0;
+		flex-shrink: 0;
+		background-color: var(--block-background-fill);
+		color: var(--body-text-color);
+		border: 1px solid var(--border-color-primary);
+		border-radius: var(--radius-md);
+		cursor: pointer;
+	}
+
+	.record-button::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		flex-shrink: 0;
+	}
+
+	.record-button:hover {
+		background-color: var(--block-background-fill);
+		border-color: var(--border-color-accent);
+	}
+
+	.record-button:active {
+		transform: scale(0.98);
+	}
+
+	.stop-button {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: var(--size-9);
+		height: var(--size-9);
+		padding: 0;
+		border: var(--size-px) solid var(--border-color-primary);
+		border-radius: var(--radius-md);
+		background: var(--button-secondary-background-fill);
+		color: var(--error-500);
+		cursor: pointer;
+		flex-shrink: 0;
+	}
+
+	.stop-button:hover {
+		background: var(--button-secondary-background-fill-hover);
+		color: var(--error-600);
+	}
+
+	.stop-button:active {
+		transform: scale(0.95);
+	}
+
+	.stop-button :global(svg) {
+		width: var(--size-5);
+		height: var(--size-5);
+	}
+
+	@media (prefers-reduced-motion: reduce) {
+		.record-btn {
+			transition: none;
+		}
+		.record-btn.recording {
+			animation: none;
+		}
+	}
+
+	@media (max-width: 768px) {
+		.device-select-large {
+			max-width: var(--size-40);
+		}
+	}
+</style>

6.0.0/audio/shared/VolumeControl.svelte

@@ -0,0 +1,77 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import WaveSurfer from "wavesurfer.js";
+
+	export let currentVolume = 1;
+	export let show_volume_slider = false;
+	export let waveform: WaveSurfer | undefined;
+
+	let volumeElement: HTMLInputElement;
+
+	onMount(() => {
+		adjustSlider();
+	});
+
+	const adjustSlider = (): void => {
+		let slider = volumeElement;
+		if (!slider) return;
+
+		slider.style.background = `linear-gradient(to right, var(--color-accent) ${
+			currentVolume * 100
+		}%, var(--neutral-400) ${currentVolume * 100}%)`;
+	};
+
+	$: (currentVolume, adjustSlider());
+</script>
+
+<input
+	bind:this={volumeElement}
+	id="volume"
+	class="volume-slider"
+	type="range"
+	min="0"
+	max="1"
+	step="0.01"
+	value={currentVolume}
+	on:focusout={() => (show_volume_slider = false)}
+	on:input={(e) => {
+		if (e.target instanceof HTMLInputElement) {
+			currentVolume = parseFloat(e.target.value);
+			waveform?.setVolume(currentVolume);
+		}
+	}}
+/>
+
+<style>
+	.volume-slider {
+		-webkit-appearance: none;
+		appearance: none;
+		width: var(--size-20);
+		accent-color: var(--color-accent);
+		height: 4px;
+		cursor: pointer;
+		outline: none;
+		border-radius: 15px;
+		background-color: var(--neutral-400);
+	}
+
+	input[type="range"]::-webkit-slider-thumb {
+		-webkit-appearance: none;
+		appearance: none;
+		height: 15px;
+		width: 15px;
+		background-color: var(--color-accent);
+		border-radius: 50%;
+		border: none;
+		transition: 0.2s ease-in-out;
+	}
+
+	input[type="range"]::-moz-range-thumb {
+		height: 15px;
+		width: 15px;
+		background-color: var(--color-accent);
+		border-radius: 50%;
+		border: none;
+		transition: 0.2s ease-in-out;
+	}
+</style>

6.0.0/audio/shared/VolumeLevels.svelte

@@ -0,0 +1,12 @@
+<script lang="ts">
+	import { VolumeMuted, VolumeHigh, VolumeLow } from "@gradio/icons";
+	export let currentVolume: number;
+</script>
+
+{#if currentVolume == 0}
+	<VolumeMuted />
+{:else if currentVolume < 0.5}
+	<VolumeLow />
+{:else if currentVolume >= 0.5}
+	<VolumeHigh />
+{/if}

6.0.0/audio/shared/WaveformControls.svelte

@@ -0,0 +1,434 @@
+<script lang="ts">
+	import {
+		Play,
+		Pause,
+		Forward,
+		Backward,
+		ClosedCaption,
+		Undo,
+		Trim
+	} from "@gradio/icons";
+	import { get_skip_rewind_amount } from "../shared/utils";
+	import type { I18nFormatter } from "@gradio/utils";
+	import WaveSurfer from "wavesurfer.js";
+	import RegionsPlugin, {
+		type Region
+	} from "wavesurfer.js/dist/plugins/regions.js";
+	import type { WaveformOptions } from "./types";
+	import VolumeLevels from "./VolumeLevels.svelte";
+	import VolumeControl from "./VolumeControl.svelte";
+
+	export let waveform: WaveSurfer | undefined;
+	export let audio_duration: number;
+	export let i18n: I18nFormatter;
+	export let playing: boolean;
+	export let show_redo = false;
+	export let interactive = false;
+	export let handle_trim_audio: (start: number, end: number) => void;
+	export let mode = "";
+	export let container: HTMLDivElement;
+	export let handle_reset_value: () => void;
+	export let waveform_options: WaveformOptions = {};
+	export let trim_region_settings: WaveformOptions = {};
+	export let show_volume_slider = false;
+	export let editable = true;
+	export let subtitles_toggle = true;
+	export let show_subtitles = false;
+	export let trimDuration = 0;
+
+	let playbackSpeeds = [0.5, 1, 1.5, 2];
+	let playbackSpeed = playbackSpeeds[1];
+
+	let trimRegion: RegionsPlugin | null = null;
+	let activeRegion: Region | null = null;
+
+	let leftRegionHandle: HTMLDivElement | null;
+	let rightRegionHandle: HTMLDivElement | null;
+	let activeHandle = "";
+
+	let currentVolume = 1;
+
+	$: trimRegion =
+		container && waveform
+			? waveform.registerPlugin(RegionsPlugin.create())
+			: null;
+
+	$: trimRegion?.on("region-out", (region) => {
+		region.play();
+	});
+
+	$: trimRegion?.on("region-updated", (region) => {
+		trimDuration = region.end - region.start;
+	});
+
+	$: trimRegion?.on("region-clicked", (region, e) => {
+		e.stopPropagation(); // prevent triggering a click on the waveform
+		activeRegion = region;
+		region.play();
+	});
+
+	const addTrimRegion = (): void => {
+		if (!trimRegion) return;
+		activeRegion = trimRegion?.addRegion({
+			start: audio_duration / 4,
+			end: audio_duration / 2,
+			...trim_region_settings
+		});
+
+		trimDuration = activeRegion.end - activeRegion.start;
+	};
+
+	$: if (activeRegion) {
+		const shadowRoot = container.children[0]!.shadowRoot!;
+
+		rightRegionHandle = shadowRoot.querySelector('[data-resize="right"]');
+		leftRegionHandle = shadowRoot.querySelector('[data-resize="left"]');
+
+		if (leftRegionHandle && rightRegionHandle) {
+			leftRegionHandle.setAttribute("role", "button");
+			rightRegionHandle.setAttribute("role", "button");
+			leftRegionHandle?.setAttribute("aria-label", "Drag to adjust start time");
+			rightRegionHandle?.setAttribute("aria-label", "Drag to adjust end time");
+			leftRegionHandle?.setAttribute("tabindex", "0");
+			rightRegionHandle?.setAttribute("tabindex", "0");
+
+			leftRegionHandle.addEventListener("focus", () => {
+				if (trimRegion) activeHandle = "left";
+			});
+
+			rightRegionHandle.addEventListener("focus", () => {
+				if (trimRegion) activeHandle = "right";
+			});
+		}
+	}
+
+	const trimAudio = (): void => {
+		if (waveform && trimRegion) {
+			if (activeRegion) {
+				const start = activeRegion.start;
+				const end = activeRegion.end;
+				handle_trim_audio(start, end);
+				mode = "";
+				activeRegion = null;
+			}
+		}
+	};
+
+	const clearRegions = (): void => {
+		trimRegion?.getRegions().forEach((region) => {
+			region.remove();
+		});
+		trimRegion?.clearRegions();
+	};
+
+	const toggleTrimmingMode = (): void => {
+		clearRegions();
+		if (mode === "edit") {
+			mode = "";
+		} else {
+			mode = "edit";
+			addTrimRegion();
+		}
+	};
+
+	const toggleSubtitles = (): void => {
+		subtitles_toggle = !subtitles_toggle;
+	};
+
+	const adjustRegionHandles = (handle: string, key: string): void => {
+		let newStart;
+		let newEnd;
+
+		if (!activeRegion) return;
+		if (handle === "left") {
+			if (key === "ArrowLeft") {
+				newStart = activeRegion.start - 0.05;
+				newEnd = activeRegion.end;
+			} else {
+				newStart = activeRegion.start + 0.05;
+				newEnd = activeRegion.end;
+			}
+		} else {
+			if (key === "ArrowLeft") {
+				newStart = activeRegion.start;
+				newEnd = activeRegion.end - 0.05;
+			} else {
+				newStart = activeRegion.start;
+				newEnd = activeRegion.end + 0.05;
+			}
+		}
+
+		activeRegion.setOptions({
+			start: newStart,
+			end: newEnd
+		});
+
+		trimDuration = activeRegion.end - activeRegion.start;
+	};
+
+	$: trimRegion &&
+		window.addEventListener("keydown", (e) => {
+			if (e.key === "ArrowLeft") {
+				adjustRegionHandles(activeHandle, "ArrowLeft");
+			} else if (e.key === "ArrowRight") {
+				adjustRegionHandles(activeHandle, "ArrowRight");
+			}
+		});
+</script>
+
+<div class="controls" data-testid="waveform-controls">
+	<div class="control-wrapper">
+		<button
+			class="action icon volume"
+			style:color={show_volume_slider
+				? "var(--color-accent)"
+				: "var(--neutral-400)"}
+			aria-label="Adjust volume"
+			on:click={() => (show_volume_slider = !show_volume_slider)}
+		>
+			<VolumeLevels {currentVolume} />
+		</button>
+
+		{#if show_volume_slider}
+			<VolumeControl bind:currentVolume bind:show_volume_slider {waveform} />
+		{/if}
+
+		<button
+			class:hidden={show_volume_slider}
+			class="playback icon"
+			aria-label={`Adjust playback speed to ${
+				playbackSpeeds[
+					(playbackSpeeds.indexOf(playbackSpeed) + 1) % playbackSpeeds.length
+				]
+			}x`}
+			on:click={() => {
+				playbackSpeed =
+					playbackSpeeds[
+						(playbackSpeeds.indexOf(playbackSpeed) + 1) % playbackSpeeds.length
+					];
+
+				waveform?.setPlaybackRate(playbackSpeed);
+			}}
+		>
+			<span>{playbackSpeed}x</span>
+		</button>
+	</div>
+
+	<div class="play-pause-wrapper">
+		<button
+			class="rewind icon"
+			aria-label={`Skip backwards by ${get_skip_rewind_amount(
+				audio_duration,
+				waveform_options.skip_length
+			)} seconds`}
+			on:click={() =>
+				waveform?.skip(
+					get_skip_rewind_amount(audio_duration, waveform_options.skip_length) *
+						-1
+				)}
+		>
+			<Backward />
+		</button>
+		<button
+			class="play-pause-button icon"
+			on:click={() => waveform?.playPause()}
+			aria-label={playing ? i18n("audio.pause") : i18n("audio.play")}
+		>
+			{#if playing}
+				<Pause />
+			{:else}
+				<Play />
+			{/if}
+		</button>
+		<button
+			class="skip icon"
+			aria-label="Skip forward by {get_skip_rewind_amount(
+				audio_duration,
+				waveform_options.skip_length
+			)} seconds"
+			on:click={() =>
+				waveform?.skip(
+					get_skip_rewind_amount(audio_duration, waveform_options.skip_length)
+				)}
+		>
+			<Forward />
+		</button>
+	</div>
+
+	<div class="settings-wrapper">
+		{#if show_subtitles}
+			<button
+				class="action icon cc-button"
+				data-testid="subtitles-toggle"
+				style="color: {subtitles_toggle
+					? 'var(--color-accent)'
+					: 'var(--neutral-400)'}"
+				on:click={toggleSubtitles}
+			>
+				<ClosedCaption /></button
+			>
+		{/if}
+		{#if editable && interactive}
+			{#if show_redo && mode === ""}
+				<button
+					class="action icon"
+					aria-label="Reset audio"
+					on:click={() => {
+						handle_reset_value();
+						clearRegions();
+						mode = "";
+					}}
+				>
+					<Undo />
+				</button>
+			{/if}
+
+			{#if mode === ""}
+				<button
+					class="action icon"
+					aria-label="Trim audio to selection"
+					on:click={toggleTrimmingMode}
+				>
+					<Trim />
+				</button>
+			{:else}
+				<button class="text-button" on:click={trimAudio}>Trim</button>
+				<button class="text-button" on:click={toggleTrimmingMode}>Cancel</button
+				>
+			{/if}
+		{/if}
+	</div>
+</div>
+
+<style>
+	.settings-wrapper {
+		display: flex;
+		justify-self: self-end;
+		align-items: center;
+		grid-area: editing;
+	}
+	.text-button {
+		border: 1px solid var(--neutral-400);
+		border-radius: var(--radius-sm);
+		font-weight: 300;
+		font-size: var(--size-3);
+		text-align: center;
+		color: var(--neutral-400);
+		height: var(--size-5);
+		font-weight: bold;
+		padding: 0 5px;
+		margin-left: 5px;
+	}
+
+	.text-button:hover,
+	.text-button:focus {
+		color: var(--color-accent);
+		border-color: var(--color-accent);
+	}
+
+	.controls {
+		display: grid;
+		grid-template-columns: 1fr 1fr 1fr;
+		grid-template-areas: "controls playback editing";
+		margin-top: 5px;
+		align-items: center;
+		position: relative;
+		flex-wrap: wrap;
+		justify-content: space-between;
+	}
+	.controls div {
+		margin: var(--size-1) 0;
+	}
+
+	@media (max-width: 600px) {
+		.controls {
+			grid-template-columns: 1fr 1fr;
+			grid-template-rows: auto auto;
+			grid-template-areas:
+				"playback playback"
+				"controls editing";
+		}
+	}
+
+	@media (max-width: 319px) {
+		.controls {
+			overflow-x: scroll;
+		}
+	}
+
+	.hidden {
+		display: none;
+	}
+
+	.control-wrapper {
+		display: flex;
+		justify-self: self-start;
+		align-items: center;
+		justify-content: space-between;
+		grid-area: controls;
+	}
+
+	.action {
+		width: var(--size-5);
+		color: var(--neutral-400);
+		margin-left: var(--spacing-md);
+	}
+	.icon:hover,
+	.icon:focus {
+		color: var(--color-accent);
+	}
+	.play-pause-wrapper {
+		display: flex;
+		justify-self: center;
+		grid-area: playback;
+	}
+	.cc-button {
+		width: var(--size-8);
+	}
+
+	@media (max-width: 600px) {
+		.play-pause-wrapper {
+			margin: var(--spacing-md);
+		}
+	}
+	.playback {
+		border: 1px solid var(--neutral-400);
+		border-radius: var(--radius-sm);
+		width: 5.5ch;
+		font-weight: 300;
+		font-size: var(--size-3);
+		text-align: center;
+		color: var(--neutral-400);
+		height: var(--size-5);
+		font-weight: bold;
+	}
+
+	.playback:hover,
+	.playback:focus {
+		color: var(--color-accent);
+		border-color: var(--color-accent);
+	}
+
+	.rewind,
+	.skip {
+		margin: 0 10px;
+		color: var(--neutral-400);
+	}
+
+	.play-pause-button {
+		width: var(--size-8);
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		color: var(--neutral-400);
+		fill: var(--neutral-400);
+	}
+
+	.volume {
+		position: relative;
+		display: flex;
+		justify-content: center;
+		margin-right: var(--spacing-xl);
+		width: var(--size-5);
+	}
+</style>

6.0.0/audio/shared/WaveformRecordControls.svelte

@@ -0,0 +1,301 @@
+<script lang="ts">
+	import { onMount, onDestroy } from "svelte";
+	import { Pause } from "@gradio/icons";
+	import type { I18nFormatter } from "@gradio/utils";
+	import RecordPlugin from "wavesurfer.js/dist/plugins/record.js";
+	import DeviceSelect from "./DeviceSelect.svelte";
+
+	export let record: RecordPlugin;
+	export let i18n: I18nFormatter;
+	export let recording = false;
+
+	let micDevices: MediaDeviceInfo[] = [];
+	let recordButton: HTMLButtonElement;
+	let pauseButton: HTMLButtonElement;
+	let resumeButton: HTMLButtonElement;
+	let stopButton: HTMLButtonElement;
+	let stopButtonPaused: HTMLButtonElement;
+	let recording_ongoing = false;
+
+	export let record_time: string;
+	export let show_recording_waveform: boolean | undefined;
+	export let timing = false;
+
+	const handleRecordStart = (): void => {
+		recordButton.style.display = "none";
+		stopButton.style.display = "flex";
+		pauseButton.style.display = "block";
+	};
+
+	const handleRecordEnd = (): void => {
+		if (record.isPaused()) {
+			record.resumeRecording();
+			record.stopRecording();
+		}
+		record.stopMic();
+
+		recordButton.style.display = "flex";
+		stopButton.style.display = "none";
+		pauseButton.style.display = "none";
+		recordButton.disabled = false;
+	};
+
+	const handleRecordPause = (): void => {
+		pauseButton.style.display = "none";
+		resumeButton.style.display = "block";
+		stopButton.style.display = "none";
+		stopButtonPaused.style.display = "flex";
+	};
+
+	const handleRecordResume = (): void => {
+		pauseButton.style.display = "block";
+		resumeButton.style.display = "none";
+		recordButton.style.display = "none";
+		stopButton.style.display = "flex";
+		stopButtonPaused.style.display = "none";
+	};
+
+	onMount(() => {
+		record.on("record-start", handleRecordStart);
+		record.on("record-end", handleRecordEnd);
+		record.on("record-pause", handleRecordPause);
+		record.on("record-resume", handleRecordResume);
+	});
+
+	onDestroy(() => {
+		record.un("record-start", handleRecordStart);
+		record.un("record-end", handleRecordEnd);
+		record.un("record-pause", handleRecordPause);
+		record.un("record-resume", handleRecordResume);
+	});
+
+	$: if (recording && !recording_ongoing) {
+		record.startMic().then(() => {
+			record.startRecording();
+			recording_ongoing = true;
+		});
+	} else if (!recording && recording_ongoing) {
+		if (record.isPaused()) {
+			record.resumeRecording();
+		}
+		record.stopRecording();
+		recording_ongoing = false;
+	}
+</script>
+
+<div class="controls">
+	<div class="wrapper">
+		<button
+			bind:this={recordButton}
+			class="record record-button"
+			on:click={() => record.startRecording()}>{i18n("audio.record")}</button
+		>
+
+		<button
+			bind:this={stopButton}
+			class="stop-button {record.isPaused() ? 'stop-button-paused' : ''}"
+			on:click={() => {
+				if (record.isPaused()) {
+					record.resumeRecording();
+					record.stopRecording();
+				}
+
+				record.stopRecording();
+			}}>{i18n("audio.stop")}</button
+		>
+
+		<button
+			bind:this={stopButtonPaused}
+			id="stop-paused"
+			class="stop-button-paused"
+			on:click={() => {
+				if (record.isPaused()) {
+					record.resumeRecording();
+					record.stopRecording();
+				}
+
+				record.stopRecording();
+			}}>{i18n("audio.stop")}</button
+		>
+
+		<button
+			aria-label="pause"
+			bind:this={pauseButton}
+			class="pause-button"
+			on:click={() => record.pauseRecording()}><Pause /></button
+		>
+		<button
+			bind:this={resumeButton}
+			class="resume-button"
+			on:click={() => record.resumeRecording()}>{i18n("audio.resume")}</button
+		>
+		{#if timing && !show_recording_waveform}
+			<time class="duration-button duration">{record_time}</time>
+		{/if}
+	</div>
+	<DeviceSelect bind:micDevices {i18n} />
+</div>
+
+<style>
+	.controls {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		flex-wrap: wrap;
+	}
+
+	.wrapper {
+		display: flex;
+		align-items: center;
+		flex-wrap: wrap;
+	}
+
+	.record {
+		margin-right: var(--spacing-md);
+	}
+
+	.stop-button-paused {
+		display: none;
+		height: var(--size-8);
+		width: var(--size-20);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		align-items: center;
+		border: 1px solid var(--block-border-color);
+		margin: var(--size-1) var(--size-1) 0 0;
+	}
+
+	.stop-button-paused::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+	}
+	.stop-button::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+		animation: scaling 1800ms infinite;
+	}
+
+	.stop-button {
+		display: none;
+		height: var(--size-8);
+		width: var(--size-20);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		align-items: center;
+		border: 1px solid var(--primary-600);
+		margin: var(--size-1) var(--size-1) 0 0;
+	}
+
+	.record-button::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+	}
+
+	.record-button {
+		height: var(--size-8);
+		width: var(--size-24);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		display: flex;
+		align-items: center;
+		border: 1px solid var(--block-border-color);
+	}
+
+	.duration-button {
+		border-radius: var(--button-large-radius);
+	}
+
+	.stop-button:disabled {
+		cursor: not-allowed;
+	}
+
+	.record-button:disabled {
+		cursor: not-allowed;
+		opacity: 0.5;
+	}
+
+	@keyframes scaling {
+		0% {
+			background-color: var(--primary-600);
+			scale: 1;
+		}
+		50% {
+			background-color: var(--primary-600);
+			scale: 1.2;
+		}
+		100% {
+			background-color: var(--primary-600);
+			scale: 1;
+		}
+	}
+
+	.pause-button {
+		display: none;
+		height: var(--size-8);
+		width: var(--size-20);
+		border: 1px solid var(--block-border-color);
+		border-radius: var(--button-large-radius);
+		padding: var(--spacing-md);
+		margin: var(--size-1) var(--size-1) 0 0;
+	}
+
+	.resume-button {
+		display: none;
+		height: var(--size-8);
+		width: var(--size-20);
+		border: 1px solid var(--block-border-color);
+		border-radius: var(--button-large-radius);
+		padding: var(--spacing-xl);
+		line-height: 1px;
+		font-size: var(--text-md);
+		margin: var(--size-1) var(--size-1) 0 0;
+	}
+
+	.duration {
+		display: flex;
+		height: var(--size-8);
+		width: var(--size-20);
+		border: 1px solid var(--block-border-color);
+		padding: var(--spacing-md);
+		align-items: center;
+		justify-content: center;
+		margin: var(--size-1) var(--size-1) 0 0;
+	}
+
+	:global(::part(region)) {
+		border-radius: var(--radius-md);
+		height: 98% !important;
+		border: 1px solid var(--trim-region-color);
+		background-color: unset;
+		border-width: 1px 3px;
+	}
+
+	:global(::part(region))::after {
+		content: "";
+		position: absolute;
+		top: 0;
+		left: 0;
+		width: 100%;
+		height: 100%;
+		background: var(--trim-region-color);
+		opacity: 0.2;
+		border-radius: var(--radius-md);
+	}
+
+	:global(::part(region-handle)) {
+		width: 5px !important;
+		border: none;
+	}
+</style>

6.0.0/audio/shared/audioBufferToWav.ts

@@ -0,0 +1,59 @@
+export function audioBufferToWav(audioBuffer: AudioBuffer): Uint8Array {
+	const numOfChan = audioBuffer.numberOfChannels;
+	const length = audioBuffer.length * numOfChan * 2 + 44;
+	const buffer = new ArrayBuffer(length);
+	const view = new DataView(buffer);
+	let offset = 0;
+
+	// Write WAV header
+	const writeString = function (
+		view: DataView,
+		offset: number,
+		string: string
+	): void {
+		for (let i = 0; i < string.length; i++) {
+			view.setUint8(offset + i, string.charCodeAt(i));
+		}
+	};
+
+	writeString(view, offset, "RIFF");
+	offset += 4;
+	view.setUint32(offset, length - 8, true);
+	offset += 4;
+	writeString(view, offset, "WAVE");
+	offset += 4;
+	writeString(view, offset, "fmt ");
+	offset += 4;
+	view.setUint32(offset, 16, true);
+	offset += 4; // Sub-chunk size, 16 for PCM
+	view.setUint16(offset, 1, true);
+	offset += 2; // PCM format
+	view.setUint16(offset, numOfChan, true);
+	offset += 2;
+	view.setUint32(offset, audioBuffer.sampleRate, true);
+	offset += 4;
+	view.setUint32(offset, audioBuffer.sampleRate * 2 * numOfChan, true);
+	offset += 4;
+	view.setUint16(offset, numOfChan * 2, true);
+	offset += 2;
+	view.setUint16(offset, 16, true);
+	offset += 2;
+	writeString(view, offset, "data");
+	offset += 4;
+	view.setUint32(offset, audioBuffer.length * numOfChan * 2, true);
+	offset += 4;
+
+	// Write PCM audio data
+	for (let i = 0; i < audioBuffer.length; i++) {
+		for (let channel = 0; channel < numOfChan; channel++) {
+			const sample = Math.max(
+				-1,
+				Math.min(1, audioBuffer.getChannelData(channel)[i])
+			);
+			view.setInt16(offset, sample * 0x7fff, true);
+			offset += 2;
+		}
+	}
+
+	return new Uint8Array(buffer);
+}

6.0.0/audio/shared/index.ts

@@ -0,0 +1,3 @@
+export { default as Audio } from "./Audio.svelte";
+export { default as MinimalAudioPlayer } from "./MinimalAudioPlayer.svelte";
+export { default as MinimalAudioRecorder } from "./MinimalAudioRecorder.svelte";

6.0.0/audio/shared/types.ts

@@ -0,0 +1,58 @@
+import { FileData } from "@gradio/client";
+
+export type WaveformOptions = {
+	waveform_color?: string;
+	waveform_progress_color?: string;
+	show_controls?: boolean;
+	skip_length?: number;
+	trim_region_color?: string;
+	show_recording_waveform?: boolean;
+	sample_rate?: number;
+};
+
+export interface SubtitleData {
+	start: number;
+	end: number;
+	text: string;
+}
+
+export interface AudioProps {
+	sources:
+		| ["microphone"]
+		| ["upload"]
+		| ["microphone", "upload"]
+		| ["upload", "microphone"];
+	value: FileData | null;
+	type: "numpy" | "filepath";
+	autoplay: boolean;
+	buttons: ("play" | "download")[];
+	recording: boolean;
+	loop: boolean;
+	subtitles: FileData | SubtitleData[] | null;
+	waveform_options: WaveformOptions;
+	editable: boolean;
+	pending: boolean;
+	streaming: boolean;
+	stream_every: number;
+	input_ready: boolean;
+	minimal?: boolean;
+}
+
+export interface AudioEvents {
+	change: any;
+	upload: any;
+	stream: any;
+	clear: any;
+	play: any;
+	pause: any;
+	stop: any;
+	start_recording: any;
+	pause_recording: any;
+	stop_recording: any;
+	input: any;
+	error: any;
+	warning: any;
+	clear_status: any;
+	close_stream: any;
+	edit: any;
+}

6.0.0/audio/shared/utils.ts

@@ -0,0 +1,79 @@
+import type WaveSurfer from "wavesurfer.js";
+import { audioBufferToWav } from "./audioBufferToWav";
+
+export interface LoadedParams {
+	autoplay?: boolean;
+}
+
+export function blob_to_data_url(blob: Blob): Promise<string> {
+	return new Promise((fulfill, reject) => {
+		let reader = new FileReader();
+		reader.onerror = reject;
+		reader.onload = () => fulfill(reader.result as string);
+		reader.readAsDataURL(blob);
+	});
+}
+
+export const process_audio = async (
+	audioBuffer: AudioBuffer,
+	start?: number,
+	end?: number,
+	waveform_sample_rate?: number
+): Promise<Uint8Array> => {
+	const audioContext = new AudioContext({
+		sampleRate: waveform_sample_rate || audioBuffer.sampleRate
+	});
+	const numberOfChannels = audioBuffer.numberOfChannels;
+	const sampleRate = waveform_sample_rate || audioBuffer.sampleRate;
+
+	let trimmedLength = audioBuffer.length;
+	let startOffset = 0;
+
+	if (start && end) {
+		startOffset = Math.round(start * sampleRate);
+		const endOffset = Math.round(end * sampleRate);
+		trimmedLength = endOffset - startOffset;
+	}
+
+	const trimmedAudioBuffer = audioContext.createBuffer(
+		numberOfChannels,
+		trimmedLength,
+		sampleRate
+	);
+
+	for (let channel = 0; channel < numberOfChannels; channel++) {
+		const channelData = audioBuffer.getChannelData(channel);
+		const trimmedData = trimmedAudioBuffer.getChannelData(channel);
+		for (let i = 0; i < trimmedLength; i++) {
+			trimmedData[i] = channelData[startOffset + i];
+		}
+	}
+
+	return audioBufferToWav(trimmedAudioBuffer);
+};
+
+export function loaded(
+	node: HTMLAudioElement,
+	{ autoplay }: LoadedParams = {}
+): void {
+	async function handle_playback(): Promise<void> {
+		if (!autoplay) return;
+		node.pause();
+		await node.play();
+	}
+}
+
+export const skip_audio = (waveform: WaveSurfer, amount: number): void => {
+	if (!waveform) return;
+	waveform.skip(amount);
+};
+
+export const get_skip_rewind_amount = (
+	audio_duration: number,
+	skip_length?: number | null
+): number => {
+	if (!skip_length) {
+		skip_length = 5;
+	}
+	return (audio_duration / 100) * skip_length || 5;
+};

6.0.0/audio/static/StaticAudio.svelte

@@ -0,0 +1,103 @@
+<script lang="ts">
+	import { uploadToHuggingFace } from "@gradio/utils";
+	import { Empty } from "@gradio/atoms";
+	import {
+		ShareButton,
+		IconButton,
+		BlockLabel,
+		DownloadLink,
+		IconButtonWrapper
+	} from "@gradio/atoms";
+	import { Download, Music } from "@gradio/icons";
+	import type { I18nFormatter } from "@gradio/utils";
+	import AudioPlayer from "../player/AudioPlayer.svelte";
+	import MinimalAudioPlayer from "../shared/MinimalAudioPlayer.svelte";
+	import { createEventDispatcher } from "svelte";
+	import type { FileData } from "@gradio/client";
+	import type { WaveformOptions, SubtitleData } from "../shared/types";
+
+	export let value: null | FileData = null;
+	export let subtitles: null | FileData | SubtitleData[] = null;
+	export let label: string;
+	export let show_label = true;
+	export let buttons: string[] | null = null;
+	export let i18n: I18nFormatter;
+	export let waveform_settings: Record<string, any> = {};
+	export let waveform_options: WaveformOptions = {
+		show_recording_waveform: true
+	};
+	export let editable = true;
+	export let loop: boolean;
+	export let display_icon_button_wrapper_top_corner = false;
+	export let minimal = false;
+
+	const dispatch = createEventDispatcher<{
+		change: FileData;
+		play: undefined;
+		pause: undefined;
+		end: undefined;
+		stop: undefined;
+	}>();
+
+	$: value && dispatch("change", value);
+</script>
+
+<BlockLabel
+	{show_label}
+	Icon={Music}
+	float={false}
+	label={label || i18n("audio.audio")}
+/>
+
+{#if value !== null}
+	{#if minimal}
+		<MinimalAudioPlayer {value} label={label || i18n("audio.audio")} {loop} />
+	{:else}
+		<IconButtonWrapper
+			display_top_corner={display_icon_button_wrapper_top_corner}
+		>
+			{#if buttons === null ? true : buttons.includes("download")}
+				<DownloadLink
+					href={value.is_stream
+						? value.url?.replace("playlist.m3u8", "playlist-file")
+						: value.url}
+					download={value.orig_name || value.path}
+				>
+					<IconButton Icon={Download} label={i18n("common.download")} />
+				</DownloadLink>
+			{/if}
+			{#if buttons === null ? true : buttons.includes("share")}
+				<ShareButton
+					{i18n}
+					on:error
+					on:share
+					formatter={async (value) => {
+						if (!value) return "";
+						let url = await uploadToHuggingFace(value.url, "url");
+						return `<audio controls src="${url}"></audio>`;
+					}}
+					{value}
+				/>
+			{/if}
+		</IconButtonWrapper>
+
+		<AudioPlayer
+			{value}
+			subtitles={Array.isArray(subtitles) ? subtitles : subtitles?.url}
+			{label}
+			{i18n}
+			{waveform_settings}
+			{waveform_options}
+			{editable}
+			{loop}
+			on:pause
+			on:play
+			on:stop
+			on:load
+		/>
+	{/if}
+{:else}
+	<Empty size="small">
+		<Music />
+	</Empty>
+{/if}

6.0.0/audio/streaming/StreamAudio.svelte

@@ -0,0 +1,205 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+	import type { I18nFormatter } from "@gradio/utils";
+	import { Spinner } from "@gradio/icons";
+	import WaveSurfer from "wavesurfer.js";
+	import RecordPlugin from "wavesurfer.js/dist/plugins/record.js";
+	import type { WaveformOptions } from "../shared/types";
+	import DeviceSelect from "../shared/DeviceSelect.svelte";
+
+	export let recording = false;
+	export let paused_recording = false;
+	export let stop: () => void;
+	export let record: () => void;
+	export let i18n: I18nFormatter;
+	export let waveform_settings: Record<string, any>;
+	export let waveform_options: WaveformOptions = {
+		show_recording_waveform: true
+	};
+	export let waiting = false;
+
+	let micWaveform: WaveSurfer;
+	let waveformRecord: RecordPlugin;
+
+	let microphoneContainer: HTMLDivElement;
+
+	let micDevices: MediaDeviceInfo[] = [];
+
+	onMount(() => {
+		create_mic_waveform();
+	});
+
+	const create_mic_waveform = (): void => {
+		if (micWaveform !== undefined) micWaveform.destroy();
+		if (!microphoneContainer) return;
+		micWaveform = WaveSurfer.create({
+			...waveform_settings,
+			normalize: false,
+			container: microphoneContainer
+		});
+
+		waveformRecord = micWaveform.registerPlugin(RecordPlugin.create());
+	};
+</script>
+
+<div class="mic-wrap">
+	{#if waveform_options.show_recording_waveform}
+		<div
+			bind:this={microphoneContainer}
+			style:display={recording ? "block" : "none"}
+		/>
+	{/if}
+	<div class="controls">
+		{#if recording && !waiting}
+			<button
+				class={paused_recording ? "stop-button-paused" : "stop-button"}
+				on:click={() => {
+					waveformRecord?.stopMic();
+					stop();
+				}}
+			>
+				<span class="record-icon">
+					<span class="pinger" />
+					<span class="dot" />
+				</span>
+				{paused_recording ? i18n("audio.pause") : i18n("audio.stop")}
+			</button>
+		{:else if recording && waiting}
+			<button
+				class="spinner-button"
+				on:click={() => {
+					stop();
+				}}
+			>
+				<div class="icon">
+					<Spinner />
+				</div>
+				{i18n("audio.waiting")}
+			</button>
+		{:else}
+			<button
+				class="record-button"
+				on:click={() => {
+					waveformRecord?.startMic();
+					record();
+				}}
+			>
+				<span class="record-icon">
+					<span class="dot" />
+				</span>
+				{i18n("audio.record")}
+			</button>
+		{/if}
+
+		<DeviceSelect bind:micDevices {i18n} />
+	</div>
+</div>
+
+<style>
+	.controls {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		flex-wrap: wrap;
+	}
+
+	.mic-wrap {
+		display: block;
+		align-items: center;
+		margin: var(--spacing-xl);
+	}
+
+	.icon {
+		width: var(--size-4);
+		height: var(--size-4);
+		fill: var(--primary-600);
+		stroke: var(--primary-600);
+	}
+
+	.stop-button-paused {
+		display: none;
+		height: var(--size-8);
+		width: var(--size-20);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		align-items: center;
+		border: 1px solid var(--block-border-color);
+		margin-right: 5px;
+	}
+
+	.stop-button-paused::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+	}
+
+	.stop-button::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+		animation: scaling 1800ms infinite;
+	}
+
+	.stop-button {
+		height: var(--size-8);
+		width: var(--size-20);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		align-items: center;
+		border: 1px solid var(--primary-600);
+		margin-right: 5px;
+		display: flex;
+	}
+
+	.spinner-button {
+		height: var(--size-8);
+		width: var(--size-24);
+		background-color: var(--block-background-fill);
+		border-radius: var(--radius-3xl);
+		align-items: center;
+		border: 1px solid var(--primary-600);
+		margin: 0 var(--spacing-xl);
+		display: flex;
+		justify-content: space-evenly;
+	}
+
+	.record-button::before {
+		content: "";
+		height: var(--size-4);
+		width: var(--size-4);
+		border-radius: var(--radius-full);
+		background: var(--primary-600);
+		margin: 0 var(--spacing-xl);
+	}
+
+	.record-button {
+		height: var(--size-8);
+		width: var(--size-24);
+		background-color: var(--block-background-fill);
+		border-radius: var(--button-large-radius);
+		display: flex;
+		align-items: center;
+		border: 1px solid var(--block-border-color);
+	}
+
+	@keyframes scaling {
+		0% {
+			background-color: var(--primary-600);
+			scale: 1;
+		}
+		50% {
+			background-color: var(--primary-600);
+			scale: 1.2;
+		}
+		100% {
+			background-color: var(--primary-600);
+			scale: 1;
+		}
+	}
+</style>

6.0.0/audio/streaming/media_recorder.ts

@@ -0,0 +1,14 @@
+import type { IMediaRecorderConstructor } from "extendable-media-recorder";
+
+let media_recorder_initialized = false;
+let media_recorder;
+
+export async function init_media_recorder(): Promise<IMediaRecorderConstructor> {
+	const { MediaRecorder, register } = await import("extendable-media-recorder");
+	const { connect } = await import("extendable-media-recorder-wav-encoder");
+
+	register(await connect());
+	media_recorder_initialized = true;
+	media_recorder = MediaRecorder;
+	return media_recorder;
+}