Return to bitmap_avx2.cpp CVS log

Up to [Isaki's NoNo m68k/m88k emulator] / nono / lib

Annotation of nono/lib/bitmap_avx2.cpp, revision 1.1

1.1     ! root        1: //
        !             2: // nono
        !             3: // Copyright (C) 2024 nono project
        !             4: // Licensed under nono-license.txt
        !             5: //
        !             6: 
        !             7: //
        !             8: // ビットマップ (AVX2)
        !             9: //
        !            10: 
        !            11: #include "bitmap.h"
        !            12: #include <x86intrin.h>
        !            13: 
        !            14: // I8 から RGBX への変換。
        !            15: void
        !            16: BitmapRGBX::CopyLineI8_avx2(uint32 *d32, const uint8 *s8, uint width,
        !            17:        const Color *palette)
        !            18: {
        !            19:        uint packed = width & ~7;
        !            20: 
        !            21:        const uint8 *s8total  = s8 + width;
        !            22:        const uint8 *s8packed = s8 + packed;
        !            23: 
        !            24:        for (; s8 < s8packed; ) {
        !            25:                // 8ピクセルずつ処理する
        !            26: 
        !            27:                // s8 は BitmapI8 なのでビッグエンディアン並びに相当。
        !            28:                // idx0 = $00000000'00000000'I7I6I5I4'I3I2I1I0
        !            29:                __m128i idx0 = _mm_loadl_epi64((const __m128i *)s8);
        !            30:                s8 += 8;
        !            31: 
        !            32:                // idx  = $000000I7'000000I6'000000I5'000000I4'
        !            33:                //         000000I3'000000I2'000000I1'000000I0
        !            34:                __m256i idx = _mm256_cvtepu8_epi32(idx0);
        !            35: 
        !            36:                // 8個の 32bit インデックスから XBGR を取得
        !            37:                // c  = $00B7G7R7'00B6G6R6'00B5G5R5'00B4G4R4'
        !            38:                //       00B3G3R3'00B2G2R2'00B1G1R1'00B0G0R0
        !            39:                __m256i c = _mm256_i32gather_epi32((const int *)palette, idx, 4);
        !            40: 
        !            41:                _mm256_storeu_si256((__m256i *)d32, c);
        !            42:                d32 += 8;
        !            43:        }
        !            44: 
        !            45:        // 残りは通常通り処理
        !            46:        if (s8 < s8total) {
        !            47:                CopyLineI8_gen(d32, s8, (width - packed), palette);
        !            48:        }
        !            49: }
        !            50: 
        !            51: // RGBX から RGB への変換。
        !            52: void
        !            53: BitmapRGBX::ConvertToRGB_avx2(BitmapRGB& dst) const
        !            54: {
        !            55:        const BitmapRGBX& src = *this;
        !            56: 
        !            57:        // 256bit リニアに使えれば下詰めで済んだんだが、上位 128bit と
        !            58:        // 下位 128bit をまたいでシャッフルは出来なくて、かつこの後のストアは
        !            59:        // 連続領域への書き込みになるので、中央でつなげておく。うーん。
        !            60:        const __m256i shuff = _mm256_set_epi8(
        !            61:                -1,-1,-1,-1, 14,13,12,10,  9, 8, 6, 5,  4, 2, 1, 0,
        !            62:                14,13,12,10,  9, 8, 6, 5,  4, 2, 1, 0, -1,-1,-1,-1
        !            63:        );
        !            64:        const __m256i mask = _mm256_set_epi32(0, -1, -1, -1,  -1, -1, -1, 0);
        !            65: 
        !            66:        // この変換は一次元配列とみなしても行える。
        !            67:        // モニタ等のパネルでも呼ばれるので何ピクセルで割り切れるかの前提は不可。
        !            68:        uint total  = GetWidth() * GetHeight();
        !            69:        uint packed = total & ~7;
        !            70: 
        !            71:        const uint32 *s32 = (const uint32 *)src.GetRowPtr(0);
        !            72:        const uint32 *s32total  = s32 + total;
        !            73:        const uint32 *s32packed = s32 + packed;
        !            74: 
        !            75:        uint32 *d32 = (uint32 *)dst.GetRowPtr(0);
        !            76:        for (; s32 < s32packed; ) {
        !            77:                // 8ピクセルずつ処理する
        !            78: 
        !            79:                // c  = $x7B7G7R7'x6B6G6R6'x5B5G5R5'x4B4G4R4'
        !            80:                //       x3B3G3R3'x2B2G2R2'x1B1G1R1'x0B0G0R0
        !            81:                __m256i c = _mm256_load_si256((const __m256i *)s32);
        !            82:                s32 += 8;
        !            83: 
        !            84:                // res= $00000000'B7G7R7B6'G6R6B5G5'R5B4G4R4'
        !            85:                //       B3G3R3B2'G2R2B1G1'R1B0G0R0'00000000
        !            86:                __m256i res = _mm256_shuffle_epi8(c, shuff);
        !            87: 
        !            88:                // 先頭(下位)と末尾(上位)の 32bit ずつを除いたところを書き出す。
        !            89:                _mm256_maskstore_epi32((int *)(d32 - 1), mask, res);
        !            90:                d32 += 6;
        !            91:        }
        !            92: 
        !            93:        uint8 *d8 = (uint8 *)d32;
        !            94:        for (; s32 < s32total; ) {
        !            95:                // 残りを1ピクセルずつ処理する
        !            96:                Color c(*s32++);
        !            97:                *d8++ = c.r;
        !            98:                *d8++ = c.g;
        !            99:                *d8++ = c.b;
        !           100:        }
        !           101: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.