initial commit log 🪵🦫

.gitattributes

@@ -0,0 +1,9 @@
+*.png filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+*.ico filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,53 @@
+# secret codes
+lib/config/secrets.dart
+run_locally_with_secrets.sh
+
+# Python venv
+.python_venv/
+
+# Miscellaneous
+*.class
+*.log
+*.pyc
+*.swp
+.DS_Store
+.atom/
+.buildlog/
+.history
+.svn/
+migrate_working_dir/
+
+# IntelliJ related
+*.iml
+*.ipr
+*.iws
+.idea/
+
+# The .vscode folder contains launch configuration and tasks you configure in
+# VS Code which you may wish to be included in version control, so this line
+# is commented out by default.
+#.vscode/
+
+# Flutter/Dart/Pub related
+**/doc/api/
+**/ios/Flutter/.last_build_id
+.dart_tool/
+.flutter-plugins
+.flutter-plugins-dependencies
+.pub-cache/
+.pub/
+/build/
+!/build/web
+
+# Symbolication related
+app.*.symbols
+
+# Obfuscation related
+app.*.map.json
+
+# Android Studio will place build artifacts here
+/android/app/debug
+/android/app/profile
+/android/app/release
+
+/assets/config/

.metadata

@@ -0,0 +1,45 @@
+# This file tracks properties of this Flutter project.
+# Used by Flutter tool to assess capabilities and perform upgrades etc.
+#
+# This file should be version controlled and should not be manually edited.
+
+version:
+  revision: "dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668"
+  channel: "stable"
+
+project_type: app
+
+# Tracks metadata for the flutter migrate command
+migration:
+  platforms:
+    - platform: root
+      create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+      base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+    - platform: android
+      create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+      base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+    - platform: ios
+      create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+      base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+    - platform: linux
+      create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+      base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+    - platform: macos
+      create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+      base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+    - platform: web
+      create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+      base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+    - platform: windows
+      create_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+      base_revision: dec2ee5c1f98f8e84a7d5380c05eb8a3d0a81668
+
+  # User provided section
+
+  # List of Local paths (relative to this file) that should be
+  # ignored by the migrate tool.
+  #
+  # Files that are not part of the templates will be ignored by default.
+  unmanaged_files:
+    - 'lib/main.dart'
+    - 'ios/Runner.xcodeproj/project.pbxproj'

DEPLOYMENT.md

@@ -0,0 +1,73 @@
+
+## Deploying aitube2 to https://aitube.at
+
+Note: this document is meant for aitube administrators only, not the general public.
+
+Aitube is not an app/tool but a website, it is not designed to be cloned (technically you can, but since this is not a goal it is not documented).
+
+### Setup the domain
+
+TODO
+
+### Seting up the Python virtual environment
+
+```bash
+python3 -m venv .python_venv
+source .python_venv/bin/activate
+python3 -m pip install --no-cache-dir --upgrade -r requirements.txt 
+```
+
+### Deployment to production
+
+To deploy the aitube2 api to production:
+
+    $ git push space main
+
+To deploy the aitube2 client to production, simply run:
+
+    $ flutter run web
+
+and upload the assets to:
+
+    https://huggingface.co/spaces/jbilcke-hf/aitube2/tree/main/public
+
+#### Running a rendering node
+
+Current aitube uses `jbilcke-hf/LTX-Video-0-9-6-HFIE` as a rendering node.
+
+aitube uses a round-robin schedule implemented on the gateway.
+This helps ensuring a smooth attribution of requests.
+
+What works well is to use the target number of users in parallel (eg. 3) and use 50% more capability to make sure we can handle the load, so in this case about 5 servers.
+
+```bash
+# note: you need to replace <YOUR_ACCOUNT_NAME>, <ROUND_ROBIN_INDEX> and <YOUR_HF_TOKEN>
+
+curl https://api.endpoints.huggingface.cloud/v2/endpoint/<YOUR_ACCOUNT_NAME> 	-X POST 	-d '{"cacheHttpResponses":false,"compute":{"accelerator":"gpu","instanceSize":"x1","instanceType":"nvidia-l40s","scaling":{"maxReplica":1,"measure":{"hardwareUsage":80},"minReplica":0,"scaleToZeroTimeout":120,"metric":"hardwareUsage"}},"model":{"env":{},"framework":"custom","image":{"huggingface":{}},"repository":"jbilcke-hf/LTX-Video-0-9-6-HFIE","secrets":{},"task":"custom","fromCatalog":false},"name":"ltx-video-0-9-6-round-robin-<ROUND_ROBIN_INDEX>","provider":{"region":"us-east-1","vendor":"aws"},"tags":[""],"type":"protected"}' 	-H "Content-Type: application/json" 	-H "Authorization: Bearer <YOUR_HF_TOKEN>"
+```
+
+#### Running the gateway scheduler
+
+```bash
+# load the environment
+# (if you haven't done it already for this shell session)
+source .python_venv/bin/activate
+
+HF_TOKEN="<USE YOUR OWN TOKEN>" \
+    SECRET_TOKEN="<USE YOUR OWN TOKEN>" \
+    VIDEO_ROUND_ROBIN_SERVER_1="https:/<USE YOUR OWN SERVER>.endpoints.huggingface.cloud" \
+    VIDEO_ROUND_ROBIN_SERVER_2="https://<USE YOUR OWN SERVER>.endpoints.huggingface.cloud" \
+    VIDEO_ROUND_ROBIN_SERVER_3="https://<USE YOUR OWN SERVER>.endpoints.huggingface.cloud" \
+    VIDEO_ROUND_ROBIN_SERVER_4="https://<USE YOUR OWN SERVER>.endpoints.huggingface.cloud" \
+    HF_IMAGE_MODEL="https://<USE YOUR OWN SERVER>.endpoints.huggingface.cloud" \
+    HF_TEXT_MODEL="https://<USE YOUR OWN SERVER>.endpoints.huggingface.cloud" \
+    python3 api.py
+```
+
+### Run the client (web)
+
+```bash
+
+flutter run --dart-define=CONFIG_PATH=assets/config/aitube_low.yaml -d chrome
+```
+

Dockerfile

@@ -0,0 +1,52 @@
+FROM nvidia/cuda:12.4.0-devel-ubuntu22.04
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+ENV PYTHONUNBUFFERED=1
+
+RUN apt-get update && apt-get install --no-install-recommends -y \
+  build-essential \
+  python3.11 \
+  python3-pip \
+  python3-dev \
+  git \
+  curl \
+  ffmpeg \
+  libglib2.0-0 \
+  libsm6 \
+  libxrender1 \
+  libxext6 \
+  && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+# Switch to the "user" user
+USER user
+# Set home to the user's home directory
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+# Set home to the user's home directory
+ENV PYTHONPATH=$HOME/app \
+  PYTHONUNBUFFERED=1 \
+  DATA_ROOT=/tmp/data
+
+RUN echo "Installing requirements.txt"
+RUN pip3 install --no-cache-dir --upgrade -r /code/requirements.txt
+
+# yeah.. this is manual for now
+#RUN flutter build web
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+EXPOSE 8080
+
+ENV PORT 8080
+
+CMD python3 api.py

README.md

