├── app
    ├── .gitignore
    ├── src
    │   └── main
    │   │   ├── res
    │   │       ├── values
    │   │       │   ├── strings.xml
    │   │       │   ├── colors.xml
    │   │       │   └── themes.xml
    │   │       ├── mipmap-xhdpi
    │   │       │   └── ic_launcher.png
    │   │       ├── mipmap-xxhdpi
    │   │       │   └── ic_launcher.png
    │   │       └── layout
    │   │       │   └── activity_main.xml
    │   │   ├── AndroidManifest.xml
    │   │   └── java
    │   │       └── com
    │   │           └── xiaoguang
    │   │               └── widget
    │   │                   └── videocompress
    │   │                       └── demo
    │   │                           └── MainActivity.java
    ├── proguard-rules.pro
    └── build.gradle
├── videocompress
    ├── .gitignore
    ├── consumer-rules.pro
    ├── libs
    │   ├── aspectjrt-1.7.3.jar
    │   └── isoparser-1.0.6.jar
    ├── src
    │   └── main
    │   │   ├── res
    │   │       ├── drawable-xxhdpi
    │   │       │   ├── ic_file_img.png
    │   │       │   ├── ic_file_pdf.png
    │   │       │   ├── ic_file_ppt.png
    │   │       │   ├── ic_file_txt.png
    │   │       │   ├── ic_file_zip.png
    │   │       │   ├── ic_file_excel.png
    │   │       │   ├── ic_file_music.png
    │   │       │   ├── ic_file_video.png
    │   │       │   ├── ic_file_word.png
    │   │       │   └── ic_file_not_found.png
    │   │       ├── values
    │   │       │   ├── strings.xml
    │   │       │   ├── colors.xml
    │   │       │   └── themes.xml
    │   │       ├── drawable
    │   │       │   ├── shape_color_4d000000_radius_16.xml
    │   │       │   └── shape_color_white_radius_16.xml
    │   │       └── layout
    │   │       │   └── dialog_media_loading.xml
    │   │   ├── AndroidManifest.xml
    │   │   └── java
    │   │       └── com
    │   │           └── xiaoguang
    │   │               └── widget
    │   │                   └── videocompress
    │   │                       ├── core
    │   │                           ├── Sample.java
    │   │                           ├── Mp4Movie.java
    │   │                           ├── VideoCompress.java
    │   │                           ├── InputSurface.java
    │   │                           ├── OutputSurface.java
    │   │                           ├── TextureRenderer.java
    │   │                           ├── Track.java
    │   │                           ├── MP4Builder.java
    │   │                           └── VideoController.java
    │   │                       └── dialog
    │   │                           └── VideoCompressDialog.java
    ├── build.gradle
    └── proguard-rules.pro
├── settings.gradle
├── gradle
    └── wrapper
    │   ├── gradle-wrapper.jar
    │   └── gradle-wrapper.properties
├── .gitignore
├── gradle.properties
├── gradlew.bat
├── gradlew
└── README.md


/app/.gitignore:
--------------------------------------------------------------------------------
1 | /build


--------------------------------------------------------------------------------
/videocompress/.gitignore:
--------------------------------------------------------------------------------
1 | /build


--------------------------------------------------------------------------------
/videocompress/consumer-rules.pro:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | include ':app', ':videocompress'
2 | 


--------------------------------------------------------------------------------
/app/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 |     <string name="app_name">VideoCompression</string>
3 | </resources>


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITxiaoguang/VideoCompress/HEAD/gradle/wrapper/gradle-wrapper.jar


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *.iml
2 | .gradle
3 | /local.properties
4 | .idea/
5 | .DS_Store
6 | /build
7 | /captures
8 | .externalNativeBuild
9 | 


--------------------------------------------------------------------------------
/videocompress/libs/aspectjrt-1.7.3.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITxiaoguang/VideoCompress/HEAD/videocompress/libs/aspectjrt-1.7.3.jar


--------------------------------------------------------------------------------
/videocompress/libs/isoparser-1.0.6.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITxiaoguang/VideoCompress/HEAD/videocompress/libs/isoparser-1.0.6.jar


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITxiaoguang/VideoCompress/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITxiaoguang/VideoCompress/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/videocompress/src/main/res/drawable-xxhdpi/ic_file_img.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITxiaoguang/VideoCompress/HEAD/videocompress/src/main/res/drawable-xxhdpi/ic_file_img.png


--------------------------------------------------------------------------------
/videocompress/src/main/res/drawable-xxhdpi/ic_file_pdf.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITxiaoguang/VideoCompress/HEAD/videocompress/src/main/res/drawable-xxhdpi/ic_file_pdf.png


--------------------------------------------------------------------------------
/videocompress/src/main/res/drawable-xxhdpi/ic_file_ppt.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITxiaoguang/VideoCompress/HEAD/videocompress/src/main/res/drawable-xxhdpi/ic_file_ppt.png


--------------------------------------------------------------------------------
/videocompress/src/main/res/drawable-xxhdpi/ic_file_txt.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITxiaoguang/VideoCompress/HEAD/videocompress/src/main/res/drawable-xxhdpi/ic_file_txt.png


--------------------------------------------------------------------------------
/videocompress/src/main/res/drawable-xxhdpi/ic_file_zip.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITxiaoguang/VideoCompress/HEAD/videocompress/src/main/res/drawable-xxhdpi/ic_file_zip.png


--------------------------------------------------------------------------------
/videocompress/src/main/res/drawable-xxhdpi/ic_file_excel.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITxiaoguang/VideoCompress/HEAD/videocompress/src/main/res/drawable-xxhdpi/ic_file_excel.png


--------------------------------------------------------------------------------
/videocompress/src/main/res/drawable-xxhdpi/ic_file_music.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITxiaoguang/VideoCompress/HEAD/videocompress/src/main/res/drawable-xxhdpi/ic_file_music.png


--------------------------------------------------------------------------------
/videocompress/src/main/res/drawable-xxhdpi/ic_file_video.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITxiaoguang/VideoCompress/HEAD/videocompress/src/main/res/drawable-xxhdpi/ic_file_video.png


--------------------------------------------------------------------------------
/videocompress/src/main/res/drawable-xxhdpi/ic_file_word.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITxiaoguang/VideoCompress/HEAD/videocompress/src/main/res/drawable-xxhdpi/ic_file_word.png


--------------------------------------------------------------------------------
/videocompress/src/main/res/drawable-xxhdpi/ic_file_not_found.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ITxiaoguang/VideoCompress/HEAD/videocompress/src/main/res/drawable-xxhdpi/ic_file_not_found.png


--------------------------------------------------------------------------------
/videocompress/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
3 |     package="com.xiaoguang.widget.videocompress">
4 | 
5 | </manifest>


--------------------------------------------------------------------------------
/videocompress/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 | 
3 |     <string name="compressing">压缩中...</string>
4 |     <string name="cancel">取消</string>
5 |     <string name="compress_cancel">取消转码。</string>
6 |     <string name="compress_error">压缩失败。</string>
7 | 
8 | </resources>


--------------------------------------------------------------------------------
/app/src/main/res/values/colors.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 |     <color name="colorAccent">#FF8048</color>
4 |     <color name="colorPrimary">@android:color/white</color>
5 |     <color name="transparent">@android:color/transparent</color>
6 | </resources>


--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | #Sat Oct 23 09:58:22 CST 2021
2 | distributionBase=GRADLE_USER_HOME
3 | distributionUrl=https\://services.gradle.org/distributions/gradle-6.5-all.zip
4 | distributionPath=wrapper/dists
5 | zipStorePath=wrapper/dists
6 | zipStoreBase=GRADLE_USER_HOME
7 | 


--------------------------------------------------------------------------------
/videocompress/src/main/res/drawable/shape_color_4d000000_radius_16.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <shape xmlns:android="http://schemas.android.com/apk/res/android"
3 |     android:shape="rectangle">
4 |     <corners android:radius="16dp" />
5 |     <solid android:color="#4d000000" />
6 | </shape>
7 | 


--------------------------------------------------------------------------------
/videocompress/src/main/res/drawable/shape_color_white_radius_16.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <shape xmlns:android="http://schemas.android.com/apk/res/android"
3 |     android:shape="rectangle">
4 |     <corners android:radius="16dp" />
5 |     <solid android:color="@android:color/white" />
6 | </shape>


--------------------------------------------------------------------------------
/videocompress/src/main/res/values/colors.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <resources>
3 |     <color name="colorAccent">#FF8048</color>
4 |     <color name="colorPrimary">@android:color/white</color>
5 |     <color name="transparent">@android:color/transparent</color>
6 | 
7 |     <color name="color_111111">#111111</color>
8 | 
9 | </resources>


