Implement HTTP Live Streaming (HLS)

{
  ":original": {
    "robot": "/upload/handle"
  },
  "low": {
    "robot": "/video/encode",
    "use": ":original",
    "ffmpeg_stack": "v4.3.1",
    "preset": "hls-270p",
    "turbo": true
  },
  "mid": {
    "robot": "/video/encode",
    "use": ":original",
    "ffmpeg_stack": "v4.3.1",
    "preset": "hls-360p",
    "turbo": true
  },
  "high": {
    "robot": "/video/encode",
    "use": ":original",
    "ffmpeg_stack": "v4.3.1",
    "preset": "hls-540p",
    "turbo": true
  },
  "adaptive": {
    "robot": "/video/adaptive",
    "use": {
      "steps": [
        "low",
        "mid",
        "high"
      ],
      "bundle_steps": true
    },
    "technique": "hls",
    "playlist_name": "my_playlist.m3u8",
    "ffmpeg_stack": "v4.3.1"
  },
  "exported": {
    "robot": "/s3/store",
    "use": [
      "adaptive",
      ":original"
    ],
    "path": "hlsdemo/${file.meta.relative_path}/${file.name}",
    "credentials": "YOUR_AWS_CREDENTIALS",
    "url_prefix": "https://demos.transloadit.com/"
  }
}

# Prerequisites: brew install curl jq || sudo apt install curl jq
# To avoid tampering, use Signature Authentication
echo '{
  "auth": {
    "key": "YOUR_TRANSLOADIT_KEY"
  },
  "steps":   {
    ":original": {
      "robot": "/upload/handle"
    },
    "low": {
      "robot": "/video/encode",
      "use": ":original",
      "ffmpeg_stack": "v4.3.1",
      "preset": "hls-270p",
      "turbo": true
    },
    "mid": {
      "robot": "/video/encode",
      "use": ":original",
      "ffmpeg_stack": "v4.3.1",
      "preset": "hls-360p",
      "turbo": true
    },
    "high": {
      "robot": "/video/encode",
      "use": ":original",
      "ffmpeg_stack": "v4.3.1",
      "preset": "hls-540p",
      "turbo": true
    },
    "adaptive": {
      "robot": "/video/adaptive",
      "use": {
        "steps": [
          "low",
          "mid",
          "high"
        ],
        "bundle_steps": true
      },
      "technique": "hls",
      "playlist_name": "my_playlist.m3u8",
      "ffmpeg_stack": "v4.3.1"
    },
    "exported": {
      "robot": "/s3/store",
      "use": [
        "adaptive",
        ":original"
      ],
      "path": "hlsdemo/${file.meta.relative_path}/${file.name}",
      "credentials": "YOUR_AWS_CREDENTIALS",
      "url_prefix": "https://demos.transloadit.com/"
    }
  }
}' |curl \\
    --request POST \\
    --form 'params=<-' \\
    --form my_file1=@./surf.mp4 \\
  https://api2.transloadit.com/assemblies \\
|jq

// Add 'Transloadit' to your Podfile, run 'pod install', add credentials to 'Info.plist'
import Arcane
import TransloaditKit

// Set Encoding Instructions
var AssemblySteps: Array = Array<Step>() // An array to hold the Steps

var Step1 = Step (key: ":original") // Create a Step object
Step1?.setValue("/upload/handle", forOption: "robot") // Add the details
AssemblySteps.append(Step1) // Add the Step to the array

var Step2 = Step (key: "low") // Create a Step object
Step2?.setValue(":original", forOption: "use") // Add the details
Step2?.setValue("/video/encode", forOption: "robot") // Add the details
Step2?.setValue("v4.3.1", forOption: "ffmpeg_stack") // Add the details
Step2?.setValue("hls-270p", forOption: "preset") // Add the details
Step2?.setValue(true, forOption: "turbo") // Add the details
AssemblySteps.append(Step2) // Add the Step to the array

