Upload folder using huggingface_hub

6.8.1/video/Example.svelte

@@ -0,0 +1,84 @@
+<script lang="ts">
+	import Video from "./shared/Video.svelte";
+	import { playable } from "./shared/utils";
+	import { type FileData } from "@gradio/client";
+
+	interface Props {
+		type: "gallery" | "table";
+		selected?: boolean;
+		value?: null | FileData;
+		loop: boolean;
+	}
+
+	let { type, selected = false, value = null, loop }: Props = $props();
+
+	let video: HTMLVideoElement | undefined = $state();
+
+	async function init(): Promise<void> {
+		if (!video) return;
+		video.muted = true;
+		video.playsInline = true;
+		video.controls = false;
+		video.setAttribute("muted", "");
+
+		await video.play();
+		video.pause();
+	}
+</script>
+
+{#if value}
+	{#if playable()}
+		<div
+			class="container"
+			class:table={type === "table"}
+			class:gallery={type === "gallery"}
+			class:selected
+		>
+			<Video
+				muted
+				playsinline
+				bind:node={video}
+				onloadeddata={init}
+				onmouseover={() => video?.play()}
+				onmouseout={() => video?.pause()}
+				src={value?.url}
+				is_stream={false}
+				{loop}
+			/>
+		</div>
+	{:else}
+		<div>{value}</div>
+	{/if}
+{/if}
+
+<style>
+	.container {
+		flex: none;
+		max-width: none;
+	}
+	.container :global(video) {
+		width: var(--size-full);
+		height: var(--size-full);
+		object-fit: cover;
+	}
+
+	.container:hover,
+	.container.selected {
+		border-color: var(--border-color-accent);
+	}
+	.container.table {
+		margin: 0 auto;
+		border: 2px solid var(--border-color-primary);
+		border-radius: var(--radius-lg);
+		overflow: hidden;
+		width: var(--size-20);
+		height: var(--size-20);
+		object-fit: cover;
+	}
+
+	.container.gallery {
+		height: var(--size-20);
+		max-height: var(--size-20);
+		object-fit: cover;
+	}
+</style>

6.8.1/video/Index.svelte

@@ -0,0 +1,189 @@
+<svelte:options accessors={true} />
+
+<script lang="ts">
+	import { tick } from "svelte";
+	import type { FileData } from "@gradio/client";
+	import { Block, UploadText } from "@gradio/atoms";
+	import StaticVideo from "./shared/VideoPreview.svelte";
+	import Video from "./shared/InteractiveVideo.svelte";
+	import { StatusTracker } from "@gradio/statustracker";
+	import { Gradio } from "@gradio/utils";
+	import type { VideoProps, VideoEvents } from "./types";
+
+	const props = $props();
+
+	let upload_promise = $state<Promise<any>>();
+
+	class VideoGradio extends Gradio<VideoEvents, VideoProps> {
+		async get_data() {
+			if (upload_promise) {
+				await upload_promise;
+				await tick();
+			}
+			const data = await super.get_data();
+
+			return data;
+		}
+	}
+
+	const gradio = new VideoGradio(props);
+	let old_value = $state(gradio.props.value);
+
+	let uploading = $state(false);
+	let dragging = $state(false);
+	let active_source = $derived.by(() =>
+		gradio.props.sources ? gradio.props.sources[0] : undefined
+	);
+	let initial_value: FileData | null = gradio.props.value;
+
+	$effect(() => {
+		if (old_value != gradio.props.value) {
+			old_value = gradio.props.value;
+			gradio.dispatch("change");
+		}
+	});
+
+	const handle_reset_value = (): void => {
+		if (initial_value === null || gradio.props.value === initial_value) {
+			return;
+		}
+		gradio.props.value = initial_value;
+	};
+
+	function handle_change(detail: FileData | null): void {
+		if (detail != null) {
+			gradio.props.value = detail as FileData;
+		} else {
+			gradio.props.value = null;
+		}
+	}
+
+	function handle_error(detail: string): void {
+		const [level, status] = detail.includes("Invalid file type")
+			? ["warning", "complete"]
+			: ["error", "error"];
+		gradio.shared.loading_status.status = status as any;
+		gradio.shared.loading_status.message = detail;
+		gradio.dispatch(level as "error" | "warning", detail);
+	}
+</script>
+
+{#if !gradio.shared.interactive}
+	<Block
+		visible={gradio.shared.visible}
+		variant={gradio.props.value === null && active_source === "upload"
+			? "dashed"
+			: "solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		height={gradio.props.height || undefined}
+		width={gradio.props.width}
+		container={gradio.shared.container}
+		scale={gradio.shared.scale}
+		min_width={gradio.shared.min_width}
+		allow_overflow={false}
+	>
+		<StatusTracker
+			autoscroll={gradio.shared.autoscroll}
+			i18n={gradio.i18n}
+			{...gradio.shared.loading_status}
+			on_clear_status={() =>
+				gradio.dispatch("clear_status", gradio.shared.loading_status)}
+		/>
+
+		<StaticVideo
+			value={gradio.props.value}
+			subtitle={gradio.props.subtitles}
+			label={gradio.shared.label}
+			show_label={gradio.shared.show_label}
+			autoplay={gradio.props.autoplay}
+			loop={gradio.props.loop}
+			buttons={gradio.props.buttons ?? ["download", "share"]}
+			on_custom_button_click={(id) => {
+				gradio.dispatch("custom_button_click", { id });
+			}}
+			bind:playback_position={gradio.props.playback_position}
+			onplay={() => gradio.dispatch("play")}
+			onpause={() => gradio.dispatch("pause")}
+			onstop={() => gradio.dispatch("stop")}
+			onend={() => gradio.dispatch("end")}
+			onshare={(detail) => gradio.dispatch("share", detail)}
+			onerror={(detail) => gradio.dispatch("error", detail)}
+			i18n={gradio.i18n}
+			upload={(...args) => gradio.shared.client.upload(...args)}
+		/>
+	</Block>
+{:else}
+	<Block
+		visible={gradio.shared.visible}
+		variant={gradio.props.value === null && active_source === "upload"
+			? "dashed"
+			: "solid"}
+		border_mode={dragging ? "focus" : "base"}
+		padding={false}
+		elem_id={gradio.shared.elem_id}
+		elem_classes={gradio.shared.elem_classes}
+		height={gradio.props.height || undefined}
+		width={gradio.props.width}
+		container={gradio.shared.container}
+		scale={gradio.shared.scale}
+		min_width={gradio.shared.min_width}
+		allow_overflow={false}
+	>
+		<StatusTracker
+			autoscroll={gradio.shared.autoscroll}
+			i18n={gradio.i18n}
+			{...gradio.shared.loading_status}
+			on_clear_status={() =>
+				gradio.dispatch("clear_status", gradio.shared.loading_status)}
+		/>
+
+		<Video
+			bind:upload_promise
+			value={gradio.props.value}
+			subtitle={gradio.props.subtitles}
+			onchange={handle_change}
+			ondrag={(detail) => (dragging = detail)}
+			onerror={handle_error}
+			bind:uploading
+			label={gradio.shared.label}
+			show_label={gradio.shared.show_label}
+			buttons={gradio.props.buttons ?? ["download", "share"]}
+			on_custom_button_click={(id) => {
+				gradio.dispatch("custom_button_click", { id });
+			}}
+			sources={gradio.props.sources}
+			{active_source}
+			webcam_options={gradio.props.webcam_options}
+			include_audio={gradio.props.include_audio}
+			autoplay={gradio.props.autoplay}
+			root={gradio.shared.root}
+			loop={gradio.props.loop}
+			{handle_reset_value}
+			bind:playback_position={gradio.props.playback_position}
+			onclear={() => {
+				gradio.props.value = null;
+				gradio.dispatch("clear");
+				gradio.dispatch("input");
+			}}
+			onplay={() => gradio.dispatch("play")}
+			onpause={() => gradio.dispatch("pause")}
+			onupload={() => {
+				gradio.dispatch("upload");
+				gradio.dispatch("input");
+			}}
+			onstop={() => gradio.dispatch("stop")}
+			onend={() => gradio.dispatch("end")}
+			onstart_recording={() => gradio.dispatch("start_recording")}
+			onstop_recording={() => gradio.dispatch("stop_recording")}
+			i18n={gradio.i18n}
+			max_file_size={gradio.shared.max_file_size}
+			upload={(...args) => gradio.shared.client.upload(...args)}
+			stream_handler={(...args) => gradio.shared.client.stream(...args)}
+		>
+			<UploadText i18n={gradio.i18n} type="video" />
+		</Video>
+	</Block>
+{/if}

6.8.1/video/index.ts

@@ -0,0 +1,7 @@
+export { default as BaseInteractiveVideo } from "./shared/InteractiveVideo.svelte";
+export { default as BaseStaticVideo } from "./shared/VideoPreview.svelte";
+export { default as BasePlayer } from "./shared/Player.svelte";
+export { prettyBytes, playable, loaded } from "./shared/utils";
+export { default as BaseExample } from "./Example.svelte";
+import { default as Index } from "./Index.svelte";
+export default Index;

6.8.1/video/package.json

@@ -0,0 +1,58 @@
+{
+	"name": "@gradio/video",
+	"version": "0.20.3",
+	"description": "Gradio UI packages",
+	"type": "module",
+	"author": "",
+	"license": "ISC",
+	"private": false,
+	"dependencies": {
+		"@ffmpeg/ffmpeg": "^0.12.15",
+		"@ffmpeg/util": "^0.12.2",
+		"@gradio/atoms": "workspace:^",
+		"@gradio/client": "workspace:^",
+		"@gradio/icons": "workspace:^",
+		"@gradio/image": "workspace:^",
+		"@gradio/statustracker": "workspace:^",
+		"@gradio/upload": "workspace:^",
+		"@gradio/utils": "workspace:^",
+		"hls.js": "^1.6.13",
+		"mrmime": "^2.0.1"
+	},
+	"devDependencies": {
+		"@gradio/preview": "workspace:^"
+	},
+	"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": "./shared/VideoPreview.svelte",
+			"svelte": "./dist/shared/VideoPreview.svelte",
+			"types": "./dist/shared/VideoPreview.svelte.d.ts"
+		}
+	},
+	"peerDependencies": {
+		"svelte": "^5.48.0"
+	},
+	"main": "index.ts",
+	"main_changeset": true,
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/gradio-app/gradio.git",
+		"directory": "js/video"
+	}
+}

6.8.1/video/shared/InteractiveVideo.svelte

@@ -0,0 +1,232 @@
+<script lang="ts">
+	import { Upload } from "@gradio/upload";
+	import type { FileData, Client } from "@gradio/client";
+	import { BlockLabel } from "@gradio/atoms";
+	import { Webcam } from "@gradio/image";
+	import { Video } from "@gradio/icons";
+	import type { WebcamOptions } from "./utils";
+	import { prettyBytes, playable } from "./utils";
+	import Player from "./Player.svelte";
+	import type { I18nFormatter } from "@gradio/utils";
+	import { SelectSource } from "@gradio/atoms";
+	import type { Snippet } from "svelte";
+
+	interface Props {
+		value?: FileData | null;
+		subtitle?: FileData | null;
+		sources?:
+			| ["webcam"]
+			| ["upload"]
+			| ["webcam", "upload"]
+			| ["upload", "webcam"];
+		label?: string;
+		show_download_button?: boolean;
+		show_label?: boolean;
+		webcam_options: WebcamOptions;
+		include_audio: boolean;
+		autoplay: boolean;
+		root: string;
+		i18n: I18nFormatter;
+		active_source?: "webcam" | "upload";
+		handle_reset_value?: () => void;
+		max_file_size?: number | null;
+		upload: Client["upload"];
+		stream_handler: Client["stream"];
+		loop: boolean;
+		uploading?: boolean;
+		upload_promise?: Promise<any> | null;
+		playback_position?: number;
+		buttons?: (string | CustomButtonType)[] | null;
+		on_custom_button_click?: ((id: number) => void) | null;
+		onchange?: (value: FileData | null) => void;
+		onclear?: () => void;
+		onplay?: () => void;
+		onpause?: () => void;
+		onend?: () => void;
+		ondrag?: (dragging: boolean) => void;
+		onerror?: (error: string) => void;
+		onupload?: (value: FileData) => void;
+		onstart_recording?: () => void;
+		onstop_recording?: () => void;
+		onstop?: () => void;
+		children?: Snippet;
+	}
+
+	import type { CustomButton as CustomButtonType } from "@gradio/utils";
+
+	let {
+		value = $bindable(null),
+		subtitle = null,
+		sources = ["webcam", "upload"],
+		label = undefined,
+		show_download_button = false,
+		show_label = true,
+		webcam_options,
+		include_audio,
+		autoplay,
+		root,
+		i18n,
+		active_source: initial_active_source = "webcam",
+		handle_reset_value = () => {},
+		max_file_size = null,
+		upload,
+		stream_handler,
+		loop,
+		uploading = $bindable(),
+		upload_promise = $bindable(),
+		playback_position = $bindable(),
+		buttons = null,
+		on_custom_button_click = null,
+		onchange,
+		onclear,
+		onplay,
+		onpause,
+		onend,
+		ondrag,
+		onerror,
+		onupload,
+		onstart_recording,
+		onstop_recording,
+		onstop,
+		children
+	}: Props = $props();
+
+	let has_change_history = $state(false);
+	let active_source = $derived.by(() => {
+		return initial_active_source ?? "webcam";
+	});
+
+	function handle_load(detail: FileData | null): void {
+		value = detail;
+		onchange?.(detail);
+		if (detail) {
+			onupload?.(detail);
+		}
+	}
+
+	function handle_clear(): void {
+		value = null;
+		onchange?.(null);
+		onclear?.();
+	}
+
+	function handle_change(video: FileData): void {
+		has_change_history = true;
+		onchange?.(video);
+	}
+
+	function handle_capture({
+		detail
+	}: CustomEvent<FileData | any | null>): void {
+		onchange?.(detail);
+	}
+
+	let dragging = $state(false);
+
+	$effect(() => {
+		ondrag?.(dragging);
+	});
+</script>
+
+<BlockLabel {show_label} Icon={Video} label={label || "Video"} />
+<div data-testid="video" class="video-container">
+	{#if value === null || value?.url === undefined}
+		<div class="upload-container">
+			{#if active_source === "upload"}
+				<Upload
+					bind:upload_promise
+					bind:dragging
+					bind:uploading
+					filetype="video/x-m4v,video/*"
+					onload={handle_load}
+					{max_file_size}
+					onerror={(detail) => onerror?.(detail)}
+					{root}
+					{upload}
+					{stream_handler}
+					aria_label={i18n("video.drop_to_upload")}
+				>
+					{#if children}
+						{@render children()}
+					{/if}
+				</Upload>
+			{:else if active_source === "webcam"}
+				<Webcam
+					{root}
+					mirror_webcam={webcam_options.mirror}
+					webcam_constraints={webcam_options.constraints}
+					{include_audio}
+					mode="video"
+					on:error={({ detail }) => onerror?.(detail)}
+					on:capture={handle_capture}
+					on:start_recording={() => onstart_recording?.()}
+					on:stop_recording={() => onstop_recording?.()}
+					{i18n}
+					{upload}
+					stream_every={1}
+				/>
+			{/if}
+		</div>
+	{:else if value?.url}
+		{#key value?.url}
+			<Player
+				{upload}
+				{root}
+				interactive
+				{autoplay}
+				src={value.url}
+				subtitle={subtitle?.url}
+				is_stream={false}
+				onplay={() => onplay?.()}
+				onpause={() => onpause?.()}
+				onstop={() => onstop?.()}
+				onend={() => onend?.()}
+				onerror={(error) => onerror?.(error)}
+				mirror={webcam_options.mirror && active_source === "webcam"}
+				{label}
+				{handle_change}
+				{handle_reset_value}
+				{loop}
+				{value}
+				{i18n}
+				{show_download_button}
+				{handle_clear}
+				{has_change_history}
+				bind:playback_position
+			/>
+		{/key}
+	{:else if value.size}
+		<div class="file-name">{value.orig_name || value.url}</div>
+		<div class="file-size">
+			{prettyBytes(value.size)}
+		</div>
+	{/if}
+
+	<SelectSource {sources} bind:active_source {handle_clear} />
+</div>
+
+<style>
+	.file-name {
+		padding: var(--size-6);
+		font-size: var(--text-xxl);
+		word-break: break-all;
+	}
+
+	.file-size {
+		padding: var(--size-2);
+		font-size: var(--text-xl);
+	}
+
+	.upload-container {
+		height: 100%;
+		width: 100%;
+	}
+
+	.video-container {
+		display: flex;
+		height: 100%;
+		flex-direction: column;
+		justify-content: center;
+		align-items: center;
+	}
+</style>

6.8.1/video/shared/Player.svelte

@@ -0,0 +1,433 @@
+<script lang="ts">
+	import { onMount, onDestroy } from "svelte";
+	import { Play, Pause, Maximize, Undo } from "@gradio/icons";
+	import Video from "./Video.svelte";
+	import VideoControls from "./VideoControls.svelte";
+	import VolumeControl from "./VolumeControl.svelte";
+	import VolumeLevels from "../../audio/shared/VolumeLevels.svelte";
+	import type { FileData, Client } from "@gradio/client";
+	import { prepare_files } from "@gradio/client";
+	import { format_time } from "@gradio/utils";
+	import type { I18nFormatter } from "@gradio/utils";
+
+	interface Props {
+		root?: string;
+		src: string;
+		subtitle?: string | null;
+		mirror: boolean;
+		autoplay: boolean;
+		loop: boolean;
+		label?: string;
+		interactive?: boolean;
+		handle_change?: (video: FileData) => void;
+		handle_reset_value?: () => void;
+		upload: Client["upload"];
+		is_stream?: boolean;
+		i18n: I18nFormatter;
+		show_download_button?: boolean;
+		value?: FileData | null;
+		handle_clear?: () => void;
+		has_change_history?: boolean;
+		playback_position?: number;
+		onplay?: () => void;
+		onpause?: () => void;
+		onstop?: () => void;
+		onend?: () => void;
+		onerror?: (error: string) => void;
+		onloadstart?: () => void;
+		onloadeddata?: () => void;
+		onloadedmetadata?: () => void;
+	}
+
+	let {
+		root = "",
+		src,
+		subtitle = null,
+		mirror,
+		autoplay,
+		loop,
+		label = "test",
+		interactive = false,
+		handle_change = () => {},
+		handle_reset_value = () => {},
+		upload,
+		is_stream = undefined,
+		i18n,
+		show_download_button = false,
+		value = null,
+		handle_clear = () => {},
+		has_change_history = false,
+		playback_position = $bindable(),
+		onplay,
+		onpause,
+		onstop,
+		onend,
+		onerror,
+		onloadstart,
+		onloadeddata,
+		onloadedmetadata
+	}: Props = $props();
+
+	let time = $state(0);
+	let duration = $state<number>(0);
+	let paused = $state(true);
+	let video = $state<HTMLVideoElement>();
+	let processingVideo = $state(false);
+	let show_volume_slider = $state(false);
+	let current_volume = $state(1);
+	let is_fullscreen = $state(false);
+
+	function handleMove(e: TouchEvent | MouseEvent): void {
+		if (!duration) return;
+
+		if (e.type === "click") {
+			handle_click(e as MouseEvent);
+			return;
+		}
+
+		if (e.type !== "touchmove" && !((e as MouseEvent).buttons & 1)) return;
+
+		const clientX =
+			e.type === "touchmove"
+				? (e as TouchEvent).touches[0].clientX
+				: (e as MouseEvent).clientX;
+		const { left, right } = (
+			e.currentTarget as HTMLProgressElement
+		).getBoundingClientRect();
+		time = (duration * (clientX - left)) / (right - left);
+	}
+
+	async function play_pause(): Promise<void> {
+		if (!video) return;
+		if (document.fullscreenElement != video) {
+			const isPlaying =
+				video.currentTime > 0 &&
+				!video.paused &&
+				!video.ended &&
+				video.readyState > video.HAVE_CURRENT_DATA;
+
+			if (!isPlaying) {
+				await video.play();
+			} else video.pause();
+		}
+	}
+
+	function handle_click(e: MouseEvent): void {
+		if (!duration) return;
+		const { left, right } = (
+			e.currentTarget as HTMLProgressElement
+		).getBoundingClientRect();
+		time = (duration * (e.clientX - left)) / (right - left);
+	}
+
+	function handle_end(): void {
+		onstop?.();
+		onend?.();
+	}
+
+	const handle_trim_video = async (videoBlob: Blob): Promise<void> => {
+		let _video_blob = new File([videoBlob], "video.mp4");
+		const val = await prepare_files([_video_blob]);
+		let value = ((await upload(val, root))?.filter(Boolean) as FileData[])[0];
+
+		handle_change(value);
+	};
+
+	function open_full_screen(): void {
+		if (!video) return;
+		if (!is_fullscreen) {
+			video.requestFullscreen();
+		} else {
+			document.exitFullscreen();
+		}
+	}
+
+	function handleFullscreenChange(): void {
+		is_fullscreen = document.fullscreenElement === video;
+		if (video) {
+			video.controls = is_fullscreen;
+		}
+	}
+
+	let last_synced_volume = 1;
+	let previous_video: HTMLVideoElement | undefined;
+	// Tolerance for floating-point comparison of volume values
+	const VOLUME_EPSILON = 0.001;
+
+	function handleVolumeChange(): void {
+		if (video && Math.abs(video.volume - last_synced_volume) > VOLUME_EPSILON) {
+			current_volume = video.volume;
+			last_synced_volume = video.volume;
+		}
+	}
+
+	onMount(() => {
+		document.addEventListener("fullscreenchange", handleFullscreenChange);
+		return () => {
+			document.removeEventListener("fullscreenchange", handleFullscreenChange);
+		};
+	});
+
+	onDestroy(() => {
+		if (video) {
+			video.removeEventListener("volumechange", handleVolumeChange);
+		}
+	});
+
+	$effect(() => {
+		if (video && video !== previous_video) {
+			if (previous_video) {
+				previous_video.removeEventListener("volumechange", handleVolumeChange);
+			}
+			video.addEventListener("volumechange", handleVolumeChange);
+			previous_video = video;
+		}
+	});
+
+	$effect(() => {
+		playback_position = time;
+	});
+
+	$effect(() => {
+		if (playback_position !== time && video) {
+			video.currentTime = playback_position;
+		}
+	});
+
+	$effect(() => {
+		if (video && !is_fullscreen) {
+			if (Math.abs(video.volume - current_volume) > VOLUME_EPSILON) {
+				video.volume = current_volume;
+				last_synced_volume = current_volume;
+			}
+			video.controls = false;
+		}
+	});
+
+	$effect(() => {
+		if (video && is_fullscreen) {
+			last_synced_volume = video.volume;
+		}
+	});
+</script>
+
+<div class="wrap">
+	<div class="mirror-wrap" class:mirror>
+		<Video
+			{src}
+			preload="auto"
+			{autoplay}
+			{loop}
+			{is_stream}
+			controls={is_fullscreen}
+			onclick={play_pause}
+			onplay={() => onplay?.()}
+			onpause={() => onpause?.()}
+			onerror={(error) => onerror?.(error)}
+			onended={handle_end}
+			bind:currentTime={time}
+			bind:duration
+			bind:paused
+			bind:node={video}
+			data-testid={`${label}-player`}
+			{processingVideo}
+			onloadstart={() => onloadstart?.()}
+			onloadeddata={() => onloadeddata?.()}
+			onloadedmetadata={() => onloadedmetadata?.()}
+		>
+			<track kind="captions" src={subtitle} default />
+		</Video>
+	</div>
+
+	<div class="controls">
+		<div class="inner">
+			<span
+				role="button"
+				tabindex="0"
+				class="icon"
+				aria-label="play-pause-replay-button"
+				onclick={play_pause}
+				onkeydown={play_pause}
+			>
+				{#if time === duration}
+					<Undo />
+				{:else if paused}
+					<Play />
+				{:else}
+					<Pause />
+				{/if}
+			</span>
+
+			<span class="time">{format_time(time)} / {format_time(duration)}</span>
+
+			<!-- TODO: implement accessible video timeline for 4.0 -->
+			<!-- svelte-ignore a11y_click_events_have_key_events -->
+			<!-- svelte-ignore a11y_no_noninteractive_element_interactions -->
+			<progress
+				value={time / duration || 0}
+				onmousemove={handleMove}
+				ontouchmove={(e) => {
+					e.preventDefault();
+					handleMove(e);
+				}}
+				onclick={(e) => {
+					e.stopPropagation();
+					e.preventDefault();
+					handle_click(e);
+				}}
+			></progress>
+
+			<div class="volume-control-wrapper">
+				<button
+					class="icon volume-button"
+					style:color={show_volume_slider ? "var(--color-accent)" : "white"}
+					aria-label="Adjust volume"
+					onclick={() => (show_volume_slider = !show_volume_slider)}
+				>
+					<VolumeLevels currentVolume={current_volume} />
+				</button>
+
+				{#if show_volume_slider}
+					<VolumeControl bind:current_volume bind:show_volume_slider />
+				{/if}
+			</div>
+
+			{#if !show_volume_slider}
+				<div
+					role="button"
+					tabindex="0"
+					class="icon"
+					aria-label="full-screen"
+					onclick={open_full_screen}
+					onkeypress={open_full_screen}
+				>
+					<Maximize />
+				</div>
+			{/if}
+		</div>
+	</div>
+</div>
+{#if interactive}
+	<VideoControls
+		videoElement={video}
+		showRedo
+		{handle_trim_video}
+		{handle_reset_value}
+		bind:processingVideo
+		{value}
+		{i18n}
+		{show_download_button}
+		{handle_clear}
+		{has_change_history}
+	/>
+{/if}
+
+<style lang="postcss">
+	span {
+		text-shadow: 0 0 8px rgba(0, 0, 0, 0.5);
+	}
+
+	progress {
+		margin-right: var(--size-3);
+		border-radius: var(--radius-sm);
+		width: var(--size-full);
+		height: var(--size-2);
+	}
+
+	progress::-webkit-progress-bar {
+		border-radius: 2px;
+		background-color: rgba(255, 255, 255, 0.2);
+		overflow: hidden;
+	}
+
+	progress::-webkit-progress-value {
+		background-color: rgba(255, 255, 255, 0.9);
+	}
+
+	.mirror {
+		transform: scaleX(-1);
+	}
+
+	.mirror-wrap {
+		position: relative;
+		height: 100%;
+		width: 100%;
+	}
+
+	.controls {
+		position: absolute;
+		bottom: 0;
+		opacity: 0;
+		transition: 500ms;
+		margin: var(--size-2);
+		border-radius: var(--radius-md);
+		background: var(--color-grey-800);
+		padding: var(--size-2) var(--size-1);
+		width: calc(100% - 0.375rem * 2);
+		width: calc(100% - var(--size-2) * 2);
+		z-index: 10;
+	}
+	.wrap:hover .controls {
+		opacity: 1;
+	}
+	:global(:fullscreen) .controls {
+		display: none;
+	}
+
+	.inner {
+		display: flex;
+		justify-content: space-between;
+		align-items: center;
+		padding-right: var(--size-2);
+		padding-left: var(--size-2);
+		width: var(--size-full);
+		height: var(--size-full);
+	}
+
+	.icon {
+		display: flex;
+		justify-content: center;
+		cursor: pointer;
+		width: var(--size-6);
+		color: white;
+	}
+
+	.volume-control-wrapper {
+		position: relative;
+		display: flex;
+		align-items: center;
+		margin-right: var(--spacing-md);
+	}
+
+	.volume-button {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		cursor: pointer;
+		width: var(--size-6);
+		color: white;
+		border: none;
+		background: none;
+		padding: 0;
+	}
+
+	.time {
+		flex-shrink: 0;
+		margin-right: var(--size-3);
+		margin-left: var(--size-3);
+		color: white;
+		font-size: var(--text-sm);
+		font-family: var(--font-mono);
+	}
+	.wrap {
+		position: relative;
+		background-color: var(--background-fill-secondary);
+		height: var(--size-full);
+		width: var(--size-full);
+		border-radius: var(--radius-xl);
+	}
+	.wrap :global(video) {
+		height: var(--size-full);
+		width: var(--size-full);
+	}
+</style>

6.8.1/video/shared/Video.svelte

@@ -0,0 +1,224 @@
+<script lang="ts">
+	import type { HTMLVideoAttributes } from "svelte/elements";
+	import { loaded } from "./utils";
+	import type { Snippet } from "svelte";
+
+	import Hls from "hls.js";
+
+	interface Props {
+		src?: HTMLVideoAttributes["src"];
+		muted?: HTMLVideoAttributes["muted"];
+		playsinline?: HTMLVideoAttributes["playsinline"];
+		preload?: HTMLVideoAttributes["preload"];
+		autoplay?: HTMLVideoAttributes["autoplay"];
+		controls?: HTMLVideoAttributes["controls"];
+		currentTime?: number;
+		duration?: number;
+		paused?: boolean;
+		node?: HTMLVideoElement;
+		loop: boolean;
+		is_stream: boolean;
+		processingVideo?: boolean;
+		onloadeddata?: () => void;
+		onclick?: () => void;
+		onplay?: () => void;
+		onpause?: () => void;
+		onended?: () => void;
+		onmouseover?: () => void;
+		onmouseout?: () => void;
+		onfocus?: () => void;
+		onblur?: () => void;
+		onerror?: (error: string) => void;
+		onloadstart?: () => void;
+		onloadedmetadata?: () => void;
+		"data-testid"?: string;
+		children?: Snippet;
+	}
+
+	let {
+		src = undefined,
+		muted = undefined,
+		playsinline = undefined,
+		preload = undefined,
+		autoplay = undefined,
+		controls = undefined,
+		currentTime = $bindable(undefined),
+		duration = $bindable(undefined),
+		paused = $bindable(undefined),
+		node = $bindable(undefined),
+		loop,
+		is_stream,
+		processingVideo = false,
+		onloadeddata,
+		onclick,
+		onplay,
+		onpause,
+		onended,
+		onmouseover,
+		onmouseout,
+		onfocus,
+		onblur,
+		onerror,
+		onloadstart,
+		onloadedmetadata,
+		"data-testid": dataTestid,
+		children
+	}: Props = $props();
+
+	let stream_active = $state(false);
+
+	function load_stream(
+		src: string | null | undefined,
+		is_stream: boolean,
+		node: HTMLVideoElement
+	): void {
+		if (!src || !is_stream) return;
+
+		if (Hls.isSupported() && !stream_active) {
+			const hls = new Hls({
+				maxBufferLength: 1, // 0.5 seconds (500 ms)
+				maxMaxBufferLength: 1, // Maximum max buffer length in seconds
+				lowLatencyMode: true // Enable low latency mode
+			});
+			hls.loadSource(src);
+			hls.attachMedia(node);
+			hls.on(Hls.Events.MANIFEST_PARSED, function () {
+				(node as HTMLVideoElement).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;
+		}
+	}
+
+	$effect(() => {
+		src;
+		stream_active = false;
+	});
+
+	$effect(() => {
+		if (node && src && is_stream) {
+			load_stream(src, is_stream, node);
+		}
+	});
+</script>
+
+<!--
+The spread operator with `$$props` or `$$restProps` can't be used here
+to pass props from the parent component to the <video> element
+because of its unexpected behavior: https://github.com/sveltejs/svelte/issues/7404
+For example, if we add {...$$props} or {...$$restProps}, the boolean props aside it like `controls` will be compiled as string "true" or "false" on the actual DOM.
+Then, even when `controls` is false, the compiled DOM would be `<video controls="false">` which is equivalent to `<video controls>` since the string "false" is even truthy.
+-->
+<div class:hidden={!processingVideo} class="overlay">
+	<span class="load-wrap">
+		<span class="loader" />
+	</span>
+</div>
+<video
+	{src}
+	{muted}
+	{playsinline}
+	{preload}
+	{autoplay}
+	{controls}
+	{loop}
+	onloadeddata={() => onloadeddata?.()}
+	onclick={() => onclick?.()}
+	onplay={() => onplay?.()}
+	onpause={() => onpause?.()}
+	onended={() => onended?.()}
+	onmouseover={() => onmouseover?.()}
+	onmouseout={() => onmouseout?.()}
+	onfocus={() => onfocus?.()}
+	onblur={() => onblur?.()}
+	onerror={() => onerror?.("Video not playable")}
+	onloadstart={() => onloadstart?.()}
+	onloadedmetadata={() => onloadedmetadata?.()}
+	bind:currentTime
+	bind:duration
+	bind:paused
+	bind:this={node}
+	use:loaded={{ autoplay: autoplay ?? false }}
+	data-testid={dataTestid}
+	crossorigin="anonymous"
+>
+	{#if children}
+		{@render children()}
+	{/if}
+</video>
+
+<style>
+	.overlay {
+		position: absolute;
+		background-color: rgba(0, 0, 0, 0.4);
+		width: 100%;
+		height: 100%;
+	}
+
+	.hidden {
+		display: none;
+	}
+
+	.load-wrap {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		height: 100%;
+	}
+
+	.loader {
+		display: flex;
+		position: relative;
+		background-color: var(--border-color-accent-subdued);
+		animation: shadowPulse 2s linear infinite;
+		box-shadow:
+			-24px 0 var(--border-color-accent-subdued),
+			24px 0 var(--border-color-accent-subdued);
+		margin: var(--spacing-md);
+		border-radius: 50%;
+		width: 10px;
+		height: 10px;
+		scale: 0.5;
+	}
+
+	@keyframes shadowPulse {
+		33% {
+			box-shadow:
+				-24px 0 var(--border-color-accent-subdued),
+				24px 0 #fff;
+			background: #fff;
+		}
+		66% {
+			box-shadow:
+				-24px 0 #fff,
+				24px 0 #fff;
+			background: var(--border-color-accent-subdued);
+		}
+		100% {
+			box-shadow:
+				-24px 0 #fff,
+				24px 0 var(--border-color-accent-subdued);
+			background: #fff;
+		}
+	}
+</style>

6.8.1/video/shared/VideoControls.svelte

@@ -0,0 +1,224 @@
+<script lang="ts">
+	import { Undo, Trim, Clear } from "@gradio/icons";
+	import VideoTimeline from "./VideoTimeline.svelte";
+	import { trimVideo } from "./utils";
+	import { FFmpeg } from "@ffmpeg/ffmpeg";
+	import loadFfmpeg from "./utils";
+	import { onMount } from "svelte";
+	import { format_time } from "@gradio/utils";
+	import { IconButton } from "@gradio/atoms";
+	import { ModifyUpload } from "@gradio/upload";
+	import type { FileData } from "@gradio/client";
+
+	interface Props {
+		videoElement?: HTMLVideoElement;
+		showRedo?: boolean;
+		interactive?: boolean;
+		mode?: string;
+		handle_reset_value: () => void;
+		handle_trim_video: (videoBlob: Blob) => void;
+		processingVideo?: boolean;
+		i18n: (key: string) => string;
+		value?: FileData | null;
+		show_download_button?: boolean;
+		handle_clear?: () => void;
+		has_change_history?: boolean;
+	}
+
+	let {
+		videoElement = undefined,
+		showRedo = false,
+		interactive = true,
+		mode = $bindable(""),
+		handle_reset_value,
+		handle_trim_video,
+		processingVideo = $bindable(false),
+		i18n,
+		value = null,
+		show_download_button = false,
+		handle_clear = () => {},
+		has_change_history = false
+	}: Props = $props();
+
+	let ffmpeg: FFmpeg;
+
+	onMount(async () => {
+		ffmpeg = await loadFfmpeg();
+	});
+
+	$effect(() => {
+		if (mode === "edit" && trimmedDuration === null && videoElement) {
+			trimmedDuration = videoElement.duration;
+		}
+	});
+
+	let trimmedDuration = $state<number | null>(null);
+	let dragStart = $state(0);
+	let dragEnd = $state(0);
+
+	let loadingTimeline = $state(false);
+
+	const toggleTrimmingMode = (): void => {
+		if (mode === "edit") {
+			mode = "";
+			if (videoElement) {
+				trimmedDuration = videoElement.duration;
+			}
+		} else {
+			mode = "edit";
+		}
+	};
+</script>
+
+<div class="container" class:hidden={mode !== "edit"}>
+	{#if mode === "edit" && videoElement}
+		<div class="timeline-wrapper">
+			<VideoTimeline
+				{videoElement}
+				bind:dragStart
+				bind:dragEnd
+				bind:trimmedDuration
+				bind:loadingTimeline
+			/>
+		</div>
+	{/if}
+
+	<div class="controls" data-testid="waveform-controls">
+		{#if mode === "edit" && trimmedDuration !== null}
+			<time
+				aria-label="duration of selected region in seconds"
+				class:hidden={loadingTimeline}>{format_time(trimmedDuration)}</time
+			>
+			<div class="edit-buttons">
+				<button
+					class:hidden={loadingTimeline}
+					class="text-button"
+					onclick={() => {
+						if (!videoElement) return;
+						mode = "";
+						processingVideo = true;
+						trimVideo(ffmpeg, dragStart, dragEnd, videoElement)
+							.then((videoBlob) => {
+								handle_trim_video(videoBlob);
+							})
+							.then(() => {
+								processingVideo = false;
+							});
+					}}>Trim</button
+				>
+				<button
+					class="text-button"
+					class:hidden={loadingTimeline}
+					onclick={toggleTrimmingMode}>Cancel</button
+				>
+			</div>
+		{:else}
+			<div />
+		{/if}
+	</div>
+</div>
+
+<ModifyUpload
+	{i18n}
+	onclear={() => handle_clear()}
+	download={show_download_button ? value?.url : null}
+>
+	{#if showRedo && mode === ""}
+		<IconButton
+			Icon={Undo}
+			label="Reset video to initial value"
+			disabled={processingVideo || !has_change_history}
+			onclick={() => {
+				handle_reset_value();
+				mode = "";
+			}}
+		/>
+	{/if}
+
+	{#if interactive && mode === ""}
+		<IconButton
+			Icon={Trim}
+			label="Trim video to selection"
+			disabled={processingVideo}
+			onclick={toggleTrimmingMode}
+		/>
+	{/if}
+</ModifyUpload>
+
+<style>
+	.container {
+		width: 100%;
+	}
+	time {
+		color: var(--color-accent);
+		font-weight: bold;
+		padding-left: var(--spacing-xs);
+	}
+
+	.timeline-wrapper {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		width: 100%;
+	}
+
+	.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: flex;
+		justify-content: space-between;
+		align-items: center;
+		margin: var(--spacing-lg);
+		overflow: hidden;
+	}
+
+	.edit-buttons {
+		display: flex;
+		gap: var(--spacing-sm);
+	}
+
+	@media (max-width: 320px) {
+		.controls {
+			flex-direction: column;
+			align-items: flex-start;
+		}
+
+		.edit-buttons {
+			margin-top: var(--spacing-sm);
+		}
+
+		.controls * {
+			margin: var(--spacing-sm);
+		}
+
+		.controls .text-button {
+			margin-left: 0;
+		}
+	}
+
+	.container {
+		display: flex;
+		flex-direction: column;
+	}
+
+	.hidden {
+		display: none;
+	}
+</style>

6.8.1/video/shared/VideoPreview.svelte

@@ -0,0 +1,154 @@
+<script lang="ts">
+	import { tick } from "svelte";
+	import {
+		BlockLabel,
+		Empty,
+		IconButton,
+		ShareButton,
+		IconButtonWrapper,
+		DownloadLink
+	} from "@gradio/atoms";
+	import type { FileData, Client } from "@gradio/client";
+	import { Video, Download } from "@gradio/icons";
+	import { uploadToHuggingFace } from "@gradio/utils";
+	import type { CustomButton as CustomButtonType } from "@gradio/utils";
+
+	import Player from "./Player.svelte";
+	import type { I18nFormatter } from "js/core/src/gradio_helper";
+
+	interface Props {
+		value?: FileData | null;
+		subtitle?: FileData | null;
+		label?: string;
+		show_label?: boolean;
+		autoplay: boolean;
+		buttons?: (string | CustomButtonType)[] | null;
+		on_custom_button_click?: ((id: number) => void) | null;
+		loop: boolean;
+		i18n: I18nFormatter;
+		upload: Client["upload"];
+		display_icon_button_wrapper_top_corner?: boolean;
+		playback_position?: number;
+		onplay?: () => void;
+		onpause?: () => void;
+		onend?: () => void;
+		onstop?: () => void;
+		onload?: () => void;
+		onchange?: (value: FileData) => void;
+		onerror?: (error: string) => void;
+		onshare?: (detail: unknown) => void;
+	}
+
+	let {
+		value = $bindable(null),
+		subtitle = null,
+		label = undefined,
+		show_label = true,
+		autoplay,
+		buttons = null,
+		on_custom_button_click = null,
+		loop,
+		i18n,
+		upload,
+		display_icon_button_wrapper_top_corner = false,
+		playback_position = $bindable(),
+		onplay,
+		onpause,
+		onend,
+		onstop,
+		onload,
+		onchange,
+		onerror,
+		onshare
+	}: Props = $props();
+
+	let old_value = $state<FileData | null>(null);
+	let old_subtitle = $state<FileData | null>(null);
+
+	$effect(() => {
+		if (value) {
+			onchange?.(value);
+		}
+	});
+
+	$effect(() => {
+		async function updateValue(): Promise<void> {
+			// needed to bust subtitle caching issues on Chrome
+			if (
+				value !== old_value &&
+				subtitle !== old_subtitle &&
+				old_subtitle !== null
+			) {
+				old_value = value;
+				value = null;
+				await tick();
+				value = old_value;
+			}
+			old_value = value;
+			old_subtitle = subtitle;
+		}
+		updateValue();
+	});
+</script>
+
+<BlockLabel {show_label} Icon={Video} label={label || "Video"} />
+{#if !value || value.url === undefined}
+	<Empty unpadded_box={true} size="large"><Video /></Empty>
+{:else}
+	{#key value.url}
+		<Player
+			src={value.url}
+			subtitle={subtitle?.url}
+			is_stream={value.is_stream}
+			{autoplay}
+			onplay={() => onplay?.()}
+			onpause={() => onpause?.()}
+			onstop={() => onstop?.()}
+			onend={() => onend?.()}
+			onloadedmetadata={() => {
+				// Deal with `<video>`'s `loadedmetadata` event as `VideoPreview`'s `load` event
+				// to represent not only the video is loaded but also the metadata is loaded
+				// so its dimensions (w/h) are known. This is used for Chatbot's auto scroll.
+				onload?.();
+			}}
+			mirror={false}
+			{label}
+			{loop}
+			interactive={false}
+			{upload}
+			{i18n}
+			bind:playback_position
+		/>
+	{/key}
+	<div data-testid="download-div">
+		<IconButtonWrapper
+			display_top_corner={display_icon_button_wrapper_top_corner}
+			buttons={buttons ?? ["download", "share"]}
+			{on_custom_button_click}
+		>
+			{#if buttons?.some((btn) => typeof btn === "string" && btn === "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="Download" />
+				</DownloadLink>
+			{/if}
+			{#if buttons?.some((btn) => typeof btn === "string" && btn === "share")}
+				<ShareButton
+					{i18n}
+					onerror={(detail) => onerror?.(detail)}
+					onshare={(detail) => onshare?.(detail)}
+					{value}
+					formatter={async (value) => {
+						if (!value) return "";
+						let url = await uploadToHuggingFace(value.data, "url");
+						return url;
+					}}
+				/>
+			{/if}
+		</IconButtonWrapper>
+	</div>
+{/if}

6.8.1/video/shared/VideoTimeline.svelte

@@ -0,0 +1,293 @@
+<script lang="ts">
+	import { onMount, onDestroy } from "svelte";
+
+	interface Props {
+		videoElement: HTMLVideoElement;
+		trimmedDuration?: number | null;
+		dragStart?: number;
+		dragEnd?: number;
+		loadingTimeline?: boolean;
+	}
+
+	let {
+		videoElement,
+		trimmedDuration = $bindable(null),
+		dragStart = $bindable(0),
+		dragEnd = $bindable(0),
+		loadingTimeline = $bindable(false)
+	}: Props = $props();
+
+	let thumbnails = $state<string[]>([]);
+	let numberOfThumbnails = 10;
+	let intervalId: ReturnType<typeof setInterval> | undefined;
+	let videoDuration: number;
+
+	let leftHandlePosition = $state(0);
+	let rightHandlePosition = $state(100);
+
+	let dragging = $state<string | null>(null);
+
+	const startDragging = (side: string | null): void => {
+		dragging = side;
+	};
+
+	let loadingTimelineValue = $derived(thumbnails.length !== numberOfThumbnails);
+
+	$effect(() => {
+		loadingTimeline = loadingTimelineValue;
+	});
+
+	const stopDragging = (): void => {
+		dragging = null;
+	};
+
+	const drag = (event: { clientX: number }, distance?: number): void => {
+		if (dragging) {
+			const timeline = document.getElementById("timeline");
+
+			if (!timeline) return;
+
+			const rect = timeline.getBoundingClientRect();
+			let newPercentage = ((event.clientX - rect.left) / rect.width) * 100;
+
+			if (distance) {
+				// Move handle based on arrow key press
+				newPercentage =
+					dragging === "left"
+						? leftHandlePosition + distance
+						: rightHandlePosition + distance;
+			} else {
+				// Move handle based on mouse drag
+				newPercentage = ((event.clientX - rect.left) / rect.width) * 100;
+			}
+
+			newPercentage = Math.max(0, Math.min(newPercentage, 100)); // Keep within 0 and 100
+
+			if (dragging === "left") {
+				leftHandlePosition = Math.min(newPercentage, rightHandlePosition);
+
+				// Calculate the new time and set it for the videoElement
+				const newTimeLeft = (leftHandlePosition / 100) * videoDuration;
+				videoElement.currentTime = newTimeLeft;
+
+				dragStart = newTimeLeft;
+			} else if (dragging === "right") {
+				rightHandlePosition = Math.max(newPercentage, leftHandlePosition);
+
+				const newTimeRight = (rightHandlePosition / 100) * videoDuration;
+				videoElement.currentTime = newTimeRight;
+
+				dragEnd = newTimeRight;
+			}
+
+			const startTime = (leftHandlePosition / 100) * videoDuration;
+			const endTime = (rightHandlePosition / 100) * videoDuration;
+			trimmedDuration = endTime - startTime;
+
+			leftHandlePosition = leftHandlePosition;
+			rightHandlePosition = rightHandlePosition;
+		}
+	};
+
+	const moveHandle = (e: KeyboardEvent): void => {
+		if (dragging) {
+			// Calculate the movement distance as a percentage of the video duration
+			const distance = (1 / videoDuration) * 100;
+
+			if (e.key === "ArrowLeft") {
+				drag({ clientX: 0 }, -distance);
+			} else if (e.key === "ArrowRight") {
+				drag({ clientX: 0 }, distance);
+			}
+		}
+	};
+
+	const generateThumbnail = (): void => {
+		const canvas = document.createElement("canvas");
+		const ctx = canvas.getContext("2d");
+		if (!ctx) return;
+
+		canvas.width = videoElement.videoWidth;
+		canvas.height = videoElement.videoHeight;
+
+		ctx.drawImage(videoElement, 0, 0, canvas.width, canvas.height);
+
+		const thumbnail: string = canvas.toDataURL("image/jpeg", 0.7);
+		thumbnails = [...thumbnails, thumbnail];
+	};
+
+	onMount(() => {
+		const loadMetadata = (): void => {
+			videoDuration = videoElement.duration;
+
+			const interval = videoDuration / numberOfThumbnails;
+			let captures = 0;
+
+			const onSeeked = (): void => {
+				generateThumbnail();
+				captures++;
+
+				if (captures < numberOfThumbnails) {
+					videoElement.currentTime += interval;
+				} else {
+					videoElement.removeEventListener("seeked", onSeeked);
+				}
+			};
+
+			videoElement.addEventListener("seeked", onSeeked);
+			videoElement.currentTime = 0;
+		};
+
+		if (videoElement.readyState >= 1) {
+			loadMetadata();
+		} else {
+			videoElement.addEventListener("loadedmetadata", loadMetadata);
+		}
+	});
+
+	onDestroy(() => {
+		window.removeEventListener("mousemove", drag);
+		window.removeEventListener("mouseup", stopDragging);
+		window.removeEventListener("keydown", moveHandle);
+
+		if (intervalId !== undefined) {
+			clearInterval(intervalId);
+		}
+	});
+
+	onMount(() => {
+		window.addEventListener("mousemove", drag);
+		window.addEventListener("mouseup", stopDragging);
+		window.addEventListener("keydown", moveHandle);
+	});
+</script>
+
+<div class="container">
+	{#if loadingTimelineValue}
+		<div class="load-wrap">
+			<span aria-label="loading timeline" class="loader" />
+		</div>
+	{:else}
+		<div id="timeline" class="thumbnail-wrapper">
+			<button
+				aria-label="start drag handle for trimming video"
+				class="handle left"
+				onmousedown={() => startDragging("left")}
+				onblur={stopDragging}
+				onkeydown={(e) => {
+					if (e.key === "ArrowLeft" || e.key == "ArrowRight") {
+						startDragging("left");
+					}
+				}}
+				style="left: {leftHandlePosition}%;"
+			></button>
+
+			<div
+				class="opaque-layer"
+				style="left: {leftHandlePosition}%; right: {100 - rightHandlePosition}%"
+			></div>
+
+			{#each thumbnails as thumbnail, i (i)}
+				<img src={thumbnail} alt={`frame-${i}`} draggable="false" />
+			{/each}
+			<button
+				aria-label="end drag handle for trimming video"
+				class="handle right"
+				onmousedown={() => startDragging("right")}
+				onblur={stopDragging}
+				onkeydown={(e) => {
+					if (e.key === "ArrowLeft" || e.key == "ArrowRight") {
+						startDragging("right");
+					}
+				}}
+				style="left: {rightHandlePosition}%;"
+			></button>
+		</div>
+	{/if}
+</div>
+
+<style>
+	.load-wrap {
+		display: flex;
+		justify-content: center;
+		align-items: center;
+		height: 100%;
+	}
+	.loader {
+		display: flex;
+		position: relative;
+		background-color: var(--border-color-accent-subdued);
+		animation: shadowPulse 2s linear infinite;
+		box-shadow:
+			-24px 0 var(--border-color-accent-subdued),
+			24px 0 var(--border-color-accent-subdued);
+		margin: var(--spacing-md);
+		border-radius: 50%;
+		width: 10px;
+		height: 10px;
+		scale: 0.5;
+	}
+
+	@keyframes shadowPulse {
+		33% {
+			box-shadow:
+				-24px 0 var(--border-color-accent-subdued),
+				24px 0 #fff;
+			background: #fff;
+		}
+		66% {
+			box-shadow:
+				-24px 0 #fff,
+				24px 0 #fff;
+			background: var(--border-color-accent-subdued);
+		}
+		100% {
+			box-shadow:
+				-24px 0 #fff,
+				24px 0 var(--border-color-accent-subdued);
+			background: #fff;
+		}
+	}
+
+	.container {
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		justify-content: center;
+		margin: var(--spacing-lg) var(--spacing-lg) 0 var(--spacing-lg);
+	}
+
+	#timeline {
+		display: flex;
+		height: var(--size-10);
+		flex: 1;
+		position: relative;
+	}
+
+	img {
+		flex: 1 1 auto;
+		min-width: 0;
+		object-fit: cover;
+		height: var(--size-12);
+		border: 1px solid var(--block-border-color);
+		user-select: none;
+		z-index: 1;
+	}
+
+	.handle {
+		width: 3px;
+		background-color: var(--color-accent);
+		cursor: ew-resize;
+		height: var(--size-12);
+		z-index: 3;
+		position: absolute;
+	}
+
+	.opaque-layer {
+		background-color: rgba(230, 103, 40, 0.25);
+		border: 1px solid var(--color-accent);
+		height: var(--size-12);
+		position: absolute;
+		z-index: 2;
+	}
+</style>

6.8.1/video/shared/VolumeControl.svelte

@@ -0,0 +1,85 @@
+<script lang="ts">
+	import { onMount } from "svelte";
+
+	interface Props {
+		current_volume?: number;
+		show_volume_slider?: boolean;
+	}
+
+	let {
+		current_volume = $bindable(1),
+		show_volume_slider = $bindable(false)
+	}: Props = $props();
+
+	let volume_element: HTMLInputElement | undefined = $state();
+
+	onMount(() => {
+		adjustSlider();
+	});
+
+	const adjustSlider = (): void => {
+		let slider = volume_element;
+		if (!slider) return;
+
+		slider.style.background = `linear-gradient(to right, white ${
+			current_volume * 100
+		}%, rgba(255, 255, 255, 0.3) ${current_volume * 100}%)`;
+	};
+
+	$effect(() => {
+		current_volume;
+		adjustSlider();
+	});
+</script>
+
+<input
+	bind:this={volume_element}
+	id="volume"
+	class="volume-slider"
+	type="range"
+	min="0"
+	max="1"
+	step="0.01"
+	value={current_volume}
+	onfocusout={() => (show_volume_slider = false)}
+	oninput={(e) => {
+		if (e.target instanceof HTMLInputElement) {
+			current_volume = parseFloat(e.target.value);
+		}
+	}}
+/>
+
+<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: rgba(255, 255, 255, 0.3);
+		margin-left: var(--spacing-sm);
+	}
+
+	input[type="range"]::-webkit-slider-thumb {
+		-webkit-appearance: none;
+		appearance: none;
+		height: 15px;
+		width: 15px;
+		background-color: white;
+		border-radius: 50%;
+		border: none;
+		transition: 0.2s ease-in-out;
+	}
+
+	input[type="range"]::-moz-range-thumb {
+		height: 15px;
+		width: 15px;
+		background-color: white;
+		border-radius: 50%;
+		border: none;
+		transition: 0.2s ease-in-out;
+	}
+</style>

6.8.1/video/shared/index.ts

@@ -0,0 +1 @@
+export { default as Video } from "./Video.svelte";

6.8.1/video/shared/types.ts

@@ -0,0 +1,5 @@
+export interface SubtitleData {
+	start: number;
+	end: number;
+	text: string;
+}

6.8.1/video/shared/utils.ts

@@ -0,0 +1,151 @@
+import { toBlobURL } from "@ffmpeg/util";
+import { FFmpeg } from "@ffmpeg/ffmpeg";
+import { lookup } from "mrmime";
+
+export const prettyBytes = (bytes: number): string => {
+	let units = ["B", "KB", "MB", "GB", "PB"];
+	let i = 0;
+	while (bytes > 1024) {
+		bytes /= 1024;
+		i++;
+	}
+	let unit = units[i];
+	return bytes.toFixed(1) + " " + unit;
+};
+
+export const playable = (): boolean => {
+	// TODO: Fix this
+	// let video_element = document.createElement("video");
+	// let mime_type = mime.lookup(filename);
+	// return video_element.canPlayType(mime_type) != "";
+	return true; // FIX BEFORE COMMIT - mime import causing issues
+};
+
+export function loaded(
+	node: HTMLVideoElement,
+	{ autoplay }: { autoplay: boolean }
+): any {
+	async function handle_playback(): Promise<void> {
+		if (!autoplay) return;
+		await node.play();
+	}
+
+	node.addEventListener("loadeddata", handle_playback);
+
+	return {
+		destroy(): void {
+			node.removeEventListener("loadeddata", handle_playback);
+		}
+	};
+}
+
+export default async function loadFfmpeg(): Promise<FFmpeg> {
+	const ffmpeg = new FFmpeg();
+	const baseURL = "https://unpkg.com/@ffmpeg/core@0.12.4/dist/esm";
+
+	await ffmpeg.load({
+		coreURL: await toBlobURL(`${baseURL}/ffmpeg-core.js`, "text/javascript"),
+		wasmURL: await toBlobURL(`${baseURL}/ffmpeg-core.wasm`, "application/wasm")
+	});
+
+	return ffmpeg;
+}
+
+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 async function trimVideo(
+	ffmpeg: FFmpeg,
+	startTime: number,
+	endTime: number,
+	videoElement: HTMLVideoElement
+): Promise<any> {
+	const videoUrl = videoElement.src;
+	const mimeType = lookup(videoElement.src) || "video/mp4";
+	const blobUrl = await toBlobURL(videoUrl, mimeType);
+	const response = await fetch(blobUrl);
+	const vidBlob = await response.blob();
+	const type = getVideoExtensionFromMimeType(mimeType) || "mp4";
+	const inputName = `input.${type}`;
+	const outputName = `output.${type}`;
+
+	try {
+		if (startTime === 0 && endTime === 0) {
+			return vidBlob;
+		}
+
+		await ffmpeg.writeFile(
+			inputName,
+			new Uint8Array(await vidBlob.arrayBuffer())
+		);
+
+		let command = [
+			"-i",
+			inputName,
+			...(startTime !== 0 ? ["-ss", startTime.toString()] : []),
+			...(endTime !== 0 ? ["-to", endTime.toString()] : []),
+			"-c:a",
+			"copy",
+			outputName
+		];
+
+		await ffmpeg.exec(command);
+		const outputData = await ffmpeg.readFile(outputName);
+		const outputBlob = new Blob([outputData], {
+			type: `video/${type}`
+		});
+
+		return outputBlob;
+	} catch (error) {
+		console.error("Error initializing FFmpeg:", error);
+		return vidBlob;
+	}
+}
+
+const getVideoExtensionFromMimeType = (mimeType: string): string | null => {
+	const videoMimeToExtensionMap: { [key: string]: string } = {
+		"video/mp4": "mp4",
+		"video/webm": "webm",
+		"video/ogg": "ogv",
+		"video/quicktime": "mov",
+		"video/x-msvideo": "avi",
+		"video/x-matroska": "mkv",
+		"video/mpeg": "mpeg",
+		"video/3gpp": "3gp",
+		"video/3gpp2": "3g2",
+		"video/h261": "h261",
+		"video/h263": "h263",
+		"video/h264": "h264",
+		"video/jpeg": "jpgv",
+		"video/jpm": "jpm",
+		"video/mj2": "mj2",
+		"video/mpv": "mpv",
+		"video/vnd.ms-playready.media.pyv": "pyv",
+		"video/vnd.uvvu.mp4": "uvu",
+		"video/vnd.vivo": "viv",
+		"video/x-f4v": "f4v",
+		"video/x-fli": "fli",
+		"video/x-flv": "flv",
+		"video/x-m4v": "m4v",
+		"video/x-ms-asf": "asf",
+		"video/x-ms-wm": "wm",
+		"video/x-ms-wmv": "wmv",
+		"video/x-ms-wmx": "wmx",
+		"video/x-ms-wvx": "wvx",
+		"video/x-sgi-movie": "movie",
+		"video/x-smv": "smv"
+	};
+
+	return videoMimeToExtensionMap[mimeType] || null;
+};
+
+export interface WebcamOptions {
+	mirror: boolean;
+	constraints: Record<string, any>;
+}

6.8.1/video/types.ts

@@ -0,0 +1,41 @@
+import type { FileData } from "@gradio/client";
+import type { LoadingStatus } from "@gradio/statustracker";
+import type { CustomButton } from "@gradio/utils";
+import type { WebcamOptions } from "./shared/utils";
+
+export interface VideoProps {
+	value: FileData | null;
+	height: number | undefined;
+	width: number | undefined;
+	autoplay: boolean;
+	buttons: ("share" | "download" | "fullscreen" | CustomButton)[];
+	sources:
+		| ["webcam"]
+		| ["upload"]
+		| ["webcam", "upload"]
+		| ["upload", "webcam"];
+	webcam_options: WebcamOptions;
+	include_audio: boolean;
+	loop: boolean;
+	webcam_constraints: object;
+	subtitles: FileData | null;
+	playback_position: number;
+}
+
+export interface VideoEvents {
+	change: never;
+	clear: never;
+	play: never;
+	pause: never;
+	upload: never;
+	stop: never;
+	end: never;
+	start_recording: never;
+	stop_recording: never;
+	input: any;
+	clear_status: LoadingStatus;
+	share: any;
+	error: any;
+	warning: any;
+	custom_button_click: { id: number };
+}