@revideo/create 0.3.7-alpha.975 → 0.3.7-beta.987

package/examples/google-cloud-run/package.json

@@ -1,28 +0,0 @@
-{
-  "name": "google-cloud-run",
-  "private": true,
-  "version": "0.0.0",
-  "scripts": {
-    "start": "vite",
-    "serve": "tsc && node dist/index.js",
-    "build": "tsc && vite build",
-    "render": "tsc && node dist/render.js"
-  },
-  "dependencies": {
-    "@revideo/2d": "0.3.3",
-    "@revideo/core": "0.3.3",
-    "@revideo/ffmpeg": "0.3.3",
-    "@revideo/renderer": "0.3.3",
-    "@revideo/vite-plugin": "0.3.3",
-    "express": "^4.19.2",
-    "uuid": "^9.0.1"
-  },
-  "devDependencies": {
-    "@revideo/cli": "^0.3.3",
-    "@revideo/ui": "0.3.3",
-    "@types/express": "^4.17.21",
-    "@types/uuid": "^9.0.8",
-    "typescript": "^5.2.2",
-    "vite": "^4.5"
-  }
-}

package/examples/google-cloud-run/src/index.ts

@@ -1,39 +0,0 @@
-import { renderVideo } from '@revideo/renderer';
-import { v4 as uuidv4 } from 'uuid';
-import * as express from 'express';
-import * as fs from 'fs';
-import * as path from 'path';
-
-const app = express();
-app.use(express.json());
-
-app.get('/', (req, res) => {
-  res.status(200).send(`Hello World!`);
-});
-
-app.post('/render', async (req, res) => {
-  try {
-    const { variables } = req.body;
-    const jobId = uuidv4();
-
-    console.log("Rendering video...")
-    await renderVideo("./vite.config.ts", variables, () => {}, { name: jobId, logProgress: true, puppeteer: { args: ['--no-sandbox', '--disable-setuid-sandbox'] }});
-    console.log("Finished rendering")
-
-    const outputFilePath = path.join(process.cwd(), `./output/${jobId}.mp4`);
-    
-    if (fs.existsSync(outputFilePath)) {
-      res.sendFile(outputFilePath); // alternatively (and recommended), upload file to a bucket
-    } else {
-      res.status(500).send('Rendered video not found');
-    }
-  } catch (err) {
-    console.error('Error rendering video:', err);
-    res.status(500).send('Error rendering video');
-  }
-});
-
-const port = parseInt(process.env.PORT) || 8080;
-app.listen(port, () => {
-  console.log(`listening on port ${port}`);
-});

package/examples/google-cloud-run/src/project.meta

@@ -1,31 +0,0 @@
-{
-  "version": 0,
-  "shared": {
-    "background": null,
-    "range": [
-      0,
-      null
-    ],
-    "size": {
-      "x": 1920,
-      "y": 1080
-    },
-    "audioOffset": 0
-  },
-  "preview": {
-    "fps": 30,
-    "resolutionScale": 1
-  },
-  "rendering": {
-    "fps": 30,
-    "resolutionScale": 1,
-    "colorSpace": "srgb",
-    "exporter": {
-      "name": "@revideo/core/ffmpeg",
-      "options": {
-        "fastStart": true,
-        "includeAudio": true
-      }
-    }
-  }
-}

package/examples/google-cloud-run/src/project.ts

@@ -1,7 +0,0 @@
-import {makeProject} from '@revideo/core';
-
-import example from './scenes/example?scene';
-
-export default makeProject({
-  scenes: [example],
-});

package/examples/google-cloud-run/src/revideo.d.ts

@@ -1 +0,0 @@
-/// <reference types="@revideo/core/project" />

package/examples/google-cloud-run/src/scenes/example.meta

@@ -1,5 +0,0 @@
-{
-  "version": 0,
-  "timeEvents": [],
-  "seed": 2544124688
-}

package/examples/google-cloud-run/src/scenes/example.tsx

