ソースコードのエラーが消えない

Question

C言語初心者です。
「5×5のBayerパターンでの色表現で適応型カラーブレーン補間法(ACPI)を使用する」という課題に詰まりました。Qt Creatorで実行するとまだ27個もエラーが出てきます。

さらっとソースを見て、適当に目に付いた間違いを簡単に教えて戴ければ幸いです(最終的な調整は自分で行います)。
よろしくお願いします。

#include <math.h>
#include <stdlib.h>

static void acpi1(unsigned char const* const bayer, unsigned int* const r, unsigned int* const g, unsigned int* const b);
static void acpi2(unsigned char const* const bayer, unsigned int* const r, unsigned int* const g, unsigned int* const b);
static void acpi3(unsigned char const* const bayer, unsigned int* const r, unsigned int* const g, unsigned int* const b);
static void acpi4(unsigned char const* const bayer, unsigned int* const r, unsigned int* const g, unsigned int* const b);



void MakeRGBData_Acpi(
    unsigned char* const out_r,		/* R */
    unsigned char* const out_g,		/* G */
    unsigned char* const out_b,		/* B */
    unsigned char const* const input_img,	/* aのアドレステーブル */
    int const	start_x,	    /* 切り出し位置 x */
    int const	start_y,	    /* 切り出し位置 y */
    int const	size_x,		 /* 切り出しサイズ x */
    int const	size_y		  /* 切り出しサイズ y */
)
{
    int y;

    int const end_x = start_x + size_x;
    int const end_y = start_y + size_y;

    for (y = start_y; y < end_y; ++y) {
        int x;
        for (x = start_x; x < end_x; ++x) {
            int const in_pos = y * BUF_WIDTH + x;
            int const out_pos = (x - start_x) + (y - start_y) * size_x;

            unsigned char const* const bayerA = &input_img[in_pos];

            unsigned int A_RED, A_GREEN, A_BLUE;
            unsigned int is_odd_x = x & 1;
            unsigned int is_odd_y = y & 1;

            // 入力画像のベイヤパターンは以下の通り
            // 0 → x
            // ↓  G B G B G B ・・・0行目（偶数行）
            // y  R G R G R G ・・・1行目（奇数行）
            //    G B G B G B ・・・2行目（偶数行）
            //    R G R G R G ・・・3行目（奇数行）
        	//    G B G B G B ・・・4行目（偶数行）
            //    R G R G R G ・・・5行目（奇数行）

            if(is_odd_x && is_odd_y) {
                // 処理対象画素が偶数行、偶数列の場合、周囲5×5の画素は以下のベイヤパターンとなる
                // 下図の中央のGが今回処理対象画素。周囲の5×5の画素の値を使って中央のR,Bを復元
                // G R G R G
                // B G B G B
                // G R G R G
        	    // B G B G B
                // G R G R G
                acpi1(bayerA, &A_RED, &A_GREEN, &A_BLUE);
            }
            else if(is_odd_x && !is_odd_y) {
                // 処理対象画素が奇数行、偶数列の場合、周囲5×5の画素は以下のベイヤパターンとなる
                // 下図の中央のBが今回処理対象画素。周囲の5×5の画素の値を使って中央のR,Gを復元
            	// B G B G B
            	// G R G R G
            	// B G B G B
            	// G R G R G
        		// B G B G B
                acpi2(bayerA, &A_RED, &A_GREEN, &A_BLUE);
            }
            else if(!is_odd_x && is_odd_y) {
                // 処理対象画素が偶数行、奇数列の場合、周囲5×5の画素は以下のベイヤパターンとなる
                // 下図の中央のRが今回処理対象画素。周囲の5×5の画素の値を使って中央のG,Bを復元
                // R G R G R
                // G B G B G
                // R G R G R
            	// G B G B G
                // R G R G R
                acpi3(bayerA, &A_RED, &A_GREEN, &A_BLUE);
            }
            else {
                // 処理対象画素が奇数行、奇数列の場合、周囲5×5の画素は以下のベイヤパターンとなる
                // 下図の中央のGが今回処理対象画素。周囲の5×5の画素の値を使って中央のR,Bを復元
                // G B G B G
                // R G R G R
                // G B G B G
            	// R G R G R
                // G B G B G
                acpi4(bayerA, &A_RED, &A_GREEN, &A_BLUE);
            }
            out_r[out_pos] = A_RED   ;
            out_g[out_pos] = A_GREEN ;
            out_b[out_pos] = A_BLUE  ;
        }
    }
}

