📄 yuv2rgb.c
字号:
}
#define YUV_LOAD_CONVERT_DITHER_STORE_2x2(cc,df,d1,d2,sy1,sy2,su,sv) \
{ \
PIXEL(df,a11); PIXEL(df,a12); \
PIXEL(df,a21); PIXEL(df,a22); \
YUV_LOAD_CONVERT_DITHER_2x2(cc,df,a11,a12,a21,a22,sy1,sy2,su,sv); \
sy1+=2; sy2+=2; su++; sv++; \
STORE(df,d1,a11); \
STORE(df,d1+BPP(df),a12); \
d1+=2*BPP(df); \
STORE(df,d2,a21); \
STORE(df,d2+BPP(df),a22); \
d2+=2*BPP(df); \
}
/*
* Generic YUV load-convert-average-store macros:
* [d1],[d2] = convert([s1],[s2]);
* [d01] = ([d0]+[d1])/2;
* [d12] = ([d1]+[d2])/2;
*/
#define YUV_LOAD_CONVERT_AVERAGE_STORE_2x1(cc,df,d0,d01,d1,d12,d2,sy1,sy2,su,sv) \
{ \
PIXEL(df,a1); PIXEL(df,a2); \
YUV_LOAD_CONVERT_2x1(cc,df,a1,a2,sy1,sy2,su,sv); \
sy1++; sy2++; su++; sv++; \
STORE(df,d1,a1); \
d1+=BPP(df); \
STORE(df,d2,a2); \
d2+=BPP(df); \
AVERAGE(df,a2,a1,a2); \
LOAD_AVERAGE(df,a1,a1,d0); \
d0+=BPP(df); \
STORE(df,d01,a1); \
d01+=BPP(df); \
STORE(df,d12,a2); \
d12+=BPP(df); \
}
#define YUV_LOAD_CONVERT_AVERAGE_STORE_2x2(cc,df,d0,d01,d1,d12,d2,sy1,sy2,su,sv) \
{ \
PIXEL(df,a11); PIXEL(df,a12); \
PIXEL(df,a21); PIXEL(df,a22); \
YUV_LOAD_CONVERT_2x2(cc,df,a11,a12,a21,a22,sy1,sy2,su,sv); \
sy1+=2; sy2+=2; su++; sv++; \
STORE(df,d1,a11); \
STORE(df,d1+BPP(df),a12); \
d1+=2*BPP(df); \
STORE(df,d2,a21); \
STORE(df,d2+BPP(df),a22); \
d2+=2*BPP(df); \
AVERAGE(df,a21,a11,a21); \
AVERAGE(df,a22,a12,a22); \
LOAD_AVERAGE(df,a11,a11,d0); \
LOAD_AVERAGE(df,a12,a12,d0+BPP(df)); \
d0+=2*BPP(df); \
STORE(df,d01,a11); \
STORE(df,d01+BPP(df),a12); \
d01+=2*BPP(df); \
STORE(df,d12,a21); \
STORE(df,d12+BPP(df),a22); \
d12+=2*BPP(df); \
}
#define YUV_LOAD_CONVERT_AVERAGE_DITHER_STORE_2x2(cc,df,d0,d01,d1,d12,d2,sy1,sy2,su,sv) \
{ \
PIXEL(df,a11); PIXEL(df,a12); \
PIXEL(df,a21); PIXEL(df,a22); \
YUV_LOAD_CONVERT_DITHER_2x2(cc,df,a11,a12,a21,a22,sy1,sy2,su,sv); \
sy1+=2; sy2+=2; su++; sv++; \
STORE(df,d1,a11); \
STORE(df,d1+BPP(df),a12); \
d1+=2*BPP(df); \
STORE(df,d2,a21); \
STORE(df,d2+BPP(df),a22); \
d2+=2*BPP(df); \
AVERAGE(df,a21,a11,a21); \
AVERAGE(df,a22,a12,a22); \
LOAD_AVERAGE(df,a11,a11,d0); \
LOAD_AVERAGE(df,a12,a12,d0+BPP(df)); \
d0+=2*BPP(df); \
STORE(df,d01,a11); \
STORE(df,d01+BPP(df),a12); \
d01+=2*BPP(df); \
STORE(df,d12,a21); \
STORE(df,d12+BPP(df),a22); \
d12+=2*BPP(df); \
}
/*** Generic YUVtoRGB double-row converters: ***************/
/*
* Generic YUVtoRGB double-row shrinking converter:
* uses read-ahead optimization to process full 2x2 blocks
* whenever possible.
*/
#define DBLROW_SHRINK(cc,df,d1,d2,dest_x,dest_dx,sy1,sy2,su,sv,src_x,src_dx) \
{ \
/* initialize local variables: */ \
register int count = dest_dx; \
register int limit = src_dx >> 1; /* -1 */ \
register int step = dest_dx; \
/* check row length: */ \
if (count) { \
/* check if we have an odd first block: */ \
if (src_x & 1) \
goto start_odd; \
/* process even pixels: */ \
do { \
PIXEL(df,a11); PIXEL(df,a12); \
PIXEL(df,a21); PIXEL(df,a22); \
/* make one Bresenham step ahead: */ \
if ((limit -= step) < 0) { \
limit += src_dx; \
/* can we process 2x2 pixels? */ \
if (!--count) \
goto last_pixel; \
/* process full 2x2 block: */ \
YUV_LOAD_CONVERT_2x2(cc,df,a11,a12,a21,a22,sy1,sy2,su,sv); \
sy1+=2; sy2+=2; su++; sv++; \
STORE(df,d1,a11); \
STORE(df,d1+BPP(df),a12); \
d1+=2*BPP(df); \
STORE(df,d2,a21); \
STORE(df,d2+BPP(df),a22); \
d2+=2*BPP(df); \
} else { \
/* proc. first 2x1 block & skip next: */\
YUV_LOAD_CONVERT_2x1(cc,df,a11,a21,sy1,sy2,su,sv); \
sy1+=2; sy2+=2; su++; sv++; \
STORE(df,d1,a11); \
d1+=BPP(df); \
STORE(df,d2,a21); \
d2+=BPP(df); \
} \
/* inverted Bresenham stepping: */ \
while ((limit -= step) >= 0) { \
/* skip next even source pixel: */ \
sy1++; sy2++; \
if ((limit -= step) < 0) \
goto cont_odd; \
/* skip odd source pixel: */ \
sy1++; sy2++; \
su++; sv++; /* next chroma: */ \
} \
cont_even: /* continue loop with next even pixel: */ \
limit += src_dx; \
} while (--count); \
goto done; \
last_pixel: /* use this branch to process last pixel:*/ \
count++; \
start_odd: /* process odd pixels: */ \
do { \
PIXEL(df,a11); PIXEL(df,a21); \
YUV_LOAD_CONVERT_2x1(cc,df,a11,a21,sy1,sy2,su,sv); \
STORE(df,d1,a11); \
d1+=BPP(df); \
STORE(df,d2,a21); \
d2+=BPP(df); \
/* inverted Bresenham stepping: */ \
do { \
/* skip odd source pixel: */ \
sy1++; sy2++; \
su++; sv++; /* next chroma: */ \
if ((limit -= step) < 0) \
goto cont_even; \
/* skip even source pixel: */ \
sy1++; sy2++; \
} while ((limit -= step) >= 0); \
cont_odd: limit += src_dx; \
} while (--count); \
done: ; \
} \
}
/*
* Generic YUVtoRGB double-row copy converter:
*/
#define DBLROW_COPY(cc,df,d1,d2,dest_x,dest_dx,sy1,sy2,su,sv,src_x,src_dx) \
{ \
register int count = dest_dx; \
/* convert first 2x1 block: */ \
if ((src_x & 1) && count) { \
YUV_LOAD_CONVERT_STORE_2x1(cc,df,d1,d2,sy1,sy2,su,sv); \
count--; \
} \
/* convert all integral 2x2 blocks: */ \
while (count >= 2) { \
YUV_LOAD_CONVERT_DITHER_STORE_2x2(cc,df,d1,d2,sy1,sy2,su,sv); \
count -= 2; \
} \
/* convert last 2x1 block: */ \
if (count) { \
YUV_LOAD_CONVERT_STORE_2x1(cc,df,d1,d2,sy1,sy2,su,sv); \
} \
}
/*
* Generic YUVtoRGB double row stretching converter:
*/
#define DBLROW_STRETCH(cc,df,d1,d2,dest_x,dest_dx,sy1,sy2,su,sv,src_x,src_dx) \
{ \
/* initialize local variables: */ \
register int count = dest_dx; \
register int limit = dest_dx >> 1; /* !!! */ \
register int step = src_dx; \
/* # of pixels to be processed separately: */ \
int remainder = dest_dx - limit; \
if ((src_x + src_dx) & 1) remainder += dest_dx; \
remainder /= step; \
/* check row length: */ \
if (count) { \
PIXEL(df,a11); PIXEL(df,a12); \
PIXEL(df,a21); PIXEL(df,a22); \
/* update count: */ \
if ((count -= remainder) <= 0) \
goto convert_last; \
/* check if we have an odd first block: */ \
if (src_x & 1) { \
/* convert first 2x1 block: */ \
YUV_LOAD_CONVERT_2x1(cc,df,a12,a22,sy1,sy2,su,sv); \
sy1++; sy2++; su++; sv++; \
goto rep_odd; \
} \
/* the main loop: */ \
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -