windows下存储位图及YUV转RGB

 

static int av_create_bmp(char* filename,BYTE *pRGBBuffer,int width,int height,int bpp)
{
    BITMAPFILEHEADER bmpheader;
    BITMAPINFO bmpinfo;
    FILE *fp;

    fp = fopen(filename,"wb");
    if(!fp)return -1;

    bmpheader.bfType = ('M'<<8)|'B';
    bmpheader.bfReserved1 = 0;
    bmpheader.bfReserved2 = 0;
    bmpheader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
    bmpheader.bfSize = bmpheader.bfOffBits + width*height*bpp/8;

    bmpinfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmpinfo.bmiHeader.biWidth = width;
    bmpinfo.bmiHeader.biHeight = height;
    bmpinfo.bmiHeader.biPlanes = 1;
    bmpinfo.bmiHeader.biBitCount = bpp;
    bmpinfo.bmiHeader.biCompression = BI_RGB;
    bmpinfo.bmiHeader.biSizeImage = 0;
    bmpinfo.bmiHeader.biXPelsPerMeter = 100;
    bmpinfo.bmiHeader.biYPelsPerMeter = 100;
    bmpinfo.bmiHeader.biClrUsed = 0;
    bmpinfo.bmiHeader.biClrImportant = 0;

    fwrite(&bmpheader,sizeof(BITMAPFILEHEADER),1,fp);
    fwrite(&bmpinfo.bmiHeader,sizeof(BITMAPINFOHEADER),1,fp);
    fwrite(pRGBBuffer,width*height*bpp/8,1,fp);
    fclose(fp);

    return 0;
}


void YUV_TO_RGB24(uint8_t *puc_y,int stride_y,uint8_t *puc_u,uint8_t *puc_v, int stride_uv, 
                  uint8_t *puc_out,int width_y,int height_y,int stride_out) 
{
    int y, horiz_count;
    uint8_t *puc_out_remembered;
    //int stride_out = width_y * 3;

    if (height_y < 0) {
        //we are flipping our output upside-down
        height_y  = -height_y;
        puc_y     += (height_y   - 1) * stride_y ;
        puc_u     += (height_y/2 - 1) * stride_uv;
        puc_v     += (height_y/2 - 1) * stride_uv;
        stride_y  = -stride_y;
        stride_uv = -stride_uv;
    }

    horiz_count = -(width_y >> 3);

    for (y=0; y<height_y; y++) {
        if (y == height_y-1) {
            //this is the last output line - we need to be careful not to overrun the end of this line
            uint8_t temp_buff[3*MAXIMUM_Y_WIDTH+1];
            puc_out_remembered = puc_out;
            puc_out = temp_buff; //write the RGB to a temporary store
        }
        _asm {
                push eax
                push ebx
                push ecx
                push edx
                push edi

                mov eax, puc_out       
                mov ebx, puc_y       
                mov ecx, puc_u       
                mov edx, puc_v
                mov edi, horiz_count

horiz_loop:

                movd mm2, [ecx]
                pxor mm7, mm7

                movd mm3, [edx]
                punpcklbw mm2, mm7       

                movq mm0, [ebx]          
                punpcklbw mm3, mm7       

                movq mm1, mmw_0x00ff     

                psubusb mm0, mmb_0x10    

                psubw mm2, mmw_0x0080    
                pand mm1, mm0            

                psubw mm3, mmw_0x0080    
                psllw mm1, 3             

                psrlw mm0, 8             
                psllw mm2, 3             

                pmulhw mm1, mmw_mult_Y   //0x2568
                psllw mm0, 3             

                psllw mm3, 3             
                movq mm5, mm3            

                pmulhw mm5, mmw_mult_V_R //0x3343
                movq mm4, mm2            

                pmulhw mm0, mmw_mult_Y   
                movq mm7, mm1            

                pmulhw mm2, mmw_mult_U_G //0xf36e
                paddsw mm7, mm5

                pmulhw mm3, mmw_mult_V_G //0xe5e2
                packuswb mm7, mm7

                pmulhw mm4, mmw_mult_U_B //0x40cf
                paddsw mm5, mm0      

                packuswb mm5, mm5
                paddsw mm2, mm3          

                movq mm3, mm1            
                movq mm6, mm1            

                paddsw mm3, mm4
                paddsw mm6, mm2

                punpcklbw mm7, mm5
                paddsw mm2, mm0

                packuswb mm6, mm6
                packuswb mm2, mm2

                packuswb mm3, mm3
                paddsw mm4, mm0

                packuswb mm4, mm4
                punpcklbw mm6, mm2

                punpcklbw mm3, mm4

                // 32-bit shuffle.
                pxor mm0, mm0

                movq mm1, mm6
                punpcklbw mm1, mm0

                movq mm0, mm3
                punpcklbw mm0, mm7

                movq mm2, mm0

                punpcklbw mm0, mm1
                punpckhbw mm2, mm1

                // 24-bit shuffle and sav
                movd   [eax], mm0
                psrlq mm0, 32

                movd  3[eax], mm0

                movd  6[eax], mm2


                psrlq mm2, 32            

                movd  9[eax], mm2        

                // 32-bit shuffle.
                pxor mm0, mm0            

                movq mm1, mm6            
                punpckhbw mm1, mm0       

                movq mm0, mm3            
                punpckhbw mm0, mm7       

                movq mm2, mm0            

                punpcklbw mm0, mm1       
                punpckhbw mm2, mm1       

                // 24-bit shuffle and sav
                movd 12[eax], mm0        
                psrlq mm0, 32            

                movd 15[eax], mm0        
                add ebx, 8               

                movd 18[eax], mm2        
                psrlq mm2, 32            

                add ecx, 4               
                add edx, 4               

                movd 21[eax], mm2        
                add eax, 24              

                inc edi
                jne horiz_loop

                pop edi
                pop edx
                pop ecx
                pop ebx
                pop eax

                emms
        }


        if (y == height_y-1) {
            //last line of output - we have used the temp_buff and need to copy
            int x = 3 * width_y;                  //interation counter
            uint8_t *ps = puc_out;                // source pointer (temporary line store)
            uint8_t *pd = puc_out_remembered;     // dest pointer
            while (x--) *(pd++) = *(ps++);          // copy the line
        }

        puc_y   += stride_y;
        if (y%2) {
            puc_u   += stride_uv;
            puc_v   += stride_uv;
        }
        puc_out += stride_out; 
    }
}

