* modules/*: sanitization of the modules description strings.
[vlc.git] / modules / video_output / mga / mga.c
1 /*****************************************************************************
2  * mga.c : Matrox Graphic Array plugin for vlc
3  *****************************************************************************
4  * Copyright (C) 2000, 2001 VideoLAN
5  * $Id: mga.c,v 1.2 2003/03/30 18:14:39 gbazin Exp $
6  *
7  * Authors: Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
8  *          Samuel Hocevar <sam@zoy.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  * 
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #include <errno.h>                                                 /* ENOMEM */
29 #include <unistd.h>                                               /* close() */
30 #include <stdlib.h>                                                /* free() */
31 #include <string.h>                                            /* strerror() */
32 #include <fcntl.h>                                                 /* open() */
33 #include <sys/ioctl.h>                                            /* ioctl() */
34 #include <sys/mman.h>                                          /* PROT_WRITE */
35
36 #include <vlc/vlc.h>
37 #include <vlc/vout.h>
38
39 #ifdef SYS_BSD
40 #include <sys/types.h>                                     /* typedef ushort */
41 #endif
42
43 /*****************************************************************************
44  * Local prototypes
45  *****************************************************************************/
46 static int  Create    ( vlc_object_t * );
47 static void Destroy   ( vlc_object_t * );
48
49 static int  Init      ( vout_thread_t * );
50 static void End       ( vout_thread_t * );                         
51 static void Display   ( vout_thread_t *, picture_t * );            
52
53 static int  NewPicture     ( vout_thread_t *, picture_t * );
54
55 /*****************************************************************************
56  * Module descriptor
57  *****************************************************************************/
58 vlc_module_begin();  
59     set_description( _("Matrox Graphic Array video output") );
60     set_capability( "video output", 10 );
61     set_callbacks( Create, Destroy );
62 vlc_module_end();
63
64 /*****************************************************************************
65  * vout_sys_t: video output MGA method descriptor
66  *****************************************************************************
67  * This structure is part of the video output thread descriptor.
68  * It describes the MGA specific properties of an output thread.
69  *****************************************************************************/
70 #ifndef __LINUX_MGAVID_H
71 #   define __LINUX_MGAVID_H
72
73 #   define MGA_VID_CONFIG _IOR('J', 1, mga_vid_config_t)
74 #   define MGA_VID_ON     _IO ('J', 2)
75 #   define MGA_VID_OFF    _IO ('J', 3)
76 #   define MGA_VID_FSEL   _IOR('J', 4, int)
77 #   define MGA_G200 0x1234
78 #   define MGA_G400 0x5678
79
80 #   define MGA_VID_FORMAT_YV12 0x32315659
81 #   define MGA_VID_FORMAT_IYUV (('I'<<24)|('Y'<<16)|('U'<<8)|'V')
82 #   define MGA_VID_FORMAT_I420 (('I'<<24)|('4'<<16)|('2'<<8)|'0')
83 #   define MGA_VID_FORMAT_YUY2 (('Y'<<24)|('U'<<16)|('Y'<<8)|'2')
84 #   define MGA_VID_FORMAT_UYVY (('U'<<24)|('Y'<<16)|('V'<<8)|'Y')
85
86 #   define MGA_VID_VERSION     0x0201
87
88 #   define MGA_NUM_FRAMES      1
89
90 typedef struct mga_vid_config_t
91 {
92     u16 version;
93     u16 card_type;
94     u32 ram_size;
95     u32 src_width;
96     u32 src_height;
97     u32 dest_width;
98     u32 dest_height;
99     u32 x_org;
100     u32 y_org;
101     u8  colkey_on;
102     u8  colkey_red;
103     u8  colkey_green;
104     u8  colkey_blue;
105     u32 format;
106     u32 frame_size;
107     u32 num_frames;
108 } mga_vid_config_t;
109 #endif
110
111 struct vout_sys_t
112 {
113     mga_vid_config_t    mga;
114     int                 i_fd;
115     byte_t *            p_video;
116 };
117
118 struct picture_sys_t
119 {
120     int     i_frame;
121 };
122
123 #define CEIL32(x) (((x)+31)&~31)
124
125 /*****************************************************************************
126  * Create: allocates dummy video thread output method
127  *****************************************************************************
128  * This function allocates and initializes a dummy vout method.
129  *****************************************************************************/
130 static int Create( vlc_object_t *p_this )
131 {
132     vout_thread_t *p_vout = (vout_thread_t *)p_this;
133
134     /* Allocate structure */
135     p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
136     if( p_vout->p_sys == NULL )
137     {
138         msg_Err( p_vout, "out of memory" );
139         return( 1 );
140     }
141
142     p_vout->p_sys->i_fd = open( "/dev/mga_vid", O_RDWR );
143     if( p_vout->p_sys->i_fd == -1 )
144     {
145         msg_Err( p_vout, "cannot open MGA driver /dev/mga_vid" );
146         free( p_vout->p_sys );
147         return( 1 );
148     }
149
150     p_vout->pf_init = Init;
151     p_vout->pf_end = End;
152     p_vout->pf_manage = NULL;
153     p_vout->pf_render = NULL;
154     p_vout->pf_display = Display;
155
156     return( 0 );
157 }
158
159 /*****************************************************************************
160  * Init: initialize dummy video thread output method
161  *****************************************************************************/
162 static int Init( vout_thread_t *p_vout )
163 {
164     int i_index;
165     picture_t *p_pic;
166
167     I_OUTPUTPICTURES = 0;
168
169     /* create the MGA output */
170     p_vout->output.i_width = p_vout->render.i_width;
171     p_vout->output.i_height = p_vout->render.i_height;
172     p_vout->output.i_aspect = p_vout->render.i_aspect;
173
174     /* Set coordinates and aspect ratio */
175     p_vout->p_sys->mga.src_width = CEIL32(p_vout->output.i_width);
176     p_vout->p_sys->mga.src_height = p_vout->output.i_height;
177     vout_PlacePicture( p_vout, 1024, 768,
178                        &p_vout->p_sys->mga.x_org, &p_vout->p_sys->mga.y_org,
179                        &p_vout->p_sys->mga.dest_width,
180                        &p_vout->p_sys->mga.dest_height );
181
182     /* Initialize a video buffer */
183     p_vout->p_sys->mga.colkey_on = 0;
184     p_vout->p_sys->mga.num_frames = MGA_NUM_FRAMES;
185     p_vout->p_sys->mga.frame_size = CEIL32(p_vout->output.i_width)
186                                      * p_vout->output.i_height * 2;
187     p_vout->p_sys->mga.version = MGA_VID_VERSION;
188
189     /* Assume we only do YMGA for the moment. XXX: mga_vid calls this
190      * YV12, but it's actually some strange format with packed UV. */
191     p_vout->output.i_chroma = VLC_FOURCC('Y','M','G','A');
192     p_vout->p_sys->mga.format = MGA_VID_FORMAT_YV12;
193     
194     if( ioctl(p_vout->p_sys->i_fd, MGA_VID_CONFIG, &p_vout->p_sys->mga) )
195     {
196         msg_Err( p_vout, "MGA config ioctl failed" );
197         return -1;
198     }
199
200     if( p_vout->p_sys->mga.card_type == MGA_G200 )
201     {
202         msg_Dbg( p_vout, "detected MGA G200 (%d MB Ram)",
203                          p_vout->p_sys->mga.ram_size );
204     }
205     else
206     {
207         msg_Dbg( p_vout, "detected MGA G400/G450 (%d MB Ram)",
208                          p_vout->p_sys->mga.ram_size );
209     }
210
211     p_vout->p_sys->p_video = mmap( 0, p_vout->p_sys->mga.frame_size
212                                        * MGA_NUM_FRAMES,
213                                    PROT_WRITE, MAP_SHARED,
214                                    p_vout->p_sys->i_fd, 0 );
215
216     /* Try to initialize up to MGA_NUM_FRAMES direct buffers */
217     while( I_OUTPUTPICTURES < MGA_NUM_FRAMES )
218     {
219         p_pic = NULL;
220
221         /* Find an empty picture slot */
222         for( i_index = 0 ; i_index < VOUT_MAX_PICTURES ; i_index++ )
223         {
224             if( p_vout->p_picture[ i_index ].i_status == FREE_PICTURE )
225             {
226                 p_pic = p_vout->p_picture + i_index;
227                 break;
228             }
229         }
230
231         /* Allocate the picture */
232         if( p_pic == NULL || NewPicture( p_vout, p_pic ) )
233         {
234             break;
235         }
236
237         p_pic->i_status = DESTROYED_PICTURE;
238         p_pic->i_type   = DIRECT_PICTURE;
239
240         PP_OUTPUTPICTURE[ I_OUTPUTPICTURES ] = p_pic;
241
242         I_OUTPUTPICTURES++;
243     }
244
245     /* Blank the windows */
246     for( i_index = 0; i_index < I_OUTPUTPICTURES; i_index++ )
247     {
248         memset( p_vout->p_sys->p_video
249                  + p_vout->p_sys->mga.frame_size * i_index,
250                 0x00, p_vout->p_sys->mga.frame_size / 2 );
251         memset( p_vout->p_sys->p_video
252                  + p_vout->p_sys->mga.frame_size * ( 2*i_index + 1 ) / 2,
253                 0x80, p_vout->p_sys->mga.frame_size / 2 );
254     }
255
256     /* Display the image */
257     ioctl( p_vout->p_sys->i_fd, MGA_VID_ON, 0 );
258
259     return( 0 );
260 }
261
262 /*****************************************************************************
263  * End: terminate dummy video thread output method
264  *****************************************************************************/
265 static void End( vout_thread_t *p_vout )
266 {
267     int i_index;
268
269     ioctl( p_vout->p_sys->i_fd, MGA_VID_OFF, 0 );
270
271     /* Free the output buffers we allocated */
272     for( i_index = I_OUTPUTPICTURES ; i_index ; )
273     {
274         i_index--;
275     }
276 }
277
278 /*****************************************************************************
279  * Destroy: destroy dummy video thread output method
280  *****************************************************************************
281  * Terminate an output method created by DummyCreateOutputMethod
282  *****************************************************************************/
283 static void Destroy( vlc_object_t *p_this )
284 {   
285     vout_thread_t *p_vout = (vout_thread_t *)p_this; 
286     close( p_vout->p_sys->i_fd );
287     free( p_vout->p_sys );
288 }
289
290 /*****************************************************************************
291  * Display: displays previously rendered output
292  *****************************************************************************/
293 static void Display( vout_thread_t *p_vout, picture_t *p_pic )
294 {
295     ioctl( p_vout->p_sys->i_fd, MGA_VID_FSEL, &p_pic->p_sys->i_frame );
296 }
297
298 /* Following functions are local */
299
300 /*****************************************************************************
301  * NewPicture: allocate a picture
302  *****************************************************************************
303  * Returns 0 on success, -1 otherwise
304  *****************************************************************************/
305 static int NewPicture( vout_thread_t *p_vout, picture_t *p_pic )
306 {
307     /* We know the chroma, allocate a buffer which will be used
308      * directly by the decoder */
309     p_pic->p_data = p_vout->p_sys->p_video + I_OUTPUTPICTURES
310                                               * p_vout->p_sys->mga.frame_size;
311
312     p_pic->p_sys = malloc( sizeof( picture_sys_t ) );
313
314     if( p_pic->p_sys == NULL )
315     {
316         return -1;
317     }
318
319     p_pic->Y_PIXELS = p_pic->p_data;
320     p_pic->p[Y_PLANE].i_lines = p_vout->output.i_height;
321     p_pic->p[Y_PLANE].i_pitch = CEIL32( p_vout->output.i_width );
322     p_pic->p[Y_PLANE].i_pixel_pitch = 1;
323     p_pic->p[Y_PLANE].i_visible_pitch = p_vout->output.i_width;
324
325     p_pic->U_PIXELS = p_pic->p_data + p_vout->p_sys->mga.frame_size * 2/4;
326     p_pic->p[U_PLANE].i_lines = p_vout->output.i_height / 2;
327     p_pic->p[U_PLANE].i_pitch = CEIL32( p_vout->output.i_width ) / 2;
328     p_pic->p[U_PLANE].i_pixel_pitch = 1;
329     p_pic->p[U_PLANE].i_visible_pitch = p_pic->p[U_PLANE].i_pitch;
330
331     p_pic->V_PIXELS = p_pic->p_data + p_vout->p_sys->mga.frame_size * 3/4;
332     p_pic->p[V_PLANE].i_lines = p_vout->output.i_height / 2;
333     p_pic->p[V_PLANE].i_pitch = CEIL32( p_vout->output.i_width ) / 2;
334     p_pic->p[V_PLANE].i_pixel_pitch = 1;
335     p_pic->p[V_PLANE].i_visible_pitch = p_pic->p[V_PLANE].i_pitch;
336
337     p_pic->p_sys->i_frame = I_OUTPUTPICTURES;
338
339     p_pic->i_planes = 3;
340
341     return 0;
342 }
343