b3f4c0f29da7647ab7b0773a9b13dba15f17ced4
[vlc.git] / modules / video_chroma / i420_rgb.c
1 /*****************************************************************************
2  * i420_rgb.c : YUV to bitmap RGB conversion module for vlc
3  *****************************************************************************
4  * Copyright (C) 2000, 2001 VideoLAN
5  * $Id: i420_rgb.c,v 1.2 2002/11/20 13:37:36 sam Exp $
6  *
7  * Authors: Samuel Hocevar <sam@zoy.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  * 
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #include <math.h>                                            /* exp(), pow() */
28 #include <string.h>                                            /* strerror() */
29 #include <stdlib.h>                                      /* malloc(), free() */
30
31 #include <vlc/vlc.h>
32 #include <vlc/vout.h>
33
34 #include "i420_rgb.h"
35 #if defined (MODULE_NAME_IS_i420_rgb)
36 #   include "i420_rgb_c.h"
37 #endif
38
39 /*****************************************************************************
40  * Local and extern prototypes.
41  *****************************************************************************/
42 static int  Activate   ( vlc_object_t * );
43 static void Deactivate ( vlc_object_t * );
44
45 #if defined (MODULE_NAME_IS_i420_rgb)
46 static void SetGammaTable       ( int *pi_table, double f_gamma );
47 static void SetYUV              ( vout_thread_t * );
48 static void Set8bppPalette      ( vout_thread_t *, u8 * );
49 #endif
50
51 /*****************************************************************************
52  * Module descriptor.
53  *****************************************************************************/
54 vlc_module_begin();
55 #if defined (MODULE_NAME_IS_i420_rgb)
56     set_description( _("I420,IYUV,YV12 to "
57                        "RGB,RV15,RV16,RV24,RV32 conversions") );
58     set_capability( "chroma", 80 );
59 #elif defined (MODULE_NAME_IS_i420_rgb_mmx)
60     set_description( _( "MMX I420,IYUV,YV12 to "
61                         "RV15,RV16,RV24,RV32 conversions") );
62     set_capability( "chroma", 100 );
63     add_requirement( MMX );
64 #endif
65     set_callbacks( Activate, Deactivate );
66 vlc_module_end();
67
68 /*****************************************************************************
69  * Activate: allocate a chroma function
70  *****************************************************************************
71  * This function allocates and initializes a chroma function
72  *****************************************************************************/
73 static int Activate( vlc_object_t *p_this )
74 {
75     vout_thread_t *p_vout = (vout_thread_t *)p_this;
76 #if defined (MODULE_NAME_IS_i420_rgb)
77     size_t i_tables_size;
78 #endif
79
80     if( p_vout->render.i_width & 1 || p_vout->render.i_height & 1 )
81     {
82         return -1;
83     }
84
85     switch( p_vout->render.i_chroma )
86     {
87         case VLC_FOURCC('Y','V','1','2'):
88         case VLC_FOURCC('I','4','2','0'):
89         case VLC_FOURCC('I','Y','U','V'):
90             switch( p_vout->output.i_chroma )
91             {
92 #if defined (MODULE_NAME_IS_i420_rgb)
93                 case VLC_FOURCC('R','G','B','2'):
94                     p_vout->chroma.pf_convert = E_(I420_RGB8);
95                     break;
96 #endif
97                 case VLC_FOURCC('R','V','1','5'):
98                     p_vout->chroma.pf_convert = E_(I420_RGB15);
99                     break;
100
101                 case VLC_FOURCC('R','V','1','6'):
102                     p_vout->chroma.pf_convert = E_(I420_RGB16);
103                     break;
104
105                 case VLC_FOURCC('R','V','2','4'):
106                 case VLC_FOURCC('R','V','3','2'):
107                     p_vout->chroma.pf_convert = E_(I420_RGB32);
108                     break;
109
110                 default:
111                     return -1;
112             }
113             break;
114
115         default:
116             return -1;
117     }
118     
119     p_vout->chroma.p_sys = malloc( sizeof( chroma_sys_t ) );
120     if( p_vout->chroma.p_sys == NULL )
121     {
122         return -1;
123     }
124
125     switch( p_vout->output.i_chroma )
126     {
127 #if defined (MODULE_NAME_IS_i420_rgb)
128         case VLC_FOURCC('R','G','B','2'):
129             p_vout->chroma.p_sys->p_buffer = malloc( VOUT_MAX_WIDTH );
130             break;
131 #endif
132
133         case VLC_FOURCC('R','V','1','5'):
134         case VLC_FOURCC('R','V','1','6'):
135             p_vout->chroma.p_sys->p_buffer = malloc( VOUT_MAX_WIDTH * 2 );
136             break;
137
138         case VLC_FOURCC('R','V','2','4'):
139         case VLC_FOURCC('R','V','3','2'):
140             p_vout->chroma.p_sys->p_buffer = malloc( VOUT_MAX_WIDTH * 4 );
141             break;
142
143         default:
144             p_vout->chroma.p_sys->p_buffer = NULL;
145             break;
146     }
147
148     if( p_vout->chroma.p_sys->p_buffer == NULL )
149     {
150         free( p_vout->chroma.p_sys );
151         return -1;
152     }
153
154     p_vout->chroma.p_sys->p_offset = malloc( p_vout->output.i_width
155                     * ( ( p_vout->output.i_chroma
156                            == VLC_FOURCC('R','G','B','2') ) ? 2 : 1 )
157                     * sizeof( int ) );
158     if( p_vout->chroma.p_sys->p_offset == NULL )
159     {
160         free( p_vout->chroma.p_sys->p_buffer );
161         free( p_vout->chroma.p_sys );
162         return -1;
163     }
164
165 #if defined (MODULE_NAME_IS_i420_rgb)
166     switch( p_vout->output.i_chroma )
167     {
168     case VLC_FOURCC('R','G','B','2'):
169         i_tables_size = sizeof( u8 ) * PALETTE_TABLE_SIZE;
170         break;
171     case VLC_FOURCC('R','V','1','5'):
172     case VLC_FOURCC('R','V','1','6'):
173         i_tables_size = sizeof( u16 ) * RGB_TABLE_SIZE;
174         break;
175     default: /* RV24, RV32 */
176         i_tables_size = sizeof( u32 ) * RGB_TABLE_SIZE;
177         break;
178     }
179
180     p_vout->chroma.p_sys->p_base = malloc( i_tables_size );
181     if( p_vout->chroma.p_sys->p_base == NULL )
182     {
183         free( p_vout->chroma.p_sys->p_offset );
184         free( p_vout->chroma.p_sys->p_buffer );
185         free( p_vout->chroma.p_sys );
186         return -1;
187     }
188
189     SetYUV( p_vout );
190 #endif
191
192     return 0; 
193 }
194
195 /*****************************************************************************
196  * Deactivate: free the chroma function
197  *****************************************************************************
198  * This function frees the previously allocated chroma function
199  *****************************************************************************/
200 static void Deactivate( vlc_object_t *p_this )
201 {
202     vout_thread_t *p_vout = (vout_thread_t *)p_this;
203
204 #if defined (MODULE_NAME_IS_i420_rgb)
205     free( p_vout->chroma.p_sys->p_base );
206 #endif
207     free( p_vout->chroma.p_sys->p_offset );
208     free( p_vout->chroma.p_sys->p_buffer );
209     free( p_vout->chroma.p_sys );
210 }
211
212 #if defined (MODULE_NAME_IS_i420_rgb)
213 /*****************************************************************************
214  * SetGammaTable: return intensity table transformed by gamma curve.
215  *****************************************************************************
216  * pi_table is a table of 256 entries from 0 to 255.
217  *****************************************************************************/
218 static void SetGammaTable( int *pi_table, double f_gamma )
219 {
220     int i_y;                                               /* base intensity */
221
222     /* Use exp(gamma) instead of gamma */
223     f_gamma = exp( f_gamma );
224
225     /* Build gamma table */
226     for( i_y = 0; i_y < 256; i_y++ )
227     {
228         pi_table[ i_y ] = (int)( pow( (double)i_y / 256, f_gamma ) * 256 );
229     }
230 }
231
232 /*****************************************************************************
233  * SetYUV: compute tables and set function pointers
234  *****************************************************************************/
235 static void SetYUV( vout_thread_t *p_vout )
236 {
237     int         pi_gamma[256];                                /* gamma table */
238     int         i_index;                                  /* index in tables */
239
240     /* Build gamma table */
241     SetGammaTable( pi_gamma, p_vout->f_gamma );
242
243     /*
244      * Set pointers and build YUV tables
245      */
246
247     /* Color: build red, green and blue tables */
248     switch( p_vout->output.i_chroma )
249     {
250     case VLC_FOURCC('R','G','B','2'):
251         p_vout->chroma.p_sys->p_rgb8 = (u8 *)p_vout->chroma.p_sys->p_base;
252         Set8bppPalette( p_vout, p_vout->chroma.p_sys->p_rgb8 );
253         break;
254
255     case VLC_FOURCC('R','V','1','5'):
256     case VLC_FOURCC('R','V','1','6'):
257         p_vout->chroma.p_sys->p_rgb16 = (u16 *)p_vout->chroma.p_sys->p_base;
258         for( i_index = 0; i_index < RED_MARGIN; i_index++ )
259         {
260             p_vout->chroma.p_sys->p_rgb16[RED_OFFSET - RED_MARGIN + i_index] = RGB2PIXEL( p_vout, pi_gamma[0], 0, 0 );
261             p_vout->chroma.p_sys->p_rgb16[RED_OFFSET + 256 + i_index] =        RGB2PIXEL( p_vout, pi_gamma[255], 0, 0 );
262         }
263         for( i_index = 0; i_index < GREEN_MARGIN; i_index++ )
264         {
265             p_vout->chroma.p_sys->p_rgb16[GREEN_OFFSET - GREEN_MARGIN + i_index] = RGB2PIXEL( p_vout, 0, pi_gamma[0], 0 );
266             p_vout->chroma.p_sys->p_rgb16[GREEN_OFFSET + 256 + i_index] =          RGB2PIXEL( p_vout, 0, pi_gamma[255], 0 );
267         }
268         for( i_index = 0; i_index < BLUE_MARGIN; i_index++ )
269         {
270             p_vout->chroma.p_sys->p_rgb16[BLUE_OFFSET - BLUE_MARGIN + i_index] = RGB2PIXEL( p_vout, 0, 0, pi_gamma[0] );
271             p_vout->chroma.p_sys->p_rgb16[BLUE_OFFSET + BLUE_MARGIN + i_index] = RGB2PIXEL( p_vout, 0, 0, pi_gamma[255] );
272         }
273         for( i_index = 0; i_index < 256; i_index++ )
274         {
275             p_vout->chroma.p_sys->p_rgb16[RED_OFFSET + i_index] =   RGB2PIXEL( p_vout, pi_gamma[ i_index ], 0, 0 );
276             p_vout->chroma.p_sys->p_rgb16[GREEN_OFFSET + i_index] = RGB2PIXEL( p_vout, 0, pi_gamma[ i_index ], 0 );
277             p_vout->chroma.p_sys->p_rgb16[BLUE_OFFSET + i_index] =  RGB2PIXEL( p_vout, 0, 0, pi_gamma[ i_index ] );
278         }
279         break;
280
281     case VLC_FOURCC('R','V','2','4'):
282     case VLC_FOURCC('R','V','3','2'):
283         p_vout->chroma.p_sys->p_rgb32 = (u32 *)p_vout->chroma.p_sys->p_base;
284         for( i_index = 0; i_index < RED_MARGIN; i_index++ )
285         {
286             p_vout->chroma.p_sys->p_rgb32[RED_OFFSET - RED_MARGIN + i_index] = RGB2PIXEL( p_vout, pi_gamma[0], 0, 0 );
287             p_vout->chroma.p_sys->p_rgb32[RED_OFFSET + 256 + i_index] =        RGB2PIXEL( p_vout, pi_gamma[255], 0, 0 );
288         }
289         for( i_index = 0; i_index < GREEN_MARGIN; i_index++ )
290         {
291             p_vout->chroma.p_sys->p_rgb32[GREEN_OFFSET - GREEN_MARGIN + i_index] = RGB2PIXEL( p_vout, 0, pi_gamma[0], 0 );
292             p_vout->chroma.p_sys->p_rgb32[GREEN_OFFSET + 256 + i_index] =          RGB2PIXEL( p_vout, 0, pi_gamma[255], 0 );
293         }
294         for( i_index = 0; i_index < BLUE_MARGIN; i_index++ )
295         {
296             p_vout->chroma.p_sys->p_rgb32[BLUE_OFFSET - BLUE_MARGIN + i_index] = RGB2PIXEL( p_vout, 0, 0, pi_gamma[0] );
297             p_vout->chroma.p_sys->p_rgb32[BLUE_OFFSET + BLUE_MARGIN + i_index] = RGB2PIXEL( p_vout, 0, 0, pi_gamma[255] );
298         }
299         for( i_index = 0; i_index < 256; i_index++ )
300         {
301             p_vout->chroma.p_sys->p_rgb32[RED_OFFSET + i_index] =   RGB2PIXEL( p_vout, pi_gamma[ i_index ], 0, 0 );
302             p_vout->chroma.p_sys->p_rgb32[GREEN_OFFSET + i_index] = RGB2PIXEL( p_vout, 0, pi_gamma[ i_index ], 0 );
303             p_vout->chroma.p_sys->p_rgb32[BLUE_OFFSET + i_index] =  RGB2PIXEL( p_vout, 0, 0, pi_gamma[ i_index ] );
304         }
305         break;
306     }
307 }
308
309 static void Set8bppPalette( vout_thread_t *p_vout, u8 *p_rgb8 )
310 {
311     #define CLIP( x ) ( ((x < 0) ? 0 : (x > 255) ? 255 : x) << 8 )
312
313     int y,u,v;
314     int r,g,b;
315     int i = 0, j = 0;
316     u16 red[ 256 ], green[ 256 ], blue[ 256 ];
317     unsigned char p_lookup[PALETTE_TABLE_SIZE];
318
319     /* This loop calculates the intersection of an YUV box and the RGB cube. */
320     for ( y = 0; y <= 256; y += 16, i += 128 - 81 )
321     {
322         for ( u = 0; u <= 256; u += 32 )
323         {
324             for ( v = 0; v <= 256; v += 32 )
325             {
326                 r = y + ( (V_RED_COEF*(v-128)) >> SHIFT );
327                 g = y + ( (U_GREEN_COEF*(u-128)
328                          + V_GREEN_COEF*(v-128)) >> SHIFT );
329                 b = y + ( (U_BLUE_COEF*(u-128)) >> SHIFT );
330
331                 if( r >= 0x00 && g >= 0x00 && b >= 0x00
332                         && r <= 0xff && g <= 0xff && b <= 0xff )
333                 {
334                     /* This one should never happen unless someone
335                      * fscked up my code */
336                     if( j == 256 )
337                     {
338                         msg_Err( p_vout, "no colors left in palette" );
339                         break;
340                     }
341
342                     /* Clip the colors */
343                     red[ j ] = CLIP( r );
344                     green[ j ] = CLIP( g );
345                     blue[ j ] = CLIP( b );
346
347                     /* Allocate color */
348                     p_lookup[ i ] = 1;
349                     p_rgb8[ i++ ] = j;
350                     j++;
351                 }
352                 else
353                 {
354                     p_lookup[ i ] = 0;
355                     p_rgb8[ i++ ] = 0;
356                 }
357             }
358         }
359     }
360
361     /* The colors have been allocated, we can set the palette */
362     p_vout->output.pf_setpalette( p_vout, red, green, blue );
363
364 #if 0
365     /* There will eventually be a way to know which colors
366      * couldn't be allocated and try to find a replacement */
367     p_vout->i_white_pixel = 0xff;
368     p_vout->i_black_pixel = 0x00;
369     p_vout->i_gray_pixel = 0x44;
370     p_vout->i_blue_pixel = 0x3b;
371 #endif
372
373     /* This loop allocates colors that got outside the RGB cube */
374     for ( i = 0, y = 0; y <= 256; y += 16, i += 128 - 81 )
375     {
376         for ( u = 0; u <= 256; u += 32 )
377         {
378             for ( v = 0; v <= 256; v += 32, i++ )
379             {
380                 int u2, v2, dist, mindist = 100000000;
381
382                 if( p_lookup[ i ] || y == 0 )
383                 {
384                     continue;
385                 }
386
387                 /* Heavy. yeah. */
388                 for( u2 = 0; u2 <= 256; u2 += 32 )
389                 {
390                     for( v2 = 0; v2 <= 256; v2 += 32 )
391                     {
392                         j = ((y>>4)<<7) + (u2>>5)*9 + (v2>>5);
393                         dist = (u-u2)*(u-u2) + (v-v2)*(v-v2);
394
395                         /* Find the nearest color */
396                         if( p_lookup[ j ] && dist < mindist )
397                         {
398                             p_rgb8[ i ] = p_rgb8[ j ];
399                             mindist = dist;
400                         }
401
402                         j -= 128;
403
404                         /* Find the nearest color */
405                         if( p_lookup[ j ] && dist + 128 < mindist )
406                         {
407                             p_rgb8[ i ] = p_rgb8[ j ];
408                             mindist = dist + 128;
409                         }
410                     }
411                 }
412             }
413         }
414     }
415 }
416
417 #endif
418