├── .gitignore
├── .idea
├── gradle.xml
├── misc.xml
├── modules.xml
├── runConfigurations.xml
└── vcs.xml
├── README.md
├── app
├── .gitignore
├── build.gradle
├── proguard-rules.pro
└── src
│ ├── androidTest
│ └── java
│ │ └── com
│ │ └── videocompress
│ │ └── ExampleInstrumentedTest.java
│ ├── main
│ ├── AndroidManifest.xml
│ ├── java
│ │ └── com
│ │ │ └── videocompress
│ │ │ └── MainActivity.java
│ └── res
│ │ ├── drawable-v24
│ │ └── ic_launcher_foreground.xml
│ │ ├── drawable
│ │ └── ic_launcher_background.xml
│ │ ├── layout
│ │ └── activity_main.xml
│ │ ├── mipmap-anydpi-v26
│ │ ├── ic_launcher.xml
│ │ └── ic_launcher_round.xml
│ │ ├── mipmap-hdpi
│ │ ├── ic_launcher.png
│ │ └── ic_launcher_round.png
│ │ ├── mipmap-mdpi
│ │ ├── ic_launcher.png
│ │ └── ic_launcher_round.png
│ │ ├── mipmap-xhdpi
│ │ ├── ic_launcher.png
│ │ └── ic_launcher_round.png
│ │ ├── mipmap-xxhdpi
│ │ ├── ic_launcher.png
│ │ └── ic_launcher_round.png
│ │ ├── mipmap-xxxhdpi
│ │ ├── ic_launcher.png
│ │ └── ic_launcher_round.png
│ │ └── values
│ │ ├── colors.xml
│ │ ├── strings.xml
│ │ └── styles.xml
│ └── test
│ └── java
│ └── com
│ └── videocompress
│ └── ExampleUnitTest.java
├── build.gradle
├── gradle.properties
├── gradle
└── wrapper
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
├── settings.gradle
└── silicompressor
├── .gitignore
├── build.gradle
├── libs
├── aspectjrt-1.7.3.jar
└── isoparser-1.0.6.jar
├── proguard-rules.pro
└── src
├── androidTest
└── java
│ └── com
│ └── iceteck
│ └── silicompressorr
│ └── ApplicationTest.java
├── main
├── AndroidManifest.xml
├── java
│ └── com
│ │ └── iceteck
│ │ └── silicompressorr
│ │ ├── FileUtils.java
│ │ ├── SiliCompressor.java
│ │ ├── Util.java
│ │ ├── VideoCompress.java
│ │ └── videocompression
│ │ ├── Config.java
│ │ ├── InputSurface.java
│ │ ├── MP4Builder.java
│ │ ├── MediaController.java
│ │ ├── Mp4Movie.java
│ │ ├── OutputSurface.java
│ │ ├── Sample.java
│ │ ├── TextureRenderer.java
│ │ ├── Track.java
│ │ └── VideoController.java
└── res
│ └── values
│ └── strings.xml
└── test
└── java
└── com
└── iceteck
└── silicompressorr
└── ExampleUnitTest.java
/.gitignore:
--------------------------------------------------------------------------------
1 | *.iml
2 | .gradle
3 | /local.properties
4 | /.idea/workspace.xml
5 | /.idea/libraries
6 | .DS_Store
7 | /build
8 | /captures
9 | .externalNativeBuild
10 |
--------------------------------------------------------------------------------
/.idea/gradle.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
18 |
19 |
--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
16 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
--------------------------------------------------------------------------------
/.idea/modules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
--------------------------------------------------------------------------------
/.idea/runConfigurations.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
11 |
12 |
--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # VideoCompress
2 | Android视频压缩
3 |
4 | 博客地址：http://blog.csdn.net/qq_36421691/article/details/79113392
5 |
6 | 首先： 视频压缩是硬解的压缩，我最开始接触压缩是FFMpeg压缩，使用的是 https://github.com/chenzhihui28/VideoRecorderAndCompressor ，想尝试的人也可以去看下，但是当我压缩的时候发现，压缩时间很慢，比如压缩1分46秒（253M，ViVO x7 plus）的视频花了2分多钟，具体时间自己可以去测，因为项目需要上传本地视频，本地视频一般很大。。假如是5分钟的视频那么用FFMpeg压缩时间就大于5分钟。。。，而且FFMpeg的命令我真的来不及去玩。。。里面涉及到东西有点多。。
7 |
8 | 然后： 项目又要很快要把这个压缩功能做完。。。我又没做过这个。。简直是一窍不通。。。 然后实在没法只有github上来找。。。。 之后了解到了硬解，十分感谢这篇文章，大家都可以去看下 https://github.com/Tourenathan-G5organisation/SiliCompressor 这篇文章看了之后，经测试 1分46秒的视频压缩只要1分10几秒左右，如果手机好点，还可以更快。。。。 但是这个文章没有progress，这让我很不方便查看，然后我就去浏览Issuses发现了有个人对这个progress进行了修改 https://github.com/fishwjy/VideoCompressor 我就把两篇文章合在一起使用了。。。。。
9 |
10 | 最后： 选择本地视频通过 https://github.com/LuckSiege/PictureSelector 来选择的，大家都可以去看下。。。。。
11 |
12 | 结语： github上的这个Wiki没怎么玩过不知道咋写。。。。。连传图和传gif都不知道咋玩。。。所以效果只有自己去测了， 而且这个项目只是做压缩的一个记录。。。。。如果有其他建议麻烦大家指正。
13 |
14 | # 错误
15 | Error:(56, 1) A problem occurred evaluating project ':silicompressor'.
16 | > Could not read script 'https://raw.githubusercontent.com/nuuneoi/JCenter/master/installv1.gradle'.
17 | > Connection timed out: connect
18 | # 解决方法
19 | 在silicompressor/build.gradle删除以下两句话，然后rebulid（原因是没有梯子）
20 | // Place it at the end of the file
21 | apply from: 'https://raw.githubusercontent.com/nuuneoi/JCenter/master/installv1.gradle'
22 | apply from: 'https://raw.githubusercontent.com/nuuneoi/JCenter/master/bintrayv1.gradle'
23 |
--------------------------------------------------------------------------------
/app/.gitignore:
--------------------------------------------------------------------------------
1 | /build
2 |
--------------------------------------------------------------------------------
/app/build.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: 'com.android.application'
2 |
3 | android {
4 | compileSdkVersion 26
5 | defaultConfig {
6 | applicationId "com.videocompress"
7 | minSdkVersion 15
8 | targetSdkVersion 26
9 | versionCode 1
10 | versionName "1.0"
11 | testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
12 | }
13 | buildTypes {
14 | release {
15 | minifyEnabled false
16 | proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
17 | }
18 | }
19 | }
20 |
21 | dependencies {
22 | implementation fileTree(include: ['*.jar'], dir: 'libs')
23 | implementation 'com.android.support:appcompat-v7:26.1.0'
24 | implementation 'com.android.support.constraint:constraint-layout:1.0.2'
25 | testImplementation 'junit:junit:4.12'
26 | androidTestImplementation 'com.android.support.test:runner:1.0.1'
27 | androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.1'
28 | compile 'com.github.LuckSiege.PictureSelector:picture_library:v2.1.7'
29 | implementation project(':silicompressor')
30 | }
31 |
--------------------------------------------------------------------------------
/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
22 |
--------------------------------------------------------------------------------
/app/src/androidTest/java/com/videocompress/ExampleInstrumentedTest.java:
--------------------------------------------------------------------------------
1 | package com.videocompress;
2 |
3 | import android.content.Context;
4 | import android.support.test.InstrumentationRegistry;
5 | import android.support.test.runner.AndroidJUnit4;
6 |
7 | import org.junit.Test;
8 | import org.junit.runner.RunWith;
9 |
10 | import static org.junit.Assert.*;
11 |
12 | /**
13 | * Instrumented test, which will execute on an Android device.
14 | *
15 | * @see Testing documentation
16 | */
17 | @RunWith(AndroidJUnit4.class)
18 | public class ExampleInstrumentedTest {
19 | @Test
20 | public void useAppContext() throws Exception {
21 | // Context of the app under test.
22 | Context appContext = InstrumentationRegistry.getTargetContext();
23 |
24 | assertEquals("com.videocompress", appContext.getPackageName());
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/app/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
--------------------------------------------------------------------------------
/app/src/main/java/com/videocompress/MainActivity.java:
--------------------------------------------------------------------------------
1 | package com.videocompress;
2 |
3 | import android.annotation.TargetApi;
4 | import android.app.Activity;
5 | import android.content.Intent;
6 | import android.content.res.Configuration;
7 | import android.net.Uri;
8 | import android.os.Build;
9 | import android.os.Bundle;
10 | import android.os.Environment;
11 | import android.util.Log;
12 | import android.view.View;
13 | import android.widget.Button;
14 | import android.widget.TextView;
15 | import android.widget.Toast;
16 |
17 | import com.iceteck.silicompressorr.VideoCompress;
18 | import com.luck.picture.lib.PictureSelector;
19 | import com.luck.picture.lib.config.PictureConfig;
20 | import com.luck.picture.lib.config.PictureMimeType;
21 | import com.luck.picture.lib.entity.LocalMedia;
22 |
23 | import java.io.File;
24 | import java.text.SimpleDateFormat;
25 | import java.util.Date;
26 | import java.util.List;
27 | import java.util.Locale;
28 |
29 | public class MainActivity extends Activity implements View.OnClickListener {
30 | private static final String TAG = "MainActivity";
31 | private Button localButton;
32 | private Button compressButton;
33 | private long startTime, endTime;
34 | private String outputDir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS).getAbsolutePath();
35 | private String inputDir="";
36 | private TextView inputText;
37 | private TextView outPutText;
38 | @Override
39 | protected void onCreate(Bundle savedInstanceState) {
40 | super.onCreate(savedInstanceState);
41 | setContentView(R.layout.activity_main);
42 | initView();
43 | }
44 |
45 | private void initView(){
46 | localButton=findViewById(R.id.localButton);
47 | compressButton=findViewById(R.id.compressButton);
48 | localButton.setOnClickListener(this);
49 | compressButton.setOnClickListener(this);
50 | inputText=findViewById(R.id.inputText);
51 | outPutText=findViewById(R.id.outPutText);
52 | }
53 |
54 | @Override
55 | public void onClick(View view) {
56 | switch (view.getId()){
57 | case R.id.localButton:
58 | setPicture();
59 | break;
60 | case R.id.compressButton:
61 | final String destPath = outputDir + File.separator + "VID_" + new SimpleDateFormat("yyyyMMdd_HHmmss", getLocale()).format(new Date()) + ".mp4";
62 | outPutText.setText(destPath);
63 | VideoCompress.compressVideoLow(inputDir, destPath, new VideoCompress.CompressListener() {
64 | @Override
65 | public void onStart() {
66 | startTime = System.currentTimeMillis();
67 | setTime(startTime,"开始时间");
68 |
69 | }
70 |
71 | @Override
72 | public void onSuccess() {
73 | endTime = System.currentTimeMillis();
74 | setTime(endTime,"结束时间");
75 | Log.i(TAG,"压缩后大小 = "+getFileSize(destPath));
76 | openFile(new File(destPath));
77 | }
78 |
79 | @Override
80 | public void onFail() {
81 | endTime = System.currentTimeMillis();
82 | setTime(endTime,"失败时间");
83 | }
84 |
85 | @Override
86 | public void onProgress(float percent) {
87 | Log.i(TAG,String.valueOf(percent) + "%");
88 | }
89 | });
90 | break;
91 | }
92 | }
93 |
94 | private void setPicture(){
95 | // 进入相册 以下是例子：用不到的api可以不写
96 | PictureSelector.create(MainActivity.this)
97 | .openGallery(PictureMimeType.ofVideo())//全部.PictureMimeType.ofAll()、图片.ofImage()、视频.ofVideo()、音频.ofAudio()
98 | .imageSpanCount(4)// 每行显示个数 int
99 | .selectionMode(PictureConfig.SINGLE)// 多选 or 单选 PictureConfig.MULTIPLE or PictureConfig.SINGLE
100 | .previewVideo(true)// 是否可预览视频 true or false
101 | .enablePreviewAudio(true) // 是否可播放音频 true or false
102 | .isCamera(false)// 是否显示拍照按钮 true or false
103 | .openClickSound(false)// 是否开启点击声音 true or false
104 | .videoQuality(1)// 视频录制质量 0 or 1 int
105 | .videoMaxSecond(60)// 显示多少秒以内的视频or音频也可适用 int
106 | .videoMinSecond(10)// 显示多少秒以内的视频or音频也可适用 int
107 | .recordVideoSecond(60)//视频秒数录制 默认60s int
108 | .forResult(PictureConfig.CHOOSE_REQUEST);//结果回调onActivityResult code
109 | }
110 |
111 |
112 | @Override
113 | protected void onActivityResult(int requestCode, int resultCode, Intent data) {
114 | super.onActivityResult(requestCode, resultCode, data);
115 | if (resultCode==RESULT_OK){
116 | switch (requestCode){
117 | case PictureConfig.CHOOSE_REQUEST:
118 | List selectList = PictureSelector.obtainMultipleResult(data);
119 | for (int i = 0; i
7 |
12 |
13 |
19 |
239 | *
240 | * Callers should check whether the path is local before assuming it
241 | * represents a local file.
242 | *
243 | * @param context The context.
244 | * @param uri The Uri to query.
245 | * @see #isLocal(String)
246 | * @see #getFile(Context, Uri)
247 | * @author paulburke
248 | */
249 | public static String getPath(final Context context, final Uri uri) {
250 |
251 | if (DEBUG)
252 | Log.d(TAG + " File -",
253 | "Authority: " + uri.getAuthority() +
254 | ", Fragment: " + uri.getFragment() +
255 | ", Port: " + uri.getPort() +
256 | ", Query: " + uri.getQuery() +
257 | ", Scheme: " + uri.getScheme() +
258 | ", Host: " + uri.getHost() +
259 | ", Segments: " + uri.getPathSegments().toString()
260 | );
261 |
262 | final boolean isKitKat = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT;
263 |
264 | // DocumentProvider
265 |
266 | if ( Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT && DocumentsContract.isDocumentUri(context, uri)) {
267 |
268 | // ExternalStorageProvider
269 | if (isExternalStorageDocument(uri)) {
270 | final String docId = DocumentsContract.getDocumentId(uri);
271 | final String[] split = docId.split(":");
272 | final String type = split[0];
273 |
274 | if ("primary".equalsIgnoreCase(type)) {
275 | return Environment.getExternalStorageDirectory() + "/" + split[1];
276 | }
277 |
278 |
279 | }
280 | // DownloadsProvider
281 | else if (isDownloadsDocument(uri)) {
282 |
283 | final String id = DocumentsContract.getDocumentId(uri);
284 | final Uri contentUri = ContentUris.withAppendedId(
285 | Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
286 |
287 | return getDataColumn(context, contentUri, null, null);
288 | }
289 | // MediaProvider
290 | else if (isMediaDocument(uri)) {
291 | final String docId = DocumentsContract.getDocumentId(uri);
292 | final String[] split = docId.split(":");
293 | final String type = split[0];
294 |
295 | Uri contentUri = null;
296 | if ("image".equals(type)) {
297 | contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
298 | } else if ("video".equals(type)) {
299 | contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
300 | } else if ("audio".equals(type)) {
301 | contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
302 | }
303 |
304 | final String selection = "_id=?";
305 | final String[] selectionArgs = new String[] {
306 | split[1]
307 | };
308 |
309 | return getDataColumn(context, contentUri, selection, selectionArgs);
310 | }
311 | }
312 | // MediaStore (and general)
313 | else if ("content".equalsIgnoreCase(uri.getScheme())) {
314 |
315 | // Return the remote address
316 | if (isGooglePhotosUri(uri))
317 | return uri.getLastPathSegment();
318 |
319 | return getDataColumn(context, uri, null, null);
320 | }
321 | // File
322 | else if ("file".equalsIgnoreCase(uri.getScheme())) {
323 | return uri.getPath();
324 | }
325 |
326 |
327 | return null;
328 | }
329 |
330 | /**
331 | * Convert Uri into File, if possible.
332 | *
333 | * @return file A local file that the Uri was pointing to, or null if the
334 | * Uri is unsupported or pointed to a remote resource.
335 | * @see #getPath(Context, Uri)
336 | * @author paulburke
337 | */
338 | public static File getFile(Context context, Uri uri) {
339 | if (uri != null) {
340 | String path = getPath(context, uri);
341 | if (path != null && isLocal(path)) {
342 | return new File(path);
343 | }
344 | }
345 | return null;
346 | }
347 |
348 | /**
349 | * Get the file size in a human-readable string.
350 | *
351 | * @param size
352 | * @return
353 | * @author paulburke
354 | */
355 | public static String getReadableFileSize(int size) {
356 | final int BYTES_IN_KILOBYTES = 1024;
357 | final DecimalFormat dec = new DecimalFormat("###.#");
358 | final String KILOBYTES = " KB";
359 | final String MEGABYTES = " MB";
360 | final String GIGABYTES = " GB";
361 | float fileSize = 0;
362 | String suffix = KILOBYTES;
363 |
364 | if (size > BYTES_IN_KILOBYTES) {
365 | fileSize = size / BYTES_IN_KILOBYTES;
366 | if (fileSize > BYTES_IN_KILOBYTES) {
367 | fileSize = fileSize / BYTES_IN_KILOBYTES;
368 | if (fileSize > BYTES_IN_KILOBYTES) {
369 | fileSize = fileSize / BYTES_IN_KILOBYTES;
370 | suffix = GIGABYTES;
371 | } else {
372 | suffix = MEGABYTES;
373 | }
374 | }
375 | }
376 | return String.valueOf(dec.format(fileSize) + suffix);
377 | }
378 |
379 | /**
380 | * Attempt to retrieve the thumbnail of given File from the MediaStore. This
381 | * should not be called on the UI thread.
382 | *
383 | * @param context
384 | * @param file
385 | * @return
386 | * @author paulburke
387 | */
388 | public static Bitmap getThumbnail(Context context, File file) {
389 | return getThumbnail(context, getUri(file), getMimeType(file));
390 | }
391 |
392 | /**
393 | * Attempt to retrieve the thumbnail of given Uri from the MediaStore. This
394 | * should not be called on the UI thread.
395 | *
396 | * @param context
397 | * @param uri
398 | * @return
399 | * @author paulburke
400 | */
401 | public static Bitmap getThumbnail(Context context, Uri uri) {
402 | return getThumbnail(context, uri, getMimeType(context, uri));
403 | }
404 |
405 | /**
406 | * Attempt to retrieve the thumbnail of given Uri from the MediaStore. This
407 | * should not be called on the UI thread.
408 | *
409 | * @param context
410 | * @param uri
411 | * @param mimeType
412 | * @return
413 | * @author paulburke
414 | */
415 | public static Bitmap getThumbnail(Context context, Uri uri, String mimeType) {
416 | if (DEBUG)
417 | Log.d(TAG, "Attempting to get thumbnail");
418 |
419 | if (!isMediaUri(uri)) {
420 | Log.e(TAG, "You can only retrieve thumbnails for images and videos.");
421 | return null;
422 | }
423 |
424 | Bitmap bm = null;
425 | if (uri != null) {
426 | final ContentResolver resolver = context.getContentResolver();
427 | Cursor cursor = null;
428 | try {
429 | cursor = resolver.query(uri, null, null, null, null);
430 | if (cursor.moveToFirst()) {
431 | final int id = cursor.getInt(0);
432 | if (DEBUG)
433 | Log.d(TAG, "Got thumb ID: " + id);
434 |
435 | if (mimeType.contains("video")) {
436 | bm = MediaStore.Video.Thumbnails.getThumbnail(
437 | resolver,
438 | id,
439 | MediaStore.Video.Thumbnails.MINI_KIND,
440 | null);
441 | }
442 | else if (mimeType.contains(FileUtils.MIME_TYPE_IMAGE)) {
443 | bm = MediaStore.Images.Thumbnails.getThumbnail(
444 | resolver,
445 | id,
446 | MediaStore.Images.Thumbnails.MINI_KIND,
447 | null);
448 | }
449 | }
450 | } catch (Exception e) {
451 | if (DEBUG)
452 | Log.e(TAG, "getThumbnail", e);
453 | } finally {
454 | if (cursor != null)
455 | cursor.close();
456 | }
457 | }
458 | return bm;
459 | }
460 |
461 | /**
462 | * File and folder comparator. TODO Expose sorting option method
463 | *
464 | * @author paulburke
465 | */
466 | public static Comparator sComparator = new Comparator() {
467 | @Override
468 | public int compare(File f1, File f2) {
469 | // Sort alphabetically by lower case, which is much cleaner
470 | return f1.getName().toLowerCase().compareTo(
471 | f2.getName().toLowerCase());
472 | }
473 | };
474 |
475 | /**
476 | * File (not directories) filter.
477 | *
478 | * @author paulburke
479 | */
480 | public static FileFilter sFileFilter = new FileFilter() {
481 | @Override
482 | public boolean accept(File file) {
483 | final String fileName = file.getName();
484 | // Return files only (not directories) and skip hidden files
485 | return file.isFile() && !fileName.startsWith(HIDDEN_PREFIX);
486 | }
487 | };
488 |
489 | /**
490 | * Folder (directories) filter.
491 | *
492 | * @author paulburke
493 | */
494 | public static FileFilter sDirFilter = new FileFilter() {
495 | @Override
496 | public boolean accept(File file) {
497 | final String fileName = file.getName();
498 | // Return directories only and skip hidden directories
499 | return file.isDirectory() && !fileName.startsWith(HIDDEN_PREFIX);
500 | }
501 | };
502 |
503 | /**
504 | * Get the Intent for selecting content to be used in an Intent Chooser.
505 | *
506 | * @return The intent for opening a file with Intent.createChooser()
507 | * @author paulburke
508 | */
509 | public static Intent createGetContentIntent() {
510 | // Implicitly allow the user to select a particular kind of data
511 | final Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
512 | // The MIME data type filter
513 | intent.setType("*/*");
514 | // Only return URIs that can be opened with ContentResolver
515 | intent.addCategory(Intent.CATEGORY_OPENABLE);
516 | return intent;
517 | }
518 | }
--------------------------------------------------------------------------------
/silicompressor/src/main/java/com/iceteck/silicompressorr/SiliCompressor.java:
--------------------------------------------------------------------------------
1 | package com.iceteck.silicompressorr;
2 |
3 | import android.annotation.SuppressLint;
4 | import android.content.Context;
5 | import android.database.Cursor;
6 | import android.graphics.Bitmap;
7 | import android.graphics.BitmapFactory;
8 | import android.graphics.Canvas;
9 | import android.graphics.Matrix;
10 | import android.graphics.Paint;
11 | import android.media.ExifInterface;
12 | import android.net.Uri;
13 | import android.os.Environment;
14 | import android.provider.DocumentsContract;
15 | import android.provider.MediaStore;
16 | import android.util.Log;
17 |
18 | import com.iceteck.silicompressorr.videocompression.MediaController;
19 |
20 | import java.io.File;
21 | import java.io.FileNotFoundException;
22 | import java.io.FileOutputStream;
23 | import java.io.IOException;
24 | import java.net.URISyntaxException;
25 | import java.text.SimpleDateFormat;
26 | import java.util.Date;
27 | import java.util.Locale;
28 |
29 | /**
30 | * @author Toure, Akah L
31 | * @version 1.1.1
32 | * Created by Toure on 28/03/2016.
33 | */
34 | public class SiliCompressor {
35 |
36 | private static final String LOG_TAG = SiliCompressor.class.getSimpleName();
37 | public static String videoCompressionPath ;
38 |
39 | static volatile SiliCompressor singleton = null;
40 | private static Context mContext;
41 |
42 | public SiliCompressor(Context context){
43 | mContext = context;
44 | }
45 |
46 | // initialise the class and set the context
47 | public static SiliCompressor with(Context context){
48 | if (singleton == null) {
49 | synchronized (SiliCompressor.class) {
50 | if (singleton == null) {
51 | singleton = new Builder(context).build();
52 | }
53 | }
54 | }
55 | return singleton;
56 |
57 | }
58 |
59 | /**
60 | * Compresses the image at the specified Uri String and and return the filepath of the compressed image.
61 | * @param imageUri imageUri Uri (String) of the source image you wish to compress
62 | * @return filepath
63 | */
64 | public String compress(String imageUri, File destination){
65 | return compressImage(imageUri, destination);
66 | }
67 |
68 | /**
69 | * Compresses the image at the specified Uri String and and return the filepath of the compressed image.
70 | * @param imageUri imageUri Uri (String) of the source image you wish to compress
71 | * @return filepath
72 | */
73 | public String compress(String imageUri, File destination, boolean deleteSourceImage){
74 |
75 | String compressUri = compressImage(imageUri, destination);
76 |
77 | if (deleteSourceImage)
78 | {
79 | File source = new File(getRealPathFromURI(imageUri));
80 | if (source.exists()) {
81 | boolean isdeleted = source.delete();
82 | Log.d(LOG_TAG, (isdeleted) ? "SourceImage File deleted" : "SourceImage File not deleted");
83 | }
84 | }
85 |
86 | return compressUri;
87 | }
88 |
89 |
90 | public String compress(int drawableID) throws IOException {
91 |
92 | // Create a bitmap from this drawable
93 | Bitmap bitmap = BitmapFactory.decodeResource(mContext.getApplicationContext().getResources(), drawableID);
94 | if (null != bitmap){
95 | // Create a file from the bitmap
96 |
97 | // Create an image file name
98 | String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.ENGLISH).format(new Date());
99 | String imageFileName = "JPEG_" + timeStamp + "_";
100 | File storageDir = Environment.getExternalStoragePublicDirectory(
101 | Environment.DIRECTORY_PICTURES);
102 | File image = File.createTempFile(
103 | imageFileName, /* prefix */
104 | ".jpg", /* suffix */
105 | storageDir /* directory */
106 | );
107 | FileOutputStream out = new FileOutputStream(image);
108 | bitmap.compress(Bitmap.CompressFormat.JPEG, 100, out);
109 |
110 | // Compress the new file
111 | Uri copyImageUri = Uri.fromFile(image);
112 |
113 | String compressImagePath = compressImage(copyImageUri.toString(),new File(Environment.getExternalStorageDirectory(), "Silicompressor/images"));
114 |
115 | // Delete the file create from the drawable Id
116 | if (image.exists()) {
117 | boolean isdeleted = image.delete();
118 | Log.d(LOG_TAG, (isdeleted) ? "SourceImage File deleted" : "SourceImage File not deleted");
119 | }
120 |
121 | // return the path to the compress image
122 | return compressImagePath;
123 | }
124 |
125 | return null;
126 | }
127 |
128 |
129 | /**
130 | * Compresses the image at the specified Uri String and and return the bitmap data of the compressed image.
131 | *
132 | * @param imageUri imageUri Uri (String) of the source image you wish to compress
133 | * @return Bitmap format of the new image file (compressed)
134 | * @throws IOException
135 | */
136 | public Bitmap getCompressBitmap(String imageUri) throws IOException {
137 | File imageFile = new File(compressImage(imageUri,new File(Environment.getExternalStorageDirectory(), "Silicompressor/images")));
138 | Uri newImageUri = Uri.fromFile(imageFile);
139 | Bitmap bitmap = MediaStore.Images.Media.getBitmap(mContext.getContentResolver(), newImageUri);
140 | return bitmap;
141 | }
142 |
143 | /**
144 | * Compresses the image at the specified Uri String and and return the bitmap data of the compressed image.
145 | * @param imageUri Uri (String) of the source image you wish to compress
146 | * @param deleteSourceImage If True will delete the source file
147 | * @return Compress image bitmap
148 | * @throws IOException
149 | */
150 | public Bitmap getCompressBitmap(String imageUri, boolean deleteSourceImage) throws IOException {
151 | File imageFile = new File(compressImage(imageUri,new File(Environment.getExternalStorageDirectory(), "Silicompressor/images")));
152 | Uri newImageUri = Uri.fromFile(imageFile);
153 | Bitmap bitmap = MediaStore.Images.Media.getBitmap(mContext.getContentResolver(), newImageUri);
154 |
155 | if (deleteSourceImage)
156 | {
157 | File source = new File(getRealPathFromURI(imageUri));
158 | if (source.exists()) {
159 | boolean isdeleted = source.delete();
160 | Log.d(LOG_TAG, (isdeleted) ? "SourceImage File deleted" : "SourceImage File not deleted");
161 | }
162 | }
163 | return bitmap;
164 | }
165 |
166 | /**
167 | * Do the actual compression of this image
168 | * @param imageUri source image file to compress
169 | * @param destDirectory destination directory to place image in
170 | * @return uri string of the compressed image
171 | */
172 | private String compressImage(String imageUri, File destDirectory) {
173 |
174 | String filePath = getRealPathFromURI(imageUri);
175 | Bitmap scaledBitmap = null;
176 |
177 | BitmapFactory.Options options = new BitmapFactory.Options();
178 |
179 | // by setting this field as true, the actual bitmap pixels are not loaded in the memory. Just the bounds are loaded. If
180 | // you try the use the bitmap here, you will get null.
181 | options.inJustDecodeBounds = true;
182 | Bitmap bmp = BitmapFactory.decodeFile(filePath, options);
183 |
184 | int actualHeight = options.outHeight;
185 | int actualWidth = options.outWidth;
186 |
187 | // max Height and width values of the compressed image is taken as 816x612
188 |
189 | float maxHeight = 816.0f;
190 | float maxWidth = 612.0f;
191 | float imgRatio = actualWidth / actualHeight;
192 | float maxRatio = maxWidth / maxHeight;
193 |
194 | // width and height values are set maintaining the aspect ratio of the image
195 |
196 | if (actualHeight > maxHeight || actualWidth > maxWidth) {
197 | if (imgRatio < maxRatio) {
198 | imgRatio = maxHeight / actualHeight;
199 | actualWidth = (int) (imgRatio * actualWidth);
200 | actualHeight = (int) maxHeight;
201 | } else if (imgRatio > maxRatio) {
202 | imgRatio = maxWidth / actualWidth;
203 | actualHeight = (int) (imgRatio * actualHeight);
204 | actualWidth = (int) maxWidth;
205 | } else {
206 | actualHeight = (int) maxHeight;
207 | actualWidth = (int) maxWidth;
208 |
209 | }
210 | }
211 |
212 | // setting inSampleSize value allows to load a scaled down version of the original image
213 |
214 | options.inSampleSize = calculateInSampleSize(options, actualWidth, actualHeight);
215 |
216 | // inJustDecodeBounds set to false to load the actual bitmap
217 | options.inJustDecodeBounds = false;
218 |
219 | // this options allow android to claim the bitmap memory if it runs low on memory
220 | options.inPurgeable = true;
221 | options.inInputShareable = true;
222 | options.inTempStorage = new byte[16 * 1024];
223 |
224 | try {
225 | // load the bitmap from its path
226 | bmp = BitmapFactory.decodeFile(filePath, options);
227 | } catch (OutOfMemoryError exception) {
228 | exception.printStackTrace();
229 |
230 | }
231 | try {
232 | scaledBitmap = Bitmap.createBitmap(actualWidth, actualHeight, Bitmap.Config.ARGB_8888);
233 | } catch (OutOfMemoryError exception) {
234 | exception.printStackTrace();
235 | }
236 |
237 | float ratioX = actualWidth / (float) options.outWidth;
238 | float ratioY = actualHeight / (float) options.outHeight;
239 | float middleX = actualWidth / 2.0f;
240 | float middleY = actualHeight / 2.0f;
241 |
242 | Matrix scaleMatrix = new Matrix();
243 | scaleMatrix.setScale(ratioX, ratioY, middleX, middleY);
244 |
245 | Canvas canvas = new Canvas(scaledBitmap);
246 | canvas.setMatrix(scaleMatrix);
247 | canvas.drawBitmap(bmp, middleX - bmp.getWidth() / 2, middleY - bmp.getHeight() / 2, new Paint(Paint.FILTER_BITMAP_FLAG));
248 |
249 | // check the rotation of the image and display it properly
250 | ExifInterface exif;
251 | try {
252 | exif = new ExifInterface(filePath);
253 |
254 | int orientation = exif.getAttributeInt(
255 | ExifInterface.TAG_ORIENTATION, 0);
256 | Log.d("EXIF", "Exif: " + orientation);
257 | Matrix matrix = new Matrix();
258 | if (orientation == 6) {
259 | matrix.postRotate(90);
260 | Log.d("EXIF", "Exif: " + orientation);
261 | } else if (orientation == 3) {
262 | matrix.postRotate(180);
263 | Log.d("EXIF", "Exif: " + orientation);
264 | } else if (orientation == 8) {
265 | matrix.postRotate(270);
266 | Log.d("EXIF", "Exif: " + orientation);
267 | }
268 | scaledBitmap = Bitmap.createBitmap(scaledBitmap, 0, 0,
269 | scaledBitmap.getWidth(), scaledBitmap.getHeight(), matrix,
270 | true);
271 | } catch (IOException e) {
272 | e.printStackTrace();
273 | }
274 |
275 | FileOutputStream out = null;
276 | String filename = getFilename(imageUri, destDirectory);
277 | try {
278 | out = new FileOutputStream(filename);
279 |
280 | // write the compressed bitmap at the destination specified by filename.
281 | scaledBitmap.compress(Bitmap.CompressFormat.JPEG, 80, out);
282 |
283 | } catch (FileNotFoundException e) {
284 | e.printStackTrace();
285 | }
286 |
287 | return filename;
288 |
289 | }
290 |
291 | /**
292 | * Perform background video compression. Make sure the videofileUri and destinationUri are valid
293 | * resources because this method does not account for missing directories hence your converted file
294 | * could be in an unknown location
295 | * This uses default values for the converted videos
296 | * @param videoFilePath source path for the video file
297 | * @param destinationDir destination directory where converted file should be saved
298 | * @return The Path of the compressed video file
299 | */
300 | public String compressVideo(String videoFilePath, String destinationDir) throws URISyntaxException {
301 | return compressVideo( videoFilePath, destinationDir, 0, 0, 0 );
302 | }
303 |
304 | /**
305 | * Perform background video compression. Make sure the videofileUri and destinationUri are valid
306 | * resources because this method does not account for missing directories hence your converted file
307 | * could be in an unknown location
308 | * This uses default values for the converted videos
309 | * @param videoFileUri source uri for the video file
310 | * @param destinationDir destination directory where converted file should be saved
311 | * @return The Path of the compressed video file
312 | */
313 | public String compressVideo(Uri videoFileUri, String destinationDir) throws URISyntaxException {
314 | return compressVideo( videoFileUri, destinationDir, 0, 0, 0 );
315 | }
316 |
317 | /**
318 | * Perform background video compression. Make sure the videofileUri and destinationUri are valid
319 | * resources because this method does not account for missing directories hence your converted file
320 | * could be in an unknown location
321 | * @param videoFileUri source uri for the video file
322 | * @param destinationDir destination directory where converted file should be saved
323 | * @param outWidth the target width of the compressed video or 0 to use default width
324 | * @param outHeight the target height of the compressed video or 0 to use default height
325 | * @param bitrate the target bitrate of the compressed video or 0 to user default bitrate
326 | * @return The Path of the compressed video file
327 | */
328 | public String compressVideo(Uri videoFileUri, String destinationDir, int outWidth, int outHeight, int bitrate) throws URISyntaxException {
329 | boolean isconverted = MediaController.getInstance().convertVideo(Util.getFilePath(mContext, videoFileUri), new File(destinationDir), outWidth, outHeight, bitrate);
330 | if (isconverted){
331 | Log.v(LOG_TAG, "Video Conversion Complete");
332 | }else{
333 | Log.v(LOG_TAG, "Video conversion in progress");
334 | }
335 |
336 | return MediaController.cachedFile.getPath();
337 |
338 | }
339 |
340 |
341 | /**
342 | * Perform background video compression. Make sure the videofileUri and destinationUri are valid
343 | * resources because this method does not account for missing directories hence your converted file
344 | * could be in an unknown location
345 | * @param videoFilePath source path for the video file
346 | * @param destinationDir destination directory where converted file should be saved
347 | * @param outWidth the target width of the compressed video or 0 to use default width
348 | * @param outHeight the target height of the compressed video or 0 to use default height
349 | * @param bitrate the target bitrate of the compressed video or 0 to user default bitrate
350 | * @return The Path of the compressed video file
351 | */
352 | public String compressVideo(String videoFilePath, String destinationDir, int outWidth, int outHeight, int bitrate) throws URISyntaxException {
353 | boolean isconverted = MediaController.getInstance().convertVideo( videoFilePath, new File(destinationDir), outWidth, outHeight, bitrate);
354 | if (isconverted){
355 | Log.v(LOG_TAG, "Video Conversion Complete");
356 | }else{
357 | Log.v(LOG_TAG, "Video conversion in progress");
358 | }
359 |
360 | return MediaController.cachedFile.getPath();
361 |
362 | }
363 |
364 |
365 | private int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
366 | final int height = options.outHeight;
367 | final int width = options.outWidth;
368 | int inSampleSize = 1;
369 |
370 | if (height > reqHeight || width > reqWidth) {
371 | final int heightRatio = Math.round((float) height / (float) reqHeight);
372 | final int widthRatio = Math.round((float) width / (float) reqWidth);
373 | inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
374 | }
375 | final float totalPixels = width * height;
376 | final float totalReqPixelsCap = reqWidth * reqHeight * 2;
377 | while (totalPixels / (inSampleSize * inSampleSize) > totalReqPixelsCap) {
378 | inSampleSize++;
379 | }
380 |
381 | return inSampleSize;
382 | }
383 |
384 | private String getFilename(String filename, File file) {
385 | if (!file.exists()) {
386 | file.mkdirs();
387 | }
388 | String ext = ".jpg";
389 | //get extension
390 | /*if (Pattern.matches("^[.][p][n][g]", filename)){
391 | ext = ".png";
392 | }*/
393 |
394 | return (file.getAbsolutePath() + "/IMG_" + new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date()) + ext);
395 |
396 | }
397 |
398 | /**
399 | * Gets a valid path from the supply contentURI
400 | * @param contentURI
401 | * @return A validPath of the image
402 | */
403 | private String getRealPathFromURI(String contentURI) {
404 | Uri contentUri = Uri.parse(contentURI);
405 | Cursor cursor = mContext.getContentResolver().query(contentUri, null, null, null, null);
406 | if (cursor == null) {
407 | return contentUri.getPath();
408 | } else {
409 | cursor.moveToFirst();
410 | int index = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
411 | String str = cursor.getString(index);
412 | cursor.close();
413 | return str;
414 | }
415 | // return FileUtils.getPath(mContext, contentUri);
416 |
417 | // return getRealPathFromURI_API19(mContext, contentUri);
418 |
419 |
420 | }
421 | @SuppressLint("NewApi")
422 | public static String getRealPathFromURI_API19(Context context, Uri uri){
423 | String filePath = "";
424 | String wholeID = DocumentsContract.getDocumentId(uri);
425 |
426 | // Split at colon, use second item in the array
427 | String id = wholeID.split(":")[1];
428 |
429 | String[] column = { MediaStore.Images.Media.DATA };
430 |
431 | // where id is equal to
432 | String sel = MediaStore.Images.Media._ID + "=?";
433 |
434 | Cursor cursor = context.getContentResolver().query(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
435 | column, sel, new String[]{ id }, null);
436 |
437 | int columnIndex = cursor.getColumnIndex(column[0]);
438 |
439 | if (cursor.moveToFirst()) {
440 | filePath = cursor.getString(columnIndex);
441 | }
442 | cursor.close();
443 | return filePath;
444 | }
445 |
446 | /**
447 | * Fluent API for creating {@link SiliCompressor} instances.
448 | */
449 | public static class Builder {
450 |
451 | private final Context context;
452 |
453 |
454 | /**
455 | * Start building a new {@link SiliCompressor} instance.
456 | */
457 | public Builder(Context context) {
458 | if (context == null) {
459 | throw new IllegalArgumentException("Context must not be null.");
460 | }
461 | this.context = context.getApplicationContext();
462 | }
463 |
464 |
465 | /**
466 | * Create the {@link SiliCompressor} instance.
467 | */
468 | public SiliCompressor build() {
469 | Context context = this.context;
470 |
471 | return new SiliCompressor(context);
472 | }
473 | }
474 |
475 | }
476 |
--------------------------------------------------------------------------------
/silicompressor/src/main/java/com/iceteck/silicompressorr/Util.java:
--------------------------------------------------------------------------------
1 | package com.iceteck.silicompressorr;
2 |
3 | import android.annotation.SuppressLint;
4 | import android.content.ContentUris;
5 | import android.content.Context;
6 | import android.database.Cursor;
7 | import android.net.Uri;
8 | import android.os.Build;
9 | import android.os.Environment;
10 | import android.provider.DocumentsContract;
11 | import android.provider.MediaStore;
12 |
13 | import java.net.URISyntaxException;
14 |
15 | /**
16 | * Created by Larry Akah on 5/23/17.
17 | */
18 |
19 | public class Util {
20 |
21 | @SuppressLint("NewApi")
22 | public static String getFilePath(Context context, Uri uri) throws URISyntaxException {
23 | String selection = null;
24 | String[] selectionArgs = null;
25 | // Uri is different in versions after KITKAT (Android 4.4), we need to
26 | if (Build.VERSION.SDK_INT >= 19 && DocumentsContract.isDocumentUri(context.getApplicationContext(), uri)) {
27 | if (isExternalStorageDocument(uri)) {
28 | final String docId = DocumentsContract.getDocumentId(uri);
29 | final String[] split = docId.split(":");
30 | return Environment.getExternalStorageDirectory() + "/" + split[1];
31 | } else if (isDownloadsDocument(uri)) {
32 | final String id = DocumentsContract.getDocumentId(uri);
33 | uri = ContentUris.withAppendedId(
34 | Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
35 | } else if (isMediaDocument(uri)) {
36 | final String docId = DocumentsContract.getDocumentId(uri);
37 | final String[] split = docId.split(":");
38 | final String type = split[0];
39 | if ("image".equals(type)) {
40 | uri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
41 | } else if ("video".equals(type)) {
42 | uri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
43 | } else if ("audio".equals(type)) {
44 | uri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
45 | }
46 | selection = "_id=?";
47 | selectionArgs = new String[]{
48 | split[1]
49 | };
50 | }
51 | }
52 | if ("content".equalsIgnoreCase(uri.getScheme())) {
53 | String[] projection = {
54 | MediaStore.Images.Media.DATA
55 | };
56 | Cursor cursor = null;
57 | try {
58 | cursor = context.getContentResolver()
59 | .query(uri, projection, selection, selectionArgs, null);
60 | int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
61 | if (cursor.moveToFirst()) {
62 | return cursor.getString(column_index);
63 | }
64 | } catch (Exception e) {
65 | e.printStackTrace();
66 | }
67 | } else if ("file".equalsIgnoreCase(uri.getScheme())) {
68 | return uri.getPath();
69 | }
70 | return null;
71 | }
72 |
73 | public static boolean isExternalStorageDocument(Uri uri) {
74 | return "com.android.externalstorage.documents".equals(uri.getAuthority());
75 | }
76 |
77 | public static boolean isDownloadsDocument(Uri uri) {
78 | return "com.android.providers.downloads.documents".equals(uri.getAuthority());
79 | }
80 |
81 | public static boolean isMediaDocument(Uri uri) {
82 | return "com.android.providers.media.documents".equals(uri.getAuthority());
83 | }
84 | }
85 |
--------------------------------------------------------------------------------
/silicompressor/src/main/java/com/iceteck/silicompressorr/VideoCompress.java:
--------------------------------------------------------------------------------
1 | package com.iceteck.silicompressorr;
2 |
3 | import android.os.AsyncTask;
4 |
5 | import com.iceteck.silicompressorr.videocompression.VideoController;
6 |
7 | /**
8 | * Created by Vincent Woo
9 | * Date: 2017/8/16
10 | * Time: 15:15
11 | */
12 |
13 | public class VideoCompress {
14 | private static final String TAG = VideoCompress.class.getSimpleName();
15 |
16 | public static VideoCompressTask compressVideoHigh(String srcPath, String destPath, CompressListener listener) {
17 | VideoCompressTask task = new VideoCompressTask(listener, VideoController.COMPRESS_QUALITY_HIGH);
18 | task.execute(srcPath, destPath);
19 | return task;
20 | }
21 |
22 | public static VideoCompressTask compressVideoMedium(String srcPath, String destPath, CompressListener listener) {
23 | VideoCompressTask task = new VideoCompressTask(listener, VideoController.COMPRESS_QUALITY_MEDIUM);
24 | task.execute(srcPath, destPath);
25 | return task;
26 | }
27 |
28 | public static VideoCompressTask compressVideoLow(String srcPath, String destPath, CompressListener listener) {
29 | VideoCompressTask task = new VideoCompressTask(listener, VideoController.COMPRESS_QUALITY_LOW);
30 | task.execute(srcPath, destPath);
31 | return task;
32 | }
33 |
34 | private static class VideoCompressTask extends AsyncTask {
35 | private CompressListener mListener;
36 | private int mQuality;
37 |
38 | public VideoCompressTask(CompressListener listener, int quality) {
39 | mListener = listener;
40 | mQuality = quality;
41 | }
42 |
43 | @Override
44 | protected void onPreExecute() {
45 | super.onPreExecute();
46 | if (mListener != null) {
47 | mListener.onStart();
48 | }
49 | }
50 |
51 | @Override
52 | protected Boolean doInBackground(String... paths) {
53 | return VideoController.getInstance().convertVideo(paths[0], paths[1], mQuality, new VideoController.CompressProgressListener() {
54 | @Override
55 | public void onProgress(float percent) {
56 | publishProgress(percent);
57 | }
58 | });
59 | }
60 |
61 | @Override
62 | protected void onProgressUpdate(Float... percent) {
63 | super.onProgressUpdate(percent);
64 | if (mListener != null) {
65 | mListener.onProgress(percent[0]);
66 | }
67 | }
68 |
69 | @Override
70 | protected void onPostExecute(Boolean result) {
71 | super.onPostExecute(result);
72 | if (mListener != null) {
73 | if (result) {
74 | mListener.onSuccess();
75 | } else {
76 | mListener.onFail();
77 | }
78 | }
79 | }
80 | }
81 |
82 | public interface CompressListener {
83 | void onStart();
84 | void onSuccess();
85 | void onFail();
86 | void onProgress(float percent);
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/silicompressor/src/main/java/com/iceteck/silicompressorr/videocompression/Config.java:
--------------------------------------------------------------------------------
1 | package com.iceteck.silicompressorr.videocompression;
2 |
3 | /*
4 | * By Jorge E. Hernandez (@lalongooo) 2015
5 | * */
6 |
7 | /*
8 | * Static class to define general configuration values of the application
9 | * */
10 | public class Config {
11 |
12 | /**
13 | * Application root directory. All media files wi'll be stored here.
14 | */
15 | //public static final String VIDEO_COMPRESSOR_APPLICATION_DIR_NAME = "VideoCompressor";
16 |
17 | /**
18 | * Application folder for video files
19 | */
20 | //public static final String VIDEO_COMPRESSOR_COMPRESSED_VIDEOS_DIR = "/CompressedVideos/";
21 |
22 | /**
23 | * Application folder for video files
24 | */
25 | public static final String VIDEO_COMPRESSOR_TEMP_DIR = "/Temp/";
26 | }
27 |
--------------------------------------------------------------------------------
/silicompressor/src/main/java/com/iceteck/silicompressorr/videocompression/InputSurface.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2013 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.iceteck.silicompressorr.videocompression;
18 |
19 | import android.annotation.TargetApi;
20 | import android.opengl.EGL14;
21 | import android.opengl.EGLConfig;
22 | import android.opengl.EGLContext;
23 | import android.opengl.EGLDisplay;
24 | import android.opengl.EGLExt;
25 | import android.opengl.EGLSurface;
26 | import android.os.Build;
27 | import android.view.Surface;
28 |
29 | @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
30 | public class InputSurface {
31 | private static final boolean VERBOSE = false;
32 | private static final int EGL_RECORDABLE_ANDROID = 0x3142;
33 | private static final int EGL_OPENGL_ES2_BIT = 4;
34 | private EGLDisplay mEGLDisplay;
35 | private EGLContext mEGLContext;
36 | private EGLSurface mEGLSurface;
37 | private Surface mSurface;
38 |
39 | public InputSurface(Surface surface) {
40 | if (surface == null) {
41 | throw new NullPointerException();
42 | }
43 | mSurface = surface;
44 | eglSetup();
45 | }
46 |
47 | private void eglSetup() {
48 | mEGLDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
49 | if (mEGLDisplay == EGL14.EGL_NO_DISPLAY) {
50 | throw new RuntimeException("unable to get EGL14 display");
51 | }
52 | int[] version = new int[2];
53 | if (!EGL14.eglInitialize(mEGLDisplay, version, 0, version, 1)) {
54 | mEGLDisplay = null;
55 | throw new RuntimeException("unable to initialize EGL14");
56 | }
57 |
58 | int[] attribList = {
59 | EGL14.EGL_RED_SIZE, 8,
60 | EGL14.EGL_GREEN_SIZE, 8,
61 | EGL14.EGL_BLUE_SIZE, 8,
62 | EGL14.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
63 | EGL_RECORDABLE_ANDROID, 1,
64 | EGL14.EGL_NONE
65 | };
66 | EGLConfig[] configs = new EGLConfig[1];
67 | int[] numConfigs = new int[1];
68 | if (!EGL14.eglChooseConfig(mEGLDisplay, attribList, 0, configs, 0, configs.length,
69 | numConfigs, 0)) {
70 | throw new RuntimeException("unable to find RGB888+recordable ES2 EGL config");
71 | }
72 |
73 | int[] attrib_list = {
74 | EGL14.EGL_CONTEXT_CLIENT_VERSION, 2,
75 | EGL14.EGL_NONE
76 | };
77 |
78 | mEGLContext = EGL14.eglCreateContext(mEGLDisplay, configs[0], EGL14.EGL_NO_CONTEXT, attrib_list, 0);
79 | checkEglError("eglCreateContext");
80 | if (mEGLContext == null) {
81 | throw new RuntimeException("null context");
82 | }
83 |
84 | int[] surfaceAttribs = {
85 | EGL14.EGL_NONE
86 | };
87 | mEGLSurface = EGL14.eglCreateWindowSurface(mEGLDisplay, configs[0], mSurface,
88 | surfaceAttribs, 0);
89 | checkEglError("eglCreateWindowSurface");
90 | if (mEGLSurface == null) {
91 | throw new RuntimeException("surface was null");
92 | }
93 | }
94 |
95 | public void release() {
96 | if (EGL14.eglGetCurrentContext().equals(mEGLContext)) {
97 | EGL14.eglMakeCurrent(mEGLDisplay, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_SURFACE, EGL14.EGL_NO_CONTEXT);
98 | }
99 | EGL14.eglDestroySurface(mEGLDisplay, mEGLSurface);
100 | EGL14.eglDestroyContext(mEGLDisplay, mEGLContext);
101 | mSurface.release();
102 | mEGLDisplay = null;
103 | mEGLContext = null;
104 | mEGLSurface = null;
105 | mSurface = null;
106 | }
107 |
108 | public void makeCurrent() {
109 | if (!EGL14.eglMakeCurrent(mEGLDisplay, mEGLSurface, mEGLSurface, mEGLContext)) {
110 | throw new RuntimeException("eglMakeCurrent failed");
111 | }
112 | }
113 |
114 | public boolean swapBuffers() {
115 | return EGL14.eglSwapBuffers(mEGLDisplay, mEGLSurface);
116 | }
117 |
118 | public Surface getSurface() {
119 | return mSurface;
120 | }
121 |
122 | public void setPresentationTime(long nsecs) {
123 | EGLExt.eglPresentationTimeANDROID(mEGLDisplay, mEGLSurface, nsecs);
124 | }
125 |
126 | private void checkEglError(String msg) {
127 | boolean failed = false;
128 | int error;
129 | while ((error = EGL14.eglGetError()) != EGL14.EGL_SUCCESS) {
130 | failed = true;
131 | }
132 | if (failed) {
133 | throw new RuntimeException("EGL error encountered (see log)");
134 | }
135 | }
136 | }
137 |
--------------------------------------------------------------------------------
/silicompressor/src/main/java/com/iceteck/silicompressorr/videocompression/MP4Builder.java:
--------------------------------------------------------------------------------
1 | /*
2 | * This is the source code of Telegram for Android v. 1.7.x.
3 | * It is licensed under GNU GPL v. 2 or later.
4 | * You should have received a copy of the license in this archive (see LICENSE).
5 | *
6 | * Copyright Nikolai Kudashov, 2013-2014.
7 | */
8 |
9 | package com.iceteck.silicompressorr.videocompression;
10 |
11 | import android.annotation.TargetApi;
12 | import android.media.MediaCodec;
13 | import android.media.MediaFormat;
14 |
15 | import com.coremedia.iso.BoxParser;
16 | import com.coremedia.iso.IsoFile;
17 | import com.coremedia.iso.IsoTypeWriter;
18 | import com.coremedia.iso.boxes.Box;
19 | import com.coremedia.iso.boxes.Container;
20 | import com.coremedia.iso.boxes.DataEntryUrlBox;
21 | import com.coremedia.iso.boxes.DataInformationBox;
22 | import com.coremedia.iso.boxes.DataReferenceBox;
23 | import com.coremedia.iso.boxes.FileTypeBox;
24 | import com.coremedia.iso.boxes.HandlerBox;
25 | import com.coremedia.iso.boxes.MediaBox;
26 | import com.coremedia.iso.boxes.MediaHeaderBox;
27 | import com.coremedia.iso.boxes.MediaInformationBox;
28 | import com.coremedia.iso.boxes.MovieBox;
29 | import com.coremedia.iso.boxes.MovieHeaderBox;
30 | import com.coremedia.iso.boxes.SampleSizeBox;
31 | import com.coremedia.iso.boxes.SampleTableBox;
32 | import com.coremedia.iso.boxes.SampleToChunkBox;
33 | import com.coremedia.iso.boxes.StaticChunkOffsetBox;
34 | import com.coremedia.iso.boxes.SyncSampleBox;
35 | import com.coremedia.iso.boxes.TimeToSampleBox;
36 | import com.coremedia.iso.boxes.TrackBox;
37 | import com.coremedia.iso.boxes.TrackHeaderBox;
38 | import com.googlecode.mp4parser.DataSource;
39 | import com.googlecode.mp4parser.util.Matrix;
40 |
41 | import java.io.FileOutputStream;
42 | import java.io.IOException;
43 | import java.nio.ByteBuffer;
44 | import java.nio.channels.FileChannel;
45 | import java.nio.channels.WritableByteChannel;
46 | import java.util.ArrayList;
47 | import java.util.Date;
48 | import java.util.HashMap;
49 | import java.util.LinkedList;
50 | import java.util.List;
51 |
52 | @TargetApi(16)
53 | public class MP4Builder {
54 |
55 | private InterleaveChunkMdat mdat = null;
56 | private Mp4Movie currentMp4Movie = null;
57 | private FileOutputStream fos = null;
58 | private FileChannel fc = null;
59 | private long dataOffset = 0;
60 | private long writedSinceLastMdat = 0;
61 | private boolean writeNewMdat = true;
62 | private HashMap track2SampleSizes = new HashMap<>();
63 | private ByteBuffer sizeBuffer = null;
64 |
65 | public MP4Builder createMovie(Mp4Movie mp4Movie) throws Exception {
66 | currentMp4Movie = mp4Movie;
67 |
68 | fos = new FileOutputStream(mp4Movie.getCacheFile());
69 | fc = fos.getChannel();
70 |
71 | FileTypeBox fileTypeBox = createFileTypeBox();
72 | fileTypeBox.getBox(fc);
73 | dataOffset += fileTypeBox.getSize();
74 | writedSinceLastMdat += dataOffset;
75 |
76 | mdat = new InterleaveChunkMdat();
77 |
78 | sizeBuffer = ByteBuffer.allocateDirect(4);
79 |
80 | return this;
81 | }
82 |
83 | private void flushCurrentMdat() throws Exception {
84 | long oldPosition = fc.position();
85 | fc.position(mdat.getOffset());
86 | mdat.getBox(fc);
87 | fc.position(oldPosition);
88 | mdat.setDataOffset(0);
89 | mdat.setContentSize(0);
90 | fos.flush();
91 | }
92 |
93 | public boolean writeSampleData(int trackIndex, ByteBuffer byteBuf, MediaCodec.BufferInfo bufferInfo, boolean isAudio) throws Exception {
94 | if (writeNewMdat) {
95 | mdat.setContentSize(0);
96 | mdat.getBox(fc);
97 | mdat.setDataOffset(dataOffset);
98 | dataOffset += 16;
99 | writedSinceLastMdat += 16;
100 | writeNewMdat = false;
101 | }
102 |
103 | mdat.setContentSize(mdat.getContentSize() + bufferInfo.size);
104 | writedSinceLastMdat += bufferInfo.size;
105 |
106 | boolean flush = false;
107 | if (writedSinceLastMdat >= 32 * 1024) {
108 | flushCurrentMdat();
109 | writeNewMdat = true;
110 | flush = true;
111 | writedSinceLastMdat -= 32 * 1024;
112 | }
113 |
114 | currentMp4Movie.addSample(trackIndex, dataOffset, bufferInfo);
115 | byteBuf.position(bufferInfo.offset + (isAudio ? 0 : 4));
116 | byteBuf.limit(bufferInfo.offset + bufferInfo.size);
117 |
118 | if (!isAudio) {
119 | sizeBuffer.position(0);
120 | sizeBuffer.putInt(bufferInfo.size - 4);
121 | sizeBuffer.position(0);
122 | fc.write(sizeBuffer);
123 | }
124 |
125 | fc.write(byteBuf);
126 | dataOffset += bufferInfo.size;
127 |
128 | if (flush) {
129 | fos.flush();
130 | }
131 | return flush;
132 | }
133 |
134 | public int addTrack(MediaFormat mediaFormat, boolean isAudio) throws Exception {
135 | return currentMp4Movie.addTrack(mediaFormat, isAudio);
136 | }
137 |
138 | public void finishMovie(boolean error) throws Exception {
139 | if (mdat.getContentSize() != 0) {
140 | flushCurrentMdat();
141 | }
142 |
143 | for (Track track : currentMp4Movie.getTracks()) {
144 | List samples = track.getSamples();
145 | long[] sizes = new long[samples.size()];
146 | for (int i = 0; i < sizes.length; i++) {
147 | sizes[i] = samples.get(i).getSize();
148 | }
149 | track2SampleSizes.put(track, sizes);
150 | }
151 |
152 | Box moov = createMovieBox(currentMp4Movie);
153 | moov.getBox(fc);
154 | fos.flush();
155 |
156 | fc.close();
157 | fos.close();
158 | }
159 |
160 | protected FileTypeBox createFileTypeBox() {
161 | LinkedList minorBrands = new LinkedList<>();
162 | minorBrands.add("isom");
163 | minorBrands.add("3gp4");
164 | return new FileTypeBox("isom", 0, minorBrands);
165 | }
166 |
167 | private class InterleaveChunkMdat implements Box {
168 | private Container parent;
169 | private long contentSize = 1024 * 1024 * 1024;
170 | private long dataOffset = 0;
171 |
172 | public Container getParent() {
173 | return parent;
174 | }
175 |
176 | public long getOffset() {
177 | return dataOffset;
178 | }
179 |
180 | public void setDataOffset(long offset) {
181 | dataOffset = offset;
182 | }
183 |
184 | public void setParent(Container parent) {
185 | this.parent = parent;
186 | }
187 |
188 | public void setContentSize(long contentSize) {
189 | this.contentSize = contentSize;
190 | }
191 |
192 | public long getContentSize() {
193 | return contentSize;
194 | }
195 |
196 | public String getType() {
197 | return "mdat";
198 | }
199 |
200 | public long getSize() {
201 | return 16 + contentSize;
202 | }
203 |
204 | private boolean isSmallBox(long contentSize) {
205 | return (contentSize + 8) < 4294967296L;
206 | }
207 |
208 | @Override
209 | public void parse(DataSource dataSource, ByteBuffer header, long contentSize, BoxParser boxParser) throws IOException {
210 |
211 | }
212 |
213 | public void getBox(WritableByteChannel writableByteChannel) throws IOException {
214 | ByteBuffer bb = ByteBuffer.allocate(16);
215 | long size = getSize();
216 | if (isSmallBox(size)) {
217 | IsoTypeWriter.writeUInt32(bb, size);
218 | } else {
219 | IsoTypeWriter.writeUInt32(bb, 1);
220 | }
221 | bb.put(IsoFile.fourCCtoBytes("mdat"));
222 | if (isSmallBox(size)) {
223 | bb.put(new byte[8]);
224 | } else {
225 | IsoTypeWriter.writeUInt64(bb, size);
226 | }
227 | bb.rewind();
228 | writableByteChannel.write(bb);
229 | }
230 | }
231 |
232 | public static long gcd(long a, long b) {
233 | if (b == 0) {
234 | return a;
235 | }
236 | return gcd(b, a % b);
237 | }
238 |
239 | public long getTimescale(Mp4Movie mp4Movie) {
240 | long timescale = 0;
241 | if (!mp4Movie.getTracks().isEmpty()) {
242 | timescale = mp4Movie.getTracks().iterator().next().getTimeScale();
243 | }
244 | for (Track track : mp4Movie.getTracks()) {
245 | timescale = gcd(track.getTimeScale(), timescale);
246 | }
247 | return timescale;
248 | }
249 |
250 | protected MovieBox createMovieBox(Mp4Movie movie) {
251 | MovieBox movieBox = new MovieBox();
252 | MovieHeaderBox mvhd = new MovieHeaderBox();
253 |
254 | mvhd.setCreationTime(new Date());
255 | mvhd.setModificationTime(new Date());
256 | mvhd.setMatrix(Matrix.ROTATE_0);
257 | long movieTimeScale = getTimescale(movie);
258 | long duration = 0;
259 |
260 | for (Track track : movie.getTracks()) {
261 | long tracksDuration = track.getDuration() * movieTimeScale / track.getTimeScale();
262 | if (tracksDuration > duration) {
263 | duration = tracksDuration;
264 | }
265 | }
266 |
267 | mvhd.setDuration(duration);
268 | mvhd.setTimescale(movieTimeScale);
269 | mvhd.setNextTrackId(movie.getTracks().size() + 1);
270 |
271 | movieBox.addBox(mvhd);
272 | for (Track track : movie.getTracks()) {
273 | movieBox.addBox(createTrackBox(track, movie));
274 | }
275 | return movieBox;
276 | }
277 |
278 | protected TrackBox createTrackBox(Track track, Mp4Movie movie) {
279 | TrackBox trackBox = new TrackBox();
280 | TrackHeaderBox tkhd = new TrackHeaderBox();
281 |
282 | tkhd.setEnabled(true);
283 | tkhd.setInMovie(true);
284 | tkhd.setInPreview(true);
285 | if (track.isAudio()) {
286 | tkhd.setMatrix(Matrix.ROTATE_0);
287 | } else {
288 | tkhd.setMatrix(movie.getMatrix());
289 | }
290 | tkhd.setAlternateGroup(0);
291 | tkhd.setCreationTime(track.getCreationTime());
292 | tkhd.setDuration(track.getDuration() * getTimescale(movie) / track.getTimeScale());
293 | tkhd.setHeight(track.getHeight());
294 | tkhd.setWidth(track.getWidth());
295 | tkhd.setLayer(0);
296 | tkhd.setModificationTime(new Date());
297 | tkhd.setTrackId(track.getTrackId() + 1);
298 | tkhd.setVolume(track.getVolume());
299 |
300 | trackBox.addBox(tkhd);
301 |
302 | MediaBox mdia = new MediaBox();
303 | trackBox.addBox(mdia);
304 | MediaHeaderBox mdhd = new MediaHeaderBox();
305 | mdhd.setCreationTime(track.getCreationTime());
306 | mdhd.setDuration(track.getDuration());
307 | mdhd.setTimescale(track.getTimeScale());
308 | mdhd.setLanguage("eng");
309 | mdia.addBox(mdhd);
310 | HandlerBox hdlr = new HandlerBox();
311 | hdlr.setName(track.isAudio() ? "SoundHandle" : "VideoHandle");
312 | hdlr.setHandlerType(track.getHandler());
313 |
314 | mdia.addBox(hdlr);
315 |
316 | MediaInformationBox minf = new MediaInformationBox();
317 | minf.addBox(track.getMediaHeaderBox());
318 |
319 | DataInformationBox dinf = new DataInformationBox();
320 | DataReferenceBox dref = new DataReferenceBox();
321 | dinf.addBox(dref);
322 | DataEntryUrlBox url = new DataEntryUrlBox();
323 | url.setFlags(1);
324 | dref.addBox(url);
325 | minf.addBox(dinf);
326 |
327 | Box stbl = createStbl(track);
328 | minf.addBox(stbl);
329 | mdia.addBox(minf);
330 |
331 | return trackBox;
332 | }
333 |
334 | protected Box createStbl(Track track) {
335 | SampleTableBox stbl = new SampleTableBox();
336 |
337 | createStsd(track, stbl);
338 | createStts(track, stbl);
339 | createStss(track, stbl);
340 | createStsc(track, stbl);
341 | createStsz(track, stbl);
342 | createStco(track, stbl);
343 |
344 | return stbl;
345 | }
346 |
347 | protected void createStsd(Track track, SampleTableBox stbl) {
348 | stbl.addBox(track.getSampleDescriptionBox());
349 | }
350 |
351 | protected void createStts(Track track, SampleTableBox stbl) {
352 | TimeToSampleBox.Entry lastEntry = null;
353 | List entries = new ArrayList<>();
354 |
355 | for (long delta : track.getSampleDurations()) {
356 | if (lastEntry != null && lastEntry.getDelta() == delta) {
357 | lastEntry.setCount(lastEntry.getCount() + 1);
358 | } else {
359 | lastEntry = new TimeToSampleBox.Entry(1, delta);
360 | entries.add(lastEntry);
361 | }
362 | }
363 | TimeToSampleBox stts = new TimeToSampleBox();
364 | stts.setEntries(entries);
365 | stbl.addBox(stts);
366 | }
367 |
368 | protected void createStss(Track track, SampleTableBox stbl) {
369 | long[] syncSamples = track.getSyncSamples();
370 | if (syncSamples != null && syncSamples.length > 0) {
371 | SyncSampleBox stss = new SyncSampleBox();
372 | stss.setSampleNumber(syncSamples);
373 | stbl.addBox(stss);
374 | }
375 | }
376 |
377 | protected void createStsc(Track track, SampleTableBox stbl) {
378 | SampleToChunkBox stsc = new SampleToChunkBox();
379 | stsc.setEntries(new LinkedList());
380 |
381 | long lastOffset = -1;
382 | int lastChunkNumber = 1;
383 | int lastSampleCount = 0;
384 |
385 | int previousWritedChunkCount = -1;
386 |
387 | int samplesCount = track.getSamples().size();
388 | for (int a = 0; a < samplesCount; a++) {
389 | Sample sample = track.getSamples().get(a);
390 | long offset = sample.getOffset();
391 | long size = sample.getSize();
392 |
393 | lastOffset = offset + size;
394 | lastSampleCount++;
395 |
396 | boolean write = false;
397 | if (a != samplesCount - 1) {
398 | Sample nextSample = track.getSamples().get(a + 1);
399 | if (lastOffset != nextSample.getOffset()) {
400 | write = true;
401 | }
402 | } else {
403 | write = true;
404 | }
405 | if (write) {
406 | if (previousWritedChunkCount != lastSampleCount) {
407 | stsc.getEntries().add(new SampleToChunkBox.Entry(lastChunkNumber, lastSampleCount, 1));
408 | previousWritedChunkCount = lastSampleCount;
409 | }
410 | lastSampleCount = 0;
411 | lastChunkNumber++;
412 | }
413 | }
414 | stbl.addBox(stsc);
415 | }
416 |
417 | protected void createStsz(Track track, SampleTableBox stbl) {
418 | SampleSizeBox stsz = new SampleSizeBox();
419 | stsz.setSampleSizes(track2SampleSizes.get(track));
420 | stbl.addBox(stsz);
421 | }
422 |
423 | protected void createStco(Track track, SampleTableBox stbl) {
424 | ArrayList chunksOffsets = new ArrayList<>();
425 | long lastOffset = -1;
426 | for (Sample sample : track.getSamples()) {
427 | long offset = sample.getOffset();
428 | if (lastOffset != -1 && lastOffset != offset) {
429 | lastOffset = -1;
430 | }
431 | if (lastOffset == -1) {
432 | chunksOffsets.add(offset);
433 | }
434 | lastOffset = offset + sample.getSize();
435 | }
436 | long[] chunkOffsetsLong = new long[chunksOffsets.size()];
437 | for (int a = 0; a < chunksOffsets.size(); a++) {
438 | chunkOffsetsLong[a] = chunksOffsets.get(a);
439 | }
440 |
441 | StaticChunkOffsetBox stco = new StaticChunkOffsetBox();
442 | stco.setChunkOffsets(chunkOffsetsLong);
443 | stbl.addBox(stco);
444 | }
445 | }
446 |
--------------------------------------------------------------------------------
/silicompressor/src/main/java/com/iceteck/silicompressorr/videocompression/MediaController.java:
--------------------------------------------------------------------------------
1 | package com.iceteck.silicompressorr.videocompression;
2 |
3 | /**
4 | * @Author By Jorge E. Hernandez (@lalongooo) 2015
5 | * @Co-Author Akah Larry (@larrytech7) 2017
6 | */
7 |
8 | import android.annotation.SuppressLint;
9 | import android.annotation.TargetApi;
10 | import android.media.MediaCodec;
11 | import android.media.MediaCodecInfo;
12 | import android.media.MediaCodecList;
13 | import android.media.MediaExtractor;
14 | import android.media.MediaFormat;
15 | import android.media.MediaMetadataRetriever;
16 | import android.os.Build;
17 | import android.util.Log;
18 |
19 | import java.io.File;
20 | import java.io.FileInputStream;
21 | import java.io.FileOutputStream;
22 | import java.io.IOException;
23 | import java.nio.ByteBuffer;
24 | import java.nio.channels.FileChannel;
25 | import java.text.SimpleDateFormat;
26 | import java.util.Date;
27 | import java.util.Locale;
28 |
29 | @SuppressLint("NewApi")
30 | public class MediaController {
31 |
32 | public static File cachedFile;
33 | public String path;
34 |
35 | public final static String MIME_TYPE = "video/avc";
36 | private final static int PROCESSOR_TYPE_OTHER = 0;
37 | private final static int PROCESSOR_TYPE_QCOM = 1;
38 | private final static int PROCESSOR_TYPE_INTEL = 2;
39 | private final static int PROCESSOR_TYPE_MTK = 3;
40 | private final static int PROCESSOR_TYPE_SEC = 4;
41 | private final static int PROCESSOR_TYPE_TI = 5;
42 | private static volatile MediaController Instance = null;
43 | private boolean videoConvertFirstWrite = true;
44 |
45 | //Default values
46 | private final static int DEFAULT_VIDEO_WIDTH = 640;
47 | private final static int DEFAULT_VIDEO_HEIGHT = 360;
48 | private final static int DEFAULT_VIDEO_BITRATE = 450000;
49 |
50 | public static MediaController getInstance() {
51 | MediaController localInstance = Instance;
52 | if (localInstance == null) {
53 | synchronized (MediaController.class) {
54 | localInstance = Instance;
55 | if (localInstance == null) {
56 | Instance = localInstance = new MediaController();
57 | }
58 | }
59 | }
60 | return localInstance;
61 | }
62 |
63 | @SuppressLint("NewApi")
64 | public static int selectColorFormat(MediaCodecInfo codecInfo, String mimeType) {
65 | MediaCodecInfo.CodecCapabilities capabilities = codecInfo.getCapabilitiesForType(mimeType);
66 | int lastColorFormat = 0;
67 | for (int i = 0; i < capabilities.colorFormats.length; i++) {
68 | int colorFormat = capabilities.colorFormats[i];
69 | if (isRecognizedFormat(colorFormat)) {
70 | lastColorFormat = colorFormat;
71 | if (!(codecInfo.getName().equals("OMX.SEC.AVC.Encoder") && colorFormat == 19)) {
72 | return colorFormat;
73 | }
74 | }
75 | }
76 | return lastColorFormat;
77 | }
78 |
79 | private static boolean isRecognizedFormat(int colorFormat) {
80 | switch (colorFormat) {
81 | case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar:
82 | case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedPlanar:
83 | case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar:
84 | case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedSemiPlanar:
85 | case MediaCodecInfo.CodecCapabilities.COLOR_TI_FormatYUV420PackedSemiPlanar:
86 | return true;
87 | default:
88 | return false;
89 | }
90 | }
91 |
92 | public native static int convertVideoFrame(ByteBuffer src, ByteBuffer dest, int destFormat, int width, int height, int padding, int swap);
93 |
94 | private void didWriteData(final boolean last, final boolean error) {
95 | final boolean firstWrite = videoConvertFirstWrite;
96 | if (firstWrite) {
97 | videoConvertFirstWrite = false;
98 | }
99 | }
100 |
101 | public static class VideoConvertRunnable implements Runnable {
102 |
103 | private String videoPath;
104 | private File destDirectory;
105 |
106 | private VideoConvertRunnable(String videoPath, File dest) {
107 | this.videoPath = videoPath;
108 | this.destDirectory = dest;
109 | }
110 |
111 | public static void runConversion(final String videoPath, final File dest) {
112 | new Thread(new Runnable() {
113 | @Override
114 | public void run() {
115 | try {
116 | VideoConvertRunnable wrapper = new VideoConvertRunnable(videoPath, dest);
117 | Thread th = new Thread(wrapper, "VideoConvertRunnable");
118 | th.start();
119 | th.join();
120 | } catch (Exception e) {
121 | Log.e("tmessages", e.getMessage());
122 | }
123 | }
124 | }).start();
125 | }
126 |
127 | @Override
128 | public void run() {
129 | MediaController.getInstance().convertVideo(videoPath, destDirectory);
130 | }
131 | }
132 |
133 | public static MediaCodecInfo selectCodec(String mimeType) {
134 | int numCodecs = MediaCodecList.getCodecCount();
135 | MediaCodecInfo lastCodecInfo = null;
136 | for (int i = 0; i < numCodecs; i++) {
137 | MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);
138 | if (!codecInfo.isEncoder()) {
139 | continue;
140 | }
141 | String[] types = codecInfo.getSupportedTypes();
142 | for (String type : types) {
143 | if (type.equalsIgnoreCase(mimeType)) {
144 | lastCodecInfo = codecInfo;
145 | if (!lastCodecInfo.getName().equals("OMX.SEC.avc.enc")) {
146 | return lastCodecInfo;
147 | } else if (lastCodecInfo.getName().equals("OMX.SEC.AVC.Encoder")) {
148 | return lastCodecInfo;
149 | }
150 | }
151 | }
152 | }
153 | return lastCodecInfo;
154 | }
155 |
156 | /**
157 | * Background conversion for queueing tasks
158 | * @param path source file to compress
159 | * @param dest destination directory to put result
160 | */
161 |
162 | public void scheduleVideoConvert(String path, File dest) {
163 | startVideoConvertFromQueue(path, dest);
164 | }
165 |
166 | private void startVideoConvertFromQueue(String path, File dest) {
167 | VideoConvertRunnable.runConversion(path, dest);
168 | }
169 |
170 | @TargetApi(16)
171 | private long readAndWriteTrack(MediaExtractor extractor, MP4Builder mediaMuxer, MediaCodec.BufferInfo info, long start, long end, File file, boolean isAudio) throws Exception {
172 | int trackIndex = selectTrack(extractor, isAudio);
173 | if (trackIndex >= 0) {
174 | extractor.selectTrack(trackIndex);
175 | MediaFormat trackFormat = extractor.getTrackFormat(trackIndex);
176 | int muxerTrackIndex = mediaMuxer.addTrack(trackFormat, isAudio);
177 | int maxBufferSize = trackFormat.getInteger(MediaFormat.KEY_MAX_INPUT_SIZE);
178 | boolean inputDone = false;
179 | if (start > 0) {
180 | extractor.seekTo(start, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
181 | } else {
182 | extractor.seekTo(0, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
183 | }
184 | ByteBuffer buffer = ByteBuffer.allocateDirect(maxBufferSize);
185 | long startTime = -1;
186 |
187 | while (!inputDone) {
188 |
189 | boolean eof = false;
190 | int index = extractor.getSampleTrackIndex();
191 | if (index == trackIndex) {
192 | info.size = extractor.readSampleData(buffer, 0);
193 |
194 | if (info.size < 0) {
195 | info.size = 0;
196 | eof = true;
197 | } else {
198 | info.presentationTimeUs = extractor.getSampleTime();
199 | if (start > 0 && startTime == -1) {
200 | startTime = info.presentationTimeUs;
201 | }
202 | if (end < 0 || info.presentationTimeUs < end) {
203 | info.offset = 0;
204 | info.flags = extractor.getSampleFlags();
205 | if (mediaMuxer.writeSampleData(muxerTrackIndex, buffer, info, isAudio)) {
206 | // didWriteData(messageObject, file, false, false);
207 | }
208 | extractor.advance();
209 | } else {
210 | eof = true;
211 | }
212 | }
213 | } else if (index == -1) {
214 | eof = true;
215 | }
216 | if (eof) {
217 | inputDone = true;
218 | }
219 | }
220 |
221 | extractor.unselectTrack(trackIndex);
222 | return startTime;
223 | }
224 | return -1;
225 | }
226 |
227 | @TargetApi(16)
228 | private int selectTrack(MediaExtractor extractor, boolean audio) {
229 | int numTracks = extractor.getTrackCount();
230 | for (int i = 0; i < numTracks; i++) {
231 | MediaFormat format = extractor.getTrackFormat(i);
232 | String mime = format.getString(MediaFormat.KEY_MIME);
233 | if (audio) {
234 | if (mime.startsWith("audio/")) {
235 | return i;
236 | }
237 | } else {
238 | if (mime.startsWith("video/")) {
239 | return i;
240 | }
241 | }
242 | }
243 | return -5;
244 | }
245 |
246 | /**
247 | * Perform the actual video compression. Processes the frames and does the magic
248 | * Width, height and bitrate are now default
249 | * @param sourcePath the source uri for the file as per
250 | * @param destDir the destination directory where compressed video is eventually saved
251 | * @return
252 | */
253 | public boolean convertVideo(final String sourcePath, File destDir)
254 | {
255 | return convertVideo( sourcePath, destDir, 0, 0, 0 );
256 | }
257 |
258 | /**
259 | * Perform the actual video compression. Processes the frames and does the magic
260 | * @param sourcePath the source uri for the file as per
261 | * @param destDir the destination directory where compressed video is eventually saved
262 | * @param outWidth the target width of the converted video, 0 is default
263 | * @param outHeight the target height of the converted video, 0 is default
264 | * @param outBitrate the target bitrate of the converted video, 0 is default
265 | * @return
266 | */
267 | @TargetApi(16)
268 | public boolean convertVideo(final String sourcePath, File destDir, int outWidth, int outHeight, int outBitrate) {
269 | this.path=sourcePath;
270 |
271 | MediaMetadataRetriever retriever = new MediaMetadataRetriever();
272 | retriever.setDataSource(path);
273 | String width = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT);
274 | String height = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH);
275 | String rotation = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION);
276 |
277 | long startTime = -1;
278 | long endTime = -1;
279 |
280 | int resultWidth = outWidth > 0 ? outWidth : DEFAULT_VIDEO_WIDTH;
281 | int resultHeight = outHeight > 0 ? outHeight : DEFAULT_VIDEO_HEIGHT;
282 |
283 | int rotationValue = Integer.valueOf(rotation);
284 | int originalWidth = Integer.valueOf(width);
285 | int originalHeight = Integer.valueOf(height);
286 |
287 | int bitrate = outBitrate > 0 ? outBitrate : DEFAULT_VIDEO_BITRATE;
288 | int rotateRender = 0;
289 |
290 | File cacheFile = new File(destDir,
291 | "VIDEO_" + new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.US).format(new Date()) + ".mp4"
292 | );
293 |
294 | if (Build.VERSION.SDK_INT < 18 && resultHeight > resultWidth && resultWidth != originalWidth && resultHeight != originalHeight) {
295 | int temp = resultHeight;
296 | resultHeight = resultWidth;
297 | resultWidth = temp;
298 | rotationValue = 90;
299 | rotateRender = 270;
300 | } else if (Build.VERSION.SDK_INT > 20) {
301 | if (rotationValue == 90) {
302 | int temp = resultHeight;
303 | resultHeight = resultWidth;
304 | resultWidth = temp;
305 | rotationValue = 0;
306 | rotateRender = 270;
307 | } else if (rotationValue == 180) {
308 | rotateRender = 180;
309 | rotationValue = 0;
310 | } else if (rotationValue == 270) {
311 | int temp = resultHeight;
312 | resultHeight = resultWidth;
313 | resultWidth = temp;
314 | rotationValue = 0;
315 | rotateRender = 90;
316 | }
317 | }
318 |
319 |
320 | File inputFile = new File(path);
321 | if (!inputFile.canRead()) {
322 | didWriteData(true, true);
323 | return false;
324 | }
325 |
326 | videoConvertFirstWrite = true;
327 | boolean error = false;
328 | long videoStartTime = startTime;
329 |
330 | long time = System.currentTimeMillis();
331 |
332 | if (resultWidth != 0 && resultHeight != 0) {
333 | MP4Builder mediaMuxer = null;
334 | MediaExtractor extractor = null;
335 |
336 | try {
337 | MediaCodec.BufferInfo info = new MediaCodec.BufferInfo();
338 | Mp4Movie movie = new Mp4Movie();
339 | movie.setCacheFile(cacheFile);
340 | movie.setRotation(rotationValue);
341 | movie.setSize(resultWidth, resultHeight);
342 | mediaMuxer = new MP4Builder().createMovie(movie);
343 | extractor = new MediaExtractor();
344 | extractor.setDataSource(inputFile.toString());
345 |
346 |
347 | if (resultWidth != originalWidth || resultHeight != originalHeight) {
348 | int videoIndex;
349 | videoIndex = selectTrack(extractor, false);
350 |
351 | if (videoIndex >= 0) {
352 | MediaCodec decoder = null;
353 | MediaCodec encoder = null;
354 | InputSurface inputSurface = null;
355 | OutputSurface outputSurface = null;
356 |
357 | try {
358 | long videoTime = -1;
359 | boolean outputDone = false;
360 | boolean inputDone = false;
361 | boolean decoderDone = false;
362 | int swapUV = 0;
363 | int videoTrackIndex = -5;
364 |
365 | int colorFormat;
366 | int processorType = PROCESSOR_TYPE_OTHER;
367 | String manufacturer = Build.MANUFACTURER.toLowerCase();
368 | if (Build.VERSION.SDK_INT < 18) {
369 | MediaCodecInfo codecInfo = selectCodec(MIME_TYPE);
370 | colorFormat = selectColorFormat(codecInfo, MIME_TYPE);
371 | if (colorFormat == 0) {
372 | throw new RuntimeException("no supported color format");
373 | }
374 | String codecName = codecInfo.getName();
375 | if (codecName.contains("OMX.qcom.")) {
376 | processorType = PROCESSOR_TYPE_QCOM;
377 | if (Build.VERSION.SDK_INT == 16) {
378 | if (manufacturer.equals("lge") || manufacturer.equals("nokia")) {
379 | swapUV = 1;
380 | }
381 | }
382 | } else if (codecName.contains("OMX.Intel.")) {
383 | processorType = PROCESSOR_TYPE_INTEL;
384 | } else if (codecName.equals("OMX.MTK.VIDEO.ENCODER.AVC")) {
385 | processorType = PROCESSOR_TYPE_MTK;
386 | } else if (codecName.equals("OMX.SEC.AVC.Encoder")) {
387 | processorType = PROCESSOR_TYPE_SEC;
388 | swapUV = 1;
389 | } else if (codecName.equals("OMX.TI.DUCATI1.VIDEO.H264E")) {
390 | processorType = PROCESSOR_TYPE_TI;
391 | }
392 | Log.e("tmessages", "codec = " + codecInfo.getName() + " manufacturer = " + manufacturer + "device = " + Build.MODEL);
393 | } else {
394 | colorFormat = MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface;
395 | }
396 | Log.e("tmessages", "colorFormat = " + colorFormat);
397 |
398 | int resultHeightAligned = resultHeight;
399 | int padding = 0;
400 | int bufferSize = resultWidth * resultHeight * 3 / 2;
401 | if (processorType == PROCESSOR_TYPE_OTHER) {
402 | if (resultHeight % 16 != 0) {
403 | resultHeightAligned += (16 - (resultHeight % 16));
404 | padding = resultWidth * (resultHeightAligned - resultHeight);
405 | bufferSize += padding * 5 / 4;
406 | }
407 | } else if (processorType == PROCESSOR_TYPE_QCOM) {
408 | if (!manufacturer.toLowerCase().equals("lge")) {
409 | int uvoffset = (resultWidth * resultHeight + 2047) & ~2047;
410 | padding = uvoffset - (resultWidth * resultHeight);
411 | bufferSize += padding;
412 | }
413 | } else if (processorType == PROCESSOR_TYPE_TI) {
414 | //resultHeightAligned = 368;
415 | //bufferSize = resultWidth * resultHeightAligned * 3 / 2;
416 | //resultHeightAligned += (16 - (resultHeight % 16));
417 | //padding = resultWidth * (resultHeightAligned - resultHeight);
418 | //bufferSize += padding * 5 / 4;
419 | } else if (processorType == PROCESSOR_TYPE_MTK) {
420 | if (manufacturer.equals("baidu")) {
421 | resultHeightAligned += (16 - (resultHeight % 16));
422 | padding = resultWidth * (resultHeightAligned - resultHeight);
423 | bufferSize += padding * 5 / 4;
424 | }
425 | }
426 |
427 | extractor.selectTrack(videoIndex);
428 | if (startTime > 0) {
429 | extractor.seekTo(startTime, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
430 | } else {
431 | extractor.seekTo(0, MediaExtractor.SEEK_TO_PREVIOUS_SYNC);
432 | }
433 | MediaFormat inputFormat = extractor.getTrackFormat(videoIndex);
434 |
435 | MediaFormat outputFormat = MediaFormat.createVideoFormat(MIME_TYPE, resultWidth, resultHeight);
436 | outputFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, colorFormat);
437 | outputFormat.setInteger(MediaFormat.KEY_BIT_RATE, bitrate != 0 ? bitrate : 921600);
438 | outputFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 25);
439 | outputFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 10);
440 | if (Build.VERSION.SDK_INT < 18) {
441 | outputFormat.setInteger("stride", resultWidth + 32);
442 | outputFormat.setInteger("slice-height", resultHeight);
443 | }
444 |
445 | encoder = MediaCodec.createEncoderByType(MIME_TYPE);
446 | encoder.configure(outputFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
447 | if (Build.VERSION.SDK_INT >= 18) {
448 | inputSurface = new InputSurface(encoder.createInputSurface());
449 | inputSurface.makeCurrent();
450 | }
451 | encoder.start();
452 |
453 | decoder = MediaCodec.createDecoderByType(inputFormat.getString(MediaFormat.KEY_MIME));
454 | if (Build.VERSION.SDK_INT >= 18) {
455 | outputSurface = new OutputSurface();
456 | } else {
457 | outputSurface = new OutputSurface(resultWidth, resultHeight, rotateRender);
458 | }
459 | decoder.configure(inputFormat, outputSurface.getSurface(), null, 0);
460 | decoder.start();
461 |
462 | final int TIMEOUT_USEC = 2500;
463 | ByteBuffer[] decoderInputBuffers = null;
464 | ByteBuffer[] encoderOutputBuffers = null;
465 | ByteBuffer[] encoderInputBuffers = null;
466 | if (Build.VERSION.SDK_INT < 21) {
467 | decoderInputBuffers = decoder.getInputBuffers();
468 | encoderOutputBuffers = encoder.getOutputBuffers();
469 | if (Build.VERSION.SDK_INT < 18) {
470 | encoderInputBuffers = encoder.getInputBuffers();
471 | }
472 | }
473 |
474 | while (!outputDone) {
475 | if (!inputDone) {
476 | boolean eof = false;
477 | int index = extractor.getSampleTrackIndex();
478 | if (index == videoIndex) {
479 | int inputBufIndex = decoder.dequeueInputBuffer(TIMEOUT_USEC);
480 | if (inputBufIndex >= 0) {
481 | ByteBuffer inputBuf;
482 | if (Build.VERSION.SDK_INT < 21) {
483 | inputBuf = decoderInputBuffers[inputBufIndex];
484 | } else {
485 | inputBuf = decoder.getInputBuffer(inputBufIndex);
486 | }
487 | int chunkSize = extractor.readSampleData(inputBuf, 0);
488 | if (chunkSize < 0) {
489 | decoder.queueInputBuffer(inputBufIndex, 0, 0, 0L, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
490 | inputDone = true;
491 | } else {
492 | decoder.queueInputBuffer(inputBufIndex, 0, chunkSize, extractor.getSampleTime(), 0);
493 | extractor.advance();
494 | }
495 | }
496 | } else if (index == -1) {
497 | eof = true;
498 | }
499 | if (eof) {
500 | int inputBufIndex = decoder.dequeueInputBuffer(TIMEOUT_USEC);
501 | if (inputBufIndex >= 0) {
502 | decoder.queueInputBuffer(inputBufIndex, 0, 0, 0L, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
503 | inputDone = true;
504 | }
505 | }
506 | }
507 |
508 | boolean decoderOutputAvailable = !decoderDone;
509 | boolean encoderOutputAvailable = true;
510 | while (decoderOutputAvailable || encoderOutputAvailable) {
511 | int encoderStatus = encoder.dequeueOutputBuffer(info, TIMEOUT_USEC);
512 | if (encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
513 | encoderOutputAvailable = false;
514 | } else if (encoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
515 | if (Build.VERSION.SDK_INT < 21) {
516 | encoderOutputBuffers = encoder.getOutputBuffers();
517 | }
518 | } else if (encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
519 | MediaFormat newFormat = encoder.getOutputFormat();
520 | if (videoTrackIndex == -5) {
521 | videoTrackIndex = mediaMuxer.addTrack(newFormat, false);
522 | }
523 | } else if (encoderStatus < 0) {
524 | throw new RuntimeException("unexpected result from encoder.dequeueOutputBuffer: " + encoderStatus);
525 | } else {
526 | ByteBuffer encodedData;
527 | if (Build.VERSION.SDK_INT < 21) {
528 | encodedData = encoderOutputBuffers[encoderStatus];
529 | } else {
530 | encodedData = encoder.getOutputBuffer(encoderStatus);
531 | }
532 | if (encodedData == null) {
533 | throw new RuntimeException("encoderOutputBuffer " + encoderStatus + " was null");
534 | }
535 | if (info.size > 1) {
536 | if ((info.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) == 0) {
537 | if (mediaMuxer.writeSampleData(videoTrackIndex, encodedData, info, false)) {
538 | didWriteData(false, false);
539 | }
540 | } else if (videoTrackIndex == -5) {
541 | byte[] csd = new byte[info.size];
542 | encodedData.limit(info.offset + info.size);
543 | encodedData.position(info.offset);
544 | encodedData.get(csd);
545 | ByteBuffer sps = null;
546 | ByteBuffer pps = null;
547 | for (int a = info.size - 1; a >= 0; a--) {
548 | if (a > 3) {
549 | if (csd[a] == 1 && csd[a - 1] == 0 && csd[a - 2] == 0 && csd[a - 3] == 0) {
550 | sps = ByteBuffer.allocate(a - 3);
551 | pps = ByteBuffer.allocate(info.size - (a - 3));
552 | sps.put(csd, 0, a - 3).position(0);
553 | pps.put(csd, a - 3, info.size - (a - 3)).position(0);
554 | break;
555 | }
556 | } else {
557 | break;
558 | }
559 | }
560 |
561 | MediaFormat newFormat = MediaFormat.createVideoFormat(MIME_TYPE, resultWidth, resultHeight);
562 | if (sps != null && pps != null) {
563 | newFormat.setByteBuffer("csd-0", sps);
564 | newFormat.setByteBuffer("csd-1", pps);
565 | }
566 | videoTrackIndex = mediaMuxer.addTrack(newFormat, false);
567 | }
568 | }
569 | outputDone = (info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0;
570 | encoder.releaseOutputBuffer(encoderStatus, false);
571 | }
572 | if (encoderStatus != MediaCodec.INFO_TRY_AGAIN_LATER) {
573 | continue;
574 | }
575 |
576 | if (!decoderDone) {
577 | int decoderStatus = decoder.dequeueOutputBuffer(info, TIMEOUT_USEC);
578 | if (decoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
579 | decoderOutputAvailable = false;
580 | } else if (decoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
581 |
582 | } else if (decoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
583 | MediaFormat newFormat = decoder.getOutputFormat();
584 | Log.e("tmessages", "newFormat = " + newFormat);
585 | } else if (decoderStatus < 0) {
586 | throw new RuntimeException("unexpected result from decoder.dequeueOutputBuffer: " + decoderStatus);
587 | } else {
588 | boolean doRender;
589 | if (Build.VERSION.SDK_INT >= 18) {
590 | doRender = info.size != 0;
591 | } else {
592 | doRender = info.size != 0 || info.presentationTimeUs != 0;
593 | }
594 | if (endTime > 0 && info.presentationTimeUs >= endTime) {
595 | inputDone = true;
596 | decoderDone = true;
597 | doRender = false;
598 | info.flags |= MediaCodec.BUFFER_FLAG_END_OF_STREAM;
599 | }
600 | if (startTime > 0 && videoTime == -1) {
601 | if (info.presentationTimeUs < startTime) {
602 | doRender = false;
603 | Log.e("tmessages", "drop frame startTime = " + startTime + " present time = " + info.presentationTimeUs);
604 | } else {
605 | videoTime = info.presentationTimeUs;
606 | }
607 | }
608 | decoder.releaseOutputBuffer(decoderStatus, doRender);
609 | if (doRender) {
610 | boolean errorWait = false;
611 | try {
612 | outputSurface.awaitNewImage();
613 | } catch (Exception e) {
614 | errorWait = true;
615 | Log.e("tmessages", e.getMessage());
616 | }
617 | if (!errorWait) {
618 | if (Build.VERSION.SDK_INT >= 18) {
619 | outputSurface.drawImage(false);
620 | inputSurface.setPresentationTime(info.presentationTimeUs * 1000);
621 | inputSurface.swapBuffers();
622 | } else {
623 | int inputBufIndex = encoder.dequeueInputBuffer(TIMEOUT_USEC);
624 | if (inputBufIndex >= 0) {
625 | outputSurface.drawImage(true);
626 | ByteBuffer rgbBuf = outputSurface.getFrame();
627 | ByteBuffer yuvBuf = encoderInputBuffers[inputBufIndex];
628 | yuvBuf.clear();
629 | convertVideoFrame(rgbBuf, yuvBuf, colorFormat, resultWidth, resultHeight, padding, swapUV);
630 | encoder.queueInputBuffer(inputBufIndex, 0, bufferSize, info.presentationTimeUs, 0);
631 | } else {
632 | Log.e("tmessages", "input buffer not available");
633 | }
634 | }
635 | }
636 | }
637 | if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
638 | decoderOutputAvailable = false;
639 | Log.e("tmessages", "decoder stream end");
640 | if (Build.VERSION.SDK_INT >= 18) {
641 | encoder.signalEndOfInputStream();
642 | } else {
643 | int inputBufIndex = encoder.dequeueInputBuffer(TIMEOUT_USEC);
644 | if (inputBufIndex >= 0) {
645 | encoder.queueInputBuffer(inputBufIndex, 0, 1, info.presentationTimeUs, MediaCodec.BUFFER_FLAG_END_OF_STREAM);
646 | }
647 | }
648 | }
649 | }
650 | }
651 | }
652 | }
653 | if (videoTime != -1) {
654 | videoStartTime = videoTime;
655 | }
656 | } catch (Exception e) {
657 | Log.e("tmessages", e.getMessage());
658 | error = true;
659 | }
660 |
661 | extractor.unselectTrack(videoIndex);
662 |
663 | if (outputSurface != null) {
664 | outputSurface.release();
665 | }
666 | if (inputSurface != null) {
667 | inputSurface.release();
668 | }
669 | if (decoder != null) {
670 | decoder.stop();
671 | decoder.release();
672 | }
673 | if (encoder != null) {
674 | encoder.stop();
675 | encoder.release();
676 | }
677 | }
678 | } else {
679 | long videoTime = readAndWriteTrack(extractor, mediaMuxer, info, startTime, endTime, cacheFile, false);
680 | if (videoTime != -1) {
681 | videoStartTime = videoTime;
682 | }
683 | }
684 | if (!error) {
685 | readAndWriteTrack(extractor, mediaMuxer, info, videoStartTime, endTime, cacheFile, true);
686 | }
687 | } catch (Exception e) {
688 | error = true;
689 | Log.e("tmessages", e.getMessage());
690 | } finally {
691 | if (extractor != null) {
692 | extractor.release();
693 | }
694 | if (mediaMuxer != null) {
695 | try {
696 | mediaMuxer.finishMovie(false);
697 | } catch (Exception e) {
698 | Log.e("tmessages", e.getMessage());
699 | }
700 | }
701 | Log.e("tmessages", "time = " + (System.currentTimeMillis() - time));
702 | }
703 | } else {
704 | didWriteData(true, true);
705 | return false;
706 | }
707 | didWriteData(true, error);
708 |
709 | cachedFile=cacheFile;
710 |
711 | /* File fdelete = inputFile;
712 | if (fdelete.exists()) {
713 | if (fdelete.delete()) {
714 | Log.e("file Deleted :" ,inputFile.getPath());
715 | } else {
716 | Log.e("file not Deleted :" , inputFile.getPath());
717 | }
718 | }*/
719 |
720 | //inputFile.delete();
721 | Log.e("ViratPath",path+"");
722 | Log.e("ViratPath",cacheFile.getPath()+"");
723 | Log.e("ViratPath",inputFile.getPath()+"");
724 |
725 |
726 | /* Log.e("ViratPath",path+"");
727 | File replacedFile = new File(path);
728 |
729 | FileOutputStream fos = null;
730 | InputStream inputStream = null;
731 | try {
732 | fos = new FileOutputStream(replacedFile);
733 | inputStream = new FileInputStream(cacheFile);
734 | byte[] buf = new byte[1024];
735 | int len;
736 | while ((len = inputStream.read(buf)) > 0) {
737 | fos.write(buf, 0, len);
738 | }
739 | inputStream.close();
740 | fos.close();
741 |
742 | } catch (FileNotFoundException e) {
743 | e.printStackTrace();
744 | } catch (IOException e) {
745 | e.printStackTrace();
746 | }
747 | */
748 |
749 | // cacheFile.delete();
750 |
751 | /* try {
752 | // copyFile(cacheFile,inputFile);
753 | //inputFile.delete();
754 | FileUtils.copyFile(cacheFile,inputFile);
755 | } catch (IOException e) {
756 | e.printStackTrace();
757 | }*/
758 | // cacheFile.delete();
759 | // inputFile.delete();
760 | return true;
761 | }
762 |
763 | public static void copyFile(File src, File dst) throws IOException
764 | {
765 | FileChannel inChannel = new FileInputStream(src).getChannel();
766 | FileChannel outChannel = new FileOutputStream(dst).getChannel();
767 | try
768 | {
769 | inChannel.transferTo(1, inChannel.size(), outChannel);
770 | }
771 | finally
772 | {
773 | if (inChannel != null)
774 | inChannel.close();
775 | if (outChannel != null)
776 | outChannel.close();
777 | }
778 | }
779 | }
--------------------------------------------------------------------------------
/silicompressor/src/main/java/com/iceteck/silicompressorr/videocompression/Mp4Movie.java:
--------------------------------------------------------------------------------
1 | /*
2 | * This is the source code of Telegram for Android v. 1.7.x.
3 | * It is licensed under GNU GPL v. 2 or later.
4 | * You should have received a copy of the license in this archive (see LICENSE).
5 | *
6 | * Copyright Nikolai Kudashov, 2013-2014.
7 | */
8 |
9 | package com.iceteck.silicompressorr.videocompression;
10 |
11 | import android.annotation.TargetApi;
12 | import android.media.MediaCodec;
13 | import android.media.MediaFormat;
14 |
15 | import com.googlecode.mp4parser.util.Matrix;
16 |
17 | import java.io.File;
18 | import java.util.ArrayList;
19 |
20 | @TargetApi(16)
21 | public class Mp4Movie {
22 | private Matrix matrix = Matrix.ROTATE_0;
23 | private ArrayList