FC2カウンター FPGAの部屋 HSV の値を変更する HSVConverter を作る2
fc2ブログ

FPGAやCPLDの話題やFPGA用のツールの話題などです。 マニアックです。 日記も書きます。

FPGAの部屋

FPGAの部屋の有用と思われるコンテンツのまとめサイトを作りました。Xilinx ISEの初心者の方には、FPGAリテラシーおよびチュートリアルのページをお勧めいたします。

HSV の値を変更する HSVConverter を作る2

HSV の値を変更する HSVConverter を作る1”の続き。

前回は、これまで、RGB-HSV 変換 IP と HSV-RGB 変換 IP を作ってきたが、HSV の値を変更する HSVConverter IP を Vitis HLS 2023.1 で作成しようということで、概要を述べた。今回は、ソースコードの HSVConverter.cpp とテストベンチの HSVConverter_tb.cpp を示して、Vitis HLS 2023.1 の HSVConverter プロジェクトを作成する。

最初に HSVConverter.h を示す。

// HSVConverter.h
// 2023/10/21 by marsee
//

#ifndef __HSVCONVERTER_H__
#define __HSVCONVERTER_H__

#define ORG_IMGwAxiVdma 0
#define HSV_CONVwAxiVdma 1
#define ORG_IMGwAxiDma 2
#define HSV_CONVwAxiDma 3

#endif


ソースコードの HSVConverter.cpp を示す。

// HSVConverter.cpp
// 2023/10/21 by marsee
//

#include <stdint.h>
#include <ap_int.h>
#include <hls_stream.h>
#include <ap_axi_sdata.h>
#include <ap_fixed.h>

#include "HSVConverter.h"

int hsv_conv(ap_uint<32> data, ap_uint<32> &val, int32_t h_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> s_mult, int32_t s_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> v_mult, int32_t v_ad);
int separate_hsv(ap_uint<25> hsv, ap_uint<9> &h, ap_uint<8> &s, ap_uint<8> &v);

int HSVConverter(hls::stream<ap_axiu<32,1,1,1> >& ins,
        hls::stream<ap_axiu<32,1,1,1> >& outs, int32_t function,
        int32_t row_size, int32_t col_size,
        int32_t h_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> s_mult, int32_t s_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> v_mult, int32_t v_add){
#pragma HLS INTERFACE mode=s_axilite port=return
#pragma HLS INTERFACE mode=axis register_mode=both port=ins register
#pragma HLS INTERFACE mode=axis register_mode=both port=outs register
#pragma HLS INTERFACE mode=s_axilite port=function
#pragma HLS INTERFACE mode=s_axilite port=row_size
#pragma HLS INTERFACE mode=s_axilite port=col_size
#pragma HLS INTERFACE mode=s_axilite port=h_add
#pragma HLS INTERFACE mode=s_axilite port=s_mult
#pragma HLS INTERFACE mode=s_axilite port=s_add
#pragma HLS INTERFACE mode=s_axilite port=v_mult
#pragma HLS INTERFACE mode=s_axilite port=v_add

    ap_axiu<32,1,1,1> pix;
    ap_axiu<32,1,1,1> hsvd;
    ap_uint<32> val;

    LOOP_WAIT_USER : do {   // user が 1になった時にフレームがスタートする
#pragma HLS LOOP_TRIPCOUNT min=1 max=1 avg=1
        ins >> pix;
        if(function==ORG_IMGwAxiDma || function==HSV_CONVwAxiDma)
            break;
    } while(pix.user == 0);

    LOOP_Y: for(int y=0; y<row_size; y++){
#pragma HLS LOOP_TRIPCOUNT avg=600 max=1080 min=48
        LOOP_X: for(int x=0; x<col_size; x++){
#pragma HLS LOOP_TRIPCOUNT avg=800 max=1920 min=64
#pragma HLS PIPELINE II=1
            if (!(x==0 && y==0))    // 最初の入力はすでに入力されている
                ins >> pix; // AXI4-Stream からの入力

            hsv_conv(pix.data, val, h_add, s_mult, s_add, v_mult, v_add);
            hsvd.data = val;

            if(function==ORG_IMGwAxiVdma || function == HSV_CONVwAxiVdma){
                if(x==0 && y==0) // 最初のピクセル
                    hsvd.user = 1;
                else
                    hsvd.user = 0;
                if(x == (col_size-1)) // 行の最後
                    hsvd.last = 1;
                else
                    hsvd.last = 0;
            }else{
                hsvd.user = 0;
                hsvd.last = pix.last;
            }
            hsvd.keep = 0x7;
            hsvd.strb = 0x7;
            if(function==HSV_CONVwAxiVdma || function==HSV_CONVwAxiDma)
                outs << hsvd;
            else
                outs << pix;
        }
    }
    return(0);
}

// hsv_converter
// h に h_add を加算する
// s に
int hsv_conv(ap_uint<32> data, ap_uint<32> &val, int32_t h_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> s_mult, int32_t s_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> v_mult, int32_t v_add){
    ap_uint<9> h;
    ap_uint<8> s , v;
    int32_t calc_h;
    ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> calc_st, calc_vt, ap_05;
    int32_t calc_s, calc_v;
    ap_uint<9> ht;
    ap_uint<8> st, vt;

    ap_05 = (ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT>)0.5;
    separate_hsv(data, h, s, v);
    calc_h = (h + h_add)%360;
    if(calc_h < 0)
        calc_h = 360 + calc_h;
    calc_st = (ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT>)s * s_mult;
    calc_s = (uint32_t)(calc_st + ap_05) + s_add;
    calc_vt = (ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT>)v * v_mult;
    calc_v = (uint32_t)(calc_vt + ap_05) + v_add;
    if(calc_s < 0)
        calc_s = 0;
    else if(calc_s > 255)
        calc_s = 255;
    if(calc_v < 0)
        calc_v = 0;
    else if(calc_v > 255)
        calc_v = 255;
    ht = (ap_uint<9>)calc_h;
    st = (ap_uint<8>)calc_s;
    vt = (ap_uint<8>)calc_v;

    val = ((ap_uint<32>)ht << 16)+((ap_uint<32>)st << 8)+(ap_uint<32>)vt;
    return(0);
}

// separate_hsv
// HSVを分離する
// HSVのフォーマットは、{H(9bits), S(8bits), V(8bits)}, 1pixel = 32bits
//
int separate_hsv(ap_uint<25> hsv, ap_uint<9> &h, ap_uint<8> &s, ap_uint<8> &v){
    v = (ap_uint<8>)(hsv & 0x1ff);
    s = (ap_uint<8>)((hsv>>8) & 0xff);
    h = (ap_uint<9>)((hsv>>16) & 0x1ff);
    return(0);
}


テストベンチの HSVConverter_tb.cpp を示す。

// HSVConverter_tb.cpp
// 2023/10/21 by marsee
//

// HSVCwXilinxVideoStandard を define すると axi_vdma 用となり、コメントアウトすると axi_dma 用になる
//

#include <stdio.h>
#include <stdint.h>
#include <ap_int.h>
#include <hls_stream.h>
#include <ap_axi_sdata.h>
#include "opencv2/opencv.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgcodecs/imgcodecs.hpp"

#include "HSVConverter.h"

#define HSVCwXilinxVideoStandard

constexpr int size = 3;

int HSVConverter(hls::stream<ap_axiu<32,1,1,1> >& ins,
        hls::stream<ap_axiu<32,1,1,1> >& outs, int32_t function,
        int32_t row_size, int32_t col_size,
        int32_t h_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> s_mult, int32_t s_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> v_mult, int32_t v_add);
int HSVConverter_soft(hls::stream<ap_axiu<32,1,1,1> >& ins,
        hls::stream<ap_axiu<32,1,1,1> >& outs, int32_t function,
        int32_t row_size, int32_t col_size,
        int32_t h_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> s_mult, int32_t s_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> v_mult, int32_t v_add);
int hsv_conv_soft(ap_uint<32> data, ap_uint<32> &val, int32_t h_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> s_mult, int32_t s_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> v_mult, int32_t v_ad);
int separate_hsv_soft(ap_uint<25> hsv, ap_uint<9> &h, ap_uint<8> &s, ap_uint<8> &v);
int32_t RGB2HSV(int32_t rgb);
int32_t HSV2RGB(int32_t hsv);

const char INPUT_JPG_FILE[] = "test2.jpg";
const char OUTPUT_JPG_FILE[] = "hsv_converter.jpg";
const char ORG_OUT_JPG_FILE[] = "hsv_converter2.jpg";

int main(){
    hls::stream<ap_axiu<32,1,1,1> > ins, ins2;
    hls::stream<ap_axiu<32,1,1,1> > ins_soft;
    hls::stream<ap_axiu<32,1,1,1> > outs, outs2;
    hls::stream<ap_axiu<32,1,1,1> > outs_soft;
    ap_axiu<32,1,1,1> pix;
    ap_axiu<32,1,1,1> vals, vals_soft;

    // JPG ファイルをMat に読み込む
    cv::Mat img = cv::imread(INPUT_JPG_FILE);

    // ピクセルを入れる領域の確保
    std::vector<int32_t> rd_bmp(sizeof(int32_t)*img.cols*img.rows);
    std::vector<int32_t> hw_hsv_conv(sizeof(int32_t)*(img.cols)*(img.rows));
    std::vector<int32_t> sw_hsv_conv(sizeof(int32_t)*(img.cols)*(img.rows));

    // rd_bmp にJPGのピクセルを代入
    cv::Mat_<cv::Vec3b> dst_vec3b = cv::Mat_<cv::Vec3b>(img);
    for (int y=0; y<img.rows; y++){
        for (int x=0; x<img.cols; x++){
            cv::Vec3b pixel;
            pixel = dst_vec3b(y,x);
            rd_bmp[y*img.cols+x] = (pixel[0] & 0xff) | ((pixel[1] & 0xff)<<8) | ((pixel[2] & 0xff)<<16); // RGB 8 bits
            // blue - pixel[0]; green - pixel[1]; red - pixel[2];
        }
    }

#ifdef HSVCwXilinxVideoStandard
    // ins に入力データを用意する
    for(int i=0; i<5; i++){ // dummy data
        pix.user = 0;
        pix.data = i;
        pix.last = 0;
        pix.user = 0;
        pix.keep = 0x7;
        pix.strb = 0x7;
        ins << pix;
    }
#endif

    for(int j=0; j < img.rows; j++){
        for(int i=0; i < img.cols; i++){
            pix.data = RGB2HSV((int32_t)rd_bmp[(j*img.cols)+i]);
#ifdef HSVCwXilinxVideoStandard
            if (j==0 && i==0)   // 最初のデータの時に TUSER を 1 にする
                pix.user = 1;
            else
                pix.user = 0;

            if (i == img.cols-1) // 行の最後でTLASTをアサートする
                pix.last = 1;
            else
                pix.last = 0;
#else
            if(j==img.rows-1 && i==img.cols-1)
                pix.last = 1;
            else
                pix.last = 0;
            pix.user = 0;
#endif
            pix.keep = 0x7;
            pix.strb = 0x7;

            ins << pix;
            ins2 << pix;
            ins_soft << pix;
        }
    }

    // Hに180を加えて、SとVは2倍する
#ifdef HSVCwXilinxVideoStandard
    HSVConverter(ins, outs, HSV_CONVwAxiVdma, img.rows, img.cols, 180, 2.0, 0, 2.0, 0); // ハードウェア
    HSVConverter_soft(ins_soft, outs_soft, HSV_CONVwAxiVdma, img.rows, img.cols, 180, 2.0, 0, 2.0, 0);  // ソフトウェア
#else
    HSVConverter(ins, outs, HSV_CONVwAxiDma, img.rows, img.cols, 180, 2.0, 0, 2.0, 0); // ハードウェアのメディアンフィルタ
    HSVConverter_soft(ins_soft, outs_soft, HSV_CONVwAxiDma, img.rows, img.cols, 180, 2.0, 0, 2.0, 0);  // ソフトウェアのメディアンフィルタ
#endif

    // ハードウェアとソフトウェアのメディアンフィルタの値のチェック
    for (int y=0; y<img.rows; y++){ // 結果の画像サイズはx-2, y-2
        for (int x=0; x<img.cols; x++){
            outs >> vals;
            outs_soft >> vals_soft;
            ap_uint<32> val = vals.data;
            hw_hsv_conv[y*img.cols+x] = (int32_t)val;
            if (val != vals_soft.data){
                printf("ERROR HW and SW results mismatch x = %ld, y = %ld, HW = %x, SW = %x\n",
                        x, y, val, vals_soft.data);
                return(1);
            }
        }
    }
    printf("Success HW and SW results match\n");

    const int hsv_conv_row = img.rows;
    const int hsv_conv_cols = img.cols;
    cv::Mat wbmpf(hsv_conv_row, hsv_conv_cols, CV_8UC3);
    // wbmpf に色変換後の画像を入力
    cv::Mat_<cv::Vec3b> sob_vec3b = cv::Mat_<cv::Vec3b>(wbmpf);
    for (int y=0; y<wbmpf.rows; y++){
        for (int x=0; x<wbmpf.cols; x++){
            cv::Vec3b pixel;
            pixel = sob_vec3b(y,x);
            int32_t rbg = HSV2RGB(hw_hsv_conv[y*wbmpf.cols+x]);
            pixel[0] = (rbg & 0xff); // blue
            pixel[1] = ((rbg >> 8) & 0xff); // green
            pixel[2] = ((rbg >> 16) & 0xff); // red
            sob_vec3b(y,x) = pixel;
        }
    }

    // ハードウェアのメディアンフィルタの結果を jpg ファイルへ出力する
    cv::imwrite(OUTPUT_JPG_FILE, wbmpf);

#ifdef HSVCwXilinxVideoStandard
    HSVConverter(ins2, outs2, HSV_CONVwAxiVdma, img.rows, img.cols, 0, 1.0, 32, 1.0, 32);
#else
    HSVConverter(ins2, outs2, HSV_CONVwAxiDma, img.rows, img.cols, 0, 1.0, 32, 1.0, 32);
#endif

    cv::Mat wbmpf2(hsv_conv_row, hsv_conv_cols, CV_8UC3);
    // wbmpf2 に元画像を入力
    sob_vec3b = cv::Mat_<cv::Vec3b>(wbmpf2);
    for (int y=0; y<wbmpf.rows; y++){
        for (int x=0; x<wbmpf.cols; x++){
            cv::Vec3b pixel;
            pixel = sob_vec3b(y,x);
            outs2 >> vals;
            int32_t val = HSV2RGB(vals.data);
            pixel[0] = (val & 0xff); // blue
            pixel[1] = ((val >> 8) & 0xff); // green
            pixel[2] = ((val >> 16) & 0xff); // red
            sob_vec3b(y,x) = pixel;
        }
    }

    // 元画像を jpg ファイルへ出力する
    cv::imwrite(ORG_OUT_JPG_FILE, wbmpf2);

    return(0);
}