@@ -1,30 +0,0 @@
-import {Audio, Txt, Video, makeScene2D} from '@revideo/2d';
-import {all, chain, createRef, waitFor, useScene} from '@revideo/core';
-
-export default makeScene2D(function* (view) {
-  const textRef = createRef<Txt>();
-
-  yield view.add(
-    <>
-      <Video
-        src={'https://revideo-example-assets.s3.amazonaws.com/stars.mp4'}
-        size={['100%', '100%']}
-        play={true}
-      />
-      <Audio
-        src={'https://revideo-example-assets.s3.amazonaws.com/chill-beat.mp3'}
-        play={true}
-        time={17.0}
-      />
-    </>,
-  );
-
-  yield* waitFor(1);
-
-  view.add(
-    <Txt fontFamily={"Sans-Serif"} fill={"white"} fontSize={10} ref={textRef}>Hello {useScene().variables.get("username", "user")()}</Txt>
-  );
-
-  yield* textRef().scale(10, 1);
-  yield* waitFor(2);
-});

package/examples/google-cloud-run/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "@revideo/2d/tsconfig.project.json",
-  "include": ["src"],
-  "compilerOptions": {
-    "noEmit": false,
-    "outDir": "dist",
-    "module": "CommonJS"
-  }
-}

package/examples/google-cloud-run/vite.config.ts

@@ -1,9 +0,0 @@
-import {defineConfig} from 'vite';
-import motionCanvas from '@revideo/vite-plugin';
-
-
-export default defineConfig({
-  plugins: [
-    motionCanvas(),
-  ],
-});

package/examples/google-cloud-run-parallelized/README.md

