摘要: 我们得到的很多视频数据(一些解码器的输出或者摄像头的输出等)都使用了一种
叫YUV的颜色格式；本文介绍了常见的YUV视频格式(YUY2/YVYU/UYVY/I420/YV12等)到
RGB颜色格式的转换,并尝试对转化的速度进行优化；
全文 分为:
《上篇》文章首先介绍了YUV颜色格式，并介绍了YUV颜色格式和RGB颜色格式之
间的相互转换；然后重点介绍了YUYV视频格式到RGB32格式的转化，并尝试进行了一
些速度优化；
《中篇》尝试使用MMX/SSE指令对前面实现的解码器核心进行速度优化；然
后简要介绍了一个使用这类CPU特殊指令时的代码框架，使得解码程序能够根据运行时
的CPU指令支持情况动态调用最佳的实现代码；并最终提供一个多核并行的优化版本；
《下篇》介绍YUV类型的其他种类繁多的视频数据编码格式；并将前面实现的解码
器核心(在不损失代码速度的前提下)进行必要的修改，使之适用于这些YUV视频格式
的解码；
(2007.11.25 优化了一下DECODE_YUYV_SSE，使用预读优化;调整了一下MMX指令的定义方式，结构更好一些)
(2007.11.13 修正了一下颜色转换公式中的系数)
(2007.11.05 修改函数DECODE_YUYV_AutoEx中的一个bug)
正文:
代码使用C++,编译器:VC2005
涉及到汇编的时候假定为x86平台；
现在的高清视频帧尺寸越来越大，所以本文测试的图片大小将使用1024x576和
1920x1080两种常见的帧尺寸来测试解码器速度；
测试平台:(CPU:AMD64x2 4200+(2.37G); 内存:DDR2 677(双通道); 编译器:VC2005)
测试平台:(CPU:Intel Core2 4400(2.00G);内存:DDR2 667(双通道); 编译器:VC2005)
请先参看《YUV视频格式到RGB32格式转换的速度优化 上篇》，
本文章将继续成倍的提高其速度!
A:使用MMX指令来继续优化YUYV视频格式到RGB32格式的转换函数
现在绝大多数的x86CPU都支持MMX指令，它是一种单指令多数据流的指令集(SIMD)；
MMX指令能够同时操作8个byte或者4个short等; 在YUV转换到RGB的运算中,为了保持精
度选用一次运算4个short数据类型；那外考虑如果在一个寄存器中保存YUYV四个数据，
整个运算写起来会较麻烦，且算法受到Y、U、V三个颜色存放位置的影响严重；而且考
虑到除了packed模式外很多YUV视频数据都为planar模式，所以想把Y、U、V先分离到
各自的寄存器再运算，看起来舒服得多，那么运算核心将用一个寄存器保存4个U，一
个寄存器保存4个V，对应8个Y，也就是说核心转换代码运行一遍可以输出8个RGB32比
特颜色；
所以我们先来实现一个通用的MMX实现的转换核心：
我们约定输入:
mm0 = Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0
mm1 = 00 u3 00 u2 00 u1 00 u0
mm2 = 00 v3 00 v2 00 v1 00 v0
通过edx指向的内存输出:
[edx -- edx+8*4]
由于主要的计算使用short精度，那些系数就不能使用16位的定点数了；为了不超出short的
范围可以使用13位的定点数(再大就会溢出了)；
MMX实现的转换核心(使用了宏来实现)：YUV422ToRGB32_MMX:
(系数的由来/数据在MMX寄存器的大致流动都有较详细的注释；
如果有人进一步改进了这个核心,请告诉我:)
const UInt64 csMMX_16_b = 0x1010101010101010; // byte{16,16,16,16,16,16,16,16}
const UInt64 csMMX_128_w = 0x0080008000800080; //short{ 128, 128, 128, 128}
const UInt64 csMMX_0x00FF_w = 0x00FF00FF00FF00FF; //掩码
const UInt64 csMMX_Y_coeff_w = 0x2543254325432543; //short{ 9539, 9539, 9539, 9539} =1.164383*(1<<13)
const UInt64 csMMX_U_blue_w = 0x408D408D408D408D; //short{16525,16525,16525,16525} =2.017232*(1<<13)
const UInt64 csMMX_U_green_w = 0xF377F377F377F377; //short{-3209,-3209,-3209,-3209} =(-0.391762)*(1<<13)
const UInt64 csMMX_V_green_w = 0xE5FCE5FCE5FCE5FC; //short{-6660,-6660,-6660,-6660} =(-0.812968)*(1<<13)
const UInt64 csMMX_V_red_w = 0x3313331333133313; // short{13075,13075,13075,13075} =1.596027*(1<<13)
//一次处理8个颜色输出
#define YUV422ToRGB32_MMX(out_RGB_reg,WriteCode) /
/*input : mm0 = Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0 */ /
/* mm1 = 00 u3 00 u2 00 u1 00 u0 */ /
/* mm2 = 00 v3 00 v2 00 v1 00 v0 */ /
/*output : [out_RGB_reg -- out_RGB_reg+8*4] */ /
/
asm psubusb mm0,csMMX_16_b /* mm0 : Y -= 16 */ /
asm psubsw mm1,csMMX_128_w /* mm1 : u -= 128 */ /
asm movq mm7,mm0 /
asm psubsw mm2,csMMX_128_w /* mm2 : v -= 128 */ /
asm pand mm0,csMMX_0x00FF_w /* mm0 = 00 Y6 00 Y4 00 Y2 00 Y0 */ /
asm psllw mm1,3 /* mm1 : u *= 8 */ /
asm psllw mm2,3 /* mm2 : v *= 8 */ /
asm psrlw mm7,8 /* mm7 = 00 Y7 00 Y5 00 Y3 00 Y1 */ /
asm movq mm3,mm1 /
asm movq mm4,mm2 /
/
asm pmulhw mm1,csMMX_U_green_w /* mm1 = u * U_green */ /
asm psllw mm0,3 /* y*=8 */ /
asm pmulhw mm2,csMMX_V_green_w /* mm2 = v * V_green */ /
asm psllw mm7,3 /* y*=8 */ /
asm pmulhw mm3,csMMX_U_blue_w /
asm paddsw mm1,mm2 /
asm pmulhw mm4,csMMX_V_red_w /
asm movq mm2,mm3 /
asm pmulhw mm0,csMMX_Y_coeff_w /
asm movq mm6,mm4 /
asm pmulhw mm7,csMMX_Y_coeff_w /
asm movq mm5,mm1 /
asm paddsw mm3,mm0 /* mm3 = B6 B4 B2 B0 */ /
asm paddsw mm2,mm7 /* mm2 = B7 B5 B3 B1 */ /
asm paddsw mm4,mm0 /* mm4 = R6 R4 R2 R0 */ /
asm paddsw mm6,mm7 /* mm6 = R7 R5 R3 R1 */ /
asm paddsw mm1,mm0 /* mm1 = G6 G4 G2 G0 */ /
asm paddsw mm5,mm7 /* mm5 = G7 G5 G3 G1 */ /
/
asm packuswb mm3,mm4 /* mm3 = R6 R4 R2 R0 B6 B4 B2 B0 to [0-255] */ /
asm packuswb mm2,mm6 /* mm2 = R7 R5 R3 R1 B7 B5 B3 B1 to [0-255] */ /
asm packuswb mm5,mm1 /* mm5 = G6 G4 G2 G0 G7 G5 G3 G1 to [0-255] */ /
asm movq mm4,mm3 /
asm punpcklbw mm3,mm2 /* mm3 = B7 B6 B5 B4 B3 B2 B1 B0 */ /
asm punpckldq mm1,mm5 /* mm1 = G7 G5 G3 G1 xx xx xx xx */ /
asm punpckhbw mm4,mm2 /* mm4 = R7 R6 R5 R4 R3 R2 R1 R0 */ /
asm punpckhbw mm5,mm1 /* mm5 = G7 G6 G5 G4 G3 G2 G1 G0 */ /
/
/*out*/ /
asm pcmpeqb mm2,mm2 /* mm2 = FF FF FF FF FF FF FF FF */ /
/
asm movq mm0,mm3 /
asm movq mm7,mm4 /
asm punpcklbw mm0,mm5 /* mm0 = G3 B3 G2 B2 G1 B1 G0 B0 */ /
asm punpcklbw mm7,mm2 /* mm7 = FF R3 FF R2 FF R1 FF R0 */ /
asm movq mm1,mm0 /
asm movq mm6,mm3 /
asm punpcklwd mm0,mm7 /* mm0 = FF R1 G1 B1 FF R0 G0 B0 */ /
asm punpckhwd mm1,mm7 /* mm1 = FF R3 G3 B3 FF R2 G2 B2 */ /
asm WriteCode [out_RGB_reg],mm0 /
asm movq mm7,mm4 /
asm punpckhbw mm6,mm5 /* mm6 = G7 B7 G6 B6 G5 B5 G4 B4 */ /
asm WriteCode [out_RGB_reg+8 ],mm1 /
asm punpckhbw mm7,mm2 /* mm7 = FF R7 FF R6 FF R5 FF R4 */ /
asm movq mm0,mm6 /
asm punpcklwd mm6,mm7 /* mm6 = FF R5 G5 B5 FF R4 G4 B4 */ /
asm punpckhwd mm0,mm7 /* mm0 = FF R7 G7 B7 FF R6 G6 B6 */ /
asm WriteCode [out_RGB_reg+8*2 ],mm6 /
asm WriteCode [out_RGB_reg+8*3 ],mm0
YUV视频格式到RGB32格式的转换函数，MMX指令实现版本
asm movq mm0,[in_yuv_reg ] /*mm0=V1 Y3 U1 Y2 V0 Y1 U0 Y0 */ /
asm movq mm4,[in_yuv_reg+8] /*mm4=V3 Y7 U3 Y6 V2 Y5 U2 Y4 */ /
asm movq mm1,mm0 /
asm movq mm5,mm4 /
asm psrlw mm1,8 /*mm1=00 V1 00 U1 00 V0 00 U0 */ /
asm psrlw mm5,8 /*mm5=00 V3 00 U3 00 V2 00 U2 */ /
asm pand mm0,csMMX_0x00FF_w /*mm0=00 Y3 00 Y2 00 Y1 00 Y0 */ /
asm pand mm4,csMMX_0x00FF_w /*mm4=00 Y7 00 Y6 00 Y5 00 Y4 */ /
asm packuswb mm1,mm5 /*mm1=V3 U3 V2 U2 V1 U1 V0 U0 */ /
asm movq mm2,mm1 /
asm packuswb mm0,mm4 /*mm0=Y7 Y6 Y5 Y4 Y3 Y2 Y1 Y0 */ /
asm psllw mm1,8 /*mm1=U3 00 U2 00 U1 00 U0 00 */ /
asm psrlw mm2,8 /*mm2=00 V3 00 V2 00 V1 00 V0 */ /
asm psrlw mm1,8 /*mm1=00 U3 00 U2 00 U1 00 U0 */
void DECODE_YUYV_MMX_line(TARGB32* pDstLine,const TUInt8* pYUYV,long width)
{
long expand8_width=(width>>3)<<3 ;
if (expand8_width>0 )
{
asm
{
mov ecx,expand8_width
mov eax,pYUYV
mov edx,pDstLine
lea eax,[eax+ecx*2 ]
lea edx,[edx+ecx*4 ]
neg ecx
loop_beign:
YUYV_Loader_MMX(eax+ecx*2 )
YUV422ToRGB32_MMX(edx+ecx*4 ,movq)
add ecx,8
jnz loop_beign
mov pYUYV,eax
mov pDstLine,edx
}
}
//处理边界
DECODE_YUYV_Common_line(pDstLine,pYUYV,width- expand8_width);
}
void DECODE_YUYV_MMX(const TUInt8* pYUYV,const TPicRegion& DstPic)
{
assert((DstPic.width & 1)==0 );
long YUV_byte_width=(DstPic.width>>1)<<2 ;
TARGB32* pDstLine= DstPic.pdata;
for (long y=0;y<DstPic.height;++ y)
{
DECODE_YUYV_MMX_line(pDstLine,pYUYV,DstPic.width);
pYUYV+= YUV_byte_width;
((TUInt8*&)pDstLine)+= DstPic.byte_width;
}
asm emms
}
速度测试:
//==============================================================================
// | 1024x576 | 1920x1080 |
//------------------------------------------------------------------------------
// | AMD64x2 | Core2 | AMD64x2 | Core2 |
//------------------------------------------------------------------------------
//DECODE_YUYV_MMX 585.4 FPS 569.8 FPS 169.8 FPS 160.4 FPS
B.使用SSE中的软件预取和禁止写缓存来改进MMX版本
这里的改动其实很小，只是把YUV422ToRGB32_MMX中颜色数据保存操作
movq [mem],mmx_reg 修改成 movntq [mem],mmx_reg
然后再处理完成后调用sfence缓存刷新指令。
完整代码如下:
#define YUV422ToRGB32_SSE(out_RGB_reg) YUV422ToRGB32_MMX(out_RGB_reg,movntq)
void DECODE_YUYV_SSE_line(TARGB32* pDstLine,const TUInt8* pYUYV,long width)
{
long expand8_width=(width>>3)<<3 ;
if (expand8_width>0 )
{
asm
{
mov ecx,expand8_width
mov eax,pYUYV
mov edx,pDstLine
lea eax,[eax+ecx*2 ]
lea edx,[edx+ecx*4 ]
neg ecx
loop_beign:
YUYV_Loader_MMX(eax+ecx*2 )
prefetchnta [eax+ecx*2+64*4] //预读
YUV422ToRGB32_SSE(edx+ecx*4 )
add ecx,8
jnz loop_beign
mov pYUYV,eax
mov pDstLine,edx
}
}
//处理边界
DECODE_YUYV_Common_line(pDstLine,pYUYV,width- expand8_width);
}
void DECODE_YUYV_SSE(const TUInt8* pYUYV,const TPicRegion& DstPic)
{
assert((DstPic.width & 1)==0 );
long YUV_byte_width=(DstPic.width>>1)<<2 ;
TARGB32* pDstLine= DstPic.pdata;
for (long y=0;y<DstPic.height;++ y)
{
DECODE_YUYV_SSE_line(pDstLine,pYUYV,DstPic.width);
pYUYV+= YUV_byte_width;
((TUInt8*&)pDstLine)+= DstPic.byte_width;
}
asm sfence
asm emms
}
速度测试:
//==============================================================================
// | 1024x576 | 1920x1080 |
//------------------------------------------------------------------------------
// | AMD64x2 | Core2 | AMD64x2 | Core2 |
//------------------------------------------------------------------------------
//DECODE_YUYV_SSE 770.3 FPS 741.9 FPS 220.0 FPS 209.7 FPS
C.使用CPU特殊指令的一般框架
我的blog文章中，经常使用MMX/SSE等特殊指令，都是只给出代码实现；它们离实际项目代
码还有一点距离；在实际的项目中需要一种机制使得开发的软件能够根据运行的CPU的特性动
态的决定调用最优化的实现版本；
在x86CPU上可以使用CPUID指令来得到各种关于当前CPU的特性，包括制造商、CPU家族号、
缓存信息、是否支持MMX/SSE/SSE2指令集 等等；
要使用CPUID指令，首先应该判断CPU是否支持该指令；方法是判断EFLAGS寄存器的第21位
是否可以改写；如果可以改写，那么说明这块CPU支持CPUID指令； 函数实现如下:
{
long int CPUIDInfOld=0 ;
long int CPUIDInfNew=0 ;
try
{
asm
{
pushfd // 保存原 EFLAGS
pop eax
mov edx,eax
mov CPUIDInfOld,eax //
xor eax,00200000h // 改写 第21位
push eax
popfd // 改写 EFLAGS
pushfd // 保存新 EFLAGS
pop eax
mov CPUIDInfNew,eax
push edx // 恢复原 EFLAGS
popfd
}
return (CPUIDInfOld!=CPUIDInfNew); // EFLAGS 第21位 可以改写
}
catch (...)
{
return false ;
}
}
//那么判断CPU是否支持MMX指令的函数如下:
{
if (! _CPUSupportCPUID())
return false ;
long int MMXInf=0 ;
try
{
asm
{
push ebx
mov eax, 1
cpuid
mov MMXInf,edx
pop ebx
}
MMXInf =MMXInf & (1 << 23); //检测edx第23位
return (MMXInf==(1 << 23 ));
}
catch (...)
{
return false ;
}
}
//判断CPU是否支持SSE指令的函数如下:
{
if (! _CPUSupportCPUID())
return false ;
long int SSEInf=0 ;
try
{
asm
{
push ebx
mov eax, 1
cpuid
mov SSEInf,edx
pop ebx
}
SSEInf =SSEInf & (1 << 25); //检测edx第25位
return (SSEInf==(1 << 25 ));
}
catch (...)
{
return false ;
}
}
// 由于SSE的寄存器是比较后期加入的，某些较老的操作系统可能不支持这些寄存器
//的任务切换保存；可以用触发异常的方式来判断操作系统是否支持SSE;
{
//触发异常来判断
try
{
asm
{
//movups xmm0,xmm0
asm _emit 0x0F asm _emit 0x10 asm _emit 0xC0
}
return true ;
}
catch (...)
{
return false ;
}
}
//定义常量，用以在程序作为分支条件
const bool _IS_SSE_ACTIVE=_CPUSupportSSE() && _SystemSupportSSE();
D.根据运行的CPU支持的指令集来动态调用不同的解码器实现
const TDECODE_YUYV_line_proc DECODE_YUYV_Auto_line=
( _IS_MMX_ACTIVE ? (_IS_SSE_ACTIVE ? DECODE_YUYV_SSE_line : DECODE_YUYV_MMX_line) : DECODE_YUYV_Common_line );
__forceinline void DECODE_filish()
{
if (_IS_MMX_ACTIVE)
{
if (_IS_SSE_ACTIVE) { asm sfence }
asm emms
}
}
void DECODE_YUYV_Auto(const TUInt8* pYUYV,const TPicRegion& DstPic)
{
assert((DstPic.width & 1)==0 );
long YUV_byte_width=(DstPic.width>>1)<<2 ;
TARGB32* pDstLine= DstPic.pdata;
for (long y=0;y<DstPic.height;++ y)
{
DECODE_YUYV_Auto_line(pDstLine,pYUYV,DstPic.width);
pYUYV+= YUV_byte_width;
((TUInt8*&)pDstLine)+= DstPic.byte_width;
}
DECODE_filish();
}
在我的两台测试电脑上速度同DECODE_YUYV_SSE，因为它们都支持MMX和SSE;
E.YUYV视频格式解码器的并行化实现
这个比较简单，将图像分为多个块交给多个CPU同时执行就可以了；代码如下:
( 这里利用CWorkThreadPool类来并行执行任务; 参见我的Blog文
章《并行计算简介和多核CPU编程Demo》,里面有CWorkThreadPool类的完整源代码)
struct TDECODE_YUYV_Parallel_WorkData
{
const TUInt8* pYUYV;
TPicRegion DstPic;
};
void DECODE_YUYV_Parallel_callback(void* wd)
{
TDECODE_YUYV_Parallel_WorkData* WorkData=(TDECODE_YUYV_Parallel_WorkData* )wd;
DECODE_YUYV_Auto(WorkData->pYUYV,WorkData-> DstPic);
}
void DECODE_YUYV_Parallel(const TUInt8* pYUYV,const TPicRegion& DstPic)
{
long work_count= CWorkThreadPool::best_work_count();
std::vector<TDECODE_YUYV_Parallel_WorkData> work_list(work_count);
std::vector<TDECODE_YUYV_Parallel_WorkData*> pwork_list(work_count);
long cheight=DstPic.height / work_count;
for (long i=0;i<work_count;++ i)
{
work_list[i].pYUYV=pYUYV+i*cheight*(DstPic.width*2 );
work_list[i].DstPic.pdata=DstPic.pixel_pos(0,cheight* i);
work_list[i].DstPic.byte_width= DstPic.byte_width;
work_list[i].DstPic.width= DstPic.width;
work_list[i].DstPic.height= cheight;
pwork_list[i]=& work_list[i];
}
work_list[work_count-1].DstPic.height=DstPic.height-cheight*(work_count-1 );
CWorkThreadPool::work_execute(DECODE_YUYV_Parallel_callback,(void**)&pwork_list[0 ],work_count);
}
速度测试:
//==============================================================================
// | 1024x576 | 1920x1080 |
//------------------------------------------------------------------------------
// | AMD64x2 | Core2 | AMD64x2 | Core2 |
//------------------------------------------------------------------------------
//DECODE_YUYV_Parallel 1433.9 FPS 1417.1 FPS 414.1 FPS 286.3 FPS
F.另一种更灵活的任务分配方案
我的Blog文章中，涉及到并行的时候，一般都是前面那种简单的平均任务分配模式；
这里再实现一种复杂一点的分配方案：线程执行完自己分配的任务后，尝试帮助其它
线程执行没有完成的任务；(以单行为最小可分配任务粒度)； 这有一个优点，就是
在多任务环境下，能够更好地利用全部的CPU资源; 实现如下:
{
//任务领取
if ((*Lock)!=0) return ;
long lock_value=InterlockedIncrement(Lock);// 也可以用带lock前缀的inc指令来代替这个windows调用
//警告: 在以后更多个核的电脑上，这里的lock造成的潜在冲突没有测试过
if (lock_value>=2) return ;
// lock_value==1时，任务领取成功
//执行任务
DECODE_YUYV_Auto_line(pDstLine,pYUYV,width);
}
__forceinline void DECODE_YUYV_AutoEx(const TUInt8* pYUYV,const TPicRegion& DstPic,volatile long* LockList,long begin_y0)
{
assert((DstPic.width & 1)==0 );
long YUV_byte_width=(DstPic.width>>1)<<2 ;
TARGB32* pDstLine= DstPic.pdata;
long y;
const TUInt8* pYUYV_b=pYUYV+(YUV_byte_width* begin_y0);
TARGB32* pDstLine_b=(TARGB32*)(((TUInt8*)DstPic.pdata)+(DstPic.byte_width* begin_y0));
for (y=begin_y0;y<DstPic.height;++ y)
{
DECODE_YUYV_AutoLock_line(pDstLine_b,pYUYV_b,DstPic.width,& LockList[y]);
pYUYV_b+= YUV_byte_width;
((TUInt8*&)pDstLine_b)+= DstPic.byte_width;
}
for (y=0;y<begin_y0;++ y)
{
DECODE_YUYV_AutoLock_line(pDstLine,pYUYV,DstPic.width,& LockList[y]);
pYUYV+= YUV_byte_width;
((TUInt8*&)pDstLine)+= DstPic.byte_width;
}
DECODE_filish();
}
struct TDECODE_YUYV_ParallelEx_WorkData
{
const TUInt8* pYUYV;
TPicRegion DstPic;
long* LockList;
long begin_y0;
};
void DECODE_YUYV_ParallelEx_callback(void* wd)
{
TDECODE_YUYV_ParallelEx_WorkData* WorkData=(TDECODE_YUYV_ParallelEx_WorkData* )wd;
DECODE_YUYV_AutoEx(WorkData->pYUYV,WorkData->DstPic,(volatile long*)WorkData->LockList,WorkData-> begin_y0);
}
void DECODE_YUYV_ParallelEx(const TUInt8* pYUYV,const TPicRegion& DstPic)
{
long work_count= CWorkThreadPool::best_work_count();
std::vector<TDECODE_YUYV_ParallelEx_WorkData> work_list(work_count);
std::vector<TDECODE_YUYV_ParallelEx_WorkData*> pwork_list(work_count);
std::vector<long> lock_list(DstPic.height);
for (long y=0;y<DstPic.height;++ y)
lock_list[y]=0 ;
long cheight=DstPic.height / work_count;
for (long i=0;i<work_count;++ i)
{
work_list[i].pYUYV= pYUYV;
work_list[i].DstPic= DstPic;
work_list[i].begin_y0=i* cheight;
work_list[i].LockList=&lock_list[0 ];
pwork_list[i]=& work_list[i];
}
CWorkThreadPool::work_execute(DECODE_YUYV_ParallelEx_callback,(void**)&pwork_list[0 ],work_count);
}
速度测试:
//==============================================================================
// | 1024x576 | 1920x1080 |
//------------------------------------------------------------------------------
// | AMD64x2 | Core2 | AMD64x2 | Core2 |
//------------------------------------------------------------------------------
//DECODE_YUYV_ParallelEx 1387.5 FPS 1359.2 FPS 409.9 FPS 287.4 FPS
G:把测试成绩放在一起
//测试平台:(CPU:AMD64x2 4200+(2.37G); 内存:DDR2 677(双通道); 编译器:VC2005)
//测试平台:(CPU:Intel Core2 4400(2.00G);内存:DDR2 667(双通道); 编译器:VC2005)
//==============================================================================
// | 1024x576 | 1920x1080 |
//------------------------------------------------------------------------------
// | AMD64x2 | Core2 | AMD64x2 | Core2 |
//------------------------------------------------------------------------------
//DECODE_YUYV_Float 55.0 FPS 63.7 FPS 15.6 FPS 18.0 FPS
//DECODE_YUYV_Int 137.1 FPS 131.9 FPS 39.0 FPS 37.1 FPS
//DECODE_YUYV_RGBTable 164.8 FPS 152.9 FPS 47.1 FPS 43.7 FPS
//DECODE_YUYV_Table 146.1 FPS 151.3 FPS 41.8 FPS 43.5 FPS
//DECODE_YUYV_TableEx 236.5 FPS 300.5 FPS 68.1 FPS 85.0 FPS
//DECODE_YUYV_Common 250.7 FPS 287.1 FPS 71.9 FPS 80.7 FPS
//DECODE_YUYV_MMX 585.4 FPS 569.8 FPS 169.8 FPS 160.4 FPS
//DECODE_YUYV_SSE 770.3 FPS 741.9 FPS 220.0 FPS 209.7 FPS
//DECODE_YUYV_Auto (同DECODE_YUYV_SSE)
//DECODE_YUYV_Parallel 1433.9 FPS 1417.1 FPS 414.1 FPS 286.3 FPS
//DECODE_YUYV_ParallelEx 1387.5 FPS 1359.2 FPS 409.9 FPS 287.4 FPS
(欢迎提出不足和改进意见；文章下篇将开始支持更多类型的YUV视频数据格式)
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