int HSVConverter_soft(hls::stream<ap_axiu<32,1,1,1> >& ins,
        hls::stream<ap_axiu<32,1,1,1> >& outs, int32_t function,
        int32_t row_size, int32_t col_size,
        int32_t h_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> s_mult, int32_t s_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> v_mult, int32_t v_add){

    ap_axiu<32,1,1,1> pix;
    ap_axiu<32,1,1,1> hsvd;
    ap_uint<32> val;

    do {   // user が 1になった時にフレームがスタートする
        ins >> pix;
        if(function==ORG_IMGwAxiDma || function==HSV_CONVwAxiDma)
            break;
    } while(pix.user == 0);

    for(int y=0; y<row_size; y++){
        for(int x=0; x<col_size; x++){
            if (!(x==0 && y==0))    // 最初の入力はすでに入力されている
                ins >> pix; // AXI4-Stream からの入力

            hsv_conv_soft(pix.data, val, h_add, s_mult, s_add, v_mult, v_add);
            hsvd.data = val;

            if(function==ORG_IMGwAxiVdma || function == HSV_CONVwAxiVdma){
                if(x==0 && y==0) // 最初のピクセル
                    hsvd.user = 1;
                else
                    hsvd.user = 0;
                if(x == (col_size-1)) // 行の最後
                    hsvd.last = 1;
                else
                    hsvd.last = 0;
            }else{
                hsvd.user = 0;
                hsvd.last = pix.last;
            }
            hsvd.keep = 0x7;
            hsvd.strb = 0x7;
            if(function==HSV_CONVwAxiVdma || function==HSV_CONVwAxiDma)
                outs << hsvd;
            else
                outs << pix;
        }
    }
    return(0);
}

