Some sample command lines:

H.264 WEB VIDEO ENCODING TUTORIAL WITH FFMPEG

6th January 2012 · by Jernej Virag · in Computer stuff, Video encoding / FFmpeg

Web is full of articles about encoding videos with FFmpeg, however most of them are obsolete and use old non-working FFmpeg parameters. So here’s my guide for encoding web videos using recent FFMpeg versions for Flash and HTML5.

Step 1: Get a new build of FFmpeg

Most distribution builds are very old, buggy and have numerous issues. Don’t use them.

Ubuntu users: UbuntuForums has a great guide for compiling newest FFMpeg build. I strongly suggest you use a stable FFmpeg build (that’s 0.9 at the moment) instead of git master. Don’t forget libx264 for H.264 and libvpx for VP8/WEBM if you want that support.
Windows users: Zeranoe has great static builds of FFmpeg for Windows with libx264 and libvpx included. Use those for encoding.
OS X users: MacPorts should be able to compile and install FFmpeg with libvpx and libx264. As I don’t use any machines with OS X you’ll have to check for yourself.

If you already know what “bitrates, profiles etc.” are and just want the command lines skip to step 4 or sample command lines.

Step 2: Choose resolution, bitrate and profile

Now you’ll have to decide on two things – the resolution, bitrate and profile you want those videos in.

Resolution gives “sharpness” to the overall image. If you choose a low resolution, the video will be small and it will be blurry when users will put it full-screen. Typically people use 360p (that’s a shorthand naming made popular by HD televison, meaning picture has height of 360 with width corresponding to wanted aspect ratio), 480p, 720p and 1080p resolutions, as those correspond to common screen sizes, which avoids excessive blurriness.
Contrary to popular belief, resolution does not affect file size.

Bitrate tells the encoder about how many bits should each second of video have. It directly determines file size of the video along with the quality. Set too low, it will cause the video to look very blocky (especially in fast-moving scenes) and set too high will make your files excessively large.
When choosing bitrate you need to remember, it is directly connected to resolution – storing pictures of certain resolution requires more bits, so if you want higher resolution videos, you’ll have to choose higher bitrate for them to not look like garbage.
A rule of thumb to calculate file size from bitrate is:

filesize (in MB) = (bitrate in Mbit/s * 8) * (video length in seconds)

Some general resolution/bitrate guidelines that we’ve found to work well at Viidea:

RESOLUTION	BITRATE	APPROXIMATE SIZE OF 10 MIN VIDEO
320p (for mobile phones)	180 kbit/s	~13 MB
360p	300 kbit/s	~22 MB
480p	500 kbit/s	~37 MB
576p (SD)	850 kbit/s	~63 MB
720p (HD)	1000 kbit/s	~75 MB

The values in the table were optimized for lecture-type content recorded with SD cameras, so if you want to encode something more dynamic (like Transformers ;) ) I suggest you bump the bitrate up a little.

Profile constrains H.264 to a subset of features – higher profiles require more CPU power to decode and are able to generate better looking videos at same bitrate. You should always choose the best profile your target devices support.

Basic support matrix for devices:

DEVICE	MAX SUPPORTED PROFILE
Desktop browsers iPhone 4S, iPad 2  Tegra Android tablets Xbox 360, Playstation 3	High profile
iPhone 3GS, iPhone 4, iPad high-end Android phones	Main profile
iPhone, iPhone 3G medium/low-end Android devices other embedded players	Baseline profile

Remember, most devices also have a maximum resolution and bitrate they can handle. That is usually expressed in as a H.264 level and can be set in FFmpeg with -level parameter (this will make FFmpeg abort encoding of videos which couldn’t be played on the device).

Step 3: Choose audio format and bitrate

For audio, the choice is a lot simpler – if you want to encode for mobile devices I strongly suggest you use AAC+, which has a very noticeable improvement of audio quality at the same bitrate. Sadly, libaacplus in FFmpeg, doesn’t support encoding to higher bitrates than 64 kbps. With that in mind, AAC+ is perfect for podcasts, lectures and other speech content, since it retains quality even at low bitrates (difference between “normal” LC-AAC at 96 kbit/s  vs. AAC+ at 64kbit/s is practically not noticeable).

Otherwise, rule of thumb is to take around 128 kbit/s for standard quality material and 192kbit/s for something more complex.

Step 4: Encode!

So, you made all the hard choices and now it’s time to encode your video. FFmpeg command line to encode a standard web video looks like this:

