簡體   English   中英

了解Ringdroid代碼+ Android

[英]Understanding Ringdroid code + Android

這個問題是給那些熟悉Ringdroid代碼的人的。 我在理解Ringdroid 代碼的CheapAMR.java ”文件時遇到了一些困難。 我必須在Blackberry項目中實現此代碼,但首先我想正確地理解代碼。 我無法理解此文件中以下數組的用途:

  1. int[] adaptiveIndex
  2. int[] adaptiveGain
  3. int[] fixedGain
  4. int[][] pulse

我也無法理解如何填充這些數組的值。 我不知道如何用Google搜索這個問題,因為我不知道它們在這段代碼中的作用:

    void getMR122Params(int[] bits,
                            int[] adaptiveIndex,
                            int[] adaptiveGain,
                            int[] fixedGain,
                            int[][] pulse) {
            adaptiveIndex[0] =
                0x01 * bits[45] +
                0x02 * bits[43] +
                0x04 * bits[41] +
                0x08 * bits[39] +
                0x10 * bits[37] +
                0x20 * bits[35] +
                0x40 * bits[33] +
                0x80 * bits[31] +
                0x100 * bits[29];
            adaptiveIndex[1] =
                0x01 * bits[242] +
                0x02 * bits[79] +
                0x04 * bits[77] +
                0x08 * bits[75] +
                0x10 * bits[73] +
                0x20 * bits[71];
            adaptiveIndex[2] =
                0x01 * bits[46] +
                0x02 * bits[44] +
                0x04 * bits[42] +
                0x08 * bits[40] +
                0x10 * bits[38] +
                0x20 * bits[36] +
                0x40 * bits[34] +
                0x80 * bits[32] +
                0x100 * bits[30];
            adaptiveIndex[3] =
                0x01 * bits[243] +
                0x02 * bits[80] +
                0x04 * bits[78] +
                0x08 * bits[76] +
                0x10 * bits[74] +
                0x20 * bits[72];

            adaptiveGain[0] =
                0x01 * bits[88] +
                0x02 * bits[55] +
                0x04 * bits[51] +
                0x08 * bits[47];
            adaptiveGain[1] =
                0x01 * bits[89] +
                0x02 * bits[56] +
                0x04 * bits[52] +
                0x08 * bits[48];
            adaptiveGain[2] =
                0x01 * bits[90] +
                0x02 * bits[57] +
                0x04 * bits[53] +
                0x08 * bits[49];
            adaptiveGain[3] =
                0x01 * bits[91] +
                0x02 * bits[58] +
                0x04 * bits[54] +
                0x08 * bits[50];

            fixedGain[0] =
                0x01 * bits[104] +
                0x02 * bits[92] +
                0x04 * bits[67] +
                0x08 * bits[63] +
                0x10 * bits[59];
            fixedGain[1] =
                0x01 * bits[105] +
                0x02 * bits[93] +
                0x04 * bits[68] +
                0x08 * bits[64] +
                0x10 * bits[60];
            fixedGain[2] =
                0x01 * bits[106] +
                0x02 * bits[94] +
                0x04 * bits[69] +
                0x08 * bits[65] +
                0x10 * bits[61];
            fixedGain[3] =
                0x01 * bits[107] +
                0x02 * bits[95] +
                0x04 * bits[70] +
                0x08 * bits[66] +
                0x10 * bits[62];

            pulse[0][0] =
                0x01 * bits[122] +
                0x02 * bits[123] +
                0x04 * bits[124] +
                0x08 * bits[96];
            pulse[0][3] =
                0x01 * bits[125] +
                0x02 * bits[126] +
                0x04 * bits[127] +
                0x08 * bits[100];
            pulse[0][2] =
                0x01 * bits[128] +
                0x02 * bits[129] +
                0x04 * bits[130] +
                0x08 * bits[108];
            pulse[0][3] =
                0x01 * bits[131] +
                0x02 * 

bits[132] +
            0x04 * bits[133] +
            0x08 * bits[112];
        pulse[0][4] =
            0x01 * bits[134] +
            0x02 * bits[135] +
            0x04 * bits[136] +
            0x08 * bits[116];
        pulse[0][5] =
            0x01 * bits[182] +
            0x02 * bits[183] +
            0x04 * bits[184];
        pulse[0][6] =
            0x01 * bits[185] +
            0x02 * bits[186] +
            0x04 * bits[187];
        pulse[0][7] =
            0x01 * bits[188] +
            0x02 * bits[189] +
            0x04 * bits[190];
        pulse[0][8] =
            0x01 * bits[191] +
            0x02 * bits[192] +
            0x04 * bits[193];
        pulse[0][9] =
            0x01 * bits[194] +
            0x02 * bits[195] +
            0x04 * bits[196];
        pulse[1][0] =
            0x01 * bits[137] +
            0x02 * bits[138] +
            0x04 * bits[139] +
            0x08 * bits[97];
        pulse[1][4] =
            0x01 * bits[140] +
            0x02 * bits[141] +
            0x04 * bits[142] +
            0x08 * bits[101];
        pulse[1][2] =
            0x01 * bits[143] +
            0x02 * bits[144] +
            0x04 * bits[145] +
            0x08 * bits[109];
        pulse[1][3] =
            0x01 * bits[146] +
            0x02 * bits[147] +
            0x04 * bits[148] +
            0x08 * bits[113];
        pulse[1][4] =
            0x01 * bits[149] +
            0x02 * bits[150] +
            0x04 * bits[151] +
            0x08 * bits[117];
        pulse[1][5] =
            0x01 * bits[197] +
            0x02 * bits[198] +
            0x04 * bits[199];
        pulse[1][6] =
            0x01 * bits[200] +
            0x02 * bits[201] +
            0x04 * bits[202];
        pulse[1][7] =
            0x01 * bits[203] +
            0x02 * bits[204] +
            0x04 * bits[205];
        pulse[1][8] =
            0x01 * bits[206] +
            0x02 * bits[207] +
            0x04 * bits[208];
        pulse[1][9] =
            0x01 * bits[209] +
            0x02 * bits[210] +
            0x04 * bits[211];
        pulse[2][0] =
            0x01 * bits[152] +
            0x02 * bits[153] +
            0x04 * bits[154] +
            0x08 * bits[98];
        pulse[2][5] =
            0x01 * bits[155] +
            0x02 * bits[156] +
            0x04 * bits[157] +
            0x08 * bits[102];
        pulse[2][2] =
            0x01 * bits[158] +
            0x02 * bits[159] +
            0x04 * bits[160] +
            0x08 * bits[110];
        pulse[2][3] =
            0x01 * bits[161] +
            0x02 * bits[162] +
            0x04 * bits[163] +
            0x08 * bits[114];
        pulse[2][4] =
            0x01 * bits[164] +
            0x02 * bits[165] +
            0x04 * bits[166] +
            0x08 * bits[118];
        pulse[2][5] =
            0x01 * bits[212] +
            0x02 * bits[213] +
            0x04 * bits[214];
        pulse[2][6] =
            0x01 * bits[215] +
            0x02 * bits[216] +
            0x04 * bits[217];
        pulse[2][7] =
            0x01 * bits[218] +
            0x02 * bits[219] +
            0x04 * bits[220];
        pulse[2][8] =
            0x01 * bits[221] +
            0x02 * bits[222] +
            0x04 * bits[223];
        pulse[2][9] =
            0x01 * bits[224] +
            0x02 * bits[225] +
            0x04 * bits[226];
        pulse[3][0] =
            0x01 * bits[167] +
            0x02 * bits[168] +
            0x04 * bits[169] +
            0x08 * bits[99];
        pulse[3][6] =
            0x01 * bits[170] +
            0x02 * bits[171] +
            0x04 * bits[172] +
            0x08 * bits[103];
        pulse[3][2] =
            0x01 * bits[173] +
            0x02 * bits[174] +
            0x04 * bits[175] +
            0x08 * bits[111];
        pulse[3][3] =
            0x01 * bits[176] +
            0x02 * bits[177] +
            0x04 * bits[178] +
            0x08 * bits[115];
        pulse[3][4] =
            0x01 * bits[179] +
            0x02 * bits[180] +
            0x04 * bits[181] +
            0x08 * bits[119];
        pulse[3][5] =
            0x01 * bits[227] +
            0x02 * bits[228] +
            0x04 * bits[229];
        pulse[3][6] =
            0x01 * bits[230] +
            0x02 * bits[231] +
            0x04 * bits[232];
        pulse[3][7] =
            0x01 * bits[233] +
            0x02 * bits[234] +
            0x04 * bits[235];
        pulse[3][8] =
            0x01 * bits[236] +
            0x02 * bits[237] +
            0x04 * bits[238];
        pulse[3][9] =
            0x01 * bits[239] +
            0x02 * bits[240] +
            0x04 * bits[241];
    }

如果有人對此有所了解,請也幫助我。

我的解釋是(輸入)位數組分配到其他(輸出)數組,這樣某些位的“位掩碼”將進入輸出數組的int值。

位在任何索引處應僅包含0和1,然后使用此示例

bits[88]=1;
bits[55]=0;
bits[51]=1;
bits[47]=0;

adaptiveGain[0] =
                0x01 * bits[88] +
                0x02 * bits[55] +
                0x04 * bits[51] +
                0x08 * bits[47];

adaptiveGain [0]將包含1 * 1 + 0 * 2 + 1 * 4 + 0 * 8 = 5

注意0x是十六進制表示法。 所以0x100十六進制= 256 dec。

暫無
暫無

聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.

 
粵ICP備18138465號  © 2020-2024 STACKOOM.COM