// hsv_converter
// h に h_add を加算する
// s に
int hsv_conv_soft(ap_uint<32> data, ap_uint<32> &val, int32_t h_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> s_mult, int32_t s_add,
        ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> v_mult, int32_t v_add){
    ap_uint<9> h;
    ap_uint<8> s , v;
    int32_t calc_h;
    ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT> calc_st, calc_vt, ap_05;
    int32_t calc_s, calc_v;
    ap_uint<9> ht;
    ap_uint<8> st, vt;

    ap_05 = (ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT>)0.5;
    separate_hsv_soft(data, h, s, v);
    calc_h = (h + h_add)%360;
    if(calc_h < 0)
        calc_h = 360 + calc_h;
    calc_st = (ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT>)s * s_mult;
    calc_s = (uint32_t)(calc_st + ap_05) + s_add;
    calc_vt = (ap_ufixed<16, 8, AP_TRN_ZERO, AP_SAT>)v * v_mult;
    calc_v = (uint32_t)(calc_vt + ap_05) + v_add;
    if(calc_s < 0)
        calc_s = 0;
    else if(calc_s > 255)
        calc_s = 255;
    if(calc_v < 0)
        calc_v = 0;
    else if(calc_v > 255)
        calc_v = 255;
    ht = (ap_uint<9>)calc_h;
    st = (ap_uint<8>)calc_s;
    vt = (ap_uint<8>)calc_v;

    val = ((ap_uint<32>)ht << 16)+((ap_uint<32>)st << 8)+(ap_uint<32>)vt;
    return(0);
}

// separate_hsv
// HSVを分離する
// HSVのフォーマットは、{H(9bits), S(8bits), V(8bits)}, 1pixel = 32bits
//
int separate_hsv_soft(ap_uint<25> hsv, ap_uint<9> &h, ap_uint<8> &s, ap_uint<8> &v){
    v = (ap_uint<8>)(hsv & 0x1ff);
    s = (ap_uint<8>)((hsv>>8) & 0xff);
    h = (ap_uint<9>)((hsv>>16) & 0x1ff);
    return(0);
}

// RGBからHSVに変換
int32_t RGB2HSV(int32_t rgb){
    int32_t r, g, b;
    int32_t h, s, v;
    float ht, st;
    float max, min;
    int32_t hsv;

    b = rgb & 0xff;
    g = (rgb>>8) & 0xff;
    r = (rgb>>16) & 0xff;

    // h と max, min を求める
    if(r==g && g==b && r==b){
        max = (float)r; // 8倍
        min = (float)r;
    }else if(r>=g && r>=b){ // r が最大
        max = (float)r;
        if(g>=b)
            min = (float)b;
        else
            min = (float)g;
    }else if(g>=r && g>=b){ // g が最大
        max = (float)g;
        if(r>=b)
            min = (float)b;
        else
            min = (float)r;
    }else{ // b が最大
        max = (float)b;
        if(r>=g)
            min = (float)g;
        else
            min = (float)r;
    }
    if(max-min == 0.0)
        ht = 0.0;
    else if(max == (float)r)
        ht = 60.0 * (((float)g-(float)b)/(max-min));
    else if(max == (float)g)
        ht = 60.0 * (((float)b-(float)r)/(max-min)) + 120.0; // MAGビットシフトして精度を確保
    else // if(max == b)
        ht = 60.0 * (((float)r-(float)g)/(max-min)) + 240.0; // MAGビットシフトして精度を確保

    if(ht < 0)
        ht += 360.0;
    h = (uint32_t)(ht + 0.5);

    if(max == 0.0)
        st = 0.0;
    else
        st = ((max - min)/max) * 255.0; // MAGビットシフトして精度を確保
    s = (uint32_t)(st + 0.5);

    v = (uint32_t)max;

    hsv = ((h&0x1ff)<<16) + ((s&0xff)<<8) + (v&0xff);

    return(hsv);
}