1. static int av_create_bmp(char* filename,BYTE *pRGBBuffer,int width,int height,int bpp)
2. {
3.     BITMAPFILEHEADER bmpheader;
4.     BITMAPINFO bmpinfo;
5.     FILE *fp;
7.     fp = fopen(filename,"wb");
8.     if(!fp)return -1;
10.     bmpheader.bfType = ('M'<<8)|'B';
11.     bmpheader.bfReserved1 = 0;
12.     bmpheader.bfReserved2 = 0;
13.     bmpheader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
14.     bmpheader.bfSize = bmpheader.bfOffBits + width*height*bpp/8;
16.     bmpinfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
17.     bmpinfo.bmiHeader.biWidth = width;
18.     bmpinfo.bmiHeader.biHeight = height;
19.     bmpinfo.bmiHeader.biPlanes = 1;
20.     bmpinfo.bmiHeader.biBitCount = bpp;
21.     bmpinfo.bmiHeader.biCompression = BI_RGB;
22.     bmpinfo.bmiHeader.biSizeImage = 0;
23.     bmpinfo.bmiHeader.biXPelsPerMeter = 100;
24.     bmpinfo.bmiHeader.biYPelsPerMeter = 100;
25.     bmpinfo.bmiHeader.biClrUsed = 0;
26.     bmpinfo.bmiHeader.biClrImportant = 0;
28.     fwrite(&bmpheader,sizeof(BITMAPFILEHEADER),1,fp);
29.     fwrite(&bmpinfo.bmiHeader,sizeof(BITMAPINFOHEADER),1,fp);
30.     fwrite(pRGBBuffer,width*height*bpp/8,1,fp);
31.     fclose(fp);
33.     return 0;
34. }

