2012年3月12日 星期一

Android 開發教學筆記 - 學習 Renderscript 的足跡


From: Graphics Renderscript overview


接觸 Renderscript 一陣子了,盡管官方文件顯少,但最佳的學習方式就是大量的程式碼閱讀,久了就會熟習為啥有 A 還是 B 的架構。據說 Renderscript 一開始是要設計給圖形運算的,以高效能、跨平台為出發點,不知不覺就設計出可以平行運算的架構,所以學習 Renderscript 別忘了繪圖運算跟平行處理這兩個方向。


關於 Renderscript 相關程式碼:



我本身一開始是先接觸 HelloCompute 的,看懂之後又對 Carousel 的效果著迷,在沒有圖學背景,悄悄地啃食完了,深深覺得數學真的很奧妙。之後閒暇之餘,又看了 Fountain 、HelloWorld 、 Gravity 和 Balls 等範例,漸漸地就能夠把 Renderscript 雛形給建立好。


回憶起來,我覺得比較好的學習曲線:



  • 平行運算


    • HelloCompute> Balls


  • 繪圖運算


    • HelloWorld > Gravity > Fountain > Carousel 



從 HelloWorld 的架構下,就能夠搞懂怎樣初始化一些繪圖的架構,例如 int root() 回傳的數值可代表畫面更新的頻率等,而 HelloCompute 則是專門做平行運算的架構。之所以把 Balls 擺在平行運算是因為裡頭有一個在 Renderscript 中呼叫 rsForEach 啦,而 HelloCompute 是在 Java 端呼叫 mScript.forEach_root ,更簡單的範例請參考 Renderscript Part 2 吧,算是把 HelloCompute 從 mScript.forEach_root 快速改寫成 rsForEach 的方式。


除此之外,最近也有一篇 R. Jason Sams 寫的一篇 Levels in Renderscript ,也是不錯的效能測試的文章。


2012年3月11日 星期日

走讀台灣 系列書籍


圖片來源:Pubu電子書城 - 走讀台灣 - 嘉義市


記得過年時剛好在 iPad 上嘗試使用 Pubu 電子書閱讀器,覺得這種用「圖片」方式瀏覽傳統書籍,在網路夠快的情境下,感覺其實沒有那麼糟。


最近想說想多了解一下自己居住的城市,所以就找了「走讀台灣」系列書籍,有豐富的圖片跟文字史料,我想,跟旅遊書籍差不多了吧!只是在網路上找了很久,才發現「走讀台灣」只在一些地方可以購買:



根據一位國中老師的分享,這系列似乎是課後補充教材?難怪很難購買,應該沒多人會想去買學生上課用的書吧 XD


最後,我是在 Pubu 電子書城購買 120 元的版本(DRM-free),這個版本就是國外行之有年的 Social-DRM 版本!簡單的說就是在電子書上的每一頁嵌入購買者的相關資訊,如 Email 或帳號資訊,所以,購買後若要下載還要等一會兒,我猜是系統正在動態產生這些圖檔(嵌有一小段個人資訊)。


說真的,最後產出的電子書只是「圖檔」湊起來的,說真的還是有點小落寞啦 :P 畢竟直接買實體書就會送電子書了,這時候這種圖檔式電子書就顯得遜色不少。而令我眼睛一亮的 EPUB 格式卻都只是圖檔而已,這下可好,螢幕小的閱讀裝置肯定很痛苦,完完全全地為 EPUB 格式產生出毫無用途的 EPUB 電子書而已。


2012年3月8日 星期四

Android 開發教學筆記 - Renderscript Parallel Computing 之 Define a structure for your data

雖然網路上有許多 Renderscript 處理繪圖運算的範例,但它不只可以作繪圖加速還可以作平行運算,在 PandaBoard ES Rev B 板子上,發現雙核心 CPU 的架構下,似乎是沒問題的。然而,網路上場看得範例都是處理圖檔,讀檔的資料結構很簡單,就是最基本的 Bitmap 而已,於是花了不少功夫推敲,才找到如何定義自己的資料結構進行平行運算!


作法很簡單,先把你想要的資料結構定義在 Renderscript (myscript.rs) 檔案內,如 C 語言的 structure:


#pragma version(1)
#pragma rs java_package_name(com.example.android.rs.MyParallelCompute)


#include "rs_graphics.rsh"


struct MyDataIn {
        int a;
        int b;
};


//struct MyDataOut {
//         int sum;
//};
//void root(const struct MyDataIn *in, struct MyDataOut* out) {


