update README

add pods test application for tvos
update test applications
2019-07-04 14:31:46 +03:00 · 2019-07-03 23:13:37 +03:00 · 2019-07-03 16:39:28 +03:00 · 2019-07-03 13:22:54 +03:00 · 2019-07-03 13:15:44 +03:00 · 2019-07-03 03:35:47 +03:00
11803 changed files with 1074065 additions and 559329 deletions
@@ -0,0 +1,33 @@
+---
+name: Issue Template
+about: Create an issue to help us improve
+
+---
+
+**Description**
+Description of what the issue is about.
+
+**Expected behavior**
+What you expected to happen.
+
+**Current behavior**
+What happened.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Logs**
+Post logs here or paste them to [Ghostbin](https://ghostbin.com) and insert the link here.
+
+**Environment**
+ - Platform: [e.g. Android/IOS]
+ - Architecture: [arm-v7a, arm-v7a-neon, arm64-v8a, x86, x86_64, armv7, armv7s, arm64, i386, x86_64]
+ - Version (if applicable) [e.g. v1.2]
+ - Source branch (if applicable) [e.g. master, dev-v2.x]
+ - Xcode version (if applicable) [e.g. 7.3.1, 9.0.1]
+ - Cocoapods version (if applicable) [e.g. 1.2.1]
+ - Android Studio version (if applicable) [e.g. 3.1]
+ - Android NDK version (if applicable) [e.g. 16b, 17c]
+
+**Other**
+Add any other context about the problem here.
@@ -0,0 +1,130 @@
+branches:
+  only:
+  - master
+  - development
+sudo: false
+git:
+  quiet: true
+addons:
+  apt:
+    packages:
+      - autoconf
+      - automake
+      - libtool
+      - pkg-config
+      - curl
+      - git
+      - cmake
+      - gcc
+      - gperf
+      - texinfo
+      - yasm
+      - nasm
+      - bison
+      - autogen
+      - patch
+  homebrew:
+    packages:
+      - nasm
+    update: true
+matrix:
+  include:
+    - name: "Android Main Build"
+      language: android
+      android:
+        components:
+          - tools
+          - platform-tools
+          - build-tools-28.0.3
+          - android-24
+          - extra-google-google_play_services
+          - extra-google-m2repository
+          - extra-android-m2repository
+      install:
+        - echo y | sdkmanager "ndk-bundle"
+        - echo y | sdkmanager "cmake;3.10.2.4988404"
+        - echo y | sdkmanager "lldb;3.1"
+      before_script:
+        - export ANDROID_NDK_ROOT=$ANDROID_HOME/ndk-bundle
+        - rm -f ./build.log
+      after_success:
+        - grep -e INFO ./build.log | grep build
+      after_failure:
+        - tail -30 ./build.log
+        - tail -30 ./src/ffmpeg/ffbuild/config.log
+      script:
+        - bash ./android.sh --no-output-redirection
+    - name: "Android LTS Build"
+      language: android
+      android:
+        components:
+          - tools
+          - platform-tools
+          - build-tools-28.0.3
+          - android-16
+          - android-21
+          - extra-google-google_play_services
+          - extra-google-m2repository
+          - extra-android-m2repository
+      install:
+        - echo y | sdkmanager "ndk-bundle"
+        - echo y | sdkmanager "cmake;3.10.2.4988404"
+        - echo y | sdkmanager "lldb;3.1"
+      before_script:
+        - export ANDROID_NDK_ROOT=$ANDROID_HOME/ndk-bundle
+        - rm -f ./build.log
+      after_success:
+        - grep -e INFO ./build.log | grep build
+      after_failure:
+        - tail -30 ./build.log
+        - tail -30 ./src/ffmpeg/ffbuild/config.log
+      script:
+        - bash ./android.sh --lts --no-output-redirection
+    - name: "iOS Main Build"
+      language: objective-c
+      osx_image: xcode10.2
+      before_script:
+        - rm -f ./build.log
+      after_success:
+        - grep -e INFO ./build.log | grep build
+      after_failure:
+        - tail -30 ./build.log
+        - tail -30 ./src/ffmpeg/ffbuild/config.log
+      script:
+        - bash ./ios.sh --no-output-redirection
+    - name: "iOS LTS Build"
+      language: objective-c
+      osx_image: xcode7.3
+      before_script:
+        - rm -f ./build.log
+      after_success:
+        - grep -e INFO ./build.log | grep build
+      after_failure:
+        - tail -30 ./build.log
+        - tail -30 ./src/ffmpeg/ffbuild/config.log
+      script:
+        - bash ./ios.sh --lts --no-output-redirection
+    - name: "tvOS Main Build"
+      language: objective-c
+      osx_image: xcode10.2
+      before_script:
+        - rm -f ./build.log
+      after_success:
+        - grep -e INFO ./build.log | grep build
+      after_failure:
+        - tail -30 ./build.log
+        - tail -30 ./src/ffmpeg/ffbuild/config.log
+      script:
+        - bash ./tvos.sh --no-output-redirection
+    - name: "tvOS LTS Build"
+      language: objective-c
+      osx_image: xcode7.3
+      before_script:
+        - rm -f ./build.log
+      after_success:
+        - grep -e INFO ./build.log | grep build
+      after_failure:
+        - tail -30 ./build.log
+        - tail -30 ./src/ffmpeg/ffbuild/config.log
+      script:
+        - bash ./tvos.sh --lts --no-output-redirection
@@ -1,51 +1,64 @@
-# MobileFFmpeg [![Join the chat at https://gitter.im/mobile-ffmpeg/Lobby](https://badges.gitter.im/mobile-ffmpeg/Lobby.svg)](https://gitter.im/mobile-ffmpeg/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) ![GitHub release](https://img.shields.io/badge/release-v3.0-blue.svg) ![Bintray](https://img.shields.io/badge/bintray-v3.0-blue.svg) ![CocoaPods](https://img.shields.io/badge/pod-v3.0-blue.svg)
+# MobileFFmpeg ![GitHub release](https://img.shields.io/badge/release-v4.2.2-blue.svg) ![Bintray](https://img.shields.io/badge/bintray-v4.2.2-blue.svg) ![CocoaPods](https://img.shields.io/badge/pod-v4.2.2-blue.svg) [![Build Status](https://travis-ci.org/tanersener/mobile-ffmpeg.svg?branch=master)](https://travis-ci.org/tanersener/mobile-ffmpeg)

-FFmpeg for Android and IOS
+FFmpeg for Android, iOS and tvOS

-<img src="https://github.com/tanersener/mobile-ffmpeg/blob/dev-v3.x/docs/assets/mobile-ffmpeg-logo-v7.png" width="320">
+<img src="https://github.com/tanersener/mobile-ffmpeg/blob/master/docs/assets/mobile-ffmpeg-logo-v7.png" width="320">

 ### 1. Features
 - Use binaries available at `Github`/`JCenter`/`CocoaPods` or build your own version with external libraries you need
 - Supports
-    - Both Android and IOS
-    - FFmpeg `v3.4.x`, `v4.0.x` and `v4.1-dev-x` (master) releases
-    - 27 external libraries
+    - Android, iOS and tvOS
+    - FFmpeg `v3.4.x`, `v4.0.x`, `v4.1` and `v4.2-dev` releases
+    - 28 external libraries
    
-        `chromaprint`, `fontconfig`, `freetype`, `fribidi`, `gmp`, `gnutls`, `kvazaar`, `lame`, `libaom`, `libass`, `libiconv`, `libilbc`, `libtheora`, `libvorbis`, `libvpx`, `libwebp`, `libxml2`, `opencore-amr`, `opus`, `sdl`, `shine`, `snappy`, `soxr`, `speex`, `tesseract`, `twolame`, `wavpack`
+        `chromaprint`, `fontconfig`, `freetype`, `fribidi`, `gmp`, `gnutls`, `kvazaar`, `lame`, `libaom`, `libass`, `libiconv`, `libilbc`, `libtheora`, `libvorbis`, `libvpx`, `libwebp`, `libxml2`, `opencore-amr`, `openh264`, `opus`, `sdl`, `shine`, `snappy`, `soxr`, `speex`, `tesseract`, `twolame`, `wavpack`
    
    - 4 external libraries with GPL license
    
        `vid.stab`, `x264`, `x265`, `xvidcore`

 - Exposes both FFmpeg library and MobileFFmpeg wrapper library capabilities
- Creates shared libraries (.so for Android, .dylib for IOS)
- Includes cross-compile instructions for 43 open-source libraries
+- Includes cross-compile instructions for 44 open-source libraries
    
-    `chromaprint`, `expat`, `ffmpeg`, `fontconfig`, `freetype`, `fribidi`, `giflib`, `gmp`, `gnutls`, `kvazaar`, `lame`, `leptonica`, `libaom`, `libass`, `libiconv`, `libilbc`, `libjpeg`, `libjpeg-turbo`, `libogg`, `libpng`, `libsndfile`, `libtheora`, `libuuid`, `libvorbis`, `libvpx`, `libwebp`, `libxml2`, `nettle`, `opencore-amr`, `opus`, `sdl`, `shine`, `snappy`, `soxr`, `speex`, `tesseract`, `tiff`, `twolame`, `vid.stab`, `wavpack`, `x264`, `x265`, `xvidcore`
+    `chromaprint`, `expat`, `ffmpeg`, `fontconfig`, `freetype`, `fribidi`, `giflib`, `gmp`, `gnutls`, `kvazaar`, `lame`, `leptonica`, `libaom`, `libass`, `libiconv`, `libilbc`, `libjpeg`, `libjpeg-turbo`, `libogg`, `libpng`, `libsndfile`, `libtheora`, `libuuid`, `libvorbis`, `libvpx`, `libwebp`, `libxml2`, `nettle`, `opencore-amr`, `openh264`, `opus`, `sdl`, `shine`, `snappy`, `soxr`, `speex`, `tesseract`, `tiff`, `twolame`, `vid.stab`, `wavpack`, `x264`, `x265`, `xvidcore`

 - Licensed under LGPL 3.0, can be customized to support GPL v3.0

 #### 1.1 Android
 - Builds `arm-v7a`, `arm-v7a-neon`, `arm64-v8a`, `x86` and `x86_64` architectures
 - Supports `zlib` and `MediaCodec` system libraries
+- Camera access on [supported devices](https://developer.android.com/ndk/guides/stable_apis#camera)
+- Builds shared native libraries (.so)
 - Creates Android archive with .aar extension
+- Supports `API Level 16+`

-#### 1.2 IOS
- Builds `armv7`, `armv7s`, `arm64`, `i386` and `x86_64` architectures
+#### 1.2 iOS
+- Builds `armv7`, `armv7s`, `arm64`, `arm64e`, `i386` and `x86_64` architectures
 - Supports `bzip2`, `zlib` system libraries and `AudioToolbox`, `CoreImage`, `VideoToolbox`, `AVFoundation` system frameworks
+- Objective-C API
+- Camera access
 - `ARC` enabled library
 - Built with `-fembed-bitcode` flag
- Creates IOS shared/dynamic universal (fat) library
- Creates IOS static universal (fat) library
- Creates IOS dynamic framework for IOS 8 or later
- Supports Xcode 7.3.1 or later
+- Creates static framework and static universal (fat) library (.a)
+- Supports `iOS SDK 8.0.x` or later
+ 
+#### 1.3 tvOS
+- Builds `arm64` and `x86_64` architectures
+- Supports `bzip2`, `zlib` system libraries and `AudioToolbox`, `CoreImage`, `VideoToolbox` system frameworks
+- Objective-C API
+- `ARC` enabled library
+- Built with `-fembed-bitcode` flag
+- Creates static framework and static universal (fat) library (.a)
+- Supports `tvOS SDK 9.2` or later

 ### 2. Using
-Binaries are available at [Github](https://github.com/tanersener/mobile-ffmpeg/releases), [JCenter](https://bintray.com/bintray/jcenter) and [CocoaPods](https://cocoapods.org). 
+Published binaries are available at [Github](https://github.com/tanersener/mobile-ffmpeg/releases), [JCenter](https://bintray.com/bintray/jcenter) and [CocoaPods](https://cocoapods.org).

-Refer to [Using IOS Universal Binaries](https://github.com/tanersener/mobile-ffmpeg/wiki/Using-IOS-Universal-Binaries) guide to import IOS universal binaries released at [Github](https://github.com/tanersener/mobile-ffmpeg/releases).
+Unpublished development builds can be found under the [development-snapshot](https://www.dropbox.com/sh/frzg32yjzyucmob/AADX81RhiVfk9o7Vo2J8jlH2a) directory. 

-There are eight different binary packages. Below you can see which system libraries and external libraries are enabled in each of them.
+There are eight different `mobile-ffmpeg` packages. Below you can see which system libraries and external libraries are enabled in each of them. 
+
+Please remember that some parts of `FFmpeg` are licensed under the `GPL` and only `GPL` licensed `mobile-ffmpeg` packages include them.

 <table>
 <thead>
@@ -68,10 +81,10 @@ There are eight different binary packages. Below you can see which system librar
 <td align="center"><sup>vid.stab</sup><br><sup>x264</sup><br><sup>x265</sup><br><sup>xvidcore</sup></td>
 <td align="center"><sup>gmp</sup><br><sup>gnutls</sup></td>
 <td align="center"><sup>gmp</sup><br><sup>gnutls</sup><br><sup>vid.stab</sup><br><sup>x264</sup><br><sup>x265</sup><br><sup>xvidcore</sup></td>
-<td align="center"><sup>chromaprint</sup><br><sup>lame</sup><br><sup>libilbc</sup><br><sup>libvorbis</sup><br><sup>opencore-amr</sup><br><sup>opus</sup><br><sup>shine</sup><br><sup>soxr</sup><br><sup>speex</sup><br><sup>twolame</sup><br><sup>wavpack</sup></td>
+<td align="center"><sup>lame</sup><br><sup>libilbc</sup><br><sup>libvorbis</sup><br><sup>opencore-amr</sup><br><sup>opus</sup><br><sup>shine</sup><br><sup>soxr</sup><br><sup>speex</sup><br><sup>twolame</sup><br><sup>wavpack</sup></td>
 <td align="center"><sup>fontconfig</sup><br><sup>freetype</sup><br><sup>fribidi</sup><br><sup>kvazaar</sup><br><sup>libaom</sup><br><sup>libass</sup><br><sup>libiconv</sup><br><sup>libtheora</sup><br><sup>libvpx</sup><br><sup>libwebp</sup><br><sup>snappy</sup></td>
-<td align="center"><sup>chromaprint</sup><br><sup>fontconfig</sup><br><sup>freetype</sup><br><sup>fribidi</sup><br><sup>gmp</sup><br><sup>gnutls</sup><br><sup>kvazaar</sup><br><sup>lame</sup><br><sup>libaom</sup><br><sup>libass</sup><br><sup>libiconv</sup><br><sup>libilbc</sup><br><sup>libtheora</sup><br><sup>libvorbis</sup><br><sup>libvpx</sup><br><sup>libwebp</sup><br><sup>libxml2</sup><br><sup>opencore-amr</sup><br><sup>opus</sup><br><sup>sdl</sup><br><sup>shine</sup><br><sup>snappy</sup><br><sup>soxr</sup><br><sup>speex</sup><br><sup>tesseract</sup><br><sup>twolame</sup><br><sup>wavpack</sup></td>
-<td align="center"><sup>chromaprint</sup><br><sup>fontconfig</sup><br><sup>freetype</sup><br><sup>fribidi</sup><br><sup>gmp</sup><br><sup>gnutls</sup><br><sup>kvazaar</sup><br><sup>lame</sup><br><sup>libaom</sup><br><sup>libass</sup><br><sup>libiconv</sup><br><sup>libilbc</sup><br><sup>libtheora</sup><br><sup>libvorbis</sup><br><sup>libvpx</sup><br><sup>libwebp</sup><br><sup>libxml2</sup><br><sup>opencore-amr</sup><br><sup>opus</sup><br><sup>sdl</sup><br><sup>shine</sup><br><sup>snappy</sup><br><sup>soxr</sup><br><sup>speex</sup><br><sup>tesseract</sup><br><sup>twolame</sup><br><sup>vid.stab</sup><br><sup>wavpack</sup><br><sup>x264</sup><br><sup>x265</sup><br><sup>xvidcore</sup></td>
+<td align="center"><sup>fontconfig</sup><br><sup>freetype</sup><br><sup>fribidi</sup><br><sup>gmp</sup><br><sup>gnutls</sup><br><sup>kvazaar</sup><br><sup>lame</sup><br><sup>libaom</sup><br><sup>libass</sup><br><sup>libiconv</sup><br><sup>libilbc</sup><br><sup>libtheora</sup><br><sup>libvorbis</sup><br><sup>libvpx</sup><br><sup>libwebp</sup><br><sup>libxml2</sup><br><sup>opencore-amr</sup><br><sup>opus</sup><br><sup>shine</sup><br><sup>snappy</sup><br><sup>soxr</sup><br><sup>speex</sup><br><sup>twolame</sup><br><sup>wavpack</sup></td>
+<td align="center"><sup>fontconfig</sup><br><sup>freetype</sup><br><sup>fribidi</sup><br><sup>gmp</sup><br><sup>gnutls</sup><br><sup>kvazaar</sup><br><sup>lame</sup><br><sup>libaom</sup><br><sup>libass</sup><br><sup>libiconv</sup><br><sup>libilbc</sup><br><sup>libtheora</sup><br><sup>libvorbis</sup><br><sup>libvpx</sup><br><sup>libwebp</sup><br><sup>libxml2</sup><br><sup>opencore-amr</sup><br><sup>opus</sup><br><sup>shine</sup><br><sup>snappy</sup><br><sup>soxr</sup><br><sup>speex</sup><br><sup>twolame</sup><br><sup>vid.stab</sup><br><sup>wavpack</sup><br><sup>x264</sup><br><sup>x265</sup><br><sup>xvidcore</sup></td>
 </tr>
 <tr>
 <td align="center"><sup>android system libraries</sup></td>
@@ -81,6 +94,10 @@ There are eight different binary packages. Below you can see which system librar
 <td align="center"><sup>ios system libraries</sup></td>
 <td align="center" colspan=8><sup>zlib</sup><br><sup>AudioToolbox</sup><br><sup>AVFoundation</sup><br><sup>CoreImage</sup><br><sup>VideoToolbox</sup><br><sup>bzip2</sup></td>
 </tr>
+<tr>
+<td align="center"><sup>tvos system libraries</sup></td>
+<td align="center" colspan=8><sup>zlib</sup><br><sup>AudioToolbox</sup><br><sup>CoreImage</sup><br><sup>VideoToolbox</sup><br><sup>bzip2</sup></td>
+</tr>
 </tbody>
 </table>

@@ -90,13 +107,17 @@ There are eight different binary packages. Below you can see which system librar

 - `chromaprint`, `vid.stab` and `x265` are supported since `v2.1`

- - `sdl`, `tesseract`, `twolame` external libraries; `zlib`, `MediaCodec` Android system libraries; `bzip2`, `zlib` IOS system libraries and `AudioToolbox`, `CoreImage`, `VideoToolbox`, `AVFoundation` IOS system frameworks are supported since `v3.0`
+ - `sdl`, `tesseract`, `twolame` external libraries; `zlib`, `MediaCodec` Android system libraries; `bzip2`, `zlib` iOS system libraries and `AudioToolbox`, `CoreImage`, `VideoToolbox`, `AVFoundation` iOS system frameworks are supported since `v3.0`
+
+ - Since `v4.2`, `chromaprint`, `sdl` and `tesseract` libraries are not included in binary releases. You can still build them and include in your releases
+ 
+ - `AVFoundation` is not available on `tvOS`, `VideoToolbox` is not available on `tvOS` LTS releases

 #### 2.1 Android
-1. Add MobileFFmpeg dependency from `jcenter()`
+1. Add MobileFFmpeg dependency to your `build.gradle` in `mobile-ffmpeg-<package name>` format
    ```
-    dependencies {`
-        implementation 'com.arthenica:mobile-ffmpeg-full:3.0'
+    dependencies {
+        implementation 'com.arthenica:mobile-ffmpeg-min:4.2.2'
    }
    ```

@@ -128,15 +149,20 @@ There are eight different binary packages. Below you can see which system librar

 5. Get media information for a file.
    ```
-    MediaInformation info = FFmpeg.getMediaInformation('<file path or uri>');
+    MediaInformation info = FFmpeg.getMediaInformation("<file path or uri>");
    ```

-6. List enabled external libraries.
+6. Record video and audio using Android camera.
+    ```
+    FFmpeg.execute("-f android_camera -i 0:0 -r 30 -pixel_format bgr0 -t 00:00:05 <record file path>");
+    ```
+
+7. List enabled external libraries.
    ```
    List<String> externalLibraries = Config.getExternalLibraries();
    ```

-7. Enable log callback.
+8. Enable log callback.
    ```
    Config.enableLogCallback(new LogCallback() {
        public void apply(LogMessage message) {
@@ -145,7 +171,7 @@ There are eight different binary packages. Below you can see which system librar
    });
    ```

-8. Enable statistics callback.
+9. Enable statistics callback.
    ```
    Config.enableStatisticsCallback(new StatisticsCallback() {
        public void apply(Statistics newStatistics) {
@@ -154,20 +180,27 @@ There are eight different binary packages. Below you can see which system librar
    });
    ```

-9. Set log level.
+10. Set log level.
    ```
    Config.setLogLevel(Level.AV_LOG_FATAL);
    ```

-10. Register custom fonts directory.
+11. Register custom fonts directory.
    ```
    Config.setFontDirectory(this, "<folder with fonts>", Collections.EMPTY_MAP);
    ```

-#### 2.2 IOS
-1. Add MobileFFmpeg pod to your `Podfile`
+#### 2.2 iOS / tvOS
+1. Add MobileFFmpeg dependency to your `Podfile` in `mobile-ffmpeg-<package name>` format
+
+    - iOS
    ```
-    pod 'mobile-ffmpeg-full', '~> 3.0'
+    pod 'mobile-ffmpeg-min', '~> 4.2.2'
+    ```
+
+    - tvOS
+    ```
+    pod 'mobile-ffmpeg-tv-min', '~> 4.2.2'
    ```

 2. Execute commands.
@@ -201,137 +234,247 @@ There are eight different binary packages. Below you can see which system librar
    MediaInformation *mediaInformation = [MobileFFmpeg getMediaInformation:@"<file path or uri>"];
    ```

-6. List enabled external libraries.
+6. Record video and audio using iOS camera. This operation is not supported on `tvOS` since `AVFoundation` is not available on `tvOS`.
+
    ```
-    NASArray *externalLibraries = [MobileFFmpegConfig getExternalLibraries];
+    [MobileFFmpeg execute: @"-f avfoundation -r 30 -video_size 1280x720 -pixel_format bgr0 -i 0:0 -vcodec h264_videotoolbox -vsync 2 -f h264 -t 00:00:05 %@", recordFilePath];
    ```

-7. Enable log callback.
+7. List enabled external libraries.
    ```
+    NSArray *externalLibraries = [MobileFFmpegConfig getExternalLibraries];
+    ```
+
+8. Enable log callback.
+    ```
+    [MobileFFmpegConfig setLogDelegate:self];
+
    - (void)logCallback: (int)level :(NSString*)message {
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"%@", message);
        });
    }
-    ...
-    [MobileFFmpegConfig setLogDelegate:self];
    ```

-8. Enable statistics callback.
+9. Enable statistics callback.
    ```
+    [MobileFFmpegConfig setStatisticsDelegate:self];
+
    - (void)statisticsCallback:(Statistics *)newStatistics {
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"frame: %d, time: %d\n", newStatistics.getVideoFrameNumber, newStatistics.getTime);
        });
    }
-    ...
-    [MobileFFmpegConfig setStatisticsDelegate:self];
    ```

-9. Set log level.
+10. Set log level.
    ```
    [MobileFFmpegConfig setLogLevel:AV_LOG_FATAL];
    ```

-10. Register custom fonts directory.
+11. Register custom fonts directory.
    ```
    [MobileFFmpegConfig setFontDirectory:@"<folder with fonts>" with:nil];
    ```
-    
-#### 2.3 Test Application
-You can see how MobileFFmpeg is used inside an application by running test applications provided.
-There is an Android test application under the `android/test-app` folder and an IOS test application, which requires 
-`Xcode 9.x` or later, under the `ios/test-app` folder. Both applications are identical and supports command 
-execution, video encoding, accessing https, encoding audio, burning subtitles and video stabilization.

-<img src="https://github.com/tanersener/mobile-ffmpeg/blob/master/docs/assets/ios_test_app.gif" width="240">
+#### 2.3 Manual Installation
+##### 2.3.1 Android
+
+You can import `MobileFFmpeg` aar packages in `Android Studio` using the `File` -> `New` -> `New Module` -> `Import .JAR/.AAR Package` menu.
+
+##### 2.3.2 iOS / tvOS
+
+iOS and tvOS frameworks can be installed manually using the [Importing Frameworks](https://github.com/tanersener/mobile-ffmpeg/wiki/Importing-Frameworks) guide. 
+If you want to use universal binaries please refer to [Using Universal Binaries](https://github.com/tanersener/mobile-ffmpeg/wiki/Using-Universal-Binaries) guide.   
+    
+#### 2.4 Test Application
+You can see how MobileFFmpeg is used inside an application by running test applications provided.
+There is an `Android` test application under the `android/test-app` folder, an `iOS` test application under the 
+`ios/test-app` folder and a `tvOS` test application under the `tvos/test-app` folder. 
+
+All applications are identical and supports command execution, video encoding, accessing https, encoding audio, 
+burning subtitles, video stabilization and pipe operations.
+
+<img src="https://github.com/tanersener/mobile-ffmpeg/blob/master/docs/assets/android_test_app.gif" width="240">

 ### 3. Versions

- `MobileFFmpeg v1.x` is the previous stable, includes `FFmpeg v3.4.4`
+`MobileFFmpeg` version number is aligned with `FFmpeg` since version `4.2`. 

- `MobileFFmpeg v2.x` is the current stable, includes `FFmpeg v4.0.2`
+In previous versions, `MobileFFmpeg` version of a release and `FFmpeg` version included in that release was different. 
+The following table lists `FFmpeg` versions used in `MobileFFmpeg` releases.
+  
+- `dev` part in `FFmpeg` version number indicates that `FFmpeg` source is pulled from the `FFmpeg` `master` branch. 
+Exact version number is obtained using `git describe --tags`. 

- `MobileFFmpeg v3.x` is the next stable, includes `FFmpeg v4.1-dev-1517`
+|  MobileFFmpeg Version | FFmpeg Version | Release Date |
+| :----: | :----: |:----: |
+| [4.2.2](https://github.com/tanersener/mobile-ffmpeg/releases/tag/v4.2.2) | 4.2-dev-1824 | July 3, 2019 |
+| [4.2.2.LTS](https://github.com/tanersener/mobile-ffmpeg/releases/tag/v4.2.2.LTS) | 4.2-dev-1824 | July 3, 2019 |
+| [4.2.1](https://github.com/tanersener/mobile-ffmpeg/releases/tag/v4.2.1) | 4.2-dev-1156 | Apr 2, 2019 |
+| [4.2](https://github.com/tanersener/mobile-ffmpeg/releases/tag/v4.2) | 4.2-dev-480 | Jan 3, 2019 |
+| [4.2.LTS](https://github.com/tanersener/mobile-ffmpeg/releases/tag/v4.2.LTS) | 4.2-dev-480 | Jan 3, 2019 |
+| [3.1](https://github.com/tanersener/mobile-ffmpeg/releases/tag/v3.1) | 4.1-10 | Dec 11, 2018 |
+| [3.0](https://github.com/tanersener/mobile-ffmpeg/releases/tag/v3.0) | 4.1-dev-1517 | Oct 25, 2018 |
+| [2.2](https://github.com/tanersener/mobile-ffmpeg/releases/tag/v2.2) | 4.0.3 | Nov 10, 2018 |
+| [2.1.1](https://github.com/tanersener/mobile-ffmpeg/releases/tag/v2.1.1) | 4.0.2 | Sep 19, 2018 |
+| [2.1](https://github.com/tanersener/mobile-ffmpeg/releases/tag/v2.1) | 4.0.2 | Sep 5, 2018 |
+| [2.0](https://github.com/tanersener/mobile-ffmpeg/releases/tag/v2.0) | 4.0.1 | Jun 30, 2018 |
+| [1.2](https://github.com/tanersener/mobile-ffmpeg/releases/tag/v1.2) | 3.4.4 | Aug 30, 2018|
+| [1.1](https://github.com/tanersener/mobile-ffmpeg/releases/tag/v1.1) | 3.4.2 | Jun 18, 2018 |
+| [1.0](https://github.com/tanersener/mobile-ffmpeg/releases/tag/v1.0) | 3.4.2 | Jun 6, 2018 |

-### 4. Building
-#### 4.1 Prerequisites
+### 4. LTS Releases
+
+Starting from `v4.2`, `MobileFFmpeg` binaries are published in two different variants: `Main Release` and `LTS Release`. 
+
+- Main releases include complete functionality of the library and support the latest SDK/API features.
+
+- LTS releases are customized to support a wider range of devices. They are built using older API/SDK versions, so some features are not available on them.
+
+This table shows the differences between two variants.
+
+|        | Main Release | LTS Release |
+| :----: | :----: | :----: |
+| Android API Level | 24 | 16 | 
+| Android Camera Access | Yes | - |
+| Android Architectures | arm-v7a-neon<br/>arm64-v8a<br/>x86<br/>x86-64</br> | arm-v7a<br/>arm-v7a-neon<br/>arm64-v8a<br/>x86<br/>x86-64</br> |
+| Xcode Support | 10.1 | 7.3.1 |
+| iOS SDK | 12.1 | 9.3 |
+| iOS Architectures | arm64<br/>arm64e<br/>x86-64</br> | armv7<br/>arm64<br/>i386<br/>x86-64</br> |
+| tvOS SDK | 10.2 | 9.2 |
+| tvOS Architectures | arm64<br/>x86-64 | arm64<br/>x86-64 |
+
+### 5. Development Builds
+
+Unreleased binaries built from `development` branch can be found under the [development-snapshot](https://www.dropbox.com/sh/frzg32yjzyucmob/AADX81RhiVfk9o7Vo2J8jlH2a) directory. 
+
+Please remember that these builds are provided for testing and development purposes only since they are not % 100 tested and may include minor issues. 
+
+### 6. Building
+
+Build scripts from `master` and `development` branches are tested periodically. See the latest status from the table below.
+
+| branch | status |
+| :---: | :---: |
+|  master | [![Build Status](https://travis-ci.org/tanersener/mobile-ffmpeg.svg?branch=master)](https://travis-ci.org/tanersener/mobile-ffmpeg) |
+|  development | [![Build Status](https://travis-ci.org/tanersener/mobile-ffmpeg.svg?branch=development)](https://travis-ci.org/tanersener/mobile-ffmpeg) |
+
+
+#### 6.1 Prerequisites
 1. Use your package manager (apt, yum, dnf, brew, etc.) to install the following packages.

    ```
-    autoconf automake libtool pkg-config curl cmake gcc gperf texinfo yasm nasm bison autogen patch
+    autoconf automake libtool pkg-config curl cmake gcc gperf texinfo yasm nasm bison autogen patch git
    ```
 Some of these packages are not mandatory for the default build.
-Please visit [Android Prerequisites](https://github.com/tanersener/mobile-ffmpeg/wiki/Android-Prerequisites) and
-[IOS Prerequisites](https://github.com/tanersener/mobile-ffmpeg/wiki/IOS-Prerequisites) for the details.
+Please visit [Android Prerequisites](https://github.com/tanersener/mobile-ffmpeg/wiki/Android-Prerequisites), 
+[iOS Prerequisites](https://github.com/tanersener/mobile-ffmpeg/wiki/iOS-Prerequisites) and 
+[tvOS Prerequisites](https://github.com/tanersener/mobile-ffmpeg/wiki/tvOS-Prerequisites) for the details.

 2. Android builds require these additional packages.
-    - **Android SDK 5.0 Lollipop (API Level 21)** or later
-    - **Android NDK r17c** or later with LLDB and CMake
-    - **gradle 4.4** or later
+    - **Android SDK 4.1 Jelly Bean (API Level 16)** or later
+    - **Android NDK r20** or later with LLDB and CMake

-3. IOS builds need these extra packages and tools.
-    - **IOS SDK 8.0.x** or later
+3. iOS builds need these extra packages and tools.
    - **Xcode 7.3.1** or later
+    - **iOS SDK 9.3** or later
    - **Command Line Tools**

-#### 4.2 Build Scripts
-Use `android.sh` and `ios.sh` to build MobileFFmpeg for each platform.
-After a successful build, compiled FFmpeg and MobileFFmpeg libraries can be found under `prebuilt` directory.
+4. tvOS builds need these extra packages and tools.
+    - **Xcode 7.3.1** or later
+    - **tvOS SDK 9.2** or later
+    - **Command Line Tools**

-Both `android.sh` and `ios.sh` can be customized to override default settings,
-[android.sh](https://github.com/tanersener/mobile-ffmpeg/wiki/android.sh) and
-[ios.sh](https://github.com/tanersener/mobile-ffmpeg/wiki/ios.sh) wiki pages include all available build options.
-##### 4.2.1 Android 
+#### 6.2 Build Scripts
+Use `android.sh`, `ios.sh` and `tvos.sh` to build MobileFFmpeg for each platform. 
+
+All three scripts support additional options and 
+can be customized to enable/disable specific external libraries and/or architectures. Please refer to wiki pages of
+[android.sh](https://github.com/tanersener/mobile-ffmpeg/wiki/android.sh), 
+[ios.sh](https://github.com/tanersener/mobile-ffmpeg/wiki/ios.sh) and 
+[tvos.sh](https://github.com/tanersener/mobile-ffmpeg/wiki/tvos.sh) to see all available build options.
+##### 6.2.1 Android 
 ```
+export ANDROID_HOME=<Android SDK Path>
 export ANDROID_NDK_ROOT=<Android NDK Path>
 ./android.sh
 ```

 <img src="https://github.com/tanersener/mobile-ffmpeg/blob/master/docs/assets/android_custom.gif" width="600">

-##### 4.2.2 IOS
+##### 6.2.2 iOS
 ```
-./ios.sh    
+./ios.sh
 ```

 <img src="https://github.com/tanersener/mobile-ffmpeg/blob/master/docs/assets/ios_custom.gif" width="600">

-#### 4.3 GPL Support
+##### 6.2.3 tvOS
+```
+./tvos.sh
+```
+
+<img src="https://github.com/tanersener/mobile-ffmpeg/blob/development/docs/assets/tvos_custom.gif" width="600">
+
+
+##### 6.2.4 Building LTS Binaries
+
+Use `--lts` option to build lts binaries for each platform.
+
+#### 6.3 Build Output
+
+All libraries created by the top level build scripts (`android.sh`, `ios.sh` and `tvos.sh`) can be found under 
+the `prebuilt` directory.
+
+- `Android` archive (.aar file) is located under the `android-aar` folder
+- `iOS` frameworks are located under the `ios-framework`folder
+- `iOS` universal binaries are located under the `ios-universal`folder
+- `tvOS` frameworks are located under the `tvos-framework`folder
+- `tvOS` universal binaries are located under the `tvos-universal`folder 
+
+#### 6.4 GPL Support
 It is possible to enable GPL licensed libraries `x264`, `xvidcore` since `v1.1` and `vid.stab`, `x265` since `v2.1` 
-from the top level build scripts.
-Their source code is not included in the repository and downloaded when enabled.
+from the top level build scripts. Their source code is not included in the repository and downloaded when enabled.

-#### 4.4 External Libraries
-`build` directory includes build scripts for external libraries. There are two scripts for each library, one for Android
-and one for IOS. They include all options/flags used to cross-compile the libraries. `ASM` is enabled by most of them, 
-exceptions are listed under the [ASM Support](https://github.com/tanersener/mobile-ffmpeg/wiki/ASM-Support) page.
+#### 6.5 External Libraries
+`build` directory includes build scripts of all external libraries. Two scripts exist for each external library, 
+one for `Android` and one for `iOS / tvOS`. Each of these two scripts contains options/flags used to cross-compile the 
+library on the specified mobile platform. 

-### 5. Documentation
+CPU optimizations (`ASM`) are enabled for most of the external libraries. Details and exceptions can be found under the 
+[ASM Support](https://github.com/tanersener/mobile-ffmpeg/wiki/ASM-Support) wiki page.
+
+### 7. Documentation

 A more detailed documentation is available at [Wiki](https://github.com/tanersener/mobile-ffmpeg/wiki).

-### 6. License
+### 8. License

 This project is licensed under the LGPL v3.0. However, if source code is built using optional `--enable-gpl` flag or 
 prebuilt binaries with `-gpl` postfix are used then MobileFFmpeg is subject to the GPL v3.0 license.

 Source code of FFmpeg and external libraries is included in compliance with their individual licenses.

-`strip-frameworks.sh` script included and distributed is published under the [Apache License version 2.0](https://www.apache.org/licenses/LICENSE-2.0).
+`openh264` source code included in this repository is licensed under the 2-clause BSD License but this license does 
+not cover the `MPEG LA` licensing fees. If you build `mobile-ffmpeg` with `openh264` and distribute that library, then 
+you are subject to pay `MPEG LA` licensing fees. Refer to [OpenH264 FAQ](https://www.openh264.org/faq.html) page for 
+the details. Please note that `mobile-ffmpeg` does not publish a binary with `openh264` inside.

-In test applications, fonts embedded are licensed under the [SIL Open Font License](https://opensource.org/licenses/OFL-1.1); other digital assets are published in the public domain.
+`strip-frameworks.sh` script included and distributed (until v4.x) is published under the [Apache License version 2.0](https://www.apache.org/licenses/LICENSE-2.0).
+
+In test applications; embedded fonts are licensed under the [SIL Open Font License](https://opensource.org/licenses/OFL-1.1), other digital assets are published in the public domain.

 Please visit [License](https://github.com/tanersener/mobile-ffmpeg/wiki/License) page for the details.

-### 7. Contributing
+### 9. Contributing

 If you have any recommendations or ideas to improve it, please feel free to submit issues or pull requests. Any help is appreciated.

-### 8. See Also
+### 10. See Also

 - [libav gas-preprocessor](https://github.com/libav/gas-preprocessor/raw/master/gas-preprocessor.pl)
 - [FFmpeg API Documentation](https://ffmpeg.org/doxygen/4.0/index.html)
 - [FFmpeg Wiki](https://trac.ffmpeg.org/wiki/WikiStart)
 - [FFmpeg License and Legal Considerations](https://ffmpeg.org/legal.html)
- [FFmpeg External Library Licenses](https://www.ffmpeg.org/doxygen/4.0/md_LICENSE.html)
+- [FFmpeg External Library Licenses](https://www.ffmpeg.org/doxygen/4.0/md_LICENSE.html)
@@ -39,31 +39,34 @@ LIBRARY_CHROMAPRINT=27
 LIBRARY_TWOLAME=28
 LIBRARY_SDL=29
 LIBRARY_TESSERACT=30
-LIBRARY_GIFLIB=31
-LIBRARY_JPEG=32
-LIBRARY_LIBOGG=33
-LIBRARY_LIBPNG=34
-LIBRARY_LIBUUID=35
-LIBRARY_NETTLE=36
-LIBRARY_TIFF=37
-LIBRARY_EXPAT=38
-LIBRARY_SNDFILE=39
-LIBRARY_LEPTONICA=40
-LIBRARY_ZLIB=41
-LIBRARY_MEDIA_CODEC=42
+LIBRARY_OPENH264=31
+LIBRARY_GIFLIB=32
+LIBRARY_JPEG=33
+LIBRARY_LIBOGG=34
+LIBRARY_LIBPNG=35
+LIBRARY_LIBUUID=36
+LIBRARY_NETTLE=37
+LIBRARY_TIFF=38
+LIBRARY_EXPAT=39
+LIBRARY_SNDFILE=40
+LIBRARY_LEPTONICA=41
+LIBRARY_ZLIB=42
+LIBRARY_MEDIA_CODEC=43

 # ENABLE ARCH
 ENABLED_ARCHITECTURES=(1 1 1 1 1)

 # ENABLE LIBRARIES
-ENABLED_LIBRARIES=(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
+ENABLED_LIBRARIES=(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)

 export BASEDIR=$(pwd)
-
 export MOBILE_FFMPEG_TMPDIR="${BASEDIR}/.tmp"

-# USING API LEVEL 21 / Android 5.0 (LOLLIPOP)
-export API=21
+# USING API LEVEL 24 / Android 7.0 (NOUGAT)
+export API=24
+
+RECONF_LIBRARIES=()
+REBUILD_LIBRARIES=()

 get_mobile_ffmpeg_version() {
    local MOBILE_FFMPEG_VERSION=$(grep '#define MOBILE_FFMPEG_VERSION' ${BASEDIR}/android/app/src/main/cpp/mobileffmpeg.h | grep -Eo '\".*\"' | sed -e 's/\"//g')
@@ -86,9 +89,11 @@ When compilation ends an Android Archive (AAR) file is created with enabled plat
    echo -e "Options:"

    echo -e "  -h, --help\t\t\tdisplay this help and exit"
-    echo -e "  -V, --version\t\t\tdisplay version information and exit"
+    echo -e "  -v, --version\t\t\tdisplay version information and exit"
    echo -e "  -d, --debug\t\t\tbuild with debug information"
-    echo -e "  -S, --speed\t\t\toptimize for speed instead of size\n"
+    echo -e "  -s, --speed\t\t\toptimize for speed instead of size"
+    echo -e "  -l, --lts\t\t\tbuild lts packages to support API 21+ devices"
+    echo -e "  -f, --force\t\t\tignore warnings\n"

    echo -e "Licensing options:"

@@ -125,6 +130,7 @@ When compilation ends an Android Archive (AAR) file is created with enabled plat
    echo -e "  --enable-libwebp\t\tbuild with libwebp [no]"
    echo -e "  --enable-libxml2\t\tbuild with libxml2 [no]"
    echo -e "  --enable-opencore-amr\t\tbuild with opencore-amr [no]"
+    echo -e "  --enable-openh264\t\tbuild with openh264 [no]"
    echo -e "  --enable-opus\t\t\tbuild with opus [no]"
    echo -e "  --enable-sdl\t\t\tbuild with sdl [no]"
    echo -e "  --enable-shine\t\tbuild with shine [no]"
@@ -152,7 +158,7 @@ display_version() {
    COMMAND=`echo $0 | sed -e 's/\.\///g'`

    echo -e "\
-$COMMAND $(get_mobile_ffmpeg_version)\n\
+$COMMAND v$(get_mobile_ffmpeg_version)\n\
 Copyright (c) 2018 Taner Sener\n\
 License LGPLv3.0: GNU LGPL version 3 or later\n\
 <https://www.gnu.org/licenses/lgpl-3.0.en.html>\n\
@@ -167,24 +173,75 @@ skip_library() {
    export ${SKIP_VARIABLE}=1
 }

+no_output_redirection() {
+    export NO_OUTPUT_REDIRECTION=1
+}
+
+no_workspace_cleanup_library() {
+    NO_WORKSPACE_CLEANUP_VARIABLE=$(echo "NO_WORKSPACE_CLEANUP_$1" | sed "s/\-/\_/g")
+
+    export ${NO_WORKSPACE_CLEANUP_VARIABLE}=1
+}
+
+no_link_time_optimization() {
+    export NO_LINK_TIME_OPTIMIZATION=1
+}
+
 enable_debug() {
-    export MOBILE_FFMPEG_DEBUG="-d"
+    export MOBILE_FFMPEG_DEBUG="-g"
+
+    BUILD_TYPE_ID+="debug "
 }

 optimize_for_speed() {
    export MOBILE_FFMPEG_OPTIMIZED_FOR_SPEED="1"
 }

-reconf_library() {
-    RECONF_VARIABLE=$(echo "RECONF_$1" | sed "s/\-/\_/g")
+enable_lts_build() {
+    export MOBILE_FFMPEG_LTS_BUILD="1"

-    export ${RECONF_VARIABLE}=1
+    # USING API LEVEL 16 / Android 4.1 (JELLY BEAN)
+    export API=16
+}
+
+reconf_library() {
+    local RECONF_VARIABLE=$(echo "RECONF_$1" | sed "s/\-/\_/g")
+    local library_supported=0
+
+    for library in {1..42}
+    do
+        library_name=$(get_library_name $((library - 1)))
+
+        if [[ $1 != "ffmpeg" ]] && [[ ${library_name} == $1 ]]; then
+            export ${RECONF_VARIABLE}=1
+            RECONF_LIBRARIES+=($1)
+            library_supported=1
+        fi
+    done
+
+    if [[ ${library_supported} -eq 0 ]]; then
+        echo -e "INFO: --reconf flag detected for library $1 is not supported.\n" 1>>${BASEDIR}/build.log 2>&1
+    fi
 }

 rebuild_library() {
-    REBUILD_VARIABLE=$(echo "REBUILD_$1" | sed "s/\-/\_/g")
+    local REBUILD_VARIABLE=$(echo "REBUILD_$1" | sed "s/\-/\_/g")
+    local library_supported=0

-    export ${REBUILD_VARIABLE}=1
+    for library in {1..42}
+    do
+        library_name=$(get_library_name $((library - 1)))
+
+        if [[ $1 != "ffmpeg" ]] && [[ ${library_name} == $1 ]]; then
+            export ${REBUILD_VARIABLE}=1
+            REBUILD_LIBRARIES+=($1)
+            library_supported=1
+        fi
+    done
+
+    if [[ ${library_supported} -eq 0 ]]; then
+        echo -e "INFO: --rebuild flag detected for library $1 is not supported.\n" 1>>${BASEDIR}/build.log 2>&1
+    fi
 }

 enable_library() {
@@ -285,6 +342,9 @@ set_library() {
        opencore-amr)
            ENABLED_LIBRARIES[LIBRARY_OPENCOREAMR]=$2
        ;;
+        openh264)
+            ENABLED_LIBRARIES[LIBRARY_OPENH264]=$2
+        ;;
        opus)
            ENABLED_LIBRARIES[LIBRARY_OPUS]=$2
        ;;
@@ -417,7 +477,7 @@ print_enabled_libraries() {
    let enabled=0;

    # FIRST BUILT-IN LIBRARIES
-    for library in {41..42}
+    for library in {42..43}
    do
        if [[ ${ENABLED_LIBRARIES[$library]} -eq 1 ]]; then
            if [[ ${enabled} -ge 1 ]]; then
@@ -429,7 +489,7 @@ print_enabled_libraries() {
    done

    # THEN EXTERNAL LIBRARIES
-    for library in {0..30}
+    for library in {0..31}
    do
        if [[ ${ENABLED_LIBRARIES[$library]} -eq 1 ]]; then
            if [[ ${enabled} -ge 1 ]]; then
@@ -447,7 +507,63 @@ print_enabled_libraries() {
    fi
 }

+print_reconfigure_requested_libraries() {
+    local counter=0;
+
+    for RECONF_LIBRARY in "${RECONF_LIBRARIES[@]}"
+    do
+        if [[ ${counter} -eq 0 ]]; then
+            echo -n "Reconfigure: "
+        else
+            echo -n ", "
+        fi
+
+        echo -n ${RECONF_LIBRARY}
+
+        counter=$((${counter} + 1));
+    done
+
+    if [[ ${counter} -gt 0 ]]; then
+        echo ""
+    fi
+}
+
+print_rebuild_requested_libraries() {
+    local counter=0;
+
+    for REBUILD_LIBRARY in "${REBUILD_LIBRARIES[@]}"
+    do
+        if [[ ${counter} -eq 0 ]]; then
+            echo -n "Rebuild: "
+        else
+            echo -n ", "
+        fi
+
+        echo -n ${REBUILD_LIBRARY}
+
+        counter=$((${counter} + 1));
+    done
+
+    if [[ ${counter} -gt 0 ]]; then
+        echo ""
+    fi
+}
+
 build_application_mk() {
+    if [[ ! -z ${MOBILE_FFMPEG_LTS_BUILD} ]]; then
+        local LTS_BUILD_FLAG="-DMOBILE_FFMPEG_LTS "
+    fi
+
+    if [[ ${ENABLED_LIBRARIES[$LIBRARY_X265]} -eq 1 ]] || [[ ${ENABLED_LIBRARIES[$LIBRARY_TESSERACT]} -eq 1 ]] || [[ ${ENABLED_LIBRARIES[$LIBRARY_OPENH264]} -eq 1 ]] || [[ ${ENABLED_LIBRARIES[$LIBRARY_SNAPPY]} -eq 1 ]]; then
+        local APP_STL="c++_shared"
+    else
+        local APP_STL="none"
+
+        ${SED_INLINE} 's/c++_shared //g' ${BASEDIR}/android/jni/Android.mk 1>>${BASEDIR}/build.log 2>&1
+    fi
+
+    local BUILD_DATE="-DMOBILE_FFMPEG_BUILD_DATE=$(date +%Y%m%d 2>>${BASEDIR}/build.log)"
+
    rm -f ${BASEDIR}/android/jni/Application.mk

    cat > "${BASEDIR}/android/jni/Application.mk" << EOF
@@ -455,29 +571,40 @@ APP_OPTIM := release

 APP_ABI := ${ANDROID_ARCHITECTURES}

-APP_STL := c++_shared
+APP_STL := ${APP_STL}

-APP_PLATFORM := android-21
+APP_PLATFORM := android-${API}

-APP_CFLAGS := -O3 -DANDROID -Wall -Wno-deprecated-declarations -Wno-pointer-sign -Wno-switch -Wno-unused-result -Wno-unused-variable
+APP_CFLAGS := -O3 -DANDROID ${LTS_BUILD_FLAG}${BUILD_DATE} -Wall -Wno-deprecated-declarations -Wno-pointer-sign -Wno-switch -Wno-unused-result -Wno-unused-variable
 EOF
 }

-
 # ENABLE COMMON FUNCTIONS
 . ${BASEDIR}/build/android-common.sh

+DETECTED_NDK_VERSION=$(grep -Eo Revision.* ${ANDROID_NDK_ROOT}/source.properties | sed 's/Revision//g;s/=//g;s/ //g')
+
+echo -e "\nINFO: Using Android NDK v${DETECTED_NDK_VERSION} provided at ${ANDROID_NDK_ROOT}\n" 1>>${BASEDIR}/build.log 2>&1
+echo -e "INFO: Build options: $@\n" 1>>${BASEDIR}/build.log 2>&1
+
+# CLEAR OLD NATIVE LIBS
+rm -rf ${BASEDIR}/android/libs 1>>${BASEDIR}/build.log 2>&1
+rm -rf ${BASEDIR}/android/obj 1>>${BASEDIR}/build.log 2>&1
+
 GPL_ENABLED="no"
+DISPLAY_HELP=""
+BUILD_LTS=""
+BUILD_TYPE_ID=""
+BUILD_VERSION=$(git describe --tags 2>>${BASEDIR}/build.log)

 while [ ! $# -eq 0 ]
 do

    case $1 in
 	    -h | --help)
-            display_help
-            exit 0
+            DISPLAY_HELP="1"
 	    ;;
-	    -V | --version)
+	    -v | --version)
            display_version
            exit 0
 	    ;;
@@ -486,12 +613,29 @@ do

            skip_library ${SKIP_LIBRARY}
 	    ;;
+	    --no-output-redirection)
+            no_output_redirection
+	    ;;
+	    --no-workspace-cleanup-*)
+            NO_WORKSPACE_CLEANUP_LIBRARY=`echo $1 | sed -e 's/^--[A-Za-z]*-[A-Za-z]*-[A-Za-z]*-//g'`
+
+            no_workspace_cleanup_library ${NO_WORKSPACE_CLEANUP_LIBRARY}
+	    ;;
+	    --no-link-time-optimization)
+            no_link_time_optimization
+	    ;;
        -d | --debug)
            enable_debug
 	    ;;
-        -S | --speed)
+        -s | --speed)
 	        optimize_for_speed
 	    ;;
+        -l | --lts)
+	        BUILD_LTS="1"
+	    ;;
+        -f | --force)
+	        BUILD_FORCE="1"
+	    ;;
        --reconf-*)
            CONF_LIBRARY=`echo $1 | sed -e 's/^--[A-Za-z]*-//g'`

@@ -503,7 +647,7 @@ do
            rebuild_library ${BUILD_LIBRARY}
 	    ;;
 	    --full)
-            for library in {0..42}
+            for library in {0..43}
            do
                if [[ $library -ne 18 ]] && [[ $library -ne 19 ]] && [[ $library -ne 20 ]] && [[ $library -ne 21 ]]; then
                    enable_library $(get_library_name $library)
@@ -530,17 +674,47 @@ do
    shift
 done;

+# DETECT BUILD TYPE
+rm -f ${BASEDIR}/android/jni/Android.mk 1>>${BASEDIR}/build.log 2>&1
+rm -f ${BASEDIR}/android/app/build.gradle 1>>${BASEDIR}/build.log 2>&1
+if [[ ! -z ${BUILD_LTS} ]]; then
+    enable_lts_build
+    BUILD_TYPE_ID+="LTS "
+
+    cp ${BASEDIR}/tools/ndk/Android.lts.mk ${BASEDIR}/android/jni/Android.mk 1>>${BASEDIR}/build.log 2>&1
+    cp ${BASEDIR}/tools/release/android/build.lts.gradle ${BASEDIR}/android/app/build.gradle 1>>${BASEDIR}/build.log 2>&1
+else
+    cp ${BASEDIR}/tools/ndk/Android.mk ${BASEDIR}/android/jni/Android.mk 1>>${BASEDIR}/build.log 2>&1
+    cp ${BASEDIR}/tools/release/android/build.gradle ${BASEDIR}/android/app/build.gradle 1>>${BASEDIR}/build.log 2>&1
+
+    if [[ -z ${BUILD_FORCE} ]] && [[ ${ENABLED_ARCHITECTURES[${ARCH_ARM_V7A}]} -eq 1 ]]; then
+        echo -e "INFO: Disabled arm-v7a architecture which is not included in Main releases.\n" 1>>${BASEDIR}/build.log 2>&1
+        disable_arch "arm-v7a"
+    fi
+fi
+
+if [[ ! -z ${DISPLAY_HELP} ]]; then
+    display_help
+    exit 0
+fi
+
 if [[ -z ${ANDROID_NDK_ROOT} ]]; then
    echo "ANDROID_NDK_ROOT not defined"
    exit 1
 fi

-echo -e "Building mobile-ffmpeg for Android\n"
-echo -e -n "INFO: Building mobile-ffmpeg for Android: " 1>>${BASEDIR}/build.log 2>&1
+if [[ -z ${ANDROID_HOME} ]]; then
+    echo "ANDROID_HOME not defined"
+    exit 1
+fi
+
+echo -e "\nBuilding mobile-ffmpeg ${BUILD_TYPE_ID}library for Android\n"
+echo -e -n "INFO: Building mobile-ffmpeg ${BUILD_VERSION} ${BUILD_TYPE_ID}library for Android: " 1>>${BASEDIR}/build.log 2>&1
 echo -e `date` 1>>${BASEDIR}/build.log 2>&1

-if [[ ${ENABLED_ARCHITECTURES[0]} -eq 0 ]] && [[ ${ENABLED_ARCHITECTURES[1]} -eq 1 ]]; then
-    ENABLED_ARCHITECTURES[0]=1
+# PERFORM THIS CHECK ONLY ON LTS
+if [[ ! -z ${MOBILE_FFMPEG_LTS_BUILD} ]] && [[ ${ENABLED_ARCHITECTURES[0]} -eq 0 ]] && [[ ${ENABLED_ARCHITECTURES[1]} -eq 1 ]]; then
+    ENABLED_ARCHITECTURES[ARCH_ARM_V7A]=1

    echo -e "(*) arm-v7a architecture enabled since arm-v7a-neon will be built\n"
    echo -e "(*) arm-v7a architecture enabled since arm-v7a-neon will be built\n" 1>>${BASEDIR}/build.log 2>&1
@@ -548,6 +722,8 @@ fi

 print_enabled_architectures
 print_enabled_libraries
+print_reconfigure_requested_libraries
+print_rebuild_requested_libraries

 # CHECKING GPL LIBRARIES
 for gpl_library in {18..21}
@@ -570,33 +746,28 @@ do
    fi
 done

-# CLEANING PREVIOUSLY COPIED c++_shared.so FILES
-rm -rf ${BASEDIR}/prebuilt/android-cpp-shared 1>>${BASEDIR}/build.log 2>&1
+# SAVE API VALUE
+export ORIGINAL_API=${API};

 for run_arch in {0..4}
 do
    if [[ ${ENABLED_ARCHITECTURES[$run_arch]} -eq 1 ]]; then
+        if [[ ( ${run_arch} -eq ${ARCH_ARM64_V8A} || ${run_arch} -eq ${ARCH_X86_64} ) && ${API} < 21 ]] ; then
+
+            # 64 bit ABIs supported after API 21
+            export API=21
+        else
+            export API=${ORIGINAL_API}
+        fi
+
        export ARCH=$(get_arch_name $run_arch)
        export TOOLCHAIN=$(get_toolchain)
        export TOOLCHAIN_ARCH=$(get_toolchain_arch)

-        create_toolchain || exit 1
-
-        # COPY libc++_shared.so FROM EACH TOOLCHAIN
-        mkdir -p ${BASEDIR}/prebuilt/android-cpp-shared/${TOOLCHAIN_ARCH}
-
-        if [[ $run_arch -eq 0 ]] || [[ $run_arch -eq 1 ]]; then
-            cp ${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/$(get_target_host)/lib/armv7-a/libc++_shared.so ${BASEDIR}/prebuilt/android-cpp-shared/${TOOLCHAIN_ARCH} 1>>${BASEDIR}/build.log 2>&1
-        elif [[ $run_arch -eq 4 ]]; then
-            cp ${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/$(get_target_host)/lib64/libc++_shared.so ${BASEDIR}/prebuilt/android-cpp-shared/${TOOLCHAIN_ARCH} 1>>${BASEDIR}/build.log 2>&1
-        else
-            cp ${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/$(get_target_host)/lib/libc++_shared.so ${BASEDIR}/prebuilt/android-cpp-shared/${TOOLCHAIN_ARCH} 1>>${BASEDIR}/build.log 2>&1
-        fi
-
        . ${BASEDIR}/build/main-android.sh "${ENABLED_LIBRARIES[@]}" || exit 1

        # CLEAR FLAGS
-        for library in {1..43}
+        for library in {1..44}
        do
            library_name=$(get_library_name $((library - 1)))
            unset $(echo "OK_${library_name}" | sed "s/\-/\_/g")
@@ -605,6 +776,8 @@ do
    fi
 done

+export API=${ORIGINAL_API}
+
 rm -f ${BASEDIR}/android/build/.neon 1>>${BASEDIR}/build.log 2>&1
 ANDROID_ARCHITECTURES=""
 if [[ ${ENABLED_ARCHITECTURES[1]} -eq 1 ]]; then
@@ -651,14 +824,14 @@ if [[ ! -z ${ANDROID_ARCHITECTURES} ]]; then

    echo -e -n "\n\nCreating Android archive under prebuilt/android-aar: "

-    gradle clean build 1>>${BASEDIR}/build.log 2>&1
+    ./gradlew clean build 1>>${BASEDIR}/build.log 2>&1

    if [ $? -ne 0 ]; then
        echo -e "failed\n"
        exit 1
    fi

-    cp ${BASEDIR}/android/app/build/outputs/aar/mobile-ffmpeg-*.aar ${MOBILE_FFMPEG_AAR}/mobile-ffmpeg.aar 1>>${BASEDIR}/build.log 2>&1
+    cp ${BASEDIR}/android/app/build/outputs/aar/mobile-ffmpeg.aar ${MOBILE_FFMPEG_AAR}/mobile-ffmpeg.aar 1>>${BASEDIR}/build.log 2>&1

    if [ $? -ne 0 ]; then
        echo -e "failed\n"
@@ -38,7 +38,7 @@ PROJECT_NAME           = "MobileFFmpeg Android API"
 # could be handy for archiving the generated documentation or if some version
 # control system is used.

-PROJECT_NUMBER         = 3.0
+PROJECT_NUMBER         = 4.2.2

 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -1,15 +1,17 @@
 apply plugin: 'com.android.library'

 android {
-    compileSdkVersion 27
+    compileSdkVersion 28
+
    defaultConfig {
-        minSdkVersion 21
-        targetSdkVersion 27
-        versionCode 30
-        versionName "3.0"
-        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+        minSdkVersion 24
+        targetSdkVersion 28
+        versionCode 240422
+        versionName "4.2.2"
        project.archivesBaseName = "mobile-ffmpeg"
+        consumerProguardFiles 'proguard-rules.pro'
    }
+
    buildTypes {
        release {
            minifyEnabled false
@@ -26,14 +28,6 @@ android {
    testOptions {
        unitTests.returnDefaultValues = true
    }
-
-    libraryVariants.all { variant ->
-        variant.outputs.all { output ->
-            if (outputFile != null && outputFileName.endsWith('.aar')) {
-                outputFileName = "${archivesBaseName}-${android.defaultConfig.versionName}.aar"
-            }
-        }
-    }
 }

 task javadoc(type: Javadoc) {
@@ -43,16 +37,8 @@ task javadoc(type: Javadoc) {
    source = android.sourceSets.main.java.srcDirs
 }

-afterEvaluate {
-    javadoc.classpath += files(android.libraryVariants.collect { variant ->
-        variant.javaCompile.classpath.files
-    })
-}
-
 dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
-    implementation 'com.android.support:appcompat-v7:27.1.1'
+    implementation 'com.android.support:appcompat-v7:28.0.0'
    testImplementation 'junit:junit:4.12'
-    androidTestImplementation 'com.android.support.test:runner:1.0.2'
-    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
 }
@@ -5,17 +5,12 @@
 # For more details, see
 #   http://developer.android.com/guide/developing/tools/proguard.html

-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
+-keep class com.arthenica.mobileffmpeg.Config {
+    native <methods>;
+    void log(int, byte[]);
+    void statistics(int, float, float, long , int, double, double);
+}

-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile
+-keep class com.arthenica.mobileffmpeg.AbiDetect {
+    native <methods>;
+}
@@ -2,10 +2,6 @@
    package="com.arthenica.mobileffmpeg">

    <application
-        android:allowBackup="true"
-        android:icon="@mipmap/ic_launcher"
-        android:label="@string/app_name"
-        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme"/>
 </manifest>
@@ -0,0 +1,2 @@
+/android_lts_support.o
+/libandroidltssupport.a
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <math.h>
+#include <errno.h>
+#include <malloc.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if __ANDROID_API__ < 17
+
+int posix_memalign(void** memptr, size_t alignment, size_t size) {
+  if ((alignment & (alignment - 1)) != 0 || alignment == 0) {
+    return EINVAL;
+  }
+
+  if (alignment % sizeof(void*) != 0) {
+    return EINVAL;
+  }
+
+  *memptr = memalign(alignment, size);
+  if (*memptr == NULL) {
+    return errno;
+  }
+
+  return 0;
+}
+
+#endif /* __ANDROID_API__ < 17 */
+
+double log2(double x) {
+    return (log(x) / M_LN2);
+}
+
+float log2f(float x) {
+ return (float) log2((double) x);
+}
+
+#ifdef __cplusplus
+};  /* end of extern "C" */
+#endif
@@ -191,7 +191,7 @@ void show_help_options(const OptionDef *options, const char *msg, int req_flags,
            continue;

        if (first) {
-            printf("%s\n", msg);
+            av_log(NULL, AV_LOG_INFO, "%s\n", msg);
            first = 0;
        }
        av_strlcpy(buf, po->name, sizeof(buf));
@@ -199,9 +199,9 @@ void show_help_options(const OptionDef *options, const char *msg, int req_flags,
            av_strlcat(buf, " ", sizeof(buf));
            av_strlcat(buf, po->argname, sizeof(buf));
        }
-        printf("-%-17s  %s\n", buf, po->help);
+        av_log(NULL, AV_LOG_INFO, "-%-17s  %s\n", buf, po->help);
    }
-    printf("\n");
+    av_log(NULL, AV_LOG_INFO, "\n");
 }

 void show_help_children(const AVClass *class, int flags)
@@ -209,7 +209,7 @@ void show_help_children(const AVClass *class, int flags)
    const AVClass *child = NULL;
    if (class->option) {
        av_opt_show2(&class, NULL, flags, 0);
-        printf("\n");
+        av_log(NULL, AV_LOG_INFO, "\n");
    }

    while ((child = av_opt_child_class_next(class, child)))
@@ -1214,12 +1214,12 @@ int show_buildconf(void *optctx, const char *opt, const char *arg)
 int show_license(void *optctx, const char *opt, const char *arg)
 {
 #if CONFIG_NONFREE
-    printf(
+    av_log(NULL, AV_LOG_INFO,
    "This version of %s has nonfree parts compiled in.\n"
    "Therefore it is not legally redistributable.\n",
    program_name );
 #elif CONFIG_GPLV3
-    printf(
+    av_log(NULL, AV_LOG_INFO,
    "%s is free software; you can redistribute it and/or modify\n"
    "it under the terms of the GNU General Public License as published by\n"
    "the Free Software Foundation; either version 3 of the License, or\n"
@@ -1234,7 +1234,7 @@ int show_license(void *optctx, const char *opt, const char *arg)
    "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
    program_name, program_name, program_name );
 #elif CONFIG_GPL
-    printf(
+    av_log(NULL, AV_LOG_INFO,
    "%s is free software; you can redistribute it and/or modify\n"
    "it under the terms of the GNU General Public License as published by\n"
    "the Free Software Foundation; either version 2 of the License, or\n"
@@ -1250,7 +1250,7 @@ int show_license(void *optctx, const char *opt, const char *arg)
    "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
    program_name, program_name, program_name );
 #elif CONFIG_LGPLV3
-    printf(
+    av_log(NULL, AV_LOG_INFO,
    "%s is free software; you can redistribute it and/or modify\n"
    "it under the terms of the GNU Lesser General Public License as published by\n"
    "the Free Software Foundation; either version 3 of the License, or\n"
@@ -1265,7 +1265,7 @@ int show_license(void *optctx, const char *opt, const char *arg)
    "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
    program_name, program_name, program_name );
 #else
-    printf(
+    av_log(NULL, AV_LOG_INFO,
    "%s is free software; you can redistribute it and/or\n"
    "modify it under the terms of the GNU Lesser General Public\n"
    "License as published by the Free Software Foundation; either\n"
@@ -1301,7 +1301,7 @@ static int show_formats_devices(void *optctx, const char *opt, const char *arg,
    const char *last_name;
    int is_dev;

-    printf("%s\n"
+    av_log(NULL, AV_LOG_INFO, "%s\n"
           " D. = Demuxing supported\n"
           " .E = Muxing supported\n"
           " --\n", device_only ? "Devices:" : "File formats:");
@@ -1346,7 +1346,7 @@ static int show_formats_devices(void *optctx, const char *opt, const char *arg,
            break;
        last_name = name;

-        printf(" %s%s %-15s %s\n",
+        av_log(NULL, AV_LOG_INFO, " %s%s %-15s %s\n",
               decode ? "D" : " ",
               encode ? "E" : " ",
               name,
@@ -1379,97 +1379,97 @@ int show_devices(void *optctx, const char *opt, const char *arg)
    if (codec->field) {                                                      \
        const type *p = codec->field;                                        \
                                                                             \
-        printf("    Supported " list_name ":");                              \
+        av_log(NULL, AV_LOG_INFO, "    Supported " list_name ":");                              \
        while (*p != term) {                                                 \
            get_name(*p);                                                    \
-            printf(" %s", name);                                             \
+            av_log(NULL, AV_LOG_INFO, " %s", name);                                             \
            p++;                                                             \
        }                                                                    \
-        printf("\n");                                                        \
+        av_log(NULL, AV_LOG_INFO, "\n");                                                        \
    }                                                                        \

 static void print_codec(const AVCodec *c)
 {
    int encoder = av_codec_is_encoder(c);

-    printf("%s %s [%s]:\n", encoder ? "Encoder" : "Decoder", c->name,
+    av_log(NULL, AV_LOG_INFO, "%s %s [%s]:\n", encoder ? "Encoder" : "Decoder", c->name,
           c->long_name ? c->long_name : "");

-    printf("    General capabilities: ");
+    av_log(NULL, AV_LOG_INFO, "    General capabilities: ");
    if (c->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)
-        printf("horizband ");
+        av_log(NULL, AV_LOG_INFO, "horizband ");
    if (c->capabilities & AV_CODEC_CAP_DR1)
-        printf("dr1 ");
+        av_log(NULL, AV_LOG_INFO, "dr1 ");
    if (c->capabilities & AV_CODEC_CAP_TRUNCATED)
-        printf("trunc ");
+        av_log(NULL, AV_LOG_INFO, "trunc ");
    if (c->capabilities & AV_CODEC_CAP_DELAY)
-        printf("delay ");
+        av_log(NULL, AV_LOG_INFO, "delay ");
    if (c->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME)
-        printf("small ");
+        av_log(NULL, AV_LOG_INFO, "small ");
    if (c->capabilities & AV_CODEC_CAP_SUBFRAMES)
-        printf("subframes ");
+        av_log(NULL, AV_LOG_INFO, "subframes ");
    if (c->capabilities & AV_CODEC_CAP_EXPERIMENTAL)
-        printf("exp ");
+        av_log(NULL, AV_LOG_INFO, "exp ");
    if (c->capabilities & AV_CODEC_CAP_CHANNEL_CONF)
-        printf("chconf ");
+        av_log(NULL, AV_LOG_INFO, "chconf ");
    if (c->capabilities & AV_CODEC_CAP_PARAM_CHANGE)
-        printf("paramchange ");
+        av_log(NULL, AV_LOG_INFO, "paramchange ");
    if (c->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)
-        printf("variable ");
+        av_log(NULL, AV_LOG_INFO, "variable ");
    if (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
                           AV_CODEC_CAP_SLICE_THREADS |
                           AV_CODEC_CAP_AUTO_THREADS))
-        printf("threads ");
+        av_log(NULL, AV_LOG_INFO, "threads ");
    if (c->capabilities & AV_CODEC_CAP_AVOID_PROBING)
-        printf("avoidprobe ");
+        av_log(NULL, AV_LOG_INFO, "avoidprobe ");
    if (c->capabilities & AV_CODEC_CAP_INTRA_ONLY)
-        printf("intraonly ");
+        av_log(NULL, AV_LOG_INFO, "intraonly ");
    if (c->capabilities & AV_CODEC_CAP_LOSSLESS)
-        printf("lossless ");
+        av_log(NULL, AV_LOG_INFO, "lossless ");
    if (c->capabilities & AV_CODEC_CAP_HARDWARE)
-        printf("hardware ");
+        av_log(NULL, AV_LOG_INFO, "hardware ");
    if (c->capabilities & AV_CODEC_CAP_HYBRID)
-        printf("hybrid ");
+        av_log(NULL, AV_LOG_INFO, "hybrid ");
    if (!c->capabilities)
-        printf("none");
-    printf("\n");
+        av_log(NULL, AV_LOG_INFO, "none");
+    av_log(NULL, AV_LOG_INFO, "\n");

    if (c->type == AVMEDIA_TYPE_VIDEO ||
        c->type == AVMEDIA_TYPE_AUDIO) {
-        printf("    Threading capabilities: ");
+        av_log(NULL, AV_LOG_INFO, "    Threading capabilities: ");
        switch (c->capabilities & (AV_CODEC_CAP_FRAME_THREADS |
                                   AV_CODEC_CAP_SLICE_THREADS |
                                   AV_CODEC_CAP_AUTO_THREADS)) {
        case AV_CODEC_CAP_FRAME_THREADS |
-             AV_CODEC_CAP_SLICE_THREADS: printf("frame and slice"); break;
-        case AV_CODEC_CAP_FRAME_THREADS: printf("frame");           break;
-        case AV_CODEC_CAP_SLICE_THREADS: printf("slice");           break;
-        case AV_CODEC_CAP_AUTO_THREADS : printf("auto");            break;
-        default:                         printf("none");            break;
+             AV_CODEC_CAP_SLICE_THREADS: av_log(NULL, AV_LOG_INFO, "frame and slice"); break;
+        case AV_CODEC_CAP_FRAME_THREADS: av_log(NULL, AV_LOG_INFO, "frame");           break;
+        case AV_CODEC_CAP_SLICE_THREADS: av_log(NULL, AV_LOG_INFO, "slice");           break;
+        case AV_CODEC_CAP_AUTO_THREADS : av_log(NULL, AV_LOG_INFO, "auto");            break;
+        default:                         av_log(NULL, AV_LOG_INFO, "none");            break;
        }
-        printf("\n");
+        av_log(NULL, AV_LOG_INFO, "\n");
    }

    if (avcodec_get_hw_config(c, 0)) {
-        printf("    Supported hardware devices: ");
+        av_log(NULL, AV_LOG_INFO, "    Supported hardware devices: ");
        for (int i = 0;; i++) {
            const AVCodecHWConfig *config = avcodec_get_hw_config(c, i);
            if (!config)
                break;
-            printf("%s ", av_hwdevice_get_type_name(config->device_type));
+            av_log(NULL, AV_LOG_INFO, "%s ", av_hwdevice_get_type_name(config->device_type));
        }
-        printf("\n");
+        av_log(NULL, AV_LOG_INFO, "\n");
    }

    if (c->supported_framerates) {
        const AVRational *fps = c->supported_framerates;

-        printf("    Supported framerates:");
+        av_log(NULL, AV_LOG_INFO, "    Supported framerates:");
        while (fps->num) {
-            printf(" %d/%d", fps->num, fps->den);
+            av_log(NULL, AV_LOG_INFO, " %d/%d", fps->num, fps->den);
            fps++;
        }
-        printf("\n");
+        av_log(NULL, AV_LOG_INFO, "\n");
    }
    PRINT_CODEC_SUPPORTED(c, pix_fmts, enum AVPixelFormat, "pixel formats",
                          AV_PIX_FMT_NONE, GET_PIX_FMT_NAME);
@@ -1544,12 +1544,12 @@ static void print_codecs_for_id(enum AVCodecID id, int encoder)
 {
    const AVCodec *codec = NULL;

-    printf(" (%s: ", encoder ? "encoders" : "decoders");
+    av_log(NULL, AV_LOG_INFO, " (%s: ", encoder ? "encoders" : "decoders");

    while ((codec = next_codec_for_id(id, codec, encoder)))
-        printf("%s ", codec->name);
+        av_log(NULL, AV_LOG_INFO, "%s ", codec->name);

-    printf(")");
+    av_log(NULL, AV_LOG_INFO, ")");
 }

 int show_codecs(void *optctx, const char *opt, const char *arg)
@@ -1557,7 +1557,7 @@ int show_codecs(void *optctx, const char *opt, const char *arg)
    const AVCodecDescriptor **codecs;
    unsigned i, nb_codecs = get_codecs_sorted(&codecs);

-    printf("Codecs:\n"
+    av_log(NULL, AV_LOG_INFO, "Codecs:\n"
           " D..... = Decoding supported\n"
           " .E.... = Encoding supported\n"
           " ..V... = Video codec\n"
@@ -1574,16 +1574,16 @@ int show_codecs(void *optctx, const char *opt, const char *arg)
        if (strstr(desc->name, "_deprecated"))
            continue;

-        printf(" ");
-        printf(avcodec_find_decoder(desc->id) ? "D" : ".");
-        printf(avcodec_find_encoder(desc->id) ? "E" : ".");
+        av_log(NULL, AV_LOG_INFO, " ");
+        av_log(NULL, AV_LOG_INFO, avcodec_find_decoder(desc->id) ? "D" : ".");
+        av_log(NULL, AV_LOG_INFO, avcodec_find_encoder(desc->id) ? "E" : ".");

-        printf("%c", get_media_type_char(desc->type));
-        printf((desc->props & AV_CODEC_PROP_INTRA_ONLY) ? "I" : ".");
-        printf((desc->props & AV_CODEC_PROP_LOSSY)      ? "L" : ".");
-        printf((desc->props & AV_CODEC_PROP_LOSSLESS)   ? "S" : ".");
+        av_log(NULL, AV_LOG_INFO, "%c", get_media_type_char(desc->type));
+        av_log(NULL, AV_LOG_INFO, (desc->props & AV_CODEC_PROP_INTRA_ONLY) ? "I" : ".");
+        av_log(NULL, AV_LOG_INFO, (desc->props & AV_CODEC_PROP_LOSSY)      ? "L" : ".");
+        av_log(NULL, AV_LOG_INFO, (desc->props & AV_CODEC_PROP_LOSSLESS)   ? "S" : ".");

-        printf(" %-20s %s", desc->name, desc->long_name ? desc->long_name : "");
+        av_log(NULL, AV_LOG_INFO, " %-20s %s", desc->name, desc->long_name ? desc->long_name : "");

        /* print decoders/encoders when there's more than one or their
         * names are different from codec name */
@@ -1601,7 +1601,7 @@ int show_codecs(void *optctx, const char *opt, const char *arg)
            }
        }

-        printf("\n");
+        av_log(NULL, AV_LOG_INFO, "\n");
    }
    av_free(codecs);
    return 0;
@@ -1612,7 +1612,7 @@ static void print_codecs(int encoder)
    const AVCodecDescriptor **codecs;
    unsigned i, nb_codecs = get_codecs_sorted(&codecs);

-    printf("%s:\n"
+    av_log(NULL, AV_LOG_INFO, "%s:\n"
           " V..... = Video\n"
           " A..... = Audio\n"
           " S..... = Subtitle\n"
@@ -1628,18 +1628,18 @@ static void print_codecs(int encoder)
        const AVCodec *codec = NULL;

        while ((codec = next_codec_for_id(desc->id, codec, encoder))) {
-            printf(" %c", get_media_type_char(desc->type));
-            printf((codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) ? "F" : ".");
-            printf((codec->capabilities & AV_CODEC_CAP_SLICE_THREADS) ? "S" : ".");
-            printf((codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL)  ? "X" : ".");
-            printf((codec->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)?"B" : ".");
-            printf((codec->capabilities & AV_CODEC_CAP_DR1)           ? "D" : ".");
+            av_log(NULL, AV_LOG_INFO, " %c", get_media_type_char(desc->type));
+            av_log(NULL, AV_LOG_INFO, (codec->capabilities & AV_CODEC_CAP_FRAME_THREADS) ? "F" : ".");
+            av_log(NULL, AV_LOG_INFO, (codec->capabilities & AV_CODEC_CAP_SLICE_THREADS) ? "S" : ".");
+            av_log(NULL, AV_LOG_INFO, (codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL)  ? "X" : ".");
+            av_log(NULL, AV_LOG_INFO, (codec->capabilities & AV_CODEC_CAP_DRAW_HORIZ_BAND)?"B" : ".");
+            av_log(NULL, AV_LOG_INFO, (codec->capabilities & AV_CODEC_CAP_DR1)           ? "D" : ".");

-            printf(" %-20s %s", codec->name, codec->long_name ? codec->long_name : "");
+            av_log(NULL, AV_LOG_INFO, " %-20s %s", codec->name, codec->long_name ? codec->long_name : "");
            if (strcmp(codec->name, desc->name))
-                printf(" (codec %s)", desc->name);
+                av_log(NULL, AV_LOG_INFO, " (codec %s)", desc->name);

-            printf("\n");
+            av_log(NULL, AV_LOG_INFO, "\n");
        }
    }
    av_free(codecs);
@@ -1662,10 +1662,10 @@ int show_bsfs(void *optctx, const char *opt, const char *arg)
    const AVBitStreamFilter *bsf = NULL;
    void *opaque = NULL;

-    printf("Bitstream filters:\n");
+    av_log(NULL, AV_LOG_INFO, "Bitstream filters:\n");
    while ((bsf = av_bsf_iterate(&opaque)))
-        printf("%s\n", bsf->name);
-    printf("\n");
+        av_log(NULL, AV_LOG_INFO, "%s\n", bsf->name);
+    av_log(NULL, AV_LOG_INFO, "\n");
    return 0;
 }

@@ -1674,13 +1674,13 @@ int show_protocols(void *optctx, const char *opt, const char *arg)
    void *opaque = NULL;
    const char *name;

-    printf("Supported file protocols:\n"
+    av_log(NULL, AV_LOG_INFO, "Supported file protocols:\n"
           "Input:\n");
    while ((name = avio_enum_protocols(&opaque, 0)))
-        printf("  %s\n", name);
-    printf("Output:\n");
+        av_log(NULL, AV_LOG_INFO, "  %s\n", name);
+    av_log(NULL, AV_LOG_INFO, "Output:\n");
    while ((name = avio_enum_protocols(&opaque, 1)))
-        printf("  %s\n", name);
+        av_log(NULL, AV_LOG_INFO, "  %s\n", name);
    return 0;
 }

@@ -1693,7 +1693,7 @@ int show_filters(void *optctx, const char *opt, const char *arg)
    int i, j;
    const AVFilterPad *pad;

-    printf("Filters:\n"
+    av_log(NULL, AV_LOG_INFO, "Filters:\n"
           "  T.. = Timeline support\n"
           "  .S. = Slice threading\n"
           "  ..C = Command support\n"
@@ -1719,14 +1719,14 @@ int show_filters(void *optctx, const char *opt, const char *arg)
                                  ( i && (filter->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS))) ? 'N' : '|';
        }
        *descr_cur = 0;
-        printf(" %c%c%c %-17s %-10s %s\n",
+        av_log(NULL, AV_LOG_INFO, " %c%c%c %-17s %-10s %s\n",
               filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE ? 'T' : '.',
               filter->flags & AVFILTER_FLAG_SLICE_THREADS    ? 'S' : '.',
               filter->process_command                        ? 'C' : '.',
               filter->name, descr, filter->description);
    }
 #else
-    printf("No filters available: libavfilter disabled\n");
+    av_log(NULL, AV_LOG_INFO, "No filters available: libavfilter disabled\n");
 #endif
    return 0;
 }
@@ -1737,10 +1737,10 @@ int show_colors(void *optctx, const char *opt, const char *arg)
    const uint8_t *rgb;
    int i;

-    printf("%-32s #RRGGBB\n", "name");
+    av_log(NULL, AV_LOG_INFO, "%-32s #RRGGBB\n", "name");

    for (i = 0; (name = av_get_known_color_name(i, &rgb)); i++)
-        printf("%-32s #%02x%02x%02x\n", name, rgb[0], rgb[1], rgb[2]);
+        av_log(NULL, AV_LOG_INFO, "%-32s #%02x%02x%02x\n", name, rgb[0], rgb[1], rgb[2]);

    return 0;
 }
@@ -1749,7 +1749,7 @@ int show_pix_fmts(void *optctx, const char *opt, const char *arg)
 {
    const AVPixFmtDescriptor *pix_desc = NULL;

-    printf("Pixel formats:\n"
+    av_log(NULL, AV_LOG_INFO, "Pixel formats:\n"
           "I.... = Supported Input  format for conversion\n"
           ".O... = Supported Output format for conversion\n"
           "..H.. = Hardware accelerated format\n"
@@ -1765,7 +1765,7 @@ int show_pix_fmts(void *optctx, const char *opt, const char *arg)

    while ((pix_desc = av_pix_fmt_desc_next(pix_desc))) {
        enum AVPixelFormat av_unused pix_fmt = av_pix_fmt_desc_get_id(pix_desc);
-        printf("%c%c%c%c%c %-16s       %d            %2d\n",
+        av_log(NULL, AV_LOG_INFO, "%c%c%c%c%c %-16s       %d            %2d\n",
               sws_isSupportedInput (pix_fmt)              ? 'I' : '.',
               sws_isSupportedOutput(pix_fmt)              ? 'O' : '.',
               pix_desc->flags & AV_PIX_FMT_FLAG_HWACCEL   ? 'H' : '.',
@@ -1784,24 +1784,24 @@ int show_layouts(void *optctx, const char *opt, const char *arg)
    uint64_t layout, j;
    const char *name, *descr;

-    printf("Individual channels:\n"
+    av_log(NULL, AV_LOG_INFO, "Individual channels:\n"
           "NAME           DESCRIPTION\n");
    for (i = 0; i < 63; i++) {
        name = av_get_channel_name((uint64_t)1 << i);
        if (!name)
            continue;
        descr = av_get_channel_description((uint64_t)1 << i);
-        printf("%-14s %s\n", name, descr);
+        av_log(NULL, AV_LOG_INFO, "%-14s %s\n", name, descr);
    }
-    printf("\nStandard channel layouts:\n"
+    av_log(NULL, AV_LOG_INFO, "\nStandard channel layouts:\n"
           "NAME           DECOMPOSITION\n");
    for (i = 0; !av_get_standard_channel_layout(i, &layout, &name); i++) {
        if (name) {
-            printf("%-14s ", name);
+            av_log(NULL, AV_LOG_INFO, "%-14s ", name);
            for (j = 1; j; j <<= 1)
                if ((layout & j))
-                    printf("%s%s", (layout & (j - 1)) ? "+" : "", av_get_channel_name(j));
-            printf("\n");
+                    av_log(NULL, AV_LOG_INFO, "%s%s", (layout & (j - 1)) ? "+" : "", av_get_channel_name(j));
+            av_log(NULL, AV_LOG_INFO, "\n");
        }
    }
    return 0;
@@ -1812,7 +1812,7 @@ int show_sample_fmts(void *optctx, const char *opt, const char *arg)
    int i;
    char fmt_str[128];
    for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
-        printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
+        av_log(NULL, AV_LOG_INFO, "%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
    return 0;
 }

@@ -1860,10 +1860,10 @@ static void show_help_demuxer(const char *name)
        return;
    }

-    printf("Demuxer %s [%s]:\n", fmt->name, fmt->long_name);
+    av_log(NULL, AV_LOG_INFO, "Demuxer %s [%s]:\n", fmt->name, fmt->long_name);

    if (fmt->extensions)
-        printf("    Common extensions: %s.\n", fmt->extensions);
+        av_log(NULL, AV_LOG_INFO, "    Common extensions: %s.\n", fmt->extensions);

    if (fmt->priv_class)
        show_help_children(fmt->priv_class, AV_OPT_FLAG_DECODING_PARAM);
@@ -1879,23 +1879,23 @@ static void show_help_muxer(const char *name)
        return;
    }

-    printf("Muxer %s [%s]:\n", fmt->name, fmt->long_name);
+    av_log(NULL, AV_LOG_INFO, "Muxer %s [%s]:\n", fmt->name, fmt->long_name);

    if (fmt->extensions)
-        printf("    Common extensions: %s.\n", fmt->extensions);
+        av_log(NULL, AV_LOG_INFO, "    Common extensions: %s.\n", fmt->extensions);
    if (fmt->mime_type)
-        printf("    Mime type: %s.\n", fmt->mime_type);
+        av_log(NULL, AV_LOG_INFO, "    Mime type: %s.\n", fmt->mime_type);
    if (fmt->video_codec != AV_CODEC_ID_NONE &&
        (desc = avcodec_descriptor_get(fmt->video_codec))) {
-        printf("    Default video codec: %s.\n", desc->name);
+        av_log(NULL, AV_LOG_INFO, "    Default video codec: %s.\n", desc->name);
    }
    if (fmt->audio_codec != AV_CODEC_ID_NONE &&
        (desc = avcodec_descriptor_get(fmt->audio_codec))) {
-        printf("    Default audio codec: %s.\n", desc->name);
+        av_log(NULL, AV_LOG_INFO, "    Default audio codec: %s.\n", desc->name);
    }
    if (fmt->subtitle_codec != AV_CODEC_ID_NONE &&
        (desc = avcodec_descriptor_get(fmt->subtitle_codec))) {
-        printf("    Default subtitle codec: %s.\n", desc->name);
+        av_log(NULL, AV_LOG_INFO, "    Default subtitle codec: %s.\n", desc->name);
    }

    if (fmt->priv_class)
@@ -1917,40 +1917,40 @@ static void show_help_filter(const char *name)
        return;
    }

-    printf("Filter %s\n", f->name);
+    av_log(NULL, AV_LOG_INFO, "Filter %s\n", f->name);
    if (f->description)
-        printf("  %s\n", f->description);
+        av_log(NULL, AV_LOG_INFO, "  %s\n", f->description);

    if (f->flags & AVFILTER_FLAG_SLICE_THREADS)
-        printf("    slice threading supported\n");
+        av_log(NULL, AV_LOG_INFO, "    slice threading supported\n");

-    printf("    Inputs:\n");
+    av_log(NULL, AV_LOG_INFO, "    Inputs:\n");
    count = avfilter_pad_count(f->inputs);
    for (i = 0; i < count; i++) {
-        printf("       #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
+        av_log(NULL, AV_LOG_INFO, "       #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
               media_type_string(avfilter_pad_get_type(f->inputs, i)));
    }
    if (f->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)
-        printf("        dynamic (depending on the options)\n");
+        av_log(NULL, AV_LOG_INFO, "        dynamic (depending on the options)\n");
    else if (!count)
-        printf("        none (source filter)\n");
+        av_log(NULL, AV_LOG_INFO, "        none (source filter)\n");

-    printf("    Outputs:\n");
+    av_log(NULL, AV_LOG_INFO, "    Outputs:\n");
    count = avfilter_pad_count(f->outputs);
    for (i = 0; i < count; i++) {
-        printf("       #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
+        av_log(NULL, AV_LOG_INFO, "       #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
               media_type_string(avfilter_pad_get_type(f->outputs, i)));
    }
    if (f->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS)
-        printf("        dynamic (depending on the options)\n");
+        av_log(NULL, AV_LOG_INFO, "        dynamic (depending on the options)\n");
    else if (!count)
-        printf("        none (sink filter)\n");
+        av_log(NULL, AV_LOG_INFO, "        none (sink filter)\n");

    if (f->priv_class)
        show_help_children(f->priv_class, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM |
                                          AV_OPT_FLAG_AUDIO_PARAM);
    if (f->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)
-        printf("This filter has support for timeline through the 'enable' option.\n");
+        av_log(NULL, AV_LOG_INFO, "This filter has support for timeline through the 'enable' option.\n");
 #else
    av_log(NULL, AV_LOG_ERROR, "Build without libavfilter; "
           "can not to satisfy request\n");
@@ -1970,7 +1970,7 @@ static void show_help_bsf(const char *name)
        return;
    }

-    printf("Bit stream filter %s\n", bsf->name);
+    av_log(NULL, AV_LOG_INFO, "Bit stream filter %s\n", bsf->name);
    PRINT_CODEC_SUPPORTED(bsf, codec_ids, enum AVCodecID, "codecs",
                          AV_CODEC_ID_NONE, GET_CODEC_NAME);
    if (bsf->priv_class)
@@ -2206,20 +2206,20 @@ static int print_device_sources(AVInputFormat *fmt, AVDictionary *opts)
    if (!fmt || !fmt->priv_class  || !AV_IS_INPUT_DEVICE(fmt->priv_class->category))
        return AVERROR(EINVAL);

-    printf("Auto-detected sources for %s:\n", fmt->name);
+    av_log(NULL, AV_LOG_INFO, "Auto-detected sources for %s:\n", fmt->name);
    if (!fmt->get_device_list) {
        ret = AVERROR(ENOSYS);
-        printf("Cannot list sources. Not implemented.\n");
+        av_log(NULL, AV_LOG_INFO, "Cannot list sources. Not implemented.\n");
        goto fail;
    }

    if ((ret = avdevice_list_input_sources(fmt, NULL, opts, &device_list)) < 0) {
-        printf("Cannot list sources.\n");
+        av_log(NULL, AV_LOG_INFO, "Cannot list sources.\n");
        goto fail;
    }

    for (i = 0; i < device_list->nb_devices; i++) {
-        printf("%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
+        av_log(NULL, AV_LOG_INFO, "%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
               device_list->devices[i]->device_name, device_list->devices[i]->device_description);
    }

@@ -2236,20 +2236,20 @@ static int print_device_sinks(AVOutputFormat *fmt, AVDictionary *opts)
    if (!fmt || !fmt->priv_class  || !AV_IS_OUTPUT_DEVICE(fmt->priv_class->category))
        return AVERROR(EINVAL);

-    printf("Auto-detected sinks for %s:\n", fmt->name);
+    av_log(NULL, AV_LOG_INFO, "Auto-detected sinks for %s:\n", fmt->name);
    if (!fmt->get_device_list) {
        ret = AVERROR(ENOSYS);
-        printf("Cannot list sinks. Not implemented.\n");
+        av_log(NULL, AV_LOG_INFO, "Cannot list sinks. Not implemented.\n");
        goto fail;
    }

    if ((ret = avdevice_list_output_sinks(fmt, NULL, opts, &device_list)) < 0) {
-        printf("Cannot list sinks.\n");
+        av_log(NULL, AV_LOG_INFO, "Cannot list sinks.\n");
        goto fail;
    }

    for (i = 0; i < device_list->nb_devices; i++) {
-        printf("%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
+        av_log(NULL, AV_LOG_INFO, "%s %s [%s]\n", device_list->default_device == i ? "*" : " ",
               device_list->devices[i]->device_name, device_list->devices[i]->device_description);
    }

@@ -2275,7 +2275,7 @@ static int show_sinks_sources_parse_arg(const char *arg, char **dev, AVDictionar
            }
        }
    } else
-        printf("\nDevice name is not provided.\n"
+        av_log(NULL, AV_LOG_INFO, "\nDevice name is not provided.\n"
                "You can pass devicename[,opt1=val1[,opt2=val2...]] as an argument.\n\n");
    return 0;
 }
@@ -20,6 +20,10 @@
 */

 /*
+ * CHANGES 03.2019
+ * --------------------------------------------------------
+ * - config.h include removed
+ *
 * CHANGES 08.2018
 * --------------------------------------------------------
 * - fftools_ prefix added to file name and include guards
@@ -35,7 +39,6 @@

 #include <stdint.h>

-#include "config.h"
 #include "libavcodec/avcodec.h"
 #include "libavfilter/avfilter.h"
 #include "libavformat/avformat.h"
@@ -358,6 +361,7 @@ typedef struct OptionParseContext {
 * Parse an options group and write results into optctx.
 *
 * @param optctx an app-specific options context. NULL for global options group
+ * @param g option group
 */
 int parse_optgroup(void *optctx, OptionGroup *g);

@@ -1102,6 +1102,7 @@ static void do_video_out(OutputFile *of,

    if (!ost->filters_script &&
        !ost->filters &&
+        (nb_filtergraphs == 0 || !filtergraphs[0]->graph_desc) &&
        next_picture &&
        ist &&
        lrintf(next_picture->pkt_duration * av_q2d(ist->st->time_base) / av_q2d(enc->time_base)) > 0) {
@@ -1219,6 +1220,8 @@ static void do_video_out(OutputFile *of,
  /* duplicates frame if needed */
  for (i = 0; i < nb_frames; i++) {
    AVFrame *in_picture;
+        int forced_keyframe = 0;
+        double pts_time;
    av_init_packet(&pkt);
    pkt.data = NULL;
    pkt.size = 0;
@@ -1233,17 +1236,9 @@ static void do_video_out(OutputFile *of,

    in_picture->pts = ost->sync_opts;

-#if 1
    if (!check_recording_time(ost))
-#else
-    if (ost->frame_number >= ost->max_frames)
-#endif
        return;

-    {
-        int forced_keyframe = 0;
-        double pts_time;
-
        if (enc->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME) &&
            ost->top_field_first >= 0)
            in_picture->top_field_first = !!ost->top_field_first;
@@ -1315,6 +1310,8 @@ static void do_video_out(OutputFile *of,
        ret = avcodec_send_frame(enc, in_picture);
        if (ret < 0)
            goto error;
+        // Make sure Closed Captions will not be duplicated
+        av_frame_remove_side_data(in_picture, AV_FRAME_DATA_A53_CC);

        while (1) {
            ret = avcodec_receive_packet(enc, &pkt);
@@ -1351,7 +1348,6 @@ static void do_video_out(OutputFile *of,
                fprintf(ost->logfile, "%s", enc->stats_out);
            }
        }
-    }
    ost->sync_opts++;
    /*
     * For video, number of frames in == number of packets out.
@@ -1515,8 +1511,6 @@ static int reap_filters(int flush)
                    av_rescale_q(filtered_frame->pts, filter_tb, enc->time_base) -
                    av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
            }
-            //if (ost->source_index >= 0)
-            //    *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold

            switch (av_buffersink_get_type(filter)) {
            case AVMEDIA_TYPE_VIDEO:
@@ -2247,9 +2241,6 @@ static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame)

    /* determine if the parameters for this input changed */
    need_reinit = ifilter->format != frame->format;
-    if (!!ifilter->hw_frames_ctx != !!frame->hw_frames_ctx ||
-        (ifilter->hw_frames_ctx && ifilter->hw_frames_ctx->data != frame->hw_frames_ctx->data))
-        need_reinit = 1;

    switch (ifilter->ist->st->codecpar->codec_type) {
    case AVMEDIA_TYPE_AUDIO:
@@ -2263,6 +2254,13 @@ static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame)
        break;
    }

+    if (!ifilter->ist->reinit_filters && fg->graph)
+        need_reinit = 0;
+
+    if (!!ifilter->hw_frames_ctx != !!frame->hw_frames_ctx ||
+        (ifilter->hw_frames_ctx && ifilter->hw_frames_ctx->data != frame->hw_frames_ctx->data))
+        need_reinit = 1;
+
    if (need_reinit) {
        ret = ifilter_parameters_from_frame(ifilter, frame);
        if (ret < 0)
@@ -2427,14 +2425,12 @@ static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output,
    ist->samples_decoded += decoded_frame->nb_samples;
    ist->frames_decoded++;

-#if 1
    /* increment next_dts to use for the case where the input stream does not
       have timestamps or there are multiple frames in the packet */
    ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
                     avctx->sample_rate;
    ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
                     avctx->sample_rate;
-#endif

    if (decoded_frame->pts != AV_NOPTS_VALUE) {
        decoded_frame_tb   = ist->st->time_base;
@@ -2894,7 +2890,7 @@ static void print_sdp(void)
    av_sdp_create(avc, j, sdp, sizeof(sdp));

    if (!sdp_filename) {
-        printf("SDP:\n%s\n", sdp);
+        av_log(NULL, AV_LOG_INFO, "SDP:\n%s\n", sdp);
        fflush(stdout);
    } else {
        if (avio_open2(&sdp_pb, sdp_filename, AVIO_FLAG_WRITE, &int_cb, NULL) < 0) {
@@ -3457,7 +3453,7 @@ static int init_output_stream_encode(OutputStream *ost)
                   "if you want a different framerate.\n",
                   ost->file_index, ost->index);
        }
-//      ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
+
        if (ost->enc->supported_framerates && !ost->force_fps) {
            int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
            ost->frame_rate = ost->enc->supported_framerates[idx];
@@ -4588,7 +4584,10 @@ static int process_input(int file_index)
                pkt_dts + AV_TIME_BASE/10 < FFMAX(ist->pts, ist->dts)) {
                ifile->ts_offset -= delta;
                av_log(NULL, AV_LOG_DEBUG,
-                       "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
+                       "timestamp discontinuity for stream #%d:%d "
+                       "(id=%d, type=%s): %"PRId64", new offset= %"PRId64"\n",
+                       ist->file_index, ist->st->index, ist->st->id,
+                       av_get_media_type_string(ist->dec_ctx->codec_type),
                       delta, ifile->ts_offset);
                pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
                if (pkt.pts != AV_NOPTS_VALUE)
@@ -5041,11 +5040,6 @@ int execute(int argc, char **argv)
            exit_program(1);
        }

-    //     if (nb_input_files == 0) {
-    //         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
-    //         exit_program(1);
-    //     }
-
        for (i = 0; i < nb_output_files; i++) {
            if (strcmp(output_files[i]->ctx->oformat->name, "rtp"))
                want_sdp = 0;
@@ -17,6 +17,10 @@
 */

 /*
+ * CHANGES 03.2019
+ * --------------------------------------------------------
+ * - config.h include removed
+ *
 * CHANGES 08.2018
 * --------------------------------------------------------
 * - fftools_ prefix added to file name and include guards
@@ -31,8 +35,6 @@
 #ifndef FFTOOLS_FFMPEG_H
 #define FFTOOLS_FFMPEG_H

-#include "config.h"
-
 #include <stdint.h>
 #include <stdio.h>
 #include <signal.h>
@@ -301,10 +301,17 @@ static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
            exit_program(1);
        }
        ist = input_streams[input_files[file_idx]->ist_index + st->index];
+        if (ist->user_set_discard == AVDISCARD_ALL) {
+            av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
+                   "matches a disabled input stream.\n", p, fg->graph_desc);
+            exit_program(1);
+        }
    } else {
        /* find the first unused stream of corresponding type */
        for (i = 0; i < nb_input_streams; i++) {
            ist = input_streams[i];
+            if (ist->user_set_discard == AVDISCARD_ALL)
+                continue;
            if (ist->dec_ctx->codec_type == type && ist->discard)
                break;
        }
@@ -740,6 +747,7 @@ static int sub2video_prepare(InputStream *ist, InputFilter *ifilter)
    if (!ist->sub2video.frame)
        return AVERROR(ENOMEM);
    ist->sub2video.last_pts = INT64_MIN;
+    ist->sub2video.end_pts  = INT64_MIN;
    return 0;
 }

@@ -183,13 +183,13 @@ static int show_hwaccels(void *optctx, const char *opt, const char *arg)
    enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
    int i;

-    printf("Hardware acceleration methods:\n");
+    av_log(NULL, AV_LOG_INFO, "Hardware acceleration methods:\n");
    while ((type = av_hwdevice_iterate_types(type)) !=
           AV_HWDEVICE_TYPE_NONE)
-        printf("%s\n", av_hwdevice_get_type_name(type));
+        av_log(NULL, AV_LOG_INFO, "%s\n", av_hwdevice_get_type_name(type));
    for (i = 0; hwaccels[i].name; i++)
-        printf("%s\n", hwaccels[i].name);
-    printf("\n");
+        av_log(NULL, AV_LOG_INFO, "%s\n", hwaccels[i].name);
+    av_log(NULL, AV_LOG_INFO, "\n");
    return 0;
 }

@@ -278,7 +278,7 @@ static int opt_map(void *optctx, const char *opt, const char *arg)
 {
    OptionsContext *o = optctx;
    StreamMap *m = NULL;
-    int i, negative = 0, file_idx;
+    int i, negative = 0, file_idx, disabled = 0;
    int sync_file_idx = -1, sync_stream_idx = 0;
    char *p, *sync;
    char *map;
@@ -313,6 +313,11 @@ static int opt_map(void *optctx, const char *opt, const char *arg)
                                       "match any streams.\n", arg);
            exit_program(1);
        }
+        if (input_streams[input_files[sync_file_idx]->ist_index + sync_stream_idx]->user_set_discard == AVDISCARD_ALL) {
+            av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s matches a disabled input "
+                                       "stream.\n", arg);
+            exit_program(1);
+        }
    }


@@ -349,6 +354,10 @@ static int opt_map(void *optctx, const char *opt, const char *arg)
                if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
                            *p == ':' ? p + 1 : p) <= 0)
                    continue;
+                if (input_streams[input_files[file_idx]->ist_index + i]->user_set_discard == AVDISCARD_ALL) {
+                    disabled = 1;
+                    continue;
+                }
                GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
                m = &o->stream_maps[o->nb_stream_maps - 1];

@@ -368,6 +377,10 @@ static int opt_map(void *optctx, const char *opt, const char *arg)
    if (!m) {
        if (allow_unused) {
            av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
+        } else if (disabled) {
+            av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches disabled streams.\n"
+                                       "To ignore this, add a trailing '?' to the map.\n", arg);
+            exit_program(1);
        } else {
            av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
                                       "To ignore this, add a trailing '?' to the map.\n", arg);
@@ -447,7 +460,8 @@ static int opt_map_channel(void *optctx, const char *opt, const char *arg)
    /* allow trailing ? to map_channel */
    if ((allow_unused = strchr(mapchan, '?')))
        *allow_unused = 0;
-    if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
+    if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels ||
+        input_streams[input_files[m->file_idx]->ist_index + m->stream_idx]->user_set_discard == AVDISCARD_ALL) {
        if (allow_unused) {
            av_log(NULL, AV_LOG_VERBOSE, "mapchan: invalid audio channel #%d.%d.%d\n",
                    m->file_idx, m->stream_idx, m->channel_idx);
@@ -495,11 +509,11 @@ static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
 {
    if (!strcmp(arg, "list")) {
        enum AVHWDeviceType type = AV_HWDEVICE_TYPE_NONE;
-        printf("Supported hardware device types:\n");
+        av_log(NULL, AV_LOG_INFO, "Supported hardware device types:\n");
        while ((type = av_hwdevice_iterate_types(type)) !=
               AV_HWDEVICE_TYPE_NONE)
-            printf("%s\n", av_hwdevice_get_type_name(type));
-        printf("\n");
+            av_log(NULL, AV_LOG_INFO, "%s\n", av_hwdevice_get_type_name(type));
+        av_log(NULL, AV_LOG_INFO, "\n");
        exit_program(0);
    } else {
        return hw_device_init_from_string(arg, NULL);
@@ -756,6 +770,13 @@ static void add_input_streams(OptionsContext *o, AVFormatContext *ic)

        MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
        ist->user_set_discard = AVDISCARD_NONE;
+
+        if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
+            (o->audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ||
+            (o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) ||
+            (o->data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA))
+                ist->user_set_discard = AVDISCARD_ALL;
+
        if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
            av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
                    discard_str);
@@ -1670,6 +1691,8 @@ static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, in

    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
+    if (o->nb_filters > 1)
+        av_log(NULL, AV_LOG_ERROR, "Only '-vf %s' read, ignoring remaining -vf options: Use ',' to separate filters\n", ost->filters);

    if (!ost->stream_copy) {
        const char *p = NULL;
@@ -1851,6 +1874,8 @@ static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, in

    MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
    MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
+    if (o->nb_filters > 1)
+        av_log(NULL, AV_LOG_ERROR, "Only '-af %s' read, ignoring remaining -af options: Use ',' to separate filters\n", ost->filters);

    if (!ost->stream_copy) {
        char *sample_fmt = NULL;
@@ -2184,6 +2209,8 @@ static int open_output_file(OptionsContext *o, const char *filename)
                int new_area;
                ist = input_streams[i];
                new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
+                if (ist->user_set_discard == AVDISCARD_ALL)
+                    continue;
                if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
                    new_area = 1;
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
@@ -2205,6 +2232,8 @@ static int open_output_file(OptionsContext *o, const char *filename)
                int score;
                ist = input_streams[i];
                score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
+                if (ist->user_set_discard == AVDISCARD_ALL)
+                    continue;
                if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
                    score > best_score) {
                    best_score = score;
@@ -2226,6 +2255,8 @@ static int open_output_file(OptionsContext *o, const char *filename)
                    AVCodec const *output_codec =
                        avcodec_find_encoder(oc->oformat->subtitle_codec);
                    int input_props = 0, output_props = 0;
+                    if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
+                        continue;
                    if (output_codec)
                        output_descriptor = avcodec_descriptor_get(output_codec->id);
                    if (input_descriptor)
@@ -2247,6 +2278,8 @@ static int open_output_file(OptionsContext *o, const char *filename)
        if (!o->data_disable ) {
            enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
            for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
+                if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
+                    continue;
                if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
                    && input_streams[i]->st->codecpar->codec_id == codec_id )
                    new_data_stream(o, oc, i);
@@ -2285,6 +2318,11 @@ loop_end:
                int src_idx = input_files[map->file_index]->ist_index + map->stream_index;

                ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
+                if (ist->user_set_discard == AVDISCARD_ALL) {
+                    av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
+                           map->file_index, map->stream_index);
+                    exit_program(1);
+                }
                if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
                    continue;
                if(o->   audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
@@ -3150,7 +3188,7 @@ void show_help_default(const char *opt, const char *arg)

    show_usage();

-    printf("Getting help:\n"
+    av_log(NULL, AV_LOG_INFO, "Getting help:\n"
           "    -h      -- print basic options\n"
           "    -h long -- print more options\n"
           "    -h full -- print all options (including all format and codec specific options, very long)\n"
@@ -3188,7 +3226,7 @@ void show_help_default(const char *opt, const char *arg)
                          OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
    show_help_options(options, "Subtitle options:",
                      OPT_SUBTITLE, 0, 0);
-    printf("\n");
+    av_log(NULL, AV_LOG_INFO, "\n");

    if (show_avoptions) {
        int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
@@ -18,6 +18,15 @@
 */

 /*
+ * CHANGES 04.2019
+ * --------------------------------------------------------
+ * - setNativeEnvironmentVariable method added
+ *
+ * CHANGES 02.2019
+ * --------------------------------------------------------
+ * - JavaVM registered via av_jni_set_java_vm()
+ * - registerNewNativeFFmpegPipe() method added
+ *
 * CHANGES 10.2018
 * --------------------------------------------------------
 * - getBuildConf method added
@@ -32,11 +41,14 @@
 */

 #include <pthread.h>
+#include <sys/types.h>
+#include <sys/stat.h>

 #include "config.h"
+#include "libavcodec/jni.h"
 #include "libavutil/bprint.h"
-#include "mobileffmpeg.h"
 #include "fftools_ffmpeg.h"
+#include "mobileffmpeg.h"

 /** Callback data structure */
 struct CallbackData {
@@ -92,7 +104,9 @@ JNINativeMethod configMethods[] = {
    {"getNativeVersion", "()Ljava/lang/String;", (void*) Java_com_arthenica_mobileffmpeg_Config_getNativeVersion},
    {"nativeExecute", "([Ljava/lang/String;)I", (void*) Java_com_arthenica_mobileffmpeg_Config_nativeExecute},
    {"nativeCancel", "()V", (void*) Java_com_arthenica_mobileffmpeg_Config_nativeCancel},
-    {"getNativeBuildConf", "()Ljava/lang/String;", (void*) Java_com_arthenica_mobileffmpeg_Config_getNativeBuildConf}
+    {"registerNewNativeFFmpegPipe", "(Ljava/lang/String;)I", (void*) Java_com_arthenica_mobileffmpeg_Config_registerNewNativeFFmpegPipe},
+    {"getNativeBuildDate", "()Ljava/lang/String;", (void*) Java_com_arthenica_mobileffmpeg_Config_getNativeBuildDate},
+    {"setNativeEnvironmentVariable", "(Ljava/lang/String;Ljava/lang/String;)I", (void*) Java_com_arthenica_mobileffmpeg_Config_setNativeEnvironmentVariable}
 };

 /** Forward declaration for function defined in fftools_ffmpeg.c */
@@ -234,6 +248,9 @@ void monitorNotify() {

 /**
 * Adds log data to the end of callback data list.
+ *
+ * @param level log level
+ * @param data log data
 */
 void logCallbackDataAdd(int level, const char *data) {

@@ -345,10 +362,10 @@ struct CallbackData *callbackDataRemove() {
 /**
 * Callback function for FFmpeg logs.
 *
- * \param pointer to AVClass struct
- * \param level
- * \param format
- * \param arguments
+ * @param ptr pointer to AVClass struct
+ * @param level log level
+ * @param format format string
+ * @param vargs arguments
 */
 void mobileffmpeg_log_callback_function(void *ptr, int level, const char* format, va_list vargs) {
    char line[LOG_LINE_SIZE];
@@ -358,6 +375,10 @@ void mobileffmpeg_log_callback_function(void *ptr, int level, const char* format
    if (level >= 0) {
        level &= 0xff;
    }
+    int activeLogLevel = av_log_get_level();
+    if ((activeLogLevel == AV_LOG_QUIET) || (level > activeLogLevel)) {
+        return;
+    }

    avutil_log_format_line(ptr, level, format, vargs, part, &print_prefix);
    snprintf(line, sizeof(line), "%s%s%s%s", part[0].str, part[1].str, part[2].str, part[3].str);
@@ -377,13 +398,13 @@ void mobileffmpeg_log_callback_function(void *ptr, int level, const char* format
 /**
 * Callback function for FFmpeg statistics.
 *
- * \param frameNumber last processed frame number
- * \param fps frames processed per second
- * \param quality quality of the output stream (video only)
- * \param size size in bytes
- * \param time processed output duration
- * \param bitrate output bit rate in kbits/s
- * \param speed processing speed = processed duration / operation duration
+ * @param frameNumber last processed frame number
+ * @param fps frames processed per second
+ * @param quality quality of the output stream (video only)
+ * @param size size in bytes
+ * @param time processed output duration
+ * @param bitrate output bit rate in kbits/s
+ * @param speed processing speed = processed duration / operation duration
 */
 void mobileffmpeg_statistics_callback_function(int frameNumber, float fps, float quality, int64_t size, int time, double bitrate, double speed) {
    statisticsCallbackDataAdd(frameNumber, fps, quality, size, time, bitrate, speed);
@@ -458,9 +479,9 @@ void *callbackThreadFunction() {
 /**
 * Called when 'mobileffmpeg' native library is loaded.
 *
- * \param vm pointer to the running virtual machine
- * \param reserved reserved
- * \return JNI version needed by 'mobileffmpeg' library
+ * @param vm pointer to the running virtual machine
+ * @param reserved reserved
+ * @return JNI version needed by 'mobileffmpeg' library
 */
 jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env;
@@ -475,7 +496,7 @@ jint JNI_OnLoad(JavaVM *vm, void *reserved) {
        return JNI_FALSE;
    }

-    if ((*env)->RegisterNatives(env, localConfigClass, configMethods, 9) < 0) {
+    if ((*env)->RegisterNatives(env, localConfigClass, configMethods, 11) < 0) {
        LOGE("OnLoad failed to RegisterNatives for class %s.\n", configClassName);
        return JNI_FALSE;
    }
@@ -496,6 +517,8 @@ jint JNI_OnLoad(JavaVM *vm, void *reserved) {
        return JNI_FALSE;
    }

+    av_jni_set_java_vm(vm, NULL);
+
    configClass = (jclass) ((*env)->NewGlobalRef(env, localConfigClass));

    redirectionEnabled = 0;
@@ -512,9 +535,9 @@ jint JNI_OnLoad(JavaVM *vm, void *reserved) {
 /**
 * Sets log level.
 *
- * \param env pointer to native method interface
- * \param reference to the class on which this method is invoked
- * \param log level
+ * @param env pointer to native method interface
+ * @param object reference to the class on which this method is invoked
+ * @param level log level
 */
 JNIEXPORT void JNICALL Java_com_arthenica_mobileffmpeg_Config_setNativeLogLevel(JNIEnv *env, jclass object, jint level) {
    av_log_set_level(level);
@@ -523,8 +546,8 @@ JNIEXPORT void JNICALL Java_com_arthenica_mobileffmpeg_Config_setNativeLogLevel(
 /**
 * Returns current log level.
 *
- * \param env pointer to native method interface
- * \param reference to the class on which this method is invoked
+ * @param env pointer to native method interface
+ * @param object reference to the class on which this method is invoked
 */
 JNIEXPORT jint JNICALL Java_com_arthenica_mobileffmpeg_Config_getNativeLogLevel(JNIEnv *env, jclass object) {
    return av_log_get_level();
@@ -533,8 +556,8 @@ JNIEXPORT jint JNICALL Java_com_arthenica_mobileffmpeg_Config_getNativeLogLevel(
 /**
 * Enables log and statistics redirection.
 *
- * \param env pointer to native method interface
- * \param reference to the class on which this method is invoked
+ * @param env pointer to native method interface
+ * @param object reference to the class on which this method is invoked
 */
 JNIEXPORT void JNICALL Java_com_arthenica_mobileffmpeg_Config_enableNativeRedirection(JNIEnv *env, jclass object) {
    mutexLock();
@@ -560,8 +583,8 @@ JNIEXPORT void JNICALL Java_com_arthenica_mobileffmpeg_Config_enableNativeRedire
 /**
 * Disables log and statistics redirection.
 *
- * \param env pointer to native method interface
- * \param reference to the class on which this method is invoked
+ * @param env pointer to native method interface
+ * @param object reference to the class on which this method is invoked
 */
 JNIEXPORT void JNICALL Java_com_arthenica_mobileffmpeg_Config_disableNativeRedirection(JNIEnv *env, jclass object) {

@@ -584,9 +607,9 @@ JNIEXPORT void JNICALL Java_com_arthenica_mobileffmpeg_Config_disableNativeRedir
 /**
 * Returns FFmpeg version bundled within the library natively.
 *
- * \param env pointer to native method interface
- * \param object reference to the class on which this method is invoked
- * \return FFmpeg version string
+ * @param env pointer to native method interface
+ * @param object reference to the class on which this method is invoked
+ * @return FFmpeg version string
 */
 JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_Config_getNativeFFmpegVersion(JNIEnv *env, jclass object) {
    return (*env)->NewStringUTF(env, FFMPEG_VERSION);
@@ -595,9 +618,9 @@ JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_Config_getNativeFFmpeg
 /**
 * Returns MobileFFmpeg library version natively.
 *
- * \param env pointer to native method interface
- * \param object reference to the class on which this method is invoked
- * \return MobileFFmpeg version string
+ * @param env pointer to native method interface
+ * @param object reference to the class on which this method is invoked
+ * @return MobileFFmpeg version string
 */
 JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_Config_getNativeVersion(JNIEnv *env, jclass object) {
    return (*env)->NewStringUTF(env, MOBILE_FFMPEG_VERSION);
@@ -606,10 +629,10 @@ JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_Config_getNativeVersio
 /**
 * Synchronously executes FFmpeg command natively with arguments provided.
 *
- * \param env pointer to native method interface
- * \param object reference to the class on which this method is invoked
- * \param stringArray reference to the object holding FFmpeg command arguments
- * \return zero on successful execution, non-zero on error
+ * @param env pointer to native method interface
+ * @param object reference to the class on which this method is invoked
+ * @param stringArray reference to the object holding FFmpeg command arguments
+ * @return zero on successful execution, non-zero on error
 */
 JNIEXPORT jint JNICALL Java_com_arthenica_mobileffmpeg_Config_nativeExecute(JNIEnv *env, jclass object, jobjectArray stringArray) {
    jstring *tempArray = NULL;
@@ -661,20 +684,52 @@ JNIEXPORT jint JNICALL Java_com_arthenica_mobileffmpeg_Config_nativeExecute(JNIE
 /**
 * Cancels an ongoing operation natively.
 *
- * \param env pointer to native method interface
- * \param object reference to the class on which this method is invoked
+ * @param env pointer to native method interface
+ * @param object reference to the class on which this method is invoked
 */
 JNIEXPORT void JNICALL Java_com_arthenica_mobileffmpeg_Config_nativeCancel(JNIEnv *env, jclass object) {
    cancel_operation();
 }

 /**
- * Returns build configuration for FFmpeg.
+ * Creates natively a new named pipe to use in FFmpeg operations.
 *
- * \param env pointer to native method interface
- * \param object reference to the class on which this method is invoked
- * \return build configuration string
+ * @param env pointer to native method interface
+ * @param object reference to the class on which this method is invoked
+ * @param ffmpegPipePath full path of ffmpeg pipe
+ * @return zero on successful creation, non-zero on error
 */
-JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_Config_getNativeBuildConf(JNIEnv *env, jclass object) {
-    return (*env)->NewStringUTF(env, FFMPEG_CONFIGURATION);
+JNIEXPORT int JNICALL Java_com_arthenica_mobileffmpeg_Config_registerNewNativeFFmpegPipe(JNIEnv *env, jclass object, jstring ffmpegPipePath) {
+    const char *ffmpegPipePathString = (*env)->GetStringUTFChars(env, ffmpegPipePath, 0);
+
+    return mkfifo(ffmpegPipePathString, S_IRWXU | S_IRWXG | S_IROTH);
+}
+
+/**
+ * Returns MobileFFmpeg library build date natively.
+ *
+ * @param env pointer to native method interface
+ * @param object reference to the class on which this method is invoked
+ * @return MobileFFmpeg library build date
+ */
+JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_Config_getNativeBuildDate(JNIEnv *env, jclass object) {
+    char buildDate[10];
+    sprintf(buildDate, "%d", MOBILE_FFMPEG_BUILD_DATE);
+    return (*env)->NewStringUTF(env, buildDate);
+}
+
+/**
+ * Sets an environment variable natively
+ *
+ * @param env pointer to native method interface
+ * @param object reference to the class on which this method is invoked
+ * @param variableName environment variable name
+ * @param variableValue environment variable value
+ * @return zero on success, non-zero on error
+ */
+JNIEXPORT int JNICALL Java_com_arthenica_mobileffmpeg_Config_setNativeEnvironmentVariable(JNIEnv *env, jclass object, jstring variableName, jstring variableValue) {
+    const char *variableNameString = (*env)->GetStringUTFChars(env, variableName, 0);
+    const char *variableValueString = (*env)->GetStringUTFChars(env, variableValue, 0);
+
+    return setenv(variableNameString, variableValueString, 1);
 }
@@ -27,7 +27,7 @@
 #include "libavutil/ffversion.h"

 /** Library version string */
-#define MOBILE_FFMPEG_VERSION "3.0"
+#define MOBILE_FFMPEG_VERSION "4.2.2"

 /** Defines tag used for Android logging. */
 #define LIB_NAME "mobile-ffmpeg"
@@ -105,9 +105,23 @@ JNIEXPORT void JNICALL Java_com_arthenica_mobileffmpeg_Config_nativeCancel(JNIEn

 /*
 * Class:     com_arthenica_mobileffmpeg_Config
- * Method:    getNativeBuildConf
+ * Method:    registerNewNativeFFmpegPipe
+ * Signature: (Ljava/lang/String;)I
+ */
+JNIEXPORT int JNICALL Java_com_arthenica_mobileffmpeg_Config_registerNewNativeFFmpegPipe(JNIEnv *env, jclass object, jstring ffmpegPipePath);
+
+/*
+ * Class:     com_arthenica_mobileffmpeg_Config
+ * Method:    getNativeBuildDate
 * Signature: ()Ljava/lang/String;
 */
-JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_Config_getNativeBuildConf(JNIEnv *, jclass);
+JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_Config_getNativeBuildDate(JNIEnv *env, jclass object);
+
+/**
+ * Class:     com_arthenica_mobileffmpeg_Config
+ * Method:    setNativeEnvironmentVariable
+ * Signature: (Ljava/lang/String;Ljava/lang/String;)I
+ */
+JNIEXPORT int JNICALL Java_com_arthenica_mobileffmpeg_Config_setNativeEnvironmentVariable(JNIEnv *env, jclass object, jstring variableName, jstring variableValue);

 #endif /* MOBILE_FFMPEG_H */
@@ -18,6 +18,7 @@
 */

 #include "cpu-features.h"
+#include "fftools_ffmpeg.h"
 #include "mobileffmpeg_abidetect.h"

 /** Full name of the Java class that owns native functions in this file. */
@@ -26,15 +27,17 @@ const char *abiDetectClassName = "com/arthenica/mobileffmpeg/AbiDetect";
 /** Prototypes of native functions defined by this file. */
 JNINativeMethod abiDetectMethods[] = {
  {"getNativeAbi", "()Ljava/lang/String;", (void*) Java_com_arthenica_mobileffmpeg_AbiDetect_getNativeAbi},
-  {"getCpuAbi", "()Ljava/lang/String;", (void*) Java_com_arthenica_mobileffmpeg_AbiDetect_getCpuAbi}
+  {"getNativeCpuAbi", "()Ljava/lang/String;", (void*) Java_com_arthenica_mobileffmpeg_AbiDetect_getNativeCpuAbi},
+  {"isNativeLTSBuild", "()Z", (void*) Java_com_arthenica_mobileffmpeg_AbiDetect_isNativeLTSBuild},
+  {"getNativeBuildConf", "()Ljava/lang/String;", (void*) Java_com_arthenica_mobileffmpeg_AbiDetect_getNativeBuildConf}
 };

 /**
 * Called when 'abidetect' native library is loaded.
 *
- * \param vm pointer to the running virtual machine
- * \param reserved reserved
- * \return JNI version needed by 'abidetect' library
+ * @param vm pointer to the running virtual machine
+ * @param reserved reserved
+ * @return JNI version needed by 'abidetect' library
 */
 jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    JNIEnv *env;
@@ -49,7 +52,7 @@ jint JNI_OnLoad(JavaVM *vm, void *reserved) {
        return JNI_FALSE;
    }

-    if ((*env)->RegisterNatives(env, abiDetectClass, abiDetectMethods, 2) < 0) {
+    if ((*env)->RegisterNatives(env, abiDetectClass, abiDetectMethods, 4) < 0) {
        LOGE("OnLoad failed to RegisterNatives for class %s.\n", abiDetectClassName);
        return JNI_FALSE;
    }
@@ -60,9 +63,9 @@ jint JNI_OnLoad(JavaVM *vm, void *reserved) {
 /**
 * Returns loaded ABI name.
 *
- * \param env pointer to native method interface
- * \param object reference to the class on which this method is invoked
- * \return loaded ABI name as UTF string
+ * @param env pointer to native method interface
+ * @param object reference to the class on which this method is invoked
+ * @return loaded ABI name as UTF string
 */
 JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_AbiDetect_getNativeAbi(JNIEnv *env, jclass object) {

@@ -83,11 +86,11 @@ JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_AbiDetect_getNativeAbi
 /**
 * Returns ABI name of the running cpu.
 *
- * \param env pointer to native method interface
- * \param object reference to the class on which this method is invoked
- * \return ABI name of the running cpu as UTF string
+ * @param env pointer to native method interface
+ * @param object reference to the class on which this method is invoked
+ * @return ABI name of the running cpu as UTF string
 */
-JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_AbiDetect_getCpuAbi(JNIEnv *env, jclass object) {
+JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_AbiDetect_getNativeCpuAbi(JNIEnv *env, jclass object) {
    AndroidCpuFamily family = android_getCpuFamily();

    if (family == ANDROID_CPU_FAMILY_ARM) {
@@ -113,3 +116,29 @@ JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_AbiDetect_getCpuAbi(JN
        return (*env)->NewStringUTF(env, ABI_UNKNOWN);
    }
 }
+
+/**
+ * Returns whether MobileFFmpeg release is a long term release or not.
+ *
+ * @param env pointer to native method interface
+ * @param object reference to the class on which this method is invoked
+ * @return YES or NO
+ */
+JNIEXPORT jboolean JNICALL Java_com_arthenica_mobileffmpeg_AbiDetect_isNativeLTSBuild(JNIEnv *env, jclass object) {
+    #if defined(MOBILE_FFMPEG_LTS)
+        return JNI_TRUE;
+    #else
+        return JNI_FALSE;
+    #endif
+}
+
+/**
+ * Returns build configuration for FFmpeg.
+ *
+ * @param env pointer to native method interface
+ * @param object reference to the class on which this method is invoked
+ * @return build configuration string
+ */
+JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_AbiDetect_getNativeBuildConf(JNIEnv *env, jclass object) {
+    return (*env)->NewStringUTF(env, FFMPEG_CONFIGURATION);
+}
@@ -53,10 +53,23 @@ JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_AbiDetect_getNativeAbi

 /*
 * Class:     com_arthenica_mobileffmpeg_AbiDetect
- * Method:    getCpuAbi
+ * Method:    getNativeCpuAbi
 * Signature: ()Ljava/lang/String;
 */
-JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_AbiDetect_getCpuAbi(JNIEnv *, jclass);
+JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_AbiDetect_getNativeCpuAbi(JNIEnv *, jclass);

+/**
+ * Class:     com_arthenica_mobileffmpeg_AbiDetect
+ * Method:    isNativeLTSBuild
+ * Signature: ()Z
+ */
+JNIEXPORT jboolean JNICALL Java_com_arthenica_mobileffmpeg_AbiDetect_isNativeLTSBuild(JNIEnv *, jclass);
+
+/*
+ * Class:     com_arthenica_mobileffmpeg_AbiDetect
+ * Method:    getNativeBuildConf
+ * Signature: ()Ljava/lang/String;
+ */
+JNIEXPORT jstring JNICALL Java_com_arthenica_mobileffmpeg_AbiDetect_getNativeBuildConf(JNIEnv *, jclass);

 #endif /* MOBILE_FFMPEG_ABIDETECT_H */
@@ -19,6 +19,8 @@

 package com.arthenica.mobileffmpeg;

+import android.os.Build;
+
 /**
 * <p>This class is used to detect running ABI name using Android's <code>cpufeatures</code>
 * library.
@@ -30,6 +32,11 @@ public class AbiDetect {

    static {
        armV7aNeonLoaded = false;
+
+        /* LOAD NOT-LOADED LIBRARIES ON API < 21 */
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+            System.loadLibrary("cpufeatures");
+        }
        System.loadLibrary("mobileffmpeg-abidetect");

        /* ALL LIBRARIES LOADED AT STARTUP */
@@ -37,6 +44,10 @@ public class AbiDetect {
        FFmpeg.class.getName();
    }

+    static final String ARM_V7A = "arm-v7a";
+
+    static final String ARM_V7A_NEON = "arm-v7a-neon";
+
    private static boolean armV7aNeonLoaded;

    /**
@@ -56,24 +67,38 @@ public class AbiDetect {
     */
    public static String getAbi() {
        if (armV7aNeonLoaded) {
-            return "arm-v7a-neon";
+            return ARM_V7A_NEON;
        } else {
            return getNativeAbi();
        }
    }

    /**
-     * <p>Returns native loaded ABI name.
+     * <p>Returns loaded ABI name.
     *
-     * @return native loaded ABI name
+     * @return loaded ABI name
     */
-    private native static String getNativeAbi();
+    public native static String getNativeAbi();

    /**
     * <p>Returns ABI name of the running cpu.
     *
     * @return ABI name of the running cpu
     */
-    public native static String getCpuAbi();
+    public native static String getNativeCpuAbi();
+
+    /**
+     * <p>Returns whether MobileFFmpeg release is a long term release or not.
+     *
+     * @return YES or NO
+     */
+    native static boolean isNativeLTSBuild();
+
+    /**
+     * <p>Returns build configuration for <code>FFmpeg</code>.
+     *
+     * @return build configuration string
+     */
+    native static String getNativeBuildConf();

 }
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2019 Taner Sener
+ *
+ * This file is part of MobileFFmpeg.
+ *
+ * MobileFFmpeg is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * MobileFFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with MobileFFmpeg.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.arthenica.mobileffmpeg;
+
+import android.content.Context;
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraManager;
+import android.hardware.camera2.CameraMetadata;
+import android.os.Build;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static android.content.Context.CAMERA_SERVICE;
+import static com.arthenica.mobileffmpeg.Config.TAG;
+
+class CameraSupport {
+
+    /**
+     * <p>Compatibility method for extracting supported camera ids.
+     *
+     * @param context application context
+     * @return returns the list of supported camera ids
+     */
+    static List<String> extractSupportedCameraIds(final Context context) {
+        final List<String> detectedCameraIdList = new ArrayList<>();
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            try {
+                final CameraManager manager = (CameraManager) context.getSystemService(CAMERA_SERVICE);
+                if (manager != null) {
+                    final String[] cameraIdList = manager.getCameraIdList();
+
+                    for (String cameraId : cameraIdList) {
+                        final CameraCharacteristics chars = manager.getCameraCharacteristics(cameraId);
+                        final Integer cameraSupport = chars.get(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL);
+
+                        if (cameraSupport != null && cameraSupport == CameraMetadata.INFO_SUPPORTED_HARDWARE_LEVEL_LEGACY) {
+                            Log.d(TAG, "Detected camera with id " + cameraId + " has LEGACY hardware level which is not supported by Android Camera2 NDK API.");
+                        } else if (cameraSupport != null) {
+                            detectedCameraIdList.add(cameraId);
+                        }
+                    }
+                }
+            } catch (final CameraAccessException e) {
+                Log.w(TAG, "Detecting camera ids failed.", e);
+            }
+        }
+
+        return detectedCameraIdList;
+    }
+
+}
@@ -20,17 +20,23 @@
 package com.arthenica.mobileffmpeg;

 import android.content.Context;
-import android.system.ErrnoException;
-import android.system.Os;
+import android.hardware.camera2.CameraAccessException;
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CameraManager;
+import android.hardware.camera2.CameraMetadata;
+import android.os.Build;
 import android.util.Log;

 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;

+import static android.content.Context.CAMERA_SERVICE;
+import static com.arthenica.mobileffmpeg.FFmpeg.getBuildDate;
 import static com.arthenica.mobileffmpeg.FFmpeg.getVersion;

 /**
@@ -64,6 +70,8 @@ public class Config {
     */
    public static final String TAG = "mobile-ffmpeg";

+    public static final String MOBILE_FFMPEG_PIPE_PREFIX = "mf_pipe_";
+
    private static LogCallback logCallbackFunction;

    private static Level activeLogLevel;
@@ -76,25 +84,53 @@ public class Config {

    private static boolean runningSystemCommand;

+    private static int lastCreatedPipeIndex;
+
    static {

        Log.i(Config.TAG, "Loading mobile-ffmpeg.");

-        /* ALL LIBRARIES LOADED AT STARTUP */
-        Abi cpuAbi = Abi.from(AbiDetect.getCpuAbi());
+        /* LOAD NOT-LOADED LIBRARIES ON API < 21 */
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+            final List<String> externalLibrariesEnabled = getExternalLibraries();
+            if (externalLibrariesEnabled.contains("tesseract") || externalLibrariesEnabled.contains("x265") || externalLibrariesEnabled.contains("snappy") || externalLibrariesEnabled.contains("openh264")) {
+                // libc++_shared.so included only when tesseract or x265 is enabled
+                System.loadLibrary("c++_shared");
+            }
+            System.loadLibrary("cpufeatures");
+            System.loadLibrary("avutil");
+            System.loadLibrary("swscale");
+            System.loadLibrary("swresample");
+            System.loadLibrary("avcodec");
+            System.loadLibrary("avformat");
+            System.loadLibrary("avfilter");
+            System.loadLibrary("avdevice");
+        }
+
+        /* ALL MOBILE-FFMPEG LIBRARIES LOADED AT STARTUP */
+        Abi.class.getName();
        FFmpeg.class.getName();

        /*
         * NEON supported arm-v7a library has a different name
         */
        boolean nativeLibraryLoaded = false;
-        if (cpuAbi == Abi.ABI_ARMV7A_NEON) {
-            try {
-                System.loadLibrary("mobileffmpeg-armv7a-neon");
-                nativeLibraryLoaded = true;
+        if (AbiDetect.ARM_V7A.equals(AbiDetect.getNativeAbi())) {
+            if (AbiDetect.isNativeLTSBuild()) {
+
+                /*
+                 * IF CPU SUPPORTS ARM-V7A-NEON THE TRY TO LOAD IT FIRST. IF NOT LOAD DEFAULT ARM-V7A
+                 */
+
+                try {
+                    System.loadLibrary("mobileffmpeg-armv7a-neon");
+                    nativeLibraryLoaded = true;
+                    AbiDetect.setArmV7aNeonLoaded(true);
+                } catch (final UnsatisfiedLinkError e) {
+                    Log.i(Config.TAG, "NEON supported armeabi-v7a library not found. Loading default armeabi-v7a library.", e);
+                }
+            } else {
                AbiDetect.setArmV7aNeonLoaded(true);
-            } catch (final UnsatisfiedLinkError e) {
-                Log.i(Config.TAG, "NEON supported armeabi-v7a library not found. Loading default armeabi-v7a library.", e);
            }
        }

@@ -102,7 +138,7 @@ public class Config {
            System.loadLibrary("mobileffmpeg");
        }

-        Log.i(Config.TAG, String.format("Loaded mobile-ffmpeg-%s-%s-%s.", getPackageName(), AbiDetect.getAbi(), getVersion()));
+        Log.i(Config.TAG, String.format("Loaded mobile-ffmpeg-%s-%s-%s-%s.", getPackageName(), AbiDetect.getAbi(), getVersion(), getBuildDate()));

        /* NATIVE LOG LEVEL IS RECEIVED ONLY ON STARTUP */
        activeLogLevel = Level.from(getNativeLogLevel());
@@ -115,6 +151,7 @@ public class Config {
        systemCommandOutputReference.set(new StringBuffer());

        runningSystemCommand = false;
+        lastCreatedPipeIndex = 0;
    }

    /**
@@ -292,10 +329,10 @@ public class Config {
     * <p>Sets and overrides <code>fontconfig</code> configuration directory.
     *
     * @param path directory which contains fontconfig configuration (fonts.conf)
-     * @throws ErrnoException if an error occurs
+     * @return zero on success, non-zero on error
     */
-    public static void setFontconfigConfigurationPath(final String path) throws ErrnoException {
-        Os.setenv("FONTCONFIG_PATH", path, true);
+    public static int setFontconfigConfigurationPath(final String path) {
+        return Config.setNativeEnvironmentVariable("FONTCONFIG_PATH", path);
    }

    /**
@@ -369,7 +406,7 @@ public class Config {

            Log.d(TAG, String.format("Font directory %s registered successfully.", fontDirectoryPath));

-        } catch (final ErrnoException | IOException e) {
+        } catch (final IOException e) {
            Log.e(TAG, String.format("Failed to set font directory: %s.", fontDirectoryPath), e);
        } finally {
            if (reference.get() != null) {
@@ -402,15 +439,58 @@ public class Config {
        return Packages.getExternalLibraries();
    }

+    /**
+     * <p>Creates a new named pipe to use in <code>FFmpeg</code> operations.
+     *
+     * <p>Please note that creator is responsible of closing created pipes.
+     *
+     * @param context application context
+     * @return the full path of named pipe
+     */
+    public static String registerNewFFmpegPipe(final Context context) {
+
+        // PIPES ARE CREATED UNDER THE CACHE DIRECTORY
+        final File cacheDir = context.getCacheDir();
+
+        final String newFFmpegPipePath = cacheDir + File.separator + MOBILE_FFMPEG_PIPE_PREFIX + (++lastCreatedPipeIndex);
+
+        // FIRST CLOSE OLD PIPES WITH THE SAME NAME
+        closeFFmpegPipe(newFFmpegPipePath);
+
+        int rc = registerNewNativeFFmpegPipe(newFFmpegPipePath);
+        if (rc == 0) {
+            return newFFmpegPipePath;
+        } else {
+            Log.e(TAG, String.format("Failed to register new FFmpeg pipe %s. Operation failed with rc=%d.", newFFmpegPipePath, rc));
+            return null;
+        }
+    }
+
+    /**
+     * <p>Closes a previously created <code>FFmpeg</code> pipe.
+     *
+     * @param ffmpegPipePath full path of ffmpeg pipe
+     */
+    public static void closeFFmpegPipe(final String ffmpegPipePath) {
+        File file = new File(ffmpegPipePath);
+        if (file.exists()) {
+            file.delete();
+        }
+    }
+
    /**
     * Executes system command. System command is not logged to output.
     *
     * @param arguments                   command arguments
     * @param commandOutputEndPatternList list of patterns which will indicate that operation has ended
+     * @param successPattern              success pattern
     * @param timeout                     execution timeout
     * @return return code
     */
-    static int systemExecute(final String[] arguments, final List<String> commandOutputEndPatternList, final long timeout) {
+    static int systemExecute(final String[] arguments, final List<String> commandOutputEndPatternList, final String successPattern, final long timeout) {
+        if (successPattern != null) {
+            commandOutputEndPatternList.add(successPattern);
+        }
        systemCommandOutputReference.set(new StringBuffer());
        runningSystemCommand = true;

@@ -433,7 +513,12 @@ public class Config {

        nativeCancel();

-        return rc;
+        StringBuffer stringBuffer = systemCommandOutputReference.get();
+        if ((successPattern != null) && (stringBuffer != null) && stringBuffer.toString().contains(successPattern)) {
+            return 0;
+        } else {
+            return rc;
+        }
    }

    private static boolean systemCommandOutputContainsPattern(final List<String> patternList) {
@@ -456,6 +541,22 @@ public class Config {
        return systemCommandOutputReference.get().toString();
    }

+    /**
+     * Returns the list of camera ids supported.
+     *
+     * @param context application context
+     * @return the list of camera ids supported or an empty list if no supported camera is found
+     */
+    public static List<String> getSupportedCameraIds(final Context context) {
+        final List<String> detectedCameraIdList = new ArrayList<>();
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            detectedCameraIdList.addAll(CameraSupport.extractSupportedCameraIds(context));
+        }
+
+        return detectedCameraIdList;
+    }
+
    /**
     * <p>Enables native redirection. Necessary for log and statistics callback functions.
     */
@@ -509,10 +610,29 @@ public class Config {
    native static void nativeCancel();

    /**
-     * <p>Returns build configuration for <code>FFmpeg</code>.
+     * <p>Creates natively a new named pipe to use in <code>FFmpeg</code> operations.
     *
-     * @return build configuration string
+     * <p>Please note that creator is responsible of closing created pipes.
+     *
+     * @param ffmpegPipePath full path of ffmpeg pipe
+     * @return zero on successful creation, non-zero on error
     */
-    native static String getNativeBuildConf();
+    native static int registerNewNativeFFmpegPipe(final String ffmpegPipePath);
+
+    /**
+     * <p>Returns MobileFFmpeg library build date natively.
+     *
+     * @return MobileFFmpeg library build date
+     */
+    native static String getNativeBuildDate();
+
+    /**
+     * <p>Sets an environment variable natively.
+     *
+     * @param variableName  environment variable name
+     * @param variableValue environment variable value
+     * @return zero on success, non-zero on error
+     */
+    native static int setNativeEnvironmentVariable(final String variableName, final String variableValue);

 }
@@ -21,6 +21,7 @@ package com.arthenica.mobileffmpeg;

 import android.util.Log;

+import java.util.ArrayList;
 import java.util.Arrays;

 /**
@@ -79,7 +80,11 @@ public class FFmpeg {
     * @return MobileFFmpeg version
     */
    public static String getVersion() {
-        return Config.getNativeVersion();
+        if (AbiDetect.isNativeLTSBuild()) {
+            return String.format("%s-lts", Config.getNativeVersion());
+        } else {
+            return Config.getNativeVersion();
+        }
    }

    /**
@@ -169,7 +174,7 @@ public class FFmpeg {
     * @since 3.0
     */
    public static MediaInformation getMediaInformation(final String path, final Long timeout) {
-        int rc = Config.systemExecute(new String[]{"-v", "info", "-hide_banner", "-i", path, "-f", "null", "-"}, Arrays.asList("Press [q] to stop, [?] for help", "No such file or directory", "Input/output error", "Conversion failed"), timeout);
+        int rc = Config.systemExecute(new String[]{"-v", "info", "-hide_banner", "-i", path}, new ArrayList<>(Arrays.asList("Press [q] to stop, [?] for help", "No such file or directory", "Input/output error", "Conversion failed", "HTTP error")), "At least one output file must be specified", timeout);

        if (rc == 0) {
            return MediaInformationParser.from(Config.getSystemCommandOutput());
@@ -179,4 +184,22 @@ public class FFmpeg {
        }
    }

+    /**
+     * <p>Returns whether MobileFFmpeg release is a long term release or not.
+     *
+     * @return YES or NO
+     */
+    public static boolean isLTSBuild() {
+        return AbiDetect.isNativeLTSBuild();
+    }
+
+    /**
+     * <p>Returns MobileFFmpeg library build date.
+     *
+     * @return MobileFFmpeg library build date
+     */
+    public static String getBuildDate() {
+        return Config.getNativeBuildDate();
+    }
+
 }
@@ -67,12 +67,14 @@ public class MediaInformationParser {
        if (rawCommandOutput != null) {
            final String[] split = rawCommandOutput.split("\n");
            boolean metadata = false;
+            boolean sidedata = false;
            StreamInformation lastCreatedStream = null;
            final StringBuilder rawInformation = new StringBuilder();

            for (final String outputLine : split) {
                if (outputLine.startsWith("[")) {
                    metadata = false;
+                    sidedata = false;
                    continue;
                }

@@ -80,23 +82,30 @@ public class MediaInformationParser {

                if (trimmedLine.startsWith("Input")) {
                    metadata = false;
+                    sidedata = false;
                    lastCreatedStream = null;
                    Pair<String, String> pair = parseInputBlock(trimmedLine);
                    mediaInformation.setFormat(pair.getFirst());
                    mediaInformation.setPath(pair.getSecond());
                } else if (trimmedLine.startsWith("Duration")) {
                    metadata = false;
+                    sidedata = false;
                    lastCreatedStream = null;
                    Trio<Long, Long, Long> trio = parseDurationBlock(trimmedLine);
                    mediaInformation.setDuration(trio.getFirst());
                    mediaInformation.setStartTime(trio.getSecond());
                    mediaInformation.setBitrate(trio.getThird());
-                } else if (trimmedLine.startsWith("Metadata")) {
+                } else if (trimmedLine.toLowerCase(Locale.ENGLISH).startsWith("metadata")) {
+                    sidedata = false;
                    metadata = true;
+                } else if (trimmedLine.toLowerCase(Locale.ENGLISH).startsWith("side data")) {
+                    metadata = false;
+                    sidedata = true;
                } else if (trimmedLine.startsWith("Stream mapping") || trimmedLine.startsWith("Press [q] to stop") || trimmedLine.startsWith("Output")) {
                    break;
                } else if (trimmedLine.startsWith("Stream")) {
                    metadata = false;
+                    sidedata = false;
                    lastCreatedStream = MediaInformationParser.parseStreamBlock(trimmedLine);
                    mediaInformation.addStream(lastCreatedStream);
                } else if (metadata) {
@@ -109,6 +118,14 @@ public class MediaInformationParser {
                            mediaInformation.addMetadata(pair.getFirst(), pair.getSecond());
                        }
                    }
+                } else if (sidedata) {
+                    Pair<String, String> pair = parseMetadataBlock(trimmedLine);
+
+                    if (pair.getFirst() != null && pair.getSecond() != null) {
+                        if (lastCreatedStream != null) {
+                            lastCreatedStream.addSidedata(pair.getFirst(), pair.getSecond());
+                        }
+                    }
                }

                rawInformation.append(outputLine);
@@ -189,14 +206,14 @@ public class MediaInformationParser {
                            pEnd = count(part2, ")");
                        }

-                        streamInformation.setFullFormat(part2.toLowerCase().trim());
-                        streamInformation.setFormat(part2.replaceAll("\\(.*\\)", "").toLowerCase().trim());
+                        streamInformation.setFullFormat(part2.toLowerCase(Locale.getDefault()).trim());
+                        streamInformation.setFormat(part2.replaceAll("\\(.*\\)", "").toLowerCase(Locale.getDefault()).trim());
                    }

                    lastUsedPart++;
                    String videoDimensionPart = safeGet(parts, lastUsedPart);
                    if (videoDimensionPart != null) {
-                        String videoLayout = videoDimensionPart.toLowerCase().trim();
+                        String videoLayout = videoDimensionPart.toLowerCase(Locale.getDefault()).trim();
                        Pair<Long, Long> dimensions = parseVideoDimensions(videoLayout);
                        streamInformation.setWidth(dimensions.getFirst());
                        streamInformation.setHeight(dimensions.getSecond());
@@ -205,7 +222,7 @@ public class MediaInformationParser {
                    }

                    for (int i = lastUsedPart + 1; i < parts.length; i++) {
-                        String part = parts[i].replaceAll("\\(.*\\)", "").toLowerCase();
+                        String part = parts[i].replaceAll("\\(.*\\)", "").toLowerCase(Locale.getDefault());

                        if (part.contains("kb/s")) {
                            streamInformation.setBitrate(toLongObject(part.replaceAll("kb/s", "").trim()));
@@ -219,19 +236,22 @@ public class MediaInformationParser {
                            streamInformation.setCodecTimeBase(part.replaceAll("tbc", "").trim());
                        }
                    }
-                }
-                if ("audio".equals(type)) {
+                } else if ("audio".equals(type)) {
                    if (part2 != null) {
                        streamInformation.setSampleRate(parseAudioStreamSampleRate(part2));
                    }
                    if (part3 != null) {
-                        streamInformation.setChannelLayout(part3.toLowerCase().trim());
+                        streamInformation.setChannelLayout(part3.toLowerCase(Locale.getDefault()).trim());
                    }
                    if (part4 != null) {
-                        streamInformation.setSampleFormat(part4.toLowerCase().trim());
+                        streamInformation.setSampleFormat(part4.toLowerCase(Locale.getDefault()).trim());
                    }
                    if (part5 != null) {
-                        streamInformation.setBitrate(toLongObject(part5.toLowerCase().replaceAll("\\(.*\\)", "").replaceAll("kb/s", "").trim()));
+                        streamInformation.setBitrate(toLongObject(part5.toLowerCase(Locale.getDefault()).replaceAll("\\(.*\\)", "").replaceAll("kb/s", "").trim()));
+                    }
+                } else if ("data".equals(type)) {
+                    if (part2 != null) {
+                        streamInformation.setBitrate(toLongObject(part2.toLowerCase(Locale.getDefault()).replaceAll("\\(.*\\)", "").replaceAll("kb/s", "").trim()));
                    }
                }
            }
@@ -245,7 +265,7 @@ public class MediaInformationParser {
        Long height = null;

        if (input != null) {
-            final String[] dimensions = input.toLowerCase().replaceAll("\\[.*\\]", "").trim().split("x");
+            final String[] dimensions = input.toLowerCase(Locale.getDefault()).replaceAll("\\[.*\\]", "").trim().split("x");
            width = toLongObject(safeGet(dimensions, 0));
            height = toLongObject(safeGet(dimensions, 1));
        }
@@ -257,7 +277,7 @@ public class MediaInformationParser {
        if (input != null) {
            String[] parts = input.replaceAll("\\[", "").replaceAll("\\]", "").split(" ");
            for (int i = 0; i < parts.length; i++) {
-                if (parts[i].toLowerCase().equals("sar")) {
+                if (parts[i].toLowerCase(Locale.getDefault()).equals("sar")) {
                    return safeGet(parts, i + 1);
                }
            }
@@ -270,7 +290,7 @@ public class MediaInformationParser {
        if (input != null) {
            String[] parts = input.replaceAll("\\[", "").replaceAll("\\]", "").split(" ");
            for (int i = 0; i < parts.length; i++) {
-                if (parts[i].toLowerCase().equals("dar")) {
+                if (parts[i].toLowerCase(Locale.getDefault()).equals("dar")) {
                    return safeGet(parts, i + 1);
                }
            }
@@ -284,7 +304,7 @@ public class MediaInformationParser {
            boolean khz = false;
            boolean mhz = false;

-            String lowerCase = input.toLowerCase();
+            String lowerCase = input.toLowerCase(Locale.getDefault());
            if (lowerCase.contains("khz")) {
                khz = true;
            }
@@ -312,10 +332,12 @@ public class MediaInformationParser {

    static String parseStreamType(final String input) {
        if (input != null) {
-            if (input.toLowerCase().contains("audio:")) {
+            if (input.toLowerCase(Locale.getDefault()).contains("audio:")) {
                return "audio";
-            } else if (input.toLowerCase().contains("video:")) {
+            } else if (input.toLowerCase(Locale.getDefault()).contains("video:")) {
                return "video";
+            } else if (input.toLowerCase(Locale.getDefault()).contains("data:")) {
+                return "data";
            }
        }

@@ -324,10 +346,11 @@ public class MediaInformationParser {

    static String parseStreamCodec(final String input) {
        if (input != null) {
-            return input.toLowerCase()
+            return input.toLowerCase(Locale.getDefault())
                    .replaceAll("\\(.*\\)", "")
                    .replaceAll("video:", "")
                    .replaceAll("audio:", "")
+                    .replaceAll("data:", "")
                    .trim();
        }

@@ -336,9 +359,10 @@ public class MediaInformationParser {

    static String parseStreamFullCodec(final String input) {
        if (input != null) {
-            return input.toLowerCase()
+            return input.toLowerCase(Locale.getDefault())
                    .replaceAll("video:", "")
                    .replaceAll("audio:", "")
+                    .replaceAll("data:", "")
                    .trim();
        }

@@ -34,7 +34,6 @@ class Packages {

    static {
        supportedExternalLibraries = new ArrayList<>();
-        supportedExternalLibraries.add("chromaprint");
        supportedExternalLibraries.add("fontconfig");
        supportedExternalLibraries.add("freetype");
        supportedExternalLibraries.add("fribidi");
@@ -53,9 +52,10 @@ class Packages {
        supportedExternalLibraries.add("libwebp");
        supportedExternalLibraries.add("libxml2");
        supportedExternalLibraries.add("opencore-amr");
+        supportedExternalLibraries.add("openh264");
        supportedExternalLibraries.add("opus");
+        supportedExternalLibraries.add("sdl2");
        supportedExternalLibraries.add("shine");
-        supportedExternalLibraries.add("sdl");
        supportedExternalLibraries.add("snappy");
        supportedExternalLibraries.add("soxr");
        supportedExternalLibraries.add("speex");
@@ -73,7 +73,7 @@ class Packages {
     * @return enabled external libraries
     */
    static List<String> getExternalLibraries() {
-        final String buildConfiguration = Config.getNativeBuildConf();
+        final String buildConfiguration = AbiDetect.getNativeBuildConf();

        final List<String> enabledLibraryList = new ArrayList<>();
        for (String supportedExternalLibrary : supportedExternalLibraries) {
@@ -100,7 +100,6 @@ class Packages {
        final boolean gnutls = externalLibraryList.contains("gnutls");
        final boolean xvid = externalLibraryList.contains("xvid");

-        boolean min = false;
        boolean minGpl = false;
        boolean https = false;
        boolean httpsGpl = false;
@@ -128,14 +127,11 @@ class Packages {
        } else {
            if (gnutls) {
                https = true;
-            } else {
-                min = true;
            }
        }

        if (fullGpl) {
-            if (externalLibraryList.contains("chromaprint") &&
-                    externalLibraryList.contains("fontconfig") &&
+            if (externalLibraryList.contains("fontconfig") &&
                    externalLibraryList.contains("freetype") &&
                    externalLibraryList.contains("fribidi") &&
                    externalLibraryList.contains("gmp") &&
@@ -155,11 +151,9 @@ class Packages {
                    externalLibraryList.contains("opencore-amr") &&
                    externalLibraryList.contains("opus") &&
                    externalLibraryList.contains("shine") &&
-                    externalLibraryList.contains("sdl") &&
                    externalLibraryList.contains("snappy") &&
                    externalLibraryList.contains("soxr") &&
                    externalLibraryList.contains("speex") &&
-                    externalLibraryList.contains("tesseract") &&
                    externalLibraryList.contains("twolame") &&
                    externalLibraryList.contains("wavpack") &&
                    externalLibraryList.contains("x264") &&
@@ -172,8 +166,7 @@ class Packages {
        }

        if (full) {
-            if (externalLibraryList.contains("chromaprint") &&
-                    externalLibraryList.contains("fontconfig") &&
+            if (externalLibraryList.contains("fontconfig") &&
                    externalLibraryList.contains("freetype") &&
                    externalLibraryList.contains("fribidi") &&
                    externalLibraryList.contains("gmp") &&
@@ -192,11 +185,9 @@ class Packages {
                    externalLibraryList.contains("opencore-amr") &&
                    externalLibraryList.contains("opus") &&
                    externalLibraryList.contains("shine") &&
-                    externalLibraryList.contains("sdl") &&
                    externalLibraryList.contains("snappy") &&
                    externalLibraryList.contains("soxr") &&
                    externalLibraryList.contains("speex") &&
-                    externalLibraryList.contains("tesseract") &&
                    externalLibraryList.contains("twolame") &&
                    externalLibraryList.contains("wavpack")) {
                return "full";
@@ -273,7 +264,11 @@ class Packages {
            }
        }

-        return "min";
+        if (externalLibraryList.size() == 0) {
+            return "min";
+        } else {
+            return "custom";
+        }
    }

 }
@@ -84,8 +84,14 @@ public class StreamInformation {
     */
    private final Map<String, String> metadata;

+    /**
+     * Side data map
+     */
+    private final Map<String, String> sidedata;
+
    public StreamInformation() {
        this.metadata = new HashMap<>();
+        this.sidedata = new HashMap<>();
    }

    /**
@@ -422,6 +428,16 @@ public class StreamInformation {
        this.metadata.put(key, value);
    }

+    /**
+     * Retrieves metadata value associated with this key.
+     *
+     * @param key metadata key
+     * @return metadata value associated with this key
+     */
+    public String getMetadata(String key) {
+        return this.metadata.get(key);
+    }
+
    /**
     * Returns all metadata entries.
     *
@@ -431,4 +447,33 @@ public class StreamInformation {
        return this.metadata.entrySet();
    }

+    /**
+     * Adds side data.
+     *
+     * @param key side data key
+     * @param value side data value
+     */
+    public void addSidedata(String key, String value) {
+        this.sidedata.put(key, value);
+    }
+
+    /**
+     * Retrieves side data value associated with this key.
+     *
+     * @param key side data key
+     * @return side data value associated with this key
+     */
+    public String getSidedata(String key) {
+        return this.sidedata.get(key);
+    }
+
+    /**
+     * Returns all side data entries.
+     *
+     * @return set of site data entries
+     */
+    public Set<Map.Entry<String, String>> getSidedataEntries() {
+        return this.sidedata.entrySet();
+    }
+
 }
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2018-2019 Taner Sener
+ *
+ * This file is part of MobileFFmpeg.
+ *
+ * MobileFFmpeg is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * MobileFFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with MobileFFmpeg.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.arthenica.mobileffmpeg.util;
+
+import android.os.AsyncTask;
+
+import com.arthenica.mobileffmpeg.FFmpeg;
+
+public class AsyncExecuteTask extends AsyncTask<String, Integer, Integer> {
+
+    private final ExecuteCallback executeCallback;
+
+    public AsyncExecuteTask(final ExecuteCallback executeCallback) {
+        this.executeCallback = executeCallback;
+    }
+
+    @Override
+    protected Integer doInBackground(final String... arguments) {
+        return FFmpeg.execute(arguments);
+    }
+
+    @Override
+    protected void onPostExecute(final Integer rc) {
+        if (executeCallback != null) {
+            executeCallback.apply(rc, FFmpeg.getLastCommandOutput());
+        }
+    }
+
+}
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2018-2019 Taner Sener
+ *
+ * This file is part of MobileFFmpeg.
+ *
+ * MobileFFmpeg is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * MobileFFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with MobileFFmpeg.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.arthenica.mobileffmpeg.util;
+
+import android.os.AsyncTask;
+
+import com.arthenica.mobileffmpeg.FFmpeg;
+import com.arthenica.mobileffmpeg.MediaInformation;
+
+public class AsyncGetMediaInformationTask extends AsyncTask<String, MediaInformation, MediaInformation> {
+
+    private final GetMediaInformationCallback getMediaInformationCallback;
+
+    public AsyncGetMediaInformationTask(final GetMediaInformationCallback getMediaInformationCallback) {
+        this.getMediaInformationCallback = getMediaInformationCallback;
+    }
+
+    @Override
+    protected MediaInformation doInBackground(final String... arguments) {
+        return FFmpeg.getMediaInformation(arguments[0]);
+    }
+
+    @Override
+    protected void onPostExecute(final MediaInformation mediaInformation) {
+        if (getMediaInformationCallback != null) {
+            getMediaInformationCallback.apply(mediaInformation);
+        }
+    }
+
+}
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2018 Taner Sener
+ *
+ * This file is part of MobileFFmpeg.
+ *
+ * MobileFFmpeg is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * MobileFFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with MobileFFmpeg.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.arthenica.mobileffmpeg.util;
+
+/**
+ * <p>Represents a callback function to receive execution result.
+ *
+ * @author Taner Sener
+ * @since v2.1
+ */
+@FunctionalInterface
+public interface ExecuteCallback {
+
+    void apply(int returnCode, String executeOutput);
+
+}
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2018 Taner Sener
+ *
+ * This file is part of MobileFFmpeg.
+ *
+ * MobileFFmpeg is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * MobileFFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with MobileFFmpeg.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.arthenica.mobileffmpeg.util;
+
+import com.arthenica.mobileffmpeg.MediaInformation;
+
+/**
+ * <p>Represents a callback function to receive getMediaInformation result.
+ *
+ * @author Taner Sener
+ */
+@FunctionalInterface
+public interface GetMediaInformationCallback {
+
+    void apply(MediaInformation mediaInformation);
+
+}
@@ -1,33 +0,0 @@
-/*
- * Copyright (c) 2018 Taner Sener
- *
- * This file is part of MobileFFmpeg.
- *
- * MobileFFmpeg is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MobileFFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- *  You should have received a copy of the GNU Lesser General Public License
- *  along with MobileFFmpeg.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.arthenica.mobileffmpeg.util;
-
-/**
- * <p>Represents a callback function to receive run result.
- *
- * @author Taner Sener
- * @since v2.1
- */
-@FunctionalInterface
-public interface RunCallback {
-
-    void apply(final int returnCode);
-
-}
@@ -1,3 +0,0 @@
-<resources>
-    <string name="app_name">MobileFFmpeg</string>
-</resources>
@@ -22,6 +22,9 @@ package com.arthenica.mobileffmpeg;
 import org.junit.Assert;
 import org.junit.Test;

+import java.util.Map;
+import java.util.Set;
+
 /**
 * <p>Tests for {@link FFmpeg} class.
 */
@@ -298,6 +301,40 @@ public class FFmpegTest {
                    "frame=  813 fps=0.0 q=-0.0 Lsize=N/A time=00:00:33.01 bitrate=N/A speed= 234x    \n" +
                    "video:426kB audio:6190kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: unknown";

+    private static final String MEDIA_INFORMATION_RECORDING =
+            "Input #0, mov,mp4,m4a,3gp,3g2,mj2, from '/var/mobile/Containers/Data/Application/845A06CD-8427-4D2D-A9A8-F7738063E220/Library/Caches/video.mov':\n" +
+                    "  Metadata:\n" +
+                    "    major_brand     : qt\n" +
+                    "    minor_version   : 0\n" +
+                    "    compatible_brands: qt\n" +
+                    "    creation_time   : 2019-04-18T09:53:38.000000Z\n" +
+                    "    com.apple.quicktime.location.ISO6709: +40.9761+029.0949+070.349/\n" +
+                    "    com.apple.quicktime.make: Apple\n" +
+                    "    com.apple.quicktime.model: iPhone 6\n" +
+                    "    com.apple.quicktime.software: 12.2\n" +
+                    "    com.apple.quicktime.creationdate: 2019-04-18T12:53:38+0300\n" +
+                    "  Duration: 00:00:02.30, start: 0.000000, bitrate: 16658 kb/s\n" +
+                    "    Stream #0:0(und): Video: h264 (avc1 / 0x31637661), yuv420p(tv, bt709), 1920x1080, 16535 kb/s, 29.98 fps, 29.97 tbr, 600 tbn, 1200 tbc (default)\n" +
+                    "    Metadata:\n" +
+                    "      rotate          : 90\n" +
+                    "      creation_time   : 2019-04-18T09:53:38.000000Z\n" +
+                    "      handler_name    : Core Media Video\n" +
+                    "      encoder         : H.264\n" +
+                    "    Side data:\n" +
+                    "      displaymatrix: rotation of -90.00 degrees\n" +
+                    "    Stream #0:1(und): Audio: aac (mp4a / 0x6134706D), 44100 Hz, mono, fltp, 96 kb/s (default)\n" +
+                    "    Metadata:\n" +
+                    "      creation_time   : 2019-04-18T09:53:38.000000Z\n" +
+                    "      handler_name    : Core Media Audio\n" +
+                    "    Stream #0:2(und): Data: none (mebx / 0x7862656D), 0 kb/s (default)\n" +
+                    "    Metadata:\n" +
+                    "      creation_time   : 2019-04-18T09:53:38.000000Z\n" +
+                    "      handler_name    : Core Media Metadata\n" +
+                    "    Stream #0:3(und): Data: none (mebx / 0x7862656D), 0 kb/s (default)\n" +
+                    "    Metadata:\n" +
+                    "      creation_time   : 2019-04-18T09:53:38.000000Z\n" +
+                    "      handler_name    : Core Media Metadata\n";
+
    @Test
    public void mediaInformationMp3() {
        MediaInformation mediaInformation = MediaInformationParser.from(MEDIA_INFORMATION_MP3);
@@ -305,6 +342,17 @@ public class FFmpegTest {
        Assert.assertNotNull(mediaInformation);
        assertMediaInput(mediaInformation, "mp3", "beethoven_-_symphony_no_9.mp3");
        assertMediaDuration(mediaInformation, 213240L, 0L, 320L);
+
+        assertMetadata(mediaInformation, "comment", "");
+        assertMetadata(mediaInformation, "album", "Symphony No.9");
+        assertMetadata(mediaInformation, "compilation", "0");
+        assertMetadata(mediaInformation, "date", "-1");
+        assertMetadata(mediaInformation, "title", "Symphony No.9");
+        assertMetadata(mediaInformation, "artist", "Beethoven");
+        assertMetadata(mediaInformation, "album_artist", "Beethoven");
+        assertMetadata(mediaInformation, "track", "-1");
+        assertMetadata(mediaInformation, "lyrics-XXX", "");
+
        Assert.assertNotNull(mediaInformation.getStreams());
        Assert.assertEquals(1, mediaInformation.getStreams().size());
        assertAudioStream(mediaInformation.getStreams().get(0), 0L, "mp3", "mp3", 48000L, "stereo", "fltp", 320L);
@@ -341,9 +389,17 @@ public class FFmpegTest {
        Assert.assertNotNull(mediaInformation);
        assertMediaInput(mediaInformation, "mov,mp4,m4a,3gp,3g2,mj2", "transition_rotate.mp4");
        assertMediaDuration(mediaInformation, 15000L, 0L, 7764L);
+
+        assertMetadata(mediaInformation, "major_brand", "isom");
+        assertMetadata(mediaInformation, "minor_version", "512");
+        assertMetadata(mediaInformation, "compatible_brands", "isomiso2avc1mp41");
+        assertMetadata(mediaInformation, "encoder", "Lavf58.12.100");
+
        Assert.assertNotNull(mediaInformation.getStreams());
        Assert.assertEquals(1, mediaInformation.getStreams().size());
        assertVideoStream(mediaInformation.getStreams().get(0), 0L, "h264", "h264 (main) (avc1 / 0x31637661)", "yuv420p", "yuv420p", 1280L, 720L, "1:1", "16:9", 7762L, "25", "30", "15360", "60");
+
+        assertStreamMetadata(mediaInformation.getStreams().get(0), "handler_name", "VideoHandler");
    }

    @Test
@@ -377,11 +433,31 @@ public class FFmpegTest {
        Assert.assertNotNull(mediaInformation);
        assertMediaInput(mediaInformation, "mov,mp4,m4a,3gp,3g2,mj2", "http://distribution.bbb3d.renderfarming.net/video/mp4/bbb_sunflower_2160p_30fps_stereo_abl.mp4");
        assertMediaDuration(mediaInformation, 634530L, 0L, 10385L);
+
+        assertMetadata(mediaInformation, "major_brand", "isom");
+        assertMetadata(mediaInformation, "minor_version", "1");
+        assertMetadata(mediaInformation, "compatible_brands", "isomavc1");
+        assertMetadata(mediaInformation, "creation_time", "2013-12-16T17:21:55.000000Z");
+        assertMetadata(mediaInformation, "title", "Big Buck Bunny, Sunflower version");
+        assertMetadata(mediaInformation, "artist", "Blender Foundation 2008, Janus Bager Kristensen 2013");
+        assertMetadata(mediaInformation, "comment", "Creative Commons Attribution 3.0 - http://bbb3d.renderfarming.net");
+        assertMetadata(mediaInformation, "genre", "Animation");
+        assertMetadata(mediaInformation, "composer", "Sacha Goedegebure");
+
        Assert.assertNotNull(mediaInformation.getStreams());
        Assert.assertEquals(3, mediaInformation.getStreams().size());
        assertVideoStream(mediaInformation.getStreams().get(0), 0L, "h264", "h264 (high) (avc1 / 0x31637661)", "yuv420p", "yuv420p", 3840L, 4320L, "1:1", "8:9", 9902L, "30", "30", "30k", "60");
        assertAudioStream(mediaInformation.getStreams().get(1), 1L, "mp3", "mp3 (mp4a / 0x6134706d)", 48000L, "stereo", "fltp", 160L);
        assertAudioStream(mediaInformation.getStreams().get(2), 2L, "ac3", "ac3 (ac-3 / 0x332d6361)", 48000L, "5.1(side)", "fltp", 320L);
+
+        assertStreamMetadata(mediaInformation.getStreams().get(0), "creation_time", "2013-12-16T17:21:55.000000Z");
+        assertStreamMetadata(mediaInformation.getStreams().get(0), "handler_name", "GPAC ISO Video Handler");
+        assertStreamMetadata(mediaInformation.getStreams().get(1), "creation_time", "2013-12-16T17:21:58.000000Z");
+        assertStreamMetadata(mediaInformation.getStreams().get(1), "handler_name", "GPAC ISO Audio Handler");
+        assertStreamMetadata(mediaInformation.getStreams().get(2), "creation_time", "2013-12-16T17:21:58.000000Z");
+        assertStreamMetadata(mediaInformation.getStreams().get(2), "handler_name", "GPAC ISO Audio Handler");
+
+        assertStreamSidedata(mediaInformation.getStreams().get(2), "audio service type", "main");
    }

    @Test
@@ -391,11 +467,31 @@ public class FFmpegTest {
        Assert.assertNotNull(mediaInformation);
        assertMediaInput(mediaInformation, "mov,mp4,m4a,3gp,3g2,mj2", "http://distribution.bbb3d.renderfarming.net/video/mp4/bbb_sunflower_1080p_30fps_stereo_arcd.mp4");
        assertMediaDuration(mediaInformation, 634530L, 0L, 4474L);
+
+        assertMetadata(mediaInformation, "major_brand", "isom");
+        assertMetadata(mediaInformation, "minor_version", "1");
+        assertMetadata(mediaInformation, "compatible_brands", "isomavc1");
+        assertMetadata(mediaInformation, "creation_time", "2013-12-16T17:49:59.000000Z");
+        assertMetadata(mediaInformation, "title", "Big Buck Bunny, Sunflower version");
+        assertMetadata(mediaInformation, "artist", "Blender Foundation 2008, Janus Bager Kristensen 2013");
+        assertMetadata(mediaInformation, "comment", "Creative Commons Attribution 3.0 - http://bbb3d.renderfarming.net");
+        assertMetadata(mediaInformation, "genre", "Animation");
+        assertMetadata(mediaInformation, "composer", "Sacha Goedegebure");
+
        Assert.assertNotNull(mediaInformation.getStreams());
        Assert.assertEquals(3, mediaInformation.getStreams().size());
        assertVideoStream(mediaInformation.getStreams().get(0), 0L, "h264", "h264 (high) (avc1 / 0x31637661)", "yuv420p", "yuv420p", 1920L, 1080L, "1:1", "16:9", 3992L, "30", "30", "30k", "60");
        assertAudioStream(mediaInformation.getStreams().get(1), 1L, "mp3", "mp3 (mp4a / 0x6134706d)", 48000L, "stereo", "fltp", 160L);
        assertAudioStream(mediaInformation.getStreams().get(2), 2L, "ac3", "ac3 (ac-3 / 0x332d6361)", 48000L, "5.1(side)", "fltp", 320L);
+
+        assertStreamMetadata(mediaInformation.getStreams().get(0), "creation_time", "2013-12-16T17:49:59.000000Z");
+        assertStreamMetadata(mediaInformation.getStreams().get(0), "handler_name", "GPAC ISO Video Handler");
+        assertStreamMetadata(mediaInformation.getStreams().get(1), "creation_time", "2013-12-16T17:50:04.000000Z");
+        assertStreamMetadata(mediaInformation.getStreams().get(1), "handler_name", "GPAC ISO Audio Handler");
+        assertStreamMetadata(mediaInformation.getStreams().get(2), "creation_time", "2013-12-16T17:50:04.000000Z");
+        assertStreamMetadata(mediaInformation.getStreams().get(2), "handler_name", "GPAC ISO Audio Handler");
+
+        assertStreamSidedata(mediaInformation.getStreams().get(2), "audio service type", "main");
    }

    @Test
@@ -409,6 +505,48 @@ public class FFmpegTest {
        Assert.assertEquals(2, mediaInformation.getStreams().size());
        assertVideoStream(mediaInformation.getStreams().get(0), 0L, "theora", "theora", "yuv420p", "yuv420p(bt470bg/bt470bg/bt709)", 720L, 400L, null, null, null, "25", "25", "25", "25");
        assertAudioStream(mediaInformation.getStreams().get(1), 1L, "vorbis", "vorbis", 48000L, "stereo", "fltp", 80L);
+
+        assertStreamMetadata(mediaInformation.getStreams().get(0), "ENCODER", "ffmpeg2theora 0.19");
+        assertStreamMetadata(mediaInformation.getStreams().get(1), "ENCODER", "ffmpeg2theora 0.19");
+    }
+
+    @Test
+    public void setMediaInformationRecording() {
+        MediaInformation mediaInformation = MediaInformationParser.from(MEDIA_INFORMATION_RECORDING);
+
+        Assert.assertNotNull(mediaInformation);
+        assertMediaInput(mediaInformation, "mov,mp4,m4a,3gp,3g2,mj2", "/var/mobile/Containers/Data/Application/845A06CD-8427-4D2D-A9A8-F7738063E220/Library/Caches/video.mov");
+        assertMediaDuration(mediaInformation, 2300L, 0L, 16658L);
+
+        assertMetadata(mediaInformation, "major_brand", "qt");
+        assertMetadata(mediaInformation, "minor_version", "0");
+        assertMetadata(mediaInformation, "compatible_brands", "qt");
+        assertMetadata(mediaInformation, "creation_time", "2019-04-18T09:53:38.000000Z");
+        assertMetadata(mediaInformation, "com.apple.quicktime.location.ISO6709", "+40.9761+029.0949+070.349/");
+        assertMetadata(mediaInformation, "com.apple.quicktime.make", "Apple");
+        assertMetadata(mediaInformation, "com.apple.quicktime.model", "iPhone 6");
+        assertMetadata(mediaInformation, "com.apple.quicktime.software", "12.2");
+        assertMetadata(mediaInformation, "com.apple.quicktime.creationdate", "2019-04-18T12:53:38+0300");
+
+        Assert.assertNotNull(mediaInformation.getStreams());
+        Assert.assertEquals(4, mediaInformation.getStreams().size());
+        assertVideoStream(mediaInformation.getStreams().get(0), 0L, "h264", "h264 (avc1 / 0x31637661)", "yuv420p", "yuv420p(tv, bt709)", 1920L, 1080L, null, null, 16535L, "29.98", "29.97", "600", "1200");
+        assertAudioStream(mediaInformation.getStreams().get(1), 1L, "aac", "aac (mp4a / 0x6134706d)", 44100L, "mono", "fltp", 96L);
+        assertStream(mediaInformation.getStreams().get(2), 2L, "data", "none", "none (mebx / 0x7862656d)", 0L);
+        assertStream(mediaInformation.getStreams().get(3), 3L, "data", "none", "none (mebx / 0x7862656d)", 0L);
+
+        assertStreamMetadata(mediaInformation.getStreams().get(0), "rotate", "90");
+        assertStreamMetadata(mediaInformation.getStreams().get(0), "creation_time", "2019-04-18T09:53:38.000000Z");
+        assertStreamMetadata(mediaInformation.getStreams().get(0), "handler_name", "Core Media Video");
+        assertStreamMetadata(mediaInformation.getStreams().get(0), "encoder", "H.264");
+        assertStreamMetadata(mediaInformation.getStreams().get(1), "creation_time", "2019-04-18T09:53:38.000000Z");
+        assertStreamMetadata(mediaInformation.getStreams().get(1), "handler_name", "Core Media Audio");
+        assertStreamMetadata(mediaInformation.getStreams().get(2), "creation_time", "2019-04-18T09:53:38.000000Z");
+        assertStreamMetadata(mediaInformation.getStreams().get(2), "handler_name", "Core Media Metadata");
+        assertStreamMetadata(mediaInformation.getStreams().get(3), "creation_time", "2019-04-18T09:53:38.000000Z");
+        assertStreamMetadata(mediaInformation.getStreams().get(3), "handler_name", "Core Media Metadata");
+
+        assertStreamSidedata(mediaInformation.getStreams().get(0), "displaymatrix", "rotation of -90.00 degrees");
    }

    private void assertMediaInput(MediaInformation mediaInformation, String format, String path) {
@@ -422,11 +560,74 @@ public class FFmpegTest {
        Assert.assertEquals(bitrate, mediaInformation.getBitrate());
    }

+    private void assertMetadata(MediaInformation mediaInformation, String expectedKey, String expectedValue) {
+        Set<Map.Entry<String, String>> metadataEntries = mediaInformation.getMetadataEntries();
+        Assert.assertNotNull(metadataEntries);
+
+        for (Map.Entry<String, String> metadataEntry : metadataEntries) {
+            String key = metadataEntry.getKey();
+            String value = metadataEntry.getValue();
+
+            if (key.equals(expectedKey)) {
+                Assert.assertEquals(expectedValue, value);
+                return;
+            }
+        }
+
+        Assert.fail(expectedKey + " not found");
+    }
+
+    private void assertStreamMetadata(StreamInformation streamInformation, String expectedKey, String expectedValue) {
+        Set<Map.Entry<String, String>> metadataEntries = streamInformation.getMetadataEntries();
+        Assert.assertNotNull(metadataEntries);
+
+        for (Map.Entry<String, String> metadataEntry : metadataEntries) {
+            String key = metadataEntry.getKey();
+            String value = metadataEntry.getValue();
+
+            if (key.equals(expectedKey)) {
+                Assert.assertEquals(expectedValue, value);
+                return;
+            }
+        }
+
+        Assert.fail(expectedKey + " not found");
+    }
+
+    private void assertStreamSidedata(StreamInformation streamInformation, String expectedKey, String expectedValue) {
+        Set<Map.Entry<String, String>> sidedataEntries = streamInformation.getSidedataEntries();
+        Assert.assertNotNull(sidedataEntries);
+
+        for (Map.Entry<String, String> metadataEntry : sidedataEntries) {
+            String key = metadataEntry.getKey();
+            String value = metadataEntry.getValue();
+
+            if (key.equals(expectedKey)) {
+                Assert.assertEquals(expectedValue, value);
+                return;
+            }
+        }
+
+        Assert.fail(expectedKey + " not found");
+    }
+
+    private void assertStream(StreamInformation streamInformation, Long index, String type, String codec, String fullCodec, Long bitrate) {
+        Assert.assertEquals(index, streamInformation.getIndex());
+        Assert.assertEquals(type, streamInformation.getType());
+
+        Assert.assertEquals(codec, streamInformation.getCodec());
+        Assert.assertEquals(fullCodec, streamInformation.getFullCodec());
+
+        Assert.assertEquals(bitrate, streamInformation.getBitrate());
+    }
+
    private void assertAudioStream(StreamInformation streamInformation, Long index, String codec, String fullCodec, Long sampleRate, String channelLayout, String sampleFormat, Long bitrate) {
        Assert.assertEquals(index, streamInformation.getIndex());
        Assert.assertEquals("audio", streamInformation.getType());
+
        Assert.assertEquals(codec, streamInformation.getCodec());
        Assert.assertEquals(fullCodec, streamInformation.getFullCodec());
+
        Assert.assertEquals(sampleRate, streamInformation.getSampleRate());
        Assert.assertEquals(channelLayout, streamInformation.getChannelLayout());
        Assert.assertEquals(sampleFormat, streamInformation.getSampleFormat());
@@ -436,6 +637,7 @@ public class FFmpegTest {
    private void assertVideoStream(StreamInformation streamInformation, Long index, String codec, String fullCodec, String format, String fullFormat, Long width, Long height, String sar, String dar, Long bitrate, String averageFrameRate, String realFrameRate, String timeBase, String codecTimeBase) {
        Assert.assertEquals(index, streamInformation.getIndex());
        Assert.assertEquals("video", streamInformation.getType());
+
        Assert.assertEquals(codec, streamInformation.getCodec());
        Assert.assertEquals(fullCodec, streamInformation.getFullCodec());

@@ -1,14 +1,12 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.

 buildscript {
-    
    repositories {
        google()
        jcenter()
    }
    dependencies {
-        classpath 'com.android.tools.build:gradle:3.1.4'
-
+        classpath 'com.android.tools.build:gradle:3.3.2'

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
@@ -1,6 +1,5 @@
-#Thu Mar 15 21:50:32 EET 2018
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.4-all.zip
@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh

 ##############################################################################
 ##
@@ -6,42 +6,6 @@
 ##
 ##############################################################################

-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn ( ) {
-    echo "$*"
-}
-
-die ( ) {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-esac
-
 # Attempt to set APP_HOME
 # Resolve links: $0 may be a link
 PRG="$0"
@@ -60,6 +24,46 @@ cd "`dirname \"$PRG\"`/" >/dev/null
 APP_HOME="`pwd -P`"
 cd "$SAVED" >/dev/null

+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar

 # Determine the Java command to use to start the JVM.
@@ -85,7 +89,7 @@ location of your Java installation."
 fi

 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
    MAX_FD_LIMIT=`ulimit -H -n`
    if [ $? -eq 0 ] ; then
        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@@ -150,11 +154,19 @@ if $cygwin ; then
    esac
 fi

-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
-    JVM_OPTS=("$@")
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
 }
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+APP_ARGS=$(save "$@")

-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
@@ -8,14 +8,14 @@
@rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal

-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%

+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m"
+
@rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome

@@ -46,10 +46,9 @@ echo location of your Java installation.
 goto fail

 :init
-@rem Get command-line arguments, handling Windowz variants
+@rem Get command-line arguments, handling Windows variants

 if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval[2+2]" == "4" goto 4NT_args

 :win9xME_args
@rem Slurp the command line arguments.
@@ -60,11 +59,6 @@ set _SKIP=2
 if "x%~1" == "x" goto execute

 set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$

 :execute
@rem Setup the command line
@@ -1 +1,2 @@
 /Application.mk
+/Android.mk.tmp
@@ -2,14 +2,17 @@ LOCAL_PATH := $(call my-dir)
 $(call import-add-path, $(LOCAL_PATH))

 MY_ARM_MODE := arm
+MY_ARM_NEON := false
 MY_PATH := ../app/src/main/cpp

 # DEFINE ARCH FLAGS
 ifeq ($(TARGET_ARCH_ABI), armeabi-v7a)
    MY_ARCH_FLAGS := ARM_V7A
+    MY_ARM_NEON := true
 endif
 ifeq ($(TARGET_ARCH_ABI), arm64-v8a)
    MY_ARCH_FLAGS := ARM64_V8A
+    MY_ARM_NEON := true
 endif
 ifeq ($(TARGET_ARCH_ABI), x86)
    MY_ARCH_FLAGS := X86
@@ -25,6 +28,7 @@ LOCAL_SRC_FILES := $(NDK_ROOT)/sources/android/cpufeatures/cpu-features.c
 LOCAL_CFLAGS := -Wall -Wextra -Werror
 LOCAL_EXPORT_C_INCLUDES := $(NDK_ROOT)/sources/android/cpufeatures
 LOCAL_EXPORT_LDLIBS := -ldl
+LOCAL_ARM_NEON := ${MY_ARM_NEON}
 include $(BUILD_SHARED_LIBRARY)

 include $(CLEAR_VARS)
@@ -34,6 +38,7 @@ LOCAL_SRC_FILES := $(MY_PATH)/mobileffmpeg_abidetect.c
 LOCAL_CFLAGS := -Wall -Wextra -Werror -Wno-unused-parameter -I${LOCAL_PATH}/../../prebuilt/android-$(TARGET_ARCH)/ffmpeg/include -I$(NDK_ROOT)/sources/android/cpufeatures -DMOBILE_FFMPEG_${MY_ARCH_FLAGS}
 LOCAL_LDLIBS := -llog -lz -landroid
 LOCAL_SHARED_LIBRARIES := cpufeatures
+LOCAL_ARM_NEON := ${MY_ARM_NEON}
 include $(BUILD_SHARED_LIBRARY)

 include $(CLEAR_VARS)
@@ -43,24 +48,7 @@ LOCAL_SRC_FILES := $(MY_PATH)/mobileffmpeg.c $(MY_PATH)/fftools_cmdutils.c $(MY_
 LOCAL_CFLAGS := -Wall -Werror -Wno-unused-parameter -Wno-switch -Wno-sign-compare -I${LOCAL_PATH}/../../prebuilt/android-$(TARGET_ARCH)/ffmpeg/include
 LOCAL_LDLIBS := -llog -lz -landroid
 LOCAL_SHARED_LIBRARIES := c++_shared libavfilter libavformat libavcodec libavutil libswresample libavdevice libswscale
+LOCAL_ARM_NEON := ${MY_ARM_NEON}
 include $(BUILD_SHARED_LIBRARY)

-ifeq ($(TARGET_ARCH_ABI), armeabi-v7a)
-    ifeq ("$(shell test -e $(LOCAL_PATH)/../build/.neon && echo neon)","neon")
-
-        include $(CLEAR_VARS)
-        LOCAL_ARM_MODE := $(MY_ARM_MODE)
-        LOCAL_MODULE := mobileffmpeg-armv7a-neon
-        LOCAL_SRC_FILES := $(MY_PATH)/mobileffmpeg.c $(MY_PATH)/fftools_cmdutils.c $(MY_PATH)/fftools_ffmpeg.c $(MY_PATH)/fftools_ffmpeg_opt.c $(MY_PATH)/fftools_ffmpeg_hw.c $(MY_PATH)/fftools_ffmpeg_filter.c
-        LOCAL_CFLAGS := -Wall -Werror -Wno-unused-parameter -Wno-switch -Wno-sign-compare -I${LOCAL_PATH}/../../prebuilt/android-$(TARGET_ARCH)/ffmpeg/include
-        LOCAL_LDLIBS := -llog -lz -landroid
-        LOCAL_SHARED_LIBRARIES := c++_shared libavcodec-neon libavfilter-neon libswscale-neon libavformat libavutil libswresample libavdevice
-        LOCAL_ARM_NEON := true
-        include $(BUILD_SHARED_LIBRARY)
-
-        $(call import-module, ffmpeg/neon)
-
-    endif
-endif
-
 $(call import-module, ffmpeg)
@@ -1,4 +1,3 @@
 /build
 /.idea/
-/gradle/
 /local.properties
@@ -1,32 +1,62 @@
 apply plugin: 'com.android.application'

 android {
-    compileSdkVersion 27
+    signingConfigs {
+        localConfig {
+            keyAlias 'androiddebugkey'
+            storeFile file(System.getProperty("user.home") + '/.android/debug.keystore')
+            storePassword 'android'
+            keyPassword 'android'
+        }
+    }
+    compileSdkVersion 28
    defaultConfig {
        applicationId "com.arthenica.mobileffmpeg.test"
-        minSdkVersion 21
-        targetSdkVersion 27
-        versionCode 30
-        versionName "3.0"
-        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+        minSdkVersion 24
+        targetSdkVersion 28
+        versionCode 240422
+        versionName "4.2.2"
    }
    buildTypes {
-        release {
+        debug {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
+        release {
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+            signingConfig signingConfigs.localConfig
+        }
+    }
+    splits {
+        abi {
+            enable true
+            reset()
+            include "armeabi-v7a", "arm64-v8a", "x86", "x86_64"
+            universalApk false
+        }
+    }
+}
+
+ext.abiCodes = ['x86':1, 'x86_64':2, 'armeabi-v7a':3, 'arm64-v8a':4]
+
+import com.android.build.OutputFile
+
+android.applicationVariants.all { variant ->
+    variant.outputs.each {
+        output ->
+            def baseAbiVersionCode = project.ext.abiCodes.get(output.getFilter(OutputFile.ABI))
+            output.versionCodeOverride = baseAbiVersionCode + variant.versionCode
    }
 }

 dependencies {
-    implementation fileTree(dir: 'libs', include: ['*.jar'])
-    // implementation 'com.arthenica:mobile-ffmpeg-full:3.0'
-    implementation project(':app')
+    implementation fileTree(include: ['*.jar'], dir: 'libs')
+    implementation 'com.arthenica:mobile-ffmpeg-full:4.2.2'
+    // implementation project(':app')
    testImplementation 'junit:junit:4.12'
-    androidTestImplementation 'com.android.support.test:runner:1.0.2'
-    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
-    implementation 'com.android.support:support-v4:27.1.1'
-    implementation 'com.android.support:design:27.1.1'
-    implementation 'com.android.support:appcompat-v7:27.1.1'
+    implementation 'com.android.support:support-v4:28.0.0'
+    implementation 'com.android.support:design:28.0.0'
+    implementation 'com.android.support:appcompat-v7:28.0.0'
    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
 }
@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
@@ -0,0 +1,172 @@
+#!/usr/bin/env sh
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"
@@ -0,0 +1,84 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
@@ -4,18 +4,3 @@
 #
 # For more details, see
 #   http://developer.android.com/guide/developing/tools/proguard.html
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
-
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile
@@ -12,14 +12,14 @@
    <uses-feature android:name="android.hardware.camera" android:required="true" />

    <application
-        android:allowBackup="true"
+        android:allowBackup="false"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:largeHeap="true"
        android:theme="@style/AppTheme"
-        tools:replace="android:icon">
+        tools:ignore="GoogleAppIndexingWarning">
        <activity android:name="com.arthenica.mobileffmpeg.test.MainActivity"
            android:theme="@style/AppTheme">
            <intent-filter>
@@ -39,7 +39,7 @@ import com.arthenica.mobileffmpeg.Config;
 import com.arthenica.mobileffmpeg.FFmpeg;
 import com.arthenica.mobileffmpeg.LogCallback;
 import com.arthenica.mobileffmpeg.LogMessage;
-import com.arthenica.mobileffmpeg.util.RunCallback;
+import com.arthenica.mobileffmpeg.util.ExecuteCallback;

 import java.io.File;
 import java.util.concurrent.Callable;
@@ -159,10 +159,10 @@ public class AudioTabFragment extends Fragment implements AdapterView.OnItemSele

        android.util.Log.d(TAG, String.format("FFmpeg process started with arguments\n'%s'", ffmpegCommand));

-        MainActivity.executeAsync(new RunCallback() {
+        MainActivity.executeAsync(new ExecuteCallback() {

            @Override
-            public void apply(final int returnCode) {
+            public void apply(final int returnCode, final String commandOutput) {
                android.util.Log.d(TAG, String.format("FFmpeg process exited with rc %d", returnCode));

                hideProgressDialog();
@@ -34,7 +34,7 @@ import com.arthenica.mobileffmpeg.Config;
 import com.arthenica.mobileffmpeg.FFmpeg;
 import com.arthenica.mobileffmpeg.LogCallback;
 import com.arthenica.mobileffmpeg.LogMessage;
-import com.arthenica.mobileffmpeg.util.RunCallback;
+import com.arthenica.mobileffmpeg.util.ExecuteCallback;

 import java.util.concurrent.Callable;

@@ -117,7 +117,7 @@ public class CommandTabFragment extends Fragment {
    public void runFFmpeg() {
        clearLog();

-        final String ffmpegCommand = commandText.getText().toString();
+        final String ffmpegCommand = String.format("-hide_banner %s", commandText.getText().toString());

        android.util.Log.d(MainActivity.TAG, "Testing COMMAND synchronously.");

@@ -135,16 +135,16 @@ public class CommandTabFragment extends Fragment {
    public void runFFmpegAsync() {
        clearLog();

-        final String ffmpegCommand = commandText.getText().toString();
+        final String ffmpegCommand = String.format("-hide_banner %s", commandText.getText().toString());

        android.util.Log.d(MainActivity.TAG, "Testing COMMAND asynchronously.");

        android.util.Log.d(MainActivity.TAG, String.format("FFmpeg process started with arguments\n\'%s\'", ffmpegCommand));

-        MainActivity.executeAsync(new RunCallback() {
+        MainActivity.executeAsync(new ExecuteCallback() {

            @Override
-            public void apply(int result) {
+            public void apply(int result, final String commandOutput) {

                android.util.Log.d(MainActivity.TAG, String.format("FFmpeg process exited with rc %d", result));

@@ -34,12 +34,16 @@ import com.arthenica.mobileffmpeg.Config;
 import com.arthenica.mobileffmpeg.FFmpeg;
 import com.arthenica.mobileffmpeg.LogCallback;
 import com.arthenica.mobileffmpeg.LogMessage;
+import com.arthenica.mobileffmpeg.MediaInformation;
+import com.arthenica.mobileffmpeg.StreamInformation;

+import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.Callable;

 public class HttpsTabFragment extends Fragment {

-    public static final String HTTPS_TEST_DEFAULT_URL = "https://upload.wikimedia.org/wikipedia/commons/thumb/4/4b/FFmpeg-Logo.svg/568px-FFmpeg-Logo.svg.png";
+    public static final String HTTPS_TEST_DEFAULT_URL = "https://download.blender.org/peach/trailer/trailer_1080p.ogg";

    private MainActivity mainActivity;
    private EditText urlText;
@@ -119,14 +123,100 @@ public class HttpsTabFragment extends Fragment {
        }

        // HTTPS COMMAND ARGUMENTS
-        final String ffmpegCommand = String.format("-hide_banner -i %s -f null -", testUrl);
+        MediaInformation information = FFmpeg.getMediaInformation(testUrl);
+        if (information == null) {
+            appendLog("Get media information failed\n");
+        } else {
+            appendLog("Media information for " + information.getPath() + "\n");

-        android.util.Log.d(MainActivity.TAG, String.format("FFmpeg process started with arguments\n'%s'", ffmpegCommand));
+            if (information.getFormat() != null) {
+                appendLog("Format: " + information.getFormat() + "\n");
+            }
+            if (information.getBitrate() != null) {
+                appendLog("Bitrate: " + information.getBitrate() + "\n");
+            }
+            if (information.getDuration() != null) {
+                appendLog("Duration: " + information.getDuration() + "\n");
+            }
+            if (information.getStartTime() != null) {
+                appendLog("Start time: " + information.getStartTime() + "\n");
+            }
+            if (information.getMetadataEntries() != null) {
+                Set<Map.Entry<String, String>> entries = information.getMetadataEntries();
+                for (Map.Entry<String, String> entry : entries) {
+                    appendLog("Metadata: " + entry.getKey() + ":" + entry.getValue() + "\n");
+                }
+            }
+            if (information.getStreams() != null) {
+                for (StreamInformation stream : information.getStreams()) {
+                    if (stream.getIndex() != null) {
+                        appendLog("Stream index: " + stream.getIndex() + "\n");
+                    }
+                    if (stream.getType() != null) {
+                        appendLog("Stream type: " + stream.getType() + "\n");
+                    }
+                    if (stream.getCodec() != null) {
+                        appendLog("Stream codec: " + stream.getCodec() + "\n");
+                    }
+                    if (stream.getFullCodec() != null) {
+                        appendLog("Stream full codec: " + stream.getFullCodec() + "\n");
+                    }
+                    if (stream.getFormat() != null) {
+                        appendLog("Stream format: " + stream.getFormat() + "\n");
+                    }
+                    if (stream.getFullFormat() != null) {
+                        appendLog("Stream full format: " + stream.getFullFormat() + "\n");
+                    }

-        // EXECUTE
-        int result = FFmpeg.execute(ffmpegCommand);
+                    if (stream.getWidth() != null) {
+                        appendLog("Stream width: " + stream.getWidth() + "\n");
+                    }
+                    if (stream.getHeight() != null) {
+                        appendLog("Stream height: " + stream.getHeight() + "\n");
+                    }

-        android.util.Log.d(MainActivity.TAG, String.format("FFmpeg process exited with rc %d", result));
+                    if (stream.getBitrate() != null) {
+                        appendLog("Stream bitrate: " + stream.getBitrate() + "\n");
+                    }
+                    if (stream.getSampleRate() != null) {
+                        appendLog("Stream sample rate: " + stream.getSampleRate() + "\n");
+                    }
+                    if (stream.getSampleFormat() != null) {
+                        appendLog("Stream sample format: " + stream.getSampleFormat() + "\n");
+                    }
+                    if (stream.getChannelLayout() != null) {
+                        appendLog("Stream channel layout: " + stream.getChannelLayout() + "\n");
+                    }
+
+                    if (stream.getSampleAspectRatio() != null) {
+                        appendLog("Stream sample aspect ratio: " + stream.getSampleAspectRatio() + "\n");
+                    }
+                    if (stream.getDisplayAspectRatio() != null) {
+                        appendLog("Stream display ascpect ratio: " + stream.getDisplayAspectRatio() + "\n");
+                        ;
+                    }
+                    if (stream.getAverageFrameRate() != null) {
+                        appendLog("Stream average frame rate: " + stream.getAverageFrameRate() + "\n");
+                    }
+                    if (stream.getRealFrameRate() != null) {
+                        appendLog("Stream real frame rate: " + stream.getRealFrameRate() + "\n");
+                    }
+                    if (stream.getTimeBase() != null) {
+                        appendLog("Stream time base: " + stream.getTimeBase() + "\n");
+                    }
+                    if (stream.getCodecTimeBase() != null) {
+                        appendLog("Stream codec time base: " + stream.getCodecTimeBase() + "\n");
+                    }
+
+                    if (stream.getMetadataEntries() != null) {
+                        Set<Map.Entry<String, String>> entries = stream.getMetadataEntries();
+                        for (Map.Entry<String, String> entry : entries) {
+                            appendLog("Stream metadata: " + entry.getKey() + ":" + entry.getValue() + "\n");
+                        }
+                    }
+                }
+            }
+        }
    }

    public void setActive() {
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Taner Sener
+ * Copyright (c) 2018-2019 Taner Sener
 *
 * This file is part of MobileFFmpeg.
 *
@@ -27,6 +27,7 @@ import android.content.pm.PackageManager;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
 import android.graphics.Color;
+import android.os.AsyncTask;
 import android.os.Bundle;
 import android.os.Handler;
 import android.support.v4.app.ActivityCompat;
@@ -40,19 +41,18 @@ import android.widget.Button;
 import android.widget.TextView;

 import com.arthenica.mobileffmpeg.Config;
-import com.arthenica.mobileffmpeg.FFmpeg;
-import com.arthenica.mobileffmpeg.util.AsynchronousTaskService;
-import com.arthenica.mobileffmpeg.util.RunCallback;
+import com.arthenica.mobileffmpeg.util.AsyncExecuteTask;
+import com.arthenica.mobileffmpeg.util.ExecuteCallback;

 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Queue;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.Future;

 public class MainActivity extends AppCompatActivity {

@@ -65,8 +65,6 @@ public class MainActivity extends AppCompatActivity {
            Manifest.permission.CAMERA
    };

-    protected static final AsynchronousTaskService asynchronousTaskService = new AsynchronousTaskService();
-
    protected static final Queue<Callable> actionQueue = new ConcurrentLinkedQueue<>();

    protected static final Handler handler = new Handler();
@@ -112,7 +110,7 @@ public class MainActivity extends AppCompatActivity {
        }

        final ViewPager viewPager = findViewById(R.id.pager);
-        viewPager.setAdapter(new PagerAdapter(getSupportFragmentManager(), this, 6));
+        viewPager.setAdapter(new PagerAdapter(getSupportFragmentManager(), this, 7));

        waitForUIAction();

@@ -142,6 +140,9 @@ public class MainActivity extends AppCompatActivity {
        } catch (final IOException e) {
            Log.e(TAG, "Font registration failed.", e);
        }
+
+        Log.d(TAG, "Listing supported camera ids.");
+        listSupportedCameraIds();
    }

    @Override
@@ -154,23 +155,12 @@ public class MainActivity extends AppCompatActivity {
    /**
     * <p>Starts a new asynchronous FFmpeg operation with arguments provided.
     *
-     * @param runCallback callback function to receive result of this execution
-     * @param arguments   FFmpeg command options/arguments
-     * @return <code>Future</code> instance of asynchronous operation started
+     * @param executeCallback callback function to receive result of this execution
+     * @param arguments       FFmpeg command options/arguments
     */
-    public static Future executeAsync(final RunCallback runCallback, final String arguments) {
-        return asynchronousTaskService.runAsynchronously(new Callable<Integer>() {
-
-            @Override
-            public Integer call() {
-                int returnCode = FFmpeg.execute(arguments, " ");
-                if (runCallback != null) {
-                    runCallback.apply(returnCode);
-                }
-
-                return returnCode;
-            }
-        });
+    public static void executeAsync(final ExecuteCallback executeCallback, final String arguments) {
+        final AsyncExecuteTask asyncCommandTask = new AsyncExecuteTask(executeCallback);
+        asyncCommandTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, arguments.split(" "));
    }

    public static void waitForUIAction() {
@@ -266,4 +256,15 @@ public class MainActivity extends AppCompatActivity {
        // Config.setFontDirectory(this, cacheDirectory.getAbsolutePath(), null);
    }

+    protected void listSupportedCameraIds() {
+        final List<String> supportedCameraIds = Config.getSupportedCameraIds(this);
+        if (supportedCameraIds.size() == 0) {
+            android.util.Log.d(MainActivity.TAG, "No supported cameras found.");
+        } else {
+            for (String supportedCameraId : supportedCameraIds) {
+                android.util.Log.d(MainActivity.TAG, "Supported camera detected: " + supportedCameraId);
+            }
+        }
+    }
+
 }
@@ -55,6 +55,9 @@ public class PagerAdapter extends FragmentPagerAdapter {
            case 5: {
                return VidStabTabFragment.newInstance(mainActivity);
            }
+            case 6: {
+                return PipeTabFragment.newInstance(mainActivity);
+            }
            default: {
                return null;
            }
@@ -87,6 +90,9 @@ public class PagerAdapter extends FragmentPagerAdapter {
            case 5: {
                return mainActivity.getString(R.string.vidstab_tab);
            }
+            case 6: {
+                return mainActivity.getString(R.string.pipe_tab);
+            }
            default: {
                return null;
            }
@@ -0,0 +1,282 @@
+/*
+ * Copyright (c) 2018 Taner Sener
+ *
+ * This file is part of MobileFFmpeg.
+ *
+ * MobileFFmpeg is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * MobileFFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with MobileFFmpeg.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.arthenica.mobileffmpeg.test;
+
+import android.app.AlertDialog;
+import android.media.MediaPlayer;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.v4.app.Fragment;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.MediaController;
+import android.widget.TextView;
+import android.widget.VideoView;
+
+import com.arthenica.mobileffmpeg.Config;
+import com.arthenica.mobileffmpeg.LogCallback;
+import com.arthenica.mobileffmpeg.LogMessage;
+import com.arthenica.mobileffmpeg.Statistics;
+import com.arthenica.mobileffmpeg.StatisticsCallback;
+import com.arthenica.mobileffmpeg.util.AsyncCatImageTask;
+import com.arthenica.mobileffmpeg.util.ExecuteCallback;
+
+import java.io.File;
+import java.io.IOException;
+import java.math.BigDecimal;
+import java.util.concurrent.Callable;
+
+import static com.arthenica.mobileffmpeg.FFmpeg.RETURN_CODE_SUCCESS;
+import static com.arthenica.mobileffmpeg.test.MainActivity.TAG;
+
+public class PipeTabFragment extends Fragment {
+
+    private MainActivity mainActivity;
+    private VideoView videoView;
+    private AlertDialog progressDialog;
+    private Statistics statistics;
+
+    @Override
+    public View onCreateView(@NonNull final LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.fragment_pipe_tab, container, false);
+    }
+
+    @Override
+    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+
+        if (getView() != null) {
+            View createButton = getView().findViewById(R.id.createButton);
+            if (createButton != null) {
+                createButton.setOnClickListener(new View.OnClickListener() {
+
+                    @Override
+                    public void onClick(View v) {
+                        createVideo();
+                    }
+                });
+            }
+
+            videoView = getView().findViewById(R.id.videoPlayerFrame);
+        }
+
+        progressDialog = mainActivity.createProgressDialog("Creating video");
+    }
+
+    @Override
+    public void setUserVisibleHint(boolean isVisibleToUser) {
+        super.setUserVisibleHint(isVisibleToUser);
+        if (isVisibleToUser) {
+            setActive();
+        }
+    }
+
+    public void setMainActivity(MainActivity mainActivity) {
+        this.mainActivity = mainActivity;
+    }
+
+    public static PipeTabFragment newInstance(final MainActivity mainActivity) {
+        final PipeTabFragment fragment = new PipeTabFragment();
+        fragment.setMainActivity(mainActivity);
+        return fragment;
+    }
+
+    public void enableLogCallback() {
+        Config.enableLogCallback(new LogCallback() {
+
+            @Override
+            public void apply(LogMessage message) {
+                Log.d(MainActivity.TAG, message.getText());
+            }
+        });
+    }
+
+    public void enableStatisticsCallback() {
+        Config.enableStatisticsCallback(new StatisticsCallback() {
+
+            @Override
+            public void apply(final Statistics newStatistics) {
+                MainActivity.addUIAction(new Callable() {
+
+                    @Override
+                    public Object call() {
+                        PipeTabFragment.this.statistics = newStatistics;
+                        updateProgressDialog();
+                        return null;
+                    }
+                });
+            }
+        });
+    }
+
+    void startAsyncCatImageProcess(final String imagePath, final String namedPipePath) {
+        AsyncCatImageTask asyncTask = new AsyncCatImageTask();
+        asyncTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, imagePath, namedPipePath);
+    }
+
+    public void createVideo() {
+        final File image1File = new File(mainActivity.getCacheDir(), "colosseum.jpg");
+        final File image2File = new File(mainActivity.getCacheDir(), "pyramid.jpg");
+        final File image3File = new File(mainActivity.getCacheDir(), "tajmahal.jpg");
+        final File videoFile = getVideoFile();
+
+        String pipe1 = Config.registerNewFFmpegPipe(mainActivity);
+        String pipe2 = Config.registerNewFFmpegPipe(mainActivity);
+        String pipe3 = Config.registerNewFFmpegPipe(mainActivity);
+
+        try {
+
+            // IF VIDEO IS PLAYING STOP PLAYBACK
+            videoView.stopPlayback();
+
+            if (videoFile.exists()) {
+                videoFile.delete();
+            }
+
+            Log.d(TAG, "Testing PIPE with 'mpeg4' codec");
+
+            showProgressDialog();
+
+            mainActivity.resourceToFile(R.drawable.colosseum, image1File);
+            mainActivity.resourceToFile(R.drawable.pyramid, image2File);
+            mainActivity.resourceToFile(R.drawable.tajmahal, image3File);
+
+            final String ffmpegCommand = Video.generateCreateVideoWithPipesScript(pipe1, pipe2, pipe3, videoFile.getAbsolutePath());
+
+            Log.d(TAG, String.format("FFmpeg process started with arguments\n'%s'", ffmpegCommand));
+
+            MainActivity.executeAsync(new ExecuteCallback() {
+
+                @Override
+                public void apply(final int returnCode, final String commandOutput) {
+                    Log.d(TAG, String.format("FFmpeg process exited with rc %d", returnCode));
+
+                    hideProgressDialog();
+
+                    MainActivity.addUIAction(new Callable() {
+
+                        @Override
+                        public Object call() {
+                            if (returnCode == RETURN_CODE_SUCCESS) {
+                                Log.d(TAG, "Create completed successfully; playing video.");
+                                playVideo();
+                            } else {
+                                Popup.show(mainActivity, "Create failed. Please check log for the details.");
+                                Log.d(TAG, String.format("Create failed with rc=%d", returnCode));
+                            }
+
+                            return null;
+                        }
+                    });
+                }
+            }, ffmpegCommand);
+
+            // START ASYNC PROCESSES AFTER INITIATING FFMPEG COMMAND
+            startAsyncCatImageProcess(image1File.getAbsolutePath(), pipe1);
+            startAsyncCatImageProcess(image2File.getAbsolutePath(), pipe2);
+            startAsyncCatImageProcess(image3File.getAbsolutePath(), pipe3);
+
+        } catch (IOException e) {
+            Log.e(TAG, "Create video failed", e);
+            Popup.show(mainActivity, "Create video failed");
+        }
+    }
+
+    protected void playVideo() {
+        MediaController mediaController = new MediaController(mainActivity);
+        mediaController.setAnchorView(videoView);
+        videoView.setVideoURI(Uri.parse("file://" + getVideoFile().getAbsolutePath()));
+        videoView.setMediaController(mediaController);
+        videoView.requestFocus();
+        videoView.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
+
+            @Override
+            public void onPrepared(MediaPlayer mp) {
+                videoView.setBackgroundColor(0x00000000);
+            }
+        });
+        videoView.setOnErrorListener(new MediaPlayer.OnErrorListener() {
+
+            @Override
+            public boolean onError(MediaPlayer mp, int what, int extra) {
+                videoView.stopPlayback();
+                return false;
+            }
+        });
+        videoView.start();
+    }
+
+    protected File getVideoFile() {
+        return new File(mainActivity.getFilesDir(), "video.mp4");
+    }
+
+    public void setActive() {
+        Log.i(MainActivity.TAG, "Pipe Tab Activated");
+        enableLogCallback();
+        enableStatisticsCallback();
+        Popup.show(mainActivity, Tooltip.PIPE_TEST_TOOLTIP_TEXT);
+    }
+
+    protected void showProgressDialog() {
+
+        // CLEAN STATISTICS
+        statistics = null;
+        Config.resetStatistics();
+
+        progressDialog.show();
+    }
+
+    protected void updateProgressDialog() {
+        if (statistics == null) {
+            return;
+        }
+
+        int timeInMilliseconds = this.statistics.getTime();
+        if (timeInMilliseconds > 0) {
+            int totalVideoDuration = 9000;
+
+            String completePercentage = new BigDecimal(timeInMilliseconds).multiply(new BigDecimal(100)).divide(new BigDecimal(totalVideoDuration), 0, BigDecimal.ROUND_HALF_UP).toString();
+
+            TextView textView = progressDialog.findViewById(R.id.progressDialogText);
+            if (textView != null) {
+                textView.setText(String.format("Creating video: %% %s", completePercentage));
+            }
+        }
+    }
+
+    protected void hideProgressDialog() {
+        progressDialog.dismiss();
+
+        MainActivity.addUIAction(new Callable() {
+
+            @Override
+            public Object call() {
+                PipeTabFragment.this.progressDialog = mainActivity.createProgressDialog("Creating video");
+                return null;
+            }
+        });
+    }
+
+}
@@ -40,7 +40,7 @@ import com.arthenica.mobileffmpeg.LogCallback;
 import com.arthenica.mobileffmpeg.LogMessage;
 import com.arthenica.mobileffmpeg.Statistics;
 import com.arthenica.mobileffmpeg.StatisticsCallback;
-import com.arthenica.mobileffmpeg.util.RunCallback;
+import com.arthenica.mobileffmpeg.util.ExecuteCallback;

 import java.io.File;
 import java.io.IOException;
@@ -172,10 +172,10 @@ public class SubtitleTabFragment extends Fragment {

            state = State.CREATING;

-            MainActivity.executeAsync(new RunCallback() {
+            MainActivity.executeAsync(new ExecuteCallback() {

                @Override
-                public void apply(final int returnCode) {
+                public void apply(final int returnCode, final String commandOutput) {
                    Log.d(TAG, String.format("FFmpeg process exited with rc %d", returnCode));

                    state = State.IDLE;
@@ -198,10 +198,10 @@ public class SubtitleTabFragment extends Fragment {

                                state = State.BURNING;

-                                MainActivity.executeAsync(new RunCallback() {
+                                MainActivity.executeAsync(new ExecuteCallback() {

                                    @Override
-                                    public void apply(final int returnCode) {
+                                    public void apply(final int returnCode, final String commandOutput) {
                                        Log.d(TAG, String.format("FFmpeg process exited with rc %d", returnCode));

                                        state = State.IDLE;
@@ -39,4 +39,7 @@ public interface Tooltip {
    // VID.STAB TEST
    String VIDSTAB_TEST_TOOLTIP_TEXT = "Click the button to stabilize video. Original video will play above and stabilized video will play below";

+    // PIPE TEST
+    String PIPE_TEST_TOOLTIP_TEXT = "Click the button to create a video using pipe redirection. Created video will play inside the frame below";
+
 }
@@ -35,7 +35,7 @@ import android.widget.VideoView;
 import com.arthenica.mobileffmpeg.Config;
 import com.arthenica.mobileffmpeg.LogCallback;
 import com.arthenica.mobileffmpeg.LogMessage;
-import com.arthenica.mobileffmpeg.util.RunCallback;
+import com.arthenica.mobileffmpeg.util.ExecuteCallback;

 import java.io.File;
 import java.io.IOException;
@@ -143,10 +143,10 @@ public class VidStabTabFragment extends Fragment {

            android.util.Log.d(TAG, String.format("FFmpeg process started with arguments\n'%s'", ffmpegCommand));

-            MainActivity.executeAsync(new RunCallback() {
+            MainActivity.executeAsync(new ExecuteCallback() {

                @Override
-                public void apply(final int returnCode) {
+                public void apply(final int returnCode, final String commandOutput) {
                    android.util.Log.d(TAG, String.format("FFmpeg process exited with rc %d", returnCode));

                    hideCreateProgressDialog();
@@ -165,10 +165,10 @@ public class VidStabTabFragment extends Fragment {

                                android.util.Log.d(TAG, String.format("FFmpeg process started with arguments\n'%s'", analyzeVideoCommand));

-                                MainActivity.executeAsync(new RunCallback() {
+                                MainActivity.executeAsync(new ExecuteCallback() {

                                    @Override
-                                    public void apply(final int returnCode) {
+                                    public void apply(final int returnCode, final String commandOutput) {
                                        android.util.Log.d(TAG, String.format("FFmpeg process exited with rc %d", returnCode));

                                        if (returnCode == RETURN_CODE_SUCCESS) {
@@ -176,10 +176,10 @@ public class VidStabTabFragment extends Fragment {

                                            android.util.Log.d(TAG, String.format("FFmpeg process started with arguments\n'%s'", stabilizeVideoCommand));

-                                            MainActivity.executeAsync(new RunCallback() {
+                                            MainActivity.executeAsync(new ExecuteCallback() {

                                                @Override
-                                                public void apply(final int returnCode) {
+                                                public void apply(final int returnCode, final String commandOutput) {
                                                    android.util.Log.d(TAG, String.format("FFmpeg process exited with rc %d", returnCode));

                                                    hideStabilizeProgressDialog();
@@ -19,14 +19,37 @@

 package com.arthenica.mobileffmpeg.test;

+import java.util.Locale;
+
 /**
- * <p>Generates an FFmpeg command to create a 640x427 video from provided images.
+ * <p>Generates FFmpeg scripts to create videos from provided images.
 *
 * @author Taner Sener
 */
 public class Video {

-    public static String generateEncodeVideoScript(final String image1Path, final String image2Path, final String image3Path, final String videoFilePath, final String videoCodec, final String customOptions) {
+    static String generateCreateVideoWithPipesScript(final String image1Pipe, final String image2Pipe, final String image3Pipe, final String videoFilePath) {
+        return
+                "-hide_banner -y -i " + image1Pipe + " " +
+                        "-i " + image2Pipe + " " +
+                        "-i " + image3Pipe + " " +
+                        "-filter_complex " +
+                        "[0:v]loop=loop=-1:size=1:start=0,setpts=PTS-STARTPTS,scale=w=\'if(gte(iw/ih,640/427),min(iw,640),-1)\':h=\'if(gte(iw/ih,640/427),-1,min(ih,427))\',scale=trunc(iw/2)*2:trunc(ih/2)*2,setsar=sar=1/1,split=2[stream1out1][stream1out2];" +
+                        "[1:v]loop=loop=-1:size=1:start=0,setpts=PTS-STARTPTS,scale=w=\'if(gte(iw/ih,640/427),min(iw,640),-1)\':h=\'if(gte(iw/ih,640/427),-1,min(ih,427))\',scale=trunc(iw/2)*2:trunc(ih/2)*2,setsar=sar=1/1,split=2[stream2out1][stream2out2];" +
+                        "[2:v]loop=loop=-1:size=1:start=0,setpts=PTS-STARTPTS,scale=w=\'if(gte(iw/ih,640/427),min(iw,640),-1)\':h=\'if(gte(iw/ih,640/427),-1,min(ih,427))\',scale=trunc(iw/2)*2:trunc(ih/2)*2,setsar=sar=1/1,split=2[stream3out1][stream3out2];" +
+                        "[stream1out1]pad=width=640:height=427:x=(640-iw)/2:y=(427-ih)/2:color=#00000000,trim=duration=3,select=lte(n\\,90)[stream1overlaid];" +
+                        "[stream1out2]pad=width=640:height=427:x=(640-iw)/2:y=(427-ih)/2:color=#00000000,trim=duration=1,select=lte(n\\,30)[stream1ending];" +
+                        "[stream2out1]pad=width=640:height=427:x=(640-iw)/2:y=(427-ih)/2:color=#00000000,trim=duration=2,select=lte(n\\,60)[stream2overlaid];" +
+                        "[stream2out2]pad=width=640:height=427:x=(640-iw)/2:y=(427-ih)/2:color=#00000000,trim=duration=1,select=lte(n\\,30),split=2[stream2starting][stream2ending];" +
+                        "[stream3out1]pad=width=640:height=427:x=(640-iw)/2:y=(427-ih)/2:color=#00000000,trim=duration=2,select=lte(n\\,60)[stream3overlaid];" +
+                        "[stream3out2]pad=width=640:height=427:x=(640-iw)/2:y=(427-ih)/2:color=#00000000,trim=duration=1,select=lte(n\\,30)[stream3starting];" +
+                        "[stream2starting][stream1ending]blend=all_expr=\'if(gte(X,(W/2)*T/1)*lte(X,W-(W/2)*T/1),B,A)\':shortest=1[stream2blended];" +
+                        "[stream3starting][stream2ending]blend=all_expr=\'if(gte(X,(W/2)*T/1)*lte(X,W-(W/2)*T/1),B,A)\':shortest=1[stream3blended];" +
+                        "[stream1overlaid][stream2blended][stream2overlaid][stream3blended][stream3overlaid]concat=n=5:v=1:a=0,scale=w=640:h=424,format=yuv420p[video]" +
+                        " -map [video] -vsync 2 -async 1 -c:v mpeg4 -r 30 " + videoFilePath;
+    }
+
+    static String generateEncodeVideoScript(final String image1Path, final String image2Path, final String image3Path, final String videoFilePath, final String videoCodec, final String customOptions) {
        return
                "-hide_banner -y -loop 1 -i " + image1Path + " " +
                        "-loop 1 -i " + image2Path + " " +
@@ -44,10 +67,10 @@ public class Video {
                        "[stream2starting][stream1ending]blend=all_expr=\'if(gte(X,(W/2)*T/1)*lte(X,W-(W/2)*T/1),B,A)\':shortest=1[stream2blended];" +
                        "[stream3starting][stream2ending]blend=all_expr=\'if(gte(X,(W/2)*T/1)*lte(X,W-(W/2)*T/1),B,A)\':shortest=1[stream3blended];" +
                        "[stream1overlaid][stream2blended][stream2overlaid][stream3blended][stream3overlaid]concat=n=5:v=1:a=0,scale=w=640:h=424,format=yuv420p[video]" +
-                        " -map [video] -vsync 2 -async 1 " + customOptions + "-c:v " + videoCodec.toLowerCase() + " -r 30 " + videoFilePath;
+                        " -map [video] -vsync 2 -async 1 " + customOptions + "-c:v " + videoCodec.toLowerCase(Locale.ENGLISH) + " -r 30 " + videoFilePath;
    }

-    public static String generateShakingVideoScript(final String image1Path, final String image2Path, final String image3Path, final String videoFilePath) {
+    static String generateShakingVideoScript(final String image1Path, final String image2Path, final String image3Path, final String videoFilePath) {
        return
                "-hide_banner -y -loop 1 -i " + image1Path + " " +
                        "-loop 1 -i " + image2Path + " " +
@@ -43,7 +43,7 @@ import com.arthenica.mobileffmpeg.LogCallback;
 import com.arthenica.mobileffmpeg.LogMessage;
 import com.arthenica.mobileffmpeg.Statistics;
 import com.arthenica.mobileffmpeg.StatisticsCallback;
-import com.arthenica.mobileffmpeg.util.RunCallback;
+import com.arthenica.mobileffmpeg.util.ExecuteCallback;

 import java.io.File;
 import java.io.IOException;
@@ -183,10 +183,10 @@ public class VideoTabFragment extends Fragment implements AdapterView.OnItemSele

            Log.d(TAG, String.format("FFmpeg process started with arguments\n'%s'", ffmpegCommand));

-            MainActivity.executeAsync(new RunCallback() {
+            MainActivity.executeAsync(new ExecuteCallback() {

                @Override
-                public void apply(final int returnCode) {
+                public void apply(final int returnCode, final String commandOutput) {
                    Log.d(TAG, String.format("FFmpeg process exited with rc %d", returnCode));

                    hideProgressDialog();
@@ -339,15 +339,13 @@ public class VideoTabFragment extends Fragment implements AdapterView.OnItemSele
                return "-b:v 2M ";
            case "aom":
                return "-crf 30 -strict experimental ";
-            case "kvazaar":
-                return "-preset fast ";
            case "theora":
                return "-qscale:v 7 ";
            case "hap":
                return "-format hap_q ";
            default:

-                // mpeg4, x264, xvid
+                // kvazaar, mpeg4, x264, xvid
                return "";
        }
    }
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2018-2019 Taner Sener
+ *
+ * This file is part of MobileFFmpeg.
+ *
+ * MobileFFmpeg is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * MobileFFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with MobileFFmpeg.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.arthenica.mobileffmpeg.util;
+
+import android.os.AsyncTask;
+import android.util.Log;
+
+import java.io.IOException;
+
+import static com.arthenica.mobileffmpeg.test.MainActivity.TAG;
+
+public class AsyncCatImageTask extends AsyncTask<String, Integer, Integer> {
+
+    @Override
+    protected Integer doInBackground(String... inputs) {
+        try {
+            final String asyncCommand = "cat " + inputs[0] + " > " + inputs[1];
+            Log.d(TAG, String.format("Starting async cat image command: %s", asyncCommand));
+
+            final Process process = Runtime.getRuntime().exec(new String[]{"sh", "-c", asyncCommand});
+            int rc = process.waitFor();
+
+            Log.d(TAG, String.format("Async cat image command: %s exited with %d.", asyncCommand, rc));
+
+            return rc;
+        } catch (final IOException | InterruptedException e) {
+            Log.e(TAG, String.format("Async cat image command failed for %s.", inputs[0]), e);
+            return -1;
+        }
+    }
+
+}
@@ -1,53 +0,0 @@
-/*
- * Copyright (c) 2018 Taner Sener
- *
- * This file is part of MobileFFmpeg.
- *
- * MobileFFmpeg is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MobileFFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with MobileFFmpeg.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.arthenica.mobileffmpeg.util;
-
-import android.support.annotation.NonNull;
-
-import java.text.MessageFormat;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.atomic.AtomicInteger;
-
-public class AsyncThreadFactory implements ThreadFactory {
-
-    protected static final String DEFAULT_THREAD_NAME_PREFIX = "AsyncTaskThread";
-
-    protected static AtomicInteger threadCounter;
-
-    static {
-        threadCounter = new AtomicInteger(1);
-    }
-
-    private final String namePrefix;
-
-    public AsyncThreadFactory() {
-        this(DEFAULT_THREAD_NAME_PREFIX);
-    }
-
-    public AsyncThreadFactory(final String namePrefix) {
-        this.namePrefix = namePrefix;
-    }
-
-    @Override
-    public Thread newThread(@NonNull final Runnable runnable) {
-        return new Thread(runnable, MessageFormat.format("{0}-{1,number,#}", namePrefix, threadCounter.getAndIncrement()));
-    }
-
-}
@@ -1,121 +0,0 @@
-/*
- * Copyright (c) 2018 Taner Sener
- *
- * This file is part of MobileFFmpeg.
- *
- * MobileFFmpeg is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MobileFFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with MobileFFmpeg.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.arthenica.mobileffmpeg.util;
-
-import android.util.Log;
-
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.Callable;
-import java.util.concurrent.Future;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-
-public class AsynchronousTaskService {
-
-    protected static final String TAG = "mobile-ffmpeg-android";
-
-    protected final BlockingQueue<Runnable> queue;
-
-    protected final Object executorServiceLock;
-
-    protected ThreadPoolExecutor executorService;
-
-    protected int coreThreadPoolSize;
-
-    protected int maximumThreadPoolSize;
-
-    protected int keepAliveTimeInSeconds;
-
-    public AsynchronousTaskService() {
-        this(1, 5, 30);
-    }
-
-    public AsynchronousTaskService(final int coreThreadPoolSize, final int maximumThreadPoolSize, final int keepAliveTimeInSeconds) {
-        this.executorServiceLock = new Object();
-        this.queue = new LinkedBlockingQueue<>();
-        this.executorService = null;
-
-        this.coreThreadPoolSize = coreThreadPoolSize;
-        this.maximumThreadPoolSize = maximumThreadPoolSize;
-        this.keepAliveTimeInSeconds = keepAliveTimeInSeconds;
-    }
-
-    public void init(final int coreThreadPoolSize, final int maximumThreadPoolSize, final int keepAliveTimeInSeconds) {
-        this.coreThreadPoolSize = coreThreadPoolSize;
-        this.maximumThreadPoolSize = maximumThreadPoolSize;
-        this.keepAliveTimeInSeconds = keepAliveTimeInSeconds;
-    }
-
-    public void initializeExecutorService() {
-        synchronized (executorServiceLock) {
-            if (executorService != null) {
-                executorService.shutdown();
-            }
-
-            executorService = new ThreadPoolExecutor(coreThreadPoolSize, maximumThreadPoolSize, keepAliveTimeInSeconds, TimeUnit.SECONDS, queue, new AsyncThreadFactory());
-        }
-    }
-
-    public <T> Future<T> runAsynchronously(final Callable<T> callable) {
-
-        /* INITIALIZE EXECUTOR SERVICE ONLY IF NECESSARY */
-        if (executorService == null) {
-            initializeExecutorService();
-        }
-
-        final String className = callable.getClass().getSimpleName();
-
-        try {
-            return executorService.submit(callable);
-        } catch (Exception e) {
-            Log.w(TAG, String.format("Failed to run asynchronous task %s. Running it synchronously.", className), e);
-            return runSynchronously(callable);
-        }
-    }
-
-    public <T> Future<T> runSynchronously(final Callable<T> callable) {
-        T called = null;
-
-        /* INITIALIZE EXECUTOR SERVICE ONLY IF NECESSARY */
-        if (executorService == null) {
-            initializeExecutorService();
-        }
-
-        final String className = callable.getClass().getSimpleName();
-
-        try {
-            called = callable.call();
-            return new SynchronousResultFuture<>(called, true);
-        } catch (final Exception e) {
-            Log.d(TAG, "Failed to run asynchronous task " + className + " synchronously.", e);
-            return new SynchronousResultFuture<>(called, true);
-        }
-    }
-
-    public void shutdown() {
-        if (executorService != null) {
-            synchronized (executorServiceLock) {
-                executorService.shutdown();
-            }
-        }
-    }
-
-}
@@ -1,63 +0,0 @@
-/*
- * Copyright (c) 2018 Taner Sener
- *
- * This file is part of MobileFFmpeg.
- *
- * MobileFFmpeg is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * MobileFFmpeg is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with MobileFFmpeg.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.arthenica.mobileffmpeg.util;
-
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-public class SynchronousResultFuture<V> implements Future<V> {
-
-    protected final V v;
-
-    protected final boolean completed;
-
-    public SynchronousResultFuture(final V v, final boolean completed) {
-        this.v = v;
-        this.completed = completed;
-    }
-
-    @Override
-    public boolean cancel(final boolean mayInterruptIfRunning) {
-        return false;
-    }
-
-    @Override
-    public boolean isCancelled() {
-        return !completed;
-    }
-
-    @Override
-    public boolean isDone() {
-        return completed;
-    }
-
-    @Override
-    public V get() throws InterruptedException, ExecutionException {
-        return v;
-    }
-
-    @Override
-    public V get(final long timeout, final TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
-        return v;
-    }
-
-}
@@ -4,7 +4,6 @@
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
-    android:background="@color/headerColor"
    android:gravity="top"
    android:orientation="vertical">

@@ -6,16 +6,18 @@

    <LinearLayout
        android:layout_width="match_parent"
-        android:layout_height="60dp"
-        android:layout_marginTop="10dp">
+        android:layout_height="80dp"
+        android:gravity="center_horizontal|center_vertical">

        <ProgressBar
            android:id="@+id/progressBar"
            style="?android:attr/progressBarStyle"
            android:layout_width="46dp"
            android:layout_height="match_parent"
-            android:layout_marginEnd="30dp"
-            android:layout_marginStart="30dp"
+            android:layout_marginStart="10dp"
+            android:layout_marginLeft="10dp"
+            android:layout_marginEnd="10dp"
+            android:layout_marginRight="10dp"
            android:gravity="center|start" />

        <TextView
@@ -8,6 +8,7 @@
    tools:context=".CommandTabFragment">

    <EditText
+        tools:ignore="Autofill"
        android:id="@+id/commandText"
        android:layout_width="match_parent"
        android:layout_height="40dp"
@@ -17,7 +18,8 @@
        android:layout_marginTop="20dp"
        android:hint="@string/command_text_input_placeholder"
        android:inputType="text"
-        android:singleLine="true" />
+        android:singleLine="true"
+        tools:targetApi="cupcake" />

    <Button
        android:id="@+id/runButton"
@@ -32,7 +34,8 @@
        android:textAlignment="center"
        android:textColor="@android:color/white"
        android:textSize="16sp"
-        android:textStyle="bold" />
+        android:textStyle="bold"
+        tools:targetApi="jelly_bean" />

    <Button
        android:id="@+id/runAsyncButton"
@@ -47,7 +50,8 @@
        android:textAlignment="center"
        android:textColor="@android:color/white"
        android:textSize="16sp"
-        android:textStyle="bold" />
+        android:textStyle="bold"
+        tools:targetApi="jelly_bean" />

    <TextView
        android:id="@+id/outputText"
@@ -65,5 +69,6 @@
        android:scrollbars="vertical"
        android:textColor="@android:color/black"
        android:textSize="14sp"
-        android:typeface="sans" />
+        android:typeface="sans"
+        tools:targetApi="jelly_bean" />
 </LinearLayout>
@@ -8,6 +8,7 @@
    tools:context=".HttpsTabFragment">

    <EditText
+        tools:ignore="Autofill"
        android:id="@+id/urlText"
        android:layout_width="match_parent"
        android:layout_height="40dp"
@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:gravity="center"
+    android:orientation="vertical"
+    tools:context=".PipeTabFragment">
+
+    <LinearLayout
+        android:id="@+id/createButtonLayout"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="horizontal"
+        android:gravity="center">
+
+        <Button
+            android:id="@+id/createButton"
+            android:layout_width="90dp"
+            android:layout_height="36dp"
+            android:layout_marginBottom="20dp"
+            android:layout_marginTop="20dp"
+            android:background="@drawable/rounded_button"
+            android:fontFamily="sans-serif"
+            android:gravity="center"
+            android:text="@string/video_create_button_text"
+            android:textAlignment="center"
+            android:textColor="@android:color/white"
+            android:textSize="16sp"
+            android:textStyle="bold" />
+    </LinearLayout>
+
+    <VideoView
+        android:id="@+id/videoPlayerFrame"
+        android:layout_width="wrap_content"
+        android:background="@drawable/rounded_video_frame"
+        android:layout_height="0dp"
+        android:layout_gravity="bottom"
+        android:layout_margin="20dp"
+        android:layout_weight="1" />
+</LinearLayout>
@@ -1,20 +1,23 @@
 <?xml version="1.0" encoding="utf-8"?>
 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
-    android:layout_height="match_parent">
+    android:layout_height="match_parent"
+    android:orientation="vertical">

-    <TableRow
+    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="80dp"
-        android:layout_centerInParent="true">
+        android:gravity="center_horizontal|center_vertical">

        <ProgressBar
            android:id="@+id/progressBar"
            style="?android:attr/progressBarStyle"
            android:layout_width="46dp"
            android:layout_height="match_parent"
-            android:layout_marginEnd="30dp"
-            android:layout_marginStart="30dp"
+            android:layout_marginStart="10dp"
+            android:layout_marginLeft="10dp"
+            android:layout_marginEnd="10dp"
+            android:layout_marginRight="10dp"
            android:gravity="center|start" />

        <TextView
@@ -24,5 +27,5 @@
            android:gravity="center|start"
            android:textColor="@android:color/black"
            android:textSize="18sp" />
-    </TableRow>
+    </LinearLayout>
 </RelativeLayout>
@@ -1,14 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-    <color name="colorPrimary">#e74c3c</color>
-    <color name="colorPrimaryDark">#c0392b</color>
-    <color name="colorAccent">#3498db</color>
    <color name="headerColor">#e74c3c</color>
-    <color name="buttonColor">#2ecc71</color>
    <color name="editColor">#3498db</color>
-    <color name="comboColor">#9b59b6</color>
-    <color name="playerColor">#ecf0f1</color>
-    <color name="outputColor">#f1c40f</color>
-    <color name="navigationBarColor">#f39c12</color>
    <color name="navigationColor">#e67e22</color>
 </resources>
@@ -6,14 +6,16 @@
    <string name="audio_tab">AUDIO</string>
    <string name="subtitle_tab">SUBTITLE</string>
    <string name="vidstab_tab">VID.STAB</string>
+    <string name="pipe_tab">PIPE</string>
    <string name="command_text_input_placeholder">Enter command</string>
    <string name="command_run_async_button_text">RUN ASYNC</string>
    <string name="command_run_button_text">RUN</string>
    <string name="video_encode_button_text">ENCODE</string>
+    <string name="video_create_button_text">CREATE</string>
    <string name="https_get_info_button_text">GET INFO</string>
    <string name="https_text_input_placeholder">Enter https url</string>
    <string name="audio_encode_button_text">ENCODE</string>
    <string name="subtitle_burn_subtitles_button_text">BURN SUBTITLES</string>
    <string name="vidstab_stabilize_video_button_text">STABILIZE VIDEO</string>
-    <string name="dialog_cancel_button_text">CANCEL</string>
+    <string name="dialog_cancel_button_text">Cancel</string>
 </resources>
@@ -5,7 +5,6 @@
        <item name="colorPrimary">@color/headerColor</item>
        <item name="colorPrimaryDark">@color/headerColor</item>
        <item name="colorAccent">@color/editColor</item>
-        <item name="android:navigationBarColor">@color/editColor</item>
    </style>

 </resources>
@@ -47,21 +47,21 @@ cmake -Wno-dev \
    -DCMAKE_C_FLAGS="${CFLAGS}" \
    -DCMAKE_CXX_FLAGS="${CXXFLAGS}" \
    -DCMAKE_EXE_LINKER_FLAGS="${LDFLAGS}" \
-    -DCMAKE_SYSROOT="${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot" \
-    -DCMAKE_FIND_ROOT_PATH="${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot" \
+    -DCMAKE_SYSROOT="${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot" \
+    -DCMAKE_FIND_ROOT_PATH="${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot" \
    -DCMAKE_BUILD_TYPE=Release \
    -DCMAKE_INSTALL_PREFIX="${BASEDIR}/prebuilt/android-$(get_target_build)/${LIB_NAME}" \
    -DCMAKE_SYSTEM_NAME=Generic \
-    -DCMAKE_C_COMPILER="${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/bin/$CC" \
-    -DCMAKE_LINKER="${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/bin/$LD" \
-    -DCMAKE_AR="${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/bin/$AR" \
-    -DCMAKE_AS="${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/bin/$AS" \
+    -DCMAKE_C_COMPILER="${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/bin/$CC" \
+    -DCMAKE_LINKER="${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/bin/$LD" \
+    -DCMAKE_AR="${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/bin/$AR" \
+    -DCMAKE_AS="${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/bin/$AS" \
    -DCMAKE_SYSTEM_PROCESSOR=$(get_cmake_target_processor) \
    -DCMAKE_POSITION_INDEPENDENT_CODE=1 \
    -DFFT_LIB=kissfft \
    -DBUILD_SHARED_LIBS=0 .. || exit 1

-make ${MOBILE_FFMPEG_DEBUG} -j$(get_cpu_count) || exit 1
+make -j$(get_cpu_count) || exit 1

 # CREATE PACKAGE CONFIG MANUALLY
 create_chromaprint_package_config "1.4.3"
@@ -49,18 +49,19 @@ get_library_name() {
        28) echo "twolame" ;;
        29) echo "sdl" ;;
        30) echo "tesseract" ;;
-        31) echo "giflib" ;;
-        32) echo "jpeg" ;;
-        33) echo "libogg" ;;
-        34) echo "libpng" ;;
-        35) echo "libuuid" ;;
-        36) echo "nettle" ;;
-        37) echo "tiff" ;;
-        38) echo "expat" ;;
-        39) echo "libsndfile" ;;
-        40) echo "leptonica" ;;
-        41) echo "android-zlib" ;;
-        42) echo "android-media-codec" ;;
+        31) echo "openh264" ;;
+        32) echo "giflib" ;;
+        33) echo "jpeg" ;;
+        34) echo "libogg" ;;
+        35) echo "libpng" ;;
+        36) echo "libuuid" ;;
+        37) echo "nettle" ;;
+        38) echo "tiff" ;;
+        39) echo "expat" ;;
+        40) echo "libsndfile" ;;
+        41) echo "leptonica" ;;
+        42) echo "android-zlib" ;;
+        43) echo "android-media-codec" ;;
    esac
 }

@@ -91,23 +92,42 @@ get_target_host() {
    esac
 }

-get_toolchain() {
+
+get_clang_target_host() {
    case ${ARCH} in
        arm-v7a | arm-v7a-neon)
-            echo "arm"
+            echo "armv7a-linux-androideabi${API}"
        ;;
        arm64-v8a)
-            echo "aarch64"
+            echo "aarch64-linux-android${API}"
        ;;
        x86)
-            echo "i686"
+            echo "i686-linux-android${API}"
        ;;
        x86-64)
-            echo "x86_64"
+            echo "x86_64-linux-android${API}"
        ;;
    esac
 }

+get_toolchain() {
+    HOST_OS=$(uname -s)
+    case ${HOST_OS} in
+        Darwin) HOST_OS=darwin;;
+        Linux) HOST_OS=linux;;
+        FreeBsd) HOST_OS=freebsd;;
+        CYGWIN*|*_NT-*) HOST_OS=cygwin;;
+    esac
+
+    HOST_ARCH=$(uname -m)
+    case ${HOST_ARCH} in
+        i?86) HOST_ARCH=x86;;
+        x86_64|amd64) HOST_ARCH=x86_64;;
+    esac
+
+    echo "${HOST_OS}-${HOST_ARCH}"
+}
+
 get_cmake_target_processor() {
    case ${ARCH} in
        arm-v7a | arm-v7a-neon)
@@ -131,7 +151,11 @@ get_target_build() {
            echo "arm"
        ;;
        arm-v7a-neon)
-            echo "arm/neon"
+            if [[ ! -z ${MOBILE_FFMPEG_LTS_BUILD} ]]; then
+                echo "arm/neon"
+            else
+                echo "arm"
+            fi
        ;;
        arm64-v8a)
            echo "arm64"
@@ -180,11 +204,15 @@ get_android_arch() {
 }

 get_common_includes() {
-    echo "-I${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot/usr/include -I${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot/usr/local/include"
+    echo "-I${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot/usr/include -I${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot/usr/local/include"
 }

 get_common_cflags() {
-    echo "-fstrict-aliasing -fPIC -DANDROID -D__ANDROID__ -D__ANDROID_API__=${API}"
+    if [[ ! -z ${MOBILE_FFMPEG_LTS_BUILD} ]]; then
+        local LTS_BUILD__FLAG="-DMOBILE_FFMPEG_LTS "
+    fi
+
+    echo "-fno-integrated-as -fstrict-aliasing -fPIC -DANDROID ${LTS_BUILD__FLAG}-D__ANDROID__ -D__ANDROID_API__=${API}"
 }

 get_arch_specific_cflags() {
@@ -208,39 +236,62 @@ get_arch_specific_cflags() {
 }

 get_size_optimization_cflags() {
+    if [[ -z ${NO_LINK_TIME_OPTIMIZATION} ]]; then
+        local LINK_TIME_OPTIMIZATION_FLAGS="-flto"
+    else
+        local LINK_TIME_OPTIMIZATION_FLAGS=""
+    fi

-    ARCH_OPTIMIZATION=""
+    local ARCH_OPTIMIZATION=""
    case ${ARCH} in
-        arm-v7a | arm-v7a-neon | arm64-v8a)
-            if [[ $1 -eq libwebp ]]; then
-                ARCH_OPTIMIZATION="-Os"
-            else
-                ARCH_OPTIMIZATION="-Os -finline-limit=64"
-            fi
+        arm-v7a | arm-v7a-neon)
+            case $1 in
+                ffmpeg)
+                    ARCH_OPTIMIZATION="${LINK_TIME_OPTIMIZATION_FLAGS} -O2 -ffunction-sections -fdata-sections"
+                ;;
+                *)
+                    ARCH_OPTIMIZATION="-Os -ffunction-sections -fdata-sections"
+                ;;
+            esac
+        ;;
+        arm64-v8a)
+            case $1 in
+                ffmpeg)
+                    ARCH_OPTIMIZATION="${LINK_TIME_OPTIMIZATION_FLAGS} -fuse-ld=gold -O2 -ffunction-sections -fdata-sections"
+                ;;
+                *)
+                    ARCH_OPTIMIZATION="-Os -ffunction-sections -fdata-sections"
+                ;;
+            esac
        ;;
        x86 | x86-64)
-            if [[ $1 -eq libvpx ]]; then
-                ARCH_OPTIMIZATION="-O2"
-            else
-                ARCH_OPTIMIZATION="-O2 -finline-limit=300"
-            fi
-
+            case $1 in
+                ffmpeg)
+                    ARCH_OPTIMIZATION="${LINK_TIME_OPTIMIZATION_FLAGS} -Os -ffunction-sections -fdata-sections"
+                ;;
+                *)
+                    ARCH_OPTIMIZATION="-Os -ffunction-sections -fdata-sections"
+                ;;
+            esac
        ;;
    esac

-    LIB_OPTIMIZATION=""
+    local LIB_OPTIMIZATION=""

    echo "${ARCH_OPTIMIZATION} ${LIB_OPTIMIZATION}"
 }

 get_app_specific_cflags() {

-    APP_FLAGS=""
+    local APP_FLAGS=""
    case $1 in
        xvidcore)
            APP_FLAGS=""
        ;;
-        ffmpeg | shine)
+        ffmpeg)
+            APP_FLAGS="-Wno-unused-function -DBIONIC_IOCTL_NO_SIGNEDNESS_OVERLOAD"
+        ;;
+        shine)
            APP_FLAGS="-Wno-unused-function"
        ;;
        soxr | snappy | libwebp)
@@ -258,46 +309,72 @@ get_app_specific_cflags() {
 }

 get_cflags() {
-    ARCH_FLAGS=$(get_arch_specific_cflags)
-    APP_FLAGS=$(get_app_specific_cflags $1)
-    COMMON_FLAGS=$(get_common_cflags)
+    local ARCH_FLAGS=$(get_arch_specific_cflags)
+    local APP_FLAGS=$(get_app_specific_cflags $1)
+    local COMMON_FLAGS=$(get_common_cflags)
    if [[ -z ${MOBILE_FFMPEG_DEBUG} ]]; then
-        OPTIMIZATION_FLAGS=$(get_size_optimization_cflags $1)
+        local OPTIMIZATION_FLAGS=$(get_size_optimization_cflags $1)
    else
-        OPTIMIZATION_FLAGS=""
+        local OPTIMIZATION_FLAGS="${MOBILE_FFMPEG_DEBUG}"
    fi
-    COMMON_INCLUDES=$(get_common_includes)
+    local COMMON_INCLUDES=$(get_common_includes)

    echo "${ARCH_FLAGS} ${APP_FLAGS} ${COMMON_FLAGS} ${OPTIMIZATION_FLAGS} ${COMMON_INCLUDES}"
 }

 get_cxxflags() {
+    if [[ -z ${NO_LINK_TIME_OPTIMIZATION} ]]; then
+        local LINK_TIME_OPTIMIZATION_FLAGS="-flto"
+    else
+        local LINK_TIME_OPTIMIZATION_FLAGS=""
+    fi
+
+    if [[ -z ${MOBILE_FFMPEG_DEBUG} ]]; then
+        local OPTIMIZATION_FLAGS="-Os -ffunction-sections -fdata-sections"
+    else
+        local OPTIMIZATION_FLAGS="${MOBILE_FFMPEG_DEBUG}"
+    fi
+
    case $1 in
        gnutls)
-            echo "-std=c++11 -fno-rtti"
+            echo "-std=c++11 -fno-rtti ${OPTIMIZATION_FLAGS}"
+        ;;
+        ffmpeg)
+            if [[ -z ${MOBILE_FFMPEG_DEBUG} ]]; then
+                echo "-std=c++11 -fno-exceptions -fno-rtti ${LINK_TIME_OPTIMIZATION_FLAGS} -O2 -ffunction-sections -fdata-sections"
+            else
+                echo "-std=c++11 -fno-exceptions -fno-rtti ${MOBILE_FFMPEG_DEBUG}"
+            fi
        ;;
        opencore-amr)
-            echo ""
+            echo "${OPTIMIZATION_FLAGS}"
        ;;
        x265)
-            echo "-std=c++11 -fno-exceptions"
+            echo "-std=c++11 -fno-exceptions ${OPTIMIZATION_FLAGS}"
        ;;
        *)
-            echo "-std=c++11 -fno-exceptions -fno-rtti"
+            echo "-std=c++11 -fno-exceptions -fno-rtti ${OPTIMIZATION_FLAGS}"
        ;;
    esac
 }

 get_common_linked_libraries() {
-    local COMMON_LIBRARY_PATHS="-L${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/${TARGET_HOST}/lib -L${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot/usr/lib -L${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/lib"
+    local COMMON_LIBRARY_PATHS="-L${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/${TARGET_HOST}/lib -L${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot/usr/lib/${TARGET_HOST}/${API} -L${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/lib"

    case $1 in
-        ffmpeg | tesseract)
-            echo "-lc -lm -ldl -llog -lc++_shared ${COMMON_LIBRARY_PATHS}"
+        ffmpeg)
+            if [[ -z ${MOBILE_FFMPEG_LTS_BUILD} ]]; then
+                echo "-lc -lm -ldl -llog -lcamera2ndk -lmediandk ${COMMON_LIBRARY_PATHS}"
+            else
+                echo "-lc -lm -ldl -llog ${COMMON_LIBRARY_PATHS}"
+            fi
        ;;
        libvpx)
            echo "-lc -lm ${COMMON_LIBRARY_PATHS}"
        ;;
+        tesseract | x265)
+            echo "-lc -lm -ldl -llog -lc++_shared ${COMMON_LIBRARY_PATHS}"
+        ;;
        *)
            echo "-lc -lm -ldl -llog ${COMMON_LIBRARY_PATHS}"
        ;;
@@ -305,12 +382,32 @@ get_common_linked_libraries() {
 }

 get_size_optimization_ldflags() {
+    if [[ -z ${NO_LINK_TIME_OPTIMIZATION} ]]; then
+        local LINK_TIME_OPTIMIZATION_FLAGS="-flto"
+    else
+        local LINK_TIME_OPTIMIZATION_FLAGS=""
+    fi
+
    case ${ARCH} in
        arm64-v8a)
-            echo "-Wl,--gc-sections"
+            case $1 in
+                ffmpeg)
+                    echo "-Wl,--gc-sections ${LINK_TIME_OPTIMIZATION_FLAGS} -fuse-ld=gold -O2 -ffunction-sections -fdata-sections -finline-functions"
+                ;;
+                *)
+                    echo "-Wl,--gc-sections -Os -ffunction-sections -fdata-sections"
+                ;;
+            esac
        ;;
        *)
-            echo "-Wl,--gc-sections,--icf=safe"
+            case $1 in
+                ffmpeg)
+                    echo "-Wl,--gc-sections,--icf=safe ${LINK_TIME_OPTIMIZATION_FLAGS} -O2 -ffunction-sections -fdata-sections -finline-functions"
+                ;;
+                *)
+                    echo "-Wl,--gc-sections,--icf=safe -Os -ffunction-sections -fdata-sections"
+                ;;
+            esac
        ;;
    esac
 }
@@ -336,11 +433,15 @@ get_arch_specific_ldflags() {
 }

 get_ldflags() {
-    ARCH_FLAGS=$(get_arch_specific_ldflags)
-    OPTIMIZATION_FLAGS=$(get_size_optimization_ldflags)
-    COMMON_LINKED_LIBS=$(get_common_linked_libraries $1)
+    local ARCH_FLAGS=$(get_arch_specific_ldflags)
+    if [[ -z ${MOBILE_FFMPEG_DEBUG} ]]; then
+        local OPTIMIZATION_FLAGS="$(get_size_optimization_ldflags $1)"
+    else
+        local OPTIMIZATION_FLAGS="${MOBILE_FFMPEG_DEBUG}"
+    fi
+    local COMMON_LINKED_LIBS=$(get_common_linked_libraries $1)

-    echo "${ARCH_FLAGS} ${OPTIMIZATION_FLAGS} ${COMMON_LINKED_LIBS}"
+    echo "${ARCH_FLAGS} ${OPTIMIZATION_FLAGS} ${COMMON_LINKED_LIBS} -Wl,--exclude-libs,libgcc.a -Wl,--exclude-libs,libunwind.a"
 }

 create_chromaprint_package_config() {
@@ -626,7 +727,7 @@ Description: a fast compressor/decompressor
 Version: ${SNAPPY_VERSION}

 Requires:
-Libs: -L\${libdir} -lz
+Libs: -L\${libdir} -lz -lc++
 Cflags: -I\${includedir}
 EOF
 }
@@ -668,7 +769,7 @@ URL: https://github.com/tesseract-ocr/tesseract
 Version: ${TESSERACT_VERSION}

 Requires: lept, libjpeg, libpng, giflib, zlib, libwebp, libtiff-4
-Libs: -L\${libdir} -ltesseract
+Libs: -L\${libdir} -ltesseract -lc++_shared
 Cflags: -I\${includedir}
 EOF
 }
@@ -706,7 +807,7 @@ Version: ${X265_VERSION}

 Requires:
 Libs: -L\${libdir} -lx265
-Libs.private: -lm -lgcc -lgcc -ldl -lgcc -lgcc -ldl
+Libs.private: -lm -lgcc -lgcc -ldl -lgcc -lgcc -ldl -lc++_shared
 Cflags: -I\${includedir}
 EOF
 }
@@ -731,10 +832,10 @@ EOF
 }

 create_zlib_package_config() {
-    ZLIB_VERSION=$(grep '#define ZLIB_VERSION' ${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot/usr/include/zlib.h | grep -Eo '\".*\"' | sed -e 's/\"//g')
+    ZLIB_VERSION=$(grep '#define ZLIB_VERSION' ${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot/usr/include/zlib.h | grep -Eo '\".*\"' | sed -e 's/\"//g')

    cat > "${INSTALL_PKG_CONFIG_DIR}/zlib.pc" << EOF
-prefix=${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot/usr
+prefix=${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot/usr
 exec_prefix=\${prefix}
 libdir=${ANDROID_NDK_ROOT}/platforms/android-${API}/arch-${TOOLCHAIN_ARCH}/usr/lib
 includedir=\${prefix}/include
@@ -812,15 +913,15 @@ download_gpl_library_source() {
            GPL_LIB_DEST_DIR="libvidstab"
        ;;
        x264)
-            GPL_LIB_URL="ftp://ftp.videolan.org/pub/videolan/x264/snapshots/x264-snapshot-20181015-2245-stable.tar.bz2"
-            GPL_LIB_FILE="x264-snapshot-20181015-2245-stable.tar.bz2"
-            GPL_LIB_ORIG_DIR="x264-snapshot-20181015-2245-stable"
+            GPL_LIB_URL="ftp://ftp.videolan.org/pub/videolan/x264/snapshots/x264-snapshot-20190701-2245-stable.tar.bz2"
+            GPL_LIB_FILE="x264-snapshot-20190701-2245-stable.tar.bz2"
+            GPL_LIB_ORIG_DIR="x264-snapshot-20190701-2245-stable"
            GPL_LIB_DEST_DIR="x264"
        ;;
        x265)
-            GPL_LIB_URL="https://download.videolan.org/pub/videolan/x265/x265_2.9.tar.gz"
-            GPL_LIB_FILE="x265-2.9.tar.gz"
-            GPL_LIB_ORIG_DIR="x265_2.9"
+            GPL_LIB_URL="https://download.videolan.org/pub/videolan/x265/x265_3.0.tar.gz"
+            GPL_LIB_FILE="x265-3.0.tar.gz"
+            GPL_LIB_ORIG_DIR="x265_3.0"
            GPL_LIB_DEST_DIR="x265"
        ;;
        xvidcore)
@@ -900,13 +1001,13 @@ download_gpl_library_source() {
 }

 set_toolchain_clang_paths() {
-    export PATH=$PATH:${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/bin
+    export PATH=$PATH:${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/bin

    TARGET_HOST=$(get_target_host)
    
    export AR=${TARGET_HOST}-ar
-    export CC=${TARGET_HOST}-clang
-    export CXX=${TARGET_HOST}-clang++
+    export CC=$(get_clang_target_host)-clang
+    export CXX=$(get_clang_target_host)-clang++

    if [ "$1" == "x264" ]; then
        export AS=${CC}
@@ -914,6 +1015,12 @@ set_toolchain_clang_paths() {
        export AS=${TARGET_HOST}-as
    fi

+    case ${ARCH} in
+        arm64-v8a)
+            export ac_cv_c_bigendian=no
+        ;;
+    esac
+
    export LD=${TARGET_HOST}-ld
    export RANLIB=${TARGET_HOST}-ranlib
    export STRIP=${TARGET_HOST}-strip
@@ -932,47 +1039,6 @@ set_toolchain_clang_paths() {
    prepare_inline_sed
 }

-set_toolchain_gcc_paths() {
-    export PATH=$PATH:${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/bin
-
-    TARGET_HOST=$(get_target_host)
-
-    export AR=${TARGET_HOST}-ar
-    export CC=${TARGET_HOST}-gcc
-    export CXX=${TARGET_HOST}-g++
-
-    if [ "$1" == "x264" ]; then
-        export AS=${CC}
-    else
-        export AS=${TARGET_HOST}-as
-    fi
-
-    export LD=${TARGET_HOST}-ld
-    export RANLIB=${TARGET_HOST}-ranlib
-    export STRIP=${TARGET_HOST}-strip
-
-    export INSTALL_PKG_CONFIG_DIR="${BASEDIR}/prebuilt/android-$(get_target_build)/pkgconfig"
-    export ZLIB_PACKAGE_CONFIG_PATH="${INSTALL_PKG_CONFIG_DIR}/zlib.pc"
-
-    if [ ! -d ${INSTALL_PKG_CONFIG_DIR} ]; then
-        mkdir -p ${INSTALL_PKG_CONFIG_DIR}
-    fi
-
-    if [ ! -f ${ZLIB_PACKAGE_CONFIG_PATH} ]; then
-        create_zlib_package_config
-    fi
-
-    prepare_inline_sed
-}
-
-create_toolchain() {
-    local TOOLCHAIN_DIR="${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-"${TOOLCHAIN}
-
-    if [ ! -d ${TOOLCHAIN_DIR} ]; then
-        ${ANDROID_NDK_ROOT}/build/tools/make_standalone_toolchain.py --arch ${TOOLCHAIN_ARCH} --api ${API} --stl libc++ --install-dir ${TOOLCHAIN_DIR} || exit 1
-    fi
-}
-
 build_cpufeatures() {

    # CLEAN OLD BUILD
@@ -980,18 +1046,40 @@ build_cpufeatures() {
    rm -f ${ANDROID_NDK_ROOT}/sources/android/cpufeatures/libcpufeatures.a 1>>${BASEDIR}/build.log 2>&1
    rm -f ${ANDROID_NDK_ROOT}/sources/android/cpufeatures/libcpufeatures.so 1>>${BASEDIR}/build.log 2>&1

+    echo -e "\nINFO: Building cpu-features for ${ARCH}\n" 1>>${BASEDIR}/build.log 2>&1
+
    set_toolchain_clang_paths "cpu-features"

-    echo -e "\nINFO: Building cpu-features for for ${ARCH}\n" 1>>${BASEDIR}/build.log 2>&1
-
    # THEN BUILD FOR THIS ABI
-    ${TARGET_HOST}-clang -c ${ANDROID_NDK_ROOT}/sources/android/cpufeatures/cpu-features.c -o ${ANDROID_NDK_ROOT}/sources/android/cpufeatures/cpu-features.o 1>>${BASEDIR}/build.log 2>&1
+    $(get_clang_target_host)-clang -c ${ANDROID_NDK_ROOT}/sources/android/cpufeatures/cpu-features.c -o ${ANDROID_NDK_ROOT}/sources/android/cpufeatures/cpu-features.o 1>>${BASEDIR}/build.log 2>&1
    ${TARGET_HOST}-ar rcs ${ANDROID_NDK_ROOT}/sources/android/cpufeatures/libcpufeatures.a ${ANDROID_NDK_ROOT}/sources/android/cpufeatures/cpu-features.o 1>>${BASEDIR}/build.log 2>&1
-    ${TARGET_HOST}-clang -shared ${ANDROID_NDK_ROOT}/sources/android/cpufeatures/cpu-features.o -o ${ANDROID_NDK_ROOT}/sources/android/cpufeatures/libcpufeatures.so 1>>${BASEDIR}/build.log 2>&1
+    $(get_clang_target_host)-clang -shared ${ANDROID_NDK_ROOT}/sources/android/cpufeatures/cpu-features.o -o ${ANDROID_NDK_ROOT}/sources/android/cpufeatures/libcpufeatures.so 1>>${BASEDIR}/build.log 2>&1

    create_cpufeatures_package_config
 }

+build_android_lts_support() {
+
+    # CLEAN OLD BUILD
+    rm -f ${BASEDIR}/android/app/src/main/cpp/android_lts_support.o 1>>${BASEDIR}/build.log 2>&1
+    rm -f ${BASEDIR}/android/app/src/main/cpp/android_lts_support.a 1>>${BASEDIR}/build.log 2>&1
+
+    echo -e "INFO: Building android-lts-support objects for ${ARCH}\n" 1>>${BASEDIR}/build.log 2>&1
+
+    # PREPARING PATHS
+    LIB_NAME="android-lts-support"
+    set_toolchain_clang_paths ${LIB_NAME}
+
+    # PREPARING FLAGS
+    TARGET_HOST=$(get_target_host)
+    CFLAGS=$(get_cflags ${LIB_NAME})
+    LDFLAGS=$(get_ldflags ${LIB_NAME})
+
+    # THEN BUILD FOR THIS ABI
+    $(get_clang_target_host)-clang ${CFLAGS} -Wno-unused-command-line-argument -c ${BASEDIR}/android/app/src/main/cpp/android_lts_support.c -o ${BASEDIR}/android/app/src/main/cpp/android_lts_support.o ${LDFLAGS} 1>>${BASEDIR}/build.log 2>&1
+    ${TARGET_HOST}-ar rcs ${BASEDIR}/android/app/src/main/cpp/libandroidltssupport.a ${BASEDIR}/android/app/src/main/cpp/android_lts_support.o 1>>${BASEDIR}/build.log 2>&1
+}
+
 autoreconf_library() {
    echo -e "\nDEBUG: Running full autoreconf for $1\n" 1>>${BASEDIR}/build.log 2>&1

@@ -45,7 +45,7 @@ fi
 ./configure \
    --prefix=${BASEDIR}/prebuilt/android-$(get_target_build)/${LIB_NAME} \
    --with-pic \
-    --with-sysroot=${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot \
+    --with-sysroot=${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot \
    --without-docbook \
    --without-xmlwf \
    --enable-static \
@@ -53,9 +53,9 @@ fi
    --disable-fast-install \
    --host=${TARGET_HOST} || exit 1

-make ${MOBILE_FFMPEG_DEBUG} -j$(get_cpu_count) || exit 1
+make -j$(get_cpu_count) || exit 1

 # MANUALLY COPY PKG-CONFIG FILES
-cp ./expat.pc ${INSTALL_PKG_CONFIG_DIR}
+cp ./expat.pc ${INSTALL_PKG_CONFIG_DIR} || exit 1

 make install || exit 1
@@ -73,9 +73,10 @@ case ${ARCH} in
    ;;
 esac

-CONFIGURE_POSTFIX="--disable-autodetect"
+CONFIGURE_POSTFIX=""
+HIGH_PRIORITY_INCLUDES=""

-for library in {1..43}
+for library in {1..44}
 do
    if [[ ${!library} -eq 1 ]]; then
        ENABLED_LIBRARY=$(get_library_name $((library - 1)))
@@ -137,6 +138,7 @@ do
                CFLAGS+=" $(pkg-config --cflags libiconv)"
                LDFLAGS+=" $(pkg-config --libs --static libiconv)"
                CONFIGURE_POSTFIX+=" --enable-iconv"
+                HIGH_PRIORITY_INCLUDES+=" $(pkg-config --cflags libiconv)"
            ;;
            libilbc)
                CFLAGS+=" $(pkg-config --cflags libilbc)"
@@ -182,6 +184,11 @@ do
                CONFIGURE_POSTFIX+=" --enable-libopencore-amrnb"
                CONFIGURE_POSTFIX+=" --enable-libopencore-amrwb"
            ;;
+            openh264)
+                FFMPEG_CFLAGS+=" $(pkg-config --cflags openh264)"
+                FFMPEG_LDFLAGS+=" $(pkg-config --libs --static openh264)"
+                CONFIGURE_POSTFIX+=" --enable-libopenh264"
+            ;;
            opus)
                CFLAGS+=" $(pkg-config --cflags opus)"
                LDFLAGS+=" $(pkg-config --libs --static opus)"
@@ -278,7 +285,9 @@ do
    else

        # THE FOLLOWING LIBRARIES SHOULD BE EXPLICITLY DISABLED TO PREVENT AUTODETECT
-        if [[ ${library} -eq 42 ]]; then
+        if [[ ${library} -eq 30 ]]; then
+            CONFIGURE_POSTFIX+=" --disable-sdl2"
+        elif [[ ${library} -eq 43 ]]; then
            CONFIGURE_POSTFIX+=" --disable-zlib"
        fi
    fi
@@ -286,6 +295,11 @@ done

 LDFLAGS+=" -L${ANDROID_NDK_ROOT}/platforms/android-${API}/arch-${TOOLCHAIN_ARCH}/usr/lib"

+# LINKING WITH ANDROID LTS SUPPORT LIBRARY IS NECESSARY FOR API < 18
+if [[ ! -z ${MOBILE_FFMPEG_LTS_BUILD} ]] && [[ ${API} < 18 ]]; then
+    LDFLAGS+=" -Wl,--whole-archive ${BASEDIR}/android/app/src/main/cpp/libandroidltssupport.a -Wl,--no-whole-archive"
+fi
+
 # OPTIMIZE FOR SPEED INSTEAD OF SIZE
 if [[ -z ${MOBILE_FFMPEG_OPTIMIZED_FOR_SPEED} ]]; then
    SIZE_OPTIONS="--enable-small";
@@ -293,23 +307,45 @@ else
    SIZE_OPTIONS="";
 fi

+# SET DEBUG OPTIONS
+if [[ -z ${MOBILE_FFMPEG_DEBUG} ]]; then
+
+    # SET LTO FLAGS
+    if [[ -z ${NO_LINK_TIME_OPTIMIZATION} ]]; then
+        DEBUG_OPTIONS="--disable-debug --enable-lto";
+    else
+        DEBUG_OPTIONS="--disable-debug --disable-lto";
+    fi
+else
+    DEBUG_OPTIONS="--enable-debug";
+fi
+
 cd ${BASEDIR}/src/${LIB_NAME} || exit 1

 echo -n -e "\n${LIB_NAME}: "

-make distclean 2>/dev/null 1>/dev/null
+if [[ -z ${NO_WORKSPACE_CLEANUP_ffmpeg} ]]; then
+    echo -e "INFO: Cleaning workspace for ${LIB_NAME}" 1>>${BASEDIR}/build.log 2>&1
+    make distclean 2>/dev/null 1>/dev/null
+fi
+
+export CFLAGS="${HIGH_PRIORITY_INCLUDES} ${CFLAGS}"
+export CXXFLAGS="${CXXFLAGS}"
+export LDFLAGS="${LDFLAGS}"
+
+# USE HIGHER LIMITS FOR FFMPEG LINKING
+ulimit -n 2048 1>>${BASEDIR}/build.log 2>&1

 ./configure \
    --cross-prefix="${TARGET_HOST}-" \
-    --sysroot="${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot" \
+    --sysroot="${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot" \
    --prefix="${BASEDIR}/prebuilt/android-$(get_target_build)/${LIB_NAME}" \
    --pkg-config="${HOST_PKG_CONFIG_PATH}" \
-    --extra-cflags="${CFLAGS}" \
-    --extra-cxxflags="${CXXFLAGS}" \
-    --extra-ldflags="${LDFLAGS}" \
    --enable-version3 \
    --arch="${TARGET_ARCH}" \
    --cpu="${TARGET_CPU}" \
+    --cc="${CC}" \
+    --cxx="${CXX}" \
    --target-os=android \
    ${ASM_FLAGS} \
    --enable-cross-compile \
@@ -318,11 +354,15 @@ make distclean 2>/dev/null 1>/dev/null
    --enable-optimizations \
    --enable-swscale \
    --enable-shared \
-    --enable-v4l2-m2m \
+    --disable-v4l2-m2m \
+    --disable-outdev=v4l2 \
+    --disable-outdev=fbdev \
+    --disable-indev=v4l2 \
+    --disable-indev=fbdev \
    ${SIZE_OPTIONS} \
    --disable-openssl \
    --disable-xmm-clobber-test \
-    --disable-debug \
+    ${DEBUG_OPTIONS} \
    --disable-neon-clobber-test \
    --disable-programs \
    --disable-postproc \
@@ -357,13 +397,26 @@ if [ $? -ne 0 ]; then
    exit 1
 fi

-make ${MOBILE_FFMPEG_DEBUG} -j$(get_cpu_count) 1>>${BASEDIR}/build.log 2>&1
+if [[ -z ${NO_OUTPUT_REDIRECTION} ]]; then
+    make -j$(get_cpu_count) 1>>${BASEDIR}/build.log 2>&1

-if [ $? -ne 0 ]; then
-    echo "failed"
-    exit 1
+    if [ $? -ne 0 ]; then
+        echo "failed"
+        exit 1
+    fi
+else
+    echo -e "started\n"
+    make -j$(get_cpu_count)
+
+    if [ $? -ne 0 ]; then
+        echo -n -e "\n${LIB_NAME}: failed\n"
+        exit 1
+    else
+        echo -n -e "\n${LIB_NAME}: "
+    fi
 fi

+rm -rf ${BASEDIR}/prebuilt/android-$(get_target_build)/${LIB_NAME}
 make install 1>>${BASEDIR}/build.log 2>&1

 if [ $? -ne 0 ]; then
@@ -57,9 +57,9 @@ fi
    --disable-docs \
    --host=${TARGET_HOST} || exit 1

-make ${MOBILE_FFMPEG_DEBUG} -j$(get_cpu_count) || exit 1
+make -j$(get_cpu_count) || exit 1

 # CREATE PACKAGE CONFIG MANUALLY
-create_fontconfig_package_config "2.13.1"
+create_fontconfig_package_config "2.13.91"

 make install || exit 1
@@ -47,7 +47,7 @@ export LIBPNG_LIBS="-L${BASEDIR}/prebuilt/android-$(get_target_build)/libpng/lib
    --with-pic \
    --with-zlib \
    --with-png \
-    --with-sysroot=${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot \
+    --with-sysroot=${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot \
    --without-harfbuzz \
    --without-bzip2 \
    --without-fsref \
@@ -60,9 +60,9 @@ export LIBPNG_LIBS="-L${BASEDIR}/prebuilt/android-$(get_target_build)/libpng/lib
    --disable-mmap \
    --host=${TARGET_HOST} || exit 1

-make ${MOBILE_FFMPEG_DEBUG} -j$(get_cpu_count) || exit 1
+make -j$(get_cpu_count) || exit 1

 # CREATE PACKAGE CONFIG MANUALLY
-create_freetype_package_config "22.0.16"
+create_freetype_package_config "23.1.17"

 make install || exit 1
@@ -46,7 +46,7 @@ fi
 ./configure \
    --prefix=${BASEDIR}/prebuilt/android-$(get_target_build)/${LIB_NAME} \
    --with-pic \
-    --with-sysroot=${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot \
+    --with-sysroot=${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot \
    --enable-static \
    --disable-shared \
    --disable-fast-install \
@@ -54,9 +54,9 @@ fi
    --disable-deprecated \
    --host=${TARGET_HOST} || exit 1

-make ${MOBILE_FFMPEG_DEBUG} -j$(get_cpu_count) || exit 1
+make -j$(get_cpu_count) || exit 1

 # MANUALLY COPY PKG-CONFIG FILES
-cp ./*.pc ${INSTALL_PKG_CONFIG_DIR}
+cp ./*.pc ${INSTALL_PKG_CONFIG_DIR} || exit 1

 make install || exit 1
@@ -46,13 +46,13 @@ fi
 ./configure \
    --prefix=${BASEDIR}/prebuilt/android-$(get_target_build)/${LIB_NAME} \
    --with-pic \
-    --with-sysroot=${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot \
+    --with-sysroot=${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot \
    --enable-static \
    --disable-shared \
    --disable-fast-install \
    --host=${TARGET_HOST} || exit 1

-make ${MOBILE_FFMPEG_DEBUG} -j$(get_cpu_count) || exit 1
+make -j$(get_cpu_count) || exit 1

 # CREATE PACKAGE CONFIG MANUALLY
 create_giflib_package_config "5.1.4"
@@ -45,7 +45,7 @@ fi
 ./configure \
    --prefix=${BASEDIR}/prebuilt/android-$(get_target_build)/${LIB_NAME} \
    --with-pic \
-    --with-sysroot=${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot \
+    --with-sysroot=${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot \
    --enable-static \
    --disable-assembly \
    --disable-shared \
@@ -53,7 +53,7 @@ fi
    --disable-maintainer-mode \
    --host=${TARGET_HOST} || exit 1

-make ${MOBILE_FFMPEG_DEBUG} -j$(get_cpu_count) || exit 1
+make -j$(get_cpu_count) || exit 1

 # CREATE PACKAGE CONFIG MANUALLY
 create_gmp_package_config "6.1.2"
@@ -38,11 +38,11 @@ export CXXFLAGS="${COMMON_CXXFLAGS}"
 export LDFLAGS="${COMMON_LDFLAGS} -L${BASEDIR}/prebuilt/android-$(get_target_build)/libiconv/lib"

 export NETTLE_CFLAGS="-I${BASEDIR}/prebuilt/android-$(get_target_build)/nettle/include"
-export NETTLE_LIBS="-L${BASEDIR}/prebuilt/android-$(get_target_build)/nettle/lib"
+export NETTLE_LIBS="-L${BASEDIR}/prebuilt/android-$(get_target_build)/nettle/lib -lnettle -L${BASEDIR}/prebuilt/android-$(get_target_build)/gmp/lib -lgmp"
 export HOGWEED_CFLAGS="-I${BASEDIR}/prebuilt/android-$(get_target_build)/nettle/include"
-export HOGWEED_LIBS="-L${BASEDIR}/prebuilt/android-$(get_target_build)/nettle/lib"
+export HOGWEED_LIBS="-L${BASEDIR}/prebuilt/android-$(get_target_build)/nettle/lib -lhogweed -L${BASEDIR}/prebuilt/android-$(get_target_build)/gmp/lib -lgmp"
 export GMP_CFLAGS="-I${BASEDIR}/prebuilt/android-$(get_target_build)/gmp/include"
-export GMP_LIBS="-L${BASEDIR}/prebuilt/android-$(get_target_build)/gmp/lib"
+export GMP_LIBS="-L${BASEDIR}/prebuilt/android-$(get_target_build)/gmp/lib -lgmp"

 cd ${BASEDIR}/src/${LIB_NAME} || exit 1

@@ -56,11 +56,10 @@ fi
 ./configure \
    --prefix=${BASEDIR}/prebuilt/android-$(get_target_build)/${LIB_NAME} \
    --with-pic \
-    --with-sysroot=${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot \
+    --with-sysroot=${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot \
    --with-included-libtasn1 \
    --with-included-unistring \
    --without-idn \
-    --without-libidn2 \
    --without-p11-kit \
    --enable-hardware-acceleration \
    --enable-static \
@@ -70,14 +69,15 @@ fi
    --disable-code-coverage \
    --disable-doc \
    --disable-manpages \
+    --disable-guile \
    --disable-tests \
    --disable-tools \
    --disable-maintainer-mode \
    --host=${TARGET_HOST} || exit 1

-make ${MOBILE_FFMPEG_DEBUG} -j$(get_cpu_count) || exit 1
+make -j$(get_cpu_count) || exit 1

 # CREATE PACKAGE CONFIG MANUALLY
-create_gnutls_package_config "3.5.19"
+create_gnutls_package_config "3.6.8"

 make install || exit 1
@@ -47,16 +47,16 @@ cmake -Wno-dev \
    -DCMAKE_C_FLAGS="${CFLAGS}" \
    -DCMAKE_CXX_FLAGS="${CXXFLAGS}" \
    -DCMAKE_EXE_LINKER_FLAGS="${LDFLAGS}" \
-    -DCMAKE_SYSROOT="${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot" \
-    -DCMAKE_FIND_ROOT_PATH="${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot" \
+    -DCMAKE_SYSROOT="${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot" \
+    -DCMAKE_FIND_ROOT_PATH="${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot" \
    -DCMAKE_BUILD_TYPE=Release \
    -DCMAKE_INSTALL_PREFIX="${BASEDIR}/prebuilt/android-$(get_target_build)/${LIB_NAME}" \
    -DCMAKE_SYSTEM_NAME=Generic \
-    -DCMAKE_C_COMPILER="${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/bin/$CC" \
-    -DCMAKE_CXX_COMPILER="${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/bin/$CXX" \
-    -DCMAKE_LINKER="${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/bin/$LD" \
-    -DCMAKE_AR="${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/bin/$AR" \
-    -DCMAKE_AS="${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/bin/$AS" \
+    -DCMAKE_C_COMPILER="${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/bin/$CC" \
+    -DCMAKE_CXX_COMPILER="${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/bin/$CXX" \
+    -DCMAKE_LINKER="${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/bin/$LD" \
+    -DCMAKE_AR="${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/bin/$AR" \
+    -DCMAKE_AS="${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/bin/$AS" \
    -DCMAKE_POSITION_INDEPENDENT_CODE=1 \
    -DENABLE_STATIC=1 \
    -DENABLE_SHARED=0 \
@@ -66,9 +66,9 @@ cmake -Wno-dev \
    -DWITH_JAVA=0 \
    -DCMAKE_SYSTEM_PROCESSOR=$(get_cmake_target_processor) .. || exit 1

-make ${MOBILE_FFMPEG_DEBUG} -j$(get_cpu_count) || exit 1
+make -j$(get_cpu_count) || exit 1

 # MANUALLY COPY PKG-CONFIG FILES
-cp ${BASEDIR}/src/${LIB_NAME}/build/pkgscripts/libjpeg.pc ${INSTALL_PKG_CONFIG_DIR}
+cp ${BASEDIR}/src/${LIB_NAME}/build/pkgscripts/libjpeg.pc ${INSTALL_PKG_CONFIG_DIR} || exit 1

 make install || exit 1
@@ -43,18 +43,25 @@ if [[ ${RECONF_kvazaar} -eq 1 ]]; then
    autoreconf_library ${LIB_NAME}
 fi

-./configure \
+# LINKING WITH ANDROID LTS SUPPORT LIBRARY IS NECESSARY FOR API < 18
+if [[ ! -z ${MOBILE_FFMPEG_LTS_BUILD} ]] && [[ ${API} < 18 ]]; then
+    ARCH_SPECIFIC_LIBS=" -Wl,--no-whole-archive ${BASEDIR}/android/app/src/main/cpp/libandroidltssupport.a -Wl,--no-whole-archive"
+else
+    ARCH_SPECIFIC_LIBS=""
+fi
+
+LIBS="${ARCH_SPECIFIC_LIBS}" ./configure \
    --prefix=${BASEDIR}/prebuilt/android-$(get_target_build)/${LIB_NAME} \
    --with-pic \
-    --with-sysroot=${ANDROID_NDK_ROOT}/toolchains/mobile-ffmpeg-${TOOLCHAIN}/sysroot \
+    --with-sysroot=${ANDROID_NDK_ROOT}/toolchains/llvm/prebuilt/${TOOLCHAIN}/sysroot \
    --enable-static \
    --disable-shared \
    --disable-fast-install \
    --host=${TARGET_HOST} || exit 1

-make ${MOBILE_FFMPEG_DEBUG} -j$(get_cpu_count) || exit 1
+make -j$(get_cpu_count) || exit 1

 # MANUALLY COPY PKG-CONFIG FILES
-cp ./src/kvazaar.pc ${INSTALL_PKG_CONFIG_DIR}
+cp ./src/kvazaar.pc ${INSTALL_PKG_CONFIG_DIR} || exit 1

 make install || exit 1
--- a/Show More
+++ b/Show More