1. void YUV_TO_RGB24(uint8_t *puc_y,int stride_y,uint8_t *puc_u,uint8_t *puc_v, int stride_uv, 
2.                   uint8_t *puc_out,int width_y,int height_y,int stride_out) 
3. {
4.     int y, horiz_count;
5.     uint8_t *puc_out_remembered;
6.     //int stride_out = width_y * 3;
8.     if (height_y < 0) {
9.         //we are flipping our output upside-down
10.         height_y  = -height_y;
11.         puc_y     += (height_y   - 1) * stride_y ;
12.         puc_u     += (height_y/2 - 1) * stride_uv;
13.         puc_v     += (height_y/2 - 1) * stride_uv;
14.         stride_y  = -stride_y;
15.         stride_uv = -stride_uv;
16.     }
18.     horiz_count = -(width_y >> 3);
20.     for (y=0; y<height_y; y++) {
21.         if (y == height_y-1) {
22.             //this is the last output line - we need to be careful not to overrun the end of this line
23.             uint8_t temp_buff[3*MAXIMUM_Y_WIDTH+1];
24.             puc_out_remembered = puc_out;
25.             puc_out = temp_buff; //write the RGB to a temporary store
26.         }
27.         _asm {
28.                 push eax
29.                 push ebx
30.                 push ecx
31.                 push edx
32.                 push edi
34.                 mov eax, puc_out       
35.                 mov ebx, puc_y       
36.                 mov ecx, puc_u       
37.                 mov edx, puc_v
38.                 mov edi, horiz_count
40. horiz_loop:
42.                 movd mm2, [ecx]
43.                 pxor mm7, mm7
45.                 movd mm3, [edx]
46.                 punpcklbw mm2, mm7       
48.                 movq mm0, [ebx]          
49.                 punpcklbw mm3, mm7       
51.                 movq mm1, mmw_0x00ff     
53.                 psubusb mm0, mmb_0x10    
55.                 psubw mm2, mmw_0x0080    
56.                 pand mm1, mm0            
58.                 psubw mm3, mmw_0x0080    
59.                 psllw mm1, 3             
61.                 psrlw mm0, 8             
62.                 psllw mm2, 3             
64.                 pmulhw mm1, mmw_mult_Y   //0x2568
65.                 psllw mm0, 3             
67.                 psllw mm3, 3             
68.                 movq mm5, mm3            
70.                 pmulhw mm5, mmw_mult_V_R //0x3343
71.                 movq mm4, mm2            
73.                 pmulhw mm0, mmw_mult_Y   
74.                 movq mm7, mm1            
76.                 pmulhw mm2, mmw_mult_U_G //0xf36e
77.                 paddsw mm7, mm5
79.                 pmulhw mm3, mmw_mult_V_G //0xe5e2
80.                 packuswb mm7, mm7
82.                 pmulhw mm4, mmw_mult_U_B //0x40cf
83.                 paddsw mm5, mm0      
85.                 packuswb mm5, mm5
86.                 paddsw mm2, mm3          
88.                 movq mm3, mm1            
89.                 movq mm6, mm1            
91.                 paddsw mm3, mm4
92.                 paddsw mm6, mm2
94.                 punpcklbw mm7, mm5
95.                 paddsw mm2, mm0
97.                 packuswb mm6, mm6
98.                 packuswb mm2, mm2
100.                 packuswb mm3, mm3
101.                 paddsw mm4, mm0
103.                 packuswb mm4, mm4
104.                 punpcklbw mm6, mm2
106.                 punpcklbw mm3, mm4
108.                 // 32-bit shuffle.
109.                 pxor mm0, mm0
111.                 movq mm1, mm6
112.                 punpcklbw mm1, mm0
114.                 movq mm0, mm3
115.                 punpcklbw mm0, mm7
117.                 movq mm2, mm0
119.                 punpcklbw mm0, mm1
120.                 punpckhbw mm2, mm1
122.                 // 24-bit shuffle and sav
123.                 movd   [eax], mm0
124.                 psrlq mm0, 32
126.                 movd  3[eax], mm0
128.                 movd  6[eax], mm2
131.                 psrlq mm2, 32            
133.                 movd  9[eax], mm2        
135.                 // 32-bit shuffle.
136.                 pxor mm0, mm0            
138.                 movq mm1, mm6            
139.                 punpckhbw mm1, mm0       
141.                 movq mm0, mm3            
142.                 punpckhbw mm0, mm7       
144.                 movq mm2, mm0            
146.                 punpcklbw mm0, mm1       
147.                 punpckhbw mm2, mm1       
149.                 // 24-bit shuffle and sav
150.                 movd 12[eax], mm0        
151.                 psrlq mm0, 32            
153.                 movd 15[eax], mm0        
154.                 add ebx, 8               
156.                 movd 18[eax], mm2        
157.                 psrlq mm2, 32            
159.                 add ecx, 4               
160.                 add edx, 4               
162.                 movd 21[eax], mm2        
163.                 add eax, 24              
165.                 inc edi
166.                 jne horiz_loop
168.                 pop edi
169.                 pop edx
170.                 pop ecx
171.                 pop ebx
172.                 pop eax
174.                 emms
175.         }
178.         if (y == height_y-1) {
179.             //last line of output - we have used the temp_buff and need to copy
180.             int x = 3 * width_y;                  //interation counter
181.             uint8_t *ps = puc_out;                // source pointer (temporary line store)
182.             uint8_t *pd = puc_out_remembered;     // dest pointer
183.             while (x--) *(pd++) = *(ps++);          // copy the line
184.         }
186.         puc_y   += stride_y;
187.         if (y%2) {
188.             puc_u   += stride_uv;
189.             puc_v   += stride_uv;
190.         }
191.         puc_out += stride_out; 
192.     }
193. }