--------------------------------------------------------------------------------
/videocompress/src/main/java/com/xiaoguang/widget/videocompress/core/Sample.java:
--------------------------------------------------------------------------------
 1 | package com.xiaoguang.widget.videocompress.core;
 2 | 
 3 | public class Sample {
 4 |     private long offset = 0;
 5 |     private long size = 0;
 6 | 
 7 |     public Sample(long offset, long size) {
 8 |         this.offset = offset;
 9 |         this.size = size;
10 |     }
11 | 
12 |     public long getOffset() {
13 |         return offset;
14 |     }
15 | 
16 |     public long getSize() {
17 |         return size;
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/app/src/main/res/layout/activity_main.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     android:layout_width="match_parent"
 4 |     android:layout_height="match_parent">
 5 | 
 6 |     <Button
 7 |         android:id="@+id/bt_select_file"
 8 |         android:layout_width="wrap_content"
 9 |         android:layout_height="wrap_content"
10 |         android:layout_centerInParent="true"
11 |         android:text="选择文件"
12 |         android:textSize="18sp" />
13 | 
14 | </RelativeLayout>


--------------------------------------------------------------------------------
/app/src/main/res/values/themes.xml:
--------------------------------------------------------------------------------
 1 | <resources xmlns:tools="http://schemas.android.com/tools">
 2 |     <!-- Base application theme. -->
 3 |     <style name="Theme.Demo" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
 4 |         <item name="colorPrimary">@color/colorAccent</item>
 5 |         <item name="colorPrimaryVariant">@color/colorAccent</item>
 6 |         <item name="colorOnPrimary">@android:color/white</item>
 7 |         <item name="colorSecondary">@color/colorAccent</item>
 8 |         <item name="colorSecondaryVariant">@color/colorAccent</item>
 9 |         <item name="colorOnSecondary">@android:color/black</item>
10 |         <item name="android:statusBarColor" tools:targetApi="l">?attr/colorPrimaryVariant</item>
11 |     </style>
12 | 
13 | </resources>


--------------------------------------------------------------------------------
/app/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # You can control the set of applied configuration files using the
 3 | # proguardFiles setting in build.gradle.
 4 | #
 5 | # For more details, see
 6 | #   http://developer.android.com/guide/developing/tools/proguard.html
 7 | 
 8 | # If your project uses WebView with JS, uncomment the following
 9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | #   public *;
13 | #}
14 | 
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 | 
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile


--------------------------------------------------------------------------------
/videocompress/build.gradle:
--------------------------------------------------------------------------------
 1 | plugins {
 2 |     id 'com.android.library'
 3 | }
 4 | 
 5 | android {
 6 |     compileSdk 30
 7 | 
 8 |     defaultConfig {
 9 |         minSdk 14
10 |         targetSdk 30
11 |         versionCode 1
12 |         versionName "1.0.0"
13 |     }
14 | 
15 |     buildTypes {
16 |         release {
17 |             minifyEnabled false
18 |             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
19 |         }
20 |     }
21 |     compileOptions {
22 |         sourceCompatibility JavaVersion.VERSION_1_8
23 |         targetCompatibility JavaVersion.VERSION_1_8
24 |     }
25 | }
26 | 
27 | dependencies {
28 |     api fileTree(dir: 'libs', include: ['*.jar'])
29 | 
30 |     implementation 'androidx.appcompat:appcompat:1.2.0'
31 |     implementation 'com.google.android.material:material:1.4.0'
32 | }


--------------------------------------------------------------------------------
/videocompress/proguard-rules.pro:
--------------------------------------------------------------------------------
 1 | # Add project specific ProGuard rules here.
 2 | # You can control the set of applied configuration files using the
 3 | # proguardFiles setting in build.gradle.
 4 | #
 5 | # For more details, see
 6 | #   http://developer.android.com/guide/developing/tools/proguard.html
 7 | 
 8 | # If your project uses WebView with JS, uncomment the following
 9 | # and specify the fully qualified class name to the JavaScript interface
10 | # class:
11 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
12 | #   public *;
13 | #}
14 | 
15 | # Uncomment this to preserve the line number information for
16 | # debugging stack traces.
17 | #-keepattributes SourceFile,LineNumberTable
18 | 
19 | # If you keep the line number information, uncomment this to
20 | # hide the original source file name.
21 | #-renamesourcefileattribute SourceFile


--------------------------------------------------------------------------------
/app/build.gradle:
--------------------------------------------------------------------------------
 1 | plugins {
 2 | 
 3 | 
 4 |     id 'com.android.application'
 5 | }
 6 | 
 7 | android {
 8 |     compileSdk 30
 9 | 
10 |     defaultConfig {
11 |         applicationId "com.xiaoguang.widget.videocompress"
12 |         minSdk 21
13 |         targetSdk 30
14 |         versionCode 1
15 |         versionName "1.0.0"
16 |     }
17 | 
18 |     buildTypes {
19 |         release {
20 |             minifyEnabled false
21 |             proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
22 |         }
23 |     }
24 |     compileOptions {
25 |         sourceCompatibility JavaVersion.VERSION_1_8
26 |         targetCompatibility JavaVersion.VERSION_1_8
27 |     }
28 | }
29 | 
30 | dependencies {
31 | 
32 |     implementation 'androidx.appcompat:appcompat:1.2.0'
33 |     implementation 'com.google.android.material:material:1.4.0'
34 |     implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
35 | 
36 |     implementation 'com.github.ITxiaoguang:FilePicker:1.0.2'
37 |     implementation project(path: ':videocompress')
38 | 
39 | }
40 | 


--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
 1 | # Project-wide Gradle settings.
 2 | # IDE (e.g. Android Studio) users:
 3 | # Gradle settings configured through the IDE *will override*
 4 | # any settings specified in this file.
 5 | # For more details on how to configure your build environment visit
 6 | # http://www.gradle.org/docs/current/userguide/build_environment.html
 7 | # Specifies the JVM arguments used for the daemon process.
 8 | # The setting is particularly useful for tweaking memory settings.
 9 | org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
10 | # When configured, Gradle will run in incubating parallel mode.
11 | # This option should only be used with decoupled projects. More details, visit
12 | # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
13 | # org.gradle.parallel=true
14 | # AndroidX package structure to make it clearer which packages are bundled with the
15 | # Android operating system, and which are packaged with your app"s APK
16 | # https://developer.android.com/topic/libraries/support-library/androidx-rn
17 | android.useAndroidX=true
18 | # Automatically convert third-party libraries to use AndroidX
19 | android.enableJetifier=true


--------------------------------------------------------------------------------
/app/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     package="com.xiaoguang.widget.videocompress.demo">
 4 | 
 5 |     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
 6 |     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
 7 | 
 8 |     <!-- 存储卡读写权限需要在Application的Manifest清单中声明 -->
 9 |     <!-- Android10.0 需要在AndroidManifest.xml文件中application出加上 -->
10 |     <!--  android:requestLegacyExternalStorage="true" -->
11 |     <application
12 |         android:allowBackup="true"
13 |         android:icon="@mipmap/ic_launcher"
14 |         android:label="@string/app_name"
15 |         android:requestLegacyExternalStorage="true"
16 |         android:resizeableActivity="true"
17 |         android:theme="@style/Theme.Demo">
18 |         <activity
19 |             android:name="com.xiaoguang.widget.videocompress.demo.MainActivity"
20 |             android:exported="true">
21 |             <intent-filter>
22 |                 <action android:name="android.intent.action.MAIN" />
23 | 
24 |                 <category android:name="android.intent.category.LAUNCHER" />
25 |             </intent-filter>
26 |         </activity>
27 |     </application>
28 | 
29 | </manifest>


--------------------------------------------------------------------------------
/videocompress/src/main/res/values/themes.xml:
--------------------------------------------------------------------------------
 1 | <resources xmlns:tools="http://schemas.android.com/tools">
 2 |     <!-- Base application theme. -->
 3 |     <style name="Theme.Demo" parent="Theme.MaterialComponents.DayNight.DarkActionBar">
 4 |         <item name="colorPrimary">@color/colorAccent</item>
 5 |         <item name="colorPrimaryVariant">@color/colorAccent</item>
 6 |         <item name="colorOnPrimary">@android:color/white</item>
 7 |         <item name="colorSecondary">@color/colorAccent</item>
 8 |         <item name="colorSecondaryVariant">@color/colorAccent</item>
 9 |         <item name="colorOnSecondary">@android:color/black</item>
10 |         <item name="android:statusBarColor" tools:targetApi="l">?attr/colorPrimaryVariant</item>
11 |     </style>
12 | 
13 |     <style name="Theme.AccentProgressBar" parent="Theme.AppCompat.Light.NoActionBar">
14 |         <item name="colorPrimary">@color/colorAccent</item>
15 |         <item name="colorPrimaryDark">@color/colorPrimary</item>
16 |         <item name="colorAccent">@color/colorAccent</item>
17 |         <item name="colorControlNormal">@color/colorAccent</item>
18 |         <item name="colorControlActivated">@color/colorAccent</item>
19 |         <item name="colorControlHighlight">@color/colorAccent</item>
20 |         <item name="colorSwitchThumbNormal">@color/colorAccent</item>
21 |     </style>
22 | 
23 |     <style name="dialog_default_style" parent="@android:style/Theme.Dialog">
24 |         <item name="android:windowBackground">@color/transparent</item>
25 |         <item name="android:windowFrame">@null</item>
26 |         <item name="android:windowNoTitle">true</item>
27 |         <item name="android:windowIsFloating">true</item>
28 |         <item name="android:windowIsTranslucent">true</item>
29 |         <item name="android:backgroundDimEnabled">true</item>
30 |     </style>
31 | 
32 | </resources>


--------------------------------------------------------------------------------
/videocompress/src/main/java/com/xiaoguang/widget/videocompress/core/Mp4Movie.java:
--------------------------------------------------------------------------------
 1 | package com.xiaoguang.widget.videocompress.core;
 2 | 
 3 | import android.annotation.TargetApi;
 4 | import android.media.MediaCodec;
 5 | import android.media.MediaFormat;
 6 | 
 7 | import com.googlecode.mp4parser.util.Matrix;
 8 | 
 9 | import java.io.File;
10 | import java.util.ArrayList;
11 | 
12 | @TargetApi(16)
13 | public class Mp4Movie {
14 |     private Matrix matrix = Matrix.ROTATE_0;
15 |     private ArrayList<Track> tracks = new ArrayList<Track>();
16 |     private File cacheFile;
17 |     private int width;
18 |     private int height;
19 | 
20 |     public Matrix getMatrix() {
21 |         return matrix;
22 |     }
23 | 
24 |     public int getWidth() {
25 |         return width;
26 |     }
27 | 
28 |     public int getHeight() {
29 |         return height;
30 |     }
31 | 
32 |     public void setCacheFile(File file) {
33 |         cacheFile = file;
34 |     }
35 | 
36 |     public void setRotation(int angle) {
37 |         if (angle == 0) {
38 |             matrix = Matrix.ROTATE_0;
39 |         } else if (angle == 90) {
40 |             matrix = Matrix.ROTATE_90;
41 |         } else if (angle == 180) {
42 |             matrix = Matrix.ROTATE_180;
43 |         } else if (angle == 270) {
44 |             matrix = Matrix.ROTATE_270;
45 |         }
46 |     }
47 | 
48 |     public void setSize(int w, int h) {
49 |         width = w;
50 |         height = h;
51 |     }
52 | 
53 |     public ArrayList<Track> getTracks() {
54 |         return tracks;
55 |     }
56 | 
57 |     public File getCacheFile() {
58 |         return cacheFile;
59 |     }
60 | 
61 |     public void addSample(int trackIndex, long offset, MediaCodec.BufferInfo bufferInfo) throws Exception {
62 |         if (trackIndex < 0 || trackIndex >= tracks.size()) {
63 |             return;
64 |         }
65 |         Track track = tracks.get(trackIndex);
66 |         track.addSample(offset, bufferInfo);
67 |     }
68 | 
69 |     public int addTrack(MediaFormat mediaFormat, boolean isAudio) throws Exception {
70 |         tracks.add(new Track(tracks.size(), mediaFormat, isAudio));
71 |         return tracks.size() - 1;
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/videocompress/src/main/res/layout/dialog_media_loading.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     xmlns:tools="http://schemas.android.com/tools"
 4 |     android:id="@+id/rl_dialog"
 5 |     android:layout_width="200dp"
 6 |     android:layout_height="180dp"
 7 |     android:layout_gravity="center"
 8 |     android:background="@drawable/shape_color_white_radius_16"
 9 |     android:gravity="center"
10 |     android:orientation="vertical">
11 | 
12 |     <TextView
13 |         android:id="@+id/tv_des"
14 |         android:layout_width="match_parent"
15 |         android:layout_height="wrap_content"
16 |         android:layout_marginTop="20dp"
17 |         android:layout_marginBottom="8dp"
18 |         android:gravity="center"
19 |         android:paddingLeft="10dp"
20 |         android:paddingRight="10dp"
21 |         android:textColor="@color/color_111111"
22 |         android:textSize="16sp"
23 |         android:text="@string/compressing" />
24 | 
25 |     <FrameLayout
26 |         android:id="@+id/fl_loading"
27 |         android:layout_width="wrap_content"
28 |         android:layout_height="wrap_content"
29 |         android:layout_marginTop="16dp"
30 |         android:layout_marginBottom="16dp">
31 | 
32 |         <View
33 |             android:layout_width="22dp"
34 |             android:layout_height="22dp"
35 |             android:layout_gravity="center"
36 |             android:background="@drawable/shape_color_4d000000_radius_16" />
37 | 
38 |         <ProgressBar
39 |             android:id="@+id/pb_loading"
40 |             android:layout_width="32dp"
41 |             android:layout_height="32dp"
42 |             android:layout_gravity="center"
43 |             android:theme="@style/Theme.AccentProgressBar" />
44 | 
45 |         <TextView
46 |             android:id="@+id/tv_progress"
47 |             android:layout_width="wrap_content"
48 |             android:layout_height="wrap_content"
49 |             android:layout_gravity="center"
50 |             android:textColor="@android:color/white"
51 |             android:textSize="10sp"
52 |             android:textStyle="bold"
53 |             tools:text="99%" />
54 |     </FrameLayout>
55 | 
56 |     <View
57 |         android:layout_width="wrap_content"
58 |         android:layout_height="1px"
59 |         android:background="#f2f3f5" />
60 | 
61 |     <LinearLayout
62 |         android:layout_width="match_parent"
63 |         android:layout_height="wrap_content"
64 |         android:background="@null">
65 | 
66 |         <TextView
67 |             android:id="@+id/tv_cancel"
68 |             android:layout_width="0dp"
69 |             android:layout_height="wrap_content"
70 |             android:layout_weight="1"
71 |             android:gravity="center"
72 |             android:padding="12dp"
73 |             android:textColor="@color/color_111111"
74 |             android:textSize="16sp"
75 |             android:text="@string/cancel" />
76 | 
77 |     </LinearLayout>
78 | 
79 | </LinearLayout>


--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
 1 | @rem
 2 | @rem Copyright 2015 the original author or authors.
 3 | @rem
 4 | @rem Licensed under the Apache License, Version 2.0 (the "License");
 5 | @rem you may not use this file except in compliance with the License.
 6 | @rem You may obtain a copy of the License at
 7 | @rem
 8 | @rem      https://www.apache.org/licenses/LICENSE-2.0
 9 | @rem
10 | @rem Unless required by applicable law or agreed to in writing, software
11 | @rem distributed under the License is distributed on an "AS IS" BASIS,
12 | @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | @rem See the License for the specific language governing permissions and
14 | @rem limitations under the License.
15 | @rem
16 | 
17 | @if "%DEBUG%" == "" @echo off
18 | @rem ##########################################################################
19 | @rem
20 | @rem  Gradle startup script for Windows
21 | @rem
22 | @rem ##########################################################################
23 | 
24 | @rem Set local scope for the variables with windows NT shell
25 | if "%OS%"=="Windows_NT" setlocal
26 | 
27 | set DIRNAME=%~dp0
28 | if "%DIRNAME%" == "" set DIRNAME=.
29 | set APP_BASE_NAME=%~n0
30 | set APP_HOME=%DIRNAME%
31 | 
32 | @rem Resolve any "." and ".." in APP_HOME to make it shorter.
33 | for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
34 | 
35 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
36 | set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
37 | 
38 | @rem Find java.exe
39 | if defined JAVA_HOME goto findJavaFromJavaHome
40 | 
41 | set JAVA_EXE=java.exe
42 | %JAVA_EXE% -version >NUL 2>&1
43 | if "%ERRORLEVEL%" == "0" goto execute
44 | 
45 | echo.
46 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
47 | echo.
48 | echo Please set the JAVA_HOME variable in your environment to match the
49 | echo location of your Java installation.
50 | 
51 | goto fail
52 | 
53 | :findJavaFromJavaHome
54 | set JAVA_HOME=%JAVA_HOME:"=%
55 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
56 | 
57 | if exist "%JAVA_EXE%" goto execute
58 | 
59 | echo.
60 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
61 | echo.
62 | echo Please set the JAVA_HOME variable in your environment to match the
63 | echo location of your Java installation.
64 | 
65 | goto fail
66 | 
67 | :execute
68 | @rem Setup the command line
69 | 
70 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
71 | 
72 | 
73 | @rem Execute Gradle
74 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
75 | 
76 | :end
77 | @rem End local scope for the variables with windows NT shell
78 | if "%ERRORLEVEL%"=="0" goto mainEnd
79 | 
80 | :fail
81 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
82 | rem the _cmd.exe /c_ return code!
83 | if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
84 | exit /b 1
85 | 
86 | :mainEnd
87 | if "%OS%"=="Windows_NT" endlocal
88 | 
89 | :omega
90 | 


--------------------------------------------------------------------------------
/videocompress/src/main/java/com/xiaoguang/widget/videocompress/core/VideoCompress.java:
--------------------------------------------------------------------------------
 1 | package com.xiaoguang.widget.videocompress.core;
 2 | 
 3 | import android.os.AsyncTask;
 4 | 
 5 | /**
 6 |  * Created by Vincent Woo
 7 |  * Date: 2017/8/16
 8 |  * Time: 15:15
 9 |  */
10 | 
11 | public class VideoCompress {
12 |     private static final String TAG = VideoCompress.class.getSimpleName();
13 | 
14 |     public static VideoCompressTask compressVideoHigh(String srcPath, String destPath, CompressListener listener) {
15 |         VideoCompressTask task = new VideoCompressTask(listener, VideoController.COMPRESS_QUALITY_HIGH);
16 |         task.execute(srcPath, destPath);
17 |         return task;
18 |     }
19 | 
20 |     public static VideoCompressTask compressVideoMedium(String srcPath, String destPath, CompressListener listener) {
21 |         VideoCompressTask task = new VideoCompressTask(listener, VideoController.COMPRESS_QUALITY_MEDIUM);
22 |         task.execute(srcPath, destPath);
23 |         return task;
24 |     }
25 | 
26 |     public static VideoCompressTask compressVideoLow(String srcPath, String destPath, CompressListener listener) {
27 |         VideoCompressTask task = new VideoCompressTask(listener, VideoController.COMPRESS_QUALITY_LOW);
28 |         task.execute(srcPath, destPath);
29 |         return task;
30 |     }
31 | 
32 |     public static class VideoCompressTask extends AsyncTask<String, Float, Boolean> {
33 |         private CompressListener mListener;
34 |         private int mQuality;
35 | 
36 |         public VideoCompressTask(CompressListener listener, int quality) {
37 |             mListener = listener;
38 |             mQuality = quality;
39 |         }
40 | 
41 |         @Override
42 |         protected void onPreExecute() {
43 |             super.onPreExecute();
44 |             if (mListener != null) {
45 |                 mListener.onStart();
46 |             }
47 |         }
48 | 
49 |         @Override
50 |         protected Boolean doInBackground(String... paths) {
51 |             return VideoController.getInstance().convertVideo(paths[0], paths[1], mQuality, new VideoController.CompressProgressListener() {
52 |                 @Override
53 |                 public void onProgress(float percent) {
54 |                     publishProgress(percent);
55 |                 }
56 |             });
57 |         }
58 | 
59 |         @Override
60 |         protected void onProgressUpdate(Float... percent) {
61 |             super.onProgressUpdate(percent);
62 |             if (mListener != null) {
63 |                 mListener.onProgress(percent[0]);
64 |             }
65 |         }
66 | 
67 |         @Override
68 |         protected void onPostExecute(Boolean result) {
69 |             super.onPostExecute(result);
70 |             if (mListener != null) {
71 |                 if (result) {
72 |                     mListener.onSuccess();
73 |                 } else {
74 |                     mListener.onFail();
75 |                 }
76 |             }
77 |         }
78 |     }
79 | 
80 |     public interface CompressListener {
81 |         void onStart();
82 | 
83 |         void onSuccess();
84 | 
85 |         void onFail();
86 | 
87 |         void onProgress(float percent);
88 |     }
89 | }
90 | 


--------------------------------------------------------------------------------
/videocompress/src/main/java/com/xiaoguang/widget/videocompress/core/InputSurface.java:
--------------------------------------------------------------------------------
  1 | package com.xiaoguang.widget.videocompress.core;
  2 | 
  3 | import android.annotation.TargetApi;
  4 | import android.opengl.EGL14;
  5 | import android.opengl.EGLConfig;
  6 | import android.opengl.EGLContext;
  7 | import android.opengl.EGLDisplay;
  8 | import android.opengl.EGLExt;
  9 | import android.opengl.EGLSurface;
 10 | import android.os.Build;
 11 | import android.view.Surface;
 12 | 
 13 | @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
 14 | public class InputSurface {
 15 |     private static final boolean VERBOSE = false;
 16 |     private static final int EGL_RECORDABLE_ANDROID = 0x3142;
 17 |     private static final int EGL_OPENGL_ES2_BIT = 4;
 18 |     private EGLDisplay mEGLDisplay;
 19 |     private EGLContext mEGLContext;
 20 |     private EGLSurface mEGLSurface;
 21 |     private Surface mSurface;
 22 | 
 23 |     public InputSurface(Surface surface) {
 24 |         if (surface == null) {
 25 |             throw new NullPointerException();
 26 |         }
 27 |         mSurface = surface;
 28 |         eglSetup();
 29 |     }
 30 | 
 31 |     private void eglSetup() {
 32 |         mEGLDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
 33 |         if (mEGLDisplay == EGL14.EGL_NO_DISPLAY) {
 34 |             throw new RuntimeException("unable to get EGL14 display");
 35 |         }
 36 |         int[] version = new int[2];
 37 |         if (!EGL14.eglInitialize(mEGLDisplay, version, 0, version, 1)) {
 38 |             mEGLDisplay = null;
 39 |             throw new RuntimeException("unable to initialize EGL14");
 40 |         }
 41 | 
 42 |         int[] attribList = {
 43 |                 EGL14.EGL_RED_SIZE, 8,
 44 |                 EGL14.EGL_GREEN_SIZE, 8,
 45 |                 EGL14.EGL_BLUE_SIZE, 8,
 46 |                 EGL14.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
 47 |                 EGL_RECORDABLE_ANDROID, 1,
 48 |                 EGL14.EGL_NONE
 49 |         };
 50 |         EGLConfig[] configs = new EGLConfig[1];
 51 |         int[] numConfigs = new int[1];
 52 |         if (!EGL14.eglChooseConfig(mEGLDisplay, attribList, 0, configs, 0, configs.length,
 53 |                 numConfigs, 0)) {
 54 |             throw new RuntimeException("unable to find RGB888+recordable ES2 EGL config");
 55 |         }
 56 | 
 57 |         int[] attrib_list = {
 58 |                 EGL14.EGL_CONTEXT_CLIENT_VERSION, 2,
 59 |                 EGL14.EGL_NONE
 60 |         };
 61 | 
 62 |         mEGLContext = EGL14.eglCreateContext(mEGLDisplay, configs[0], EGL14.EGL_NO_CONTEXT, attrib_list, 0);
 63 |         checkEglError("eglCreateContext");
 64 |         if (mEGLContext == null) {
 65 |             throw new RuntimeException("null context");
 66 |         }
 67 | 
 68 |         int[] surfaceAttribs = {
 69 |                 EGL14.EGL_NONE
 70 |         };
 71 |         mEGLSurface = EGL14.eglCreateWindowSurface(mEGLDisplay, configs[0], mSurface,
 72 |                 surfaceAttribs, 0);
 73 |         checkEglError("eglCreateWindowSurface");
 74 |         if (mEGLSurface == null) {
 75 |             throw new RuntimeException("surface was null");
 76 |         }
 77 |     }
 78 | 
 79 |     public void release() {
 80 |         if (EGL14.eglGetCurrentContext().equals(mEGLContext)) {
 81 |             EGL14.eglMakeCurrent(mEGLDisplay, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_CONTEXT);
 82 |         }
 83 |         EGL14.eglDestroySurface(mEGLDisplay, mEGLSurface);
 84 |         EGL14.eglDestroyContext(mEGLDisplay, mEGLContext);
 85 |         mSurface.release();
 86 |         mEGLDisplay = null;
 87 |         mEGLContext = null;
 88 |         mEGLSurface = null;
 89 |         mSurface = null;
 90 |     }
 91 | 
 92 |     public void makeCurrent() {
 93 |         if (!EGL14.eglMakeCurrent(mEGLDisplay, mEGLSurface, mEGLSurface, mEGLContext)) {
 94 |             throw new RuntimeException("eglMakeCurrent failed");
 95 |         }
 96 |     }
 97 | 
 98 |     public boolean swapBuffers() {
 99 |         return EGL14.eglSwapBuffers(mEGLDisplay, mEGLSurface);
100 |     }
101 | 
102 |     public Surface getSurface() {
103 |         return mSurface;
104 |     }
105 | 
106 |     public void setPresentationTime(long nsecs) {
107 |         EGLExt.eglPresentationTimeANDROID(mEGLDisplay, mEGLSurface, nsecs);
108 |     }
109 | 
110 |     private void checkEglError(String msg) {
111 |         boolean failed = false;
112 |         int error;
113 |         while ((error = EGL14.eglGetError()) != EGL14.EGL_SUCCESS) {
114 |             failed = true;
115 |         }
116 |         if (failed) {
117 |             throw new RuntimeException("EGL error encountered (see log)");
118 |         }
119 |     }
120 | }
121 | 


--------------------------------------------------------------------------------
/videocompress/src/main/java/com/xiaoguang/widget/videocompress/dialog/VideoCompressDialog.java:
--------------------------------------------------------------------------------
  1 | package com.xiaoguang.widget.videocompress.dialog;
  2 | 
  3 | import android.app.Dialog;
  4 | import android.content.Context;
  5 | import android.os.Bundle;
  6 | import android.os.Environment;
  7 | import android.text.TextUtils;
  8 | import android.util.Log;
  9 | import android.widget.TextView;
 10 | 
 11 | import androidx.annotation.NonNull;
 12 | 
 13 | import com.xiaoguang.widget.videocompress.R;
 14 | import com.xiaoguang.widget.videocompress.core.VideoCompress;
 15 | 
 16 | import java.io.File;
 17 | import java.text.DecimalFormat;
 18 | 
 19 | /**
 20 |  * 视频压缩工具
 21 |  * use：
 22 |  * VideoCompressDialog dialog = new VideoCompressDialog(getActivity());
 23 |  * dialog.setInputPath(filePaths.get(0));
 24 |  * dialog.setCallback(new VideoCompressDialog.OnCallback() {
 25 |  *
 26 |  * @Override public void success(String successPath) {
 27 |  * }
 28 |  * @Override public void fail(int code, String message) {
 29 |  * }
 30 |  * });
 31 |  * dialog.show();
 32 |  * hxg 2021/3/31 17:22 qq:929842234
 33 |  */
 34 | public class VideoCompressDialog extends Dialog {
 35 | 
 36 |     private OnCallback callback;
 37 | 
 38 |     public interface OnCallback {
 39 |         void success(String successPath);
 40 | 
 41 |         void fail(int code, String message);
 42 |     }
 43 | 
 44 |     private Context context;
 45 | 
 46 |     private TextView tv_des;
 47 |     private TextView tv_progress;
 48 |     private TextView tv_cancel;
 49 | 
 50 |     private String inputPath;
 51 |     private String outputPath;
 52 |     private VideoCompress.VideoCompressTask videoCompressTask;
 53 | 
 54 |     public VideoCompressDialog(@NonNull Context context) {
 55 |         super(context, R.style.dialog_default_style);
 56 |         this.context = context;
 57 |     }
 58 | 
 59 |     public void setInputPath(String inputPath) {
 60 |         this.inputPath = inputPath;
 61 |     }
 62 | 
 63 |     public void setOutputPath(String outputPath) {
 64 |         this.outputPath = outputPath;
 65 |     }
 66 | 
 67 |     public void setCallback(OnCallback callback) {
 68 |         this.callback = callback;
 69 |     }
 70 | 
 71 |     @Override
 72 |     protected void onCreate(Bundle savedInstanceState) {
 73 |         super.onCreate(savedInstanceState);
 74 |         this.setContentView(R.layout.dialog_media_loading);
 75 | 
 76 |         tv_des = findViewById(R.id.tv_des);
 77 |         tv_progress = findViewById(R.id.tv_progress);
 78 |         tv_cancel = findViewById(R.id.tv_cancel);
 79 |         tv_cancel.setOnClickListener(v -> progressDialog(0, "compression cancel"));
 80 | 
 81 |         setCanceledOnTouchOutside(false);
 82 | 
 83 |         getWindow().setBackgroundDrawableResource(R.color.transparent);
 84 | 
 85 |         initOutputPath();
 86 | 
 87 |         compress();
 88 |     }
 89 | 
 90 |     /**
 91 |      * 默认输出路径  包名/cache/videoCompress/compressedMp4.mp4
 92 |      */
 93 |     private void initOutputPath() {
 94 |         if (TextUtils.isEmpty(outputPath)) {
 95 |             String path = Environment.getExternalStorageDirectory().getPath() + "/Android/data/" + context.getPackageName();
 96 |             mkdir(path);
 97 |             mkdir(path + "/cache");
 98 |             mkdir(path + "/cache/videoCompress");
 99 |             outputPath = path + "/cache/videoCompress" + "/compressedMp4.mp4";
100 |         }
101 |     }
102 | 
103 |     public static void mkdir(String filePath) {
104 |         File file = new File(filePath);
105 |         if (!file.exists()) {
106 |             file.mkdir();
107 |         }
108 |     }
109 | 
110 |     /**
111 |      * 压缩
112 |      */
113 |     private void compress() {
114 |         videoCompressTask = VideoCompress.compressVideoLow(inputPath, outputPath, new VideoCompress.CompressListener() {
115 |             @Override
116 |             public void onStart() {
117 |             }
118 | 
119 |             @Override
120 |             public void onSuccess() {
121 |                 progressDialog(1, "compression success");
122 |             }
123 | 
124 |             @Override
125 |             public void onFail() {
126 |                 progressDialog(-1, "compression error");
127 |             }
128 | 
129 |             @Override
130 |             public void onProgress(float percent) {
131 |                 Log.i("VideoCompressDialog", "percent " + percent);
132 |                 DecimalFormat decimalFormat = new DecimalFormat("0.0");
133 |                 String percentString = decimalFormat.format(percent);
134 |                 setProgressDialog(percentString);
135 |             }
136 |         });
137 |     }
138 | 
139 |     @Override
140 |     public void cancel() {
141 |     }
142 | 
143 |     @Override
144 |     public void onDetachedFromWindow() {
145 |         super.onDetachedFromWindow();
146 |         if (null != videoCompressTask) {
147 |             videoCompressTask.cancel(true);
148 |         }
149 |     }
150 | 
151 |     private void progressDialog(int code, String s) {
152 |         Log.i("VideoCompressDialog", "code " + code + "  ,msg " + s);
153 |         if (null != callback) {
154 |             switch (code) {
155 |                 case -1:
156 |                     callback.fail(-1, this.getContext().getString(R.string.compress_error));
157 |                     break;
158 |                 case 0:
159 |                     callback.fail(0, this.getContext().getString(R.string.compress_cancel));
160 |                     break;
161 |                 case 1:
162 |                     callback.success(outputPath);
163 |                     break;
164 |             }
165 |         }
166 |         dismiss();
167 |     }
168 | 
169 |     private void setProgressDialog(String percentString) {
170 |         tv_progress.setText(percentString);
171 |     }
172 | }


--------------------------------------------------------------------------------
/app/src/main/java/com/xiaoguang/widget/videocompress/demo/MainActivity.java:
--------------------------------------------------------------------------------
  1 | package com.xiaoguang.widget.videocompress.demo;
  2 | 
  3 | import android.Manifest;
  4 | import android.app.Activity;
  5 | import android.content.Intent;
  6 | import android.content.pm.ActivityInfo;
  7 | import android.content.pm.PackageManager;
  8 | import android.os.Build;
  9 | import android.os.Bundle;
 10 | import android.widget.Toast;
 11 | 
 12 | import androidx.appcompat.app.AppCompatActivity;
 13 | 
 14 | import com.xiaoguang.widget.filepicker.FilePickerBuilder;
 15 | import com.xiaoguang.widget.filepicker.FilePickerConst;
 16 | import com.xiaoguang.widget.filepicker.models.sort.SortingTypes;
 17 | import com.xiaoguang.widget.videocompress.dialog.VideoCompressDialog;
 18 | 
 19 | import java.util.ArrayList;
 20 | 
 21 | public class MainActivity extends AppCompatActivity {
 22 |     private static final int REQUEST_CODE_PERMISSION_CAMERA = 10011;
 23 | 
 24 |     private static final int REQUEST_CODE_VIDEO = 10;// 视频
 25 | 
 26 |     @Override
 27 |     protected void onCreate(Bundle savedInstanceState) {
 28 |         super.onCreate(savedInstanceState);
 29 |         setContentView(R.layout.activity_main);
 30 |         findViewById(R.id.bt_select_file).setOnClickListener(v ->
 31 |                 initPermission());
 32 |     }
 33 | 
 34 |     private void initPermission() {
 35 |         //检查相机权限
 36 |         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
 37 |             if (checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
 38 |                 //没有相机权限
 39 |                 requestPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_EXTERNAL_STORAGE},
 40 |                         REQUEST_CODE_PERMISSION_CAMERA);
 41 |             } else {
 42 |                 filePicker();
 43 |             }
 44 |         } else {
 45 |             filePicker();
 46 |         }
 47 |     }
 48 | 
 49 |     @Override
 50 |     public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
 51 |         switch (requestCode) {
 52 |             case REQUEST_CODE_PERMISSION_CAMERA:
 53 |                 if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
 54 |                     // Permission Granted 授予权限
 55 |                     //用户同意了权限申请
 56 |                     filePicker();
 57 |                 } else {
 58 |                     // Permission Denied 权限被拒绝
 59 |                     Toast.makeText(this, "初始化文件选择器失败,读取文件权限被拒绝", Toast.LENGTH_SHORT).show();
 60 |                 }
 61 |                 break;
 62 |         }
 63 |         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
 64 | 
 65 |     }
 66 | 
 67 |     private void filePicker() {
 68 | //        String[] zips = {"zip", "rar"};
 69 | //        String[] doc = {"doc", "docx"};
 70 | //        String[] ppt = {"ppt", "pptx"};
 71 | //        String[] pdf = {"pdf"};
 72 | //        String[] txt = {"txt"};
 73 | //        String[] apk = {"apk"};
 74 | //        String[] xls = {"xls", "xlsx"};
 75 | //        String[] music = {"m3u", "m4a", "m4b", "m4p", "ogg", "wma", "wmv", "ogg", "rmvb", "mp2", "mp3", "aac", "awb", "amr", "mka"};
 76 |         FilePickerBuilder.getInstance()
 77 |                 .setMaxCount(1)
 78 | //                .setSelectedFiles(docPaths)
 79 | //                .setActivityTheme(R.style.DarkTheme2)
 80 | //                .enableCameraSupport(false)
 81 |                 .showPic(false)
 82 |                 .showVideo(true)
 83 |                 .enableDocSupport(false)
 84 | //                .addFileSupport("Word", doc, R.drawable.ic_file_word)
 85 | //                .addFileSupport("压缩包", zips, R.drawable.ic_file_zip)
 86 | //                .addFileSupport("PDF", pdf, R.drawable.ic_file_pdf)
 87 | //                .addFileSupport("Txt文本", txt, R.drawable.ic_file_txt)
 88 | //                .addFileSupport("PPT", ppt, R.drawable.ic_file_ppt)
 89 | //                .addFileSupport("安装包", apk, R.drawable.ic_file_zip)
 90 | //                .addFileSupport("Excel表格", xls, R.drawable.ic_file_excel)
 91 | //                .addFileSupport("音乐", music, R.drawable.ic_file_music)
 92 |                 .setActivityTitle("请选择文件")
 93 |                 .sortDocumentsBy(SortingTypes.name)
 94 |                 .withOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED)
 95 |                 .pickFile(this, REQUEST_CODE_VIDEO);
 96 |     }
 97 | 
 98 |     @Override
 99 |     public void onActivityResult(int requestCode, int resultCode, Intent data) {
100 |         super.onActivityResult(requestCode, resultCode, data);
101 |         if (resultCode == Activity.RESULT_OK) {
102 |             if (requestCode == REQUEST_CODE_VIDEO) {// 选择视频
103 |                 ArrayList<String> filePaths = data.getStringArrayListExtra(FilePickerConst.KEY_SELECTED_DOCS);
104 |                 String path = filePaths.get(0);
105 | //                Toast.makeText(this, "地址： " + path, Toast.LENGTH_SHORT).show();
106 |                 compress(path);
107 |             }
108 |         }
109 |     }
110 | 
111 |     private void compress(String filePath) {
112 |         // String cameraPath = Environment.getExternalStorageDirectory().getPath() + "/DCIM/Camera/";
113 |         // VideoCompressDialog.mkdir(cameraPath);
114 |         // String outputPath = cameraPath + System.currentTimeMillis() + ".mp4";
115 | 
116 |         VideoCompressDialog dialog = new VideoCompressDialog(this);
117 |         dialog.setInputPath(filePath);
118 |         // dialog.setOutputPath(outputPath);// 你想导出的地址 默认输出路径：包名/cache/videoCompress/compressedMp4.mp4
119 |         dialog.setCallback(new VideoCompressDialog.OnCallback() {
120 | 
121 |             @Override
122 |             public void success(String successPath) {
123 |                 Toast.makeText(MainActivity.this, "成功，path： " + successPath, Toast.LENGTH_SHORT).show();
124 |             }
125 | 
126 |             @Override
127 |             public void fail(int code, String message) {
128 |                 Toast.makeText(MainActivity.this, "失败，message： " + message, Toast.LENGTH_SHORT).show();
129 |             }
130 |         });
131 |         dialog.show();
132 |     }
133 | }