// HSVからRGBに変換
int32_t HSV2RGB(int32_t hsv){
    int32_t h, s, v;
    float max, min;
    uint8_t r, g, b;
    int32_t rgb;

    h = (hsv >> 16) & 0x1ff;
    s = (hsv >> 8) & 0xff;
    v = hsv & 0xff;

    max = (float)v;
    min = max - ((float)s / 255.0) * max;

    if(h>=0 && h<60){
        r = (uint8_t)max;
        g = (uint8_t)(((float)h / 60.0) * (max - min) + min + 0.5);
        b = (uint8_t)(min + 0.5);
    }else if(h>=60 && h<120){
        r = (uint8_t)(((120.0 - (float)h) / 60.0) * (max - min) + min + 0.5);
        g = (uint8_t)max;
        b = (uint8_t)(min + 0.5);
    }else if(h>=120 && h<180){
        r = (uint8_t)(min + 0.5);
        g = (uint8_t)max;
        b = (uint8_t)((((float)h - 120.0) / 60.0) * (max - min) + min + 0.5);
    }else if(h>=180 && h<240){
        r = (uint8_t)(min + 0.5);
        g = (uint8_t)(((240.0 - (float)h) / 60.0) * (max - min) + min + 0.5);
        b = (uint8_t)max;
    }else if(h>=240 && h<300){
        r = (uint8_t)((((float)h - 240.0) / 60.0) * (max - min) + min + 0.5);
        g = (uint8_t)(min + 0.5);
        b = (uint8_t)max;
    }else{ // h>=300 && h<=360
        r = (uint8_t)max;
        g = (uint8_t)(min + 0.5);
        b = (uint8_t)(((360.0 - (float)h) / 60.0) * (max - min) + min + 0.5);
    }
    rgb = (r << 16) + (g << 8) + b;

    return(rgb);
}


Vitis HLS 2023.1 で HSVConverter プロジェクトを作成した。
part は xczu1cg-sbva484-1-e を指定した。
zub1cg_i5filters_50_231022.png

今回のテストベンチ・コードでは OpenCV ライブラリを使用している。
Vitis HLS 2021.1 には内蔵された OpenCV は無いので、別にインストールした OpenCV を指定する。
Vitis HLS の Project メニューから Project Settings... を選択して、Project Settings ダイアログを開いた。
Simulation タブを開いて、HSVConverter_tb.cpp の CFLAGS に

-I/usr/local/include

を設定した。
Linker Flags に

-L/usr/local/lib -lopencv_core -lopencv_imgcodecs -lopencv_imgproc

を設定した。
zub1cg_i5filters_51_231022.png

更に、 Synthesis をクリックして、 Top Function に HSVConverter を指定した。
zub1cg_i5filters_52_231022.png

OK ボタンをクリックした。
  1. 2023年10月23日 03:46 |
  2. Vitis HLS
  3. | トラックバック:0
  4. | コメント:0

コメント

コメントの投稿


管理者にだけ表示を許可する

トラックバック URL
https://marsee101.blog.fc2.com/tb.php/6075-53533ce1
この記事にトラックバックする(FC2ブログユーザー)