//------------------------------------
// ベイヤパターンの33位置のrgbの画素値を算出する処理
// G11 R12 G13 R14 G15
// B21 G22 B23 G24 B25
// G31 R32 G33 R34 G35
// B41 G42 B43 G44 B45
// G51 R52 G53 R54 G55

static void acpi1(unsigned char const* const bayer, unsigned int* const r, unsigned int* const g, unsigned int* const b)
{
    // 周囲5×5の画素値を代入する
    unsigned char const r32 = *(bayer - 1);
    unsigned char const r34 = *(bayer + 1);
    unsigned char const g13 = *(bayer - 2 * BUF_WIDTH );
	unsigned char const g22 = *(bayer - BUF_WIDTH - 1);
	unsigned char const g24 = *(bayer - BUF_WIDTH + 1);
    unsigned char const g33 = *bayer;
	unsigned char const g35 = *(bayer - BUF_WIDTH + 2);
    unsigned char const b23 = *(bayer - BUF_WIDTH);
    unsigned char const b43 = *(bayer + BUF_WIDTH);

    //追加で必要な数値を算出
	unsigned char const g23 = ((g13 + g22 + g24 + g33)/4);
    unsigned char const g32 = ((g13 + g22 + g24 + g33)/4);
    unsigned char const g34 = ((g13 + g22 + g24 + g33)/4);
    unsigned char const g43 = ((g13 + g22 + g24 + g33)/4);

    // 処理対象画素（5×5画素の中央）のRGB値を算出
	*r = (r32 + r34)/2 + (-g23 + 2 * g33 - g43)/4;
	*g = g33;
	*b = (b23 + b43)/2 + (-g32 + 2 * g33 - g34)/4;

//------------------------------------
// ベイヤパターンの33位置のrgbの画素値を算出する処理
// B11 G12 B13 G14 B15
// G21 R22 G23 R24 G25
// B31 G32 B33 G34 B35
// G41 R42 G43 R44 G45
// B51 G52 B53 G54 B55

static void acpi2(unsigned char const* const bayer, unsigned int* const r, unsigned int* const g, unsigned int* const b)
{
    // 周囲5×5の画素値を代入する
    unsigned char const r22 = *(bayer - BUF_WIDTH - 1);
	unsigned char const r24 = *(bayer - BUF_WIDTH + 1)
	unsigned char const r42 = *(bayer + BUF_WIDTH - 1);
	unsigned char const r44 = *(bayer + BUF_WIDTH + 1);
    unsigned char const g23 = *(bayer - BUF_WIDTH);
	unsigned char const g25 = *(bayer - BUF_WIDTH + 2);
    unsigned char const g32 = *(bayer - 1);
    unsigned char const g34 = *(bayer + 1);
	unsigned char const g41 = *(bayer + BUF_WIDTH - 2);
    unsigned char const g43 = *(bayer + BUF_WIDTH);
	unsigned char const g45 = *(bayer + BUF_WIDTH + 2)
    unsigned char const b13 = *(bayer - 2 * BUF_WIDTH );
    unsigned char const b31 = *(bayer + BUF_WIDTH - 2);
    unsigned char const b33 = *bayer;
	unsigned char const b35 = *(bayer - BUF_WIDTH + 2);
    unsigned char const b53 = *(bayer - 2 * BUF_WIDTH );

	// cとdの値を算出
	unsigned int const c = ((-g24 + 2 * g33 - g42) + (r24 - r42));
    unsigned int const d = ((-g22 + 2 * g33 - g44) + (r22 - r44));

	// cとdの絶対値を算出
	c = abs(c);
    d = abs(d);

    // 処理対象画素（5×5画素の中央）のRGB値を算出
	if (c < d)
	{
		*r = ((r24 + r42))/2 + ((-g24 + 2 * g33 - g42))/4;
	}
	else if (c > d)
	{
		*r = ((r22 + r44))/2 + ((-g22 + 2 * g33 - g44))/4; 
	}
	else (c = d)
	{
		*r = ((r24 + r42 + r22 + r44)/4) + ((-g22 - g24 + 4 * g33 - g42 - g44)/8);
	}
	

	// eとfの値を算出
	unsigned int const e = ((-b13 + 2 * b33 - b53) + (g23 - g43));
    unsigned int const f = ((-b31 + 2 * b33 - b35) + (g32 - g34));

	// eとfの絶対値を算出
	e = abs(e);
    f = abs(f);

	if (e < f)
	{
		*g = ((g23 + g43))/2 + ((-r13 + 2 * r33 - r53))/4;
	}
	else if (e > f)
	{
		*g = ((g32 + g34))/2 + ((-r31 + 2 * r33 - r35))/4;
	}
	else (e = f)
	{
		*g = ((g23 + g43 + g32 + g34)/4) + ((-r13 - r31 + 4 * r33 - r35 - r53)/8);
	}
	

	*b = B33
}

//------------------------------------
// ベイヤパターンの33位置のrgbの画素値を算出する処理
// R11 G12 R13 G14 R15
// G21 B22 G23 B24 G25
// R31 G32 R33 G34 R35
// G41 B42 G43 B44 G45
// R51 G52 R53 G54 R55

static void acpi3(unsigned char const* const bayer, unsigned int* const r, unsigned int* const g, unsigned int* const b)
{
    // 周囲5×5の画素値を代入する
    unsigned char const r13 = *(bayer - 2 * BUF_WIDTH );
    unsigned char const r31 = *(bayer + BUF_WIDTH - 2);
    unsigned char const r33 = *bayer;
	unsigned char const r35 = *(bayer - BUF_WIDTH + 2);
    unsigned char const r53 = *(bayer - 2 * BUF_WIDTH );
    unsigned char const g23 = *(bayer - BUF_WIDTH);
    unsigned char const g32 = *(bayer - 1);
    unsigned char const g34 = *(bayer + 1);
    unsigned char const g43 = *(bayer + BUF_WIDTH);
    unsigned char const b22 = *(bayer - BUF_WIDTH - 1);
	unsigned char const b24 = *(bayer - BUF_WIDTH + 1)
	unsigned char const b42 = *(bayer + BUF_WIDTH - 1);
	unsigned char const b44 = *(bayer + BUF_WIDTH + 1);

    // 処理対象画素（5×5画素の中央）のRGB値を算出
	// hとiの値を算出
	unsigned int const h = ((-r13 + 2 * r33 - r53) + (g23 - g43));
    unsigned int const i = ((-r31 + 2 * r33 - r35) + (g32 - g34));

	// hとiの絶対値を算出
	h = abs(h);
	i = abs(i);

	if (h < i)
	{
		*g = ((g23 + g43))/2 + ((-r13 + 2 * r33 - r53))/4;
	}
	else if (h > i)
	{
		*g = ((g32 + g34))/2 + ((-r31 + 2 * r33 - r35))/4;
	}
	else (h = i)
	{
		*g = ((g23 + g43 + g32 + g34)/4) + ((-r13 - r31 + 4 * r33 - r35 - r53)/8);
	}

	// jとkの値を算出
	unsigned int const j = ((-g24 + 2 * g33 - g42) + (b24 - b42));
    unsigned int const k = ((-g22 + 2 * g33 - g44) + (b22 - b44));

	// jとkの絶対値を算出
	j = abs(j);
	k = abs(k);


	if (j < k)
	{
		*b = ((b24 + b42))/2 + ((-g24 + 2 * g33 - g42))/4;
	}
	else if (j > k)
	{
		*b = ((b22 + b44))/2 + ((-g22 + 2 * g33 - g44))/4; 
	}
	else (j = k)
	{
		*b = ((b24 + b42 + b22 + b44)/4) + ((-g22 - g24 + 4 * g33 - g42 - g44)/8);
	}
	

	*r = r33
}

//------------------------------------
// ベイヤパターンの22位置のrgbの画素値を算出する処理
// G11 B12 G13 B14 G15
// R21 G22 R23 G24 R25
// G31 B32 G33 B34 G35
// R41 G42 R43 G44 R45
// G51 B52 G53 B54 G55

static void acpi4(unsigned char const* const bayer, unsigned int* const r, unsigned int* const g, unsigned int* const b)
{
    // 周囲5×5の画素値を代入する
    unsigned char const r23 = *(bayer - BUF_WIDTH);
    unsigned char const r43 = *(bayer + BUF_WIDTH);
	unsigned char const g22 = *(bayer - BUF_WIDTH - 1);
	unsigned char const g24 = *(bayer - BUF_WIDTH + 1)
    unsigned char const g31 = *(bayer + BUF_WIDTH - 2);
    unsigned char const g33 = *bayer;
	unsigned char const g35 = *(bayer - BUF_WIDTH + 2);
	unsigned char const g42 = *(bayer + BUF_WIDTH - 1);
	unsigned char const g44 = *(bayer + BUF_WIDTH + 1);
    unsigned char const b32 = *(bayer - 1);
    unsigned char const b34 = *(bayer + 1);

Answer 1

この問題は既に解決しました

Comments

[fiveHundred]

解決したのであれば、その手順や内容を記載してください。
（https://teratail.com/help#resolve-myself）

[Waki285]

どうやって解決したか記載をお願いします。