@@ -0,0 +1,48 @@
+---
+title: aitube2
+emoji: 🎥
+colorFrom: red
+colorTo: yellow
+sdk: docker
+app_file: api.py
+pinned: true
+short_description: A Latent YouTube
+---
+
+
+# AiTube2
+
+## News
+
+aitube2 is coming sooner than expected!
+
+Stay hooked at @flngr on X!
+
+
+## What is AiTube?
+
+AiTube 2 is a reboot of [AiTube 1](https://x.com/danielpikl/status/1737882643625078835), a project made in 2023 which generated AI videos in the background using LLM agents, to simulate an AI generated YouTube.
+
+In [AiTube 2](https://x.com/flngr/status/1864127796945011016), this concept is put upside down: now the content is generated on demand (when the user types something in the latent search input) and on the fly (video chunks are generated within a few seconds and streamed continuously).
+
+This allows for new ways of consuming AI generated content, such as collaborative and interactive prompting.
+
+# Where can I use it?
+
+AiTube 2 is not ready yet: this is an experimental side project and the [platform](https://aitube.at), code and documentation will be in development for most of 2025.
+
+# Why can't I use it?
+
+As this is a personal project I only have limited ressources to develop it on the side, but there are also technological bottlenecks.
+
+Right now it is not economically viable to operate a platform like AiTube, it requires hardware that is too expensive and/or not powerful enough to give an enjoyable and reactive streaming experience.
+
+I am evaluating various options to make it available sooner for people with the financial ressources to try it, such as creating a system to deploy render nodes to Hugging Face, GPU-on-demand blockchains.. etc.
+
+# When can I use it?
+
+I estimate it will take up to 1 to 2 years for more powerful and/or cheaper hardware to become available.
+
+I already have a open-source prototype of AiTube which I use for R&D, based on free (as in "can run on your own machine") AI video models that can run fast with low quality settings (such as LTX Video).
+
+It's not representative of the final experience, but that's a start and I use that as a basis to imagine the experiences of the future (collaborative generation, broadcasted live streams, interactive gaming, and artistic experiences that are hybrid between video and gaming).

analysis_options.yaml

@@ -0,0 +1,28 @@
+# This file configures the analyzer, which statically analyzes Dart code to
+# check for errors, warnings, and lints.
+#
+# The issues identified by the analyzer are surfaced in the UI of Dart-enabled
+# IDEs (https://dart.dev/tools#ides-and-editors). The analyzer can also be
+# invoked from the command line by running `flutter analyze`.
+
+# The following line activates a set of recommended lints for Flutter apps,
+# packages, and plugins designed to encourage good coding practices.
+include: package:flutter_lints/flutter.yaml
+
+linter:
+  # The lint rules applied to this project can be customized in the
+  # section below to disable rules from the `package:flutter_lints/flutter.yaml`
+  # included above or to enable additional rules. A list of all available lints
+  # and their documentation is published at https://dart.dev/lints.
+  #
+  # Instead of disabling a lint rule for the entire project in the
+  # section below, it can also be suppressed for a single line of code
+  # or a specific dart file by using the `// ignore: name_of_lint` and
+  # `// ignore_for_file: name_of_lint` syntax on the line or in the file
+  # producing the lint.
+  rules:
+    # avoid_print: false  # Uncomment to disable the `avoid_print` rule
+    # prefer_single_quotes: true  # Uncomment to enable the `prefer_single_quotes` rule
+
+# Additional information about this file can be found at
+# https://dart.dev/guides/language/analysis-options

android/.gitignore

@@ -0,0 +1,13 @@
+gradle-wrapper.jar
+/.gradle
+/captures/
+/gradlew
+/gradlew.bat
+/local.properties
+GeneratedPluginRegistrant.java
+
+# Remember to never publicly share your keystore.
+# See https://flutter.dev/to/reference-keystore
+key.properties
+**/*.keystore
+**/*.jks

android/app/build.gradle

@@ -0,0 +1,44 @@
+plugins {
+    id "com.android.application"
+    id "kotlin-android"
+    // The Flutter Gradle Plugin must be applied after the Android and Kotlin Gradle plugins.
+    id "dev.flutter.flutter-gradle-plugin"
+}
+
+android {
+    namespace = "com.example.aitube2"
+    compileSdk = flutter.compileSdkVersion
+    ndkVersion = flutter.ndkVersion
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+
+    kotlinOptions {
+        jvmTarget = JavaVersion.VERSION_1_8
+    }
+
+    defaultConfig {
+        // TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html).
+        applicationId = "com.example.aitube2"
+        // You can update the following values to match your application needs.
+        // For more information, see: https://flutter.dev/to/review-gradle-config.
+        minSdk = flutter.minSdkVersion
+        targetSdk = flutter.targetSdkVersion
+        versionCode = flutter.versionCode
+        versionName = flutter.versionName
+    }
+
+    buildTypes {
+        release {
+            // TODO: Add your own signing config for the release build.
+            // Signing with the debug keys for now, so `flutter run --release` works.
+            signingConfig = signingConfigs.debug
+        }
+    }
+}
+
+flutter {
+    source = "../.."
+}

android/app/src/debug/AndroidManifest.xml

@@ -0,0 +1,7 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- The INTERNET permission is required for development. Specifically,
+         the Flutter tool needs it to communicate with the running application
+         to allow setting breakpoints, to provide hot reload, etc.
+    -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+</manifest>

android/app/src/main/AndroidManifest.xml

@@ -0,0 +1,45 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <application
+        android:label="aitube2"
+        android:name="${applicationName}"
+        android:icon="@mipmap/ic_launcher">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true"
+            android:launchMode="singleTop"
+            android:taskAffinity=""
+            android:theme="@style/LaunchTheme"
+            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|smallestScreenSize|locale|layoutDirection|fontScale|screenLayout|density|uiMode"
+            android:hardwareAccelerated="true"
+            android:windowSoftInputMode="adjustResize">
+            <!-- Specifies an Android theme to apply to this Activity as soon as
+                 the Android process has started. This theme is visible to the user
+                 while the Flutter UI initializes. After that, this theme continues
+                 to determine the Window background behind the Flutter UI. -->
+            <meta-data
+              android:name="io.flutter.embedding.android.NormalTheme"
+              android:resource="@style/NormalTheme"
+              />
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+                <category android:name="android.intent.category.LAUNCHER"/>
+            </intent-filter>
+        </activity>
+        <!-- Don't delete the meta-data below.
+             This is used by the Flutter tool to generate GeneratedPluginRegistrant.java -->
+        <meta-data
+            android:name="flutterEmbedding"
+            android:value="2" />
+    </application>
+    <!-- Required to query activities that can process text, see:
+         https://developer.android.com/training/package-visibility and
+         https://developer.android.com/reference/android/content/Intent#ACTION_PROCESS_TEXT.
+
+         In particular, this is used by the Flutter engine in io.flutter.plugin.text.ProcessTextPlugin. -->
+    <queries>
+        <intent>
+            <action android:name="android.intent.action.PROCESS_TEXT"/>
+            <data android:mimeType="text/plain"/>
+        </intent>
+    </queries>
+</manifest>

android/app/src/main/kotlin/com/example/aitube2/MainActivity.kt

@@ -0,0 +1,5 @@
+package com.example.aitube2
+
+import io.flutter.embedding.android.FlutterActivity
+
+class MainActivity: FlutterActivity()

android/app/src/main/res/drawable-v21/launch_background.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Modify this file to customize your launch splash screen -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="?android:colorBackground" />
+
+    <!-- You can insert your own image assets here -->
+    <!-- <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@mipmap/launch_image" />
+    </item> -->
+</layer-list>

android/app/src/main/res/drawable/launch_background.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Modify this file to customize your launch splash screen -->
+<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:drawable="@android:color/white" />
+
+    <!-- You can insert your own image assets here -->
+    <!-- <item>
+        <bitmap
+            android:gravity="center"
+            android:src="@mipmap/launch_image" />
+    </item> -->
+</layer-list>

android/app/src/main/res/values-night/styles.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Theme applied to the Android Window while the process is starting when the OS's Dark Mode setting is on -->
+    <style name="LaunchTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <!-- Show a splash screen on the activity. Automatically removed when
+             the Flutter engine draws its first frame -->
+        <item name="android:windowBackground">@drawable/launch_background</item>
+    </style>
+    <!-- Theme applied to the Android Window as soon as the process has started.
+         This theme determines the color of the Android Window while your
+         Flutter UI initializes, as well as behind your Flutter UI while its
+         running.
+
+         This Theme is only used starting with V2 of Flutter's Android embedding. -->
+    <style name="NormalTheme" parent="@android:style/Theme.Black.NoTitleBar">
+        <item name="android:windowBackground">?android:colorBackground</item>
+    </style>
+</resources>

android/app/src/main/res/values/styles.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- Theme applied to the Android Window while the process is starting when the OS's Dark Mode setting is off -->
+    <style name="LaunchTheme" parent="@android:style/Theme.Light.NoTitleBar">
+        <!-- Show a splash screen on the activity. Automatically removed when
+             the Flutter engine draws its first frame -->
+        <item name="android:windowBackground">@drawable/launch_background</item>
+    </style>
+    <!-- Theme applied to the Android Window as soon as the process has started.
+         This theme determines the color of the Android Window while your
+         Flutter UI initializes, as well as behind your Flutter UI while its
+         running.
+
+         This Theme is only used starting with V2 of Flutter's Android embedding. -->
+    <style name="NormalTheme" parent="@android:style/Theme.Light.NoTitleBar">
+        <item name="android:windowBackground">?android:colorBackground</item>
+    </style>
+</resources>

android/app/src/profile/AndroidManifest.xml

@@ -0,0 +1,7 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <!-- The INTERNET permission is required for development. Specifically,
+         the Flutter tool needs it to communicate with the running application
+         to allow setting breakpoints, to provide hot reload, etc.
+    -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+</manifest>

android/build.gradle

@@ -0,0 +1,18 @@
+allprojects {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.buildDir = "../build"
+subprojects {
+    project.buildDir = "${rootProject.buildDir}/${project.name}"
+}
+subprojects {
+    project.evaluationDependsOn(":app")
+}
+
+tasks.register("clean", Delete) {
+    delete rootProject.buildDir
+}

android/gradle.properties

@@ -0,0 +1,3 @@
+org.gradle.jvmargs=-Xmx4G -XX:MaxMetaspaceSize=2G -XX:+HeapDumpOnOutOfMemoryError
+android.useAndroidX=true
+android.enableJetifier=true

android/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-all.zip

android/settings.gradle

@@ -0,0 +1,25 @@
+pluginManagement {
+    def flutterSdkPath = {
+        def properties = new Properties()
+        file("local.properties").withInputStream { properties.load(it) }
+        def flutterSdkPath = properties.getProperty("flutter.sdk")
+        assert flutterSdkPath != null, "flutter.sdk not set in local.properties"
+        return flutterSdkPath
+    }()
+
+    includeBuild("$flutterSdkPath/packages/flutter_tools/gradle")
+
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+plugins {
+    id "dev.flutter.flutter-plugin-loader" version "1.0.0"
+    id "com.android.application" version "8.1.0" apply false
+    id "org.jetbrains.kotlin.android" version "1.8.22" apply false
+}
+
+include ":app"

api.py

@@ -0,0 +1,445 @@
+import asyncio
+import json
+import logging
+import os
+import pathlib
+from aiohttp import web, WSMsgType
+from typing import Dict, Any
+from api_core import VideoGenerationAPI
+
+from api_config import *
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+async def process_generic_request(data: dict, ws: web.WebSocketResponse, api) -> None:
+    """Handle general requests that don't fit into specialized queues"""
+    try:
+        request_id = data.get('requestId')
+        action = data.get('action')
+        
+        def error_response(message: str):
+            return {
+                'action': action,
+                'requestId': request_id,
+                'success': False,
+                'error': message
+            }
+
+        if action == 'heartbeat':
+            # Include user role info in heartbeat response
+            user_role = getattr(ws, 'user_role', 'anon')
+            await ws.send_json({
+                'action': 'heartbeat',
+                'requestId': request_id,
+                'success': True,
+                'user_role': user_role
+            })
+        
+        elif action == 'get_user_role':
+            # Return the user role information
+            user_role = getattr(ws, 'user_role', 'anon')
+            await ws.send_json({
+                'action': 'get_user_role',
+                'requestId': request_id,
+                'success': True,
+                'user_role': user_role
+            })
+        
+        elif action == 'generate_caption':
+            title = data.get('params', {}).get('title')
+            description = data.get('params', {}).get('description')
+            
+            if not title or not description:
+                await ws.send_json(error_response('Missing title or description'))
+                return
+                
+            caption = await api.generate_caption(title, description)
+            await ws.send_json({
+                'action': action,
+                'requestId': request_id,
+                'success': True,
+                'caption': caption
+            })
+            
+        elif action == 'generate_thumbnail':
+            title = data.get('params', {}).get('title')
+            description = data.get('params', {}).get('description')
+            
+            if not title or not description:
+                await ws.send_json(error_response('Missing title or description'))
+                return
+                
+            thumbnail = await api.generate_thumbnail(title, description)
+            await ws.send_json({
+                'action': action,
+                'requestId': request_id,
+                'success': True,
+                'thumbnailUrl': thumbnail
+            })
+            
+        else:
+            await ws.send_json(error_response(f'Unknown action: {action}'))
+            
+    except Exception as e:
+        logger.error(f"Error processing generic request: {str(e)}")
+        try:
+            await ws.send_json({
+                'action': data.get('action'),
+                'requestId': data.get('requestId'),
+                'success': False,
+                'error': f'Internal server error: {str(e)}'
+            })
+        except Exception as send_error:
+            logger.error(f"Error sending error response: {send_error}")
+
+async def process_search_queue(queue: asyncio.Queue, ws: web.WebSocketResponse, api):
+    """Medium priority queue for search operations"""
+    while True:
+        try:
+            data = await queue.get()
+            request_id = data.get('requestId')
+            query = data.get('query', '').strip()
+            search_count = data.get('searchCount', 0)
+            attempt_count = data.get('attemptCount', 0)
+
+            logger.info(f"Processing search request: query='{query}', search_count={search_count}, attempt={attempt_count}")
+
+            if not query:
+                logger.warning(f"Empty query received in request: {data}")
+                result = {
+                    'action': 'search',
+                    'requestId': request_id,
+                    'success': False,
+                    'error': 'No search query provided'
+                }
+            else:
+                try:
+                    search_result = await api.search_video(
+                        query,
+                        search_count=search_count,
+                        attempt_count=attempt_count
+                    )
+                    
+                    if search_result:
+                        logger.info(f"Search successful for query '{query}' (#{search_count})")
+                        result = {
+                            'action': 'search',
+                            'requestId': request_id,
+                            'success': True,
+                            'result': search_result
+                        }
+                    else:
+                        logger.warning(f"No results found for query '{query}' (#{search_count})")
+                        result = {
+                            'action': 'search',
+                            'requestId': request_id,
+                            'success': False,
+                            'error': 'No results found'
+                        }
+                except Exception as e:
+                    logger.error(f"Search error for query '{query}' (#{search_count}, attempt {attempt_count}): {str(e)}")
+                    result = {
+                        'action': 'search',
+                        'requestId': request_id,
+                        'success': False,
+                        'error': f'Search error: {str(e)}'
+                    }
+
+            await ws.send_json(result)
+            
+        except Exception as e:
+            logger.error(f"Error in search queue processor: {str(e)}")
+            try:
+                error_response = {
+                    'action': 'search',
+                    'requestId': data.get('requestId') if 'data' in locals() else None,
+                    'success': False,
+                    'error': f'Internal server error: {str(e)}'
+                }
+                await ws.send_json(error_response)
+            except Exception as send_error:
+                logger.error(f"Error sending error response: {send_error}")
+        finally:
+            if 'queue' in locals():
+                queue.task_done()
+
+async def process_chat_queue(queue: asyncio.Queue, ws: web.WebSocketResponse):
+    """High priority queue for chat operations"""
+    while True:
+        data = await queue.get()
+        try:
+            api = ws.app['api']
+            if data['action'] == 'join_chat':
+                result = await api.handle_join_chat(data, ws)
+            elif data['action'] == 'chat_message':
+                result = await api.handle_chat_message(data, ws)
+            elif data['action'] == 'leave_chat':
+                result = await api.handle_leave_chat(data, ws)
+            await ws.send_json(result)
+        except Exception as e:
+            logger.error(f"Error processing chat request: {e}")
+            try:
+                await ws.send_json({
+                    'action': data['action'],
+                    'requestId': data.get('requestId'),
+                    'success': False,
+                    'error': f'Chat error: {str(e)}'
+                })
+            except Exception as send_error:
+                logger.error(f"Error sending error response: {send_error}")
+        finally:
+            queue.task_done()
+
+async def process_video_queue(queue: asyncio.Queue, ws: web.WebSocketResponse):
+    """Process multiple video generation requests in parallel"""
+    active_tasks = set()
+    MAX_CONCURRENT = len(VIDEO_ROUND_ROBIN_ENDPOINT_URLS)  # Match client's max concurrent generations
+
+    async def process_single_request(data):
+        try:
+            api = ws.app['api']
+            title = data.get('title', '')
+            description = data.get('description', '')
+            video_prompt_prefix = data.get('video_prompt_prefix', '')
+            options = data.get('options', {})
+            
+            # Get the user role from the websocket
+            user_role = getattr(ws, 'user_role', 'anon')
+            
+            # Pass the user role to generate_video
+            video_data = await api.generate_video(title, description, video_prompt_prefix, options, user_role)
+            
+            result = {
+                'action': 'generate_video',
+                'requestId': data.get('requestId'),
+                'success': True,
+                'video': video_data,
+            }
+            
+            await ws.send_json(result)
+            
+        except Exception as e:
+            logger.error(f"Error processing video request: {e}")
+            try:
+                await ws.send_json({
+                    'action': 'generate_video',
+                    'requestId': data.get('requestId'),
+                    'success': False,
+                    'error': f'Video generation error: {str(e)}'
+                })
+            except Exception as send_error:
+                logger.error(f"Error sending error response: {send_error}")
+        finally:
+            active_tasks.discard(asyncio.current_task())
+
+    while True:
+        # Clean up completed tasks
+        active_tasks = {task for task in active_tasks if not task.done()}
+        
+        # Start new tasks if we have capacity
+        while len(active_tasks) < MAX_CONCURRENT:
+            try:
+                # Use try_get to avoid blocking if queue is empty
+                data = await asyncio.wait_for(queue.get(), timeout=0.1)
+                
+                # Create and start new task
+                task = asyncio.create_task(process_single_request(data))
+                active_tasks.add(task)
+                
+            except asyncio.TimeoutError:
+                # No items in queue, break inner loop
+                break
+            except Exception as e:
+                logger.error(f"Error creating video generation task: {e}")
+                break
+
+        # Wait a short time before checking queue again
+        await asyncio.sleep(0.1)
+
+        # Handle any completed tasks' errors
+        for task in list(active_tasks):
+            if task.done():
+                try:
+                    await task
+                except Exception as e:
+                    logger.error(f"Task failed with error: {e}")
+                active_tasks.discard(task)
+
+async def status_handler(request: web.Request) -> web.Response:
+    """Handler for API status endpoint"""
+    api = request.app['api']
+    return web.json_response({
+        'product': PRODUCT_NAME,
+        'version': '0.1.0',
+        'maintenance_mode': MAINTENANCE_MODE,
+        'available_endpoints': len(VIDEO_ROUND_ROBIN_ENDPOINT_URLS)
+    })
+
+async def websocket_handler(request: web.Request) -> web.WebSocketResponse:
+    # Check if maintenance mode is enabled
+    if MAINTENANCE_MODE:
+        # Return an error response indicating maintenance mode
+        return web.json_response({
+            'error': 'Server is in maintenance mode',
+            'maintenance': True
+        }, status=503)  # 503 Service Unavailable
+    
+    ws = web.WebSocketResponse(
+        max_msg_size=1024*1024*10,  # 10MB max message size
+        timeout=30.0  # we want to keep things tight and short
+    )
+    
+    ws.app = request.app
+    await ws.prepare(request)
+    api = request.app['api']
+    
+    # Get the Hugging Face token from query parameters
+    hf_token = request.query.get('hf_token', '')
+    
+    # Validate the token and determine the user role
+    user_role = await api.validate_user_token(hf_token)
+    logger.info(f"User connected with role: {user_role}")
+    
+    # Store the user role in the websocket
+    ws.user_role = user_role
+
+    # Create separate queues for different request types
+    chat_queue = asyncio.Queue()
+    video_queue = asyncio.Queue()
+    search_queue = asyncio.Queue()
+    
+    # Start background tasks for handling different request types
+    background_tasks = [
+        asyncio.create_task(process_chat_queue(chat_queue, ws)),
+        asyncio.create_task(process_video_queue(video_queue, ws)),
+        asyncio.create_task(process_search_queue(search_queue, ws, api))
+    ]
+
+    try:
+        async for msg in ws:
+            if msg.type == WSMsgType.TEXT:
+                try:
+                    data = json.loads(msg.data)
+                    action = data.get('action')
+                    
+                    # Route requests to appropriate queues
+                    if action in ['join_chat', 'leave_chat', 'chat_message']:
+                        await chat_queue.put(data)
+                    elif action in ['generate_video']:
+                        await video_queue.put(data)
+                    elif action == 'search':
+                        await search_queue.put(data)
+                    else:
+                        await process_generic_request(data, ws, api)
+                        
+                except Exception as e:
+                    logger.error(f"Error processing WebSocket message: {str(e)}")
+                    await ws.send_json({
+                        'action': data.get('action') if 'data' in locals() else 'unknown',
+                        'success': False,
+                        'error': f'Error processing message: {str(e)}'
+                    })
+                    
+            elif msg.type in (WSMsgType.ERROR, WSMsgType.CLOSE):
+                break
+                
+    finally:
+        # Cleanup
+        for task in background_tasks:
+            task.cancel()
+        try:
+            await asyncio.gather(*background_tasks, return_exceptions=True)
+        except asyncio.CancelledError:
+            pass
+    
+    return ws
+
+async def init_app() -> web.Application:
+    app = web.Application(
+        client_max_size=1024**2*10  # 10MB max size
+    )
+    
+    # Create API instance
+    api = VideoGenerationAPI()
+    app['api'] = api
+    
+    # Add cleanup logic
+    async def cleanup_api(app):
+        # Add any necessary cleanup for the API
+        pass
+    
+    app.on_shutdown.append(cleanup_api)
+    
+    # Add routes
+    app.router.add_get('/ws', websocket_handler)
+    app.router.add_get('/api/status', status_handler)
+    
+    # Set up static file serving
+    # Define the path to the public directory
+    public_path = pathlib.Path(__file__).parent / 'build' / 'web'
+    if not public_path.exists():
+        public_path.mkdir(parents=True, exist_ok=True)
+    
+    # Set up static file serving with proper security considerations
+    async def static_file_handler(request):
+        # Get the path from the request (removing leading /)
+        path_parts = request.path.lstrip('/').split('/')
+        
+        # Convert to safe path to prevent path traversal attacks
+        safe_path = public_path.joinpath(*path_parts)
+        
+        # Make sure the path is within the public directory (prevent directory traversal)
+        try:
+            safe_path = safe_path.resolve()
+            if not str(safe_path).startswith(str(public_path.resolve())):
+                return web.HTTPForbidden(text="Access denied")
+        except (ValueError, FileNotFoundError):
+            return web.HTTPNotFound()
+        
+        # If path is a directory, look for index.html
+        if safe_path.is_dir():
+            safe_path = safe_path / 'index.html'
+        
+        # Check if the file exists
+        if not safe_path.exists() or not safe_path.is_file():
+            # If not found, serve index.html (for SPA routing)
+            safe_path = public_path / 'index.html'
+            if not safe_path.exists():
+                return web.HTTPNotFound()
+        
+        # Determine content type based on file extension
+        content_type = 'text/plain'
+        ext = safe_path.suffix.lower()
+        if ext == '.html':
+            content_type = 'text/html'
+        elif ext == '.js':
+            content_type = 'application/javascript'
+        elif ext == '.css':
+            content_type = 'text/css'
+        elif ext in ('.jpg', '.jpeg'):
+            content_type = 'image/jpeg'
+        elif ext == '.png':
+            content_type = 'image/png'
+        elif ext == '.gif':
+            content_type = 'image/gif'
+        elif ext == '.svg':
+            content_type = 'image/svg+xml'
+        elif ext == '.json':
+            content_type = 'application/json'
+        
+        # Return the file with appropriate headers
+        return web.FileResponse(safe_path, headers={'Content-Type': content_type})
+    
+    # Add catch-all route for static files (lower priority than API routes)
+    app.router.add_get('/{path:.*}', static_file_handler)
+    
+    return app
+
+if __name__ == '__main__':
+    app = asyncio.run(init_app())
+    web.run_app(app, host='0.0.0.0', port=8080)

api_config.py

@@ -0,0 +1,184 @@
+import os
+
+PRODUCT_NAME = os.environ.get('PRODUCT_NAME', 'AiTube')
+
+TEXT_MODEL = os.environ.get('HF_TEXT_MODEL',
+    #'HuggingFaceH4/zephyr-7b-beta'
+    'HuggingFaceTB/SmolLM2-1.7B-Instruct'
+)
+
+IMAGE_MODEL = os.environ.get('HF_IMAGE_MODEL', '')
+
+# Environment variable to control maintenance mode
+MAINTENANCE_MODE = os.environ.get('MAINTENANCE_MODE', 'false').lower() in ('true', 'yes', '1', 't')
+
+ADMIN_ACCOUNTS = [
+    "jbilcke-hf"
+]
+
+RAW_VIDEO_ROUND_ROBIN_ENDPOINT_URLS = [
+    os.environ.get('VIDEO_ROUND_ROBIN_SERVER_1', ''),
+    os.environ.get('VIDEO_ROUND_ROBIN_SERVER_2', ''),
+    os.environ.get('VIDEO_ROUND_ROBIN_SERVER_3', ''),
+    os.environ.get('VIDEO_ROUND_ROBIN_SERVER_4', ''),
+]
+
+# Filter out empty strings from the endpoint list
+VIDEO_ROUND_ROBIN_ENDPOINT_URLS = [url for url in RAW_VIDEO_ROUND_ROBIN_ENDPOINT_URLS if url]
+
+HF_TOKEN = os.environ.get('HF_TOKEN')
+
+# use the same secret token as you used to secure your BASE_SPACE_NAME spaces
+SECRET_TOKEN = os.environ.get('SECRET_TOKEN')
+
+# altenative words we could use: "saturated, highlight, overexposed, highlighted, overlit, shaking, too bright, worst quality, inconsistent motion, blurry, jittery, distorted, cropped, watermarked, watermark, logo, subtitle, subtitles, lowres"
+NEGATIVE_PROMPT = "low quality, worst quality, deformed, distorted, disfigured, blurry, text, watermark"
+
+POSITIVE_PROMPT_SUFFIX = "high quality, cinematic, 4K, intricate details"
+
+GUIDANCE_SCALE = 1.0
+
+# anonymous users are people browing AiTube2 without being connected
+# this category suffers from regular abuse so we need to enforce strict limitations
+CONFIG_FOR_ANONYMOUS_USERS = {
+
+    # anons can only watch 2 minutes per video
+    "max_rendering_time_per_client_per_video_in_sec": 2 * 60,
+
+    "max_buffer_size": 2,
+    "max_concurrent_generations": 2,
+
+    "min_num_inference_steps": 2,
+    "default_num_inference_steps": 2,
+    "max_num_inference_steps": 4,
+
+    "min_num_frames": 9, # 8 + 1
+    "default_max_num_frames": 65, # 8*8 + 1
+    "max_num_frames": 65, # 8*8 + 1
+
+    "min_clip_duration_seconds": 1,
+    "default_clip_duration_seconds": 2,
+    "max_clip_duration_seconds": 2,
+
+    "min_clip_playback_speed": 0.5,
+    "default_clip_playback_speed": 0.5,
+    "max_clip_playback_speed": 0.5,
+
+    "min_clip_framerate": 8,
+    "default_clip_framerate": 16,
+    "max_clip_framerate": 16,
+
+    "min_clip_width": 544,
+    "default_clip_width": 544,
+    "max_clip_width": 544,
+
+    "min_clip_height": 320,
+    "default_clip_height": 320,
+    "max_clip_height": 320,
+}
+
+# Hugging Face users enjoy a more normal and calibrated experience
+CONFIG_FOR_STANDARD_HF_USERS = {
+    "max_rendering_time_per_client_per_video_in_sec": 15 * 60,
+
+    "max_buffer_size": 2,
+    "max_concurrent_generations": 2,
+
+    "min_num_inference_steps": 2,
+    "default_num_inference_steps": 4,
+    "max_num_inference_steps": 6,
+    
+    "min_num_frames": 9, # 8 + 1
+    "default_num_frames": 65, # 8*8 + 1
+    "max_num_frames": 65, # 8*8 + 1
+
+    "min_clip_duration_seconds": 1,
+    "default_clip_duration_seconds": 2,
+    "max_clip_duration_seconds": 2,
+
+    "min_clip_playback_speed": 0.5,
+    "default_clip_playback_speed": 0.7,
+    "max_clip_playback_speed": 0.7,
+
+    "min_clip_framerate": 8,
+    "default_clip_framerate": 25,
+    "max_clip_framerate": 25,
+
+    "min_clip_width": 544,
+    "default_clip_width": 640,
+    "max_clip_width": 640,
+
+    "min_clip_height": 320,
+    "default_clip_height": 416,
+    "max_clip_height": 416,
+}
+
+# Hugging Face users with a Pro may enjoy an improved experience
+CONFIG_FOR_PRO_HF_USERS = {
+    "max_rendering_time_per_client_per_video_in_sec": 20 * 60,
+
+    "max_buffer_size": 2,
+    "max_concurrent_generations": 2,
+    
+    "min_num_inference_steps": 2,
+    "max_num_inference_steps": 8,
+
+    "min_num_frames": 9, # 8 + 1
+    "default_num_frames": 97, # (8*12) + 1
+    "max_num_frames": 97, # (8*12) + 1
+
+    "min_clip_duration_seconds": 1, 
+    "default_clip_duration_seconds": 2,
+    "max_clip_duration_seconds": 3,
+
+    "min_clip_playback_speed": 0.5,
+    "default_clip_playback_speed": 0.8,
+    "max_clip_playback_speed": 0.8,
+
+    "min_clip_framerate": 8,
+    "default_clip_framerate": 25,
+    "max_clip_framerate": 30,
+
+    "min_clip_width": 544,
+    "default_clip_width": 768,
+    "max_clip_width": 768,
+
+    "min_clip_height": 320,
+    "default_clip_height": 480,
+    "max_clip_height": 480,
+}
+
+CONFIG_FOR_ADMIN_HF_USERS = {
+    "max_rendering_time_per_client_per_video_in_sec": 60 * 60,
+
+    "max_buffer_size": 2,
+    "max_concurrent_generations": 2,
+    
+    "min_num_inference_steps": 2,
+    "default_num_inference_steps": 4,
+    "max_num_inference_steps": 8,
+
+    "min_num_frames": 9, # 8 + 1
+    "default_num_frames": 65, # (8 * 8) + 1
+    "max_num_frames": 129, # (8 * 16) + 1
+
+    "min_clip_duration_seconds": 1,
+    "default_clip_duration_seconds": 2,
+    "max_clip_duration_seconds": 4,
+
+    "min_clip_playback_speed": 0.5,
+    "default_clip_playback_speed": 0.8,
+    "max_clip_playback_speed": 0.9,
+
+    "min_clip_framerate": 8,
+    "default_clip_framerate": 30,
+    "max_clip_framerate": 60,
+
+    "min_clip_width": 544,
+    "default_clip_width": 768,
+    "max_clip_width": 1216,
+
+    "min_clip_height": 320,
+    "default_clip_height": 480,
+    "max_clip_height": 704,
+}

api_core.py

@@ -0,0 +1,746 @@
+import logging
+import os
+import io
+import re
+import base64
+import uuid
+from typing import Dict, Any, Optional, List, Literal
+from dataclasses import dataclass
+from asyncio import Lock, Queue
+import asyncio
+import time
+import datetime
+from contextlib import asynccontextmanager
+from collections import defaultdict
+from aiohttp import web, ClientSession
+from huggingface_hub import InferenceClient, HfApi
+from gradio_client import Client
+import random
+import yaml
+import json
+
+from api_config import *
+
+# User role type
+UserRole = Literal['anon', 'normal', 'pro', 'admin']
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def generate_seed():
+    """Generate a random positive 32-bit integer seed."""
+    return random.randint(0, 2**32 - 1)
+
+def sanitize_yaml_response(response_text: str) -> str:
+    """
+    Sanitize and format AI response into valid YAML.
+    Returns properly formatted YAML string.
+    """
+
+    response_text = response_text.split("```")[0]
+
+    # Remove any markdown code block indicators and YAML document markers
+    clean_text = re.sub(r'```yaml|```|---|\.\.\.$', '', response_text.strip())
+    
+    # Split into lines and process each line
+    lines = clean_text.split('\n')
+    sanitized_lines = []
+    current_field = None
+    
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            continue
+            
+        # Handle field starts
+        if stripped.startswith('title:') or stripped.startswith('description:'):
+            # Ensure proper YAML format with space after colon and proper quoting
+            field_name = stripped.split(':', 1)[0]
+            field_value = stripped.split(':', 1)[1].strip().strip('"\'')
+            
+            # Quote the value if it contains special characters
+            if any(c in field_value for c in ':[]{},&*#?|-<>=!%@`'):
+                field_value = f'"{field_value}"'
+                
+            sanitized_lines.append(f"{field_name}: {field_value}")
+            current_field = field_name
+            
+        elif stripped.startswith('tags:'):
+            sanitized_lines.append('tags:')
+            current_field = 'tags'
+            
+        elif stripped.startswith('-') and current_field == 'tags':
+            # Process tag values
+            tag = stripped[1:].strip().strip('"\'')
+            if tag:
+                # Clean and format tag
+                tag = re.sub(r'[^\x00-\x7F]+', '', tag)  # Remove non-ASCII
+                tag = re.sub(r'[^a-zA-Z0-9\s-]', '', tag)  # Keep only alphanumeric and hyphen
+                tag = tag.strip().lower().replace(' ', '-')
+                if tag:
+                    sanitized_lines.append(f"  - {tag}")
+                    
+        elif current_field in ['title', 'description']:
+            # Handle multi-line title/description continuation
+            value = stripped.strip('"\'')
+            if value:
+                # Append to previous line
+                prev = sanitized_lines[-1]
+                sanitized_lines[-1] = f"{prev} {value}"
+    
+    # Ensure the YAML has all required fields
+    required_fields = {'title', 'description', 'tags'}
+    found_fields = {line.split(':')[0].strip() for line in sanitized_lines if ':' in line}
+    
+    for field in required_fields - found_fields:
+        if field == 'tags':
+            sanitized_lines.extend(['tags:', '  - default'])
+        else:
+            sanitized_lines.append(f'{field}: "No {field} provided"')
+    
+    return '\n'.join(sanitized_lines)
+
+@dataclass
+class Endpoint:
+    id: int
+    url: str
+    busy: bool = False
+    last_used: float = 0
+
+class EndpointManager:
+    def __init__(self):
+        self.endpoints: List[Endpoint] = []
+        self.lock = Lock()
+        self.endpoint_queue: Queue[Endpoint] = Queue()
+        self.initialize_endpoints()
+
+    def initialize_endpoints(self):
+        """Initialize the list of endpoints"""
+        for i, url in enumerate(VIDEO_ROUND_ROBIN_ENDPOINT_URLS):
+            endpoint = Endpoint(id=i + 1, url=url)
+            self.endpoints.append(endpoint)
+            self.endpoint_queue.put_nowait(endpoint)
+
+    @asynccontextmanager
+    async def get_endpoint(self, max_wait_time: int = 10):
+        """Get the next available endpoint using a context manager"""
+        start_time = time.time()
+        endpoint = None
+        
+        try:
+            while True:
+                if time.time() - start_time > max_wait_time:
+                    raise TimeoutError(f"Could not acquire an endpoint within {max_wait_time} seconds")
+
+                try:
+                    endpoint = self.endpoint_queue.get_nowait()
+                    async with self.lock:
+                        if not endpoint.busy:
+                            endpoint.busy = True
+                            endpoint.last_used = time.time()
+                            break
+                        else:
+                            await self.endpoint_queue.put(endpoint)
+                except asyncio.QueueEmpty:
+                    await asyncio.sleep(0.5)
+                    continue
+
+            yield endpoint
+
+        finally:
+            if endpoint:
+                async with self.lock:
+                    endpoint.busy = False
+                    endpoint.last_used = time.time()
+                    await self.endpoint_queue.put(endpoint)
+
+class ChatRoom:
+    def __init__(self):
+        self.messages = []
+        self.connected_clients = set()
+        self.max_history = 100
+
+    def add_message(self, message):
+        self.messages.append(message)
+        if len(self.messages) > self.max_history:
+            self.messages.pop(0)
+
+    def get_recent_messages(self, limit=50):
+        return self.messages[-limit:]
+
+class VideoGenerationAPI:
+    def __init__(self):
+        self.inference_client = InferenceClient(token=HF_TOKEN)
+        self.hf_api = HfApi(token=HF_TOKEN)
+        self.endpoint_manager = EndpointManager()
+        self.active_requests: Dict[str, asyncio.Future] = {}
+        self.chat_rooms = defaultdict(ChatRoom)
+        self.video_events: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
+        self.event_history_limit = 50
+        # Cache for user roles to avoid repeated API calls
+        self.user_role_cache: Dict[str, Dict[str, Any]] = {}
+        # Cache expiration time (10 minutes)
+        self.cache_expiration = 600
+
+
+    def _add_event(self, video_id: str, event: Dict[str, Any]):
+        """Add an event to the video's history and maintain the size limit"""
+        events = self.video_events[video_id]
+        events.append(event)
+        if len(events) > self.event_history_limit:
+            events.pop(0)
+    
+    async def validate_user_token(self, token: str) -> UserRole:
+        """
+        Validates a Hugging Face token and determines the user's role.
+        
+        Returns one of:
+        - 'anon': Anonymous user (no token or invalid token)
+        - 'normal': Standard Hugging Face user
+        - 'pro': Hugging Face Pro user
+        - 'admin': Admin user (username in ADMIN_ACCOUNTS)
+        """
+        # If no token is provided, the user is anonymous
+        if not token:
+            return 'anon'
+        
+        # Check if we have a cached result for this token
+        current_time = time.time()
+        if token in self.user_role_cache:
+            cached_data = self.user_role_cache[token]
+            # If the cache is still valid
+            if current_time - cached_data['timestamp'] < self.cache_expiration:
+                logger.info(f"Using cached user role: {cached_data['role']}")
+                return cached_data['role']
+        
+        # No valid cache, need to check the token with the HF API
+        try:
+            # Use HF API to validate the token and get user info
+            logger.info("Validating Hugging Face token...")
+            
+            # Run in executor to avoid blocking the event loop
+            user_info = await asyncio.get_event_loop().run_in_executor(
+                None, 
+                lambda: self.hf_api.whoami(token=token)
+            )
+            
+            logger.info(f"Token valid for user: {user_info.name}")
+            
+            # Determine the user role based on the information
+            user_role: UserRole
+            
+            # Check if the user is an admin
+            if user_info.name in ADMIN_ACCOUNTS:
+                user_role = 'admin'
+            # Check if the user has a pro account
+            elif hasattr(user_info, 'is_pro') and user_info.is_pro:
+                user_role = 'pro'
+            else:
+                user_role = 'normal'
+            
+            # Cache the result
+            self.user_role_cache[token] = {
+                'role': user_role,
+                'timestamp': current_time,
+                'username': user_info.name
+            }
+            
+            return user_role
+            
+        except Exception as e:
+            logger.error(f"Failed to validate Hugging Face token: {str(e)}")
+            # If validation fails, the user is treated as anonymous
+            return 'anon'
+
+    async def download_video(self, url: str) -> bytes:
+        """Download video file from URL and return bytes"""
+        async with ClientSession() as session:
+            async with session.get(url) as response:
+                if response.status != 200:
+                    raise Exception(f"Failed to download video: HTTP {response.status}")
+                return await response.read()
+
+    async def search_video(self, query: str, search_count: int = 0, attempt_count: int = 0) -> Optional[dict]:
+        """Generate a single search result using HF text generation"""
+        prompt = f"""# Instruction
+Your response MUST be a YAML object containing a title, description, and tags, consistent with what we can find on a video sharing platform.
+Format your YAML response with only those fields: "title" (single string of a short sentence), "description" (single string of a few sentences to describe the visuals), and "tags" (array of strings). Do not add any other field.
+The description is a prompt for a generative AI, so please describe the visual elements of the scene in details, including: camera angle and focus, people's appearance, their age, actions, precise look, clothing, the location characteristics, lighting, action, objects, weather.
+Make the result unique and different from previous search results. ONLY RETURN YAML AND WITH ENGLISH CONTENT, NOT CHINESE - DO NOT ADD ANY OTHER COMMENT!
+
+# Context
+This is attempt {attempt_count} at generating search result number {search_count}.
+
+# Input
+Describe the video for this theme: "{query}".
+Don't forget to repeat singular elements about the characters, location.. in your description.
+
+# Output
+
+```yaml
+title: \""""
+
+        try:
+            print(f"search_video(): calling self.inference_client.text_generation({prompt}, model={TEXT_MODEL}, max_new_tokens=300, temperature=0.65)")
+            response = await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: self.inference_client.text_generation(
+                    prompt,
+                    model=TEXT_MODEL,
+                    max_new_tokens=300,
+                    temperature=0.6
+                )
+            )
+
+            #print("response: ", response)
+
+            response_text = re.sub(r'^\s*\.\s*\n', '', f"title: \"{response.strip()}")
+            sanitized_yaml = sanitize_yaml_response(response_text)
+            
+            try:
+                result = yaml.safe_load(sanitized_yaml)
+            except yaml.YAMLError as e:
+                logger.error(f"YAML parsing failed: {str(e)}")
+                result = None
+            
+            if not result or not isinstance(result, dict):
+                logger.error(f"Invalid result format: {result}")
+                return None
+
+            # Extract fields with defaults
+            title = str(result.get('title', '')).strip() or 'Untitled Video'
+            description = str(result.get('description', '')).strip() or 'No description available'
+            tags = result.get('tags', [])
+            
+            # Ensure tags is a list of strings
+            if not isinstance(tags, list):
+                tags = []
+            tags = [str(t).strip() for t in tags if t and isinstance(t, (str, int, float))]
+
+            # Generate thumbnail
+            #print(f"calling self.generate_thumbnail({title}, {description})")
+            try:
+                #thumbnail = await self.generate_thumbnail(title, description)
+                raise ValueError("thumbnail generation is too buggy and slow right now")
+            except Exception as e:
+                logger.error(f"Thumbnail generation failed: {str(e)}")
+                thumbnail = ""
+
+            print("got response thumbnail")
+            # Return valid result with all required fields
+            return {
+                'id': str(uuid.uuid4()),
+                'title': title,
+                'description': description,
+                'thumbnailUrl': thumbnail,
+                'videoUrl': '',
+                'isLatent': True,
+                'useFixedSeed': "webcam" in description.lower(),
+                'seed': generate_seed(),
+                'views': 0,
+                'tags': tags
+            }
+
+        except Exception as e:
+            logger.error(f"Search video generation failed: {str(e)}")
+            return None
+
+    async def generate_thumbnail(self, title: str, description: str) -> str:
+        """Generate thumbnail using HF image generation"""
+        try:
+            image_prompt = f"Thumbnail for video titled '{title}': {description}"
+            
+            image = await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: self.inference_client.text_to_image(
+                    prompt=image_prompt,
+                    model=IMAGE_MODEL,
+                    width=1024,
+                    height=512
+                )
+            )
+
+            buffered = io.BytesIO()
+            image.save(buffered, format="JPEG")
+            img_str = base64.b64encode(buffered.getvalue()).decode()
+            return f"data:image/jpeg;base64,{img_str}"
+        except Exception as e:
+            logger.error(f"Error generating thumbnail: {str(e)}")
+            return ""
+
+    async def generate_caption(self, title: str, description: str) -> str:
+        """Generate detailed caption using HF text generation"""
+        try:
+            prompt = f"""Generate a detailed story for a video named: "{title}"
+Visual description of the video: {description}.
+Instructions: Write the story summary, including the plot, action, what should happen.
+Make it around 200-300 words long.
+A video can be anything from a tutorial, webcam, trailer, movie, live stream etc."""
+
+            response = await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: self.inference_client.text_generation(
+                    prompt,
+                    model=TEXT_MODEL,
+                    max_new_tokens=180,
+                    temperature=0.7
+                )
+            )
+     
+            if "Caption: " in response:
+                response = response.replace("Caption: ", "")
+            
+            chunks = f" {response} ".split(". ")
+            if len(chunks) > 1:
+                text = ". ".join(chunks[:-1])
+            else:
+                text = response
+
+            return text.strip()
+        except Exception as e:
+            logger.error(f"Error generating caption: {str(e)}")
+            return ""
+
+
+    def get_config_value(self, role: UserRole, field: str, options: dict = None) -> Any:
+        """
+        Get the appropriate config value for a user role.
+        
+        Args:
+            role: The user role ('anon', 'normal', 'pro', 'admin')
+            field: The config field name to retrieve
+            options: Optional user-provided options that may override defaults
+            
+        Returns:
+            The config value appropriate for the user's role with respect to
+            min/max boundaries and user overrides.
+        """
+        # Select the appropriate config based on user role
+        if role == 'admin':
+            config = CONFIG_FOR_ADMIN_HF_USERS
+        elif role == 'pro':
+            config = CONFIG_FOR_PRO_HF_USERS
+        elif role == 'normal':
+            config = CONFIG_FOR_STANDARD_HF_USERS
+        else:  # Anonymous users
+            config = CONFIG_FOR_ANONYMOUS_USERS
+        
+        # Get the default value for this field from the config
+        default_value = config.get(f"default_{field}", None)
+        
+        # For fields that have min/max bounds
+        min_field = f"min_{field}"
+        max_field = f"max_{field}"
+        
+        # Check if min/max constraints exist for this field
+        has_constraints = min_field in config or max_field in config
+        
+        if not has_constraints:
+            # For fields without constraints, just return the value from config
+            return default_value
+        
+        # Get min and max values from config (if they exist)
+        min_value = config.get(min_field, None)
+        max_value = config.get(max_field, None)
+        
+        # If user provided options with this field
+        if options and field in options:
+            user_value = options[field]
+            
+            # Apply constraints if they exist
+            if min_value is not None and user_value < min_value:
+                return min_value
+            if max_value is not None and user_value > max_value:
+                return max_value
+                
+            # If within bounds, use the user's value
+            return user_value
+        
+        # If no user value, return the default
+        return default_value
+
+    async def _generate_clip_prompt(self, video_id: str, title: str, description: str) -> str:
+        """Generate a new prompt for the next clip based on event history"""
+        events = self.video_events.get(video_id, [])
+        events_json = "\n".join(json.dumps(event) for event in events)
+        
+        prompt = f"""# Context and task
+Please write the caption for a new clip.
+
+# Instructions
+1. Consider the video context and recent events
+2. Create a natural progression from previous clips
+3. Take into account user suggestions (chat messages) into the scene
+4. Don't generate hateful, political, violent or sexual content
+5. Keep visual consistency with previous clips (in most cases you should repeat the same exact description of the location, characters etc but only change a few elements. If this is a webcam scenario, don't touch the camera orientation or focus)
+6. Return ONLY the caption text, no additional formatting or explanation
+7. Write in English, about 200 words.
+8. Your caption must describe visual elements of the scene in details, including: camera angle and focus, people's appearance, age, look, costumes, clothes, the location visual characteristics and geometry, lighting, action, objects, weather, textures, lighting.
+
+# Examples
+Here is a demo scenario, with fake data:
+{{"time": "2024-11-29T13:36:15Z", "event": "new_stream_clip", "caption": "webcam view of a beautiful park, squirrels are playing in the lush grass, blablabla etc... (rest omitted for brevity)"}}
+{{"time": "2024-11-29T13:36:20Z", "event": "new_chat_message", "username": "MonkeyLover89", "data": "hi"}}
+{{"time": "2024-11-29T13:36:25Z", "event": "new_chat_message", "username": "MonkeyLover89", "data": "more squirrels plz"}}
+{{"time": "2024-11-29T13:36:26Z", "event": "new_stream_clip", "caption": "webcam view of a beautiful park, a lot of squirrels are playing in the lush grass, blablabla etc... (rest omitted for brevity)"}}
+
+# Real scenario and data
+
+We are inside a video titled "{title}"
+The video is described by: "{description}".
+Here is a summary of the {len(events)} most recent events:
+{events_json}
+
+# Your response
+Your caption:"""
+
+        try:
+            response = await asyncio.get_event_loop().run_in_executor(
+                None,
+                lambda: self.inference_client.text_generation(
+                    prompt,
+                    model=TEXT_MODEL,
+                    max_new_tokens=200,
+                    temperature=0.7
+                )
+            )
+            
+            # Clean up the response
+            caption = response.strip()
+            if caption.lower().startswith("caption:"):
+                caption = caption[8:].strip()
+                
+            return caption
+            
+        except Exception as e:
+            logger.error(f"Error generating clip prompt: {str(e)}")
+            # Fallback to original description if prompt generation fails
+            return description
+
+    async def generate_video(self, title: str, description: str, video_prompt_prefix: str, options: dict, user_role: UserRole = 'anon') -> str:
+        """Generate video using available space from pool"""
+        video_id = options.get('video_id', str(uuid.uuid4()))
+        
+        # Generate a new prompt based on event history
+        #clip_caption = await self._generate_clip_prompt(video_id, title, description)
+        clip_caption = f"{video_prompt_prefix} - {title.strip()} - {description.strip()}"
+
+        # Add the new clip to event history
+        self._add_event(video_id, {
+            "time": datetime.datetime.utcnow().isoformat() + "Z",
+            "event": "new_stream_clip",
+            "caption": clip_caption
+        })
+
+        # Use the generated caption as the prompt
+        prompt = f"{clip_caption}, {POSITIVE_PROMPT_SUFFIX}"
+        
+        # Get the config values based on user role
+        width = self.get_config_value(user_role, 'clip_width', options)
+        height = self.get_config_value(user_role, 'clip_height', options)
+        num_frames = self.get_config_value(user_role, 'num_frames', options)
+        num_inference_steps = self.get_config_value(user_role, 'num_inference_steps', options)
+        frame_rate = self.get_config_value(user_role, 'clip_framerate', options)
+        
+        # Log the user role and config values being used
+        logger.info(f"Generating video for user with role: {user_role}")
+        logger.info(f"Using config values: width={width}, height={height}, num_frames={num_frames}, steps={num_inference_steps}, fps={frame_rate}")
+        
+        json_payload = {
+            "inputs": {
+                "prompt": prompt,
+            },
+            "parameters": {
+
+                # ------------------- settings for LTX-Video -----------------------
+                
+                # this param doesn't exist
+                #"enhance_prompt_toggle": options.get('enhance_prompt', False),
+
+                "negative_prompt": options.get('negative_prompt', NEGATIVE_PROMPT),
+
+                # note about resolution:
+                # we cannot use 720 since it cannot be divided by 32
+                "width": width,
+                "height": height,
+
+                # this is a hack to fool LTX-Video into believing our input image is an actual video frame with poor encoding quality
+                #"input_image_quality": 70,
+
+                # LTX-Video requires a frame number divisible by 8, plus one frame
+                # note: glitches might appear if you use more than 168 frames
+                "num_frames": num_frames,
+
+                # using 30 steps seems to be enough for most cases, otherwise use 50 for best quality
+                # I think using a large number of steps (> 30) might create some overexposure and saturation
+                "num_inference_steps": num_inference_steps,
+
+                # values between 3.0 and 4.0 are nice
+                "guidance_scale": options.get('guidance_scale', GUIDANCE_SCALE),
+
+                "seed": options.get('seed', 42),
+            
+                # ----------------------------------------------------------------
+
+                # ------------------- settings for Varnish -----------------------
+                # This will double the number of frames.
+                # You can activate this if you want:
+                # - a slow motion effect (in that case use double_num_frames=True and fps=24, 25 or 30)
+                # - a HD soap / video game effect (in that case use double_num_frames=True and fps=60)
+                "double_num_frames": False, # <- False as we want real-time generation
+
+                # controls the number of frames per second
+                # use this in combination with the num_frames and double_num_frames settings to control the duration and "feel" of your video
+                # typical values are: 24, 25, 30, 60
+                "fps": frame_rate,
+
+                # upscale the video using Real-ESRGAN.
+                # This upscaling algorithm is relatively fast,
+                # but might create an uncanny "3D render" or "drawing" effect.
+                "super_resolution": False, # <- False as we want real-time generation
+
+                # for cosmetic purposes and get a "cinematic" feel, you can optionally add some film grain.
+                # it is not recommended to add film grain if your theme doesn't match (film grain is great for black & white, retro looks)
+                # and if you do, adding more than 12% will start to negatively impact file size (video codecs aren't great are compressing film grain)
+                # 0% = no grain
+                # 10% = a bit of grain
+                "grain_amount": 0, # value between 0-100
+
+
+                # The range of the CRF scale is 0–51, where:
+                # 0 is lossless (for 8 bit only, for 10 bit use -qp 0)
+                # 23 is the default
+                # 51 is worst quality possible
+                # A lower value generally leads to higher quality, and a subjectively sane range is 17–28.
+                # Consider 17 or 18 to be visually lossless or nearly so;
+                # it should look the same or nearly the same as the input but it isn't technically lossless.
+                # The range is exponential, so increasing the CRF value +6 results in roughly half the bitrate / file size, while -6 leads to roughly twice the bitrate.
+                #"quality": 18,
+
+            }
+        }
+
+        async with self.endpoint_manager.get_endpoint() as endpoint:
+            #logger.info(f"Using endpoint {endpoint.id} for video generation with prompt: {prompt}")
+            
+            async with ClientSession() as session:
+                async with session.post(
+                    endpoint.url,
+                    headers={
+                        "Accept": "application/json",
+                        "Authorization": f"Bearer {HF_TOKEN}",
+                        "Content-Type": "application/json"
+                    },
+                    json=json_payload
+                ) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        raise Exception(f"Video generation failed: HTTP {response.status} - {error_text}")
+                    
+                    result = await response.json()
+                    
+                    if "error" in result:
+                        raise Exception(f"Video generation failed: {result['error']}")
+                    
+                    video_data_uri = result.get("video")
+                    if not video_data_uri:
+                        raise Exception("No video data in response")
+                    
+                    return video_data_uri
+
+
+    async def handle_chat_message(self, data: dict, ws: web.WebSocketResponse) -> dict:
+        """Process and broadcast a chat message"""
+        video_id = data.get('videoId')
+        request_id = data.get('requestId')
+        
+        if not video_id:
+            return {
+                'action': 'chat_message',
+                'requestId': request_id,
+                'success': False,
+                'error': 'No video ID provided'
+            }
+
+        # Add chat message to event history
+        self._add_event(video_id, {
+            "time": datetime.datetime.utcnow().isoformat() + "Z",
+            "event": "new_chat_message",
+            "username": data.get('username', 'Anonymous'),
+            "data": data.get('content', '')
+        })
+
+        room = self.chat_rooms[video_id]
+        message_data = {k: v for k, v in data.items() if k != '_ws'}
+        room.add_message(message_data)
+        
+        for client in room.connected_clients:
+            if client != ws:
+                try:
+                    await client.send_json({
+                        'action': 'chat_message',
+                        'broadcast': True,
+                        **message_data
+                    })
+                except Exception as e:
+                    logger.error(f"Failed to broadcast to client: {e}")
+                    room.connected_clients.remove(client)
+        
+        return {
+            'action': 'chat_message',
+            'requestId': request_id,
+            'success': True,
+            'message': message_data
+        }
+
+    async def handle_join_chat(self, data: dict, ws: web.WebSocketResponse) -> dict:
+        """Handle a request to join a chat room"""
+        video_id = data.get('videoId')
+        request_id = data.get('requestId')
+        
+        if not video_id:
+            return {
+                'action': 'join_chat',
+                'requestId': request_id,
+                'success': False,
+                'error': 'No video ID provided'
+            }
+
+        room = self.chat_rooms[video_id]
+        room.connected_clients.add(ws)
+        recent_messages = room.get_recent_messages()
+        
+        return {
+            'action': 'join_chat',
+            'requestId': request_id,
+            'success': True,
+            'messages': recent_messages
+        }
+
+    async def handle_leave_chat(self, data: dict, ws: web.WebSocketResponse) -> dict:
+        """Handle a request to leave a chat room"""
+        video_id = data.get('videoId')
+        request_id = data.get('requestId')
+        
+        if not video_id:
+            return {
+                'action': 'leave_chat',
+                'requestId': request_id,
+                'success': False,
+                'error': 'No video ID provided'
+            }
+
+        room = self.chat_rooms[video_id]
+        if ws in room.connected_clients:
+            room.connected_clients.remove(ws)
+        
+        return {
+            'action': 'leave_chat',
+            'requestId': request_id,
+            'success': True
+        }

docs/for-bots/flutter-videos/fvp.md

@@ -0,0 +1,223 @@
+fvp 0.31.2 ![copy "fvp: ^0.31.2" to clipboard](/static/hash-j60jq2j3/img/content-copy-icon.svg "Copy "fvp: ^0.31.2" to clipboard")
+
+fvp: ^0.31.2 copied to clipboard
+
+
+======================================================================================================================================================================
+
+Published 9 days ago • [![verified publisher](/static/hash-j60jq2j3/img/material-icon-verified.svg "Published by a pub.dev verified publisher")mediadevkit.com](/publishers/mediadevkit.com)Dart 3 compatible
+
+SDK[Flutter](/packages?q=sdk%3Aflutter "Packages compatible with Flutter SDK")
+
+Platform[Android](/packages?q=platform%3Aandroid "Packages compatible with Android platform")[iOS](/packages?q=platform%3Aios "Packages compatible with iOS platform")[Linux](/packages?q=platform%3Alinux "Packages compatible with Linux platform")[macOS](/packages?q=platform%3Amacos "Packages compatible with macOS platform")[Windows](/packages?q=platform%3Awindows "Packages compatible with Windows platform")
+
+![liked status: inactive](/static/hash-j60jq2j3/img/like-inactive.svg)![liked status: active](/static/hash-j60jq2j3/img/like-active.svg)123
+
+→
+
+### Metadata
+
+video\_player plugin and backend APIs. Support all desktop/mobile platforms with hardware decoders, optimal renders. Supports most formats via FFmpeg
+
+More...
+
+*   Readme
+*   [Changelog](/packages/fvp/changelog)
+*   [Example](/packages/fvp/example)
+*   [Installing](/packages/fvp/install)
+*   [Versions](/packages/fvp/versions)
+*   [Scores](/packages/fvp/score)
+
+FVP [#](#fvp)
+=============
+
+A plugin for official [Flutter Video Player](https://pub.dev/packages/video_player) to support all desktop and mobile platforms, with hardware accelerated decoding and optimal rendering. Based on [libmdk](https://github.com/wang-bin/mdk-sdk). You can also create your own players other than official `video_player` with [backend player api](#backend-player-api)
+
+Prebuilt example can be download from artifacts of [github actions](https://github.com/wang-bin/fvp/actions).
+
+[More examples are here](https://github.com/wang-bin/mdk-examples/tree/master/flutter)
+
+project is create with `flutter create -t plugin --platforms=linux,macos,windows,android,ios -i objc -a java fvp`
+
+Features [#](#features)
+-----------------------
+
+*   All platforms: Windows x64(including win7) and arm64, Linux x64 and arm64, macOS, iOS, Android(requires flutter > 3.19 because of minSdk 21).
+*   You can choose official implementation or this plugin's
+*   Optimal render api: d3d11 for windows, metal for macOS/iOS, OpenGL for Linux and Android(Impeller support)
+*   Hardware decoders are enabled by default
+*   Dolby Vision support on all platforms
+*   Minimal code change for existing [Video Player](https://pub.dev/packages/video_player) apps
+*   Support most formats via FFmpeg demuxer and software decoders if not supported by gpu. You can use your own ffmpeg 4.0~7.1(or master branch) by removing bundled ffmpeg dynamic library.
+*   High performance. Lower cpu, gpu and memory load than libmpv based players.
+*   Support audio without video
+*   HEVC, VP8 and VP9 transparent video
+*   Small footprint. Only about 10MB size increase per cpu architecture(platform dependent).
+
+How to Use [#](#how-to-use)
+---------------------------
+
+*   Add [fvp](https://pub.dev/packages/fvp) in your pubspec.yaml dependencies: `flutter pub add fvp`. Since flutter 3.27, fvp must be a direct dependency in your app's pubspec.yaml.
+*   **(Optional)** Add 2 lines in your video\_player examples. Without this step, this plugin will be used for video\_player unsupported platforms(windows, linux), official implementation will be used otherwise.
+
+    import 'package:fvp/fvp.dart' as fvp;
+    
+    fvp.registerWith(); // in main() or anywhere before creating a player. use fvp for all platforms.
+    
+
+copied to clipboard
+
+You can also select the platforms to enable fvp implementation
+
+    registerWith(options: {'platforms': ['windows', 'macos', 'linux']}); // only these platforms will use this plugin implementation
+    
+
+copied to clipboard
+
+To select [other decoders](https://github.com/wang-bin/mdk-sdk/wiki/Decoders), pass options like this
+
+    fvp.registerWith(options: {
+        'video.decoders': ['D3D11', 'NVDEC', 'FFmpeg']
+        //'lowLatency': 1, // optional for network streams
+        }); // windows
+    
+
+copied to clipboard
+
+[The document](https://pub.dev/documentation/fvp/latest/fvp/registerWith.html) lists all options for `registerWith()`
+
+### Error Handling [#](#error-handling)
+
+Errors are usually produced when loading a media.
+
+    _controller.addListener(() {
+      if (_controller.value.hasError && !_controller.value.isCompleted) {
+        ...
+    
+
+copied to clipboard
+
+### Backend Player API [#](#backend-player-api)
+
+    import 'package:fvp/mdk.dart';
+    
+
+copied to clipboard
+
+The plugin implements [VideoPlayerPlatform](https://pub.dev/packages/video_player_platform_interface) via [a thin wrapper](https://github.com/wang-bin/fvp/blob/master/lib/video_player_mdk.dart) on [player.dart](https://github.com/wang-bin/fvp/blob/master/lib/src/player.dart).
+
+Now we also expose this backend player api so you can create your own players easily, and gain more features than official [video\_player](https://pub.dev/packages/video_player), for example, play from a given position, loop in a range, decoder selection, media information detail etc. You can also reuse the Player instance without unconditionally create and dispose, changing the `Player.media` is enough. [This is an example](https://github.com/wang-bin/mdk-examples/blob/master/flutter/simple/lib/multi_textures.dart)
+
+### VideoPlayerController Extensions [#](#videoplayercontroller-extensions)
+
+With this extension, we can leverage mature `video_player` code without rewriting a new one via backend player api, but gain more features, for example `snapshot()`, `record()`, `fastSeekTo()`, `setExternalSubtitle()`.
+
+    import 'package:fvp/fvp.dart' as fvp;
+    
+    fvp.registerWith(); // in main() or anywhere before creating a player. use fvp for all platforms.
+    
+    // somewhere after controller is initialized
+    _controller.record('rtmp://127.0.0.1/live/test');
+    
+
+copied to clipboard
+
+Upgrade Dependencies Manually [#](#upgrade-dependencies-manually)
+=================================================================
+
+Upgrading binary dependencies can bring new features and backend bug fixes. For macOS and iOS, in your project dir, run
+
+    pod cache clean mdk
+    find . -name Podfile.lock -delete
+    rm -rf {mac,i}os/Pods
+    
+
+copied to clipboard
+
+For other platforms, set environment var `FVP_DEPS_LATEST=1` and rebuilt, will upgrade to the latest sdk. If fvp is installed from pub.dev, run `flutter pub cache clean` is another option.
+
+Design [#](#design)
+===================
+
+*   Playback control api in dart via ffi
+*   Manage video renderers in platform specific manners. Receive player ptr via `MethodChannel` to construct player instance and set a renderer target.
+*   Callbacks and events in C++ are notified by ReceivePort
+*   Function with a one time callback is async and returns a future
+
+Enable Subtitles [#](#enable-subtitles)
+=======================================
+
+libass is required, and it's added to your app automatically for windows, macOS and android(remove ass.dll, libass.dylib and libass.so from mdk-sdk if you don't need it). For iOS, [download](https://sourceforge.net/projects/mdk-sdk/files/deps/dep.7z/download) and add `ass.framework` to your xcode project. For linux, system libass can be used, you may have to install manually via system package manager.
+
+If required subtitle font is not found in the system(e.g. android), you can add [assets/subfont.ttf](https://github.com/mpv-android/mpv-android/raw/master/app/src/main/assets/subfont.ttf) in pubspec.yaml assets as the fallback. Optionally you can also download the font file by fvp like this
+
+      fvp.registerWith(options: {
+        'subtitleFontFile': 'https://github.com/mpv-android/mpv-android/raw/master/app/src/main/assets/subfont.ttf'
+      });
+    
+
+copied to clipboard
+
+DO NOT use flutter-snap [#](#do-not-use-flutter-snap)
+=====================================================
+
+Flutter can be installed by snap, but it will add some [enviroment vars(`CPLUS_INCLUDE_PATH` and `LIBRARY_PATH`) which may break C++ compiler](https://github.com/canonical/flutter-snap/blob/main/env.sh#L15-L18). It's not recommended to use snap, althrough building for linux is [fixed](https://github.com/wang-bin/fvp/commit/567c68270ba16b95b1198ae58850707ae4ad7b22), but it's not possible for android.
+
+Screenshots [#](#screenshots)
+=============================
+
+![fpv_android](https://user-images.githubusercontent.com/785206/248862591-40f458e5-d7ca-4513-b709-b056deaaf421.jpeg) ![fvp_ios](https://user-images.githubusercontent.com/785206/250348936-e5e1fb14-9c81-4652-8f53-37e8d64195a3.jpg) ![fvp_win](https://user-images.githubusercontent.com/785206/248859525-920bdd51-6947-4a00-87b4-9c1a21a68d51.jpeg) ![fvp_win7](https://user-images.githubusercontent.com/785206/266754957-883d05c9-a057-4c1c-b824-0dc385a13f78.jpg) ![fvp_linux](https://user-images.githubusercontent.com/785206/248859533-ce2ad50b-2ead-43bb-bf25-6e2575c5ebe1.jpeg) ![fvp_macos](https://user-images.githubusercontent.com/785206/248859538-71de39a4-c5f0-4c8f-9920-d7dfc6cd0d9a.jpg)
+
+[
+
+123
+
+likes
+
+150
+
+points
+
+4.48k
+
+downloads
+
+
+
+](/packages/fvp/score)
+
+### Publisher
+
+[![verified publisher](/static/hash-j60jq2j3/img/material-icon-verified.svg "Published by a pub.dev verified publisher")mediadevkit.com](/publishers/mediadevkit.com)
+
+### Weekly Downloads
+
+2024.10.07 - 2025.04.21
+
+### Metadata
+
+video\_player plugin and backend APIs. Support all desktop/mobile platforms with hardware decoders, optimal renders. Supports most formats via FFmpeg
+
+[Repository (GitHub)](https://github.com/wang-bin/fvp)  
+
+### Topics
+
+[#video](/packages?q=topic%3Avideo) [#player](/packages?q=topic%3Aplayer) [#video-player](/packages?q=topic%3Avideo-player) [#audio-player](/packages?q=topic%3Aaudio-player) [#videoplayer](/packages?q=topic%3Avideoplayer)
+
+### Documentation
+
+[API reference](/documentation/fvp/latest/)  
+
+### License
+
+![](/static/hash-j60jq2j3/img/material-icon-balance.svg)BSD-3-Clause ([license](/packages/fvp/license))
+
+### Dependencies
+
+[ffi](/packages/ffi "^2.1.0"), [flutter](https://api.flutter.dev/), [http](/packages/http "^1.0.0"), [logging](/packages/logging "^1.2.0"), [path](/packages/path "^1.8.0"), [path\_provider](/packages/path_provider "^2.1.2"), [plugin\_platform\_interface](/packages/plugin_platform_interface "^2.0.0"), [video\_player](/packages/video_player "^2.6.0"), [video\_player\_platform\_interface](/packages/video_player_platform_interface "^6.2.0")
+
+### More
+
+[Packages that depend on fvp](/packages?q=dependency%3Afvp)
+
+{"@context":"http\\u003a\\u002f\\u002fschema.org","@type":"SoftwareSourceCode","name":"fvp","version":"0.31.2","description":"fvp - video\\u005fplayer plugin and backend APIs. Support all desktop\\u002fmobile platforms with hardware decoders, optimal renders. Supports most formats via FFmpeg","url":"https\\u003a\\u002f\\u002fpub.dev\\u002fpackages\\u002ffvp","dateCreated":"2023-06-26T16\\u003a23\\u003a33.605901Z","dateModified":"2025-04-14T04\\u003a14\\u003a34.630262Z","programmingLanguage":"Dart","image":"https\\u003a\\u002f\\u002fpub.dev\\u002fstatic\\u002fimg\\u002fpub-dev-icon-cover-image.png","license":"https\\u003a\\u002f\\u002fpub.dev\\u002fpackages\\u002ffvp\\u002flicense"}

docs/for-bots/flutter-videos/fvp_usage_example__main.dart

@@ -0,0 +1,369 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file is used to extract code samples for the README.md file.
+// Run update-excerpts if you modify this file.
+
+// ignore_for_file: library_private_types_in_public_api, public_member_api_docs
+
+// #docregion basic-example
+import 'dart:io';
+
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:video_player/video_player.dart';
+import 'package:fvp/fvp.dart';
+import 'package:logging/logging.dart';
+import 'package:intl/intl.dart';
+import 'package:file_selector/file_selector.dart';
+import 'package:image/image.dart' as img;
+
+String? source;
+
+void main(List<String> args) async {
+// set logger before registerWith()
+  Logger.root.level = Level.ALL;
+  final df = DateFormat("HH:mm:ss.SSS");
+  Logger.root.onRecord.listen((record) {
+    debugPrint(
+        '${record.loggerName}.${record.level.name}: ${df.format(record.time)}: ${record.message}',
+        wrapWidth: 0x7FFFFFFFFFFFFFFF);
+  });
+
+  final opts = <String, Object>{};
+  final globalOpts = <String, Object>{};
+  int i = 0;
+  bool useFvp = true;
+  opts['subtitleFontFile'] =
+      'https://github.com/mpv-android/mpv-android/raw/master/app/src/main/assets/subfont.ttf';
+  for (; i < args.length; i++) {
+    if (args[i] == '-c:v') {
+      opts['video.decoders'] = [args[++i]];
+    } else if (args[i] == '-maxSize') {
+      // ${w}x${h}
+      final size = args[++i].split('x');
+      opts['maxWidth'] = int.parse(size[0]);
+      opts['maxHeight'] = int.parse(size[1]);
+    } else if (args[i] == '-fvp') {
+      useFvp = int.parse(args[++i]) > 0;
+    } else if (args[i].startsWith('-')) {
+      globalOpts[args[i].substring(1)] = args[++i];
+    } else {
+      break;
+    }
+  }
+  if (globalOpts.isNotEmpty) {
+    opts['global'] = globalOpts;
+  }
+  opts['lowLatency'] = 0;
+
+  if (i <= args.length - 1) source = args[args.length - 1];
+  source ??= await getStartFile();
+
+  if (useFvp) {
+    registerWith(options: opts);
+  }
+
+  runApp(const MaterialApp(
+      localizationsDelegates: [DefaultMaterialLocalizations.delegate],
+      title: 'Video Demo',
+      home: VideoApp()));
+}
+
+Future<String?> getStartFile() async {
+  if (Platform.isMacOS) {
+    WidgetsFlutterBinding.ensureInitialized();
+    const hostApi = MethodChannel("openFile");
+    return await hostApi.invokeMethod("getCurrentFile");
+  }
+  return null;
+}
+
+Future<String?> showURIPicker(BuildContext context) async {
+  final key = GlobalKey<FormState>();
+  final src = TextEditingController();
+  String? uri;
+  await showModalBottomSheet(
+    context: context,
+    builder: (context) => Container(
+      alignment: Alignment.center,
+      child: Form(
+        key: key,
+        child: Padding(
+          padding: const EdgeInsets.all(16.0),
+          child: Column(
+            mainAxisSize: MainAxisSize.max,
+            mainAxisAlignment: MainAxisAlignment.start,
+            crossAxisAlignment: CrossAxisAlignment.center,
+            children: [
+              TextFormField(
+                controller: src,
+                style: const TextStyle(fontSize: 14.0),
+                decoration: const InputDecoration(
+                  border: UnderlineInputBorder(),
+                  labelText: 'Video URI',
+                ),
+                validator: (value) {
+                  if (value == null || value.isEmpty) {
+                    return 'Please enter a URI';
+                  }
+                  return null;
+                },
+              ),
+              Padding(
+                padding: const EdgeInsets.symmetric(vertical: 16.0),
+                child: ElevatedButton(
+                  onPressed: () {
+                    if (key.currentState!.validate()) {
+                      uri = src.text;
+                      Navigator.of(context).maybePop();
+                    }
+                  },
+                  child: const Text('Play'),
+                ),
+              ),
+            ],
+          ),
+        ),
+      ),
+    ),
+  );
+  return uri;
+}
+
+/// Stateful widget to fetch and then display video content.
+class VideoApp extends StatefulWidget {
+  const VideoApp({super.key});
+
+  @override
+  _VideoAppState createState() => _VideoAppState();
+}
+
+class _VideoAppState extends State<VideoApp> {
+  late VideoPlayerController _controller;
+
+  @override
+  void initState() {
+    super.initState();
+    if (source != null) {
+      if (File(source!).existsSync()) {
+        playFile(source!);
+      } else {
+        playUri(source!);
+      }
+    } else {
+      playUri(
+          'https://flutter.github.io/assets-for-api-docs/assets/videos/bee.mp4');
+    }
+  }
+
+  void playFile(String path) {
+    _controller.dispose();
+    _controller = VideoPlayerController.file(File(path));
+    _controller.addListener(() {
+      setState(() {});
+    });
+    _controller.initialize().then((_) {
+      // Ensure the first frame is shown after the video is initialized, even before the play button has been pressed.
+      setState(() {});
+      _controller.play();
+    });
+  }
+
+  void playUri(String uri) {
+    _controller = VideoPlayerController.network(uri);
+    _controller.addListener(() {
+      setState(() {});
+    });
+    _controller.initialize().then((_) {
+      // Ensure the first frame is shown after the video is initialized, even before the play button has been pressed.
+      setState(() {});
+      _controller.play();
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      floatingActionButton: Row(
+        children: [
+          FloatingActionButton(
+            heroTag: 'file',
+            tooltip: 'Open [File]',
+            onPressed: () async {
+              const XTypeGroup typeGroup = XTypeGroup(
+                label: 'videos',
+                //extensions: <String>['*'],
+              );
+              final XFile? file =
+                  await openFile(acceptedTypeGroups: <XTypeGroup>[typeGroup]);
+
+              if (file != null) {
+                playFile(file.path);
+              }
+            },
+            child: const Icon(Icons.file_open),
+          ),
+          const SizedBox(width: 16.0),
+          FloatingActionButton(
+            heroTag: 'uri',
+            tooltip: 'Open [Uri]',
+            onPressed: () {
+              showURIPicker(context).then((value) {
+                if (value != null) {
+                  playUri(value);
+                }
+              });
+            },
+            child: const Icon(Icons.link),
+          ),
+          const SizedBox(width: 16.0),
+          FloatingActionButton(
+            heroTag: 'snapshot',
+            tooltip: 'Snapshot',
+            onPressed: () {
+              if (_controller.value.isInitialized) {
+                final info = _controller.getMediaInfo()?.video?[0].codec;
+                if (info == null) {
+                  debugPrint('No video codec info');
+                  return;
+                }
+                final width = info.width;
+                final height = info.height;
+                _controller.snapshot().then((value) {
+                  if (value != null) {
+                    // value is rgba data, must encode to png image and save as a file
+                    final i = img.Image.fromBytes(
+                        width: width,
+                        height: height,
+                        bytes: value.buffer,
+                        numChannels: 4,
+                        rowStride: width * 4);
+                    final savePath =
+                        '${Directory.systemTemp.path}/snapshot.jpg';
+                    img.encodeJpgFile(savePath, i, quality: 70).then((value) {
+                      final msg = value
+                          ? 'Snapshot saved to $savePath'
+                          : 'Failed to save snapshot';
+                      debugPrint(msg);
+                      // show a toast
+                      if (context.mounted) {
+                        ScaffoldMessenger.of(context).showSnackBar(
+                          SnackBar(
+                            content: Text(msg),
+                            duration: const Duration(seconds: 2),
+                          ),
+                        );
+                      }
+                    });
+                  }
+                });
+              }
+            },
+            child: const Icon(Icons.screenshot),
+          ),
+        ],
+      ),
+      body: Center(
+        child: _controller.value.isInitialized
+            ? AspectRatio(
+                aspectRatio: _controller.value.aspectRatio,
+                child: Stack(
+                  alignment: Alignment.bottomCenter,
+                  children: <Widget>[
+                    VideoPlayer(_controller),
+                    _ControlsOverlay(controller: _controller),
+                    VideoProgressIndicator(_controller, allowScrubbing: true),
+                  ],
+                ),
+              )
+            : Container(),
+      ),
+    );
+  }
+
+  @override
+  void dispose() {
+    super.dispose();
+    _controller.dispose();
+  }
+}
+
+class _ControlsOverlay extends StatelessWidget {
+  const _ControlsOverlay({required this.controller});
+
+  static const List<double> _examplePlaybackRates = <double>[
+    0.25,
+    0.5,
+    1.0,
+    1.5,
+    2.0,
+    3.0,
+    5.0,
+    10.0,
+  ];
+
+  final VideoPlayerController controller;
+
+  @override
+  Widget build(BuildContext context) {
+    return Stack(
+      children: <Widget>[
+        AnimatedSwitcher(
+          duration: const Duration(milliseconds: 50),
+          reverseDuration: const Duration(milliseconds: 200),
+          child: controller.value.isPlaying
+              ? const SizedBox.shrink()
+              : Container(
+                  color: Colors.black26,
+                  child: const Center(
+                    child: Icon(
+                      Icons.play_arrow,
+                      color: Colors.white,
+                      size: 100.0,
+                      semanticLabel: 'Play',
+                    ),
+                  ),
+                ),
+        ),
+        GestureDetector(
+          onTap: () {
+            controller.value.isPlaying ? controller.pause() : controller.play();
+          },
+        ),
+        Align(
+          alignment: Alignment.topRight,
+          child: PopupMenuButton<double>(
+            initialValue: controller.value.playbackSpeed,
+            tooltip: 'Playback speed',
+            onSelected: (double speed) {
+              controller.setPlaybackSpeed(speed);
+            },
+            itemBuilder: (BuildContext context) {
+              return <PopupMenuItem<double>>[
+                for (final double speed in _examplePlaybackRates)
+                  PopupMenuItem<double>(
+                    value: speed,
+                    child: Text('${speed}x'),
+                  )
+              ];
+            },
+            child: Padding(
+              padding: const EdgeInsets.symmetric(
+                // Using less vertical padding as the text is also longer
+                // horizontally, so it feels like it would need more spacing
+                // horizontally (matching the aspect ratio of the video).
+                vertical: 12,
+                horizontal: 16,
+              ),
+              child: Text('${controller.value.playbackSpeed}x'),
+            ),
+          ),
+        ),
+      ],
+    );
+  }
+}
+
+// #enddocregion basic-example

docs/for-bots/flutter-videos/fvp_usage_example__multi_textures.dart

@@ -0,0 +1,116 @@
+import 'package:flutter/material.dart';
+import 'package:fvp/mdk.dart';
+
+void main(List<String> args) async {
+  runApp(const SinglePlayerMultipleVideoWidget());
+}
+class SinglePlayerMultipleVideoWidget extends StatefulWidget {
+  const SinglePlayerMultipleVideoWidget({Key? key}) : super(key: key);
+
+  @override
+  State<SinglePlayerMultipleVideoWidget> createState() =>
+      _SinglePlayerMultipleVideoWidgetState();
+}
+
+class _SinglePlayerMultipleVideoWidgetState
+    extends State<SinglePlayerMultipleVideoWidget> {
+  late final player = Player();
+
+  @override
+  void initState() {
+    super.initState();
+
+    player.media = 'https://flutter.github.io/assets-for-api-docs/assets/videos/bee.mp4';
+    player.loop = -1;
+    player.state = PlaybackState.playing;
+    player.updateTexture();
+  }
+
+  @override
+  void dispose() {
+    player.dispose();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp(
+      title: 'package:fvp',
+      home: Scaffold(
+        body: Center(
+          child: Row(
+                crossAxisAlignment: CrossAxisAlignment.stretch,
+                children: [
+                  Expanded(
+                    flex: 3,
+                    child: Column(
+                      mainAxisSize: MainAxisSize.min,
+                      children: [
+                        Expanded(
+                          child: Card(
+                            elevation: 8.0,
+                            color: Colors.black,
+                            clipBehavior: Clip.antiAlias,
+                            margin: const EdgeInsets.all(32.0),
+                            child: Column(
+                              mainAxisSize: MainAxisSize.max,
+                              children: [
+                                Expanded(
+                                  child: Row(
+                                    children: [
+                                      Expanded(
+                                        child: ValueListenableBuilder<int?>(
+                                          valueListenable: player.textureId,
+                                          builder: (context, id, _) => id == null
+                                            ? const SizedBox.shrink()
+                                            : Texture(textureId: id),
+                                        ),
+                                      ),
+                                      Expanded(
+                                        child:  ValueListenableBuilder<int?>(
+                                          valueListenable: player.textureId,
+                                          builder: (context, id, _) => id == null
+                                            ? const SizedBox.shrink()
+                                            : Texture(textureId: id),
+                                        ),
+                                      ),
+                                    ],
+                                  ),
+                                ),
+                                Expanded(
+                                  child: Row(
+                                    children: [
+                                      Expanded(
+                                        child: ValueListenableBuilder<int?>(
+                                          valueListenable: player.textureId,
+                                          builder: (context, id, _) => id == null
+                                            ? const SizedBox.shrink()
+                                            : Texture(textureId: id),
+                                        ),
+                                      ),
+                                      Expanded(
+                                        child:  ValueListenableBuilder<int?>(
+                                          valueListenable: player.textureId,
+                                          builder: (context, id, _) => id == null
+                                            ? const SizedBox.shrink()
+                                            : Texture(textureId: id),
+                                        ),
+                                      ),
+                                    ],
+                                  ),
+                                ),
+                              ],
+                            ),
+                          ),
+                        ),
+                        const SizedBox(height: 32.0),
+                      ],
+                    ),
+                  ),
+                ],
+              ),
+        ),
+      ),
+    );
+  }
+}

docs/for-bots/flutter-videos/video_player.md

@@ -0,0 +1,145 @@
+Video Player plugin for Flutter [#](#video-player-plugin-for-flutter)
+=====================================================================
+
+[![pub package](https://img.shields.io/pub/v/video_player.svg)](https://pub.dev/packages/video_player)
+
+A Flutter plugin for iOS, Android and Web for playing back video on a Widget surface.
+
+Android
+
+iOS
+
+macOS
+
+Web
+
+**Support**
+
+SDK 16+
+
+12.0+
+
+10.14+
+
+Any\*
+
+![The example app running in iOS](https://github.com/flutter/packages/blob/main/packages/video_player/video_player/doc/demo_ipod.gif?raw=true)
+
+Setup [#](#setup)
+-----------------
+
+### iOS [#](#ios)
+
+If you need to access videos using `http` (rather than `https`) URLs, you will need to add the appropriate `NSAppTransportSecurity` permissions to your app's _Info.plist_ file, located in `<project root>/ios/Runner/Info.plist`. See [Apple's documentation](https://developer.apple.com/documentation/bundleresources/information_property_list/nsapptransportsecurity) to determine the right combination of entries for your use case and supported iOS versions.
+
+### Android [#](#android)
+
+If you are using network-based videos, ensure that the following permission is present in your Android Manifest file, located in `<project root>/android/app/src/main/AndroidManifest.xml`:
+
+    <uses-permission android:name="android.permission.INTERNET"/>
+    
+
+copied to clipboard
+
+### macOS [#](#macos)
+
+If you are using network-based videos, you will need to [add the `com.apple.security.network.client` entitlement](https://flutter.dev/to/macos-entitlements)
+
+### Web [#](#web)
+
+> The Web platform does **not** support `dart:io`, so avoid using the `VideoPlayerController.file` constructor for the plugin. Using the constructor attempts to create a `VideoPlayerController.file` that will throw an `UnimplementedError`.
+
+\* Different web browsers may have different video-playback capabilities (supported formats, autoplay...). Check [package:video\_player\_web](https://pub.dev/packages/video_player_web) for more web-specific information.
+
+The `VideoPlayerOptions.mixWithOthers` option can't be implemented in web, at least at the moment. If you use this option in web it will be silently ignored.
+
+Supported Formats [#](#supported-formats)
+-----------------------------------------
+
+*   On iOS and macOS, the backing player is [AVPlayer](https://developer.apple.com/documentation/avfoundation/avplayer). The supported formats vary depending on the version of iOS, [AVURLAsset](https://developer.apple.com/documentation/avfoundation/avurlasset) class has [audiovisualTypes](https://developer.apple.com/documentation/avfoundation/avurlasset/1386800-audiovisualtypes?language=objc) that you can query for supported av formats.
+*   On Android, the backing player is [ExoPlayer](https://google.github.io/ExoPlayer/), please refer [here](https://google.github.io/ExoPlayer/supported-formats.html) for list of supported formats.
+*   On Web, available formats depend on your users' browsers (vendor and version). Check [package:video\_player\_web](https://pub.dev/packages/video_player_web) for more specific information.
+
+Example [#](#example)
+---------------------
+
+    import 'package:flutter/material.dart';
+    import 'package:video_player/video_player.dart';
+    
+    void main() => runApp(const VideoApp());
+    
+    /// Stateful widget to fetch and then display video content.
+    class VideoApp extends StatefulWidget {
+      const VideoApp({super.key});
+    
+      @override
+      _VideoAppState createState() => _VideoAppState();
+    }
+    
+    class _VideoAppState extends State<VideoApp> {
+      late VideoPlayerController _controller;
+    
+      @override
+      void initState() {
+        super.initState();
+        _controller = VideoPlayerController.networkUrl(Uri.parse(
+            'https://flutter.github.io/assets-for-api-docs/assets/videos/bee.mp4'))
+          ..initialize().then((_) {
+            // Ensure the first frame is shown after the video is initialized, even before the play button has been pressed.
+            setState(() {});
+          });
+      }
+    
+      @override
+      Widget build(BuildContext context) {
+        return MaterialApp(
+          title: 'Video Demo',
+          home: Scaffold(
+            body: Center(
+              child: _controller.value.isInitialized
+                  ? AspectRatio(
+                      aspectRatio: _controller.value.aspectRatio,
+                      child: VideoPlayer(_controller),
+                    )
+                  : Container(),
+            ),
+            floatingActionButton: FloatingActionButton(
+              onPressed: () {
+                setState(() {
+                  _controller.value.isPlaying
+                      ? _controller.pause()
+                      : _controller.play();
+                });
+              },
+              child: Icon(
+                _controller.value.isPlaying ? Icons.pause : Icons.play_arrow,
+              ),
+            ),
+          ),
+        );
+      }
+    
+      @override
+      void dispose() {
+        _controller.dispose();
+        super.dispose();
+      }
+    }
+    
+
+copied to clipboard
+
+Usage [#](#usage)
+-----------------
+
+The following section contains usage information that goes beyond what is included in the documentation in order to give a more elaborate overview of the API.
+
+This is not complete as of now. You can contribute to this section by [opening a pull request](https://github.com/flutter/packages/pulls).
+
+### Playback speed [#](#playback-speed)
+
+You can set the playback speed on your `_controller` (instance of `VideoPlayerController`) by calling `_controller.setPlaybackSpeed`. `setPlaybackSpeed` takes a `double` speed value indicating the rate of playback for your video. For example, when given a value of `2.0`, your video will play at 2x the regular playback speed and so on.
+
+To learn about playback speed limitations, see the [`setPlaybackSpeed` method documentation](https://pub.dev/documentation/video_player/latest/video_player/VideoPlayerController/setPlaybackSpeed.html).
+
+Furthermore, see the example app for an example playback speed implementation.

ios/.gitignore

@@ -0,0 +1,34 @@
+**/dgph
+*.mode1v3
+*.mode2v3
+*.moved-aside
+*.pbxuser
+*.perspectivev3
+**/*sync/
+.sconsign.dblite
+.tags*
+**/.vagrant/
+**/DerivedData/
+Icon?
+**/Pods/
+**/.symlinks/
+profile
+xcuserdata
+**/.generated/
+Flutter/App.framework
+Flutter/Flutter.framework
+Flutter/Flutter.podspec
+Flutter/Generated.xcconfig
+Flutter/ephemeral/
+Flutter/app.flx
+Flutter/app.zip
+Flutter/flutter_assets/
+Flutter/flutter_export_environment.sh
+ServiceDefinitions.json
+Runner/GeneratedPluginRegistrant.*
+
+# Exceptions to above rules.
+!default.mode1v3
+!default.mode2v3
+!default.pbxuser
+!default.perspectivev3

ios/Flutter/AppFrameworkInfo.plist

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>en</string>
+  <key>CFBundleExecutable</key>
+  <string>App</string>
+  <key>CFBundleIdentifier</key>
+  <string>io.flutter.flutter.app</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>App</string>
+  <key>CFBundlePackageType</key>
+  <string>FMWK</string>
+  <key>CFBundleShortVersionString</key>
+  <string>1.0</string>
+  <key>CFBundleSignature</key>
+  <string>????</string>
+  <key>CFBundleVersion</key>
+  <string>1.0</string>
+  <key>MinimumOSVersion</key>
+  <string>12.0</string>
+</dict>
+</plist>

ios/Flutter/Debug.xcconfig

@@ -0,0 +1,2 @@
+#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"
+#include "Generated.xcconfig"

ios/Flutter/Release.xcconfig

@@ -0,0 +1,2 @@
+#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"
+#include "Generated.xcconfig"

ios/Podfile

@@ -0,0 +1,44 @@
+# Uncomment this line to define a global platform for your project
+# platform :ios, '12.0'
+
+# CocoaPods analytics sends network stats synchronously affecting flutter build latency.
+ENV['COCOAPODS_DISABLE_STATS'] = 'true'
+
+project 'Runner', {
+  'Debug' => :debug,
+  'Profile' => :release,
+  'Release' => :release,
+}
+
+def flutter_root
+  generated_xcode_build_settings_path = File.expand_path(File.join('..', 'Flutter', 'Generated.xcconfig'), __FILE__)
+  unless File.exist?(generated_xcode_build_settings_path)
+    raise "#{generated_xcode_build_settings_path} must exist. If you're running pod install manually, make sure flutter pub get is executed first"
+  end
+
+  File.foreach(generated_xcode_build_settings_path) do |line|
+    matches = line.match(/FLUTTER_ROOT\=(.*)/)
+    return matches[1].strip if matches
+  end
+  raise "FLUTTER_ROOT not found in #{generated_xcode_build_settings_path}. Try deleting Generated.xcconfig, then run flutter pub get"
+end
+
+require File.expand_path(File.join('packages', 'flutter_tools', 'bin', 'podhelper'), flutter_root)
+
+flutter_ios_podfile_setup
+
+target 'Runner' do
+  use_frameworks!
+  use_modular_headers!
+
+  flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__))
+  target 'RunnerTests' do
+    inherit! :search_paths
+  end
+end
+
+post_install do |installer|
+  installer.pods_project.targets.each do |target|
+    flutter_additional_ios_build_settings(target)
+  end
+end

ios/Runner.xcodeproj/project.pbxproj

@@ -0,0 +1,616 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 54;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */ = {isa = PBXBuildFile; fileRef = 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */; };
+		331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 331C807B294A618700263BE5 /* RunnerTests.swift */; };
+		3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */ = {isa = PBXBuildFile; fileRef = 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */; };
+		74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 74858FAE1ED2DC5600515810 /* AppDelegate.swift */; };
+		97C146FC1CF9000F007C117D /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FA1CF9000F007C117D /* Main.storyboard */; };
+		97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FD1CF9000F007C117D /* Assets.xcassets */; };
+		97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		331C8085294A63A400263BE5 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 97C146E61CF9000F007C117D /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 97C146ED1CF9000F007C117D;
+			remoteInfo = Runner;
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXCopyFilesBuildPhase section */
+		9705A1C41CF9048500538489 /* Embed Frameworks */ = {
+			isa = PBXCopyFilesBuildPhase;
+			buildActionMask = 2147483647;
+			dstPath = "";
+			dstSubfolderSpec = 10;
+			files = (
+			);
+			name = "Embed Frameworks";
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXCopyFilesBuildPhase section */
+
+/* Begin PBXFileReference section */
+		1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GeneratedPluginRegistrant.h; sourceTree = "<group>"; };
+		1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = GeneratedPluginRegistrant.m; sourceTree = "<group>"; };
+		331C807B294A618700263BE5 /* RunnerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunnerTests.swift; sourceTree = "<group>"; };
+		331C8081294A63A400263BE5 /* RunnerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RunnerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; };
+		3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = AppFrameworkInfo.plist; path = Flutter/AppFrameworkInfo.plist; sourceTree = "<group>"; };
+		74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "Runner-Bridging-Header.h"; sourceTree = "<group>"; };
+		74858FAE1ED2DC5600515810 /* AppDelegate.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = "<group>"; };
+		7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = Release.xcconfig; path = Flutter/Release.xcconfig; sourceTree = "<group>"; };
+		9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Debug.xcconfig; path = Flutter/Debug.xcconfig; sourceTree = "<group>"; };
+		9740EEB31CF90195004384FC /* Generated.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Generated.xcconfig; path = Flutter/Generated.xcconfig; sourceTree = "<group>"; };
+		97C146EE1CF9000F007C117D /* Runner.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Runner.app; sourceTree = BUILT_PRODUCTS_DIR; };
+		97C146FB1CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = "<group>"; };
+		97C146FD1CF9000F007C117D /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = "<group>"; };
+		97C147001CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = "<group>"; };
+		97C147021CF9000F007C117D /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		97C146EB1CF9000F007C117D /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		331C8082294A63A400263BE5 /* RunnerTests */ = {
+			isa = PBXGroup;
+			children = (
+				331C807B294A618700263BE5 /* RunnerTests.swift */,
+			);
+			path = RunnerTests;
+			sourceTree = "<group>";
+		};
+		9740EEB11CF90186004384FC /* Flutter */ = {
+			isa = PBXGroup;
+			children = (
+				3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */,
+				9740EEB21CF90195004384FC /* Debug.xcconfig */,
+				7AFA3C8E1D35360C0083082E /* Release.xcconfig */,
+				9740EEB31CF90195004384FC /* Generated.xcconfig */,
+			);
+			name = Flutter;
+			sourceTree = "<group>";
+		};
+		97C146E51CF9000F007C117D = {
+			isa = PBXGroup;
+			children = (
+				9740EEB11CF90186004384FC /* Flutter */,
+				97C146F01CF9000F007C117D /* Runner */,
+				97C146EF1CF9000F007C117D /* Products */,
+				331C8082294A63A400263BE5 /* RunnerTests */,
+			);
+			sourceTree = "<group>";
+		};
+		97C146EF1CF9000F007C117D /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				97C146EE1CF9000F007C117D /* Runner.app */,
+				331C8081294A63A400263BE5 /* RunnerTests.xctest */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		97C146F01CF9000F007C117D /* Runner */ = {
+			isa = PBXGroup;
+			children = (
+				97C146FA1CF9000F007C117D /* Main.storyboard */,
+				97C146FD1CF9000F007C117D /* Assets.xcassets */,
+				97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */,
+				97C147021CF9000F007C117D /* Info.plist */,
+				1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */,
+				1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */,
+				74858FAE1ED2DC5600515810 /* AppDelegate.swift */,
+				74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */,
+			);
+			path = Runner;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXNativeTarget section */
+		331C8080294A63A400263BE5 /* RunnerTests */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */;
+			buildPhases = (
+				331C807D294A63A400263BE5 /* Sources */,
+				331C807F294A63A400263BE5 /* Resources */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				331C8086294A63A400263BE5 /* PBXTargetDependency */,
+			);
+			name = RunnerTests;
+			productName = RunnerTests;
+			productReference = 331C8081294A63A400263BE5 /* RunnerTests.xctest */;
+			productType = "com.apple.product-type.bundle.unit-test";
+		};
+		97C146ED1CF9000F007C117D /* Runner */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */;
+			buildPhases = (
+				9740EEB61CF901F6004384FC /* Run Script */,
+				97C146EA1CF9000F007C117D /* Sources */,
+				97C146EB1CF9000F007C117D /* Frameworks */,
+				97C146EC1CF9000F007C117D /* Resources */,
+				9705A1C41CF9048500538489 /* Embed Frameworks */,
+				3B06AD1E1E4923F5004D2608 /* Thin Binary */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = Runner;
+			productName = Runner;
+			productReference = 97C146EE1CF9000F007C117D /* Runner.app */;
+			productType = "com.apple.product-type.application";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		97C146E61CF9000F007C117D /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				BuildIndependentTargetsInParallel = YES;
+				LastUpgradeCheck = 1510;
+				ORGANIZATIONNAME = "";
+				TargetAttributes = {
+					331C8080294A63A400263BE5 = {
+						CreatedOnToolsVersion = 14.0;
+						TestTargetID = 97C146ED1CF9000F007C117D;
+					};
+					97C146ED1CF9000F007C117D = {
+						CreatedOnToolsVersion = 7.3.1;
+						LastSwiftMigration = 1100;
+					};
+				};
+			};
+			buildConfigurationList = 97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */;
+			compatibilityVersion = "Xcode 9.3";
+			developmentRegion = en;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+				Base,
+			);
+			mainGroup = 97C146E51CF9000F007C117D;
+			productRefGroup = 97C146EF1CF9000F007C117D /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				97C146ED1CF9000F007C117D /* Runner */,
+				331C8080294A63A400263BE5 /* RunnerTests */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		331C807F294A63A400263BE5 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		97C146EC1CF9000F007C117D /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */,
+				3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */,
+				97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */,
+				97C146FC1CF9000F007C117D /* Main.storyboard in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXShellScriptBuildPhase section */
+		3B06AD1E1E4923F5004D2608 /* Thin Binary */ = {
+			isa = PBXShellScriptBuildPhase;
+			alwaysOutOfDate = 1;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+				"${TARGET_BUILD_DIR}/${INFOPLIST_PATH}",
+			);
+			name = "Thin Binary";
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" embed_and_thin";
+		};
+		9740EEB61CF901F6004384FC /* Run Script */ = {
+			isa = PBXShellScriptBuildPhase;
+			alwaysOutOfDate = 1;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+			);
+			name = "Run Script";
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/sh;
+			shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" build";
+		};
+/* End PBXShellScriptBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		331C807D294A63A400263BE5 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		97C146EA1CF9000F007C117D /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */,
+				1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		331C8086294A63A400263BE5 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			target = 97C146ED1CF9000F007C117D /* Runner */;
+			targetProxy = 331C8085294A63A400263BE5 /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin PBXVariantGroup section */
+		97C146FA1CF9000F007C117D /* Main.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				97C146FB1CF9000F007C117D /* Base */,
+			);
+			name = Main.storyboard;
+			sourceTree = "<group>";
+		};
+		97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */ = {
+			isa = PBXVariantGroup;
+			children = (
+				97C147001CF9000F007C117D /* Base */,
+			);
+			name = LaunchScreen.storyboard;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		249021D3217E4FDB00AE95B9 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 12.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				SUPPORTED_PLATFORMS = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Profile;
+		};
+		249021D4217E4FDB00AE95B9 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			DefaultConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
+				ENABLE_BITCODE = NO;
+				INFOPLIST_FILE = Runner/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.example.aitube2;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
+				SWIFT_VERSION = 5.0;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Profile;
+		};
+		331C8088294A63A400263BE5 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				BUNDLE_LOADER = "$(TEST_HOST)";
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 1;
+				GENERATE_INFOPLIST_FILE = YES;
+				MARKETING_VERSION = 1.0;
+				PRODUCT_BUNDLE_IDENTIFIER = com.example.aitube2.RunnerTests;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 5.0;
+				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner";
+			};
+			name = Debug;
+		};
+		331C8089294A63A400263BE5 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				BUNDLE_LOADER = "$(TEST_HOST)";
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 1;
+				GENERATE_INFOPLIST_FILE = YES;
+				MARKETING_VERSION = 1.0;
+				PRODUCT_BUNDLE_IDENTIFIER = com.example.aitube2.RunnerTests;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_VERSION = 5.0;
+				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner";
+			};
+			name = Release;
+		};
+		331C808A294A63A400263BE5 /* Profile */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				BUNDLE_LOADER = "$(TEST_HOST)";
+				CODE_SIGN_STYLE = Automatic;
+				CURRENT_PROJECT_VERSION = 1;
+				GENERATE_INFOPLIST_FILE = YES;
+				MARKETING_VERSION = 1.0;
+				PRODUCT_BUNDLE_IDENTIFIER = com.example.aitube2.RunnerTests;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_VERSION = 5.0;
+				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner";
+			};
+			name = Profile;
+		};
+		97C147031CF9000F007C117D /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_TESTABILITY = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 12.0;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				ONLY_ACTIVE_ARCH = YES;
+				SDKROOT = iphoneos;
+				TARGETED_DEVICE_FAMILY = "1,2";
+			};
+			name = Debug;
+		};
+		97C147041CF9000F007C117D /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INFINITE_RECURSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
+				CLANG_WARN_SUSPICIOUS_MOVE = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_NS_ASSERTIONS = NO;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				ENABLE_USER_SCRIPT_SANDBOXING = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 12.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				SDKROOT = iphoneos;
+				SUPPORTED_PLATFORMS = iphoneos;
+				SWIFT_COMPILATION_MODE = wholemodule;
+				SWIFT_OPTIMIZATION_LEVEL = "-O";
+				TARGETED_DEVICE_FAMILY = "1,2";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+		97C147061CF9000F007C117D /* Debug */ = {
+			isa = XCBuildConfiguration;
+			DefaultConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
+				ENABLE_BITCODE = NO;
+				INFOPLIST_FILE = Runner/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.example.aitube2;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
+				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 5.0;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Debug;
+		};
+		97C147071CF9000F007C117D /* Release */ = {
+			isa = XCBuildConfiguration;
+			DefaultConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */;
+			buildSettings = {
+				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
+				CLANG_ENABLE_MODULES = YES;
+				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
+				ENABLE_BITCODE = NO;
+				INFOPLIST_FILE = Runner/Info.plist;
+				LD_RUNPATH_SEARCH_PATHS = (
+					"$(inherited)",
+					"@executable_path/Frameworks",
+				);
+				PRODUCT_BUNDLE_IDENTIFIER = com.example.aitube2;
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
+				SWIFT_VERSION = 5.0;
+				VERSIONING_SYSTEM = "apple-generic";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				331C8088294A63A400263BE5 /* Debug */,
+				331C8089294A63A400263BE5 /* Release */,
+				331C808A294A63A400263BE5 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				97C147031CF9000F007C117D /* Debug */,
+				97C147041CF9000F007C117D /* Release */,
+				249021D3217E4FDB00AE95B9 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				97C147061CF9000F007C117D /* Debug */,
+				97C147071CF9000F007C117D /* Release */,
+				249021D4217E4FDB00AE95B9 /* Profile */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 97C146E61CF9000F007C117D /* Project object */;
+}

ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:">
+   </FileRef>
+</Workspace>

ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>PreviewsEnabled</key>
+	<false/>
+</dict>
+</plist>

ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme

@@ -0,0 +1,98 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "1510"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "97C146ED1CF9000F007C117D"
+               BuildableName = "Runner.app"
+               BlueprintName = "Runner"
+               ReferencedContainer = "container:Runner.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "97C146ED1CF9000F007C117D"
+            BuildableName = "Runner.app"
+            BlueprintName = "Runner"
+            ReferencedContainer = "container:Runner.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <Testables>
+         <TestableReference
+            skipped = "NO"
+            parallelizable = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "331C8080294A63A400263BE5"
+               BuildableName = "RunnerTests.xctest"
+               BlueprintName = "RunnerTests"
+               ReferencedContainer = "container:Runner.xcodeproj">
+            </BuildableReference>
+         </TestableReference>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "97C146ED1CF9000F007C117D"
+            BuildableName = "Runner.app"
+            BlueprintName = "Runner"
+            ReferencedContainer = "container:Runner.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Profile"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <BuildableProductRunnable
+         runnableDebuggingMode = "0">
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "97C146ED1CF9000F007C117D"
+            BuildableName = "Runner.app"
+            BlueprintName = "Runner"
+            ReferencedContainer = "container:Runner.xcodeproj">
+         </BuildableReference>
+      </BuildableProductRunnable>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

ios/Runner.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "group:Runner.xcodeproj">
+   </FileRef>
+</Workspace>

ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>PreviewsEnabled</key>
+	<false/>
+</dict>
+</plist>

ios/Runner/AppDelegate.swift

@@ -0,0 +1,13 @@
+import Flutter
+import UIKit
+
+@main
+@objc class AppDelegate: FlutterAppDelegate {
+  override func application(
+    _ application: UIApplication,
+    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
+  ) -> Bool {
+    GeneratedPluginRegistrant.register(with: self)
+    return super.application(application, didFinishLaunchingWithOptions: launchOptions)
+  }
+}

ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,122 @@
+{
+  "images" : [
+    {
+      "size" : "20x20",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "20x20",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "3x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "1x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "3x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "3x"
+    },
+    {
+      "size" : "60x60",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "60x60",
+      "idiom" : "iphone",
+      "filename" : "[email protected]",
+      "scale" : "3x"
+    },
+    {
+      "size" : "20x20",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "1x"
+    },
+    {
+      "size" : "20x20",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "1x"
+    },
+    {
+      "size" : "29x29",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "1x"
+    },
+    {
+      "size" : "40x40",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "76x76",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "1x"
+    },
+    {
+      "size" : "76x76",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "83.5x83.5",
+      "idiom" : "ipad",
+      "filename" : "[email protected]",
+      "scale" : "2x"
+    },
+    {
+      "size" : "1024x1024",
+      "idiom" : "ios-marketing",
+      "filename" : "[email protected]",
+      "scale" : "1x"
+    }
+  ],
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  }
+}