--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env sh
  2 | 
  3 | #
  4 | # Copyright 2015 the original author or authors.
  5 | #
  6 | # Licensed under the Apache License, Version 2.0 (the "License");
  7 | # you may not use this file except in compliance with the License.
  8 | # You may obtain a copy of the License at
  9 | #
 10 | #      https://www.apache.org/licenses/LICENSE-2.0
 11 | #
 12 | # Unless required by applicable law or agreed to in writing, software
 13 | # distributed under the License is distributed on an "AS IS" BASIS,
 14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15 | # See the License for the specific language governing permissions and
 16 | # limitations under the License.
 17 | #
 18 | 
 19 | ##############################################################################
 20 | ##
 21 | ##  Gradle start up script for UN*X
 22 | ##
 23 | ##############################################################################
 24 | 
 25 | # Attempt to set APP_HOME
 26 | # Resolve links: $0 may be a link
 27 | PRG="$0"
 28 | # Need this for relative symlinks.
 29 | while [ -h "$PRG" ] ; do
 30 |     ls=`ls -ld "$PRG"`
 31 |     link=`expr "$ls" : '.*-> \(.*\)$'`
 32 |     if expr "$link" : '/.*' > /dev/null; then
 33 |         PRG="$link"
 34 |     else
 35 |         PRG=`dirname "$PRG"`"/$link"
 36 |     fi
 37 | done
 38 | SAVED="`pwd`"
 39 | cd "`dirname \"$PRG\"`/" >/dev/null
 40 | APP_HOME="`pwd -P`"
 41 | cd "$SAVED" >/dev/null
 42 | 
 43 | APP_NAME="Gradle"
 44 | APP_BASE_NAME=`basename "$0"`
 45 | 
 46 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 47 | DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 48 | 
 49 | # Use the maximum available, or set MAX_FD != -1 to use that value.
 50 | MAX_FD="maximum"
 51 | 
 52 | warn () {
 53 |     echo "$*"
 54 | }
 55 | 
 56 | die () {
 57 |     echo
 58 |     echo "$*"
 59 |     echo
 60 |     exit 1
 61 | }
 62 | 
 63 | # OS specific support (must be 'true' or 'false').
 64 | cygwin=false
 65 | msys=false
 66 | darwin=false
 67 | nonstop=false
 68 | case "`uname`" in
 69 |   CYGWIN* )
 70 |     cygwin=true
 71 |     ;;
 72 |   Darwin* )
 73 |     darwin=true
 74 |     ;;
 75 |   MINGW* )
 76 |     msys=true
 77 |     ;;
 78 |   NONSTOP* )
 79 |     nonstop=true
 80 |     ;;
 81 | esac
 82 | 
 83 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 84 | 
 85 | 
 86 | # Determine the Java command to use to start the JVM.
 87 | if [ -n "$JAVA_HOME" ] ; then
 88 |     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
 89 |         # IBM's JDK on AIX uses strange locations for the executables
 90 |         JAVACMD="$JAVA_HOME/jre/sh/java"
 91 |     else
 92 |         JAVACMD="$JAVA_HOME/bin/java"
 93 |     fi
 94 |     if [ ! -x "$JAVACMD" ] ; then
 95 |         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
 96 | 
 97 | Please set the JAVA_HOME variable in your environment to match the
 98 | location of your Java installation."
 99 |     fi
100 | else
101 |     JAVACMD="java"
102 |     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
103 | 
104 | Please set the JAVA_HOME variable in your environment to match the
105 | location of your Java installation."
106 | fi
107 | 
108 | # Increase the maximum file descriptors if we can.
109 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
110 |     MAX_FD_LIMIT=`ulimit -H -n`
111 |     if [ $? -eq 0 ] ; then
112 |         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
113 |             MAX_FD="$MAX_FD_LIMIT"
114 |         fi
115 |         ulimit -n $MAX_FD
116 |         if [ $? -ne 0 ] ; then
117 |             warn "Could not set maximum file descriptor limit: $MAX_FD"
118 |         fi
119 |     else
120 |         warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
121 |     fi
122 | fi
123 | 
124 | # For Darwin, add options to specify how the application appears in the dock
125 | if $darwin; then
126 |     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
127 | fi
128 | 
129 | # For Cygwin or MSYS, switch paths to Windows format before running java
130 | if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
131 |     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
132 |     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
133 | 
134 |     JAVACMD=`cygpath --unix "$JAVACMD"`
135 | 
136 |     # We build the pattern for arguments to be converted via cygpath
137 |     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
138 |     SEP=""
139 |     for dir in $ROOTDIRSRAW ; do
140 |         ROOTDIRS="$ROOTDIRS$SEP$dir"
141 |         SEP="|"
142 |     done
143 |     OURCYGPATTERN="(^($ROOTDIRS))"
144 |     # Add a user-defined pattern to the cygpath arguments
145 |     if [ "$GRADLE_CYGPATTERN" != "" ] ; then
146 |         OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
147 |     fi
148 |     # Now convert the arguments - kludge to limit ourselves to /bin/sh
149 |     i=0
150 |     for arg in "$@" ; do
151 |         CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
152 |         CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
153 | 
154 |         if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
155 |             eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
156 |         else
157 |             eval `echo args$i`="\"$arg\""
158 |         fi
159 |         i=`expr $i + 1`
160 |     done
161 |     case $i in
162 |         0) set -- ;;
163 |         1) set -- "$args0" ;;
164 |         2) set -- "$args0" "$args1" ;;
165 |         3) set -- "$args0" "$args1" "$args2" ;;
166 |         4) set -- "$args0" "$args1" "$args2" "$args3" ;;
167 |         5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
168 |         6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
169 |         7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
170 |         8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
171 |         9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
172 |     esac
173 | fi
174 | 
175 | # Escape application args
176 | save () {
177 |     for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
178 |     echo " "
179 | }
180 | APP_ARGS=`save "$@"`
181 | 
182 | # Collect all arguments for the java command, following the shell quoting and substitution rules
183 | eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
184 | 
185 | exec "$JAVACMD" "$@"
186 | 