void root(const struct MyDataIn *in, int* out) {
        //out->sum = (int)a+b;
        *out = in->a + in->b;
        rsDebug("myscript a=", (int) in->a);
        rsDebug("myscript b=", (int) in->b);
}


如此一來,編譯後自動產生 ScriptField_MyDataIn.java (gen/com.example.android.rs.MyParallelCompute裡),之後在 Java 端撰寫程式時,使用這個 class 來包裝你的資料:


private void createScript() {
        mRS = RenderScript.create(this);

        int myDataCount = 5;


        ScriptField_MyDataIn in = new ScriptField_MyDataIn(mRS,myDataCount);
        //ScriptField_MyDataOut out = new ScriptField_MyDataOut(mRS,myDataCount,myDataCount);


        // initial data
        for( int i=0 ; i<myDataCount ; ++i) {
                in.set_a(i, i, false);
                in.set_b(i, i*2, false);
        }
        in.copyAll();


        //Allocation dataOut = Allocation.createTyped(mRS, out.getType());
        Allocation dataOut = Allocation.createSized(mRS, Element.I32(mRS), myDataCount);


        // call renderscript
        mScript = new ScriptC_myscript(mRS, getResources(), R.raw.myscript);
        mScript.forEach_root(in.getAllocation(),dataOut);


        //byte []x = new byte[ ScriptField_MyDataOut.Item.sizeof * myDataCount ];
        //dataOut.copyTo(x);


        int[] x = new int[myDataCount];
        dataOut.copyTo(x);


        // result data
        for( int i=0 ; i<myDataCount ; ++i) {
                //Log.e("MyParalle","(a,b,sum)=("+in.get_a(i)+"+"+in.get_b(i)+"="+out.get_sum(i)+")");
                Log.e("MyParalle","(a,b,sum)=("+in.get_a(i)+"+"+in.get_b(i)+"="+x[i]+")");
        }
}


此例很簡單,使用平行運算把輸入的資料(struct MyDataIn)進行相加後輸出(int)。紅色是把資料轉成 RS 的輸入,綠色則是用來儲存運算結果,而藍色則是把綠色取得的資料,轉成在 Java 常用的結構。


幾個小筆記:



  • 用 forEach_root 進行平行運算,輸入的資料個數要跟輸出個數一樣才能使用,在此資料個數就是 myDataCount,而從 Java 傳遞給 forEach_root 的參數輸入跟輸出必須是 Allocation 型態

  • 想要自訂結構,請在 *.rs 先定義(如 struct MyDataIn),接著編譯後,則可以再 Java 中使用(如 ScriptField_MyDataIn)

  • 在 Java 中使用 ScriptField_* 進行資料初始化後,想要把它變成有效的 Allocation 時,記得先做 copyAll(),不然則是每次設值時,最後一個 copyNow 參數設定成 true,詳情起看 ScriptField_*.java 查閱實作

  • 運算後的資料也是 Allocation,必須把它轉成自己的資料結構,由於 Allocation 目前只支援輸出(copyTo)成 int [], short [], float [], byte[] 和 Bitmap 等,所以建議先以這些結構來設計,不然輸出還要花心力去做轉換,希望之後的架構可以支援直接輸出成自訂結構

  • Allocation 初始化有不少 Element.XXX 函式可以使用,例如 rs 用 void root( uchar4 *in ) 的話,那就用 Element.U8_4(mRS) 來對應


2012年3月4日 星期日

PayPal 使用心得


最近試用了一下 PayPal,覺得挺方便的,可以用在國際交易方面,例如購買商品等等。用法十分簡單,只要依自己習慣的貨幣存入帳戶,接著進行交易時,可以匯出對方貨幣,在按幾步後,就完成交易了!至於手續費的部分,可能還要查閱一下,以我這次用買家(付錢)的角度來看,看起來沒有任何手續費,但是,魔鬼都藏在細節裡,其實也存在一種手續費叫作「匯率」。


例如:


在 PayPal 存了美金 20 元,想要購買港幣 100 元的東西,使用 PayPal 需要支付 13.23 美金,過程中沒有任何手續費。


那匯率是多少?


1 美金 = 7.56 港幣


但問 Google 可以查到美金港幣的匯率是 1:7.76 左右,因此等於每一塊美金少了 0.2 港幣的價值,因此變相的手續費就在這裡。


目前不太清楚金額大小會不會影響匯率,如果匯率不會因金額大而變好的話,那變相的手續費還滿可觀的 Orz 


Android 開發筆記 - 實作 Mono 照片特效 @ Ubuntu 10.04

