Video Transform

No algorithm description given

Video Transform This algorithm uses an image processing algorithm to alter each frame of a video, then recombines it back into a freshly transformed video file. note: This algorithm takes longer than most other algorithms as it recursively calls an image algorithm over each frame of a video file, make sure to add a custom timeout to your algorithm call. note: This algorithm is royalty free, but the image processing algorithms it can call might not be, check your account's credit balance before running this algorithm on a custom video. Table of Contents Input Output Default Options Examples credits Algorithm Console Input input_file: String,
output_file: String,
algorithm: String,
advanced_input: Json,
fps: Double
 input_file - (required) - The input url of the video file, can be any standard video container format (mp4, mkv, avi, etc), can be an http/https url or a data connector uri( data:// , s3:// , dropbox:// , etc). output_file - (required) - The output url of the altered video file, must be a data connector uri ( data:// , s3:// , dropbox:// , etc). algorithm - (required) - The image processing algorithmia algorithm uri, if no default mode is found for that algorithm, advanced_input must be defined. advanced_input - (optional) - if you have advanced requirements or want to use an algorithm with no default parameters, See Advanced Input . fps - (optional) - If you have a desired fps sampling rate, input it here. defaults to the input video's fps. Advanced Input If advanced_input is found, this algorithm will parse it as a json object; finding and replacing keywords relating to uploading and downloading files in both batch and single form with paths that the Video Transform algorithm uses. The keywords are: $SINGLE_INPUT - whenever you see a single image input path for an algorithm, this keyword will work $SINGLE_OUTPUT whenever you see a single image output path for an algorithm, this keyword will work $BATCH_INPUT - similar to single input keyword, but works for arrays of input files (DeepFilter for example) $BATCH_OUTPUT - similar to single input keyword, but works for arrays of input files (DeepFilter for example) Example: SalNet algorithm default input {
 "image": "data://deeplearning/example_data/mona_lisa.jpg",
 "location": "data://.algo/temp/test42.png"
 Video Transform with advanced salnet input 
 "input_file": "data://path/to/file.mp4",
 "output_file": "data://save/file.mp4,
 "algorithm": "algo://deeplearning/SalNet/0.1.6",
 "advanced_input": {
 "image": "$SINGLE_INPUT",
 "location": "$SINGLE_OUTPUT"
 "fps": Double
 Output { 
 "output_file": String
 output_file - the complete algorithmia URI for where the output video file has been uploaded to. Default Options This algorithm has default parameters set up for a number of algorithms, this list will grow as new image altering algorithms are released: DeepFilter - uses version 0.3.2 , filterName is gan_vogh (deeplearning/DeepFilter) SalNet - uses version 0.1.6 (deeplearning/SalNet) Colorful Image Colorization - uses version 1.0.1 (deeplearning/ColorfulImageColorization) Examples DeepFilter default input { 
 DeepFilter advanced input { 
 SalNet default input with fps { 
 "fps": 14.24
 Credits All video processing is handled by FFMpeg , which is a fantastic video/image manipulation tool that can be found here

(no tags)

Cost Breakdown

0 cr
royalty per call
1 cr
usage per second
avg duration
This algorithm has permission to call other algorithms which may incur separate royalty and usage costs.

Cost Calculator

API call duration (sec)
API calls
Estimated cost
per calls
for large volume discounts
For additional details on how pricing works, see Algorithmia pricing.

Internet access

This algorithm has Internet access. This is necessary for algorithms that rely on external services, however it also implies that this algorithm is able to send your input data outside of the Algorithmia platform.

Calls other algorithms

This algorithm has permission to call other algorithms. This allows an algorithm to compose sophisticated functionality using other algorithms as building blocks, however it also carries the potential of incurring additional royalty and usage costs from any algorithm that it calls.

To understand more about how algorithm permissions work, see the permissions documentation.

1. Type your input

2. See the result

Running algorithm...

3. Use this algorithm

curl -X POST -d '{{input | formatInput:"curl"}}' -H 'Content-Type: application/json' -H 'Authorization: Simple YOUR_API_KEY'
View cURL Docs
algo auth
algo run algo://media/VideoTransform/0.2.21 -d '{{input | formatInput:"cli"}}'
View CLI Docs
import (
  algorithmia ""

input := {{input | formatInput:"go"}}

var client = algorithmia.NewClient("YOUR_API_KEY", "")
algo, _ := client.Algo("algo://media/VideoTransform/0.2.21")
resp, _ := algo.Pipe(input)
response := resp.(*algorithmia.AlgoResponse)
View Go Docs
import com.algorithmia.*;
import com.algorithmia.algo.*;

String input = "{{input | formatInput:"java"}}";
AlgorithmiaClient client = Algorithmia.client("YOUR_API_KEY");
Algorithm algo = client.algo("algo://media/VideoTransform/0.2.21");
AlgoResponse result = algo.pipeJson(input);
View Java Docs
import com.algorithmia._
import com.algorithmia.algo._

val input = {{input | formatInput:"scala"}}
val client = Algorithmia.client("YOUR_API_KEY")
val algo = client.algo("algo://media/VideoTransform/0.2.21")
val result = algo.pipeJson(input)
View Scala Docs
var input = {{input | formatInput:"javascript"}};
           .then(function(output) {
View Javascript Docs
var input = {{input | formatInput:"javascript"}};
           .then(function(response) {
View NodeJS Docs
import Algorithmia

input = {{input | formatInput:"python"}}
client = Algorithmia.client('YOUR_API_KEY')
algo = client.algo('media/VideoTransform/0.2.21')
print algo.pipe(input)
View Python Docs

input <- {{input | formatInput:"r"}}
client <- getAlgorithmiaClient("YOUR_API_KEY")
algo <- client$algo("media/VideoTransform/0.2.21")
result <- algo$pipe(input)$result
View R Docs
require 'algorithmia'

input = {{input | formatInput:"ruby"}}
client = Algorithmia.client('YOUR_API_KEY')
algo = client.algo('media/VideoTransform/0.2.21')
puts algo.pipe(input).result
View Ruby Docs
use algorithmia::*;

let input = {{input | formatInput:"rust"}};
let client = Algorithmia::client("YOUR_API_KEY");
let algo = client.algo("media/VideoTransform/0.2.21");
let response = algo.pipe(input);
View Rust Docs
import Algorithmia

let input = "{{input | formatInput:"swift"}}";
let client = Algorithmia.client(simpleKey: "YOUR_API_KEY")
let algo = client.algo(algoUri: "media/VideoTransform/0.2.21") { resp, error in
View Swift Docs
  • {{comment.username}}