var Step3 = Step (key: "mid") // Create a Step object
Step3?.setValue(":original", forOption: "use") // Add the details
Step3?.setValue("/video/encode", forOption: "robot") // Add the details
Step3?.setValue("v4.3.1", forOption: "ffmpeg_stack") // Add the details
Step3?.setValue("hls-360p", forOption: "preset") // Add the details
Step3?.setValue(true, forOption: "turbo") // Add the details
AssemblySteps.append(Step3) // Add the Step to the array

var Step4 = Step (key: "high") // Create a Step object
Step4?.setValue(":original", forOption: "use") // Add the details
Step4?.setValue("/video/encode", forOption: "robot") // Add the details
Step4?.setValue("v4.3.1", forOption: "ffmpeg_stack") // Add the details
Step4?.setValue("hls-540p", forOption: "preset") // Add the details
Step4?.setValue(true, forOption: "turbo") // Add the details
AssemblySteps.append(Step4) // Add the Step to the array

var Step5 = Step (key: "adaptive") // Create a Step object
Step5?.setValue({"steps":["low","mid","high"],"bundle_steps":true}, forOption: "use") // Add the details
Step5?.setValue("/video/adaptive", forOption: "robot") // Add the details
Step5?.setValue("v4.3.1", forOption: "ffmpeg_stack") // Add the details
Step5?.setValue("my_playlist.data.m3u8", forOption: "playlist_name") // Add the details
Step5?.setValue("hls", forOption: "technique") // Add the details
AssemblySteps.append(Step5) // Add the Step to the array

var Step6 = Step (key: "exported") // Create a Step object
Step6?.setValue(["adaptive",":original"], forOption: "use") // Add the details
Step6?.setValue("/s3/store", forOption: "robot") // Add the details
Step6?.setValue("YOUR_AWS_CREDENTIALS", forOption: "credentials") // Add the details
Step6?.setValue("hlsdemo/${file.meta.relative_path}/${file.name}", forOption: "path") // Add the details
Step6?.setValue("https://demos.transloadit.com/", forOption: "url_prefix") // Add the details
AssemblySteps.append(Step6) // Add the Step to the array

// We then create an Assembly Object with the Steps and files
var MyAssembly: Assembly = Assembly(steps: AssemblySteps, andNumberOfFiles: 1)

// Add files to upload
MyAssembly.addFile("./surf.mp4")

// Start the Assembly
Transloadit.createAssembly(MyAssembly) 

// Fires after your Assembly has completed
transloadit.assemblyStatusBlock = {(_ completionDictionary: [AnyHashable: Any]) -> Void in
  print("\(completionDictionary.description)")
}

<body>
  <form action="/uploads" enctype="multipart/form-data" method="POST">
    <input type="file" name="my_file" multiple="multiple" />
  </form>

  <script src="//ajax.googleapis.com/ajax/libs/jquery/3.2.0/jquery.min.js"></script>
  <script src="//assets.transloadit.com/js/jquery.transloadit2-v3-latest.js"></script>
  <script type="text/javascript">
  $(function() {
    $('form').transloadit({
      wait: true,
      triggerUploadOnFileSelection: true,
      params: {
        auth: {
          // To avoid tampering use signatures:
          // https://transloadit.com/docs/api/#authentication
          key: 'YOUR_TRANSLOADIT_KEY',
        },
        // It's often better store encoding instructions in your account
        // and use a `template_id` instead of adding these steps inline
        steps: {
          ':original': {
            robot: '/upload/handle'
          },
          low: {
            use: ':original',
            robot: '/video/encode',
            ffmpeg_stack: 'v4.3.1',
            preset: 'hls-270p',
            turbo: true
          },
          mid: {
            use: ':original',
            robot: '/video/encode',
            ffmpeg_stack: 'v4.3.1',
            preset: 'hls-360p',
            turbo: true
          },
          high: {
            use: ':original',
            robot: '/video/encode',
            ffmpeg_stack: 'v4.3.1',
            preset: 'hls-540p',
            turbo: true
          },
          adaptive: {
            use: {'steps':['low','mid','high'],'bundle_steps':true},
            robot: '/video/adaptive',
            ffmpeg_stack: 'v4.3.1',
            playlist_name: 'my_playlist.data.m3u8',
            technique: 'hls'
          },
          exported: {
            use: ['adaptive',':original'],
            robot: '/s3/store',
            credentials: 'YOUR_AWS_CREDENTIALS',
            path: 'hlsdemo/${file.meta.relative_path}/${file.name}',
            url_prefix: 'https://demos.transloadit.com/'
          }
        }
      }
    });
  });
  </script>
</body>

// yarn add transloadit || npm i transloadit --save-exact
const Transloadit = require('transloadit')

const transloadit = new Transloadit({
  authKey: 'YOUR_TRANSLOADIT_KEY',
  authSecret: 'YOUR_TRANSLOADIT_SECRET'
})

// Set Encoding Instructions
const options = {
  files: {
    // Add files to upload
    'myfile_1': './surf.mp4',
  },
  params: {
    steps: {
      ':original': {
        robot: '/upload/handle',
      },
      low: {
        use: ':original',
        robot: '/video/encode',
        ffmpeg_stack: 'v4.3.1',
        preset: 'hls-270p',
        turbo: true,
      },
      mid: {
        use: ':original',
        robot: '/video/encode',
        ffmpeg_stack: 'v4.3.1',
        preset: 'hls-360p',
        turbo: true,
      },
      high: {
        use: ':original',
        robot: '/video/encode',
        ffmpeg_stack: 'v4.3.1',
        preset: 'hls-540p',
        turbo: true,
      },
      adaptive: {
        use: {'steps':['low','mid','high'],'bundle_steps':true},
        robot: '/video/adaptive',
        ffmpeg_stack: 'v4.3.1',
        playlist_name: 'my_playlist.data.m3u8',
        technique: 'hls',
      },
      exported: {
        use: ['adaptive',':original'],
        robot: '/s3/store',
        credentials: 'YOUR_AWS_CREDENTIALS',
        path: 'hlsdemo/${file.meta.relative_path}/${file.name}',
        url_prefix: 'https://demos.transloadit.com/',
      },
    }
  }
}
// Start the Assembly
const result = await transloadit.createAssembly(options)
console.log({ result })

[sudo] npm install transloadify -g

export TRANSLOADIT_KEY="YOUR_TRANSLOADIT_KEY"
export TRANSLOADIT_SECRET="YOUR_TRANSLOADIT_SECRET"

# Save Encoding Instructions
echo '{
  ":original": {
    "robot": "/upload/handle"
  },
  "low": {
    "robot": "/video/encode",
    "use": ":original",
    "ffmpeg_stack": "v4.3.1",
    "preset": "hls-270p",
    "turbo": true
  },
  "mid": {
    "robot": "/video/encode",
    "use": ":original",
    "ffmpeg_stack": "v4.3.1",
    "preset": "hls-360p",
    "turbo": true
  },
  "high": {
    "robot": "/video/encode",
    "use": ":original",
    "ffmpeg_stack": "v4.3.1",
    "preset": "hls-540p",
    "turbo": true
  },
  "adaptive": {
    "robot": "/video/adaptive",
    "use": {
      "steps": [
        "low",
        "mid",
        "high"
      ],
      "bundle_steps": true
    },
    "technique": "hls",
    "playlist_name": "my_playlist.m3u8",
    "ffmpeg_stack": "v4.3.1"
  },
  "exported": {
    "robot": "/s3/store",
    "use": [
      "adaptive",
      ":original"
    ],
    "path": "hlsdemo/${file.meta.relative_path}/${file.name}",
    "credentials": "YOUR_AWS_CREDENTIALS",
    "url_prefix": "https://demos.transloadit.com/"
  }
}' > ./steps.json

transloadify \
  --input "./surf.mp4" \
  --output "./output.example" \
  --steps "./steps.json"  

// composer require transloadit/php-sdk
use transloadit\Transloadit;
$transloadit = new Transloadit([
  "key" => "YOUR_TRANSLOADIT_KEY",
  "secret" => "YOUR_TRANSLOADIT_SECRET",
]);

// Add files to upload
$files = [];
array_push($files, "./surf.mp4")

// Start the Assembly
$response = $transloadit->createAssembly([
  "files" => $files, 
  "params" => [
    "steps" => [
      ":original" => [
        "robot" => "/upload/handle",
      ],
      "low" => [
        "use" => ":original",
        "robot" => "/video/encode",
        "ffmpeg_stack" => "v4.3.1",
        "preset" => "hls-270p",
        "turbo" => true,
      ],
      "mid" => [
        "use" => ":original",
        "robot" => "/video/encode",
        "ffmpeg_stack" => "v4.3.1",
        "preset" => "hls-360p",
        "turbo" => true,
      ],
      "high" => [
        "use" => ":original",
        "robot" => "/video/encode",
        "ffmpeg_stack" => "v4.3.1",
        "preset" => "hls-540p",
        "turbo" => true,
      ],
      "adaptive" => [
        "use" => [
          "steps" => ["low", "mid", "high"],
          "bundle_steps" => true,
        ],
        "robot" => "/video/adaptive",
        "ffmpeg_stack" => "v4.3.1",
        "playlist_name" => "my_playlist.data.m3u8",
        "technique" => "hls",
      ],
      "exported" => [
        "use" => ["adaptive", ":original"],
        "robot" => "/s3/store",
        "credentials" => "YOUR_AWS_CREDENTIALS",
        "path" => [
          "h" => "l",
        ],
        "url_prefix" => "https://demos.transloadit.com/",
      ],
    ],
  ],
]);

# gem install transloadit
transloadit = Transloadit.new(
  :key => "YOUR_TRANSLOADIT_KEY",
  :secret => "YOUR_TRANSLOADIT_SECRET"
)

# Set Encoding Instructions
:original = transloadit.step ":original", "/upload/handle",
)
low = transloadit.step "low", "/video/encode",
  :use => ":original",
  :ffmpeg_stack => "v4.3.1",
  :preset => "hls-270p",
  :turbo => true
)
mid = transloadit.step "mid", "/video/encode",
  :use => ":original",
  :ffmpeg_stack => "v4.3.1",
  :preset => "hls-360p",
  :turbo => true
)
high = transloadit.step "high", "/video/encode",
  :use => ":original",
  :ffmpeg_stack => "v4.3.1",
  :preset => "hls-540p",
  :turbo => true
)
adaptive = transloadit.step "adaptive", "/video/adaptive",
  :use => {"steps":["low","mid","high"],"bundle_steps":true},
  :ffmpeg_stack => "v4.3.1",
  :playlist_name => "my_playlist.data.m3u8",
  :technique => "hls"
)
exported = transloadit.step "exported", "/s3/store",
  :use => ["adaptive",":original"],
  :credentials => "YOUR_AWS_CREDENTIALS",
  :path => "hlsdemo/${file.meta.relative_path}/${file.name}",
  :url_prefix => "https://demos.transloadit.com/"
)

assembly = transloadit.assembly(
  :steps => [ :original, low, mid, high, adaptive, exported ]
)

# Add files to upload
files = []
files.push("./surf.mp4")

# Start the Assembly
response = assembly.create! *files

until response.finished?
  sleep 1; response.reload!
end

if !response.error?
  # handle success
end

# pip install pytransloadit
from transloadit import client

tl = client.Transloadit('YOUR_TRANSLOADIT_KEY', 'YOUR_TRANSLOADIT_SECRET')
assembly = tl.new_assembly()

# Set Encoding Instructions
assembly.add_step(':original', '/upload/handle', {})
assembly.add_step('low', '/video/encode', {
  'use': ':original',
  'ffmpeg_stack': 'v4.3.1',
  'preset': 'hls-270p',
  'turbo': True
})
assembly.add_step('mid', '/video/encode', {
  'use': ':original',
  'ffmpeg_stack': 'v4.3.1',
  'preset': 'hls-360p',
  'turbo': True
})
assembly.add_step('high', '/video/encode', {
  'use': ':original',
  'ffmpeg_stack': 'v4.3.1',
  'preset': 'hls-540p',
  'turbo': True
})
assembly.add_step('adaptive', '/video/adaptive', {
  'use': {'steps':['low','mid','high'],'bundle_steps':True},
  'ffmpeg_stack': 'v4.3.1',
  'playlist_name': 'my_playlist.data.m3u8',
  'technique': 'hls'
})
assembly.add_step('exported', '/s3/store', {
  'use': ['adaptive',':original'],
  'credentials': 'YOUR_AWS_CREDENTIALS',
  'path': 'hlsdemo/${file.meta.relative_path}/${file.name}',
  'url_prefix': 'https://demos.transloadit.com/'
})

# Add files to upload
assembly.add_file(open('./surf.mp4', 'rb'))

# Start the Assembly
assembly_response = assembly.create(retries=5, wait=True)

print(assembly_response.data.get('assembly_ssl_url'))
# or:
print(assembly_response.data['assembly_ssl_url'])

// go get gopkg.in/transloadit/go-sdk.v1
package main

import (
	"fmt"

	"gopkg.in/transloadit/go-sdk.v1"
)

options := transloadit.DefaultConfig
options.AuthKey = "YOUR_TRANSLOADIT_KEY"
options.AuthSecret = "YOUR_TRANSLOADIT_SECRET"
client := transloadit.NewClient(options)

// Initialize new Assembly
assembly := transloadit.NewAssembly()

// Set Encoding Instructions
assembly.AddStep(":original", map[string]interface{}{
  "robot": "/upload/handle"
})
assembly.AddStep("low", map[string]interface{}{
  "use": ":original",
  "robot": "/video/encode",
  "ffmpeg_stack": "v4.3.1",
  "preset": "hls-270p",
  "turbo": true
})
assembly.AddStep("mid", map[string]interface{}{
  "use": ":original",
  "robot": "/video/encode",
  "ffmpeg_stack": "v4.3.1",
  "preset": "hls-360p",
  "turbo": true
})
assembly.AddStep("high", map[string]interface{}{
  "use": ":original",
  "robot": "/video/encode",
  "ffmpeg_stack": "v4.3.1",
  "preset": "hls-540p",
  "turbo": true
})
assembly.AddStep("adaptive", map[string]interface{}{
  "use": {"steps":["low", "mid", "high"],"bundle_steps":true},
  "robot": "/video/adaptive",
  "ffmpeg_stack": "v4.3.1",
  "playlist_name": "my_playlist.data.m3u8",
  "technique": "hls"
})
assembly.AddStep("exported", map[string]interface{}{
  "use": ["adaptive", ":original"],
  "robot": "/s3/store",
  "credentials": "YOUR_AWS_CREDENTIALS",
  "path": "hlsdemo/${file.meta.relative_path}/${file.name}",
  "url_prefix": "https://demos.transloadit.com/"
})

// Add files to upload
assembly.AddFile("myfile_1", "./surf.mp4")

// Start the Assembly
info, err := client.StartAssembly(context.Background(), assembly)
if err != nil {
  panic(err)
}

// All files have now been uploaded and the Assembly has started but no
// results are available yet since the conversion has not finished.
// WaitForAssembly provides functionality for polling until the Assembly
// has ended.
info, err = client.WaitForAssembly(context.Background(), info)
if err != nil {
  panic(err)
}