tw.study.rs_screenout


之前接觸 Renderscript - HelloCompute 時,第一次了解 Mono 特效是怎樣做的。這次則是要來筆記純用 Java 和 NDK 作的方式。


環境概述(以 Renderscript - HelloCompute 架構為例):


private Bitmap mBitmapIn;
private Bitmap mBitmapOut;


private Bitmap loadBitmap(int resource) {
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;
        return BitmapFactory.decodeResource(getResources(), resource, options);
}


protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);


        ...
        mBitmapIn = loadBitmap(R.drawable.data); // R.drawable.data 是一張圖片
        mBitmapOut = Bitmap.createBitmap(mBitmapIn.getWidth(), mBitmapIn.getHeight(), mBitmapIn.getConfig()); // 空資料,大小跟 mBitmapIn 一樣
        ...

        // doMonoByJava(); // use Java only
        // doMonoByNDK(); // use NDK
        // createScript();     // use Renderscript
        ...
}


純 Java 版:


private void doMonoByJava() {
        final float gMonoMult[] = {0.299f, 0.587f, 0.114f};
        int imageHeight = mBitmapIn.getHeight();
        int imageWidth = mBitmapIn.getWidth();

        /* only assign, 速度慢
        for( int i=0 ;i<imageWidth; ++i )
                for( int j=0;j<imageHeight; ++j)
                        mBitmapOut.setPixel(i, j, mBitmapIn.getPixel(i, j));
        */

        /* only assign, 速度快
        int[] pixels = new int[imageWidth*imageHeight];
        mBitmapIn.getPixels(pixels,0,imageWidth,0,0,imageWidth,imageHeight);
        mBitmapOut.setPixels(pixels, 0, imageWidth, 0, 0, imageWidth, imageHeight);
        */


        int[] pixels = new int[imageWidth*imageHeight];
        mBitmapIn.getPixels(pixels,0,imageWidth,0,0,imageWidth,imageHeight);
        for( int i=0 ; i<imageHeight*imageWidth ; ++i ) {
                int R = (pixels[i] >> 16) & 0xff; 
                int G = (pixels[i] >> 8) & 0xff;
                int B = pixels[i] & 0xff;

                int m = (int)((float)R*gMonoMult[0] + (float)G*gMonoMult[1] + (float)B*gMonoMult[2] );
                R = m;
                G = m;
                B = m;


                pixels[i] = 0xff000000 | (R << 16) | (G << 8) | B;
        }
        mBitmapOut.setPixels(pixels, 0, imageWidth, 0, 0, imageWidth, imageHeight);
}


使用 NDK 版:


HelloCompute.java:


package com.example.android.rs.hellocompute;

public class HelloCompute extends Activity {
        ...
        static {
                System.loadLibrary("my-jni");
        }
        public native void doByNDK( int [] pixels, int size);

        private void doMonoByNDK() {
                int imageHeight = mBitmapIn.getHeight();
                int imageWidth = mBitmapIn.getWidth();
                int size = imageWidth*imageHeight;
                int[] pixels = new int[size];
                mBitmapIn.getPixels(pixels,0,imageWidth,0,0,imageWidth,imageHeight);
                doByNDK(pixels,size);
                mBitmapOut.setPixels(pixels, 0, imageWidth, 0, 0, imageWidth, imageHeight);
        }
        ...
}


my-jni.c:


#include <jni.h>
void Java_com_example_android_rs_hellocompute_HelloCompute_doByNDK( JNIEnv* env, jobject thiz, jintArray pixels, jint size) {
        float gMonoMult[] = {0.299f, 0.587f, 0.114f};
        int i, R, G, B, m;


        jboolean isCopy = JNI_FALSE;
        jint *jpixels = (*env)->GetIntArrayElements(env, pixels, &isCopy);


        for(i=0 ; i<size ; ++i ) {
                R = (jpixels[i] >> 16) & 0xff; //bitwise shifting
                G = (jpixels[i] >> 8) & 0xff;
                B = jpixels[i] & 0xff;
                m = (int)((float)R*gMonoMult[0] + (float)G*gMonoMult[1] + (float)B*gMonoMult[2] );
                R = m;
                G = m;
                B = m;
                jpixels[i] = 0xff000000 | (R << 16) | (G << 8) | B;
        }
}


若要計算效率,可以再用這段程式碼:


Long timeCost = System.currentTimeMillis();

// do something ...

timeCost = System.currentTimeMillis() - timeCost;
System.out.println("Cost:"+timeCost);