--------------------------------------------------------------------------------
/videocompress/src/main/java/com/xiaoguang/widget/videocompress/core/OutputSurface.java:
--------------------------------------------------------------------------------
  1 | package com.xiaoguang.widget.videocompress.core;
  2 | 
  3 | import android.annotation.TargetApi;
  4 | import android.graphics.SurfaceTexture;
  5 | import android.opengl.GLES20;
  6 | import android.view.Surface;
  7 | 
  8 | import java.nio.ByteBuffer;
  9 | import java.nio.ByteOrder;
 10 | 
 11 | import javax.microedition.khronos.egl.EGL10;
 12 | import javax.microedition.khronos.egl.EGLConfig;
 13 | import javax.microedition.khronos.egl.EGLContext;
 14 | import javax.microedition.khronos.egl.EGLDisplay;
 15 | import javax.microedition.khronos.egl.EGLSurface;
 16 | 
 17 | @TargetApi(16)
 18 | public class OutputSurface implements SurfaceTexture.OnFrameAvailableListener {
 19 | 
 20 |     private static final int EGL_OPENGL_ES2_BIT = 4;
 21 |     private static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
 22 |     private EGL10 mEGL;
 23 |     private EGLDisplay mEGLDisplay = null;
 24 |     private EGLContext mEGLContext = null;
 25 |     private EGLSurface mEGLSurface = null;
 26 |     private SurfaceTexture mSurfaceTexture;
 27 |     private Surface mSurface;
 28 |     private final Object mFrameSyncObject = new Object();
 29 |     private boolean mFrameAvailable;
 30 |     private TextureRenderer mTextureRender;
 31 |     private int mWidth;
 32 |     private int mHeight;
 33 |     private int rotateRender = 0;
 34 |     private ByteBuffer mPixelBuf;
 35 | 
 36 |     public OutputSurface(int width, int height, int rotate) {
 37 |         if (width <= 0 || height <= 0) {
 38 |             throw new IllegalArgumentException();
 39 |         }
 40 |         mWidth = width;
 41 |         mHeight = height;
 42 |         rotateRender = rotate;
 43 |         mPixelBuf = ByteBuffer.allocateDirect(mWidth * mHeight * 4);
 44 |         mPixelBuf.order(ByteOrder.LITTLE_ENDIAN);
 45 |         eglSetup(width, height);
 46 |         makeCurrent();
 47 |         setup();
 48 |     }
 49 | 
 50 |     public OutputSurface() {
 51 |         setup();
 52 |     }
 53 | 
 54 |     private void setup() {
 55 |         mTextureRender = new TextureRenderer(rotateRender);
 56 |         mTextureRender.surfaceCreated();
 57 |         mSurfaceTexture = new SurfaceTexture(mTextureRender.getTextureId());
 58 |         mSurfaceTexture.setOnFrameAvailableListener(this);
 59 |         mSurface = new Surface(mSurfaceTexture);
 60 |     }
 61 | 
 62 |     private void eglSetup(int width, int height) {
 63 |         mEGL = (EGL10) EGLContext.getEGL();
 64 |         mEGLDisplay = mEGL.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
 65 | 
 66 |         if (mEGLDisplay == EGL10.EGL_NO_DISPLAY) {
 67 |             throw new RuntimeException("unable to get EGL10 display");
 68 |         }
 69 | 
 70 |         if (!mEGL.eglInitialize(mEGLDisplay, null)) {
 71 |             mEGLDisplay = null;
 72 |             throw new RuntimeException("unable to initialize EGL10");
 73 |         }
 74 | 
 75 |         int[] attribList = {
 76 |                 EGL10.EGL_RED_SIZE, 8,
 77 |                 EGL10.EGL_GREEN_SIZE, 8,
 78 |                 EGL10.EGL_BLUE_SIZE, 8,
 79 |                 EGL10.EGL_ALPHA_SIZE, 8,
 80 |                 EGL10.EGL_SURFACE_TYPE, EGL10.EGL_PBUFFER_BIT,
 81 |                 EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
 82 |                 EGL10.EGL_NONE
 83 |         };
 84 |         EGLConfig[] configs = new EGLConfig[1];
 85 |         int[] numConfigs = new int[1];
 86 |         if (!mEGL.eglChooseConfig(mEGLDisplay, attribList, configs, configs.length, numConfigs)) {
 87 |             throw new RuntimeException("unable to find RGB888+pbuffer EGL config");
 88 |         }
 89 |         int[] attrib_list = {
 90 |                 EGL_CONTEXT_CLIENT_VERSION, 2,
 91 |                 EGL10.EGL_NONE
 92 |         };
 93 |         mEGLContext = mEGL.eglCreateContext(mEGLDisplay, configs[0], EGL10.EGL_NO_CONTEXT, attrib_list);
 94 |         checkEglError("eglCreateContext");
 95 |         if (mEGLContext == null) {
 96 |             throw new RuntimeException("null context");
 97 |         }
 98 |         int[] surfaceAttribs = {
 99 |                 EGL10.EGL_WIDTH, width,
100 |                 EGL10.EGL_HEIGHT, height,
101 |                 EGL10.EGL_NONE
102 |         };
103 |         mEGLSurface = mEGL.eglCreatePbufferSurface(mEGLDisplay, configs[0], surfaceAttribs);
104 |         checkEglError("eglCreatePbufferSurface");
105 |         if (mEGLSurface == null) {
106 |             throw new RuntimeException("surface was null");
107 |         }
108 |     }
109 | 
110 |     public void release() {
111 |         if (mEGL != null) {
112 |             if (mEGL.eglGetCurrentContext().equals(mEGLContext)) {
113 |                 mEGL.eglMakeCurrent(mEGLDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
114 |             }
115 |             mEGL.eglDestroySurface(mEGLDisplay, mEGLSurface);
116 |             mEGL.eglDestroyContext(mEGLDisplay, mEGLContext);
117 |         }
118 |         mSurface.release();
119 |         mEGLDisplay = null;
120 |         mEGLContext = null;
121 |         mEGLSurface = null;
122 |         mEGL = null;
123 |         mTextureRender = null;
124 |         mSurface = null;
125 |         mSurfaceTexture = null;
126 |     }
127 | 
128 |     public void makeCurrent() {
129 |         if (mEGL == null) {
130 |             throw new RuntimeException("not configured for makeCurrent");
131 |         }
132 |         checkEglError("before makeCurrent");
133 |         if (!mEGL.eglMakeCurrent(mEGLDisplay, mEGLSurface, mEGLSurface, mEGLContext)) {
134 |             throw new RuntimeException("eglMakeCurrent failed");
135 |         }
136 |     }
137 | 
138 |     public Surface getSurface() {
139 |         return mSurface;
140 |     }
141 | 
142 |     public void changeFragmentShader(String fragmentShader) {
143 |         mTextureRender.changeFragmentShader(fragmentShader);
144 |     }
145 | 
146 |     public void awaitNewImage() {
147 |         final int TIMEOUT_MS = 5000;
148 |         synchronized (mFrameSyncObject) {
149 |             while (!mFrameAvailable) {
150 |                 try {
151 |                     mFrameSyncObject.wait(TIMEOUT_MS);
152 |                     if (!mFrameAvailable) {
153 |                         throw new RuntimeException("Surface frame wait timed out");
154 |                     }
155 |                 } catch (InterruptedException ie) {
156 |                     throw new RuntimeException(ie);
157 |                 }
158 |             }
159 |             mFrameAvailable = false;
160 |         }
161 |         mTextureRender.checkGlError("before updateTexImage");
162 |         mSurfaceTexture.updateTexImage();
163 |     }
164 | 
165 |     public void drawImage(boolean invert) {
166 |         mTextureRender.drawFrame(mSurfaceTexture, invert);
167 |     }
168 | 
169 |     @Override
170 |     public void onFrameAvailable(SurfaceTexture st) {
171 |         synchronized (mFrameSyncObject) {
172 |             if (mFrameAvailable) {
173 |                 throw new RuntimeException("mFrameAvailable already set, frame could be dropped");
174 |             }
175 |             mFrameAvailable = true;
176 |             mFrameSyncObject.notifyAll();
177 |         }
178 |     }
179 | 
180 |     public ByteBuffer getFrame() {
181 |         mPixelBuf.rewind();
182 |         GLES20.glReadPixels(0, 0, mWidth, mHeight, GLES20.GL_RGBA, GLES20.GL_UNSIGNED_BYTE, mPixelBuf);
183 |         return mPixelBuf;
184 |     }
185 | 
186 |     private void checkEglError(String msg) {
187 |         if (mEGL.eglGetError() != EGL10.EGL_SUCCESS) {
188 |             throw new RuntimeException("EGL error encountered (see log)");
189 |         }
190 |     }
191 | }
192 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # VideoCompress
  2 | # 一款快速、高效的视频压缩工具。A fast and efficient video compression tool.
  3 | [![](https://jitpack.io/v/ITxiaoguang/VideoCompress.svg)](https://jitpack.io/#ITxiaoguang/VideoCompress)
  4 | 
  5 | - 包超级小
  6 | - 压缩快，不失真
  7 | - 压缩后视频长宽/2，所以分辨率压缩到原来的1/4，压缩后体积超小
  8 | 
  9 | ### 支持自定义输出路径`outputPath`
 10 | 
 11 | ### 自带`VideoCompressDialog`弹窗，用法超级简单：
 12 | 
 13 | ```java
 14 | // String cameraPath = Environment.getExternalStorageDirectory().getPath() + "/DCIM/Camera/";
 15 | // VideoCompressDialog.mkdir(cameraPath);
 16 | // String outputPath = cameraPath + System.currentTimeMillis() + ".mp4";
 17 | 
 18 | VideoCompressDialog dialog = new VideoCompressDialog(this);
 19 | dialog.setInputPath(filePath);
 20 | // dialog.setOutputPath(outputPath);// 你想导出的地址 默认输出路径：包名/cache/videoCompress/compressedMp4.mp4
 21 | dialog.setCallback(new VideoCompressDialog.OnCallback() {
 22 |     @Override
 23 |     public void success(String successPath) {
 24 |         Toast.makeText(MainActivity.this, "成功，path： " + successPath, Toast.LENGTH_SHORT).show();
 25 |     }
 26 | 
 27 |     @Override
 28 |     public void fail(int code, String message) {
 29 |         Toast.makeText(MainActivity.this, "失败，message： " + message, Toast.LENGTH_SHORT).show();
 30 |     }
 31 | });
 32 | dialog.show();
 33 | ```
 34 | 
 35 | ## 如何添加
 36 | ### Gradle添加：
 37 | #### 1.在Project的`build.gradle`中添加仓库地址
 38 | 
 39 | ``` gradle
 40 | allprojects {
 41 |   repositories {
 42 |      ...
 43 |      maven { url "https://jitpack.io" }
 44 |   }
 45 | }
 46 | ```
 47 | 
 48 | #### 2.在Module目录下的`build.gradle`中添加依赖
 49 | 
 50 | [![](https://jitpack.io/v/ITxiaoguang/VideoCompress.svg)](https://jitpack.io/#ITxiaoguang/VideoCompress)
 51 | 
 52 | ``` gradle
 53 | dependencies {
 54 |        implementation 'com.github.ITxiaoguang:VideoCompress:xxx'
 55 | }
 56 | ```
 57 | 
 58 | #### 3.Android10.0 需要在`AndroidManifest.xml`文件中`application`出加上
 59 | ```xml
 60 | <application
 61 |   android:requestLegacyExternalStorage="true"
 62 |   ...
 63 |   />
 64 | ```
 65 | 
 66 | #### 4.`AndroidManifest.xml`加上读写权限，代码里并请求读写权限
 67 | ```xml
 68 | <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
 69 | <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
 70 | ```
 71 | 
 72 | #### 5.请求读写权限
 73 | ```java
 74 | private void initPermission() {
 75 |     //检查文件权限
 76 |     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
 77 |         if (checkSelfPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
 78 |             //没有文件权限
 79 |             requestPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE,
 80 |                 Manifest.permission.READ_EXTERNAL_STORAGE}, REQUEST_CODE_PERMISSION_CAMERA);
 81 |         } else {
 82 |             // todo 打开文件选择器
 83 |         }
 84 |     } else {
 85 |         // todo 打开文件选择器
 86 |     }
 87 | }
 88 | ```
 89 | 
 90 | #### 6.权限回调
 91 | ```java
 92 | @Override
 93 | public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
 94 |     switch (requestCode) {
 95 |         case REQUEST_CODE_PERMISSION_CAMERA:
 96 |             if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
 97 |                 // Permission Granted 授予权限
 98 |                 // todo 用户同意了权限申请 打开文件选择器
 99 |             } else {
100 |                 // Permission Denied 权限被拒绝
101 |                 Toast.makeText(this, "初始化文件选择器失败,读取文件权限被拒绝", Toast.LENGTH_SHORT).show();
102 |             }
103 |             break;
104 |     }
105 |     super.onRequestPermissionsResult(requestCode, permissions, grantResults);
106 | }
107 | ```
108 | 
109 | ### 自带`VideoCompressDialog`弹窗，用法超级简单：
110 | 
111 | ```java
112 | // String cameraPath = Environment.getExternalStorageDirectory().getPath() + "/DCIM/Camera/";
113 | // VideoCompressDialog.mkdir(cameraPath);
114 | // String outputPath = cameraPath + System.currentTimeMillis() + ".mp4";
115 | 
116 | VideoCompressDialog dialog = new VideoCompressDialog(this);
117 | dialog.setInputPath(inputPath);// 输入视频地址
118 | // dialog.setOutputPath(outputPath);// 输出视频地址 默认输出路径：包名/cache/videoCompress/compressedMp4.mp4
119 | dialog.setCallback(new VideoCompressDialog.OnCallback() {
120 |     @Override
121 |     public void success(String successPath) {
122 |         Toast.makeText(MainActivity.this, "成功，path： " + successPath, Toast.LENGTH_SHORT).show();
123 |     }
124 |     
125 |     @Override
126 |     public void fail(int code, String message) {
127 |         Toast.makeText(MainActivity.this, "失败，message： " + message, Toast.LENGTH_SHORT).show();
128 |     }
129 | });
130 | dialog.show();
131 | ```
132 | 
133 | ### 完整用法：
134 | 
135 | ```java
136 | // VideoCompress.compressVideoHigh   高质量压缩
137 | // VideoCompress.compressVideoMedium 中质量压缩
138 | // VideoCompress.compressVideoLow    低质量压缩
139 | // inputPath  输入视频地址
140 | // outputPath 输出视频地址
141 | VideoCompressTask task = VideoCompress.compressVideoLow(inputPath, outputPath, new VideoCompress.CompressListener() {
142 |     @Override
143 |     public void onStart() {
144 |         // Start Compress
145 |     }
146 | 
147 |     @Override
148 |     public void onSuccess() {
149 |         // Finish successfully
150 |     }
151 | 
152 |     @Override
153 |     public void onFail() {
154 |         // Failed
155 |     }
156 | 
157 |     @Override
158 |     public void onProgress(float percent) {
159 |         // Progress 进度
160 |     }
161 | });
162 | ```
163 | ### 中断任务：
164 | ```java
165 | if (null != task) {
166 |     task.cancel(true);
167 | }
168 | ```
169 | 
170 | # 选择文件
171 | 
172 | ## 推荐使用文件选择器选择文件 --> [文件选择器](https://github.com/ITxiaoguang/FilePicker)
173 | 
174 | #### 1.选择文件
175 | ```java
176 | private void filePicker() {
177 |     String[] zips = {"zip", "rar"};
178 |     String[] doc = {"doc", "docx"};
179 |     String[] ppt = {"ppt", "pptx"};
180 |     String[] pdf = {"pdf"};
181 |     String[] txt = {"txt"};
182 |     String[] apk = {"apk"};
183 |     String[] xls = {"xls", "xlsx"};
184 |     String[] music = {"m3u", "m4a", "m4b", "m4p", "ogg", "wma", "wmv", "ogg", "rmvb", "mp2", "mp3", "aac", "awb", "amr", "mka"};
185 |     FilePickerBuilder.getInstance()
186 |             .setMaxCount(1)
187 |             .enableCameraSupport(false)
188 |             .showPic(true)
189 |             .showVideo(true)
190 |             .enableDocSupport(false)
191 |             .addFileSupport("Word", doc, R.drawable.ic_file_word)
192 |             .addFileSupport("压缩包", zips, R.drawable.ic_file_zip)
193 |             .addFileSupport("PDF", pdf, R.drawable.ic_file_pdf)
194 |             .addFileSupport("Txt文本", txt, R.drawable.ic_file_txt)
195 |             .addFileSupport("PPT", ppt, R.drawable.ic_file_ppt)
196 |             .addFileSupport("安装包", apk, R.drawable.ic_file_zip)
197 |             .addFileSupport("Excel表格", xls, R.drawable.ic_file_excel)
198 |             .addFileSupport("音乐", music, R.drawable.ic_file_music)
199 |             .setActivityTitle("请选择文件")
200 |             .sortDocumentsBy(SortingTypes.name)
201 |             .withOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED)
202 |             .pickFile(this, REQUEST_CODE_FILE);
203 | }
204 | ```
205 | 
206 | #### 2.回调
207 | ```java
208 | @Override
209 | public void onActivityResult(int requestCode, int resultCode, Intent data) {
210 |     super.onActivityResult(requestCode, resultCode, data);
211 |     if (resultCode == Activity.RESULT_OK) {
212 |         if (requestCode == REQUEST_CODE_FILE) {//选择文件
213 |             ArrayList<String> filePaths = data.getStringArrayListExtra(FilePickerConst.KEY_SELECTED_DOCS);
214 |             String path = filePaths.get(0);
215 | //                Toast.makeText(this, "地址： " + path, Toast.LENGTH_SHORT).show();
216 |             compress(path);
217 |         }
218 |     }
219 | }
220 | ```
221 | 
222 | ### 鸣谢：
223 | - [mp4parser](https://github.com/sannies/mp4parser)
224 | 


--------------------------------------------------------------------------------
/videocompress/src/main/java/com/xiaoguang/widget/videocompress/core/TextureRenderer.java:
--------------------------------------------------------------------------------
  1 | package com.xiaoguang.widget.videocompress.core;
  2 | 
  3 | import android.annotation.TargetApi;
  4 | import android.graphics.SurfaceTexture;
  5 | import android.opengl.GLES11Ext;
  6 | import android.opengl.GLES20;
  7 | import android.opengl.Matrix;
  8 | 
  9 | import java.nio.ByteBuffer;
 10 | import java.nio.ByteOrder;
 11 | import java.nio.FloatBuffer;
 12 | 
 13 | @TargetApi(16)
 14 | public class TextureRenderer {
 15 | 
 16 |     private static final int FLOAT_SIZE_BYTES = 4;
 17 |     private static final int TRIANGLE_VERTICES_DATA_STRIDE_BYTES = 5 * FLOAT_SIZE_BYTES;
 18 |     private static final int TRIANGLE_VERTICES_DATA_POS_OFFSET = 0;
 19 |     private static final int TRIANGLE_VERTICES_DATA_UV_OFFSET = 3;
 20 |     private static final float[] mTriangleVerticesData = {
 21 |             -1.0f, -1.0f, 0, 0.f, 0.f,
 22 |             1.0f, -1.0f, 0, 1.f, 0.f,
 23 |             -1.0f, 1.0f, 0, 0.f, 1.f,
 24 |             1.0f, 1.0f, 0, 1.f, 1.f,
 25 |     };
 26 |     private FloatBuffer mTriangleVertices;
 27 | 
 28 |     private static final String VERTEX_SHADER =
 29 |             "uniform mat4 uMVPMatrix;\n" +
 30 |             "uniform mat4 uSTMatrix;\n" +
 31 |             "attribute vec4 aPosition;\n" +
 32 |             "attribute vec4 aTextureCoord;\n" +
 33 |             "varying vec2 vTextureCoord;\n" +
 34 |             "void main() {\n" +
 35 |             "  gl_Position = uMVPMatrix * aPosition;\n" +
 36 |             "  vTextureCoord = (uSTMatrix * aTextureCoord).xy;\n" +
 37 |             "}\n";
 38 | 
 39 |     private static final String FRAGMENT_SHADER =
 40 |             "#extension GL_OES_EGL_image_external : require\n" +
 41 |             "precision mediump float;\n" +
 42 |             "varying vec2 vTextureCoord;\n" +
 43 |             "uniform samplerExternalOES sTexture;\n" +
 44 |             "void main() {\n" +
 45 |             "  gl_FragColor = texture2D(sTexture, vTextureCoord);\n" +
 46 |             "}\n";
 47 | 
 48 |     private float[] mMVPMatrix = new float[16];
 49 |     private float[] mSTMatrix = new float[16];
 50 |     private int mProgram;
 51 |     private int mTextureID = -12345;
 52 |     private int muMVPMatrixHandle;
 53 |     private int muSTMatrixHandle;
 54 |     private int maPositionHandle;
 55 |     private int maTextureHandle;
 56 |     private int rotationAngle = 0;
 57 | 
 58 |     public TextureRenderer(int rotation) {
 59 |         rotationAngle = rotation;
 60 |         mTriangleVertices = ByteBuffer.allocateDirect(mTriangleVerticesData.length * FLOAT_SIZE_BYTES).order(ByteOrder.nativeOrder()).asFloatBuffer();
 61 |         mTriangleVertices.put(mTriangleVerticesData).position(0);
 62 |         Matrix.setIdentityM(mSTMatrix, 0);
 63 |     }
 64 | 
 65 |     public int getTextureId() {
 66 |         return mTextureID;
 67 |     }
 68 | 
 69 |     public void drawFrame(SurfaceTexture st, boolean invert) {
 70 |         checkGlError("onDrawFrame start");
 71 |         st.getTransformMatrix(mSTMatrix);
 72 | 
 73 |         if (invert) {
 74 |             mSTMatrix[5] = -mSTMatrix[5];
 75 |             mSTMatrix[13] = 1.0f - mSTMatrix[13];
 76 |         }
 77 | 
 78 |         GLES20.glUseProgram(mProgram);
 79 |         checkGlError("glUseProgram");
 80 |         GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
 81 |         GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, mTextureID);
 82 |         mTriangleVertices.position(TRIANGLE_VERTICES_DATA_POS_OFFSET);
 83 |         GLES20.glVertexAttribPointer(maPositionHandle, 3, GLES20.GL_FLOAT, false, TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mTriangleVertices);
 84 |         checkGlError("glVertexAttribPointer maPosition");
 85 |         GLES20.glEnableVertexAttribArray(maPositionHandle);
 86 |         checkGlError("glEnableVertexAttribArray maPositionHandle");
 87 |         mTriangleVertices.position(TRIANGLE_VERTICES_DATA_UV_OFFSET);
 88 |         GLES20.glVertexAttribPointer(maTextureHandle, 2, GLES20.GL_FLOAT, false, TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mTriangleVertices);
 89 |         checkGlError("glVertexAttribPointer maTextureHandle");
 90 |         GLES20.glEnableVertexAttribArray(maTextureHandle);
 91 |         checkGlError("glEnableVertexAttribArray maTextureHandle");
 92 |         GLES20.glUniformMatrix4fv(muSTMatrixHandle, 1, false, mSTMatrix, 0);
 93 |         GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, mMVPMatrix, 0);
 94 |         GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4);
 95 |         checkGlError("glDrawArrays");
 96 |         GLES20.glFinish();
 97 |     }
 98 | 
 99 |     public void surfaceCreated() {
100 |         mProgram = createProgram(VERTEX_SHADER, FRAGMENT_SHADER);
101 |         if (mProgram == 0) {
102 |             throw new RuntimeException("failed creating program");
103 |         }
104 |         maPositionHandle = GLES20.glGetAttribLocation(mProgram, "aPosition");
105 |         checkGlError("glGetAttribLocation aPosition");
106 |         if (maPositionHandle == -1) {
107 |             throw new RuntimeException("Could not get attrib location for aPosition");
108 |         }
109 |         maTextureHandle = GLES20.glGetAttribLocation(mProgram, "aTextureCoord");
110 |         checkGlError("glGetAttribLocation aTextureCoord");
111 |         if (maTextureHandle == -1) {
112 |             throw new RuntimeException("Could not get attrib location for aTextureCoord");
113 |         }
114 |         muMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
115 |         checkGlError("glGetUniformLocation uMVPMatrix");
116 |         if (muMVPMatrixHandle == -1) {
117 |             throw new RuntimeException("Could not get attrib location for uMVPMatrix");
118 |         }
119 |         muSTMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uSTMatrix");
120 |         checkGlError("glGetUniformLocation uSTMatrix");
121 |         if (muSTMatrixHandle == -1) {
122 |             throw new RuntimeException("Could not get attrib location for uSTMatrix");
123 |         }
124 |         int[] textures = new int[1];
125 |         GLES20.glGenTextures(1, textures, 0);
126 |         mTextureID = textures[0];
127 |         GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, mTextureID);
128 |         checkGlError("glBindTexture mTextureID");
129 |         GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
130 |         GLES20.glTexParameterf(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
131 |         GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
132 |         GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);
133 |         checkGlError("glTexParameter");
134 | 
135 |         Matrix.setIdentityM(mMVPMatrix, 0);
136 |         if (rotationAngle != 0) {
137 |             Matrix.rotateM(mMVPMatrix, 0, rotationAngle, 0, 0, 1);
138 |         }
139 |     }
140 | 
141 |     public void changeFragmentShader(String fragmentShader) {
142 |         GLES20.glDeleteProgram(mProgram);
143 |         mProgram = createProgram(VERTEX_SHADER, fragmentShader);
144 |         if (mProgram == 0) {
145 |             throw new RuntimeException("failed creating program");
146 |         }
147 |     }
148 | 
149 |     private int loadShader(int shaderType, String source) {
150 |         int shader = GLES20.glCreateShader(shaderType);
151 |         checkGlError("glCreateShader type=" + shaderType);
152 |         GLES20.glShaderSource(shader, source);
153 |         GLES20.glCompileShader(shader);
154 |         int[] compiled = new int[1];
155 |         GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);
156 |         if (compiled[0] == 0) {
157 |             GLES20.glDeleteShader(shader);
158 |             shader = 0;
159 |         }
160 |         return shader;
161 |     }
162 | 
163 |     private int createProgram(String vertexSource, String fragmentSource) {
164 |         int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);
165 |         if (vertexShader == 0) {
166 |             return 0;
167 |         }
168 |         int pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);
169 |         if (pixelShader == 0) {
170 |             return 0;
171 |         }
172 |         int program = GLES20.glCreateProgram();
173 |         checkGlError("glCreateProgram");
174 |         if (program == 0) {
175 |             return 0;
176 |         }
177 |         GLES20.glAttachShader(program, vertexShader);
178 |         checkGlError("glAttachShader");
179 |         GLES20.glAttachShader(program, pixelShader);
180 |         checkGlError("glAttachShader");
181 |         GLES20.glLinkProgram(program);
182 |         int[] linkStatus = new int[1];
183 |         GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);
184 |         if (linkStatus[0] != GLES20.GL_TRUE) {
185 |             GLES20.glDeleteProgram(program);
186 |             program = 0;
187 |         }
188 |         return program;
189 |     }
190 | 
191 |     public void checkGlError(String op) {
192 |         int error;
193 |         if ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
194 |             throw new RuntimeException(op + ": glError " + error);
195 |         }
196 |     }
197 | }
198 | 