fmt.Printf("You can check some results at: \n")
fmt.Printf("  - %s\n", info.Results[":original"][0].SSLURL)
fmt.Printf("  - %s\n", info.Results["low"][0].SSLURL)
fmt.Printf("  - %s\n", info.Results["mid"][0].SSLURL)
fmt.Printf("  - %s\n", info.Results["high"][0].SSLURL)
fmt.Printf("  - %s\n", info.Results["adaptive"][0].SSLURL)
fmt.Printf("  - %s\n", info.Results["exported"][0].SSLURL)

// compile 'com.transloadit.sdk:transloadit:0.1.5'
import com.transloadit.sdk.Assembly;
import com.transloadit.sdk.Transloadit;
import com.transloadit.sdk.exceptions.LocalOperationException;
import com.transloadit.sdk.exceptions.RequestException;
import com.transloadit.sdk.response.AssemblyResponse;

import java.io.File;
import java.util.HashMap;
import java.util.Map;

public class Main {
  public static void main(String[] args) {
    Transloadit transloadit = new Transloadit("YOUR_TRANSLOADIT_KEY", "YOUR_TRANSLOADIT_SECRET");
    Assembly assembly = transloadit.newAssembly();
    // Set Encoding Instructions
    Map<String Object> :originalStepOptions = new HashMap();
  
    assembly.addStep(":original", "/upload/handle", :originalStepOptions);
  
    Map<String Object> lowStepOptions = new HashMap();
    lowStepOptions.put("use", ":original");
    lowStepOptions.put("ffmpeg_stack", "v4.3.1");
    lowStepOptions.put("preset", "hls-270p");
    lowStepOptions.put("turbo", true);
    assembly.addStep("low", "/video/encode", lowStepOptions);
  
    Map<String Object> midStepOptions = new HashMap();
    midStepOptions.put("use", ":original");
    midStepOptions.put("ffmpeg_stack", "v4.3.1");
    midStepOptions.put("preset", "hls-360p");
    midStepOptions.put("turbo", true);
    assembly.addStep("mid", "/video/encode", midStepOptions);
  
    Map<String Object> highStepOptions = new HashMap();
    highStepOptions.put("use", ":original");
    highStepOptions.put("ffmpeg_stack", "v4.3.1");
    highStepOptions.put("preset", "hls-540p");
    highStepOptions.put("turbo", true);
    assembly.addStep("high", "/video/encode", highStepOptions);
  
    Map<String Object> adaptiveStepOptions = new HashMap();
    adaptiveStepOptions.put("use", new HashMap(){{
          put("steps", new HashMap(){{
          put("0", "low");
        put("1", "mid");
        put("2", "high");
      }});
        put("bundle_steps", true);
      }});
    adaptiveStepOptions.put("ffmpeg_stack", "v4.3.1");
    adaptiveStepOptions.put("playlist_name", "my_playlist.data.m3u8");
    adaptiveStepOptions.put("technique", "hls");
    assembly.addStep("adaptive", "/video/adaptive", adaptiveStepOptions);
  
    Map<String Object> exportedStepOptions = new HashMap();
    exportedStepOptions.put("use", new HashMap(){{
          put("0", "adaptive");
        put("1", ":original");
      }});
    exportedStepOptions.put("credentials", "YOUR_AWS_CREDENTIALS");
    exportedStepOptions.put("path", "hlsdemo/${file.meta.relative_path}/${file.name}");
    exportedStepOptions.put("url_prefix", "https://demos.transloadit.com/");
    assembly.addStep("exported", "/s3/store", exportedStepOptions);
  
    // Add files to upload
    assembly.addFile(new File("./surf.mp4"));
    
    // Start the Assembly
    try {
      AssemblyResponse response = assembly.save();
      
      // Wait for Assembly to finish executing
      while (!response.isFinished()) {
        response = transloadit.getAssemblyByUrl(response.getSslUrl());
      }
      
      System.out.println(response.getId());
      System.out.println(response.getUrl());
      System.out.println(response.json());
    } catch (RequestException | LocalOperationException e) {
      // Handle exception here
    }
  }
}