ffmpeg -i input_file.avi -vcodec libx264 -vprofile high -preset slow -b:v 500k -maxrate 500k -bufsize 1000k -vf scale=-1:480 -threads 0 -acodec libfdk_aac -b:a 128k output_file.mp4

You can also encode the video in two-passes, which gives the added benefit of quality increase and more accurate file size for given bitrate:

1st pass:

ffmpeg -i input_file.avi -vcodec libx264 -vprofile high -preset slow -b:v 500k -maxrate 500k -bufsize 1000k -vf scale=-1:480 -threads 0 -pass 1 -an -f mp4 /dev/null

2nd pass:

ffmpeg -i input_file.avi -vcodec libx264 -vprofile high -preset slow -b:v 500k -maxrate 500k -bufsize 1000k -vf scale=-1:480 -threads 0 -pass 2 -acodec libfdk_aac -b:a 128k -f mp4 output_file.mp4

Scary isn’t it?

Warning: ffmpeg command line arguments are position sensitive – make sure you don’t mix up the order. Good rule of thumb to prevent mistakes is to keep the order of
ffmpeg [input options] -i [input filename] -vcodec [video options] -acodec

Download: options


[output file options] [output filename]

Let’s break down all those parameters:

-i [input file]  - this specifies the name of input file
-vcodec libx264 – tells FFmpeg to encode video to H.264 using libx264 library
-vprofile high – sets H.264 profile to “High” as per Step 2. Other valid options are baseline, main
-preset slow – sets encoding preset for x264 – slower presets give more quality at same bitrate, but need more time to encode. “Slow” is a good balance between encoding time and quality.
Other valid options are: ultrafast, superfast, veryfast, faster, fast, medium, slow, slower, veryslow, placebo (never use this one)
-b:v - sets video bitrate in bits/s-maxrate and -bufsize – forces libx264 to build video in a way, that it could be streamed over 500kbit/s line considering device buffer of 1000kbits. Very useful for web – setting this to bitrate and 2x bitrate gives good results.
-vf scale – applies “scale” filter, which resizes video to desired resolution. “720:480″ would resize video to 720×480, “-1″ means “resize so the aspect ratio is same.”
Usually you set only height of the video, so for 380p you set “scale=-1:380″, for 720p “scale=-1:720″ etc.
-threads 0 – tells libx264 to choose optimal number of threads to encode, which will make sure all your processor cores in the computer are used

-acodec libfdk_aac – tells FFmpeg to encode audio to AAC using libfdk-aac library
-b:a - sets audio bitrate in bits/s

-pass [1|2] – tells FFmpeg to process video in multiple passes and sets the current pass
-an – disables audio, audio processing has no effect on first pass so it’s best to disable it to not waste CPU

That’s basically all there is to it.

Some sample command lines:

“Standard” web video (480p at 500kbit/s):
ffmpeg -i input_file.avi -vcodec libx264 -vprofile high -preset slow -b:v 500k -maxrate 500k -bufsize 1000k -vf scale=-1:480 -threads 0 -acodec libfdk_aac -b:a 128k output_file.mp4

360p video for older mobile phones (360p at 250kbit/s in baseline profile):
ffmpeg -i inputfile.avi -vcodec libx264 -vprofile baseline -preset slow -b:v 250k -maxrate 250k -bufsize 500k -vf scale=-1:360 -threads 0 -acodec libfdk_aac -b:a 96k output.mp4

480p video for iPads and tablets (480p at 400kbit/s in main profile):
ffmpeg -i inputfile.avi -vcodec libx264 -vprofile main -preset slow -b:v 400k -maxrate 400k -bufsize 800k -vf scale=-1:480 -threads 0 -acodec libfdk_aac -b:a 128k output.mp4

High-quality SD video for archive/storage (PAL at 1Mbit/s in high profile):
ffmpeg -i inputfile.avi -vcodec libx264 -vprofile high -preset slower -b:v 1000k -vf scale=-1:576 -threads 0 -acodec libfdk_aac -b:a 196k output.mp4

android layout and the layout of the property

 set EditText is empty input box prompt information.
 android: gravity 
android: gravity attribute is limited to the contents of this view. For example, a button above the text. You can set the text in the view of the left, right, and other locations. In button example, android: gravity = "right" button above text is right
 android: layout_gravity 
android: layout_gravity is used to set up the view relative to the location of the parent view. For example, a button in linearlayout where you want the button on the left, right, and other locations can be set through this property. In button example, android: layout_gravity = "right" then button right 