--------------------------------------------------------------------------------
/videocompress/src/main/java/com/xiaoguang/widget/videocompress/core/Track.java:
--------------------------------------------------------------------------------
  1 | package com.xiaoguang.widget.videocompress.core;
  2 | 
  3 | import android.annotation.TargetApi;
  4 | import android.media.MediaCodec;
  5 | import android.media.MediaFormat;
  6 | 
  7 | import com.coremedia.iso.boxes.AbstractMediaHeaderBox;
  8 | import com.coremedia.iso.boxes.SampleDescriptionBox;
  9 | import com.coremedia.iso.boxes.SoundMediaHeaderBox;
 10 | import com.coremedia.iso.boxes.VideoMediaHeaderBox;
 11 | import com.coremedia.iso.boxes.sampleentry.AudioSampleEntry;
 12 | import com.coremedia.iso.boxes.sampleentry.VisualSampleEntry;
 13 | import com.googlecode.mp4parser.boxes.mp4.ESDescriptorBox;
 14 | import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.AudioSpecificConfig;
 15 | import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.DecoderConfigDescriptor;
 16 | import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.ESDescriptor;
 17 | import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.SLConfigDescriptor;
 18 | import com.mp4parser.iso14496.part15.AvcConfigurationBox;
 19 | 
 20 | import java.nio.ByteBuffer;
 21 | import java.util.ArrayList;
 22 | import java.util.Date;
 23 | import java.util.HashMap;
 24 | import java.util.LinkedList;
 25 | import java.util.Map;
 26 | 
 27 | @TargetApi(16)
 28 | public class Track {
 29 |     private long trackId = 0;
 30 |     private ArrayList<Sample> samples = new ArrayList<Sample>();
 31 |     private long duration = 0;
 32 |     private String handler;
 33 |     private AbstractMediaHeaderBox headerBox = null;
 34 |     private SampleDescriptionBox sampleDescriptionBox = null;
 35 |     private LinkedList<Integer> syncSamples = null;
 36 |     private int timeScale;
 37 |     private Date creationTime = new Date();
 38 |     private int height;
 39 |     private int width;
 40 |     private float volume = 0;
 41 |     private ArrayList<Long> sampleDurations = new ArrayList<Long>();
 42 |     private boolean isAudio = false;
 43 |     private static Map<Integer, Integer> samplingFrequencyIndexMap = new HashMap<Integer, Integer>();
 44 |     private long lastPresentationTimeUs = 0;
 45 |     private boolean first = true;
 46 | 
 47 |     static {
 48 |         samplingFrequencyIndexMap.put(96000, 0x0);
 49 |         samplingFrequencyIndexMap.put(88200, 0x1);
 50 |         samplingFrequencyIndexMap.put(64000, 0x2);
 51 |         samplingFrequencyIndexMap.put(48000, 0x3);
 52 |         samplingFrequencyIndexMap.put(44100, 0x4);
 53 |         samplingFrequencyIndexMap.put(32000, 0x5);
 54 |         samplingFrequencyIndexMap.put(24000, 0x6);
 55 |         samplingFrequencyIndexMap.put(22050, 0x7);
 56 |         samplingFrequencyIndexMap.put(16000, 0x8);
 57 |         samplingFrequencyIndexMap.put(12000, 0x9);
 58 |         samplingFrequencyIndexMap.put(11025, 0xa);
 59 |         samplingFrequencyIndexMap.put(8000, 0xb);
 60 |     }
 61 | 
 62 |     public Track(int id, MediaFormat format, boolean isAudio) throws Exception {
 63 |         trackId = id;
 64 |         if (!isAudio) {
 65 |             sampleDurations.add((long)3015);
 66 |             duration = 3015;
 67 |             width = format.getInteger(MediaFormat.KEY_WIDTH);
 68 |             height = format.getInteger(MediaFormat.KEY_HEIGHT);
 69 |             timeScale = 90000;
 70 |             syncSamples = new LinkedList<Integer>();
 71 |             handler = "vide";
 72 |             headerBox = new VideoMediaHeaderBox();
 73 |             sampleDescriptionBox = new SampleDescriptionBox();
 74 |             String mime = format.getString(MediaFormat.KEY_MIME);
 75 |             if (mime.equals("video/avc")) {
 76 |                 VisualSampleEntry visualSampleEntry = new VisualSampleEntry("avc1");
 77 |                 visualSampleEntry.setDataReferenceIndex(1);
 78 |                 visualSampleEntry.setDepth(24);
 79 |                 visualSampleEntry.setFrameCount(1);
 80 |                 visualSampleEntry.setHorizresolution(72);
 81 |                 visualSampleEntry.setVertresolution(72);
 82 |                 visualSampleEntry.setWidth(width);
 83 |                 visualSampleEntry.setHeight(height);
 84 | 
 85 |                 AvcConfigurationBox avcConfigurationBox = new AvcConfigurationBox();
 86 | 
 87 |                 if (format.getByteBuffer("csd-0") != null) {
 88 |                     ArrayList<byte[]> spsArray = new ArrayList<byte[]>();
 89 |                     ByteBuffer spsBuff = format.getByteBuffer("csd-0");
 90 |                     spsBuff.position(4);
 91 |                     byte[] spsBytes = new byte[spsBuff.remaining()];
 92 |                     spsBuff.get(spsBytes);
 93 |                     spsArray.add(spsBytes);
 94 | 
 95 |                     ArrayList<byte[]> ppsArray = new ArrayList<byte[]>();
 96 |                     ByteBuffer ppsBuff = format.getByteBuffer("csd-1");
 97 |                     ppsBuff.position(4);
 98 |                     byte[] ppsBytes = new byte[ppsBuff.remaining()];
 99 |                     ppsBuff.get(ppsBytes);
100 |                     ppsArray.add(ppsBytes);
101 |                     avcConfigurationBox.setSequenceParameterSets(spsArray);
102 |                     avcConfigurationBox.setPictureParameterSets(ppsArray);
103 |                 }
104 |                 //ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(spsBytes);
105 |                 //SeqParameterSet seqParameterSet = SeqParameterSet.read(byteArrayInputStream);
106 | 
107 |                 avcConfigurationBox.setAvcLevelIndication(13);
108 |                 avcConfigurationBox.setAvcProfileIndication(100);
109 |                 avcConfigurationBox.setBitDepthLumaMinus8(-1);
110 |                 avcConfigurationBox.setBitDepthChromaMinus8(-1);
111 |                 avcConfigurationBox.setChromaFormat(-1);
112 |                 avcConfigurationBox.setConfigurationVersion(1);
113 |                 avcConfigurationBox.setLengthSizeMinusOne(3);
114 |                 avcConfigurationBox.setProfileCompatibility(0);
115 | 
116 |                 visualSampleEntry.addBox(avcConfigurationBox);
117 |                 sampleDescriptionBox.addBox(visualSampleEntry);
118 |             } else if (mime.equals("video/mp4v")) {
119 |                 VisualSampleEntry visualSampleEntry = new VisualSampleEntry("mp4v");
120 |                 visualSampleEntry.setDataReferenceIndex(1);
121 |                 visualSampleEntry.setDepth(24);
122 |                 visualSampleEntry.setFrameCount(1);
123 |                 visualSampleEntry.setHorizresolution(72);
124 |                 visualSampleEntry.setVertresolution(72);
125 |                 visualSampleEntry.setWidth(width);
126 |                 visualSampleEntry.setHeight(height);
127 | 
128 |                 sampleDescriptionBox.addBox(visualSampleEntry);
129 |             }
130 |         } else {
131 |             sampleDurations.add((long)1024);
132 |             duration = 1024;
133 |             isAudio = true;
134 |             volume = 1;
135 |             timeScale = format.getInteger(MediaFormat.KEY_SAMPLE_RATE);
136 |             handler = "soun";
137 |             headerBox = new SoundMediaHeaderBox();
138 |             sampleDescriptionBox = new SampleDescriptionBox();
139 |             AudioSampleEntry audioSampleEntry = new AudioSampleEntry("mp4a");
140 |             audioSampleEntry.setChannelCount(format.getInteger(MediaFormat.KEY_CHANNEL_COUNT));
141 |             audioSampleEntry.setSampleRate(format.getInteger(MediaFormat.KEY_SAMPLE_RATE));
142 |             audioSampleEntry.setDataReferenceIndex(1);
143 |             audioSampleEntry.setSampleSize(16);
144 | 
145 |             ESDescriptorBox esds = new ESDescriptorBox();
146 |             ESDescriptor descriptor = new ESDescriptor();
147 |             descriptor.setEsId(0);
148 | 
149 |             SLConfigDescriptor slConfigDescriptor = new SLConfigDescriptor();
150 |             slConfigDescriptor.setPredefined(2);
151 |             descriptor.setSlConfigDescriptor(slConfigDescriptor);
152 | 
153 |             DecoderConfigDescriptor decoderConfigDescriptor = new DecoderConfigDescriptor();
154 |             decoderConfigDescriptor.setObjectTypeIndication(0x40);
155 |             decoderConfigDescriptor.setStreamType(5);
156 |             decoderConfigDescriptor.setBufferSizeDB(1536);
157 |             decoderConfigDescriptor.setMaxBitRate(96000);
158 |             decoderConfigDescriptor.setAvgBitRate(96000);
159 | 
160 |             AudioSpecificConfig audioSpecificConfig = new AudioSpecificConfig();
161 |             audioSpecificConfig.setAudioObjectType(2);
162 |             audioSpecificConfig.setSamplingFrequencyIndex(samplingFrequencyIndexMap.get((int)audioSampleEntry.getSampleRate()));
163 |             audioSpecificConfig.setChannelConfiguration(audioSampleEntry.getChannelCount());
164 |             decoderConfigDescriptor.setAudioSpecificInfo(audioSpecificConfig);
165 | 
166 |             descriptor.setDecoderConfigDescriptor(decoderConfigDescriptor);
167 | 
168 |             ByteBuffer data = descriptor.serialize();
169 |             esds.setEsDescriptor(descriptor);
170 |             esds.setData(data);
171 |             audioSampleEntry.addBox(esds);
172 |             sampleDescriptionBox.addBox(audioSampleEntry);
173 |         }
174 |     }
175 | 
176 |     public long getTrackId() {
177 |         return trackId;
178 |     }
179 | 
180 |     public void addSample(long offset, MediaCodec.BufferInfo bufferInfo) {
181 |         boolean isSyncFrame = !isAudio && (bufferInfo.flags & MediaCodec.BUFFER_FLAG_SYNC_FRAME) != 0;
182 |         samples.add(new Sample(offset, bufferInfo.size));
183 |         if (syncSamples != null && isSyncFrame) {
184 |             syncSamples.add(samples.size());
185 |         }
186 | 
187 |         long delta = bufferInfo.presentationTimeUs - lastPresentationTimeUs;
188 |         lastPresentationTimeUs = bufferInfo.presentationTimeUs;
189 |         delta = (delta * timeScale + 500000L) / 1000000L;
190 |         if (!first) {
191 |             sampleDurations.add(sampleDurations.size() - 1, delta);
192 |             duration += delta;
193 |         }
194 |         first = false;
195 |     }
196 | 
197 |     public ArrayList<Sample> getSamples() {
198 |         return samples;
199 |     }
200 | 
201 |     public long getDuration() {
202 |         return duration;
203 |     }
204 | 
205 |     public String getHandler() {
206 |         return handler;
207 |     }
208 | 
209 |     public AbstractMediaHeaderBox getMediaHeaderBox() {
210 |         return headerBox;
211 |     }
212 | 
213 |     public SampleDescriptionBox getSampleDescriptionBox() {
214 |         return sampleDescriptionBox;
215 |     }
216 | 
217 |     public long[] getSyncSamples() {
218 |         if (syncSamples == null || syncSamples.isEmpty()) {
219 |             return null;
220 |         }
221 |         long[] returns = new long[syncSamples.size()];
222 |         for (int i = 0; i < syncSamples.size(); i++) {
223 |             returns[i] = syncSamples.get(i);
224 |         }
225 |         return returns;
226 |     }
227 | 
228 |     public int getTimeScale() {
229 |         return timeScale;
230 |     }
231 | 
232 |     public Date getCreationTime() {
233 |         return creationTime;
234 |     }
235 | 
236 |     public int getWidth() {
237 |         return width;
238 |     }
239 | 
240 |     public int getHeight() {
241 |         return height;
242 |     }
243 | 
244 |     public float getVolume() {
245 |         return volume;
246 |     }
247 | 
248 |     public ArrayList<Long> getSampleDurations() {
249 |         return sampleDurations;
250 |     }
251 | 
252 |     public boolean isAudio() {
253 |         return isAudio;
254 |     }
255 | }
256 | 


