1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 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

-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
!
 
 
 
 
 
-
-
!
-
|
|
|
-
-
!
|
-
!
-
|
|
!
|
-
!
-
|
|
!
|
-
!
|
-
!
-
|
!
!
|
-
!
|
!
|
|
!

/**
 * @brief
 *      各色成分のカラーマスク値とその要素数を受け取り、その値が正しい値かどうか、
 *      及び各カラーマスクのビット位置とビット数を返す。
 *
 * @param[in] masks
 *      カラーマスク値の配列。
 * @param[in] mask_num
 *      masks の要素数(＝カラーマスク数)。
 *      通常は 3 で、α成分のカラーマスクもある場合は 4 。
 * @param[out] positions
 *      各カラーマスクのビット位置格納先の配列。不要ならば NULL 。
 * @param[out] bitcounts
 *      各カラーマスクのビット数格納先の配列。不要ならば NULL 。
 *
 * @retval true  カラーマスク値が正しい場合。
 * @retval false カラーマスク値が不正である場合。
 */
bool check_colormasks(
    const unsigned long* const masks,
    int mask_num = 3,
    int* positions = NULL,
    int* bitcounts = NULL)
{
    // カラーマスク毎の処理
    for (int i = 0; i < mask_num; i++)
    {
        int pos = 0, bit = 0;
 
        if (masks[i] != 0)
        {
            // 有効ビットが連続しているか調べる
            unsigned long mask = masks[i];
 
            // マスクの最下位ビットが 0 の間ループ
            while ((mask & 0x00000001) == 0)
            {
                pos++;
                mask >>= 1;
            }
 
            // マスクの最下位ビットが 1 の間ループ
            while ((mask & 0x00000001) != 0)
            {
                bit++;
                mask >>= 1;
            }
 
            // マスクが 0 でないなら不正
            if (mask != 0) { return false; }
 
            // 他のカラーマスク値と重なっていないか調べる
            for (int j = i + 1; j < mask_num; j++)
            {
                if ((masks[i] & masks[j]) != 0) { return false; }
            }
        }
 
        // ビット位置及びビット数を保存
        if (positions != NULL) { positions[i] = pos; }
        if (bitcounts != NULL) { bitcounts[i] = bit; }
    }
 
    return true;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 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

-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
!
 
 
 
 
 
 
-
-
!
|
-
!
|
-
!
|
-
-
!
-
-
!
|
|
-
!
!
!
|
-
!
|
|
!

/**
 * @brief
 *      ピクセルデータ、各色成分のカラーマスク値、及びその要素数を受け取り、
 *      各カラーマスクに対応する色成分値を返す。
 *
 * @param[in] pixel
 *     ピクセルデータ。
 * @param[in] masks
 *     カラーマスク値の配列。
 * @param[in] mask_num
 *     masks の要素数(＝カラーマスク数)。
 *     通常は 3 で、α成分のカラーマスクもある場合は 4 。
 * @param[out] colors
 *     各カラーマスクに対応する色成分値格納先の配列。
 * @param[out] bitcounts
 *     各カラーマスクのビット数格納先の配列。不要ならば NULL 。
 *
 * @retval true  カラーマスク値が正しい場合。
 * @retval false カラーマスク値が不正である場合。
 */
bool get_maskedcolors(
    unsigned long pixel,
    const unsigned long* const masks,
    int mask_num,
    unsigned long* colors,
    int* bitcounts = NULL)
{
    // カラーマスク数が 0 以下は不可
    if (mask_num <= 0) { return false; }
 
    // ビット位置保存先配列作成
    int* positions = new int[mask_num];
 
    // カラーマスク値のチェックとビット位置取得
    bool valid = check_colormasks(masks, mask_num, positions, bitcounts);
    if (valid)
    {
        // カラーマスク毎の処理
        for (int i = 0; i < mask_num; i++)
        {
            // ピクセルデータとマスクを右シフト
            unsigned long px = (pixel >> positions[i]);
            unsigned long mask = (masks[i] >> positions[i]);
 
            // 論理積した値が色成分値
            colors[i] = (px & mask);
        }
    }
 
    // 配列解放
    delete [] positions;
 
    return valid;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24

-
|
|
|
|
|
|
|
|
|
|
|
!
 
-
-
!
|
|
-
|
|
!
!

/**
 * @brief
 *      あるビット数で表されている数値を他のビット数に相対変換して返します。
 *
 * @param[in] src
 *      bit_from ビットで表されている元データを指定します。
 * @param[in] bit_from
 *      src のビット数を指定します。
 * @param[in] bit_to
 *      相対変換するビット数を指定します。
 *
 * @return 相対変換された値を返します。
 */
unsigned long bits2bits(unsigned long src, int bit_from, int bit_to)
{
    // 指定したビット数で表される数値の最大値を算出
    unsigned long max_from = (1UL << bit_from) - 1;
    unsigned long max_to = (1UL << bit_to) - 1;
 
    // 割る数の半分を割られる数に足すことで四捨五入を近似
    // ※ unsigned long x, y; に対して次の式が成り立つ。
    // ※ (unsigned long)round((double)x/y) ≒ (x+(y/2))/y
    return ((src * max_to + (max_from / 2)) / max_from);
}