@@ -1,127 +0,0 @@
-# Parallel Rendering with Cloud Functions
-
-This project shows you how you can parallelize rendering across multiple Google Cloud functions to get much faster rendering speeds. Instead of rendering, say, 60 seconds of video in one process, we can also use 30 cloud functions to render 2s of video each, and afterwards stitch together the resulting partial videos.
-
-In this example, we are going to deploy two services to Google Cloud:
-
-- `/render-worker`: This is a Google Cloud Function that is responsible for rendering a partial video. It has access to your video template (`/render-worker/src/scenes`) and receives the number of total workers as well as its worker ID as an input. It accordingly exports the audio and visuals of the partial video.
-  
-- `/render-orchestrator`: This is a minimal Google Cloud Run service that manages the render workers and is your entrypoint to start rendering jobs. It receives rendering requests along with the number of desired workers, accordingly sends partial render requests to the render workers and merges their results together to obtain the final video
-  
-## Getting Started
-
-To get started, clone the `revideo-examples` repository and navigate to the `google-cloud-run-parallelized` directory.
-
-### Enable gcloud services
-
-To set up your Google Cloud services, ensure that you have the gcloud CLI installed ([guide](https://cloud.google.com/sdk/docs/install)). Then, enable the required services to deploy Cloud Functions:
-
-```
-gcloud services enable run.googleapis.com
-gcloud services enable cloudfunctions.googleapis.com
-gcloud services enable storage.googleapis.com
-gcloud services enable cloudbuild.googleapis.com
-```
-
-### Create Storage Bucket
-
-You'll need a storage bucket to save your videos as well as partial videos to. To create one, run the following command and replace `<your-region>` with your desired region (e.g. `us-east1`):
-
-```
-gsutil mb -l <your-region> gs://<your-bucket-name>/
-```
-
-Now enable public read access by running the following command:
-
-```
-gsutil iam ch allUsers:objectViewer gs://<your-bucket-name>/
-```
-
-Finally, you need to modify the CORS settings of your bucket. To do so, create the following file `cors_config.json`:
-
-```
-[
-  {
-    "origin": ["*"],
-    "responseHeader": ["Content-Type"],
-    "method": ["GET", "HEAD", "DELETE"],
-    "maxAgeSeconds": 3600
-  }
-]
-```
-
-Now run:
-
-```
-gsutil cors set cors_config.json gs://<your-bucket-name>/
-```
-
-Now you can deploy your render worker cloud function.
-
-
-### Deploy Render Worker Cloud Function
-
-To deploy the render worker cloud function, navigate to `/render-worker` and run `npm install`. Now run the following command:
-
-🚨 **Note:** In the commands below, make sure to select the same region (<your-region>) as the bucket you just created. Otherwise, your render jobs will run much slower.
-
-```
-gcloud functions deploy render-worker \
---runtime nodejs18 \
---trigger-http \
---allow-unauthenticated \
---gen2 \
---memory 4Gi \
---cpu 2 \
---concurrency=1 \
---timeout=3600s \
---region=<your-region> \
---set-env-vars=FFMPEG_PATH=ffmpeg,FFPROBE_PATH=ffprobe,GCP_BUCKET_NAME=<your-bucket-name>
-```
-
-You'll now have to wait some time for the deployment. Once your cloud function is deployed, its URL will be logged to the terminal (we will reference it as `<your-render-function-url>`). You will need this URL to configure your cloud run service that calls the cloud function you just deployed.
-
-
-### Deploy Render Orchestrator Cloud Run Service
-
-To deploy the service that orchestrates the cloud functions, navigate to `/render-orchestrator`, then run `npm install` and the following command:
-
-```
-gcloud run deploy render-orchestrator \
---source . \
---memory 8Gi \
---cpu 4 \
---allow-unauthenticated \
---concurrency=1 \
---timeout=3600s \
---region <your-region> \
---set-env-vars=FFMPEG_PATH=ffmpeg,FFPROBE_PATH=ffprobe,GCP_BUCKET_NAME=<your-bucket-name>,RENDER_WORKER_URL=<your-render-function-url>
-```
-
-Again, you'll have to wait a bit for the service to be deployed. Once that is done, you can send a request to its url `<your-render-orchestrator-url>`.
-
-### Sending a Request
-
-Once the render worker and orchestrator are running, you can send a render request as follows:
-
-```
-curl -X POST <your-render-orchestrator-url>/render \
--H "Content-Type: application/json" \
--d '{"variables": {"username": "John"}, "numWorkers": 5}'
-```
-
-This will distribute the rendering work across five cloud functions. You can check out the logs and rendering progress in the Google Cloud Function logs.
-
-
-## Usage Notes
-
-Some useful information, as well as considerations on what parameters to use:
-
-**Cold Start times:**
-Depending on your previous usage, your Google Cloud account & project might not be prioritized for cold start times, and thus the bottleneck of your render speeds might be cold start tiems. You can check the logs of your render worker function to see how fast the render workers spin up after sending the request. For example, we have noticed that after creating a new Google Cloud project, we sometimes had to wait for 30s+ for a render worker to spin up, whereas cold start times were very fast on a project that we had been using for a lot of time already.
-
-**Video Duration:**
-Parallel rendering is especially effective for longer videos (>1 min). For short videos, the overhead of waiting for a bunch of cloud functions to cold boot may not be worth it
-
-**Choosing the number of workers:**
-Depending on the length of the video you're going to render, you might want to adjust the `numWorkers` parameter. A single worker should not render less than a second of video

package/examples/google-cloud-run-parallelized/render-orchestrator/Dockerfile

@@ -1,56 +0,0 @@
-FROM node:18-bullseye
-
-RUN apt-get update && apt-get install -y \
-    nscd \
-    libnss3 \
-    libdbus-1-3 \
-    libatk1.0-0 \
-    libatk-bridge2.0-0 \
-    libcups2 \
-    libxkbcommon0 \
-    libxcomposite1 \
-    libxdamage1 \
-    libxrandr2 \
-    libgbm1 \
-    libpango-1.0-0 \
-    libcairo2 \
-    libasound2 \
-    libatspi2.0-0 
-
-RUN apt-get install -y libxfixes3
-
-WORKDIR /usr/src/app
-
-RUN wget https://github.com/eugeneware/ffmpeg-static/releases/download/b6.0/ffmpeg-linux-x64
-
-RUN chmod +x ffmpeg-linux-x64
-
-RUN mv ffmpeg-linux-x64 ffmpeg
-
-RUN mv ffmpeg /usr/local/bin/
-
-ENV FFMPEG_PATH=ffmpeg
-
-RUN wget https://github.com/eugeneware/ffmpeg-static/releases/download/b6.0/ffprobe-linux-x64
-
-RUN chmod +x ffprobe-linux-x64
-
-RUN mv ffprobe-linux-x64 ffprobe
-
-RUN mv ffprobe /usr/local/bin/
-
-ENV FFPROBE_PATH=ffprobe
-
-COPY package*.json ./
-
-COPY . ./
-
-RUN npm install
-
-RUN npx puppeteer browsers install chrome
-
-RUN apt-get update && apt-get install -y nscd libnss3
-
-RUN ffmpeg -version
-
-CMD service nscd start && npm run serve