--------------------------------------------------------------------------------
/videocompress/src/main/java/com/xiaoguang/widget/videocompress/core/MP4Builder.java:
--------------------------------------------------------------------------------
  1 | package com.xiaoguang.widget.videocompress.core;
  2 | 
  3 | import android.annotation.TargetApi;
  4 | import android.media.MediaCodec;
  5 | import android.media.MediaFormat;
  6 | 
  7 | import com.coremedia.iso.BoxParser;
  8 | import com.coremedia.iso.IsoFile;
  9 | import com.coremedia.iso.IsoTypeWriter;
 10 | import com.coremedia.iso.boxes.Box;
 11 | import com.coremedia.iso.boxes.Container;
 12 | import com.coremedia.iso.boxes.DataEntryUrlBox;
 13 | import com.coremedia.iso.boxes.DataInformationBox;
 14 | import com.coremedia.iso.boxes.DataReferenceBox;
 15 | import com.coremedia.iso.boxes.FileTypeBox;
 16 | import com.coremedia.iso.boxes.HandlerBox;
 17 | import com.coremedia.iso.boxes.MediaBox;
 18 | import com.coremedia.iso.boxes.MediaHeaderBox;
 19 | import com.coremedia.iso.boxes.MediaInformationBox;
 20 | import com.coremedia.iso.boxes.MovieBox;
 21 | import com.coremedia.iso.boxes.MovieHeaderBox;
 22 | import com.coremedia.iso.boxes.SampleSizeBox;
 23 | import com.coremedia.iso.boxes.SampleTableBox;
 24 | import com.coremedia.iso.boxes.SampleToChunkBox;
 25 | import com.coremedia.iso.boxes.StaticChunkOffsetBox;
 26 | import com.coremedia.iso.boxes.SyncSampleBox;
 27 | import com.coremedia.iso.boxes.TimeToSampleBox;
 28 | import com.coremedia.iso.boxes.TrackBox;
 29 | import com.coremedia.iso.boxes.TrackHeaderBox;
 30 | import com.googlecode.mp4parser.DataSource;
 31 | import com.googlecode.mp4parser.util.Matrix;
 32 | 
 33 | import java.io.FileOutputStream;
 34 | import java.io.IOException;
 35 | import java.nio.ByteBuffer;
 36 | import java.nio.channels.FileChannel;
 37 | import java.nio.channels.WritableByteChannel;
 38 | import java.util.ArrayList;
 39 | import java.util.Date;
 40 | import java.util.HashMap;
 41 | import java.util.LinkedList;
 42 | import java.util.List;
 43 | 
 44 | @TargetApi(16)
 45 | public class MP4Builder {
 46 |     private InterleaveChunkMdat mdat = null;
 47 |     private Mp4Movie currentMp4Movie = null;
 48 |     private FileOutputStream fos = null;
 49 |     private FileChannel fc = null;
 50 |     private long dataOffset = 0;
 51 |     private long writedSinceLastMdat = 0;
 52 |     private boolean writeNewMdat = true;
 53 |     private HashMap<Track, long[]> track2SampleSizes = new HashMap<>();
 54 |     private ByteBuffer sizeBuffer = null;
 55 | 
 56 |     public MP4Builder createMovie(Mp4Movie mp4Movie) throws Exception {
 57 |         currentMp4Movie = mp4Movie;
 58 | 
 59 |         fos = new FileOutputStream(mp4Movie.getCacheFile());
 60 |         fc = fos.getChannel();
 61 | 
 62 |         FileTypeBox fileTypeBox = createFileTypeBox();
 63 |         fileTypeBox.getBox(fc);
 64 |         dataOffset += fileTypeBox.getSize();
 65 |         writedSinceLastMdat += dataOffset;
 66 | 
 67 |         mdat = new InterleaveChunkMdat();
 68 | 
 69 |         sizeBuffer = ByteBuffer.allocateDirect(4);
 70 | 
 71 |         return this;
 72 |     }
 73 | 
 74 |     private void flushCurrentMdat() throws Exception {
 75 |         long oldPosition = fc.position();
 76 |         fc.position(mdat.getOffset());
 77 |         mdat.getBox(fc);
 78 |         fc.position(oldPosition);
 79 |         mdat.setDataOffset(0);
 80 |         mdat.setContentSize(0);
 81 |         fos.flush();
 82 |     }
 83 | 
 84 |     public boolean writeSampleData(int trackIndex, ByteBuffer byteBuf, MediaCodec.BufferInfo bufferInfo, boolean isAudio) throws Exception {
 85 |         if (writeNewMdat) {
 86 |             mdat.setContentSize(0);
 87 |             mdat.getBox(fc);
 88 |             mdat.setDataOffset(dataOffset);
 89 |             dataOffset += 16;
 90 |             writedSinceLastMdat += 16;
 91 |             writeNewMdat = false;
 92 |         }
 93 | 
 94 |         mdat.setContentSize(mdat.getContentSize() + bufferInfo.size);
 95 |         writedSinceLastMdat += bufferInfo.size;
 96 | 
 97 |         boolean flush = false;
 98 |         if (writedSinceLastMdat >= 32 * 1024) {
 99 |             flushCurrentMdat();
100 |             writeNewMdat = true;
101 |             flush = true;
102 |             writedSinceLastMdat -= 32 * 1024;
103 |         }
104 | 
105 |         currentMp4Movie.addSample(trackIndex, dataOffset, bufferInfo);
106 |         byteBuf.position(bufferInfo.offset + (isAudio ? 0 : 4));
107 |         byteBuf.limit(bufferInfo.offset + bufferInfo.size);
108 | 
109 |         if (!isAudio) {
110 |             sizeBuffer.position(0);
111 |             sizeBuffer.putInt(bufferInfo.size - 4);
112 |             sizeBuffer.position(0);
113 |             fc.write(sizeBuffer);
114 |         }
115 | 
116 |         fc.write(byteBuf);
117 |         dataOffset += bufferInfo.size;
118 | 
119 |         if (flush) {
120 |             fos.flush();
121 |         }
122 |         return flush;
123 |     }
124 | 
125 |     public int addTrack(MediaFormat mediaFormat, boolean isAudio) throws Exception {
126 |         return currentMp4Movie.addTrack(mediaFormat, isAudio);
127 |     }
128 | 
129 |     public void finishMovie(boolean error) throws Exception {
130 |         if (mdat.getContentSize() != 0) {
131 |             flushCurrentMdat();
132 |         }
133 | 
134 |         for (Track track : currentMp4Movie.getTracks()) {
135 |             List<Sample> samples = track.getSamples();
136 |             long[] sizes = new long[samples.size()];
137 |             for (int i = 0; i < sizes.length; i++) {
138 |                 sizes[i] = samples.get(i).getSize();
139 |             }
140 |             track2SampleSizes.put(track, sizes);
141 |         }
142 | 
143 |         Box moov = createMovieBox(currentMp4Movie);
144 |         moov.getBox(fc);
145 |         fos.flush();
146 | 
147 |         fc.close();
148 |         fos.close();
149 |     }
150 | 
151 |     protected FileTypeBox createFileTypeBox() {
152 |         LinkedList<String> minorBrands = new LinkedList<>();
153 |         minorBrands.add("isom");
154 |         minorBrands.add("3gp4");
155 |         return new FileTypeBox("isom", 0, minorBrands);
156 |     }
157 | 
158 |     private class InterleaveChunkMdat implements Box {
159 |         private Container parent;
160 |         private long contentSize = 1024 * 1024 * 1024;
161 |         private long dataOffset = 0;
162 | 
163 |         public Container getParent() {
164 |             return parent;
165 |         }
166 | 
167 |         public long getOffset() {
168 |             return dataOffset;
169 |         }
170 | 
171 |         public void setDataOffset(long offset) {
172 |             dataOffset = offset;
173 |         }
174 | 
175 |         public void setParent(Container parent) {
176 |             this.parent = parent;
177 |         }
178 | 
179 |         public void setContentSize(long contentSize) {
180 |             this.contentSize = contentSize;
181 |         }
182 | 
183 |         public long getContentSize() {
184 |             return contentSize;
185 |         }
186 | 
187 |         public String getType() {
188 |             return "mdat";
189 |         }
190 | 
191 |         public long getSize() {
192 |             return 16 + contentSize;
193 |         }
194 | 
195 |         private boolean isSmallBox(long contentSize) {
196 |             return (contentSize + 8) < 4294967296L;
197 |         }
198 | 
199 |         @Override
200 |         public void parse(DataSource dataSource, ByteBuffer header, long contentSize, BoxParser boxParser) throws IOException {
201 | 
202 |         }
203 | 
204 |         public void getBox(WritableByteChannel writableByteChannel) throws IOException {
205 |             ByteBuffer bb = ByteBuffer.allocate(16);
206 |             long size = getSize();
207 |             if (isSmallBox(size)) {
208 |                 IsoTypeWriter.writeUInt32(bb, size);
209 |             } else {
210 |                 IsoTypeWriter.writeUInt32(bb, 1);
211 |             }
212 |             bb.put(IsoFile.fourCCtoBytes("mdat"));
213 |             if (isSmallBox(size)) {
214 |                 bb.put(new byte[8]);
215 |             } else {
216 |                 IsoTypeWriter.writeUInt64(bb, size);
217 |             }
218 |             bb.rewind();
219 |             writableByteChannel.write(bb);
220 |         }
221 |     }
222 | 
223 |     public static long gcd(long a, long b) {
224 |         if (b == 0) {
225 |             return a;
226 |         }
227 |         return gcd(b, a % b);
228 |     }
229 | 
230 |     public long getTimescale(Mp4Movie mp4Movie) {
231 |         long timescale = 0;
232 |         if (!mp4Movie.getTracks().isEmpty()) {
233 |             timescale = mp4Movie.getTracks().iterator().next().getTimeScale();
234 |         }
235 |         for (Track track : mp4Movie.getTracks()) {
236 |             timescale = gcd(track.getTimeScale(), timescale);
237 |         }
238 |         return timescale;
239 |     }
240 | 
241 |     protected MovieBox createMovieBox(Mp4Movie movie) {
242 |         MovieBox movieBox = new MovieBox();
243 |         MovieHeaderBox mvhd = new MovieHeaderBox();
244 | 
245 |         mvhd.setCreationTime(new Date());
246 |         mvhd.setModificationTime(new Date());
247 |         mvhd.setMatrix(Matrix.ROTATE_0);
248 |         long movieTimeScale = getTimescale(movie);
249 |         long duration = 0;
250 | 
251 |         for (Track track : movie.getTracks()) {
252 |             long tracksDuration = track.getDuration() * movieTimeScale / track.getTimeScale();
253 |             if (tracksDuration > duration) {
254 |                 duration = tracksDuration;
255 |             }
256 |         }
257 | 
258 |         mvhd.setDuration(duration);
259 |         mvhd.setTimescale(movieTimeScale);
260 |         mvhd.setNextTrackId(movie.getTracks().size() + 1);
261 | 
262 |         movieBox.addBox(mvhd);
263 |         for (Track track : movie.getTracks()) {
264 |             movieBox.addBox(createTrackBox(track, movie));
265 |         }
266 |         return movieBox;
267 |     }
268 | 
269 |     protected TrackBox createTrackBox(Track track, Mp4Movie movie) {
270 |         TrackBox trackBox = new TrackBox();
271 |         TrackHeaderBox tkhd = new TrackHeaderBox();
272 | 
273 |         tkhd.setEnabled(true);
274 |         tkhd.setInMovie(true);
275 |         tkhd.setInPreview(true);
276 |         if (track.isAudio()) {
277 |             tkhd.setMatrix(Matrix.ROTATE_0);
278 |         } else {
279 |             tkhd.setMatrix(movie.getMatrix());
280 |         }
281 |         tkhd.setAlternateGroup(0);
282 |         tkhd.setCreationTime(track.getCreationTime());
283 |         tkhd.setDuration(track.getDuration() * getTimescale(movie) / track.getTimeScale());
284 |         tkhd.setHeight(track.getHeight());
285 |         tkhd.setWidth(track.getWidth());
286 |         tkhd.setLayer(0);
287 |         tkhd.setModificationTime(new Date());
288 |         tkhd.setTrackId(track.getTrackId() + 1);
289 |         tkhd.setVolume(track.getVolume());
290 | 
291 |         trackBox.addBox(tkhd);
292 | 
293 |         MediaBox mdia = new MediaBox();
294 |         trackBox.addBox(mdia);
295 |         MediaHeaderBox mdhd = new MediaHeaderBox();
296 |         mdhd.setCreationTime(track.getCreationTime());
297 |         mdhd.setDuration(track.getDuration());
298 |         mdhd.setTimescale(track.getTimeScale());
299 |         mdhd.setLanguage("eng");
300 |         mdia.addBox(mdhd);
301 |         HandlerBox hdlr = new HandlerBox();
302 |         hdlr.setName(track.isAudio() ? "SoundHandle" : "VideoHandle");
303 |         hdlr.setHandlerType(track.getHandler());
304 | 
305 |         mdia.addBox(hdlr);
306 | 
307 |         MediaInformationBox minf = new MediaInformationBox();
308 |         minf.addBox(track.getMediaHeaderBox());
309 | 
310 |         DataInformationBox dinf = new DataInformationBox();
311 |         DataReferenceBox dref = new DataReferenceBox();
312 |         dinf.addBox(dref);
313 |         DataEntryUrlBox url = new DataEntryUrlBox();
314 |         url.setFlags(1);
315 |         dref.addBox(url);
316 |         minf.addBox(dinf);
317 | 
318 |         Box stbl = createStbl(track);
319 |         minf.addBox(stbl);
320 |         mdia.addBox(minf);
321 | 
322 |         return trackBox;
323 |     }
324 | 
325 |     protected Box createStbl(Track track) {
326 |         SampleTableBox stbl = new SampleTableBox();
327 | 
328 |         createStsd(track, stbl);
329 |         createStts(track, stbl);
330 |         createStss(track, stbl);
331 |         createStsc(track, stbl);
332 |         createStsz(track, stbl);
333 |         createStco(track, stbl);
334 | 
335 |         return stbl;
336 |     }
337 | 
338 |     protected void createStsd(Track track, SampleTableBox stbl) {
339 |         stbl.addBox(track.getSampleDescriptionBox());
340 |     }
341 | 
342 |     protected void createStts(Track track, SampleTableBox stbl) {
343 |         TimeToSampleBox.Entry lastEntry = null;
344 |         List<TimeToSampleBox.Entry> entries = new ArrayList<>();
345 | 
346 |         for (long delta : track.getSampleDurations()) {
347 |             if (lastEntry != null && lastEntry.getDelta() == delta) {
348 |                 lastEntry.setCount(lastEntry.getCount() + 1);
349 |             } else {
350 |                 lastEntry = new TimeToSampleBox.Entry(1, delta);
351 |                 entries.add(lastEntry);
352 |             }
353 |         }
354 |         TimeToSampleBox stts = new TimeToSampleBox();
355 |         stts.setEntries(entries);
356 |         stbl.addBox(stts);
357 |     }
358 | 
359 |     protected void createStss(Track track, SampleTableBox stbl) {
360 |         long[] syncSamples = track.getSyncSamples();
361 |         if (syncSamples != null && syncSamples.length > 0) {
362 |             SyncSampleBox stss = new SyncSampleBox();
363 |             stss.setSampleNumber(syncSamples);
364 |             stbl.addBox(stss);
365 |         }
366 |     }
367 | 
368 |     protected void createStsc(Track track, SampleTableBox stbl) {
369 |         SampleToChunkBox stsc = new SampleToChunkBox();
370 |         stsc.setEntries(new LinkedList<SampleToChunkBox.Entry>());
371 | 
372 |         long lastOffset = -1;
373 |         int lastChunkNumber = 1;
374 |         int lastSampleCount = 0;
375 | 
376 |         int previousWritedChunkCount = -1;
377 | 
378 |         int samplesCount = track.getSamples().size();
379 |         for (int a = 0; a < samplesCount; a++) {
380 |             Sample sample = track.getSamples().get(a);
381 |             long offset = sample.getOffset();
382 |             long size = sample.getSize();
383 | 
384 |             lastOffset = offset + size;
385 |             lastSampleCount++;
386 | 
387 |             boolean write = false;
388 |             if (a != samplesCount - 1) {
389 |                 Sample nextSample = track.getSamples().get(a + 1);
390 |                 if (lastOffset != nextSample.getOffset()) {
391 |                     write = true;
392 |                 }
393 |             } else {
394 |                 write = true;
395 |             }
396 |             if (write) {
397 |                 if (previousWritedChunkCount != lastSampleCount) {
398 |                     stsc.getEntries().add(new SampleToChunkBox.Entry(lastChunkNumber, lastSampleCount, 1));
399 |                     previousWritedChunkCount = lastSampleCount;
400 |                 }
401 |                 lastSampleCount = 0;
402 |                 lastChunkNumber++;
403 |             }
404 |         }
405 |         stbl.addBox(stsc);
406 |     }
407 | 
408 |     protected void createStsz(Track track, SampleTableBox stbl) {
409 |         SampleSizeBox stsz = new SampleSizeBox();
410 |         stsz.setSampleSizes(track2SampleSizes.get(track));
411 |         stbl.addBox(stsz);
412 |     }
413 | 
414 |     protected void createStco(Track track, SampleTableBox stbl) {
415 |         ArrayList<Long> chunksOffsets = new ArrayList<>();
416 |         long lastOffset = -1;
417 |         for (Sample sample : track.getSamples()) {
418 |             long offset = sample.getOffset();
419 |             if (lastOffset != -1 && lastOffset != offset) {
420 |                 lastOffset = -1;
421 |             }
422 |             if (lastOffset == -1) {
423 |                 chunksOffsets.add(offset);
424 |             }
425 |             lastOffset = offset + sample.getSize();
426 |         }
427 |         long[] chunkOffsetsLong = new long[chunksOffsets.size()];
428 |         for (int a = 0; a < chunksOffsets.size(); a++) {
429 |             chunkOffsetsLong[a] = chunksOffsets.get(a);
430 |         }
431 | 
432 |         StaticChunkOffsetBox stco = new StaticChunkOffsetBox();
433 |         stco.setChunkOffsets(chunkOffsetsLong);
434 |         stbl.addBox(stco);
435 |     }
436 | }
437 | 


