├── .idea
├── .name
├── copyright
│ └── profiles_settings.xml
├── encodings.xml
├── vcs.xml
├── modules.xml
├── libraries
│ ├── glide_3_7_0.xml
│ ├── support_annotations_23_0_0.xml
│ ├── appcompat_v7_23_0_0.xml
│ └── support_v4_23_0_0.xml
├── runConfigurations.xml
├── compiler.xml
├── gradle.xml
└── misc.xml
├── app
├── .gitignore
├── src
│ ├── main
│ │ ├── res
│ │ │ ├── raw
│ │ │ │ └── kof_13.mp4
│ │ │ ├── mipmap-hdpi
│ │ │ │ └── ic_launcher.png
│ │ │ ├── mipmap-mdpi
│ │ │ │ └── ic_launcher.png
│ │ │ ├── mipmap-xhdpi
│ │ │ │ └── ic_launcher.png
│ │ │ ├── mipmap-xxhdpi
│ │ │ │ └── ic_launcher.png
│ │ │ ├── values
│ │ │ │ ├── strings.xml
│ │ │ │ ├── styles.xml
│ │ │ │ └── dimens.xml
│ │ │ ├── menu
│ │ │ │ └── menu_main.xml
│ │ │ ├── values-w820dp
│ │ │ │ └── dimens.xml
│ │ │ └── layout
│ │ │ │ └── activity_main.xml
│ │ ├── AndroidManifest.xml
│ │ └── java
│ │ │ └── com
│ │ │ └── beak
│ │ │ └── gifmaker
│ │ │ ├── MainActivity.java
│ │ │ └── GifMakeService.java
│ └── androidTest
│ │ └── java
│ │ └── com
│ │ └── beak
│ │ └── gifmaker
│ │ └── ApplicationTest.java
├── proguard-rules.pro
├── build.gradle
└── app.iml
├── gifmakerlib
├── .gitignore
├── src
│ ├── main
│ │ ├── res
│ │ │ └── values
│ │ │ │ └── strings.xml
│ │ ├── AndroidManifest.xml
│ │ └── java
│ │ │ └── com
│ │ │ └── beak
│ │ │ └── gifmakerlib
│ │ │ ├── GifMaker.java
│ │ │ └── AnimatedGifEncoder.java
│ └── androidTest
│ │ └── java
│ │ └── com
│ │ └── beak
│ │ └── gifmakerlib
│ │ └── ApplicationTest.java
├── build.gradle
├── proguard-rules.pro
└── gifmakerlib.iml
├── settings.gradle
├── demo_pic.png
├── make_this_gif.gif
├── gradle
└── wrapper
│ ├── gradle-wrapper.jar
│ └── gradle-wrapper.properties
├── .gitattributes
├── readme.md
├── gradle.properties
├── GifMaker.iml
├── .gitignore
├── gradlew.bat
└── gradlew
/.idea/.name:
--------------------------------------------------------------------------------
1 | GifMaker
--------------------------------------------------------------------------------
/app/.gitignore:
--------------------------------------------------------------------------------
1 | /build
2 |
--------------------------------------------------------------------------------
/gifmakerlib/.gitignore:
--------------------------------------------------------------------------------
1 | /build
2 |
--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | include ':app', ':gifmakerlib'
2 |
--------------------------------------------------------------------------------
/demo_pic.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boybeak/GifMaker/HEAD/demo_pic.png
--------------------------------------------------------------------------------
/make_this_gif.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boybeak/GifMaker/HEAD/make_this_gif.gif
--------------------------------------------------------------------------------
/app/src/main/res/raw/kof_13.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boybeak/GifMaker/HEAD/app/src/main/res/raw/kof_13.mp4
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boybeak/GifMaker/HEAD/gradle/wrapper/gradle-wrapper.jar
--------------------------------------------------------------------------------
/.idea/copyright/profiles_settings.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/gifmakerlib/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 |
2 | GifMakerLib
3 |
4 |
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-hdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boybeak/GifMaker/HEAD/app/src/main/res/mipmap-hdpi/ic_launcher.png
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-mdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boybeak/GifMaker/HEAD/app/src/main/res/mipmap-mdpi/ic_launcher.png
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boybeak/GifMaker/HEAD/app/src/main/res/mipmap-xhdpi/ic_launcher.png
--------------------------------------------------------------------------------
/app/src/main/res/mipmap-xxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/boybeak/GifMaker/HEAD/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
--------------------------------------------------------------------------------
/.idea/encodings.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/app/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 |
2 | GifMaker
3 |
4 | Hello world!
5 | Settings
6 |
7 |
--------------------------------------------------------------------------------
/app/src/main/res/values/styles.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/app/src/main/res/values/dimens.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | 16dp
4 | 16dp
5 |
6 |
--------------------------------------------------------------------------------
/gifmakerlib/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | #Thu Mar 16 13:23:39 CST 2017
2 | distributionBase=GRADLE_USER_HOME
3 | distributionPath=wrapper/dists
4 | zipStoreBase=GRADLE_USER_HOME
5 | zipStorePath=wrapper/dists
6 | distributionUrl=https\://services.gradle.org/distributions/gradle-3.3-all.zip
7 |
--------------------------------------------------------------------------------
/app/src/main/res/menu/menu_main.xml:
--------------------------------------------------------------------------------
1 |
7 |
--------------------------------------------------------------------------------
/app/src/main/res/values-w820dp/dimens.xml:
--------------------------------------------------------------------------------
1 |
2 |
5 | 64dp
6 |
7 |
--------------------------------------------------------------------------------
/app/src/androidTest/java/com/beak/gifmaker/ApplicationTest.java:
--------------------------------------------------------------------------------
1 | package com.beak.gifmaker;
2 |
3 | import android.app.Application;
4 | import android.test.ApplicationTestCase;
5 |
6 | /**
7 | * Testing Fundamentals
8 | */
9 | public class ApplicationTest extends ApplicationTestCase {
10 | public ApplicationTest() {
11 | super(Application.class);
12 | }
13 | }
--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
1 | # Auto detect text files and perform LF normalization
2 | * text=auto
3 |
4 | # Custom for Visual Studio
5 | *.cs diff=csharp
6 |
7 | # Standard to msysgit
8 | *.doc diff=astextplain
9 | *.DOC diff=astextplain
10 | *.docx diff=astextplain
11 | *.DOCX diff=astextplain
12 | *.dot diff=astextplain
13 | *.DOT diff=astextplain
14 | *.pdf diff=astextplain
15 | *.PDF diff=astextplain
16 | *.rtf diff=astextplain
17 | *.RTF diff=astextplain
18 |
--------------------------------------------------------------------------------
/gifmakerlib/src/androidTest/java/com/beak/gifmakerlib/ApplicationTest.java:
--------------------------------------------------------------------------------
1 | package com.beak.gifmakerlib;
2 |
3 | import android.app.Application;
4 | import android.test.ApplicationTestCase;
5 |
6 | /**
7 | * Testing Fundamentals
8 | */
9 | public class ApplicationTest extends ApplicationTestCase {
10 | public ApplicationTest() {
11 | super(Application.class);
12 | }
13 | }
--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
1 | # GifMaker
2 |
3 | This demo shows how to make a gif from a local video.
4 |
5 | the result is like this below:
6 |
7 | 
8 |
9 | The project runs like this below:
10 |
11 | 
`
12 |
13 |
--------------------------------------------------------------------------------
/.idea/modules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
--------------------------------------------------------------------------------
/.idea/libraries/glide_3_7_0.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/.idea/libraries/support_annotations_23_0_0.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/.idea/runConfigurations.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
11 |
12 |
--------------------------------------------------------------------------------
/.idea/libraries/appcompat_v7_23_0_0.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
--------------------------------------------------------------------------------
/gifmakerlib/build.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: 'com.android.library'
2 |
3 | android {
4 | compileSdkVersion 23
5 | buildToolsVersion '25.0.0'
6 |
7 | defaultConfig {
8 | minSdkVersion 16
9 | targetSdkVersion 23
10 | versionCode 1
11 | versionName "1.0"
12 | }
13 | buildTypes {
14 | release {
15 | minifyEnabled false
16 | proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
17 | }
18 | }
19 | }
20 |
21 | dependencies {
22 | compile fileTree(dir: 'libs', include: ['*.jar'])
23 | compile 'com.android.support:appcompat-v7:23.0.0'
24 | }
25 |
--------------------------------------------------------------------------------
/app/proguard-rules.pro:
--------------------------------------------------------------------------------
1 | # Add project specific ProGuard rules here.
2 | # By default, the flags in this file are appended to flags specified
3 | # in C:\Android\sdk/tools/proguard/proguard-android.txt
4 | # You can edit the include path and order by changing the proguardFiles
5 | # directive in build.gradle.
6 | #
7 | # For more details, see
8 | # http://developer.android.com/guide/developing/tools/proguard.html
9 |
10 | # Add any project specific keep options here:
11 |
12 | # If your project uses WebView with JS, uncomment the following
13 | # and specify the fully qualified class name to the JavaScript interface
14 | # class:
15 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
16 | # public *;
17 | #}
18 |
--------------------------------------------------------------------------------
/gifmakerlib/proguard-rules.pro:
--------------------------------------------------------------------------------
1 | # Add project specific ProGuard rules here.
2 | # By default, the flags in this file are appended to flags specified
3 | # in C:\Android\sdk/tools/proguard/proguard-android.txt
4 | # You can edit the include path and order by changing the proguardFiles
5 | # directive in build.gradle.
6 | #
7 | # For more details, see
8 | # http://developer.android.com/guide/developing/tools/proguard.html
9 |
10 | # Add any project specific keep options here:
11 |
12 | # If your project uses WebView with JS, uncomment the following
13 | # and specify the fully qualified class name to the JavaScript interface
14 | # class:
15 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
16 | # public *;
17 | #}
18 |
--------------------------------------------------------------------------------
/.idea/libraries/support_v4_23_0_0.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
--------------------------------------------------------------------------------
/.idea/compiler.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
--------------------------------------------------------------------------------
/app/build.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: 'com.android.application'
2 |
3 | android {
4 | compileSdkVersion 23
5 | buildToolsVersion '25.0.0'
6 |
7 | defaultConfig {
8 | applicationId "com.beak.gifmaker"
9 | minSdkVersion 16
10 | targetSdkVersion 23
11 | versionCode 1
12 | versionName "1.0"
13 | }
14 | buildTypes {
15 | release {
16 | minifyEnabled false
17 | proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
18 | }
19 | }
20 | }
21 |
22 | dependencies {
23 | compile fileTree(include: ['*.jar'], dir: 'libs')
24 | compile 'com.android.support:appcompat-v7:23.0.0'
25 | compile project(':gifmakerlib')
26 | compile 'com.github.bumptech.glide:glide:3.7.0'
27 | }
28 |
--------------------------------------------------------------------------------
/.idea/gradle.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
20 |
21 |
--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
1 | # Project-wide Gradle settings.
2 |
3 | # IDE (e.g. Android Studio) users:
4 | # Gradle settings configured through the IDE *will override*
5 | # any settings specified in this file.
6 |
7 | # For more details on how to configure your build environment visit
8 | # http://www.gradle.org/docs/current/userguide/build_environment.html
9 |
10 | # Specifies the JVM arguments used for the daemon process.
11 | # The setting is particularly useful for tweaking memory settings.
12 | # Default value: -Xmx10248m -XX:MaxPermSize=256m
13 | # org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
14 |
15 | # When configured, Gradle will run in incubating parallel mode.
16 | # This option should only be used with decoupled projects. More details, visit
17 | # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
18 | # org.gradle.parallel=true
--------------------------------------------------------------------------------
/app/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
6 |
7 |
12 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
25 |
26 |
27 |
--------------------------------------------------------------------------------
/GifMaker.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Built application files
2 | *.apk
3 | *.ap_
4 |
5 | # Files for the Dalvik VM
6 | *.dex
7 |
8 | # Java class files
9 | *.class
10 |
11 | # Generated files
12 | bin/
13 | gen/
14 |
15 | # Gradle files
16 | .gradle/
17 | build/
18 |
19 | # Local configuration file (sdk path, etc)
20 | local.properties
21 |
22 | # Proguard folder generated by Eclipse
23 | proguard/
24 |
25 | # Log Files
26 | *.log
27 |
28 | # =========================
29 | # Operating System Files
30 | # =========================
31 |
32 | # OSX
33 | # =========================
34 |
35 | .DS_Store
36 | .AppleDouble
37 | .LSOverride
38 |
39 | # Thumbnails
40 | ._*
41 |
42 | # Files that might appear on external disk
43 | .Spotlight-V100
44 | .Trashes
45 |
46 | # Directories potentially created on remote AFP share
47 | .AppleDB
48 | .AppleDesktop
49 | Network Trash Folder
50 | Temporary Items
51 | .apdisk
52 |
53 | # Windows
54 | # =========================
55 |
56 | # Windows image file caches
57 | Thumbs.db
58 | ehthumbs.db
59 |
60 | # Folder config file
61 | Desktop.ini
62 |
63 | # Recycle Bin used on file shares
64 | $RECYCLE.BIN/
65 |
66 | # Windows Installer files
67 | *.cab
68 | *.msi
69 | *.msm
70 | *.msp
71 |
72 | # Windows shortcuts
73 | *.lnk
74 |
--------------------------------------------------------------------------------
/app/src/main/res/layout/activity_main.xml:
--------------------------------------------------------------------------------
1 |
6 |
12 |
17 |
21 |
25 |
29 |
30 |
31 |
32 |
33 |
--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
19 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
1 | @if "%DEBUG%" == "" @echo off
2 | @rem ##########################################################################
3 | @rem
4 | @rem Gradle startup script for Windows
5 | @rem
6 | @rem ##########################################################################
7 |
8 | @rem Set local scope for the variables with windows NT shell
9 | if "%OS%"=="Windows_NT" setlocal
10 |
11 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
12 | set DEFAULT_JVM_OPTS=
13 |
14 | set DIRNAME=%~dp0
15 | if "%DIRNAME%" == "" set DIRNAME=.
16 | set APP_BASE_NAME=%~n0
17 | set APP_HOME=%DIRNAME%
18 |
19 | @rem Find java.exe
20 | if defined JAVA_HOME goto findJavaFromJavaHome
21 |
22 | set JAVA_EXE=java.exe
23 | %JAVA_EXE% -version >NUL 2>&1
24 | if "%ERRORLEVEL%" == "0" goto init
25 |
26 | echo.
27 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
28 | echo.
29 | echo Please set the JAVA_HOME variable in your environment to match the
30 | echo location of your Java installation.
31 |
32 | goto fail
33 |
34 | :findJavaFromJavaHome
35 | set JAVA_HOME=%JAVA_HOME:"=%
36 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
37 |
38 | if exist "%JAVA_EXE%" goto init
39 |
40 | echo.
41 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
42 | echo.
43 | echo Please set the JAVA_HOME variable in your environment to match the
44 | echo location of your Java installation.
45 |
46 | goto fail
47 |
48 | :init
49 | @rem Get command-line arguments, handling Windowz variants
50 |
51 | if not "%OS%" == "Windows_NT" goto win9xME_args
52 | if "%@eval[2+2]" == "4" goto 4NT_args
53 |
54 | :win9xME_args
55 | @rem Slurp the command line arguments.
56 | set CMD_LINE_ARGS=
57 | set _SKIP=2
58 |
59 | :win9xME_args_slurp
60 | if "x%~1" == "x" goto execute
61 |
62 | set CMD_LINE_ARGS=%*
63 | goto execute
64 |
65 | :4NT_args
66 | @rem Get arguments from the 4NT Shell from JP Software
67 | set CMD_LINE_ARGS=%$
68 |
69 | :execute
70 | @rem Setup the command line
71 |
72 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
73 |
74 | @rem Execute Gradle
75 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
76 |
77 | :end
78 | @rem End local scope for the variables with windows NT shell
79 | if "%ERRORLEVEL%"=="0" goto mainEnd
80 |
81 | :fail
82 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
83 | rem the _cmd.exe /c_ return code!
84 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
85 | exit /b 1
86 |
87 | :mainEnd
88 | if "%OS%"=="Windows_NT" endlocal
89 |
90 | :omega
91 |
--------------------------------------------------------------------------------
/app/src/main/java/com/beak/gifmaker/MainActivity.java:
--------------------------------------------------------------------------------
1 | package com.beak.gifmaker;
2 |
3 | import android.Manifest;
4 | import android.content.BroadcastReceiver;
5 | import android.content.Context;
6 | import android.content.Intent;
7 | import android.content.IntentFilter;
8 | import android.content.pm.PackageManager;
9 | import android.os.Environment;
10 | import android.support.annotation.NonNull;
11 | import android.support.v4.app.ActivityCompat;
12 | import android.support.v4.content.ContextCompat;
13 | import android.support.v4.content.LocalBroadcastManager;
14 | import android.support.v7.app.AppCompatActivity;
15 | import android.os.Bundle;
16 | import android.view.View;
17 | import android.widget.Button;
18 | import android.widget.ImageView;
19 | import android.widget.TextView;
20 |
21 | import com.bumptech.glide.Glide;
22 |
23 | import java.io.File;
24 |
25 | public class MainActivity extends AppCompatActivity {
26 |
27 | private static final String TAG = MainActivity.class.getSimpleName();
28 |
29 | private Button mMainBtn;
30 | private TextView mLogTv;
31 | private ImageView mShowCaseIv;
32 |
33 | private BroadcastReceiver mReceiver = new BroadcastReceiver() {
34 | @Override
35 | public void onReceive(Context context, Intent intent) {
36 | mLogTv.append(intent.getStringExtra("log") + "\n");
37 | boolean success = intent.getBooleanExtra(GifMakeService.EXTRA_SUCCESS, false);
38 | if (success) {
39 | mLogTv.append("trying to show this gif");
40 | String file = intent.getStringExtra(GifMakeService.EXTRA_FILE);
41 | Glide.with(MainActivity.this).load(new File(file)).asGif().placeholder(android.R.color.holo_green_dark).into(mShowCaseIv);
42 | }
43 | }
44 | };
45 |
46 | @Override
47 | protected void onCreate(Bundle savedInstanceState) {
48 | super.onCreate(savedInstanceState);
49 | setContentView(R.layout.activity_main);
50 |
51 | mMainBtn = (Button)findViewById(R.id.main_start_btn);
52 | mLogTv = (TextView)findViewById(R.id.main_log_tv);
53 | mShowCaseIv = (ImageView)findViewById(R.id.show_case);
54 |
55 | mMainBtn.setOnClickListener(new View.OnClickListener() {
56 | @Override
57 | public void onClick(View v) {
58 | if (PackageManager.PERMISSION_GRANTED !=
59 | ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE)) {
60 | ActivityCompat.requestPermissions(MainActivity.this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 100);
61 | } else {
62 | tryMake();
63 | }
64 | }
65 | });
66 |
67 | LocalBroadcastManager.getInstance(this).registerReceiver(mReceiver, new IntentFilter(GifMakeService.ACTION_MAKE_GIF));
68 | }
69 |
70 | @Override
71 | protected void onDestroy() {
72 | super.onDestroy();
73 | LocalBroadcastManager.getInstance(this).unregisterReceiver(mReceiver);
74 | }
75 |
76 | @Override
77 | public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
78 | super.onRequestPermissionsResult(requestCode, permissions, grantResults);
79 | if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
80 | tryMake();
81 | }
82 | }
83 |
84 | private void tryMake () {
85 | final File file = new File(Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator + "Movies" + File.separator + "0.gif");
86 | GifMakeService.startMaking(this, "android.resource://" + getPackageName() + "/" + R.raw.kof_13, file.getAbsolutePath(), 0, 10 * 1000, 200);
87 | }
88 |
89 | }
90 |
--------------------------------------------------------------------------------
/app/src/main/java/com/beak/gifmaker/GifMakeService.java:
--------------------------------------------------------------------------------
1 | package com.beak.gifmaker;
2 |
3 | import android.app.IntentService;
4 | import android.content.Intent;
5 | import android.content.Context;
6 | import android.net.Uri;
7 | import android.support.v4.content.LocalBroadcastManager;
8 | import android.util.Log;
9 |
10 | import com.beak.gifmakerlib.GifMaker;
11 |
12 | public class GifMakeService extends IntentService {
13 | // IntentService can perform, e.g. ACTION_FETCH_NEW_ITEMS
14 | public static final String ACTION_MAKE_GIF = "com.beak.gifmaker.action.MAKE_GIF";
15 |
16 | private static final String EXTRA_FROM_FILE = "com.beak.gifmaker.extra.FROM_FILE";
17 | private static final String EXTRA_TO_FILE = "com.beak.gifmaker.extra.TO_FILE";
18 | private static final String EXTRA_FROM_POSITION = "com.beak.gifmaker.extra.FROM_POSITION";
19 | private static final String EXTRA_TO_POSITION = "com.beak.gifmaker.extra.TO_POSITION";
20 | private static final String EXTRA_PERIOD = "com.beak.gifmaker.extra.PERIOD";
21 |
22 | public static final String EXTRA_FILE = "file", EXTRA_SUCCESS = "success";
23 |
24 | public GifMakeService() {
25 | super("GifMakeService");
26 | }
27 |
28 | /**
29 | * Starts this service to perform action Foo with the given parameters. If
30 | * the service is already performing a task this action will be queued.
31 | *
32 | * @see IntentService
33 | */
34 | public static void startMaking(Context context, String fromFile, String toFile, int fromPosition, int toPosition, int period) {
35 | Intent intent = new Intent(context, GifMakeService.class);
36 | intent.setAction(ACTION_MAKE_GIF);
37 | intent.putExtra(EXTRA_FROM_FILE, fromFile);
38 | intent.putExtra(EXTRA_TO_FILE, toFile);
39 | intent.putExtra(EXTRA_FROM_POSITION, fromPosition);
40 | intent.putExtra(EXTRA_TO_POSITION, toPosition);
41 | intent.putExtra(EXTRA_PERIOD, period);
42 | context.startService(intent);
43 | }
44 |
45 | @Override
46 | protected void onHandleIntent(Intent intent) {
47 | if (intent != null) {
48 | final String action = intent.getAction();
49 | if (ACTION_MAKE_GIF.equals(action)) {
50 | final String fromFile = intent.getStringExtra(EXTRA_FROM_FILE);
51 | final String toFile = intent.getStringExtra(EXTRA_TO_FILE);
52 | final int fromPosition = intent.getIntExtra(EXTRA_FROM_POSITION, 0);
53 | final int toPosition = intent.getIntExtra(EXTRA_TO_POSITION, 0);
54 | final int period = intent.getIntExtra(EXTRA_PERIOD, 200);
55 | handleTask(fromFile, toFile, fromPosition, toPosition, period);
56 | }
57 | }
58 | }
59 |
60 | /**
61 | * Handle action Foo in the provided background thread with the provided
62 | * parameters.
63 | */
64 | private void handleTask(String fromFile, String toFile, int fromPosition, int toPosition, int period) {
65 | GifMaker maker = new GifMaker(2);
66 | maker.setOnGifListener(new GifMaker.OnGifListener() {
67 | @Override
68 | public void onMake(int current, int total) {
69 | LocalBroadcastManager.getInstance(GifMakeService.this).sendBroadcast(new Intent(ACTION_MAKE_GIF).putExtra("log", "executing " + current + "/" + total));
70 | }
71 | });
72 | long startAt = System.currentTimeMillis();
73 | LocalBroadcastManager.getInstance(this).sendBroadcast(new Intent(ACTION_MAKE_GIF).putExtra("log", "start making at " + startAt));
74 | final boolean success = maker.makeGifFromVideo(this, Uri.parse(fromFile), fromPosition, toPosition, period, toFile);
75 | long now = System.currentTimeMillis();
76 | LocalBroadcastManager.getInstance(GifMakeService.this).sendBroadcast(new Intent(ACTION_MAKE_GIF)
77 | .putExtra("log", "Done! " + (success ? " success " : " failed ") + " cost time=" + ((now - startAt)/1000) + " seconds "
78 | + " \nsave at=" + toFile)
79 | .putExtra(EXTRA_FILE, toFile)
80 | .putExtra(EXTRA_SUCCESS, true));
81 | }
82 | }
83 |
--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | ##############################################################################
4 | ##
5 | ## Gradle start up script for UN*X
6 | ##
7 | ##############################################################################
8 |
9 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
10 | DEFAULT_JVM_OPTS=""
11 |
12 | APP_NAME="Gradle"
13 | APP_BASE_NAME=`basename "$0"`
14 |
15 | # Use the maximum available, or set MAX_FD != -1 to use that value.
16 | MAX_FD="maximum"
17 |
18 | warn ( ) {
19 | echo "$*"
20 | }
21 |
22 | die ( ) {
23 | echo
24 | echo "$*"
25 | echo
26 | exit 1
27 | }
28 |
29 | # OS specific support (must be 'true' or 'false').
30 | cygwin=false
31 | msys=false
32 | darwin=false
33 | case "`uname`" in
34 | CYGWIN* )
35 | cygwin=true
36 | ;;
37 | Darwin* )
38 | darwin=true
39 | ;;
40 | MINGW* )
41 | msys=true
42 | ;;
43 | esac
44 |
45 | # For Cygwin, ensure paths are in UNIX format before anything is touched.
46 | if $cygwin ; then
47 | [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
48 | fi
49 |
50 | # Attempt to set APP_HOME
51 | # Resolve links: $0 may be a link
52 | PRG="$0"
53 | # Need this for relative symlinks.
54 | while [ -h "$PRG" ] ; do
55 | ls=`ls -ld "$PRG"`
56 | link=`expr "$ls" : '.*-> \(.*\)$'`
57 | if expr "$link" : '/.*' > /dev/null; then
58 | PRG="$link"
59 | else
60 | PRG=`dirname "$PRG"`"/$link"
61 | fi
62 | done
63 | SAVED="`pwd`"
64 | cd "`dirname \"$PRG\"`/" >&-
65 | APP_HOME="`pwd -P`"
66 | cd "$SAVED" >&-
67 |
68 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
69 |
70 | # Determine the Java command to use to start the JVM.
71 | if [ -n "$JAVA_HOME" ] ; then
72 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
73 | # IBM's JDK on AIX uses strange locations for the executables
74 | JAVACMD="$JAVA_HOME/jre/sh/java"
75 | else
76 | JAVACMD="$JAVA_HOME/bin/java"
77 | fi
78 | if [ ! -x "$JAVACMD" ] ; then
79 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
80 |
81 | Please set the JAVA_HOME variable in your environment to match the
82 | location of your Java installation."
83 | fi
84 | else
85 | JAVACMD="java"
86 | which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
87 |
88 | Please set the JAVA_HOME variable in your environment to match the
89 | location of your Java installation."
90 | fi
91 |
92 | # Increase the maximum file descriptors if we can.
93 | if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
94 | MAX_FD_LIMIT=`ulimit -H -n`
95 | if [ $? -eq 0 ] ; then
96 | if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
97 | MAX_FD="$MAX_FD_LIMIT"
98 | fi
99 | ulimit -n $MAX_FD
100 | if [ $? -ne 0 ] ; then
101 | warn "Could not set maximum file descriptor limit: $MAX_FD"
102 | fi
103 | else
104 | warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
105 | fi
106 | fi
107 |
108 | # For Darwin, add options to specify how the application appears in the dock
109 | if $darwin; then
110 | GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
111 | fi
112 |
113 | # For Cygwin, switch paths to Windows format before running java
114 | if $cygwin ; then
115 | APP_HOME=`cygpath --path --mixed "$APP_HOME"`
116 | CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
117 |
118 | # We build the pattern for arguments to be converted via cygpath
119 | ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
120 | SEP=""
121 | for dir in $ROOTDIRSRAW ; do
122 | ROOTDIRS="$ROOTDIRS$SEP$dir"
123 | SEP="|"
124 | done
125 | OURCYGPATTERN="(^($ROOTDIRS))"
126 | # Add a user-defined pattern to the cygpath arguments
127 | if [ "$GRADLE_CYGPATTERN" != "" ] ; then
128 | OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
129 | fi
130 | # Now convert the arguments - kludge to limit ourselves to /bin/sh
131 | i=0
132 | for arg in "$@" ; do
133 | CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
134 | CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
135 |
136 | if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
137 | eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
138 | else
139 | eval `echo args$i`="\"$arg\""
140 | fi
141 | i=$((i+1))
142 | done
143 | case $i in
144 | (0) set -- ;;
145 | (1) set -- "$args0" ;;
146 | (2) set -- "$args0" "$args1" ;;
147 | (3) set -- "$args0" "$args1" "$args2" ;;
148 | (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
149 | (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
150 | (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
151 | (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
152 | (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
153 | (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
154 | esac
155 | fi
156 |
157 | # Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
158 | function splitJvmOpts() {
159 | JVM_OPTS=("$@")
160 | }
161 | eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
162 | JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
163 |
164 | exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
165 |
--------------------------------------------------------------------------------
/gifmakerlib/src/main/java/com/beak/gifmakerlib/GifMaker.java:
--------------------------------------------------------------------------------
1 | package com.beak.gifmakerlib;
2 |
3 | import android.content.Context;
4 | import android.content.res.Resources;
5 | import android.graphics.Bitmap;
6 | import android.graphics.BitmapFactory;
7 | import android.media.MediaMetadataRetriever;
8 | import android.media.ThumbnailUtils;
9 | import android.net.Uri;
10 | import android.support.annotation.DrawableRes;
11 |
12 | import java.io.ByteArrayOutputStream;
13 | import java.io.File;
14 | import java.io.FileOutputStream;
15 | import java.io.IOException;
16 | import java.util.ArrayList;
17 | import java.util.List;
18 |
19 | /**
20 | * Created by Beak on 2015/8/27.
21 | */
22 | public class GifMaker {
23 |
24 | private int mScale = 1;
25 |
26 | private OnGifListener mGifListener = null;
27 |
28 | public GifMaker (int scale) {
29 | if (scale < 1) {
30 | return;
31 | }
32 | mScale = scale;
33 | }
34 |
35 | public boolean makeGif (List source, String outputPath) throws IOException {
36 | AnimatedGifEncoder encoder = new AnimatedGifEncoder();
37 | ByteArrayOutputStream bos = new ByteArrayOutputStream();
38 | encoder.start(bos);
39 | encoder.setRepeat(0);
40 | final int length = source.size();
41 | for (int i = 0; i < length; i++) {
42 | Bitmap bmp = source.get(i);
43 | if (bmp == null) {
44 | continue;
45 | }
46 | Bitmap thumb = ThumbnailUtils.extractThumbnail(bmp, bmp.getWidth() / mScale, bmp.getHeight() / mScale, ThumbnailUtils.OPTIONS_RECYCLE_INPUT);
47 | try {
48 | encoder.addFrame(thumb);
49 | if (mGifListener != null) {
50 | mGifListener.onMake(i, length);
51 | }
52 | } catch (Exception e) {
53 | e.printStackTrace();
54 | System.gc();
55 | break;
56 | }
57 | //TODO how about releasing bitmap after addFrame
58 | }
59 | encoder.finish();
60 | source.clear();
61 | byte[] data = bos.toByteArray();
62 | File file = new File(outputPath);
63 | if (!file.getParentFile().exists()) {
64 | file.getParentFile().mkdirs();
65 | }
66 | FileOutputStream fileOutputStream = new FileOutputStream(file);
67 | fileOutputStream.write(data);
68 | fileOutputStream.flush();
69 | fileOutputStream.close();
70 | return file.exists();
71 | }
72 |
73 | public boolean makeGifFromPath (List sourcePathList, String outputPath) throws IOException {
74 | List bitmaps = new ArrayList();
75 | final int length = sourcePathList.size();
76 | for (int i = 0; i < length; i++) {
77 | bitmaps.add(BitmapFactory.decodeFile(sourcePathList.get(i)));
78 | }
79 | return makeGif(bitmaps, outputPath);
80 | }
81 |
82 | public boolean makeGifFromFile (List sourceFileList, String outputPath) throws IOException {
83 | List pathArray = new ArrayList();
84 | final int length = sourceFileList.size();
85 | for (int i = 0; i < length; i++) {
86 | pathArray.add(sourceFileList.get(i).getAbsolutePath());
87 | }
88 | return makeGifFromPath(pathArray, outputPath);
89 | }
90 |
91 | public boolean makeGif (Resources resources, @DrawableRes int[] sourceDrawableId, String outputPath) throws IOException {
92 | List bitmaps = new ArrayList();
93 | for (int i = 0; i < sourceDrawableId.length; i++) {
94 | bitmaps.add(BitmapFactory.decodeResource(resources, sourceDrawableId[i]));
95 | }
96 | return makeGif(bitmaps, outputPath);
97 | }
98 |
99 | public boolean makeGifFromVideo (String videoPath, long startMillSeconds, long endMillSeconds, long periodMillSeconds, String outputPath) {
100 | MediaMetadataRetriever retriever = new MediaMetadataRetriever();
101 | retriever.setDataSource(videoPath);
102 | return makeGifWithMediaMetadataRetriever(retriever, startMillSeconds, endMillSeconds, periodMillSeconds, outputPath);
103 | }
104 |
105 | public boolean makeGifFromVideo (Context context, Uri uri, long startMillSeconds, long endMillSeconds, long periodMillSeconds, String outputPath) {
106 | MediaMetadataRetriever retriever = new MediaMetadataRetriever();
107 | retriever.setDataSource(context, uri);
108 | return makeGifWithMediaMetadataRetriever(retriever, startMillSeconds, endMillSeconds, periodMillSeconds, outputPath);
109 | }
110 |
111 | private boolean makeGifWithMediaMetadataRetriever (MediaMetadataRetriever retriever, long startMillSeconds, long endMillSeconds, long periodMillSeconds, String outputPath) {
112 | if (startMillSeconds < 0 || endMillSeconds <= 0 || periodMillSeconds <= 0 || endMillSeconds <= startMillSeconds) {
113 | throw new IllegalArgumentException("startMillSecodes may < 0 or endMillSeconds or periodMillSeconds may <= 0, or endMillSeconds <= startMillSeconds");
114 | }
115 | try {
116 | List bitmaps = new ArrayList();
117 | String durationStr = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION);
118 |
119 | long duration = Long.parseLong(durationStr);
120 | long minDuration = Math.min(duration, endMillSeconds);
121 | for (long time = startMillSeconds; time < minDuration; time += periodMillSeconds) {
122 | bitmaps.add(retriever.getFrameAtTime(time * 1000, MediaMetadataRetriever.OPTION_CLOSEST));
123 | }
124 | retriever.release();
125 | return makeGif(bitmaps, outputPath);
126 | } catch (Exception e) {
127 | e.printStackTrace();
128 | return false;
129 | }
130 | }
131 |
132 | public void setOnGifListener (OnGifListener listener) {
133 | mGifListener = listener;
134 | }
135 |
136 | public interface OnGifListener {
137 | public void onMake (int current, int total);
138 | }
139 | }
140 |
--------------------------------------------------------------------------------
/app/app.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 | generateDebugSources
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 |
99 |
100 |
101 |
102 |
103 |
--------------------------------------------------------------------------------
/gifmakerlib/gifmakerlib.iml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 | generateDebugSources
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 |
99 |
100 |
101 |
102 |
103 |
--------------------------------------------------------------------------------
/gifmakerlib/src/main/java/com/beak/gifmakerlib/AnimatedGifEncoder.java:
--------------------------------------------------------------------------------
1 | package com.beak.gifmakerlib;
2 |
3 | import android.graphics.Bitmap;
4 | import android.graphics.Bitmap.Config;
5 | import android.graphics.Canvas;
6 | import android.graphics.Paint;
7 |
8 | import java.io.IOException;
9 | import java.io.OutputStream;
10 |
11 | public class AnimatedGifEncoder {
12 |
13 | protected int width; // image size
14 |
15 | protected int height;
16 |
17 | protected int x = 0;
18 |
19 | protected int y = 0;
20 |
21 | protected int transparent = -1; // transparent color if given
22 |
23 | protected int transIndex; // transparent index in color table
24 |
25 | protected int repeat = -1; // no repeat
26 |
27 | protected int delay = 0; // frame delay (hundredths)
28 |
29 | protected boolean started = false; // ready to output frames
30 |
31 | protected OutputStream out;
32 |
33 | protected Bitmap image; // current frame
34 |
35 | protected byte[] pixels; // BGR byte array from frame
36 |
37 | protected byte[] indexedPixels; // converted frame indexed to palette
38 |
39 | protected int colorDepth; // number of bit planes
40 |
41 | protected byte[] colorTab; // RGB palette
42 |
43 | protected boolean[] usedEntry = new boolean[256]; // active palette entries
44 |
45 | protected int palSize = 7; // color table size (bits-1)
46 |
47 | protected int dispose = -1; // disposal code (-1 = use default)
48 |
49 | protected boolean closeStream = false; // close stream when finished
50 |
51 | protected boolean firstFrame = true;
52 |
53 | protected boolean sizeSet = false; // if false, get size from first frame
54 |
55 | protected int sample = 10; // default sample interval for quantizer
56 |
57 | /**
58 | * Sets the delay time between each frame, or changes it for subsequent frames
59 | * (applies to last frame added).
60 | *
61 | * @param ms
62 | * int delay time in milliseconds
63 | */
64 | public void setDelay(int ms) {
65 | delay = ms / 10;
66 | }
67 |
68 | /**
69 | * Sets the GIF frame disposal code for the last added frame and any
70 | * subsequent frames. Default is 0 if no transparent color has been set,
71 | * otherwise 2.
72 | *
73 | * @param code
74 | * int disposal code.
75 | */
76 | public void setDispose(int code) {
77 | if (code >= 0) {
78 | dispose = code;
79 | }
80 | }
81 |
82 | /**
83 | * Sets the number of times the set of GIF frames should be played. Default is
84 | * 1; 0 means play indefinitely. Must be invoked before the first image is
85 | * added.
86 | *
87 | * @param iter
88 | * int number of iterations.
89 | * @return
90 | */
91 | public void setRepeat(int iter) {
92 | if (iter >= 0) {
93 | repeat = iter;
94 | }
95 | }
96 |
97 | /**
98 | * Sets the transparent color for the last added frame and any subsequent
99 | * frames. Since all colors are subject to modification in the quantization
100 | * process, the color in the final palette for each frame closest to the given
101 | * color becomes the transparent color for that frame. May be set to null to
102 | * indicate no transparent color.
103 | *
104 | * @param c
105 | * Color to be treated as transparent on display.
106 | */
107 | public void setTransparent(int c) {
108 | transparent = c;
109 | }
110 |
111 | /**
112 | * Adds next GIF frame. The frame is not written immediately, but is actually
113 | * deferred until the next frame is received so that timing data can be
114 | * inserted. Invoking finish() flushes all frames. If
115 | * setSize was not invoked, the size of the first image is used
116 | * for all subsequent frames.
117 | *
118 | * @param im
119 | * BufferedImage containing frame to write.
120 | * @return true if successful.
121 | */
122 | public boolean addFrame(Bitmap im) {
123 | if ((im == null) || !started) {
124 | return false;
125 | }
126 | boolean ok = true;
127 | try {
128 | if (!sizeSet) {
129 | // use first frame's size
130 | setSize(im.getWidth(), im.getHeight());
131 | }
132 | image = im;
133 | getImagePixels(); // convert to correct format if necessary
134 | analyzePixels(); // build color table & map pixels
135 | if (firstFrame) {
136 | writeLSD(); // logical screen descriptior
137 | writePalette(); // global color table
138 | if (repeat >= 0) {
139 | // use NS app extension to indicate reps
140 | writeNetscapeExt();
141 | }
142 | }
143 | writeGraphicCtrlExt(); // write graphic control extension
144 | writeImageDesc(); // image descriptor
145 | if (!firstFrame) {
146 | writePalette(); // local color table
147 | }
148 | writePixels(); // encode and write pixel data
149 | firstFrame = false;
150 | } catch (IOException e) {
151 | ok = false;
152 | }
153 |
154 | return ok;
155 | }
156 |
157 | /**
158 | * Flushes any pending data and closes output file. If writing to an
159 | * OutputStream, the stream is not closed.
160 | */
161 | public boolean finish() {
162 | if (!started)
163 | return false;
164 | boolean ok = true;
165 | started = false;
166 | try {
167 | out.write(0x3b); // gif trailer
168 | out.flush();
169 | if (closeStream) {
170 | out.close();
171 | }
172 | } catch (IOException e) {
173 | ok = false;
174 | }
175 |
176 | // reset for subsequent use
177 | transIndex = 0;
178 | out = null;
179 | image = null;
180 | pixels = null;
181 | indexedPixels = null;
182 | colorTab = null;
183 | closeStream = false;
184 | firstFrame = true;
185 |
186 | return ok;
187 | }
188 |
189 | /**
190 | * Sets frame rate in frames per second. Equivalent to
191 | * setDelay(1000/fps).
192 | *
193 | * @param fps
194 | * float frame rate (frames per second)
195 | */
196 | public void setFrameRate(float fps) {
197 | if (fps != 0f) {
198 | delay = (int)(100 / fps);
199 | }
200 | }
201 |
202 | /**
203 | * Sets quality of color quantization (conversion of images to the maximum 256
204 | * colors allowed by the GIF specification). Lower values (minimum = 1)
205 | * produce better colors, but slow processing significantly. 10 is the
206 | * default, and produces good color mapping at reasonable speeds. Values
207 | * greater than 20 do not yield significant improvements in speed.
208 | *
209 | * @param quality
210 | * int greater than 0.
211 | * @return
212 | */
213 | public void setQuality(int quality) {
214 | if (quality < 1)
215 | quality = 1;
216 | sample = quality;
217 | }
218 |
219 | /**
220 | * Sets the GIF frame size. The default size is the size of the first frame
221 | * added if this method is not invoked.
222 | *
223 | * @param w
224 | * int frame width.
225 | * @param h
226 | * int frame width.
227 | */
228 | public void setSize(int w, int h) {
229 | width = w;
230 | height = h;
231 | if (width < 1)
232 | width = 320;
233 | if (height < 1)
234 | height = 240;
235 | sizeSet = true;
236 | }
237 |
238 | /**
239 | * Sets the GIF frame position. The position is 0,0 by default.
240 | * Useful for only updating a section of the image
241 | *
242 | * @param w
243 | * int frame width.
244 | * @param h
245 | * int frame width.
246 | */
247 | public void setPosition(int x, int y) {
248 | this.x = x;
249 | this.y = y;
250 | }
251 |
252 | /**
253 | * Initiates GIF file creation on the given stream. The stream is not closed
254 | * automatically.
255 | *
256 | * @param os
257 | * OutputStream on which GIF images are written.
258 | * @return false if initial write failed.
259 | */
260 | public boolean start(OutputStream os) {
261 | if (os == null)
262 | return false;
263 | boolean ok = true;
264 | closeStream = false;
265 | out = os;
266 | try {
267 | writeString("GIF89a"); // header
268 | } catch (IOException e) {
269 | ok = false;
270 | }
271 | return started = ok;
272 | }
273 |
274 | /**
275 | * Analyzes image colors and creates color map.
276 | */
277 | protected void analyzePixels() {
278 | int len = pixels.length;
279 | int nPix = len / 3;
280 | indexedPixels = new byte[nPix];
281 | NeuQuant nq = new NeuQuant(pixels, len, sample);
282 | // initialize quantizer
283 | colorTab = nq.process(); // create reduced palette
284 | // convert map from BGR to RGB
285 | for (int i = 0; i < colorTab.length; i += 3) {
286 | byte temp = colorTab[i];
287 | colorTab[i] = colorTab[i + 2];
288 | colorTab[i + 2] = temp;
289 | usedEntry[i / 3] = false;
290 | }
291 | // map image pixels to new palette
292 | int k = 0;
293 | for (int i = 0; i < nPix; i++) {
294 | int index = nq.map(pixels[k++] & 0xff, pixels[k++] & 0xff, pixels[k++] & 0xff);
295 | usedEntry[index] = true;
296 | indexedPixels[i] = (byte) index;
297 | }
298 | pixels = null;
299 | colorDepth = 8;
300 | palSize = 7;
301 | // get closest match to transparent color if specified
302 | if (transparent != -1) {
303 | transIndex = findClosest(transparent);
304 | }
305 | }
306 |
307 | /**
308 | * Returns index of palette color closest to c
309 | *
310 | */
311 | protected int findClosest(int c) {
312 | if (colorTab == null)
313 | return -1;
314 | int r = (c >> 16) & 0xff;
315 | int g = (c >> 8) & 0xff;
316 | int b = (c >> 0) & 0xff;
317 | int minpos = 0;
318 | int dmin = 256 * 256 * 256;
319 | int len = colorTab.length;
320 | for (int i = 0; i < len;) {
321 | int dr = r - (colorTab[i++] & 0xff);
322 | int dg = g - (colorTab[i++] & 0xff);
323 | int db = b - (colorTab[i] & 0xff);
324 | int d = dr * dr + dg * dg + db * db;
325 | int index = i / 3;
326 | if (usedEntry[index] && (d < dmin)) {
327 | dmin = d;
328 | minpos = index;
329 | }
330 | i++;
331 | }
332 | return minpos;
333 | }
334 |
335 | /**
336 | * Extracts image pixels into byte array "pixels"
337 | */
338 | protected void getImagePixels() {
339 | int w = image.getWidth();
340 | int h = image.getHeight();
341 | if ((w != width) || (h != height)) {
342 | // create new image with right size/format
343 | Bitmap temp = Bitmap.createBitmap(width, height, Config.RGB_565);
344 | Canvas g = new Canvas(temp);
345 | g.drawBitmap(image, 0, 0, new Paint());
346 | image = temp;
347 | }
348 | int[] data = getImageData(image);
349 | pixels = new byte[data.length * 3];
350 | for (int i = 0; i < data.length; i++) {
351 | int td = data[i];
352 | int tind = i * 3;
353 | pixels[tind++] = (byte) ((td >> 0) & 0xFF);
354 | pixels[tind++] = (byte) ((td >> 8) & 0xFF);
355 | pixels[tind] = (byte) ((td >> 16) & 0xFF);
356 | }
357 | }
358 | protected int[] getImageData(Bitmap img) {
359 | int w = img.getWidth();
360 | int h = img.getHeight();
361 |
362 | int[] data = new int[w * h];
363 | img.getPixels(data, 0, w, 0, 0, w, h);
364 | return data;
365 | }
366 |
367 | /**
368 | * Writes Graphic Control Extension
369 | */
370 | protected void writeGraphicCtrlExt() throws IOException {
371 | out.write(0x21); // extension introducer
372 | out.write(0xf9); // GCE label
373 | out.write(4); // data block size
374 | int transp, disp;
375 | if (transparent == -1) {
376 | transp = 0;
377 | disp = 0; // dispose = no action
378 | } else {
379 | transp = 1;
380 | disp = 2; // force clear if using transparent color
381 | }
382 | if (dispose >= 0) {
383 | disp = dispose & 7; // user override
384 | }
385 | disp <<= 2;
386 |
387 | // packed fields
388 | out.write(0 | // 1:3 reserved
389 | disp | // 4:6 disposal
390 | 0 | // 7 user input - 0 = none
391 | transp); // 8 transparency flag
392 |
393 | writeShort(delay); // delay x 1/100 sec
394 | out.write(transIndex); // transparent color index
395 | out.write(0); // block terminator
396 | }
397 |
398 | /**
399 | * Writes Image Descriptor
400 | */
401 | protected void writeImageDesc() throws IOException {
402 | out.write(0x2c); // image separator
403 | writeShort(x); // image position x,y = 0,0
404 | writeShort(y);
405 | writeShort(width); // image size
406 | writeShort(height);
407 | // packed fields
408 | if (firstFrame) {
409 | // no LCT - GCT is used for first (or only) frame
410 | out.write(0);
411 | } else {
412 | // specify normal LCT
413 | out.write(0x80 | // 1 local color table 1=yes
414 | 0 | // 2 interlace - 0=no
415 | 0 | // 3 sorted - 0=no
416 | 0 | // 4-5 reserved
417 | palSize); // 6-8 size of color table
418 | }
419 | }
420 |
421 | /**
422 | * Writes Logical Screen Descriptor
423 | */
424 | protected void writeLSD() throws IOException {
425 | // logical screen size
426 | writeShort(width);
427 | writeShort(height);
428 | // packed fields
429 | out.write((0x80 | // 1 : global color table flag = 1 (gct used)
430 | 0x70 | // 2-4 : color resolution = 7
431 | 0x00 | // 5 : gct sort flag = 0
432 | palSize)); // 6-8 : gct size
433 |
434 | out.write(0); // background color index
435 | out.write(0); // pixel aspect ratio - assume 1:1
436 | }
437 |
438 | /**
439 | * Writes Netscape application extension to define repeat count.
440 | */
441 | protected void writeNetscapeExt() throws IOException {
442 | out.write(0x21); // extension introducer
443 | out.write(0xff); // app extension label
444 | out.write(11); // block size
445 | writeString("NETSCAPE" + "2.0"); // app id + auth code
446 | out.write(3); // sub-block size
447 | out.write(1); // loop sub-block id
448 | writeShort(repeat); // loop count (extra iterations, 0=repeat forever)
449 | out.write(0); // block terminator
450 | }
451 |
452 | /**
453 | * Writes color table
454 | */
455 | protected void writePalette() throws IOException {
456 | out.write(colorTab, 0, colorTab.length);
457 | int n = (3 * 256) - colorTab.length;
458 | for (int i = 0; i < n; i++) {
459 | out.write(0);
460 | }
461 | }
462 |
463 | /**
464 | * Encodes and writes pixel data
465 | */
466 | protected void writePixels() throws IOException {
467 | LZWEncoder encoder = new LZWEncoder(width, height, indexedPixels, colorDepth);
468 | encoder.encode(out);
469 | }
470 |
471 | /**
472 | * Write 16-bit value to output stream, LSB first
473 | */
474 | protected void writeShort(int value) throws IOException {
475 | out.write(value & 0xff);
476 | out.write((value >> 8) & 0xff);
477 | }
478 |
479 | /**
480 | * Writes string to output stream
481 | */
482 | protected void writeString(String s) throws IOException {
483 | for (int i = 0; i < s.length(); i++) {
484 | out.write((byte) s.charAt(i));
485 | }
486 | }
487 | }
488 |
489 | /*
490 | * NeuQuant Neural-Net Quantization Algorithm
491 | * ------------------------------------------
492 | *
493 | * Copyright (c) 1994 Anthony Dekker
494 | *
495 | * NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994. See
496 | * "Kohonen neural networks for optimal colour quantization" in "Network:
497 | * Computation in Neural Systems" Vol. 5 (1994) pp 351-367. for a discussion of
498 | * the algorithm.
499 | *
500 | * Any party obtaining a copy of these files from the author, directly or
501 | * indirectly, is granted, free of charge, a full and unrestricted irrevocable,
502 | * world-wide, paid up, royalty-free, nonexclusive right and license to deal in
503 | * this software and documentation files (the "Software"), including without
504 | * limitation the rights to use, copy, modify, merge, publish, distribute,
505 | * sublicense, and/or sell copies of the Software, and to permit persons who
506 | * receive copies from any such party to do so, with the only requirement being
507 | * that this copyright notice remain intact.
508 | */
509 |
510 | // Ported to Java 12/00 K Weiner
511 | class NeuQuant {
512 |
513 | protected static final int netsize = 256; /* number of colours used */
514 |
515 | /* four primes near 500 - assume no image has a length so large */
516 | /* that it is divisible by all four primes */
517 | protected static final int prime1 = 499;
518 |
519 | protected static final int prime2 = 491;
520 |
521 | protected static final int prime3 = 487;
522 |
523 | protected static final int prime4 = 503;
524 |
525 | protected static final int minpicturebytes = (3 * prime4);
526 |
527 | /* minimum size for input image */
528 |
529 | /*
530 | * Program Skeleton ---------------- [select samplefac in range 1..30] [read
531 | * image from input file] pic = (unsigned char*) malloc(3*width*height);
532 | * initnet(pic,3*width*height,samplefac); learn(); unbiasnet(); [write output
533 | * image header, using writecolourmap(f)] inxbuild(); write output image using
534 | * inxsearch(b,g,r)
535 | */
536 |
537 | /*
538 | * Network Definitions -------------------
539 | */
540 |
541 | protected static final int maxnetpos = (netsize - 1);
542 |
543 | protected static final int netbiasshift = 4; /* bias for colour values */
544 |
545 | protected static final int ncycles = 100; /* no. of learning cycles */
546 |
547 | /* defs for freq and bias */
548 | protected static final int intbiasshift = 16; /* bias for fractions */
549 |
550 | protected static final int intbias = (((int) 1) << intbiasshift);
551 |
552 | protected static final int gammashift = 10; /* gamma = 1024 */
553 |
554 | protected static final int gamma = (((int) 1) << gammashift);
555 |
556 | protected static final int betashift = 10;
557 |
558 | protected static final int beta = (intbias >> betashift); /* beta = 1/1024 */
559 |
560 | protected static final int betagamma = (intbias << (gammashift - betashift));
561 |
562 | /* defs for decreasing radius factor */
563 | protected static final int initrad = (netsize >> 3); /*
564 | * for 256 cols, radius
565 | * starts
566 | */
567 |
568 | protected static final int radiusbiasshift = 6; /* at 32.0 biased by 6 bits */
569 |
570 | protected static final int radiusbias = (((int) 1) << radiusbiasshift);
571 |
572 | protected static final int initradius = (initrad * radiusbias); /*
573 | * and
574 | * decreases
575 | * by a
576 | */
577 |
578 | protected static final int radiusdec = 30; /* factor of 1/30 each cycle */
579 |
580 | /* defs for decreasing alpha factor */
581 | protected static final int alphabiasshift = 10; /* alpha starts at 1.0 */
582 |
583 | protected static final int initalpha = (((int) 1) << alphabiasshift);
584 |
585 | protected int alphadec; /* biased by 10 bits */
586 |
587 | /* radbias and alpharadbias used for radpower calculation */
588 | protected static final int radbiasshift = 8;
589 |
590 | protected static final int radbias = (((int) 1) << radbiasshift);
591 |
592 | protected static final int alpharadbshift = (alphabiasshift + radbiasshift);
593 |
594 | protected static final int alpharadbias = (((int) 1) << alpharadbshift);
595 |
596 | /*
597 | * Types and Global Variables --------------------------
598 | */
599 |
600 | protected byte[] thepicture; /* the input image itself */
601 |
602 | protected int lengthcount; /* lengthcount = H*W*3 */
603 |
604 | protected int samplefac; /* sampling factor 1..30 */
605 |
606 | // typedef int pixel[4]; /* BGRc */
607 | protected int[][] network; /* the network itself - [netsize][4] */
608 |
609 | protected int[] netindex = new int[256];
610 |
611 | /* for network lookup - really 256 */
612 |
613 | protected int[] bias = new int[netsize];
614 |
615 | /* bias and freq arrays for learning */
616 | protected int[] freq = new int[netsize];
617 |
618 | protected int[] radpower = new int[initrad];
619 |
620 | /* radpower for precomputation */
621 |
622 | /*
623 | * Initialise network in range (0,0,0) to (255,255,255) and set parameters
624 | * -----------------------------------------------------------------------
625 | */
626 | public NeuQuant(byte[] thepic, int len, int sample) {
627 |
628 | int i;
629 | int[] p;
630 |
631 | thepicture = thepic;
632 | lengthcount = len;
633 | samplefac = sample;
634 |
635 | network = new int[netsize][];
636 | for (i = 0; i < netsize; i++) {
637 | network[i] = new int[4];
638 | p = network[i];
639 | p[0] = p[1] = p[2] = (i << (netbiasshift + 8)) / netsize;
640 | freq[i] = intbias / netsize; /* 1/netsize */
641 | bias[i] = 0;
642 | }
643 | }
644 |
645 | public byte[] colorMap() {
646 | byte[] map = new byte[3 * netsize];
647 | int[] index = new int[netsize];
648 | for (int i = 0; i < netsize; i++)
649 | index[network[i][3]] = i;
650 | int k = 0;
651 | for (int i = 0; i < netsize; i++) {
652 | int j = index[i];
653 | map[k++] = (byte) (network[j][0]);
654 | map[k++] = (byte) (network[j][1]);
655 | map[k++] = (byte) (network[j][2]);
656 | }
657 | return map;
658 | }
659 |
660 | /*
661 | * Insertion sort of network and building of netindex[0..255] (to do after
662 | * unbias)
663 | * -------------------------------------------------------------------------------
664 | */
665 | public void inxbuild() {
666 |
667 | int i, j, smallpos, smallval;
668 | int[] p;
669 | int[] q;
670 | int previouscol, startpos;
671 |
672 | previouscol = 0;
673 | startpos = 0;
674 | for (i = 0; i < netsize; i++) {
675 | p = network[i];
676 | smallpos = i;
677 | smallval = p[1]; /* index on g */
678 | /* find smallest in i..netsize-1 */
679 | for (j = i + 1; j < netsize; j++) {
680 | q = network[j];
681 | if (q[1] < smallval) { /* index on g */
682 | smallpos = j;
683 | smallval = q[1]; /* index on g */
684 | }
685 | }
686 | q = network[smallpos];
687 | /* swap p (i) and q (smallpos) entries */
688 | if (i != smallpos) {
689 | j = q[0];
690 | q[0] = p[0];
691 | p[0] = j;
692 | j = q[1];
693 | q[1] = p[1];
694 | p[1] = j;
695 | j = q[2];
696 | q[2] = p[2];
697 | p[2] = j;
698 | j = q[3];
699 | q[3] = p[3];
700 | p[3] = j;
701 | }
702 | /* smallval entry is now in position i */
703 | if (smallval != previouscol) {
704 | netindex[previouscol] = (startpos + i) >> 1;
705 | for (j = previouscol + 1; j < smallval; j++)
706 | netindex[j] = i;
707 | previouscol = smallval;
708 | startpos = i;
709 | }
710 | }
711 | netindex[previouscol] = (startpos + maxnetpos) >> 1;
712 | for (j = previouscol + 1; j < 256; j++)
713 | netindex[j] = maxnetpos; /* really 256 */
714 | }
715 |
716 | /*
717 | * Main Learning Loop ------------------
718 | */
719 | public void learn() {
720 |
721 | int i, j, b, g, r;
722 | int radius, rad, alpha, step, delta, samplepixels;
723 | byte[] p;
724 | int pix, lim;
725 |
726 | if (lengthcount < minpicturebytes)
727 | samplefac = 1;
728 | alphadec = 30 + ((samplefac - 1) / 3);
729 | p = thepicture;
730 | pix = 0;
731 | lim = lengthcount;
732 | samplepixels = lengthcount / (3 * samplefac);
733 | delta = samplepixels / ncycles;
734 | alpha = initalpha;
735 | radius = initradius;
736 |
737 | rad = radius >> radiusbiasshift;
738 | if (rad <= 1)
739 | rad = 0;
740 | for (i = 0; i < rad; i++)
741 | radpower[i] = alpha * (((rad * rad - i * i) * radbias) / (rad * rad));
742 |
743 | // fprintf(stderr,"beginning 1D learning: initial radius=%d\n", rad);
744 |
745 | if (lengthcount < minpicturebytes)
746 | step = 3;
747 | else if ((lengthcount % prime1) != 0)
748 | step = 3 * prime1;
749 | else {
750 | if ((lengthcount % prime2) != 0)
751 | step = 3 * prime2;
752 | else {
753 | if ((lengthcount % prime3) != 0)
754 | step = 3 * prime3;
755 | else
756 | step = 3 * prime4;
757 | }
758 | }
759 |
760 | i = 0;
761 | while (i < samplepixels) {
762 | b = (p[pix + 0] & 0xff) << netbiasshift;
763 | g = (p[pix + 1] & 0xff) << netbiasshift;
764 | r = (p[pix + 2] & 0xff) << netbiasshift;
765 | j = contest(b, g, r);
766 |
767 | altersingle(alpha, j, b, g, r);
768 | if (rad != 0)
769 | alterneigh(rad, j, b, g, r); /* alter neighbours */
770 |
771 | pix += step;
772 | if (pix >= lim)
773 | pix -= lengthcount;
774 |
775 | i++;
776 | if (delta == 0)
777 | delta = 1;
778 | if (i % delta == 0) {
779 | alpha -= alpha / alphadec;
780 | radius -= radius / radiusdec;
781 | rad = radius >> radiusbiasshift;
782 | if (rad <= 1)
783 | rad = 0;
784 | for (j = 0; j < rad; j++)
785 | radpower[j] = alpha * (((rad * rad - j * j) * radbias) / (rad * rad));
786 | }
787 | }
788 | // fprintf(stderr,"finished 1D learning: final alpha=%f
789 | // !\n",((float)alpha)/initalpha);
790 | }
791 |
792 | /*
793 | * Search for BGR values 0..255 (after net is unbiased) and return colour
794 | * index
795 | * ----------------------------------------------------------------------------
796 | */
797 | public int map(int b, int g, int r) {
798 |
799 | int i, j, dist, a, bestd;
800 | int[] p;
801 | int best;
802 |
803 | bestd = 1000; /* biggest possible dist is 256*3 */
804 | best = -1;
805 | i = netindex[g]; /* index on g */
806 | j = i - 1; /* start at netindex[g] and work outwards */
807 |
808 | while ((i < netsize) || (j >= 0)) {
809 | if (i < netsize) {
810 | p = network[i];
811 | dist = p[1] - g; /* inx key */
812 | if (dist >= bestd)
813 | i = netsize; /* stop iter */
814 | else {
815 | i++;
816 | if (dist < 0)
817 | dist = -dist;
818 | a = p[0] - b;
819 | if (a < 0)
820 | a = -a;
821 | dist += a;
822 | if (dist < bestd) {
823 | a = p[2] - r;
824 | if (a < 0)
825 | a = -a;
826 | dist += a;
827 | if (dist < bestd) {
828 | bestd = dist;
829 | best = p[3];
830 | }
831 | }
832 | }
833 | }
834 | if (j >= 0) {
835 | p = network[j];
836 | dist = g - p[1]; /* inx key - reverse dif */
837 | if (dist >= bestd)
838 | j = -1; /* stop iter */
839 | else {
840 | j--;
841 | if (dist < 0)
842 | dist = -dist;
843 | a = p[0] - b;
844 | if (a < 0)
845 | a = -a;
846 | dist += a;
847 | if (dist < bestd) {
848 | a = p[2] - r;
849 | if (a < 0)
850 | a = -a;
851 | dist += a;
852 | if (dist < bestd) {
853 | bestd = dist;
854 | best = p[3];
855 | }
856 | }
857 | }
858 | }
859 | }
860 | return (best);
861 | }
862 |
863 | public byte[] process() {
864 | learn();
865 | unbiasnet();
866 | inxbuild();
867 | return colorMap();
868 | }
869 |
870 | /*
871 | * Unbias network to give byte values 0..255 and record position i to prepare
872 | * for sort
873 | * -----------------------------------------------------------------------------------
874 | */
875 | public void unbiasnet() {
876 |
877 | int i;
878 |
879 | for (i = 0; i < netsize; i++) {
880 | network[i][0] >>= netbiasshift;
881 | network[i][1] >>= netbiasshift;
882 | network[i][2] >>= netbiasshift;
883 | network[i][3] = i; /* record colour no */
884 | }
885 | }
886 |
887 | /*
888 | * Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in
889 | * radpower[|i-j|]
890 | * ---------------------------------------------------------------------------------
891 | */
892 | protected void alterneigh(int rad, int i, int b, int g, int r) {
893 |
894 | int j, k, lo, hi, a, m;
895 | int[] p;
896 |
897 | lo = i - rad;
898 | if (lo < -1)
899 | lo = -1;
900 | hi = i + rad;
901 | if (hi > netsize)
902 | hi = netsize;
903 |
904 | j = i + 1;
905 | k = i - 1;
906 | m = 1;
907 | while ((j < hi) || (k > lo)) {
908 | a = radpower[m++];
909 | if (j < hi) {
910 | p = network[j++];
911 | try {
912 | p[0] -= (a * (p[0] - b)) / alpharadbias;
913 | p[1] -= (a * (p[1] - g)) / alpharadbias;
914 | p[2] -= (a * (p[2] - r)) / alpharadbias;
915 | } catch (Exception e) {
916 | } // prevents 1.3 miscompilation
917 | }
918 | if (k > lo) {
919 | p = network[k--];
920 | try {
921 | p[0] -= (a * (p[0] - b)) / alpharadbias;
922 | p[1] -= (a * (p[1] - g)) / alpharadbias;
923 | p[2] -= (a * (p[2] - r)) / alpharadbias;
924 | } catch (Exception e) {
925 | }
926 | }
927 | }
928 | }
929 |
930 | /*
931 | * Move neuron i towards biased (b,g,r) by factor alpha
932 | * ----------------------------------------------------
933 | */
934 | protected void altersingle(int alpha, int i, int b, int g, int r) {
935 |
936 | /* alter hit neuron */
937 | int[] n = network[i];
938 | n[0] -= (alpha * (n[0] - b)) / initalpha;
939 | n[1] -= (alpha * (n[1] - g)) / initalpha;
940 | n[2] -= (alpha * (n[2] - r)) / initalpha;
941 | }
942 |
943 | /*
944 | * Search for biased BGR values ----------------------------
945 | */
946 | protected int contest(int b, int g, int r) {
947 |
948 | /* finds closest neuron (min dist) and updates freq */
949 | /* finds best neuron (min dist-bias) and returns position */
950 | /* for frequently chosen neurons, freq[i] is high and bias[i] is negative */
951 | /* bias[i] = gamma*((1/netsize)-freq[i]) */
952 |
953 | int i, dist, a, biasdist, betafreq;
954 | int bestpos, bestbiaspos, bestd, bestbiasd;
955 | int[] n;
956 |
957 | bestd = ~(((int) 1) << 31);
958 | bestbiasd = bestd;
959 | bestpos = -1;
960 | bestbiaspos = bestpos;
961 |
962 | for (i = 0; i < netsize; i++) {
963 | n = network[i];
964 | dist = n[0] - b;
965 | if (dist < 0)
966 | dist = -dist;
967 | a = n[1] - g;
968 | if (a < 0)
969 | a = -a;
970 | dist += a;
971 | a = n[2] - r;
972 | if (a < 0)
973 | a = -a;
974 | dist += a;
975 | if (dist < bestd) {
976 | bestd = dist;
977 | bestpos = i;
978 | }
979 | biasdist = dist - ((bias[i]) >> (intbiasshift - netbiasshift));
980 | if (biasdist < bestbiasd) {
981 | bestbiasd = biasdist;
982 | bestbiaspos = i;
983 | }
984 | betafreq = (freq[i] >> betashift);
985 | freq[i] -= betafreq;
986 | bias[i] += (betafreq << gammashift);
987 | }
988 | freq[bestpos] += beta;
989 | bias[bestpos] -= betagamma;
990 | return (bestbiaspos);
991 | }
992 | }
993 |
994 | // ==============================================================================
995 | // Adapted from Jef Poskanzer's Java port by way of J. M. G. Elliott.
996 | // K Weiner 12/00
997 |
998 | class LZWEncoder {
999 |
1000 | private static final int EOF = -1;
1001 |
1002 | private int imgW, imgH;
1003 |
1004 | private byte[] pixAry;
1005 |
1006 | private int initCodeSize;
1007 |
1008 | private int remaining;
1009 |
1010 | private int curPixel;
1011 |
1012 | // GIFCOMPR.C - GIF Image compression routines
1013 | //
1014 | // Lempel-Ziv compression based on 'compress'. GIF modifications by
1015 | // David Rowley (mgardi@watdcsu.waterloo.edu)
1016 |
1017 | // General DEFINEs
1018 |
1019 | static final int BITS = 12;
1020 |
1021 | static final int HSIZE = 5003; // 80% occupancy
1022 |
1023 | // GIF Image compression - modified 'compress'
1024 | //
1025 | // Based on: compress.c - File compression ala IEEE Computer, June 1984.
1026 | //
1027 | // By Authors: Spencer W. Thomas (decvax!harpo!utah-cs!utah-gr!thomas)
1028 | // Jim McKie (decvax!mcvax!jim)
1029 | // Steve Davies (decvax!vax135!petsd!peora!srd)
1030 | // Ken Turkowski (decvax!decwrl!turtlevax!ken)
1031 | // James A. Woods (decvax!ihnp4!ames!jaw)
1032 | // Joe Orost (decvax!vax135!petsd!joe)
1033 |
1034 | int n_bits; // number of bits/code
1035 |
1036 | int maxbits = BITS; // user settable max # bits/code
1037 |
1038 | int maxcode; // maximum code, given n_bits
1039 |
1040 | int maxmaxcode = 1 << BITS; // should NEVER generate this code
1041 |
1042 | int[] htab = new int[HSIZE];
1043 |
1044 | int[] codetab = new int[HSIZE];
1045 |
1046 | int hsize = HSIZE; // for dynamic table sizing
1047 |
1048 | int free_ent = 0; // first unused entry
1049 |
1050 | // block compression parameters -- after all codes are used up,
1051 | // and compression rate changes, start over.
1052 | boolean clear_flg = false;
1053 |
1054 | // Algorithm: use open addressing double hashing (no chaining) on the
1055 | // prefix code / next character combination. We do a variant of Knuth's
1056 | // algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
1057 | // secondary probe. Here, the modular division first probe is gives way
1058 | // to a faster exclusive-or manipulation. Also do block compression with
1059 | // an adaptive reset, whereby the code table is cleared when the compression
1060 | // ratio decreases, but after the table fills. The variable-length output
1061 | // codes are re-sized at this point, and a special CLEAR code is generated
1062 | // for the decompressor. Late addition: construct the table according to
1063 | // file size for noticeable speed improvement on small files. Please direct
1064 | // questions about this implementation to ames!jaw.
1065 |
1066 | int g_init_bits;
1067 |
1068 | int ClearCode;
1069 |
1070 | int EOFCode;
1071 |
1072 | // output
1073 | //
1074 | // Output the given code.
1075 | // Inputs:
1076 | // code: A n_bits-bit integer. If == -1, then EOF. This assumes
1077 | // that n_bits =< wordsize - 1.
1078 | // Outputs:
1079 | // Outputs code to the file.
1080 | // Assumptions:
1081 | // Chars are 8 bits long.
1082 | // Algorithm:
1083 | // Maintain a BITS character long buffer (so that 8 codes will
1084 | // fit in it exactly). Use the VAX insv instruction to insert each
1085 | // code in turn. When the buffer fills up empty it and start over.
1086 |
1087 | int cur_accum = 0;
1088 |
1089 | int cur_bits = 0;
1090 |
1091 | int masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F, 0x001F, 0x003F, 0x007F, 0x00FF, 0x01FF,
1092 | 0x03FF, 0x07FF, 0x0FFF, 0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
1093 |
1094 | // Number of characters so far in this 'packet'
1095 | int a_count;
1096 |
1097 | // Define the storage for the packet accumulator
1098 | byte[] accum = new byte[256];
1099 |
1100 | // ----------------------------------------------------------------------------
1101 | LZWEncoder(int width, int height, byte[] pixels, int color_depth) {
1102 | imgW = width;
1103 | imgH = height;
1104 | pixAry = pixels;
1105 | initCodeSize = Math.max(2, color_depth);
1106 | }
1107 |
1108 | // Add a character to the end of the current packet, and if it is 254
1109 | // characters, flush the packet to disk.
1110 | void char_out(byte c, OutputStream outs) throws IOException {
1111 | accum[a_count++] = c;
1112 | if (a_count >= 254)
1113 | flush_char(outs);
1114 | }
1115 |
1116 | // Clear out the hash table
1117 |
1118 | // table clear for block compress
1119 | void cl_block(OutputStream outs) throws IOException {
1120 | cl_hash(hsize);
1121 | free_ent = ClearCode + 2;
1122 | clear_flg = true;
1123 |
1124 | output(ClearCode, outs);
1125 | }
1126 |
1127 | // reset code table
1128 | void cl_hash(int hsize) {
1129 | for (int i = 0; i < hsize; ++i)
1130 | htab[i] = -1;
1131 | }
1132 |
1133 | void compress(int init_bits, OutputStream outs) throws IOException {
1134 | int fcode;
1135 | int i /* = 0 */;
1136 | int c;
1137 | int ent;
1138 | int disp;
1139 | int hsize_reg;
1140 | int hshift;
1141 |
1142 | // Set up the globals: g_init_bits - initial number of bits
1143 | g_init_bits = init_bits;
1144 |
1145 | // Set up the necessary values
1146 | clear_flg = false;
1147 | n_bits = g_init_bits;
1148 | maxcode = MAXCODE(n_bits);
1149 |
1150 | ClearCode = 1 << (init_bits - 1);
1151 | EOFCode = ClearCode + 1;
1152 | free_ent = ClearCode + 2;
1153 |
1154 | a_count = 0; // clear packet
1155 |
1156 | ent = nextPixel();
1157 |
1158 | hshift = 0;
1159 | for (fcode = hsize; fcode < 65536; fcode *= 2)
1160 | ++hshift;
1161 | hshift = 8 - hshift; // set hash code range bound
1162 |
1163 | hsize_reg = hsize;
1164 | cl_hash(hsize_reg); // clear hash table
1165 |
1166 | output(ClearCode, outs);
1167 |
1168 | outer_loop: while ((c = nextPixel()) != EOF) {
1169 | fcode = (c << maxbits) + ent;
1170 | i = (c << hshift) ^ ent; // xor hashing
1171 |
1172 | if (htab[i] == fcode) {
1173 | ent = codetab[i];
1174 | continue;
1175 | } else if (htab[i] >= 0) // non-empty slot
1176 | {
1177 | disp = hsize_reg - i; // secondary hash (after G. Knott)
1178 | if (i == 0)
1179 | disp = 1;
1180 | do {
1181 | if ((i -= disp) < 0)
1182 | i += hsize_reg;
1183 |
1184 | if (htab[i] == fcode) {
1185 | ent = codetab[i];
1186 | continue outer_loop;
1187 | }
1188 | } while (htab[i] >= 0);
1189 | }
1190 | output(ent, outs);
1191 | ent = c;
1192 | if (free_ent < maxmaxcode) {
1193 | codetab[i] = free_ent++; // code -> hashtable
1194 | htab[i] = fcode;
1195 | } else
1196 | cl_block(outs);
1197 | }
1198 | // Put out the final code.
1199 | output(ent, outs);
1200 | output(EOFCode, outs);
1201 | }
1202 |
1203 | // ----------------------------------------------------------------------------
1204 | void encode(OutputStream os) throws IOException {
1205 | os.write(initCodeSize); // write "initial code size" byte
1206 |
1207 | remaining = imgW * imgH; // reset navigation variables
1208 | curPixel = 0;
1209 |
1210 | compress(initCodeSize + 1, os); // compress and write the pixel data
1211 |
1212 | os.write(0); // write block terminator
1213 | }
1214 |
1215 | // Flush the packet to disk, and reset the accumulator
1216 | void flush_char(OutputStream outs) throws IOException {
1217 | if (a_count > 0) {
1218 | outs.write(a_count);
1219 | outs.write(accum, 0, a_count);
1220 | a_count = 0;
1221 | }
1222 | }
1223 |
1224 | final int MAXCODE(int n_bits) {
1225 | return (1 << n_bits) - 1;
1226 | }
1227 |
1228 | // ----------------------------------------------------------------------------
1229 | // Return the next pixel from the image
1230 | // ----------------------------------------------------------------------------
1231 | private int nextPixel() {
1232 | if (remaining == 0)
1233 | return EOF;
1234 |
1235 | --remaining;
1236 |
1237 | byte pix = pixAry[curPixel++];
1238 |
1239 | return pix & 0xff;
1240 | }
1241 |
1242 | void output(int code, OutputStream outs) throws IOException {
1243 | cur_accum &= masks[cur_bits];
1244 |
1245 | if (cur_bits > 0)
1246 | cur_accum |= (code << cur_bits);
1247 | else
1248 | cur_accum = code;
1249 |
1250 | cur_bits += n_bits;
1251 |
1252 | while (cur_bits >= 8) {
1253 | char_out((byte) (cur_accum & 0xff), outs);
1254 | cur_accum >>= 8;
1255 | cur_bits -= 8;
1256 | }
1257 |
1258 | // If the next entry is going to be too big for the code size,
1259 | // then increase it, if possible.
1260 | if (free_ent > maxcode || clear_flg) {
1261 | if (clear_flg) {
1262 | maxcode = MAXCODE(n_bits = g_init_bits);
1263 | clear_flg = false;
1264 | } else {
1265 | ++n_bits;
1266 | if (n_bits == maxbits)
1267 | maxcode = maxmaxcode;
1268 | else
1269 | maxcode = MAXCODE(n_bits);
1270 | }
1271 | }
1272 |
1273 | if (code == EOFCode) {
1274 | // At EOF, write the rest of the buffer.
1275 | while (cur_bits > 0) {
1276 | char_out((byte) (cur_accum & 0xff), outs);
1277 | cur_accum >>= 8;
1278 | cur_bits -= 8;
1279 | }
1280 |
1281 | flush_char(outs);
1282 | }
1283 | }
1284 | }
--------------------------------------------------------------------------------