Normal

doug.jpg

twitter-brands.svg

Doug Twitter

Doug Sillars

Tutorials

ffmpeg

Overlaying two videos with FFMPEG

[FFMPEG](https://api.video/what-is/ffmpeg) is a free and open source software project that offers many tools for video and audio processing. It's designed to run on a command line interface, and has many different libraries and programs to manipulate and handle video files.

## The Question

### How can I best overlay 2 live camera feeds with FFMPEG to produce one live stream to broadcast at api.video? I’m using a raspberry PI, and having a lot of latency issues.

We then began working on the FFMPEG command that he was using to build the livestream.

For testing purposes, I replaced the two livestreams with videos stored locally on my computer.  My goal is to create a video that looks like this: Die Hard with an Indiana Jones (and the Last Crusade) overlay.


video overlay of Diehard and Indiana Jones

large_screenshot-2021-08-23-at-18-20-16.png

medium_screenshot-2021-08-23-at-18-20-16.png

small_screenshot-2021-08-23-at-18-20-16.png

thumbnail_screenshot-2021-08-23-at-18-20-16.png

screenshot-2021-08-23-at-18-20-16.png



My command began with:



```
ffmpeg  -i DieHard.mp4 -i Indianajones.mp4
```

The ```-i``` tells ffmpeg that these are input files, and then the filename.  If you were using a livestream, or a remote video you could use a url.

The end of the ffmpeg command looks like:



```
-f flv rtmp://broadcast.api.video/s/23df9302-5897-4fca-8b27-0eb39ea67ab2
```

This says to FFMPEG, save the video output as flv and send it to my livestream endpoint.  When video begins arriving at this endpoint, your api.video stream will begin broadcasting whatever video is being sent. At this point, it will just take the first input (DieHard.mp4) and stream that file - ignoring Indiana Jones. I need to do some work to add in the Indiana Jones video...

If you want to test locally, you can change the output to:


```
test.mp4
```

To save the video locally to your computer.

### Initial command

```
ffmpeg  -i DieHard.mp4 -i Indianajones.mp4 test.mp4
```

This takes in the 2 videos, outputs just DieHard.mp4 and saves it into test.mp4.  We want to overlay the Indiana Jones video.

The first thing we’ll do is scale the Diehard video to 1080p (it is 1080p, but this will ensure that all future videos fit correctly), and we will give the output of this transformation the name ‘main’

```
 -filter_complex '[0:v]scale=-1:1080[main]’
```

This command says - take the video from input 1, and resize it to -1:1080. The 2nd value is pretty obvious - make the video 1080 high. The ‘-1’ on the horizontal axis says make the height 1080, and scale the width so that the video is not stretched in any way.  If the input video is 16:9,the output will be 1920x1080. If the input video is 4:3, the output will be 1440x1080.

Let’s resize Indiana Jones to 360p (again using the ‘-1’ to ensure that the video is not stretched), and name the resized video “overlay”.  We place a semicolon between the two commands:

```
 -filter_complex '[0:v]scale=-1:1080[main];[1:v]scale=-1:360[overlay]’
```

Now we have 2 correctly sized videos, let’s set the overlay on top of the main video.  In creating the overlay, we could hard code the coordinates, but we can also use variables. In this case, main_w and main_h are for the main video width and height, and overlay_w and overlay_h are assigned to the overlay video.

We'll place the overlay in the bottom right - 25 pixels from the right and 25 pixels from the bottom.  To do this, we’ll subtract 25 and the dimension of the overlay from the dimension of the main video. The command will look like:


```
[main][overlay]overlay=(main_w-overlay_w-25):(main_h-overlay_h-25)
```

The ```[main]``` video is used as the main video, and the ```[overlay]``` as the overlay, and then we use the variables to place the overlay video.

The full command now looks like:

```
ffmpeg  -i DieHard.mp4 -i Indianajones.mp4 -filter_complex '[0:v]scale=-1:720[main];[1:v]scale=-1:240[overlay];[main][overlay]overlay=(main_w-overlay_w-25):(main_h-overlay_h-25)' test.mp4

```

And the video looks exactly how we’d like it to look! The audio, however, is from the main video: Die Hard.  We can remove the audio (making the video silent) by only exporting the video from the output video.  To do this, we can use the ```map``` parameter.  We’ll name the overlay filter [out] and then just map the first track (track 0) to the output:


```
ffmpeg  -i DieHard.mp4 -i Indianajones.mp4 
-filter_complex '[0:v]scale=-1:720[main];[1:v]scale=-1:240[overlay];[main][overlay]overlay=(main_w-overlay_w-25):(main_h-overlay_h-25)[out]' -map '[out]'0:0  test.mp4
```

This results in a silent movie.  We can programmatically pick which audio track (track 1 in both cases) with a second ```-map``` command:

* ```-map 0:1``` selects the Die Hard audio (the original 0 index input, track 1)
* ```-map 1:1``` selects Indiana jones audio (the original 1 index input, track 1)



Here are the final 2 commands (with the stream parameters added in:

```
ffmpeg  -i DieHard.mp4 -i Indianajones.mp4 -filter_complex '[0:v]scale=-1:720[main];[1:v]scale=-1:240[overlay];[main][overlay]overlay=(main_w-overlay_w-25):(main_h-overlay_h-25)[out]' -map '[out]'0:0 -map 0:1 -f flv rtmp://broadcast.api.video/s/23df9302-5897-4fca-8b27-0eb39ea67ab2

ffmpeg  -i DieHard.mp4 -i Indianajones.mp4 -filter_complex '[0:v]scale=-1:720[main];[1:v]scale=-1:240[overlay];[main][overlay]overlay=(main_w-overlay_w-25):(main_h-overlay_h-25)[out]' -map '[out]'0:0 -map 1:1 -f flv rtmp://broadcast.api.video/s/23df9302-5897-4fca-8b27-0eb39ea67ab2
```

Here’s what the final result looks like (Die Hard audio version):



In order to create his live stream, our developer simply changed the input from 2 movie trailers to his 2 live streams, and it all *just worked*.

## Conclusion

As Indiana Jones famously did not say: “What is FFMPEG? Fortune and Glory kid. Fortune and Glory.”

And we are pretty sure John McClain never said “Yippiee Ki Yay FFMPEG!”

But that is because neither of them ever got the chance to play with the tooling that allowed us to create the video above.

In this post, we’ve talked through how to scale the dimensions of multiple input videos, how to overlay them, and then how to apply an audio track to the videos.  Finally, the video created by ffmpeg is streamed to api.video for live streaming consumption by your viewers.


Use FFMPEG to resize and overlay videos and live stream them

Use FFMPEG to resize and overlay two videos, and then live stream them

Live streaming is a "one to many" form of communication.  Like a conference talk, or a class lecture - the live streamer(s) are presenting, and the viewers watch.  With api.video's live streaming, you can stream to thousands of viewers around the world in near real time!

However, at a conference there are Q&A sessions.  During a lecture, students may raise their hands with a question.  The communication is still primarily "one to many", but there is an aspect of reverse communication that is lost with *just* a live stream.

In many of the virtual conferences I have spoken in over the last 18 months, this reverse communication has been facilitated with a chat application.  Much like a live streamer on Twitch can get text questions/comments, the chat allows for the communication from the viewer to the streamer.

## Latency

With HLS live streaming - you are able to broadcast to thousands of viewers, but there is generally a latency behind 'real-time' of 5-20 seconds.  The great thing about a 'real-time' chat is that this latency cannot be felt by the viewers.  Any delay in reply from the streamer is attributed to typing time, or reading time, or formulating the answer time - making chat-boxes and HLS live streaming an excellent combination.

## Building Chat & Live Streaming

In this post, we'll build a simple webpage that integrates a live stream from [api.video](https://api.video) with a chat app from [CometChat](https://www.cometchat.com/).  

### Live Video

When you [Create a Live Stream](https://docs.api.video/reference/api/Live-Streams#create-live-stream), a player URL and iframe are generated:

```
<iframe src="https://embed.api.video/live/li4pqNqGUkhKfWcBGpZVLRY5" width="100%" height="100%" frameborder="0" scrolling="no" allowfullscreen=""></iframe>
```

You can paste this iframe into a webpage, and the live stream will appear on that page.  If the stream is not streaming, you'll see the thumbnail.

### Chat

To add a chat widget, simply copy the code from the [CometChat web widget](https://prodocs.cometchat.com/docs/web-chat-widget) page to the same page.  Add in your credentials into the chat widget, and it'll load as you expect.

### That's it

Really - that is all there is to it.  A little boilerplate code from [api.video](https://api.video), and from [CometChat](https://cometchat.com), and your live stream with chat is now up and running.

You can see an example of this today at [chatduring.a.video](https://chatduring.a.video).  It was built in about 5 minutes using the steps above.  (if the live stream is not broadcasting, it is because I am moving this month, and my Raspberry Pi is in a box around here... somewhere....)  The code is live on [Github](https://github.com/apivideo/cometchatvideo) (it's literally just the html page) if you want to crib even further.

So, check out the demo, and build your own.  We'd love to see what you've built - leave a note with a link on our [community page](https://community.api.video)



Two way communication: Chat during a live stream

large_screenshot-2021-07-23-at-11-40-43.png

medium_screenshot-2021-07-23-at-11-40-43.png

small_screenshot-2021-07-23-at-11-40-43.png

thumbnail_screenshot-2021-07-23-at-11-40-43.png

screenshot-2021-07-23-at-11-40-43.png

medium_screen-shot-2021-01-26-at-11-48-47-am.jpg

small_screen-shot-2021-01-26-at-11-48-47-am.jpg

thumbnail_screen-shot-2021-01-26-at-11-48-47-am.jpg

screen-shot-2021-01-26-at-11-48-47-am.jpg

Erikka Innes

Video trends

If you're new to video content creation, at some point you'll ask yourself whether you should host your videos on a site like YouTube or your own website. YouTube is incredible for content creators and for those looking to build fanbases for their content. For a business that wants to make a conversion to a buying customer, YouTube may not be the best spot for that business's video content. Instead, for many businesses the best place for video is their own website. And by that I mean hosting video content yourself, either entirely or by using a flexible cloud video/video streaming provider. But rather than take my word for it, consider these aspects of handling video content for yourself to make the best decision: 

* Business goals and requirements
* Reach 
* Engagement 
* Conversion 
* Analytics 

## Choosing business goals and requirements
The first step in choosing the right video strategy for your business is going over your goals and requirements. For example, if you prioritize minimal effort, YouTube might be great. However if you prioritize conversions and you're willing to put in a little effort for video SEO and other optimizations, then hosting video on your website might be better. 

Make a list of everything that's a requirement or goal to start with. And as you go over the rest of this article, you can refer back to and refine your list. If anything in your list conflicts (for example choosing minimal effort and hosting content on your own site) you can reprioritize or remove certain items. By the end of this article you should have a great idea of what option works best for you.

## Reach
When deciding whether to post videos on YouTube, or host them yourself on your site, the first thing to consider is reach. In marketing, reach is how many people see your content. It doesn't necessarily mean they engage with the content, but it means it's at least put in front of them. A big selling point for YouTube is that when you add your video there, you get the benefit of YouTube's algorithms like related videos, circulating popular videos, automatic video SEO and indexing of your content and features like playlists (see how to create your own playlist feature here: [Playlist](https://watch.a.video/playlist/)), YouTube search and more. This has the potential for huge reach.

It sounds great. The problem is about 500 hours of video are uploaded to YouTube every minute. The odds that content for your business is going to be popular right off the bat and benefit from some of the YouTube algorithms geared for popularity are not strong. While you might put in minimal effort tweaking video SEO for reach, you will put in maximum effort figuring out how to: 
* Get subscribers
* Engage relevant audience
* Buy google ads to advertise your content 
* Drive people to your YouTube channel 

Another issue is that you are spending time driving people to your YouTube channel. If you're selling something, you probably want people to go to your website and buy what you're selling. So you're sending traffic to YouTube to watch a video to convince them to go to your website. 

You can cut out a step by placing the video on your own website. It can be tricky to host your own video content, so you can host, stream and deliver content from a cloud video provider. By placing the content on your own site, you now benefit from your own site's existing reach, the SEO work you do for your site and when you advertise you are always driving traffic to something on your site instead of elsewhere. You can also do your own video SEO to get your content indexed. The end result is a centralized spot where people go to learn about you. The downside is if you wanted monetization of content handled for you, it wouldn't be. You have to handle that yourself. 

## Engagement 
Engagement is about creating an interactive experience with your content. It's coming up with ways to get them to watch more of the videos you create, check out more of your products and become more loyal and attached to your product by encouraging them to interact with you. Interactions can be all different kinds of things, from clicking through different pages of content to agreeing to join a newsletter to signing up for a free trial of a product.

YouTube is designed to maximize audience engagement, but specifically focused on watching videos. You can subscribe to content, explore new content, review your watch history, create or watch playlists made by others and YouTube is constantly trying to show you content it think you will like based on your other viewing habits. If all you need is people watching video content, this is perfect. The issue is, YouTube has its own goals for engagement, and they might not align with yours.

On YouTube, their goal is to keep viewers on YouTube, watching as many videos as possible so they can show you as many ads as possible. Your content is not a priority. If you know how to create material that is valued by YouTube because of the kind of ads they can place on your content, then you can do very well there. You won't be able to easily add other kinds of engagement though. Everything will be focused on interacting with video content.

If instead, you decide to set up content on your own site, the immediate plus is you can make your content the priority. At the end of a video, you can always recommend your own content for further viewing. You can also control how it may be viewed and by who (check out our article about creating self-guided content [Build a self guided training course with api.video](https://api.video/blog/tutorials/build-a-self-guided-training-course-with-api-video/). And to start with, only your content will be available. Depending on how elaborate you want to get with the video content you offer, you can create your own algorithms for what videos to show the viewer next based on their session (see our article about [Dynamic Metadata](https://api.video/blog/tutorials/dynamic-metadata/)). You can choose to keep your content ad free and create your own calls to action. Maybe you ask the user to watch something and then sign up for your product right on the site. Or you ask for their email so you can send them a newsletter. You have many more options than you do on YouTube. 

## Conversion
There is no doubt that the best place for conversion starts with your website where you're selling your product or offering your trial. Extra steps, like bringing a person from YouTube to your site, increase the chance that a potential customer will lose interest or find something else to do online. 

YouTube, as we discussed earlier, is great about coming up with new content for viewers to watch. If you just interested a potential customer in your product, but YouTube distracts them into watching a cool video where they then forget to check out your website, you've lost a conversion. There aren't tons of obvious ways to get conversions out of a YouTube video. You can possibly embed links, but these take you away from YouTube, and frequently people would prefer to stay on the site watching content. 

Another issue is that your YouTube video is using the excellent, automatic video SEO provided by YouTube. This is great, but YouTube gets the traffic from that. And then, because it's not a great place for conversions you lose out.

It's much better to put the content on your own website, spend the extra time to set up the video SEO, and then manage the traffic from that. 

## Analytics
In order to improve the effectiveness of your marketing, analytics are a must. YouTube offers detailed analytics and a plus is they're easily accessible through a GUI if you aren't technically inclined. One potential issue is you may have to do some extra work to figure out what traffic comes from your YouTube content to your site. 

You can get the same degree of detail with analytics from cloud video providers as well. Places like Vimeo and api.video (yes us!) offer detailed analytics. At api.video, you can get all kinds of details about your videos, like location (here's a fun post about creating a [Choropleth map](https://api.video/blog/tutorials/use-observable-to-create-a-choropleth-map-of-your-viewers/)), device type, where the viewer came from to start the session, what they did with a video during a session (for example, did they drop off part way through, where was that?) and more. 

large_choropleth.png

medium_choropleth.png

small_choropleth.png

thumbnail_choropleth.png

choropleth.png

On a flexible video platform like api.video, because you have control of everything, you can use analytics to decide whether to localize content, when and what to show viewers, and more. 

## Conclusion 
YouTube is an incredibly interesting and creative platform. It's perfect for content creators making a name for themselves, developing a visual aspect of their brand that doesn't require conversions, or anyone who wants to spend time mastering how to create successful video content on YouTue. 

Your own website is the best platform for video content if you are interested in driving traffic to your site for conversions. Nothing beats having everything in one place or pointing people to one place to learn more. You should consider a cloud video platform that will transcode, host and deliver your content but leaves the rest up to you. The video SEO is a bit more effort, but it is well worth it. If you want to give api.video a try, register here: [https://my.api.video/register](https://my.api.video/register)

Should I host my videos on YouTube or my own website? 

small_youtube.png

thumbnail_youtube.png

youtube.png

small_bees.png

thumbnail_bees.png

bees.png

Erikka Innes and Anne-Sophie Poupard

Use cases

Based in Paris, [Coverd](https://www.coverd.co/) is a company that offers smartphone insurance. And they’re revolutionizing their industry. 

Where other coverage providers only offer insurance from date of purchase, Coverd can offer plans for post-purchase smartphones. According to one of their co-founders, Nicolas Schwartz, the company got its start based on a single observation - that smartphones are a key part of everyday life for people everywhere, and a lot can happen to a smartphone. 
Anything from losing the phone, breaking it, drowning it, you name it, smartphones are susceptible to many disasters great and small. And the insurance for them, if you’ve ever tried using it, is all about the insurance company getting out of paying for damages to your phone. This is not the case with Coverd. They’re a low-cost, completely online option that covers all risks, and doesn’t make the user commit to anything. 

So where does api.video come in? Let’s find out. 

## The need to centralize video content
When Coverd was first starting out, they needed a way to document damages to user phones. 
Because the company is completely online, they required a simple, effective way to ensure customers weren’t committing insurance fraud. 

“*We started with photos at first*,” said Nicolas Schwartz, co-founder and CTO of Coverd. “*Then we moved to video, but it was very manual. We collected videos through email or chat. It was complicated to centralize all these videos, and sometimes the size was too big to be sent through email*.” 

## Finding the right solution
Coverd needed an easy-to-implement, high quality video solution that centralized their claim information. 
This would allow them to process more claims, and more easily check the damage on their customers’ phones. 

That’s when they discovered api.video. 

They knew that they wanted a video on demand solution where customers could upload videos of their damaged phones from anywhere. Once they had their design in place, they turned to api.video. “*The documentation was clear and the API was easy to use, so we were able to finalize our integration quickly*,” Schwartz said. 

Two key features that were important to Coverd were keeping the [videos private](https://api.video/blog/product-updates/video-access-management-how-to-create-deliver-and-manage-private-videos-and-what/), since only their back office would use them for claim evaluation, and [fast transcoding](https://api.video/blog/product-updates/api-video-encoding-times-2h-2021-edition/) and upload. 

api.video delivered on all fronts, and continues to be a part of their revolutionary smartphone insurance solution. 

If you are interested to know more about our end-to-end solution and how you can integrate videos into your own product, you can ask questions in our [community](https://community.api.video/) or [create a free account](https://dashboard.api.video/register) to get started.

How video helped Coverd to improve their customer support

large_coverd.png

medium_coverd.png

small_coverd.png

thumbnail_coverd.png

coverd.png

Case Study: How video helped Coverd to improve their customer support

video create

Delegated Upload

Video upload

JavaScript

Uploading a video to api.video just got easier!

We have created a [JavaScript uploader](https://docs.api.video/sdks/vod/apivideo-typescript-uploader) script to abstract this code into a single function - allowing you to focus on your code and making the video upload process easier for you and your development team!


## JS Uploader Widget

You can read about uploading a video in the [tutorial](https://api.video/blog/tutorials/uploading-large-files-with-javascript/) describing the code. The JS Uploader widget abstracts the file slice, creating all of the headers, and uploading the files - it also adds retries for segments that have issues!

The new code for uploading is under 30 lines, and most of that is for updating the page during the upload.

First, we add the script to the head (with a defer tag to not slow page load)

```
   <script src="https://unpkg.com/@api.video/video-uploader" defer></script>

```
Next we have a event listener for changes in the file upload form:

```
     input.addEventListener('change', () => {
       console.log("upload commencing");
       uploadFile(input.files[0]);
       function uploadFile(files) {
           const uploader = new VideoUploader({
               file: input.files[0],
               //changed to sandbox, because we cannot have nice things
               uploadToken: "to5PoOjCz98FdLGnsrFflnYo",
               chunkSize: 1024*1024*10, // 10MB
               retries: 10
           });
           uploader.onProgress((event) => {
               var percentComplete = Math.round(event.currentChunkUploadedBytes / event.chunksBytes * 100);
               var totalPercentComplete = Math.round(event.uploadedBytes / event.totalBytes * 100);
               document.getElementById("chunk-information").innerHTML = "Chunk # " + event.currentChunk + " is " + percentComplete + "% uploaded. Total uploaded: " + totalPercentComplete +"%";
           })
           uploader.upload()
               .then((video) => {
                   console.log(video);
                   playerUrl = video.assets.player;
                   console.log("all uploaded! Watch here: ",playerUrl ) ;
                   document.getElementById("video-information").innerHTML = "all uploaded! Watch the video <a href=\'" + playerUrl +"\' target=\'_blank\'>here</a>" ;
               });
       }
     });

```

### Walking through the code

The uploadFile function takes the files and creates an uploader function:

```
 const uploader = new VideoUploader({
               file: input.files[0],
               //changed to sandbox, because we cannot have nice things
               uploadToken: "to5PoOjCz98FdLGnsrFflnYo",
               chunkSize: 1024*1024*10, // 10MB
               retries: 10
           });

```

The chunkSize defaults to 50MB, but I have lowered this to 10MB for the sake of the demo, so you can see multiple chunks uploaded.

The retry count defaults to 5.  

#### During Upload

```
 uploader.onProgress((event) => {
               var percentComplete = Math.round(event.currentChunkUploadedBytes / event.chunksBytes * 100);
               var totalPercentComplete = Math.round(event.uploadedBytes / event.totalBytes * 100);
               document.getElementById("chunk-information").innerHTML = "Chunk # " + event.currentChunk + " is " + percentComplete + "% uploaded. Total uploaded: " + totalPercentComplete +"%";
           })


```

The onProgress updates the video upload every 50ms.  We calculate the % uploaded, and update the browser - so the user is aware that the video upload is underway.

#### Upload complete

When the video upload is complete, the API will reply with the videoId, and links to the video. We take this information to display the url to the user:

```
           uploader.upload()
               .then((video) => {
                   console.log(video);
                   playerUrl = video.assets.player;
                   console.log("all uploaded! Watch here: ",playerUrl ) ;
                   document.getElementById("video-information").innerHTML = "all uploaded! Watch the video <a href=\'" + playerUrl +"\' target=\'_blank\'>here</a>" ;
               });

```


## Conclusion

The new JS video uploader widget weighs in at just 11.5 KB, and as it is not required until after the page loads, will not impact your page speed (as long as you use the defer tag).

It will make building video upload widgets in JavaScript easier, as we've abstracted all the complexity into the library - allowing you to focus on your application, and not on the intricacies of partial uploads of video files.

Read all of the [technical details](https://docs.api.video/sdks/vod/apivideo-typescript-uploader) in our documentation, and [get started](https://dashboard.api.video/register) with your video app uploads today!


New video uploader JavaScript library

large_new-video-uploader-javascript-library.png

medium_new-video-uploader-javascript-library.png

small_new-video-uploader-javascript-library.png

thumbnail_new-video-uploader-javascript-library.png

new-video-uploader-javascript-library.png

Live stream status

[FFMPEG](https://api.video/what-is/ffmpeg) allows you to stream and [live stream](https://api.video/live-streaming/) video, but sometimes what the output means can get confusing. 

We are going to go over every part of the information in the output, so if something seems obvious, skip ahead to the part you wanted to learn about.

Here's our sample. This sample shows a session where a live stream is started using my Mac and the Mac's iSight camera. I started it using the [livestream.a.video](https://livestream.a.video) demo through a Chrome browser. There might be some differences based on what computer you're on, so keep that in mind. 

## Hello from mediarecorder-to-rtmp server!

We're using an RTMP connection, which is based on TCP. So when I connect with my request to create a live stream, my client gets a response: 

"SERVER:Hello from mediarecorder-to-rtmp server!" 

I'm asked to provide my stream key, which is going to be what I will use to broadcast. Because of how the demo is set up, that's already been sent, so now the server tells me it's received the information about where I want to broadcast my live stream to: 

"SERVER:Please set rtmp destination before start streaming.
SERVER:rtmp destination set to:rtmp://broadcast.api.video/s/30087931-229e-42cf-b5f9-e91bcc1f7332"

The last part tells me what version of FFMPEG we're using and provides a link to static builds of FFmpeg for Linux kernels 3.2.0 and up. It also gives me copyright information - wow we've had FFMPEG for 22 years!

## Configuration details 

The next part of the FFMPEG output shows us the configuration details for the live stream. 

In this section, we're told that FFMPEG was built with gcc 8. GCC stands for GNU Compiler Collection and it's the standard compiler for Linux. It's associated with the Linux distribution Debian (Debian GNU/Linux). The Debian Linux distribution is super popular and while it's less user friendly than distributions like Ubuntu, it is great for people who like free and open source software. 


## FFMPEG library versions
This section of output lists the main libraries in FFMPEG and the versions you have installed. 


## FFMPEG input info 

This section shows you details about your video live stream. 

Here's the first line: 

"FFMPEG:Input #0, matroska, webm, from 'pipe:':

This explains how video is being input. We can see here that the multimedia container matroska and the open video format webm is being used to capture video.

"Metadata:
  encoder         : Chrome
 Duration: N/A, start: 0.000000, bitrate: N/A"
 
 Next, there's more information about the streams being input: 
 
 "Stream #0:0(eng): Audio: opus, 48000 Hz, mono, fltp (default)
  Stream #0:1(eng): Video: h264 (Constrained Baseline), yuv420p(progressive),   
	240x240, SAR 1:1 DAR 1:1, 1k tbr, 1k tbn (default)"

### The audio stream
The audio stream is using the opus codec with a sample rate of 48000 Hz, which is standard for digital video files. Mono means the audio is monophonic, meaning all sounds are mixed together in a single channel. And fltp is Planar Floating point format. It's a way of retrieving the sample format for your audio. Sample format information is used to determine how many bits will be in each audio sample. The higher the number of bits per sample in a file, the more data that will be stored in the sample. You can learn more about sample format here: What is Sample Format?

### The video stream
The video stream is using the h264 codec with a constrained baseline. The term constrained baseline describes the video stream profile. A profile determines the methods that an encoder can use to generate streams and also describe the methods a decoder is expected to perform in order to decode the stream later. The term 'yuv420p' describes the type of video signal you're using. 

YUV is a type of video signal where colors are split into three channels, one for luminance (brightness) which includes green, and two for chrominance (color) which include blue and red in separate channels. 420 describes the chroma subsampling used on the video. Normally, you'd notate this as 4:2:0. It's telling you that the color channels have half the resolution of the luminance channel. If you want to learn a bit more about this way of representing color, see the api.video definition for YCbCr. The term progressive means that the video is in a progressive format, which means that the TBR value (coming up in our discussion) is talking about the frame rate rather than the field rate. There's confusion about both these terms. For the purpose of this walkthrough, let's keep things simple. A progressive video format will use frame rate to describe frames per second. An interlaced video format will use field rate. It takes two fields to show you one image. 

240x240 describes the pixels in each frame of video. SAR stands for Sample Aspect Ratio, and it's showing you the ratio between the width and the height of each individual pixel - 1:1. DAR stands for Display Aspect Ratio and that's the ratio between the width and height of a full image in your video. In this case it's also 1:1. 

In the final line, it closes out with "1k tbr, 1k tbn (default)." TBR represents the frame rate baseline. This is guessed by FFMPEG when it looks at the video stream. At the start of a video stream, TBR is low. In our stream, it's 1 at the very start. Sometimes if you have a video format that's interlaced, the TBR will be twice as high as expected, because there are two fields used to create an image. TBN represents the time base in AVStream that comes from the container. TBC is the time base for the codec for the stream.

## Stream mapping 
Next in our information from FFMPEG we have a section about stream mapping that looks like this:

Stream #0:1 is our video stream. This means that the input stream is from the first file '0' and it is the second stream in that file '1.' h264 (native) means that the detected codec of the input stream is H.264 and that FFMPEG is going to use the built-in decoder to decode the stream. It's being mapped to h264 (libx264) meaning that the output stream is going to be H.264 and FFMPEG will use the libx264 encoder to generate the stream. 

Stream #0:0 is our audio stream. This means that the input stream is from the first file '0 and its the first stream in that file '0.' opus (native) means that the detected audio codec of the input stream is opus and as before, native means that FFMPEG is going to use its built-in decoder for opus to decode the stream. aac (native) means the output audio will be in aac, and FFMPEG will use the built in encoder for aac to generate the stream. 

## Configuration details for libx264
We're mapping to libx264, so now we receive some details about how libx264 is configured for our stream. 

You can see the Video Buffering Verifier confirms that there's a buffer size set, but the max bit rate it can handle isn't specified, so it's ignored. Then the SAR is 1:1, as it was to start with. We can see the CPU capabilities available for sending our live stream and that we'll be using the constrained baseline for H.264. 

Next there's the line: 

"FFMPEG:264 - core 164 r3065 ae03d92 - H.264/MPEG-4 AVC codec - Copyleft 2003-2021 - http://www.videolan.org/x264.html"

This tells us what version of the H.264 codec FFMPEG uses. It's followed by options that are configured for the codec. 

**cabac=0** 
Cabac stands for context-adaptive binary arithmetic coding. It's a type of entropy encoding, which is a lossless data compression technique. H.264 is lossy, so cabac is used at the end to do a final compression that is lossless. You should not mistake its inclusion in H.264's compression steps as meaning all the steps are lossless. Also, explaining this algorithm in detail would take some time. If you want to learn more about cabac, look here: Context=adaptive binary arithmetic coding

**ref=1**
This indicates which frame will be the first reference frame. Here, it's the first frame.

**deblock=0:0:0**
This is the deblock filter for H.264. It creates pixelation to help improve the appearance of your video. It's useful when macroblocking occurs, which would be a huge block of pixels that look unnatural. Deblocking blurs these blocks to make them look normal again.

**analyse=0:0** 
This is part of deblocking. It helps determine the size of each block you will apply deblocking to. 

**me=dia**
This is saying that the motion estimation method is diamond or dia. Motion estimation is the process of determining motion vectors that describe the transformation from one 2D image to another; usually from adjacent frames in a video sequence. Diamond search technique for block motion estimation is based on diamond search patterns. The process of block matching motion estimation is to find out a candidate block, within a search area in the previous frame, which is most similar to the current block in the present frame. So you're saying here use this technique for motion estimation.

**subme=0** 
This is for the sub-pixel motion estimation method. It's important for video coding inter-frame prediction and has high computation complexity. It's set to 0 meaning there will be zero sub-pixel motion estimation done. 

**psy=1 psy_rd=1.00:0.00**
This is also to do with motion-compensated DCT, which is a lossy block compression transform coding technique. If set to 1 it means use psychovisual optimizations. It means optimizing quantization tables based on the human visual system and humans see. It's a complex topic that can't be fully explained here. psy_rd is about setting how strong the psychovisual optimization will be.

**mixed_ref=0** 
This allows you to use one reference per partition as opposed to per macroblock. A macroblock is a large block of pixels and a partition is a smaller, multiple variable-sized prediction block. 

**me_range=16**
Again about motion estimation, but this time about the range for a motion vector. In video compression, a motion vector is the key element in the motion estimation process. It is used to represent a macroblock in a picture based on the position of this macroblock in another picture, called the reference picture. This parameter lets you set the range.

**chroma_me=1** 
Typically when doing motion estimation, only luminance is examined. You can have chroma considered as well by setting chroma_me to be 1.

**trellis=0** 
This lets you set the rate-distortion optimal quantization. This is a method used to improve video quality in video compression. It optimizes the amount of video quality lost per chunk of data by measuring how far an optimization will deviate from the source material and the cost of that deviation. This can be used to decide what choices are useful vs. resulting in the loss of too much data. It's a slow process, so sometimes it's better not to use it, which is what's being done here by setting trellis=0.

**8x8dct=0** 
With this parameter you can enable adaptive spatial transform. This is a way of altering an image or video frame through rotation, flips, scaling and deformation. For our case, where it's for video, it's about ways to manipulate the block of data so it appears less distorted and of higher quality.

**cqm=0** 
Allows the use of a custom quantization matrix to weight frequencies differently in the quantization process. The presets quant matrices are "jvt" and "flat". Recommended only if you know what you're doing.

**deadzone=21,11** 
When trellis isn't activated, deadzone parameters determine how many DCT coefficients are rounded up or down. Rounding up results in higher quality and more detail retention, but costs more bits--so rounding is a balance between quality and bit cost. Lowering these settings will result in more coefficients being rounded up, and raising the settings will result in more coefficients being rounded down. Recommended: keep them at the defaults. This is part of the settings for rate-distortion optimal quantization. This is again fairly complex to explain. If you want to learn more about it conceptually, check out this page: Quantization

**fast_pskip=1** 
By default, x264 will skip macroblocks in P-frames that don't appear to have changed enough between two frames to justify encoding the difference. This considerably speeds up encoding. However, for a slight quality boost, P-skip can be disabled. In this case, the full analysis will be done on all P-blocks, and the only skips in the output stream will be the blocks whose motion vectors happen to match that of the skip vector and motion vectors happen to match that of the skip vector and which have no residual. The speed cost of enabling no-fast-pskip is relatively high, especially with many reference frames. There is a similar B-skip internal to x264, which is why B-frames generally encode much faster than P-frames, but it cannot be disabled on the commandline.

**chroma_qp_offset=0** 
This stands for chroma quantization parameter offset. It is the quantization parameter difference between chroma and luma. 

**threads=3**
FFMPEG is multi-threaded by default. How many threads it will use depends on the codec. By default for libx264 it is cores x1.5 for frame threads and cores x 1 for slice threads. 

**lookahead_threads=3** 
A lookahead thread looks at incoming frames before they are transcoded. Number of lookahead threads can impact performance speed.

**sliced_threads=1** 
Sliced threading decodes multiple parts of a frame at the same time.

**slices=3**
If the codec you're using supports multi-threading, you can decode more than one part of a single frame at once by working on multiple slices. This is only available if the video was encoded using slices.

**nr=0** 
Confusingly, this stands for noise-sensitivity. You can use it with static-thresh to change the threshold on blocks that are examined in an image. If they fall below the specified threshold the encoder skips them.

**decimate=1** 
This allows you to drop duplicated frames at regular intervals. 

**interlaced=0** 
This is a simple interlacing filter from progressive contents. This interleaves upper (or lower) lines from odd frames with lower (or upper) lines from even frames, halving the frame rate and preserving image height.

**bluray_compat=0** 
Configure the encoder to be compatible with the bluray standard. It is a shorthand for setting "bluray-compat=1 force-cfr=1".

**constrained_intra=0** 
You can enable constrained intra prediction, which is required for the base layer of SVC encodes. This is an intra prediction technique where the video encoder limits the use of neighboring blocks as reference blocks in the intra prediction process. If you're using constrained intra prediction, you can configure video to not use neighboring blocks as reference blocks if the neighboring blocks were coded using inter prediction. By not using inter predicted blocks as reference blocks for intra prediction, the video encoder may create an encoded video bitstream that is more error resilient.
 
**bframes=0** 
You can set the maximum number of concurrent B-frames that x264 can use. Without B-frames, a typical x264 stream has frame types like so: IPPPPP...PI. With --bframes 2, up to two consecutive P-frames can be replaced with B-frames, like: IBPBBPBPPPB...PI. B-frames are similar to P-frames, except they can use motion prediction from future frames as well. This can lead to significantly better efficiency in terms of compression ratio. 

**weightp=0** 
Use this to enable use of explicit weighted prediction to improve compression in P-frames. Higher modes are slower.

**keyint=30** 
This sets the maximum interval between IDR-frames (aka keyframes) in x264's output. You can specify "infinite" to never insert non-scenecut IDR-frames. IDR-frames are 'delimiters' in the stream - no frame can reference data from the other side of the IDR-frame. As well as this, IDR-frames are also I-frames, so they don't reference data from any other frame. This means they can be used as seek points in a video.

**keyint_min=16** 
This sets the minimum length between IDR-frames. Very small keyint ranges can cause "incorrect" IDR-frame placement (for example, a strobing scene). This option limits the minimum length in frames after each IDR-frame before another can be placed.

**scenecut=0** 
This sets the threshold for I/IDR frame placement (read: scene change detection). x264 calculates a metric for every frame to estimate how different it is from the previous frame. If the value is lower than scenecut, a 'scenecut' is detected. An I-frame is placed if it has been less than keyint_min frames since the last IDR-frame, otherwise an IDR-frame is placed. Higher values of scenecut increase the number of scenecuts detected.

**intra_refresh=0** 
You can disable IDR-frames, instead H.264 uses intra coding for each macroblock in the frame every keyint_min frames. Blocks are refreshed in a horizontally scrolling column - the 'refresh wave'. This benefits low-latency streaming by making it possible to achieve more constant frame sizes than is possible with standard IDR-frames. It also increases the resilience of the video stream to packet loss. This option does reduce compression efficiency, hence only use it when needed.

**rc=crf**
rc stands for Rate Control. You can adjust the file data rate in several ways, the option shown here is CRF, or Constant Rate Factor. CRF is an encoding mode that adjusts the file data rate up or down to achieve a selected quality level rather than a specific data rate. CRF values range from 0 to 51, with lower numbers delivering higher quality scores.

**mbtree=0** 
This stands for macroblock tree rate control. Macroblock tree rate control improves compression by tracking how long different parts of an image last across frames. For parts of an image that stay the same, you don't need to continually save that data, only make a note that it continues to be there so you can use that as a reference to reconstruct that part of the frame later. 

**crf=25.0** 
This is related to the rc=crf command. CRF is an encoding mode that adjusts the file data rate up or down to achieve a selected quality level rather than a specific data rate. CRF values range from 0 to 51, with lower numbers delivering higher quality scores.

**qcomp=0.60** 
The default setting is 0.60. qcomp stands for quantizer curve compression factor. A setting of 0 will give you a constant bitrate while a setting of 1 will give you a constant quantizer. This can be combined with mbtree, but the higher your qcomp setting, the weaker the effect of the mbtree setting.

**qpmin=0** 
The default setting for this is 0 and raising this minimum is discouraged because it can negatively impact the quality of background areas in your frame. 
qpmin defines the minimum quantizer that H.264 will ever use. The lower the quantizer, the closer the output is to the input. 

**qpmax=51** 
The default setting for qpmax is 51. The default of 51 is the highest quantizer available for use in the H.264 spec, and is extremely low quality. This default disables qpmax. You can set this as low as the 30-40 range if you want to cap the minimum quality x264 can output, but adjusting it is not recommended.

**qpstep=4**
This allows you to set the maximum change in the quantizer between two frames. 

**ip_ratio=1.40** 
The default setting is 1.40. You can change the average decrease in quantizer for B-frames vs. P-frames, with higher values decreasing B-frame quality.

**aq=0**
aq stands for Adaptive Quantization. This helps distribute bits between macroblocks in your video. If you don't use it, it can underallocate bits to sections that lack detail. A setting of 0, as with other FFMPEG settings, means you will not use it at all. 

## Output to api.video
Now that you've got all the configuration settings for your streams and you've mapped them, you'll want to see some details about what will be output to your destination. 

Here you can see the destination, shown by the stream key and then a summary of details about your video and audio streams. The encoders being used are listed as well. We don't need to walk through everything listed here because we covered it in the earlier sections when we mapped the video and audio streams. FPS is frames per second. 

Now we can take a look at the lines that show us details about each chunk of data being streamed. Here's one of the lines: 

"FFMPEG:frame=65 fps= 55 q=12.0 size=29kB time=00:00:05.06 bitrate=  47.1kbits/s speed=4.26x"

The line is a snapshot where everything that is happening at that moment is reported to the terminal. It says that in this moment, you're streaming frame 65. The frames per second is 55, and the quality (q) is 12. The lower the number for quality, the better the video. The higher the number, the worse. The size of the chunk of data being streamed is also listed in kB with size. The time is the time from when the live stream started, and the bitrate is how many kbits per second yu're streaming. speed is how fast everything is streaming. 

## Conclusion
While this guide doesn't tell you everything about all concepts (for example quantization, which is too complicated to include in this post) I hope that this walkthrough helped explain what things are a bit more.
To help you further, you can go on [our Community](https://community.api.video/) or [start building](https://dashboard.api.video/register) now.



What do my video output live stream details from ffmpeg mean ? 

What do my video output live stream details from ffmpeg mean?

large_what-do-my-video-output-live-stream-details-from-ffmpeg-mean.png

medium_what-do-my-video-output-live-stream-details-from-ffmpeg-mean.png

small_what-do-my-video-output-live-stream-details-from-ffmpeg-mean.png

thumbnail_what-do-my-video-output-live-stream-details-from-ffmpeg-mean.png

what-do-my-video-output-live-stream-details-from-ffmpeg-mean.png

Product updates

## What's .new at api.video?

We've been really busy building the best video streaming API around.  All of our teams are growing to meet the need of the rapid growth going on.  (Interested?  Check out the [careers page](https://api.video/careers/).)

We recently launched [webhooks](https://docs.api.video/reference/create-and-manage-webhooks) that tell your backend when a live stream starts or finishes.  Our video player has undergone a number of [new features](https://docs.api.video/sdks/player/apivideo-player-sdk), and we've launched [a half dozen new API clients](https://docs.api.video/sdks/api-clients/apivideo-csharp-client), a React Native [Live Stream](https://docs.api.video/sdks/livestream/react-native-livestream-component) and [player](https://docs.api.video/sdks/player/apivideo-react-native-player) modules. There's so much more coming that we cannot wait to share with you!

## Why does your post say .new?

Aren't all these features just *new*?

Ahh, yes.  We have also launched a number of domains that showcase one of the basic premises of api.video: uploading videos for video on demand (VOD) playback.  

These all use the Top Level Directory ".new", and utilize the most basic function of api.video - a video upload:

* [embed.new](https://embed.new)
* [ingest.new](https://ingest.new)
* [mp4.new](https://mp4.new)

All of these videos are using synonyms to describe a video upload.

* [Embedding](https://api.video/what-is/embed) a video is the ability to add external video content onto your webpage.  When your video is uploaded to api.video, the JSON response will contain the code for an iframe embed of your video.

* [Ingesting](https://api.video/what-is/ingest) a video is the process of uploading and converting a video for streaming on demand.  All videos uploaded to api.video are ingested and made into [HTTP Live Stream (HLS)](https://api.video/what-is/http-live-streaming-hls) videos for responsive and optimized playback.

* [mp4](https://api.video/what-is/mp4) is the most common format of video on the web.  In the case of api.video, when you upload or ingest a video, you'll have a playable h.264 mp4 video ready to be shared in addition to the HLS video stream.

When you use these sites to upload a video, you'll see the progress of the video ingestion into api.video. Upon completion, get a JSON response of the completed upload, and retrieve links for an iframe *embed* and *mp4* playback.

After a few seconds, you can also refresh the video, and see the video on demand video stream right from the page:

large_screenshot-2021-08-09-at-21-06-11.png

medium_screenshot-2021-08-09-at-21-06-11.png

small_screenshot-2021-08-09-at-21-06-11.png

thumbnail_screenshot-2021-08-09-at-21-06-11.png

screenshot-2021-08-09-at-21-06-11.png

Give our demos a try, and if you like what you see, they all have links to the code on GitHub, so you can copy and reuse for your application. All you have to do is add your api.keys and delegated upload tokens to ensure the videos end up in your [api.video](https://api.video) account.

Finally - you might see all the links that point to definitions in this post. We're building a [video glossary](https://api.video/what-is) to help you navigate all the terms that are sometimes thrown about when working with video on the web.

What's ".new" at api.video

small_dotnew-1.png

thumbnail_dotnew-1.png

dotnew-1.png

Authenticate

Python

You've prepared the perfect ad copy for your business, but now you're trying to figure out how you can personalize the ad for each business. One great way to do that would be to use a voice over tool that allows you to customize the content based on the location of your customers. Fortunately, this is available! By combining api.video with aflorithmic.ai's voice over this problem is easy to solve. 

## Imagine, if you will, that you own a pizza chain

To make this fun, let's imagine you are the owner of a popular pizza chain - Renzo's pizza chain. You have fifty different outlets and you've prepared the perfect ad: 

--Insert video here-- 

This ad is great for one of your locations, but you want people near all of your restaurants to know they can eat the best pizza for the least dough. For each location, you'd like to run this ad, but have it play information that tells the listener the city, address, day of the week and the time of the offer being described. 

No problem! We can do this in the tutorial today. Let's get started. 

## Prerequisites 

For this project, you're going to need: 

* An api.video account - [Sign up here!](https://api.video)
* An aflorithmic.ai account - [Sign up here!](https://console.api.audio/)

## Installation

We will use the [api.video Python client](https://github.com/apivideo/python-api-client) and [Aflorithic.ai's apiaudio library](https://docs.api.audio/recipes).

Installation for api.video: 
```pip install api.video```

Installation for Aflorithmic:
```pip install -U apiaudio```

### ffmpeg installation
If you want to run the project as-is, you'll also need to install ffmpeg. These instructions help you with installation on a mac. What you'll want to do is make sure you have brew installed. Then it's very easy, you just install with:

```brew install ffmpeg``` 

You need to install ffmpeg before you install the next two items.

### pydub and pyaudio installation
pydub and pyaudio can also be difficult to install, depending on your set up and what you've tried to install already. If you made the mistake of trying to install these before installing ffmpeg, then what you would do is first run:

```brew remove portaudio```

Then, reinstall this like so: 

```brew install portaudio``` 

After these steps, you should be able to successfully install the modules you'll need. Here's the commands: 

```brew pyaudio```

and 

```brew pydub```

## Project overview 
Here's what we're going to do with the example script today:

1. Prompt to collect the api.video API key and the Aflorithmic API key. 
2. Select our video from the Videos folder (for your own tweaks later you can drop other videos here to use, or use a different folder system to organize your content). 
3. Select the script we want from the Script folder and offer the user a preview of the script to make sure it's the right one. 
4. Select the localization .csv file we want to use with our script.
5. Create a sample audio file with the voice over, using the first line from the .csv file
6. Give the user the sample file so they can make sure it sounds like what they want.
7. Next we'll combine the first audio file with the video.  
9. We'll display that file for review by the user to make sure it looks right.
10. If the user approves the file, one by one we'll create an audio file, combine it with the video, tag each video with the information from the csv, and upload it for storage and hosting on api.video.
11. We'll return the user a list of video titles and a link to a playable copy of the final file. 

## Code sample 
Here is the code sample. It's a wizard that will walk you through all the steps. The complete project is available on github here: [https://github.com/apivideo/python-api-client/blob/master/examples/video_audio/README.md](https://github.com/apivideo/python-api-client/blob/master/examples/video_audio/README.md)

## Walkthrough the important stuff
A bunch of the demo is set up to walk you through the process of combining information. We don't need to go over each while loop, but let's go over some details regarding API behavior and the tools used to create the demo. 

### The script 
You can place your script into your code directly by using quotes. It could look like this (I'm saying could because there are a few different ways to set up your api.audio script): 

You can see that the script is split into three sections. This demo doesn't really make use of the features available per section so I'm not going to go into detail for this part. Personalization is achieved by using {{ }} around the name of a column from your csv spreadsheet. They can be used in whatever order you like. 

You can also choose to read your script from a .txt file. If you choose to do this, make sure to take the quotes off from the beginning and end or it will screw up the parser. A common error you will get will say there's a problem with creating a final file or working with a URL and it's usually because something broke before that point, so keep that in mind when debugging. 

In your code, when you set up your script, you'll use a command that looks something like this: 

```script = apiaudio.Script().create(scriptText=text, scriptName=script_details[0], moduleName=script_details[1], projectName=script_details[2])
```

In this snippet, you've already authenticated with your api key (```apiaudip.api_key = your_key```) so now you can work with the api's endpoints. 

The only required field is scriptText, which will contain the text of your script. However it's useful to provide the other names for reference. Be aware that you cannot delete projects or modules. After you set up your script this way, you'll be able to reference it in your code easily via scriptId. Like so:

```script.get("scriptId")```

### The audio file
For starters, when you create an audio file with api.audio, it names your file based on your project name and personalization parameters. In this demo, if you named your project "ad" then every audio file would begin with the word "ad." Next, it puts the headers for the csv file in alphabetical order, and adds the appropriate parameter next to each header. For example, our .csv file has the columns (in this order): 

* city
* address
* day_of_week
* offer_time

After each column title, the entry that appears in the audio file will appear. To separate each column, two underscores are used. Here's a sample:

ad__address_1353%20harlem%20street__city_springfield__day_of_week_tuesday__offer_time_6%20to%208%20pm

So something you'll possibly want to do is rename the files when they arrive. An easy way to handle this is with the built-in os module. 

When creating an audio file you'll do two steps, one is text-to-speech and one is mastering the audio. For text-to-speech you can pick a voice, how fast it will speak and then give it a dictionary containing the list of personalization terms you want to insert into your script. 

You can also choose a template, which will play some background music under your spoken audio. You can see in the demo I used "copacabana." To list voices or background music options, go to the [api.audio API reference docs](https://docs.api.audio/reference) and use the endpoint for listing voices or the endpoint for listing music. 
 
### The .csv
This demo reads information from a .csv file. If you want to read from something else, you can as long as your output for your program to work with becomes a list of dictionaries. .csv is pretty simple to use, so I went with that option.

### Playing a track from your application
You can play a track to check out the audio by using a variety of tools. For this one, I used pydub and pyaudio. These are fairly popular modules. In order to use them, however, audio must be converted to .wav. You will see in the code  that two imports are made from pydub: 

```
from pydub import AudioSegment
from pydub.playback import play
```

These allow us to play straight from the terminal or wherever we may be. The code to convert to .wav and play is very straightforward:

```
wav_track = AudioSegment.from_mp3(file)
wav_track.export(audio_title, format="wav")
```

There are other choices available for converting, but api.audio returns .mp3 files, so we use the from_mp3 choice. 

After we have the track, playing it is as simple as this:

```
play(wav_track)
```

### Merging audio and video 
Prior to uploading your video to api.video, you will want to add the sound and video together. This can be accomplished with ffmpeg, which you need to import to use pydub and pyaudio anyway. The code for merging audio and video is:

```
input_video = ffmpeg.input(video)
input_audio = ffmpeg.input(wav_track)
title = title + ".mp4"
ffmpeg.concat(input_video, input_audio, v=1, a=1).output(title).run()
```

This will produce an mp4. You can then upload it to api.video. 

### Upload to api.video
For details about uploading a video with api.video, you can check out the tutorial about it here: [Upload a Video with the api.video Python Client](https://api.video/blog/tutorials/upload-a-video-with-the-api-video-python-client/)

Something to note is to upload a file, it must be in the same folder as your application or it will not upload.

Once it's uploaded, you can retrieve the .mp4 from the response and play it right away in your browser using the built-in webbrowser module. 

To retrieve the mp4 from the response, you do this:

```
link_mp4 = video_response['assets']['player']
```

And then you can open the link like this:

```
 webbrowser.open(link_mp4)
 ```

This will let you make sure everything combined properly so that the audio matches with the video the way you want. 

### Create all the localized videos
After all the steps to make sure you're creating the right type of video, you can use the recipe from api.audio with a couple of tweaks to create all your new videos with personalized ads by location, then upload them for hosting to api.video.

This demo deletes every video you upload right after the upload happens so you don't end up sitting with fifty videos in a folder.

Thanks for reading! Happy coding. :) 

Localize Advertisement Videos with Personalized Voice Overs!

api.video + aflorithmic.ai: Localize Advertisement Videos with Personalized Voice Overs!

When there are a large number of attendees on a Zoom call, the call can become very laggy, and the video and audio quality is not always as good. When there is a call with a large number of participants - you may be in a case where only a few attendees are participating and most of the attendees are 'listeners.'  If that is the case, you might consider placing the listeners on a live stream - where they can listen to the meeting, but they are not on the actual Zoom call, which will make the interaction between the active participants easier.

In this post, we'll walk through the steps to add an api.video live stream to your Zoom call. Here's a video walking through the setup as well:







## Set up

In order to livestream your Zoom calls, you must be on a paid plan.  This feature is not available on the "Basic" free plan.

Go to your Settings page, and choose "in a meeting (advanced)"


medium_screenshot-2021-07-26-at-12-21-31.png

small_screenshot-2021-07-26-at-12-21-31.png

thumbnail_screenshot-2021-07-26-at-12-21-31.png

screenshot-2021-07-26-at-12-21-31.png

In this section, you'll find the "Allow livestreaming of meetings" section. Turn on the 4th option "Custom Live Streaming Service."  You can add a text comment - in the screenshot above, I added 'api.video,' but you could leave this blank.

## Creating the meeting


Adding the live streaming settings is easiest from the browser.  In your Zoom account, create a meeting.  Do all the normal things, like setting the date & time.  When done, press "Save"

A page will load with a summary of your meeting, but at the bottom is a section for setting up your live streaming:



large_screenshot-2021-07-26-at-12-35-30.png

medium_screenshot-2021-07-26-at-12-35-30.png

small_screenshot-2021-07-26-at-12-35-30.png

thumbnail_screenshot-2021-07-26-at-12-35-30.png

screenshot-2021-07-26-at-12-35-30.png

When you click the button to Configure your live stream, you'll be asked for 3 things:

* Stream URL: rtmp://broadcast.api.video/s
* Stream Key: Unique to your stream
* Viewing URL: The page where viewers can watch the stream


medium_screenshot-2021-07-26-at-12-43-01.png

small_screenshot-2021-07-26-at-12-43-01.png

thumbnail_screenshot-2021-07-26-at-12-43-01.png

screenshot-2021-07-26-at-12-43-01.png

These values are all available on the summary page of your live stream at [go.api.video](https://go.api.video) as shown in the above screenshot (Stream Key is obfuscated for security reasons.

Once you enter these values on the Zoom meeting, you are set - until the meeting actually starts.

## In the meeting

Even though you have set up the Live Stream, it is not actually active until you turn it on.  You do this in the "More" setting in the meeting, and choosing the "Live on Custom Streaming Service" button:

large_screenshot-2021-07-26-at-11-29-58.png

medium_screenshot-2021-07-26-at-11-29-58.png

small_screenshot-2021-07-26-at-11-29-58.png

thumbnail_screenshot-2021-07-26-at-11-29-58.png

screenshot-2021-07-26-at-11-29-58.png

Zoom will open a webpage, and then redirect to the "watch page."  When you return to the Zoom meeting, you'll see a notification in the upper right hand corner:



medium_screenshot-2021-07-26-at-11-33-48.png

small_screenshot-2021-07-26-at-11-33-48.png

thumbnail_screenshot-2021-07-26-at-11-33-48.png

screenshot-2021-07-26-at-11-33-48.png

## Now your meeting is Live Streaming!

In summary, there are a few steps to set up and then turn on your Zoom -> Live Stream.  But once they are set up, it is a pretty simple task to ensure that your Zoom conference calls are live streamed to your wider audience.

If you run into any issues, please reach out to us on the [api.video community](https://community.api.video)


Live stream your Zoom call with api.video

Add an api.video live stream to your Zoom call

small_zoomapivideo.jpg

thumbnail_zoomapivideo.jpg

zoomapivideo.jpg

Liven is an events management company with a mission to facilitate stress-free hybrid event experiences. Their product combines online presentations and meetings with conference broadcasts and in-person events. 

large_wedding-liven.png

medium_wedding-liven.png

small_wedding-liven.png

thumbnail_wedding-liven.png

wedding-liven.png

## An early stage start-up with an all IP live event system
“We are a pretty early stage start-up. We’re building an all IP live event system for venues and organizers. Our whole philosophy is that there’s no reason that slides, content, the sound, the lighting, the live stream and videos or anything can’t just be controlled over the internet. The technology is there,” Brett Fischl, co-founder of Liven said.

Another goal of building all the tools in-house was to cut down on time consuming errors that can occur when people need to navigate across multiple platforms. As part of their vision, Liven wanted to be able to offer high quality live streams of events and feature multiple camera angles. 

“An iPhone has a better camera than most professional grade cameras. Just buy five iPhones instead of having just one camera and then you have 5 video feeds of the whole venue,” said Brett. 

## They needed a way to broadcast content
While building their application, they realized they would need a way to broadcast content. They wanted something high quality, cost-effective, and easy to implement. After some online googling and research, the answer was clear - api.video. With its [straightforward API](https://docs.api.video/reference), [robust client and SDK offerings](https://github.com/apivideo), and [detailed documentation](https://api.video/blog/tutorials/), it seemed like the perfect fit. 

“We actually ended up building the whole integration in about a week,” Brett told us. “We had an event coming up and we needed that high quality video. … We made the decision that you guys are probably the easiest looking to integrate with. … It was super easy.”

## Liven chose api.video
So far Liven has featured api.video live streams at weddings. Particularly due to Covid, virtual attendees enjoyed the multiple camera angles of the event even though they couldn’t be there in person. Using Liven, they could choose different live streams to follow and watch. And, if the director of the show decided the virtual audience should direct their attention to a particular feed, they were able to do so to keep everyone engaged on the most important parts of the event.

“We really lean into the RTMP video feed there because we want to have a very high quality video broadcast coming out of these types of events. Right now we use api.video for weddings...at the end of a wedding we just use all the video feeds and we cut together a nice short that’s a 5-10 minute highlight reel of the event.” 

## Liven uses api.video for live and online events
Liven also does pop up shop promotion. Brett described one venue that regularly live streams pop up shopping events with multiple camera angles. The live streams are provided through api.video. As for the future, Fischl says they’re hoping to add webRTC capabilities to allow for certain events like panels or meetings to happen. They plan to continue using api.video for beautiful, high quality live streams they can broadcast to online audiences.


Case Study: Liven built their all IP event management system using api.video

large_liven.png

medium_liven.png

small_liven.png

thumbnail_liven.png

liven.png

codec

small_cedric.jpeg

thumbnail_cedric.jpeg

cedric.jpeg

Cédric Montet

At api.video, our goal is for video to be easy and affordable for anyone to build, be it individuals or organizations. We understand that achieving this goal means reducing costs at some stage of the video streaming process. That’s why, we now offer adaptive bitrate encoding for your videos at zero cost. 

&nbsp;

Yes, you heard me right. 

&nbsp;

**Encoding videos will be absolutely free for all video qualities (1080p or 4K) at [api.video](https://api.video/) - no hidden calculations, footer notes or tricks.**

(Check out this [video](https://www.youtube.com/watch?v=ouosgLbW7Ts) for more details) 


## A step towards making video streaming affordable

Video encoding is crucial as it makes it possible for videos to be shared and played smoothly on the internet. It is why we are easily able to consume various types of video media, whether it’s a YouTube video, our favorite shows on Netflix, or even catching up with friends across the globe on Zoom. Video encoding basically makes the world go around in regards to anything related to video and video content.

&nbsp;

We at api.video recognize that. From [increasing the transcoding and playback speed ](https://api.video/blog/product-updates/2021-in-review/)to building [specialized hardware like ASICs](https://api.video/blog/video-trends/the-comeback-of-specialized-hardware/) cards to increase our transcoding capacities, we've been working to make video streaming easier for you every day. And after dedicating ample time to engaging with our customers and learning about their concerns, free encoding seemed to be the next step in this direction. 

&nbsp;

So, we worked tirelessly behind the scenes to give you what no one else will - free encoding for all video qualities, be it 360p or 4K. 

## How does free video encoding benefit you as a customer

The benefit is straightforward: you save a LOT of money!

&nbsp;

- With free video encoding, you will have one less thing to worry about. As you know, you pay for three things for streaming videos — encoding, hosting, and delivery – out of which encoding is the most expensive, especially if you have a lot of videos. Free video encoding will allow you to focus your attention and resources to what is most important.

&nbsp;

- As the video needs of your app users grow, you might need to scale up your encoding capacity. Free video encoding services will give you the power to scale without any additional costs, meaning your users can handle more videos without increasing your expenses.

&nbsp;

- You can [migrate from your previous provider to api.video](https://api.video/compare/azure-media-services/) without paying an ‘entry tax’ to us. With free video encoding, you no longer need to spend money on encoding videos with a new provider when you have already paid for encoding with an older one.

&nbsp;

Now with all the saved cost, you can allocate your resources and money to a place where it is actually important – building your product and delighting your users. 

## How to get started

To use the free video encoding benefit, getting started is easy. 

&nbsp;

- If you’re a new user, [sign-up](https://dashboard.api.video/register) for a free sandbox account and start uploading your videos
- If you are looking to migrate from another vendor, [import](https://import.api.video/) your videos from your current vendor
- If you have any questions, [talk to us](https://meetings.hubspot.com/diego398/cc-talk-to-us?__hstc=54467703.754940701eda85e3c99a902d8ab0b988.1687266643206.1694417789132.1694427271479.149&__hssc=54467703.3.1694427271479&__hsfp=3654297906) by booking a slot in our calendar

&nbsp;

To know more about our[ features](https://api.video/features/), [pricing](https://api.video/pricing/) or ask any other questions, [talk to our team ](https://meetings.hubspot.com/diego398/cc-talk-to-us?__hstc=54467703.754940701eda85e3c99a902d8ab0b988.1687266643206.1694162373815.1694167498585.144&__hssc=54467703.1.1694167498585&__hsfp=3654297906)and we will help you out. 

&nbsp;

Or, you can straightaway [sign-up](https://dashboard.api.video/register) for a free sandbox account and check our product out for yourself. 


Huge pricing update: Introducing video encoding at no cost

large_Blog_Zero Cost (2).png

medium_Blog_Zero Cost (2).png

small_Blog_Zero Cost (2).png

thumbnail_Blog_Zero Cost (2).png

Blog_Zero Cost (2).png

api.video team

Modern technology has been helpful for an increasingly fast and simple method of consuming various types of video media, whether it’s a YouTube video, our favorite shows on Netflix, or even catching up with friends across the globe on Zoom. Despite the relative ease of doing anything related to video, a few complex processes take place behind the scenes, away from public view. One such process is video encoding.

Video encoding basically makes the world go around in regards to anything related to video and video content. Thanks to the technologies behind the video encoding process, it has become much easier for people and companies to share video content on the internet. But what exactly is video encoding, and what happens during the process? We’ll take a closer look at this and much more in this handy guide to video encoding.

## What is video encoding?

In a nutshell, video encoding occurs when you take raw video footage, either from a digital camera or an analog film camera, and digitally compress it to make it a more manageable file size. Video encoding happens daily in both professional and personal capacities, and many people don’t realize it.

But, without encoding, services like Netflix and YouTube would not exist – or, at least, not in the same way that it does today. Without it, we couldn’t send videos of our beloved pets to our friends and family as easily as we can today.

## Why is video encoding used?

There are a variety of reasons why video encoding is used, but all factors point to the single function of video encoding – **compression**.

This is done to ensure optimal performance and compatibility with a selected suite of software and hardware, be it for DVD/Blu-ray playback, mobile viewing, online video streaming, or general video editing. A file's video and audio information undergo transformation and compression during the encoding process, all in accordance with the requirements of the selected encoding standard.

On a professional level, the ability to compress raw video into more manageable sizes makes it easier to transmit video content such as training, promotion, presentation, and so on over the internet. 

On a personal level, video encoding makes it much easier to send videos taken from your phone directly to friends and family. Most modern-day personal devices have built-in video encoding capabilities to allow for this to happen without a second thought.

To put things in perspective, uncompressed or unencoded video can have a data rate that’s as low as 3,000 Mbps and as high as 12,000 Mbps, depending on the length and quality of the video recorded. 

**Without encoding, it would take up to days for anyone to not just transmit video, but to be able to consume it, too.**

## Differences between video encoding and video transcoding

You need to be familiar with two more [essential terms related to video encoding](https://api.video/what-is/) – transcoding and codecs.

Transcoding relates to the conversion from one digital encoding format to another. It takes the already encoded video file, decompresses it, and then alters it before re-encoding or compressing it into a different codec. Codecs are what allow encoding to occur in the first place. They are software or hardware that gives us the ability to compress video to make them more easily stored and delivered tightly.

While you may hear “encoding” and “transcoding” used interchangeably, the two terms actually mean different things. Putting it succinctly, encoding is the initial process of compressing a video from a source – such as a camera – into a codec, while transcoding takes an already encoded video file to convert it into a different codec.

## Examples of video codecs

In order to understand video encoding, you must first be familiar with two interrelated terms: [video codecs and video formats](https://api.video/blog/product-updates/every-video-format-codec-and-container-explained/). These also tend to be used interchangeably, but much like the terms encoding and transcoding, they refer to two different things.

Video formats are the type of files in which the compressed video/audio is stored. Also known as a “container”, you can tell what a video format is by looking at the file’s extension — the three to four characters that sit after a period in a file name. Here are some of the most common video formats used today:

* MP4
* FLV
* MOV
* MKV
* LXF
* MXF
* AVI
* WebM
* QT

On the other hand, **the codec is short for “Coder / Decoder” (compression / decompression)** and relates to the video compression algorithms that allow encoding to happen. Over the years, codecs have gone through multiple iterations as it coincides with the increasing sophistication and rise in the quality of filmmaking. 

If you’re a content creator, you might be aware of some of the video codecs that exist today:

- **H.264 – also known as AVC, this is the most widely-used video codec available on every platform and mobile device.**
- H.265 – also known as HEVC, stands for High-Efficiency Video Coding, and it’s slowly overtaking H.264 as the standard. This codec can compress video much more efficiently than its predecessor.
- **VP9 – is an open-source, royalty-free codec developed by Google and is considered the direct competitor of H.265. The video compression codec VP9 was created to reduce file sizes, making streaming videos simpler.**
- **AV1 – is another royalty-free, open-source codec released in 2019 by the non-profit Alliance for Open Media. It was developed to become the successor to Google’s VP9 and contend with HEVC more directly.**

## How do different technologies handle video encoding

As you may have suspected, there are a majority of ways that different technologies handle the video encoding process. Let’s take a look at the most common technologies that use video and how video encoding works on each of them:

### Video editing software

When it comes to video content creation, a majority of people will use one of two video editing software — Adobe Premiere Pro or Apple’s Final Cut Pro. Both of these video editing software handle video encoding in very similar ways: when exporting the finished video.

Depending on which device the video content is recorded on, it will already be encoded and formatted according to the settings of the device. For those using iPhones recording 1080p video at 25 frames per second (FPS), for example, the iPhone will automatically encode the video using H.264 and contain it in a .mov file format. The video editing software will “open up” the container to get to the encoded, compressed video file within so the editing process can begin.

After editing the footage is complete, it will need to be exported, which typically concerns video encoding. The edited raw media taken from a recording device such as a camera will be encoded via the codec of the person’s choosing before being put into a .mp4 container once they’ve hit “export”. As we’ve mentioned before, the most common codec used in video content creation is H.264 for HD videos, with 4K videos using H.265. 

### Websites

Different websites utilize different techniques to handle video encoding – with a majority of the major sites like YouTube, Netflix, and so on using their own technologies to handle the process. A majority of social media websites allow you to upload video files directly onto the site to share, although most of them require the files to be saved in specific containers. 

These websites will take your video file and transcode it before using their own systems and serves to re-encode it to match multiple display resolutions. This process will happen regardless of your video file's original codec and settings. Different websites have different processes, but companies that don’t have the capacity to build their own video encoding systems can use a third-party application programming interface (or API) to handle this process. These APIs act as [dedicated video encoder](https://api.video/encoding/) that allows companies to add on-demand videos to their websites more efficiently.

Using [api.video](http://api.video) as an example, all of the videos submitted to the platform will be transformed into H.264 codec in an MP4 container. This may be done using transmuxing and/or transcoding.

We expect the video bitrate to be lower than 16 Mbps for up to 1080p resolution and 50 Mbps for up to 4K resolution. We accept any bitrates, however, we will scale them down to the limits mentioned because anything above is usually challenging for most viewers’ connection to watch.

### API

The ability to generate, store, and distribute video is made possible via a video API. [api.video](http://api.video)’s solution can be tailored to suit any specific need. 

The backend process of video on demand (VOD) is exceptionally complex, even if you’re a software programmer specializing in video. It is necessary to encode, package, and typically transcode the data before sending it to any of several possible destinations. All of these things, and more, may be done with minimal fuss using api.video.

Our API basically keeps the complexities of streaming media hidden from view, so you can rapidly develop apps with as much control as you need. This saves time and effort so developers can concentrate on making the product.

## Conclusion

As you can see through this video encoding guide, a lot of work goes into making the video you watch and the video you share possible. Without video encoding compressing raw video footage, it could take days to upload and transmit video content over the internet and perhaps even longer to be able to download and enjoy them. 

The best part about encoding at api.video is that is offered at ZERO cost. You will only be charged for delivery and hosting of your videos, and the encoding will be free. Now integrate your videos in minutes with api.video or [contact us](https://api.video/contact) for more information.

A Guide to Video Encoding & Video Codecs

large_poster-3.png

medium_poster-3.png

small_poster-3.png

thumbnail_poster-3.png

poster-3.png

Encoding and transcoding are often used interchangeably but they have slightly different definitions. **Encoding is the initial process of converting raw video files into a specific digital format or codec.** It involves compressing and packaging the video data, often to reduce file size while maintaining acceptable quality. Encoding prepares the video for storage, transmission, or playback.

&nbsp;

**Transcoding, on the other hand, involves converting a video from one digital format or codec to another.** This is typically done to optimize the video for different devices or platforms, adapt to varying network conditions, or ensure compatibility with specific playback requirements. Transcoding occurs after encoding and often involves changing resolution, bitrates, or formats without altering the content itself.

## What goes on behind encoding a video?

It's easy to say that encoding is when you go from an _uncompressed source_ to a _compressed source_, but you may ask, what exactly do compressed and uncompressed sources mean?

&nbsp;

Uncompressed sources are video files that contain data that comes directly from a camera sensor vs. encoded video. In the digital space, it's SDI (Serial Digital Interface) or HDMI (High Definition Multimedia Interface). Both of them are popular standards. You'll find HDMI in places like your GoPro camera, or a mini camcorder. These days, you might also find HDMI in professional settings, but SDI is more common due to its reliability. Another example of an uncompressed source would be something analog, for instance, VHS tapes.

&nbsp;

A compressed sources, on the other hand, are video files that have undergone compression during the encoding process. Compression involves reducing the file size by removing unnecessary information or encoding the data in a more efficient format. This process results in a smaller file size, making it more manageable for storage, transmission, and playback.


## What are the types of transcoding methods?

There are three types of transcoding, depending on what you are trying to do to get a video to suit a particular browser, player, or platform:

* **Lossless-to-lossless** - This type of transcoding maintains the quality of your video across formats but allows you to take advantage of better hardware or compression algorithms. 
* **Lossless-to-lossy** - This type of transcoding will decrease your video in quality, but it will benefit you in ways such as – you will get a smaller and/or faster playing file, or a file that is compatible with the requirements of a particular platform, player, or browser.
* **Lossy-to-lossless** - Sometimes people think this means they are regaining quality. This isn't the case in this type of transcoding. If you transcode from a lossy format to a lossless format, all that it means is that you will not lose additional quality in the conversion process. You will not regain data you already lost through compression.

## Codecs for encoding and transcoding

For both encoding and transcoding, you will need to make use of codecs. A codec's job is to compress and decompress video files. It's right there in the name -  **co**mpress **dec**ompress or encode decode. So basically, codec is an algorithm that takes the video and shrinks it or changes it into a format that makes it compatible with the requirements of wherever you want the video to play. There are many codecs because there are many ways to compress a video or livestream for playback.



## What is transmuxing?

Now that you know the difference between encoding and transcoding, let's throw one more term in there - transmuxing. Transmuxing is when you change the container for a video instead of the format. It's a way of repackaging a video to make it compatible somewhere without changing what's in the file. 

&nbsp;

This process is faster than encoding or transcoding and takes less computing power because you only change the container, not the file. It's great when you need to quickly make something available, but the downside is that it doesn't handle things like making multiple video resolutions available. If you choose a container type that's incompatible with your video file, you may also cause compatibility issues, resulting in not being able to play the video.

## In closing

* **Encoding** - Encoding happens when you compress a raw data file from a video camera sensor or an analog source like a VHS tape. 
* **Transcoding** - Transcoding happens when you take an already compressed video file and change it to another format.
* **Transmuxing** - Transmuxing happens when you change the container of a video file but leave the video file untouched. 

We hope that explains the difference between encoding and transcoding clearly. 

_If you are looking for an affordable video API solution that does not burn a hole in your pocket for transcoding and encoding videos, check out our offerings on our [homepage](https://api.video/) or [sign-up for a free account here](https://dashboard.api.video/register)!_

Encoding and transcoding: what's the difference? 

Encoding and Transcoding - What's the Difference?

large_encoding-and-transcoding-whats-the-difference.jpg

medium_encoding-and-transcoding-whats-the-difference.jpg

small_encoding-and-transcoding-whats-the-difference.jpg

thumbnail_encoding-and-transcoding-whats-the-difference.jpg

encoding-and-transcoding-whats-the-difference.jpg

Once I upload my video, how quickly will it be ready to be viewed?

Our reply to this question has always been “it's really fast.”  And it is really fast. But, the dev team gave me access to the backend database, and pointed me to a few tables that might be helpful (thanks to Thomas Persohn for your patient help!)

Thus armed, I waded into a sea of data to better understand how fast our videos are encoded at api.video

## Encoding

When a video is uploaded to api.video, it is re-encoded to a HLS stream, with several different video dimensions and bitrates.  This allows api.video to deliver properly sized video to all users - no matter the device or network connection. (Read our post on [Responsive video delivery](https://api.video/blog/video-trends/responsive-video-delivery/) to learn more.)

> Summary:  All videos are encoded at 240p, 360p, 480p, 720p, 1080p and 2160p. However, the videos are only encoded up to the initial size of the video (so if the original video is 720p, there will not be 1080p or 2160p versions available). 

**FYI:** For our customers, encoding is absolutely free – we offer adaptive bitrate encoding at zero cost. 

How long does this step take? If a customer uploads a video to our service - they want to know how efficient api.video creates the content for viewing.

### Data in the study

We are constantly making adjustments to our infrastructure to speed the encoding step of our video (and that is one reason this post is dated 2H 2020 - we expect to be faster in early 2021). The last major adjustment was made in mid October, so the data presented in this study from every video uploaded to the api.video service between 15 October and 2 December 2020.

### Parameters that affect encoding

There are 2 major parameters that affect the speed of encoding a new video stream: the output dimensions and the length (duration) of the video.  

#### Dimensions

The output video dimensions have a huge impact on video creation - a 3840 × 2160 (or 4K or 2160p) video has millions more pixels than a 320x240 (240p) video, so it takes a lot longer to create.  In general, the videos exit the encoding process from smallest to largest.

#### Duration

If a video is 30 frames per second, and is 60 seconds long, there are 1800 frames to be created.  If a 30 frame per second video is an hour long 3600s), there are 108,000 frames to be created, so the longer the video - the more time for creation.

## Analysis

To better understand the encoding time, I divided the data by the size of the output video size, and looked at 2 lengths of video  - those under 5 minutes, and videos that are 45-75 minutes long (we are often asked how long a 1 hour video takes to encode).

I calculated encoding time for each bucket of video using percentiles.  

> Quick review - percentiles break the data into 100 evenly sized segments, so the 25th percentile is when 25% of the videos have been encoded. The median is the 50th percentile, and is when 50% of videos have been encoded.  We report here to the 95th percentile for video encoding.

### Short videos - under 5 minutes long

Many of the videos uploaded to api.video are short - under 5 minutes long.  These videos are generally ready to play in a few seconds:



The above chart has a lot of data, the 25, 50, 75, 90 and 95th percentile encoding times for all 6 variants of the video that api.video creates.

The median video is ready to play (at 240p) in 5.6 seconds, but a 720p version will be ready in 15s after encoding begins, and the 4K version will be ready in 37 seconds.

95% of all videos (under 5 minutes) will be playable in 32.6s, and will have 1080p versions ready in just over 2 minutes (140s).

### Long videos - 45 - 75 minutes long

Our most frequently asked question on encoding is "how long for a 1 hour video to be encoded and ready?"  Here are the numbers:


Observant viewers will see there are no 4K videos in this report. At this time, there are very few 4K streams that reach the 1 hour timeframe, and the data was quite noisy.  Hopefully, more of our 'long uploads' will add 4K support, so we can add this metric in our next update.

The median hour long video (red line) will be ready to play (at 240p) in just over 9 minutes (555s), and a 720p version will be ready about 18 minutes after encoding begins (1099s).

95% of hour long videos will have a 240p version ready in 33 minutes, and 720p in 54 (3230s).  the 1080p version will be available for 95% of videos in 108 minutes,

## Conclusion

Short videos will be ready to play - even at high resolution - in under a minute: the median 4K encoding for a short video is 37s. 

Hour long videos take longer to encode, and the median 720p video will be ready in 18 minutes.  95% of 720p videos will be ready to play in 54 minutes.

This is really fast! You can have responsive streaming video ready for your customers in just a few minutes with a simple upload!

That said, our team is working hard in the background to improve our infrastructure to make our encoding speeds even faster! 

We're really excited to have hard numbers to share with you on our encoding speeds, and we cannot wait to re-benchmark this data in 2021 to see how much faster your videos will be encoded as we improve our service.

Do you have questions about api.video or video encoding? Reach out on our [community page](https://community.api.video).


How fast does api.video encode video? 2H 2020 data

medium_gif.jpg

small_gif.jpg

thumbnail_gif.jpg

gif.jpg

Huge pricing update! Introducing video encoding at zero cost

Featured article

# api.video blog

Blog

Follow the api.video Blog to explore tutorials, video use cases, and learn about on-demand and live-streaming video updates.

Video on demand

Live streaming

Analytics

See all features

Online learning

Short-form videos

Marketplace & E-commerce

Video messaging and recording

Quick start guides

Documentation

Ecosystem catalog

Clients & SDKs

Community

Blog

Demos

Help center

Blog

Huge pricing update! Introducing video encoding at zero cost