--------------------------------------------------------------------------------
/videocompress/src/main/java/com/xiaoguang/widget/videocompress/core/VideoController.java:
--------------------------------------------------------------------------------
  1 | package com.xiaoguang.widget.videocompress.core;
  2 | 
  3 | import android.annotation.SuppressLint;
  4 | import android.annotation.TargetApi;
  5 | import android.media.MediaCodec;
  6 | import android.media.MediaCodecInfo;
  7 | import android.media.MediaCodecList;
  8 | import android.media.MediaExtractor;
  9 | import android.media.MediaFormat;
 10 | import android.media.MediaMetadataRetriever;
 11 | import android.os.Build;
 12 | import android.util.Log;
 13 | 
 14 | import java.io.File;
 15 | import java.io.FileInputStream;
 16 | import java.io.FileOutputStream;
 17 | import java.io.IOException;
 18 | import java.nio.ByteBuffer;
 19 | import java.nio.channels.FileChannel;
 20 | 
 21 | @SuppressLint("NewApi")
 22 | public class VideoController {
 23 |     static final int COMPRESS_QUALITY_HIGH = 1;
 24 |     static final int COMPRESS_QUALITY_MEDIUM = 2;
 25 |     static final int COMPRESS_QUALITY_LOW = 3;
 26 | 
 27 |     public static File cachedFile;
 28 |     public String path;
 29 | 
 30 |     public final static String MIME_TYPE = "video/avc";
 31 |     private final static int PROCESSOR_TYPE_OTHER = 0;
 32 |     private final static int PROCESSOR_TYPE_QCOM = 1;
 33 |     private final static int PROCESSOR_TYPE_INTEL = 2;
 34 |     private final static int PROCESSOR_TYPE_MTK = 3;
 35 |     private final static int PROCESSOR_TYPE_SEC = 4;
 36 |     private final static int PROCESSOR_TYPE_TI = 5;
 37 |     private static volatile VideoController Instance = null;
 38 |     private boolean videoConvertFirstWrite = true;
 39 | 
 40 |     interface CompressProgressListener {
 41 |         void onProgress(float percent);
 42 |     }
 43 | 
 44 |     public static VideoController getInstance() {
 45 |         VideoController localInstance = Instance;
 46 |         if (localInstance == null) {
 47 |             synchronized (VideoController.class) {
 48 |                 localInstance = Instance;
 49 |                 if (localInstance == null) {
 50 |                     Instance = localInstance = new VideoController();
 51 |                 }
 52 |             }
 53 |         }
 54 |         return localInstance;
 55 |     }
 56 | 
 57 |     @SuppressLint("NewApi")
 58 |     public static int selectColorFormat(MediaCodecInfo codecInfo, String mimeType) {
 59 |         MediaCodecInfo.CodecCapabilities capabilities = codecInfo.getCapabilitiesForType(mimeType);
 60 |         int lastColorFormat = 0;
 61 |         for (int i = 0; i < capabilities.colorFormats.length; i++) {
 62 |             int colorFormat = capabilities.colorFormats[i];
 63 |             if (isRecognizedFormat(colorFormat)) {
 64 |                 lastColorFormat = colorFormat;
 65 |                 if (!(codecInfo.getName().equals("OMX.SEC.AVC.Encoder") && colorFormat == 19)) {
 66 |                     return colorFormat;
 67 |                 }
 68 |             }
 69 |         }
 70 |         return lastColorFormat;
 71 |     }
 72 | 
 73 |     private static boolean isRecognizedFormat(int colorFormat) {
 74 |         switch (colorFormat) {
 75 |             case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar:
 76 |             case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedPlanar:
 77 |             case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar:
 78 |             case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedSemiPlanar:
 79 |             case MediaCodecInfo.CodecCapabilities.COLOR_TI_FormatYUV420PackedSemiPlanar:
 80 |                 return true;
 81 |             default:
 82 |                 return false;
 83 |         }
 84 |     }
 85 | 
 86 |     public native static int convertVideoFrame(ByteBuffer src, ByteBuffer dest, int destFormat, int width, int height, int padding, int swap);
 87 | 
 88 |     private void didWriteData(final boolean last, final boolean error) {
 89 |         final boolean firstWrite = videoConvertFirstWrite;
 90 |         if (firstWrite) {
 91 |             videoConvertFirstWrite = false;
 92 |         }
 93 |     }
 94 | 
 95 |     public static class VideoConvertRunnable implements Runnable {
 96 | 
 97 |         private String videoPath;
 98 |         private String destPath;
 99 | 
100 |         private VideoConvertRunnable(String videoPath, String destPath) {
101 |             this.videoPath = videoPath;
102 |             this.destPath = destPath;
103 |         }
104 | 
105 |         public static void runConversion(final String videoPath, final String destPath) {
106 |             new Thread(new Runnable() {
107 |                 @Override
108 |                 public void run() {
109 |                     try {
110 |                         VideoConvertRunnable wrapper = new VideoConvertRunnable(videoPath, destPath);
111 |                         Thread th = new Thread(wrapper, "VideoConvertRunnable");
112 |                         th.start();
113 |                         th.join();
114 |                     } catch (Exception e) {
115 |                         Log.e("tmessages", e.getMessage());
116 |                     }
117 |                 }
118 |             }).start();
119 |         }
120 | 
121 |         @Override
122 |         public void run() {
123 |             VideoController.getInstance().convertVideo(videoPath, destPath, 0, null);
124 |         }
125 |     }
126 | 
127 |     public static MediaCodecInfo selectCodec(String mimeType) {
128 |         int numCodecs = MediaCodecList.getCodecCount();
129 |         MediaCodecInfo lastCodecInfo = null;
130 |         for (int i = 0; i < numCodecs; i++) {
131 |             MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);
132 |             if (!codecInfo.isEncoder()) {
133 |                 continue;
134 |             }
135 |             String[] types = codecInfo.getSupportedTypes();
136 |             for (String type : types) {
137 |                 if (type.equalsIgnoreCase(mimeType)) {
138 |                     lastCodecInfo = codecInfo;
139 |                     if (!lastCodecInfo.getName().equals("OMX.SEC.avc.enc")) {
140 |                         return lastCodecInfo;
141 |                     } else if (lastCodecInfo.getName().equals("OMX.SEC.AVC.Encoder")) {
142 |                         return lastCodecInfo;
143 |                     }
144 |                 }
145 |             }
146 |         }
147 |         return lastCodecInfo;
148 |     }
149 | 
150 |     /**
151 |      * Background conversion for queueing tasks
152 |      *
153 |      * @param path source file to compress
154 |      * @param dest destination directory to put result
155 |      */
156 | 
157 |     public void scheduleVideoConvert(String path, String dest) {
158 |         startVideoConvertFromQueue(path, dest);
159 |     }
160 | 
161 |     private void startVideoConvertFromQueue(String path, String dest) {
162 |         VideoConvertRunnable.runConversion(path, dest);
163 |     }
164 | 
165 |     @TargetApi(16)
166 |     private long readAndWriteTrack(MediaExtractor extractor, MP4Builder mediaMuxer, MediaCodec.BufferInfo info, long start, long end, File file, boolean isAudio) throws Exception {
167 |         int trackIndex = selectTrack(extractor, isAudio);
168 |         if (trackIndex >= 0) {
169 |             extractor.selectTrack(trackIndex);
170 |             MediaFormat trackFormat = extractor.getTrackFormat(trackIndex);
171 |             int muxerTrackIndex = mediaMuxer.addTrack(trackFormat, isAudio);
172 |             int maxBufferSize = trackFormat.getInteger(MediaFormat.KEY_MAX_INPUT_SIZE);
173 |             boolean inputDone = false;
174 |             if (start > 0) {
175 |                 extractor.seekTo(start, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
176 |             } else {
177 |                 extractor.seekTo(0, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
178 |             }
179 |             ByteBuffer buffer = ByteBuffer.allocateDirect(maxBufferSize);
180 |             long startTime = -1;
181 | 
182 |             while (!inputDone) {
183 | 
184 |                 boolean eof = false;
185 |                 int index = extractor.getSampleTrackIndex();
186 |                 if (index == trackIndex) {
187 |                     info.size = extractor.readSampleData(buffer, 0);
188 | 
189 |                     if (info.size < 0) {
190 |                         info.size = 0;
191 |                         eof = true;
192 |                     } else {
193 |                         info.presentationTimeUs = extractor.getSampleTime();
194 |                         if (start > 0 && startTime == -1) {
195 |                             startTime = info.presentationTimeUs;
196 |                         }
197 |                         if (end < 0 || info.presentationTimeUs < end) {
198 |                             info.offset = 0;
199 |                             info.flags = extractor.getSampleFlags();
200 |                             if (mediaMuxer.writeSampleData(muxerTrackIndex, buffer, info, isAudio)) {
201 |                                 // didWriteData(messageObject, file, false, false);
202 |                             }
203 |                             extractor.advance();
204 |                         } else {
205 |                             eof = true;
206 |                         }
207 |                     }
208 |                 } else if (index == -1) {
209 |                     eof = true;
210 |                 }
211 |                 if (eof) {
212 |                     inputDone = true;
213 |                 }
214 |             }
215 | 
216 |             extractor.unselectTrack(trackIndex);
217 |             return startTime;
218 |         }
219 |         return -1;
220 |     }
221 | 
222 |     @TargetApi(16)
223 |     private int selectTrack(MediaExtractor extractor, boolean audio) {
224 |         int numTracks = extractor.getTrackCount();
225 |         for (int i = 0; i < numTracks; i++) {
226 |             MediaFormat format = extractor.getTrackFormat(i);
227 |             String mime = format.getString(MediaFormat.KEY_MIME);
228 |             if (audio) {
229 |                 if (mime.startsWith("audio/")) {
230 |                     return i;
231 |                 }
232 |             } else {
233 |                 if (mime.startsWith("video/")) {
234 |                     return i;
235 |                 }
236 |             }
237 |         }
238 |         return -5;
239 |     }
240 | 
241 |     /**
242 |      * Perform the actual video compression. Processes the frames and does the magic
243 |      *
244 |      * @param sourcePath      the source uri for the file as per
245 |      * @param destinationPath the destination directory where compressed video is eventually saved
246 |      * @return
247 |      */
248 |     @TargetApi(16)
249 |     public boolean convertVideo(final String sourcePath, String destinationPath, int quality, CompressProgressListener listener) {
250 |         this.path = sourcePath;
251 | 
252 |         MediaMetadataRetriever retriever = new MediaMetadataRetriever();
253 |         retriever.setDataSource(path);
254 |         String width = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH);
255 |         String height = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT);
256 |         String rotation = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION);
257 |         long duration = Long.valueOf(retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)) * 1000;
258 | 
259 |         long startTime = -1;
260 |         long endTime = -1;
261 | 
262 |         int rotationValue = Integer.valueOf(rotation);
263 |         int originalWidth = Integer.valueOf(width);
264 |         int originalHeight = Integer.valueOf(height);
265 | 
266 |         int resultWidth;
267 |         int resultHeight;
268 |         int bitrate;
269 |         switch (quality) {
270 |             default:
271 |             case COMPRESS_QUALITY_HIGH:
272 |                 resultWidth = originalWidth * 2 / 3;
273 |                 resultHeight = originalHeight * 2 / 3;
274 |                 bitrate = resultWidth * resultHeight * 30;
275 |                 break;
276 |             case COMPRESS_QUALITY_MEDIUM:
277 |                 resultWidth = originalWidth / 2;
278 |                 resultHeight = originalHeight / 2;
279 |                 bitrate = resultWidth * resultHeight * 10;
280 |                 break;
281 |             case COMPRESS_QUALITY_LOW:
282 |                 resultWidth = originalWidth / 2;
283 |                 resultHeight = originalHeight / 2;
284 |                 bitrate = (resultWidth / 2) * (resultHeight / 2) * 10;
285 |                 break;
286 |         }
287 | 
288 |         int rotateRender = 0;
289 | 
290 |         File cacheFile = new File(destinationPath);
291 | 
292 |         if (Build.VERSION.SDK_INT < 18 && resultHeight > resultWidth && resultWidth != originalWidth && resultHeight != originalHeight) {
293 |             int temp = resultHeight;
294 |             resultHeight = resultWidth;
295 |             resultWidth = temp;
296 |             rotationValue = 90;
297 |             rotateRender = 270;
298 |         } else if (Build.VERSION.SDK_INT > 20) {
299 |             if (rotationValue == 90) {
300 |                 int temp = resultHeight;
301 |                 resultHeight = resultWidth;
302 |                 resultWidth = temp;
303 |                 rotationValue = 0;
304 |                 rotateRender = 270;
305 |             } else if (rotationValue == 180) {
306 |                 rotateRender = 180;
307 |                 rotationValue = 0;
308 |             } else if (rotationValue == 270) {
309 |                 int temp = resultHeight;
310 |                 resultHeight = resultWidth;
311 |                 resultWidth = temp;
312 |                 rotationValue = 0;
313 |                 rotateRender = 90;
314 |             }
315 |         }
316 | 
317 | 
318 |         File inputFile = new File(path);
319 |         if (!inputFile.canRead()) {
320 |             didWriteData(true, true);
321 |             return false;
322 |         }
323 | 
324 |         videoConvertFirstWrite = true;
325 |         boolean error = false;
326 |         long videoStartTime = startTime;
327 | 
328 |         long time = System.currentTimeMillis();
329 | 
330 |         if (resultWidth != 0 && resultHeight != 0) {
331 |             MP4Builder mediaMuxer = null;
332 |             MediaExtractor extractor = null;
333 | 
334 |             try {
335 |                 MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
336 |                 Mp4Movie movie = new Mp4Movie();
337 |                 movie.setCacheFile(cacheFile);
338 |                 movie.setRotation(rotationValue);
339 |                 movie.setSize(resultWidth, resultHeight);
340 |                 mediaMuxer = new MP4Builder().createMovie(movie);
341 |                 extractor = new MediaExtractor();
342 |                 extractor.setDataSource(inputFile.toString());
343 | 
344 | 
345 |                 if (resultWidth != originalWidth || resultHeight != originalHeight) {
346 |                     int videoIndex;
347 |                     videoIndex = selectTrack(extractor, false);
348 | 
349 |                     if (videoIndex >= 0) {
350 |                         MediaCodec decoder = null;
351 |                         MediaCodec encoder = null;
352 |                         InputSurface inputSurface = null;
353 |                         OutputSurface outputSurface = null;
354 | 
355 |                         try {
356 |                             long videoTime = -1;
357 |                             boolean outputDone = false;
358 |                             boolean inputDone = false;
359 |                             boolean decoderDone = false;
360 |                             int swapUV = 0;
361 |                             int videoTrackIndex = -5;
362 | 
363 |                             int colorFormat;
364 |                             int processorType = PROCESSOR_TYPE_OTHER;
365 |                             String manufacturer = Build.MANUFACTURER.toLowerCase();
366 |                             if (Build.VERSION.SDK_INT < 18) {
367 |                                 MediaCodecInfo codecInfo = selectCodec(MIME_TYPE);
368 |                                 colorFormat = selectColorFormat(codecInfo, MIME_TYPE);
369 |                                 if (colorFormat == 0) {
370 |                                     throw new RuntimeException("no supported color format");
371 |                                 }
372 |                                 String codecName = codecInfo.getName();
373 |                                 if (codecName.contains("OMX.qcom.")) {
374 |                                     processorType = PROCESSOR_TYPE_QCOM;
375 |                                     if (Build.VERSION.SDK_INT == 16) {
376 |                                         if (manufacturer.equals("lge") || manufacturer.equals("nokia")) {
377 |                                             swapUV = 1;
378 |                                         }
379 |                                     }
380 |                                 } else if (codecName.contains("OMX.Intel.")) {
381 |                                     processorType = PROCESSOR_TYPE_INTEL;
382 |                                 } else if (codecName.equals("OMX.MTK.VIDEO.ENCODER.AVC")) {
383 |                                     processorType = PROCESSOR_TYPE_MTK;
384 |                                 } else if (codecName.equals("OMX.SEC.AVC.Encoder")) {
385 |                                     processorType = PROCESSOR_TYPE_SEC;
386 |                                     swapUV = 1;
387 |                                 } else if (codecName.equals("OMX.TI.DUCATI1.VIDEO.H264E")) {
388 |                                     processorType = PROCESSOR_TYPE_TI;
389 |                                 }
390 |                                 Log.e("tmessages", "codec = " + codecInfo.getName() + " manufacturer = " + manufacturer + "device = " + Build.MODEL);
391 |                             } else {
392 |                                 colorFormat = MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface;
393 |                             }
394 |                             Log.e("tmessages", "colorFormat = " + colorFormat);
395 | 
396 |                             int resultHeightAligned = resultHeight;
397 |                             int padding = 0;
398 |                             int bufferSize = resultWidth * resultHeight * 3 / 2;
399 |                             if (processorType == PROCESSOR_TYPE_OTHER) {
400 |                                 if (resultHeight % 16 != 0) {
401 |                                     resultHeightAligned += (16 - (resultHeight % 16));
402 |                                     padding = resultWidth * (resultHeightAligned - resultHeight);
403 |                                     bufferSize += padding * 5 / 4;
404 |                                 }
405 |                             } else if (processorType == PROCESSOR_TYPE_QCOM) {
406 |                                 if (!manufacturer.toLowerCase().equals("lge")) {
407 |                                     int uvoffset = (resultWidth * resultHeight + 2047) & ~2047;
408 |                                     padding = uvoffset - (resultWidth * resultHeight);
409 |                                     bufferSize += padding;
410 |                                 }
411 |                             } else if (processorType == PROCESSOR_TYPE_TI) {
412 |                                 //resultHeightAligned = 368;
413 |                                 //bufferSize = resultWidth * resultHeightAligned * 3 / 2;
414 |                                 //resultHeightAligned += (16 - (resultHeight % 16));
415 |                                 //padding = resultWidth * (resultHeightAligned - resultHeight);
416 |                                 //bufferSize += padding * 5 / 4;
417 |                             } else if (processorType == PROCESSOR_TYPE_MTK) {
418 |                                 if (manufacturer.equals("baidu")) {
419 |                                     resultHeightAligned += (16 - (resultHeight % 16));
420 |                                     padding = resultWidth * (resultHeightAligned - resultHeight);
421 |                                     bufferSize += padding * 5 / 4;
422 |                                 }
423 |                             }
424 | 
425 |                             extractor.selectTrack(videoIndex);
426 |                             if (startTime > 0) {
427 |                                 extractor.seekTo(startTime, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
428 |                             } else {
429 |                                 extractor.seekTo(0, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
430 |                             }
431 |                             MediaFormat inputFormat = extractor.getTrackFormat(videoIndex);
432 | 
433 |                             MediaFormat outputFormat = MediaFormat.createVideoFormat(MIME_TYPE, resultWidth, resultHeight);
434 |                             outputFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, colorFormat);
435 |                             outputFormat.setInteger(MediaFormat.KEY_BIT_RATE, bitrate);
436 |                             outputFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 25);
437 |                             outputFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 10);
438 |                             if (Build.VERSION.SDK_INT < 18) {
439 |                                 outputFormat.setInteger("stride", resultWidth + 32);
440 |                                 outputFormat.setInteger("slice-height", resultHeight);
441 |                             }
442 | 
443 |                             encoder = MediaCodec.createEncoderByType(MIME_TYPE);
444 |                             encoder.configure(outputFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
445 |                             if (Build.VERSION.SDK_INT >= 18) {
446 |                                 inputSurface = new InputSurface(encoder.createInputSurface());
447 |                                 inputSurface.makeCurrent();
448 |                             }
449 |                             encoder.start();
450 | 
451 |                             decoder = MediaCodec.createDecoderByType(inputFormat.getString(MediaFormat.KEY_MIME));
452 |                             if (Build.VERSION.SDK_INT >= 18) {
453 |                                 outputSurface = new OutputSurface();
454 |                             } else {
455 |                                 outputSurface = new OutputSurface(resultWidth, resultHeight, rotateRender);
456 |                             }
457 |                             decoder.configure(inputFormat, outputSurface.getSurface(), null, 0);
458 |                             decoder.start();
459 | 
460 |                             final int TIMEOUT_USEC = 2500;
461 |                             ByteBuffer[] decoderInputBuffers = null;
462 |                             ByteBuffer[] encoderOutputBuffers = null;
463 |                             ByteBuffer[] encoderInputBuffers = null;
464 |                             if (Build.VERSION.SDK_INT < 21) {
465 |                                 decoderInputBuffers = decoder.getInputBuffers();
466 |                                 encoderOutputBuffers = encoder.getOutputBuffers();
467 |                                 if (Build.VERSION.SDK_INT < 18) {
468 |                                     encoderInputBuffers = encoder.getInputBuffers();
469 |                                 }
470 |                             }
471 | 
472 |                             while (!outputDone) {
473 |                                 if (!inputDone) {
474 |                                     boolean eof = false;
475 |                                     int index = extractor.getSampleTrackIndex();
476 |                                     if (index == videoIndex) {
477 |                                         int inputBufIndex = decoder.dequeueInputBuffer(TIMEOUT_USEC);
478 |                                         if (inputBufIndex >= 0) {
479 |                                             ByteBuffer inputBuf;
480 |                                             if (Build.VERSION.SDK_INT < 21) {
481 |                                                 inputBuf = decoderInputBuffers[inputBufIndex];
482 |                                             } else {
483 |                                                 inputBuf = decoder.getInputBuffer(inputBufIndex);
484 |                                             }
485 |                                             int chunkSize = extractor.readSampleData(inputBuf, 0);
486 |                                             if (chunkSize < 0) {
487 |                                                 decoder.queueInputBuffer(inputBufIndex, 0, 0, 0L, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
488 |                                                 inputDone = true;
489 |                                             } else {
490 |                                                 decoder.queueInputBuffer(inputBufIndex, 0, chunkSize, extractor.getSampleTime(), 0);
491 |                                                 extractor.advance();
492 |                                             }
493 |                                         }
494 |                                     } else if (index == -1) {
495 |                                         eof = true;
496 |                                     }
497 |                                     if (eof) {
498 |                                         int inputBufIndex = decoder.dequeueInputBuffer(TIMEOUT_USEC);
499 |                                         if (inputBufIndex >= 0) {
500 |                                             decoder.queueInputBuffer(inputBufIndex, 0, 0, 0L, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
501 |                                             inputDone = true;
502 |                                         }
503 |                                     }
504 |                                 }
505 | 
506 |                                 boolean decoderOutputAvailable = !decoderDone;
507 |                                 boolean encoderOutputAvailable = true;
508 |                                 while (decoderOutputAvailable || encoderOutputAvailable) {
509 |                                     int encoderStatus = encoder.dequeueOutputBuffer(info, TIMEOUT_USEC);
510 |                                     if (encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
511 |                                         encoderOutputAvailable = false;
512 |                                     } else if (encoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
513 |                                         if (Build.VERSION.SDK_INT < 21) {
514 |                                             encoderOutputBuffers = encoder.getOutputBuffers();
515 |                                         }
516 |                                     } else if (encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
517 |                                         MediaFormat newFormat = encoder.getOutputFormat();
518 |                                         if (videoTrackIndex == -5) {
519 |                                             videoTrackIndex = mediaMuxer.addTrack(newFormat, false);
520 |                                         }
521 |                                     } else if (encoderStatus < 0) {
522 |                                         throw new RuntimeException("unexpected result from encoder.dequeueOutputBuffer: " + encoderStatus);
523 |                                     } else {
524 |                                         ByteBuffer encodedData;
525 |                                         if (Build.VERSION.SDK_INT < 21) {
526 |                                             encodedData = encoderOutputBuffers[encoderStatus];
527 |                                         } else {
528 |                                             encodedData = encoder.getOutputBuffer(encoderStatus);
529 |                                         }
530 |                                         if (encodedData == null) {
531 |                                             throw new RuntimeException("encoderOutputBuffer " + encoderStatus + " was null");
532 |                                         }
533 |                                         if (info.size > 1) {
534 |                                             if ((info.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) == 0) {
535 |                                                 if (mediaMuxer.writeSampleData(videoTrackIndex, encodedData, info, false)) {
536 |                                                     didWriteData(false, false);
537 |                                                 }
538 |                                             } else if (videoTrackIndex == -5) {
539 |                                                 byte[] csd = new byte[info.size];
540 |                                                 encodedData.limit(info.offset + info.size);
541 |                                                 encodedData.position(info.offset);
542 |                                                 encodedData.get(csd);
543 |                                                 ByteBuffer sps = null;
544 |                                                 ByteBuffer pps = null;
545 |                                                 for (int a = info.size - 1; a >= 0; a--) {
546 |                                                     if (a > 3) {
547 |                                                         if (csd[a] == 1 && csd[a - 1] == 0 && csd[a - 2] == 0 && csd[a - 3] == 0) {
548 |                                                             sps = ByteBuffer.allocate(a - 3);
549 |                                                             pps = ByteBuffer.allocate(info.size - (a - 3));
550 |                                                             sps.put(csd, 0, a - 3).position(0);
551 |                                                             pps.put(csd, a - 3, info.size - (a - 3)).position(0);
552 |                                                             break;
553 |                                                         }
554 |                                                     } else {
555 |                                                         break;
556 |                                                     }
557 |                                                 }
558 | 
559 |                                                 MediaFormat newFormat = MediaFormat.createVideoFormat(MIME_TYPE, resultWidth, resultHeight);
560 |                                                 if (sps != null && pps != null) {
561 |                                                     newFormat.setByteBuffer("csd-0", sps);
562 |                                                     newFormat.setByteBuffer("csd-1", pps);
563 |                                                 }
564 |                                                 videoTrackIndex = mediaMuxer.addTrack(newFormat, false);
565 |                                             }
566 |                                         }
567 |                                         outputDone = (info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
568 |                                         encoder.releaseOutputBuffer(encoderStatus, false);
569 |                                     }
570 |                                     if (encoderStatus != MediaCodec.INFO_TRY_AGAIN_LATER) {
571 |                                         continue;
572 |                                     }
573 | 
574 |                                     if (!decoderDone) {
575 |                                         int decoderStatus = decoder.dequeueOutputBuffer(info, TIMEOUT_USEC);
576 |                                         if (decoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
577 |                                             decoderOutputAvailable = false;
578 |                                         } else if (decoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
579 | 
580 |                                         } else if (decoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
581 |                                             MediaFormat newFormat = decoder.getOutputFormat();
582 |                                             Log.e("tmessages", "newFormat = " + newFormat);
583 |                                         } else if (decoderStatus < 0) {
584 |                                             throw new RuntimeException("unexpected result from decoder.dequeueOutputBuffer: " + decoderStatus);
585 |                                         } else {
586 |                                             boolean doRender;
587 |                                             if (Build.VERSION.SDK_INT >= 18) {
588 |                                                 doRender = info.size != 0;
589 |                                             } else {
590 |                                                 doRender = info.size != 0 || info.presentationTimeUs != 0;
591 |                                             }
592 |                                             if (endTime > 0 && info.presentationTimeUs >= endTime) {
593 |                                                 inputDone = true;
594 |                                                 decoderDone = true;
595 |                                                 doRender = false;
596 |                                                 info.flags |= MediaCodec.BUFFER_FLAG_END_OF_STREAM;
597 |                                             }
598 |                                             if (startTime > 0 && videoTime == -1) {
599 |                                                 if (info.presentationTimeUs < startTime) {
600 |                                                     doRender = false;
601 |                                                     Log.e("tmessages", "drop frame startTime = " + startTime + " present time = " + info.presentationTimeUs);
602 |                                                 } else {
603 |                                                     videoTime = info.presentationTimeUs;
604 |                                                 }
605 |                                             }
606 |                                             decoder.releaseOutputBuffer(decoderStatus, doRender);
607 |                                             if (doRender) {
608 |                                                 boolean errorWait = false;
609 |                                                 try {
610 |                                                     outputSurface.awaitNewImage();
611 |                                                 } catch (Exception e) {
612 |                                                     errorWait = true;
613 |                                                     Log.e("tmessages", e.getMessage());
614 |                                                 }
615 |                                                 if (!errorWait) {
616 |                                                     if (Build.VERSION.SDK_INT >= 18) {
617 |                                                         outputSurface.drawImage(false);
618 |                                                         inputSurface.setPresentationTime(info.presentationTimeUs * 1000);
619 | 
620 |                                                         if (listener != null) {
621 |                                                             listener.onProgress((float) info.presentationTimeUs / (float) duration * 100);
622 |                                                         }
623 | 
624 |                                                         inputSurface.swapBuffers();
625 |                                                     } else {
626 |                                                         int inputBufIndex = encoder.dequeueInputBuffer(TIMEOUT_USEC);
627 |                                                         if (inputBufIndex >= 0) {
628 |                                                             outputSurface.drawImage(true);
629 |                                                             ByteBuffer rgbBuf = outputSurface.getFrame();
630 |                                                             ByteBuffer yuvBuf = encoderInputBuffers[inputBufIndex];
631 |                                                             yuvBuf.clear();
632 |                                                             convertVideoFrame(rgbBuf, yuvBuf, colorFormat, resultWidth, resultHeight, padding, swapUV);
633 |                                                             encoder.queueInputBuffer(inputBufIndex, 0, bufferSize, info.presentationTimeUs, 0);
634 |                                                         } else {
635 |                                                             Log.e("tmessages", "input buffer not available");
636 |                                                         }
637 |                                                     }
638 |                                                 }
639 |                                             }
640 |                                             if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
641 |                                                 decoderOutputAvailable = false;
642 |                                                 Log.e("tmessages", "decoder stream end");
643 |                                                 if (Build.VERSION.SDK_INT >= 18) {
644 |                                                     encoder.signalEndOfInputStream();
645 |                                                 } else {
646 |                                                     int inputBufIndex = encoder.dequeueInputBuffer(TIMEOUT_USEC);
647 |                                                     if (inputBufIndex >= 0) {
648 |                                                         encoder.queueInputBuffer(inputBufIndex, 0, 1, info.presentationTimeUs, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
649 |                                                     }
650 |                                                 }
651 |                                             }
652 |                                         }
653 |                                     }
654 |                                 }
655 |                             }
656 |                             if (videoTime != -1) {
657 |                                 videoStartTime = videoTime;
658 |                             }
659 |                         } catch (Exception e) {
660 |                             Log.e("tmessages", e.getMessage());
661 |                             error = true;
662 |                         }
663 | 
664 |                         extractor.unselectTrack(videoIndex);
665 | 
666 |                         if (outputSurface != null) {
667 |                             outputSurface.release();
668 |                         }
669 |                         if (inputSurface != null) {
670 |                             inputSurface.release();
671 |                         }
672 |                         if (decoder != null) {
673 |                             decoder.stop();
674 |                             decoder.release();
675 |                         }
676 |                         if (encoder != null) {
677 |                             encoder.stop();
678 |                             encoder.release();
679 |                         }
680 |                     }
681 |                 } else {
682 |                     long videoTime = readAndWriteTrack(extractor, mediaMuxer, info, startTime, endTime, cacheFile, false);
683 |                     if (videoTime != -1) {
684 |                         videoStartTime = videoTime;
685 |                     }
686 |                 }
687 |                 if (!error) {
688 |                     readAndWriteTrack(extractor, mediaMuxer, info, videoStartTime, endTime, cacheFile, true);
689 |                 }
690 |             } catch (Exception e) {
691 |                 error = true;
692 |                 Log.e("tmessages", e.getMessage());
693 |             } finally {
694 |                 if (extractor != null) {
695 |                     extractor.release();
696 |                 }
697 |                 if (mediaMuxer != null) {
698 |                     try {
699 |                         mediaMuxer.finishMovie(false);
700 |                     } catch (Exception e) {
701 |                         Log.e("tmessages", e.getMessage());
702 |                     }
703 |                 }
704 |                 Log.e("tmessages", "time = " + (System.currentTimeMillis() - time));
705 |             }
706 |         } else {
707 |             didWriteData(true, true);
708 |             return false;
709 |         }
710 |         didWriteData(true, error);
711 | 
712 |         cachedFile = cacheFile;
713 | 
714 |        /* File fdelete = inputFile;
715 |         if (fdelete.exists()) {
716 |             if (fdelete.delete()) {
717 |                Log.e("file Deleted :" ,inputFile.getPath());
718 |             } else {
719 |                 Log.e("file not Deleted :" , inputFile.getPath());
720 |             }
721 |         }*/
722 | 
723 |         //inputFile.delete();
724 |         Log.e("ViratPath", path + "");
725 |         Log.e("ViratPath", cacheFile.getPath() + "");
726 |         Log.e("ViratPath", inputFile.getPath() + "");
727 | 
728 | 
729 |        /* Log.e("ViratPath",path+"");
730 |         File replacedFile = new File(path);
731 | 
732 |         FileOutputStream fos = null;
733 |         InputStream inputStream = null;
734 |         try {
735 |             fos = new FileOutputStream(replacedFile);
736 |              inputStream = new FileInputStream(cacheFile);
737 |             byte[] buf = new byte[1024];
738 |             int len;
739 |             while ((len = inputStream.read(buf)) > 0) {
740 |                 fos.write(buf, 0, len);
741 |             }
742 |             inputStream.close();
743 |             fos.close();
744 | 
745 |         } catch (FileNotFoundException e) {
746 |             e.printStackTrace();
747 |         } catch (IOException e) {
748 |             e.printStackTrace();
749 |         }
750 | */
751 | 
752 |         //    cacheFile.delete();
753 | 
754 |        /* try {
755 |            // copyFile(cacheFile,inputFile);
756 |             //inputFile.delete();
757 |             FileUtils.copyFile(cacheFile,inputFile);
758 |         } catch (IOException e) {
759 |             e.printStackTrace();
760 |         }*/
761 |         // cacheFile.delete();
762 |         // inputFile.delete();
763 |         return true;
764 |     }
765 | 
766 |     public static void copyFile(File src, File dst) throws IOException {
767 |         FileChannel inChannel = new FileInputStream(src).getChannel();
768 |         FileChannel outChannel = new FileOutputStream(dst).getChannel();
769 |         try {
770 |             inChannel.transferTo(1, inChannel.size(), outChannel);
771 |         } finally {
772 |             if (inChannel != null)
773 |                 inChannel.close();
774 |             if (outChannel != null)
775 |                 outChannel.close();
776 |         }
777 |     }
778 | }


--------------------------------------------------------------------------------