android: layout_alignParentRight 
to make the right and the parent of the current control control is aligned to the right. This property value can only be true or false, default false.
 android: scaleType: 
android: scaleType is to control how the image resized / moved to the horses on the ImageView size. ImageView.ScaleType / android: scaleType meaning of the value difference:
 CENTER / center at the original size picture centered, when the image length / width exceeding View the length / width, then the middle part of the picture shows the interception
 CENTER_CROP / centerCrop scaled image size centered, makes the picture length (W) equal to or greater than the length of View (W)
 CENTER_INSIDE / centerInside complete contents of the picture centered by a scaled-down size makes the picture or the original length / width equal to or less than the View's length / width
 FIT_CENTER / fitCenter the picture proportionally expansion / reduction to View the width, centered
 FIT_END / fitEnd the picture proportionally expansion / reduction to View the width of the lower part of the display in the View location
 FIT_START / fitStart the picture proportionally expansion / reduction to View the width of the upper part of the display in the View location
 FIT_XY / fitXY the picture? disproportionate expansion / reduction of the size of the display to the View
 MATRIX / matrix matrix to draw dynamically shrink enlarged images to display.
 ** to note that, Drawable folder inside the picture naming is not capitalized.

With Android Sensor Development Compass

Level sensor returned by the first parameter value is to represent the phone turned angle around the Z-axis, which is the top of the phone and the angle between true north. In the program by checking the angle compass application can be achieved. In fact, the idea is very simple, first prepare a picture, the picture pointer direction north. Then develop a direction sensor detects when the program detects the phone number at the top of the angle around the Z-axis turn, let the number of degrees compass picture reverse turn, thus achieving a pointer always points to true north. This is also the principle of the compass. Code is as follows:
Activity:

[Java]
package com.home.compass;
 
import android.app.Activity;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.view.animation.Animation;
import android.view.animation.RotateAnimation;
import android.widget.ImageView;
 
public class CompassTestActivity extends Activity implements
        SensorEventListener {
    / / Define the display assembly compass picture
    private ImageView image;
    / / Record the compass picture angle turned
    private float currentDegree = 0f;
    / / Define the real machine Sensor Manager
    private SensorManager mSensorManager;
 
    @ Override
    protected void onCreate (Bundle savedInstanceState) {
        super.onCreate (savedInstanceState);
        setContentView (R.layout.main);
        image = (ImageView) findViewById (R.id.main_iv);
        / / Get the real machine sensor management services
        mSensorManager = (SensorManager) getSystemService (SENSOR_SERVICE);
    }
 
    @ Override
    protected void onResume () {
        super.onResume ();
        / / For the system's orientation sensor registered listeners
        mSensorManager.registerListener (this,
                mSensorManager.getDefaultSensor (Sensor.TYPE_ORIENTATION),
                SensorManager.SENSOR_DELAY_GAME);
    }
 
    @ Override
    protected void onPause () {
        super.onPause ();
        / / Unregister
        mSensorManager.unregisterListener (this);
    }
 
    @ Override
    public void onAccuracyChanged (Sensor sensor, int accuracy) {
 
    }
 
    @ Override
    public void onSensorChanged (SensorEvent event) {
        / / If the event is triggered on a real machine sensor type level sensor type
        if (event.sensor.getType () == Sensor.TYPE_ORIENTATION) {
            / / Get the angle around the Z-axis rotated
            float degree = event.values ​​[0];
            / / Create a rotation animation (reverse turn degree degrees)
            RotateAnimation ra = new RotateAnimation (currentDegree,-degree,
                    Animation.RELATIVE_TO_SELF, 0.5f,
                    Animation.RELATIVE_TO_SELF, 0.5f);
            / / Set the duration of the animation
            ra.setDuration (200);
            / / Set the animation after the end of the reservation status
            ra.setFillAfter (true);
            / / Start the animation
            image.startAnimation (ra);
            currentDegree =-degree;
        }
    }
}
Layout XML:


<LinearLayout xmlns: android = "http://schemas.android.com/apk/res/android"
    android: layout_width = "match_parent"
    android: layout_height = "match_parent"
    android: gravity = "center">
 
    <ImageView
        android: id = "@ + id / main_iv"
        android: layout_width = "wrap_content"
        android: layout_height = "wrap_content"
        android: src = "@ drawable / znz" />
 
</ LinearLayout>
Here attached a picture of the compass: