← Back to branch summary

~ubuntu-branches/ubuntu/maverick/vlc/maverick

« back to all changes in this revision

Viewing changes to modules/video_output/sdl.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2008-09-17 21:56:14 UTC
  • mfrom: (1.1.17 upstream)
  • Revision ID: james.westby@ubuntu.com-20080917215614-tj0vx8xzd57e52t8
Tags: 0.9.2-1ubuntu1
https://launchpad.net/bugs/270404
https://launchpad.net/bugs/210354
https://launchpad.net/bugs/199870
https://launchpad.net/bugs/261567
* New Upstream Release, exception granted by
    - dktrkranz, norsetto, Hobbsee (via irc). LP: #270404

Changes done in ubuntu:

* add libxul-dev to build-depends
* make sure that vlc is build against libxul in configure. This doesn't
  change anything in the package, but makes it more robust if building
  in an 'unclean' chroot or when modifying the package.
* debian/control: make Vcs-* fields point to the motumedia branch
* add libx264-dev and libass-dev to build-depends
  LP: #210354, #199870
* actually enable libass support by passing --enable-libass to configure
* enable libdca: add libdca-dev to build depends and --enable-libdca
* install the x264 plugin.

Changes already in the pkg-multimedia branch in debian:

* don't install usr/share/vlc/mozilla in debian/mozilla-plugin-vlc.install  
* new upstream .desktop file now registers flash video mimetype LP: #261567
* add Xb-Npp-Applications to mozilla-plugin-vlc
* remove duplicate entries in debian/vlc-nox.install

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/video_output/sdl.c
2
2
 * sdl.c: SDL video output display method
3
3
 *****************************************************************************
4
4
 * Copyright (C) 1998-2001 the VideoLAN team
5
 
 * $Id: ba975d23a1462d37c86c72781dcf22d8c951d693 $
 
5
 * $Id$
6
6
 *
7
7
 * Authors: Samuel Hocevar <sam@zoy.org>
8
8
 *          Pierre Baillet <oct@zoy.org>
27
27
 * Preamble
28
28
 *****************************************************************************/
29
29
#include <errno.h>                                                 /* ENOMEM */
30
 
#include <stdlib.h>                                                /* free() */
31
 
#include <string.h>                                            /* strerror() */
32
 
 
33
 
#include <vlc/vlc.h>
34
 
#include <vlc/intf.h>
35
 
#include <vlc/vout.h>
36
 
#include <vlc/aout.h>
 
30
 
 
31
#ifdef HAVE_CONFIG_H
 
32
# include "config.h"
 
33
#endif
 
34
 
 
35
#include <vlc_common.h>
 
36
#include <vlc_plugin.h>
 
37
#include <vlc_interface.h>
 
38
#include <vlc_playlist.h>
 
39
#include <vlc_vout.h>
 
40
#include <vlc_keys.h>
 
41
//#include <vlc_aout.h>
37
42
 
38
43
#include <sys/types.h>
39
44
#ifndef WIN32
59
64
    int i_width;
60
65
    int i_height;
61
66
 
 
67
#if SDL_VERSION_ATLEAST(1,2,10)
 
68
    unsigned int i_desktop_width;
 
69
    unsigned int i_desktop_height;
 
70
#endif
 
71
 
62
72
    /* For YUV output */
63
73
    SDL_Overlay * p_overlay;   /* An overlay we keep to grab the XVideo port */
64
74
 
65
75
    /* For RGB output */
66
76
    int i_surfaces;
67
77
 
68
 
    vlc_bool_t  b_cursor;
69
 
    vlc_bool_t  b_cursor_autohidden;
 
78
    bool  b_cursor;
 
79
    bool  b_cursor_autohidden;
70
80
    mtime_t     i_lastmoved;
 
81
    mtime_t     i_mouse_hide_timeout;
71
82
    mtime_t     i_lastpressed;                        /* to track dbl-clicks */
72
83
};
73
84
 
98
109
static void SetPalette      ( vout_thread_t *,
99
110
                              uint16_t *, uint16_t *, uint16_t * );
100
111
 
 
112
static int ConvertKey( SDLKey );
 
113
 
 
114
 
 
115
#define CHROMA_TEXT N_("SDL chroma format")
 
116
#define CHROMA_LONGTEXT N_( \
 
117
    "Force the SDL renderer to use a specific chroma format instead of " \
 
118
    "trying to improve performances by using the most efficient one.")
 
119
 
101
120
/*****************************************************************************
102
121
 * Module descriptor
103
122
 *****************************************************************************/
105
124
    set_shortname( "SDL" );
106
125
    set_category( CAT_VIDEO );
107
126
    set_subcategory( SUBCAT_VIDEO_VOUT );
108
 
    set_description( _("Simple DirectMedia Layer video output") );
 
127
    set_description( N_("Simple DirectMedia Layer video output") );
109
128
    set_capability( "video output", 60 );
110
129
    add_shortcut( "sdl" );
 
130
    add_string( "sdl-chroma", NULL, NULL, CHROMA_TEXT, CHROMA_LONGTEXT, true );
111
131
    set_callbacks( Open, Close );
112
 
    /* XXX: check for conflicts with the SDL audio output */
113
 
    var_Create( p_module->p_libvlc, "sdl", VLC_VAR_MUTEX );
114
132
#if defined( __i386__ ) || defined( __x86_64__ )
115
133
    /* On i386, SDL is linked against svgalib */
116
134
    linked_with_a_crap_library_which_uses_atexit();
127
145
static int Open ( vlc_object_t *p_this )
128
146
{
129
147
    vout_thread_t * p_vout = (vout_thread_t *)p_this;
130
 
    vlc_value_t lockval;
 
148
    /* XXX: check for conflicts with the SDL audio output */
 
149
    vlc_mutex_t *lock = var_AcquireMutex( "sdl" );
131
150
 
132
151
#ifdef HAVE_SETENV
133
152
    char *psz_method;
134
153
#endif
135
154
 
136
 
    var_Get( p_this->p_libvlc, "sdl", &lockval );
137
 
    vlc_mutex_lock( lockval.p_address );
138
 
 
 
155
    if( lock == NULL )
 
156
        return VLC_ENOMEM;
 
157
 
 
158
    p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
 
159
    if( p_vout->p_sys == NULL )
 
160
    {
 
161
        vlc_mutex_unlock( lock );
 
162
        return VLC_ENOMEM;
 
163
    }
 
164
 
 
165
    memset( p_vout->p_sys, 0, sizeof( vout_sys_t ) );
 
166
 
 
167
    /* Check if SDL video module has been initialized */
139
168
    if( SDL_WasInit( SDL_INIT_VIDEO ) != 0 )
140
169
    {
141
 
        vlc_mutex_unlock( lockval.p_address );
 
170
        vlc_mutex_unlock( lock );
 
171
        free( p_vout->p_sys );
142
172
        return VLC_EGENERIC;
143
173
    }
144
174
 
145
175
    /* Allocate structure */
146
 
    p_vout->p_sys = malloc( sizeof( vout_sys_t ) );
147
 
    if( p_vout->p_sys == NULL )
148
 
    {
149
 
        msg_Err( p_vout, "out of memory" );
150
 
        vlc_mutex_unlock( lockval.p_address );
151
 
        return VLC_ENOMEM;
152
 
    }
153
 
 
154
176
    p_vout->pf_init = Init;
155
177
    p_vout->pf_end = End;
156
178
    p_vout->pf_manage = Manage;
157
179
    p_vout->pf_render = NULL;
158
180
    p_vout->pf_display = Display;
 
181
    p_vout->pf_control = NULL;
159
182
 
160
183
#ifdef HAVE_SETENV
161
 
    psz_method = config_GetPsz( p_vout, "vout" );
 
184
    char* psz = psz_method = config_GetPsz( p_vout, "vout" );
162
185
    if( psz_method )
163
186
    {
164
187
        while( *psz_method && *psz_method != ':' )
171
194
            setenv( "SDL_VIDEODRIVER", psz_method + 1, 1 );
172
195
        }
173
196
    }
 
197
    free( psz );
174
198
#endif
175
199
 
176
200
    /* Initialize library */
179
203
    /* Win32 SDL implementation doesn't support SDL_INIT_EVENTTHREAD yet*/
180
204
                | SDL_INIT_EVENTTHREAD
181
205
#endif
182
 
#ifdef DEBUG
 
206
#ifndef NDEBUG
183
207
    /* In debug mode you may want vlc to dump a core instead of staying
184
208
     * stuck */
185
209
                | SDL_INIT_NOPARACHUTE
188
212
    {
189
213
        msg_Err( p_vout, "cannot initialize SDL (%s)", SDL_GetError() );
190
214
        free( p_vout->p_sys );
191
 
        vlc_mutex_unlock( lockval.p_address );
 
215
        vlc_mutex_unlock( lock );
192
216
        return VLC_EGENERIC;
193
217
    }
194
218
 
195
 
    vlc_mutex_unlock( lockval.p_address );
196
 
 
 
219
    vlc_mutex_unlock( lock );
 
220
 
 
221
    /* Translate keys into unicode */
 
222
    SDL_EnableUNICODE(1);
 
223
 
 
224
    /* Get the desktop resolution */
 
225
#if SDL_VERSION_ATLEAST(1,2,10)
 
226
    /* FIXME: SDL has a problem with virtual desktop */
 
227
    p_vout->p_sys->i_desktop_width = SDL_GetVideoInfo()->current_w;
 
228
    p_vout->p_sys->i_desktop_height = SDL_GetVideoInfo()->current_h;
 
229
#endif
 
230
 
 
231
    /* Create the cursor */
197
232
    p_vout->p_sys->b_cursor = 1;
198
233
    p_vout->p_sys->b_cursor_autohidden = 0;
199
 
    p_vout->p_sys->i_lastmoved = mdate();
 
234
    p_vout->p_sys->i_lastmoved = p_vout->p_sys->i_lastpressed = mdate();
 
235
    p_vout->p_sys->i_mouse_hide_timeout =
 
236
        var_GetInteger(p_vout, "mouse-hide-timeout") * 1000;
200
237
 
201
238
    if( OpenDisplay( p_vout ) )
202
239
    {
330
367
    unsigned int i_width, i_height, i_x, i_y;
331
368
 
332
369
    /* Process events */
333
 
    while( SDL_PollEvent(&event) )
 
370
    while( SDL_PollEvent( &event ) )
334
371
    {
335
372
        switch( event.type )
336
373
        {
337
 
        case SDL_VIDEORESIZE:                          /* Resizing of window */
338
 
            /* Update dimensions */
 
374
        /* Resizing of window */
 
375
        case SDL_VIDEORESIZE:
339
376
            p_vout->i_changes |= VOUT_SIZE_CHANGE;
340
377
            p_vout->i_window_width = p_vout->p_sys->i_width = event.resize.w;
341
378
            p_vout->i_window_height = p_vout->p_sys->i_height = event.resize.h;
342
379
            break;
343
380
 
 
381
        /* Mouse move */
344
382
        case SDL_MOUSEMOTION:
345
383
            vout_PlacePicture( p_vout, p_vout->p_sys->i_width,
346
384
                               p_vout->p_sys->i_height,
347
385
                               &i_x, &i_y, &i_width, &i_height );
348
386
 
349
 
            val.i_int = ( event.motion.x - i_x )
350
 
                         * p_vout->render.i_width / i_width;
 
387
            /* Compute the x coordinate and check if the value is
 
388
               in [0,p_vout->fmt_in.i_visible_width] */
 
389
            val.i_int = ( event.motion.x - i_x ) *
 
390
                        p_vout->fmt_in.i_visible_width / i_width +
 
391
                        p_vout->fmt_in.i_x_offset;
 
392
 
 
393
            if( (int)(event.motion.x - i_x) < 0 )
 
394
                val.i_int = 0;
 
395
            else if( (unsigned int)val.i_int > p_vout->fmt_in.i_visible_width )
 
396
                val.i_int = p_vout->fmt_in.i_visible_width;
 
397
 
351
398
            var_Set( p_vout, "mouse-x", val );
352
 
            val.i_int = ( event.motion.y - i_y )
353
 
                         * p_vout->render.i_height / i_height;
 
399
 
 
400
            /* compute the y coordinate and check if the value is
 
401
               in [0,p_vout->fmt_in.i_visible_height] */
 
402
            val.i_int = ( event.motion.y - i_y ) *
 
403
                        p_vout->fmt_in.i_visible_height / i_height +
 
404
                        p_vout->fmt_in.i_y_offset;
 
405
 
 
406
            if( (int)(event.motion.y - i_y) < 0 )
 
407
                val.i_int = 0;
 
408
            else if( (unsigned int)val.i_int > p_vout->fmt_in.i_visible_height )
 
409
                val.i_int = p_vout->fmt_in.i_visible_height;
 
410
 
354
411
            var_Set( p_vout, "mouse-y", val );
355
412
 
356
 
            val.b_bool = VLC_TRUE;
 
413
            val.b_bool = true;
357
414
            var_Set( p_vout, "mouse-moved", val );
358
415
 
359
 
            if( p_vout->p_sys->b_cursor &&
360
 
                (abs(event.motion.xrel) > 2 || abs(event.motion.yrel) > 2) )
 
416
            if( p_vout->p_sys->b_cursor )
361
417
            {
362
418
                if( p_vout->p_sys->b_cursor_autohidden )
363
419
                {
371
427
            }
372
428
            break;
373
429
 
 
430
        /* Mouse button released */
374
431
        case SDL_MOUSEBUTTONUP:
375
432
            switch( event.button.button )
376
433
            {
377
434
            case SDL_BUTTON_LEFT:
378
 
                val.b_bool = VLC_TRUE;
379
 
                var_Set( p_vout, "mouse-clicked", val );
 
435
                {
 
436
                    var_Get( p_vout, "mouse-button-down", &val );
 
437
                    val.i_int &= ~1;
 
438
                    var_Set( p_vout, "mouse-button-down", val );
 
439
 
 
440
                    val.b_bool = true;
 
441
                    var_Set( p_vout, "mouse-clicked", val );
 
442
 
 
443
                    val.b_bool = false;
 
444
                    var_Set( p_vout->p_libvlc, "intf-popupmenu", val );
 
445
                }
 
446
                break;
 
447
 
 
448
            case SDL_BUTTON_MIDDLE:
 
449
                {
 
450
                    var_Get( p_vout, "mouse-button-down", &val );
 
451
                    val.i_int &= ~2;
 
452
                    var_Set( p_vout, "mouse-button-down", val );
 
453
 
 
454
                    vlc_value_t val;
 
455
                    var_Get( p_vout->p_libvlc, "intf-show", &val );
 
456
                    val.b_bool = !val.b_bool;
 
457
                    var_Set( p_vout->p_libvlc, "intf-show", val );
 
458
                }
380
459
                break;
381
460
 
382
461
            case SDL_BUTTON_RIGHT:
383
462
                {
384
463
                    intf_thread_t *p_intf;
 
464
 
 
465
                    var_Get( p_vout, "mouse-button-down", &val );
 
466
                    val.i_int &= ~4;
 
467
                    var_Set( p_vout, "mous-button-down", val );
385
468
                    p_intf = vlc_object_find( p_vout, VLC_OBJECT_INTF,
386
469
                                                      FIND_ANYWHERE );
387
470
                    if( p_intf )
389
472
                        p_intf->b_menu_change = 1;
390
473
                        vlc_object_release( p_intf );
391
474
                    }
 
475
 
 
476
                    val.b_bool = true;
 
477
                    var_Set( p_vout->p_libvlc, "intf-popupmenu", val );
392
478
                }
393
479
                break;
394
480
            }
395
481
            break;
396
482
 
 
483
        /* Mouse button pressed */
397
484
        case SDL_MOUSEBUTTONDOWN:
398
485
            switch( event.button.button )
399
486
            {
400
487
            case SDL_BUTTON_LEFT:
401
 
                /* In this part we will eventually manage
402
 
                 * clicks for DVD navigation for instance. */
 
488
                var_Get( p_vout, "mouse-button-down", &val );
 
489
                val.i_int |= 1;
 
490
                var_Set( p_vout, "mouse-button-down", val );
403
491
 
404
492
                /* detect double-clicks */
405
493
                if( ( mdate() - p_vout->p_sys->i_lastpressed ) < 300000 )
408
496
                p_vout->p_sys->i_lastpressed = mdate();
409
497
                break;
410
498
 
411
 
            case 4:
 
499
            case SDL_BUTTON_MIDDLE:
 
500
                var_Get( p_vout, "mouse-button-down", &val );
 
501
                val.i_int |= 2;
 
502
                var_Set( p_vout, "mouse-button-down", val );
412
503
                break;
413
504
 
414
 
            case 5:
 
505
            case SDL_BUTTON_RIGHT:
 
506
                var_Get( p_vout, "mouse-button-down", &val );
 
507
                val.i_int |= 4;
 
508
                var_Set( p_vout, "mouse-button-down", val );
415
509
                break;
416
510
            }
417
511
            break;
418
512
 
 
513
        /* Quit event (close the window) */
419
514
        case SDL_QUIT:
420
 
            p_vout->p_vlc->b_die = 1;
421
 
            break;
422
 
 
423
 
        case SDL_KEYDOWN:                             /* if a key is pressed */
424
 
 
425
 
            switch( event.key.keysym.sym )
426
 
            {
427
 
            case SDLK_ESCAPE:
428
 
                if( p_vout->b_fullscreen )
429
 
                {
430
 
                    p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
431
 
                }
432
 
                else
433
 
                {
434
 
                    p_vout->p_vlc->b_die = 1;
435
 
                }
436
 
                break;
437
 
 
438
 
            case SDLK_q:                                             /* quit */
439
 
                p_vout->p_vlc->b_die = 1;
440
 
                break;
441
 
 
442
 
            case SDLK_f:                             /* switch to fullscreen */
443
 
                p_vout->i_changes |= VOUT_FULLSCREEN_CHANGE;
444
 
                break;
445
 
 
446
 
            case SDLK_c:                                 /* toggle grayscale */
447
 
                p_vout->b_grayscale = ! p_vout->b_grayscale;
448
 
                p_vout->i_changes |= VOUT_GRAYSCALE_CHANGE;
449
 
                break;
450
 
 
451
 
            case SDLK_i:                                      /* toggle info */
452
 
                p_vout->b_info = ! p_vout->b_info;
453
 
                p_vout->i_changes |= VOUT_INFO_CHANGE;
454
 
                break;
455
 
 
456
 
            case SDLK_s:                                   /* toggle scaling */
457
 
                p_vout->b_scale = ! p_vout->b_scale;
458
 
                p_vout->i_changes |= VOUT_SCALE_CHANGE;
459
 
                break;
460
 
 
461
 
            case SDLK_SPACE:                             /* toggle interface */
462
 
                p_vout->b_interface = ! p_vout->b_interface;
463
 
                p_vout->i_changes |= VOUT_INTF_CHANGE;
464
 
                break;
465
 
 
466
 
            case SDLK_MENU:
467
 
                {
468
 
                    intf_thread_t *p_intf;
469
 
                    p_intf = vlc_object_find( p_vout, VLC_OBJECT_INTF,
470
 
                                                      FIND_ANYWHERE );
471
 
                    if( p_intf != NULL )
472
 
                    {
473
 
                        p_intf->b_menu_change = 1;
474
 
                        vlc_object_release( p_intf );
475
 
                    }
476
 
                }
477
 
                break;
478
 
 
479
 
            case SDLK_LEFT:
480
 
                break;
481
 
 
482
 
            case SDLK_RIGHT:
483
 
                break;
484
 
 
485
 
            case SDLK_UP:
486
 
                break;
487
 
 
488
 
            case SDLK_DOWN:
489
 
                break;
490
 
 
491
 
            case SDLK_b:
492
 
                {
493
 
                    audio_volume_t i_volume;
494
 
                    if ( !aout_VolumeDown( p_vout, 1, &i_volume ) )
495
 
                    {
496
 
                        msg_Dbg( p_vout, "audio volume is now %d", i_volume );
497
 
                    }
498
 
                    else
499
 
                    {
500
 
                        msg_Dbg( p_vout, "audio volume: operation not supported" );
501
 
                    }
502
 
                }
503
 
                break;
504
 
 
505
 
            case SDLK_n:
506
 
                {
507
 
                    audio_volume_t i_volume;
508
 
                    if ( !aout_VolumeUp( p_vout, 1, &i_volume ) )
509
 
                    {
510
 
                        msg_Dbg( p_vout, "audio volume is now %d", i_volume );
511
 
                    }
512
 
                    else
513
 
                    {
514
 
                        msg_Dbg( p_vout, "audio volume: operation not supported" );
515
 
                    }
516
 
                }
517
 
                break;
518
 
 
519
 
             default:
520
 
                break;
521
 
            }
522
 
            break;
 
515
            {
 
516
#if 0
 
517
                playlist_t *p_playlist = pl_Yield( p_vout );
 
518
                if( p_playlist != NULL )
 
519
                {
 
520
                    playlist_Stop( p_playlist );
 
521
                    pl_Release( p_vout );
 
522
                }
 
523
#else
 
524
#warning FIXME FIXME ?
 
525
#endif
 
526
            }
 
527
            break;
 
528
 
 
529
        /* Key pressed */
 
530
        case SDL_KEYDOWN:
 
531
            /* convert the key if possible */
 
532
            val.i_int = ConvertKey( event.key.keysym.sym );
 
533
 
 
534
            if( !val.i_int )
 
535
            {
 
536
                /* Find the right caracter */
 
537
                if( ( event.key.keysym.unicode & 0xff80 ) == 0 )
 
538
                {
 
539
                    val.i_int = event.key.keysym.unicode & 0x7f;
 
540
                    /* FIXME: find a better solution than this
 
541
                              hack to find the right caracter */
 
542
                    if( val.i_int >= 1 && val.i_int <= 26 )
 
543
                        val.i_int += 96;
 
544
                    else if( val.i_int >= 65 && val.i_int <= 90 )
 
545
                        val.i_int += 32;
 
546
                }
 
547
            }
 
548
 
 
549
            if( val.i_int )
 
550
            {
 
551
                if( ( event.key.keysym.mod & KMOD_SHIFT ) )
 
552
                {
 
553
                    val.i_int |= KEY_MODIFIER_SHIFT;
 
554
                }
 
555
                if( ( event.key.keysym.mod & KMOD_CTRL ) )
 
556
                {
 
557
                    val.i_int |= KEY_MODIFIER_CTRL;
 
558
                }
 
559
                if( ( event.key.keysym.mod & KMOD_ALT ) )
 
560
                {
 
561
                    val.i_int |= KEY_MODIFIER_ALT;
 
562
                }
 
563
                var_Set( p_vout->p_libvlc, "key-pressed", val );
 
564
            }
523
565
 
524
566
        default:
525
567
            break;
529
571
    /* Fullscreen change */
530
572
    if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE )
531
573
    {
532
 
        p_vout->b_fullscreen = ! p_vout->b_fullscreen;
 
574
        vlc_value_t val_fs;
 
575
 
 
576
        /* Update the object variable and trigger callback */
 
577
        val_fs.b_bool = !p_vout->b_fullscreen;
 
578
        p_vout->b_fullscreen = !p_vout->b_fullscreen;
 
579
        var_Set( p_vout, "fullscreen", val_fs );
 
580
 
 
581
        /*TODO: add the "always on top" code here !*/
533
582
 
534
583
        p_vout->p_sys->b_cursor_autohidden = 0;
535
584
        SDL_ShowCursor( p_vout->p_sys->b_cursor &&
539
588
        p_vout->i_changes |= VOUT_SIZE_CHANGE;
540
589
    }
541
590
 
542
 
    /*
543
 
     * Size change
544
 
     */
 
591
    /* Crop or Aspect Ratio Changes */
 
592
    if( p_vout->i_changes & VOUT_CROP_CHANGE ||
 
593
        p_vout->i_changes & VOUT_ASPECT_CHANGE )
 
594
    {
 
595
        p_vout->i_changes &= ~VOUT_CROP_CHANGE;
 
596
        p_vout->i_changes &= ~VOUT_ASPECT_CHANGE;
 
597
 
 
598
        p_vout->fmt_out.i_x_offset = p_vout->fmt_in.i_x_offset;
 
599
        p_vout->fmt_out.i_y_offset = p_vout->fmt_in.i_y_offset;
 
600
        p_vout->fmt_out.i_visible_width = p_vout->fmt_in.i_visible_width;
 
601
        p_vout->fmt_out.i_visible_height = p_vout->fmt_in.i_visible_height;
 
602
        p_vout->fmt_out.i_aspect = p_vout->fmt_in.i_aspect;
 
603
        p_vout->fmt_out.i_sar_num = p_vout->fmt_in.i_sar_num;
 
604
        p_vout->fmt_out.i_sar_den = p_vout->fmt_in.i_sar_den;
 
605
        p_vout->output.i_aspect = p_vout->fmt_in.i_aspect;
 
606
 
 
607
        p_vout->i_changes |= VOUT_SIZE_CHANGE;
 
608
    }
 
609
 
 
610
    /* Size change */
545
611
    if( p_vout->i_changes & VOUT_SIZE_CHANGE )
546
612
    {
547
613
        msg_Dbg( p_vout, "video display resized (%dx%d)",
554
620
         * we can handle rescaling ourselves */
555
621
        if( p_vout->p_sys->p_overlay != NULL )
556
622
            p_vout->i_changes &= ~VOUT_SIZE_CHANGE;
557
 
 
558
623
    }
559
624
 
560
625
    /* Pointer change */
561
626
    if( ! p_vout->p_sys->b_cursor_autohidden &&
562
 
        ( mdate() - p_vout->p_sys->i_lastmoved > 2000000 ) )
 
627
        ( mdate() - p_vout->p_sys->i_lastmoved >
 
628
            p_vout->p_sys->i_mouse_hide_timeout ) )
563
629
    {
564
630
        /* Hide the mouse automatically */
565
631
        p_vout->p_sys->b_cursor_autohidden = 1;
570
636
}
571
637
 
572
638
/*****************************************************************************
 
639
 * Key events handling
 
640
 *****************************************************************************/
 
641
static const struct
 
642
{
 
643
    SDLKey sdl_key;
 
644
    int i_vlckey;
 
645
} sdlkeys_to_vlckeys[] =
 
646
{
 
647
    { SDLK_F1,  KEY_F1 },
 
648
    { SDLK_F2,  KEY_F2 },
 
649
    { SDLK_F3,  KEY_F3 },
 
650
    { SDLK_F4,  KEY_F4 },
 
651
    { SDLK_F5,  KEY_F5 },
 
652
    { SDLK_F6,  KEY_F6 },
 
653
    { SDLK_F7,  KEY_F7 },
 
654
    { SDLK_F8,  KEY_F8 },
 
655
    { SDLK_F9,  KEY_F9 },
 
656
    { SDLK_F10, KEY_F10 },
 
657
    { SDLK_F11, KEY_F11 },
 
658
    { SDLK_F12, KEY_F12 },
 
659
 
 
660
    { SDLK_RETURN, KEY_ENTER },
 
661
    { SDLK_KP_ENTER, KEY_ENTER },
 
662
    { SDLK_SPACE, KEY_SPACE },
 
663
    { SDLK_ESCAPE, KEY_ESC },
 
664
 
 
665
    { SDLK_MENU, KEY_MENU },
 
666
    { SDLK_LEFT, KEY_LEFT },
 
667
    { SDLK_RIGHT, KEY_RIGHT },
 
668
    { SDLK_UP, KEY_UP },
 
669
    { SDLK_DOWN, KEY_DOWN },
 
670
 
 
671
    { SDLK_HOME, KEY_HOME },
 
672
    { SDLK_END, KEY_END },
 
673
    { SDLK_PAGEUP, KEY_PAGEUP },
 
674
    { SDLK_PAGEDOWN,  KEY_PAGEDOWN },
 
675
 
 
676
    { SDLK_INSERT, KEY_INSERT },
 
677
    { SDLK_DELETE, KEY_DELETE },
 
678
    /*TODO: find a equivalent for SDL 
 
679
    { , KEY_MEDIA_NEXT_TRACK }
 
680
    { , KEY_MEDIA_PREV_TRACK }
 
681
    { , KEY_VOLUME_MUTE }
 
682
    { , KEY_VOLUME_DOWN }
 
683
    { , KEY_VOLUME_UP }
 
684
    { , KEY_MEDIA_PLAY_PAUSE }
 
685
    { , KEY_MEDIA_PLAY_PAUSE }*/
 
686
 
 
687
    { 0, 0 }
 
688
};
 
689
 
 
690
static int ConvertKey( SDLKey sdl_key )
 
691
{
 
692
    int i;
 
693
    for( i=0; sdlkeys_to_vlckeys[i].sdl_key != 0; i++ )
 
694
    {
 
695
        if( sdlkeys_to_vlckeys[i].sdl_key == sdl_key )
 
696
        {
 
697
            return sdlkeys_to_vlckeys[i].i_vlckey;
 
698
        }
 
699
    }
 
700
    return 0;
 
701
}
 
702
 
 
703
 
 
704
/*****************************************************************************
573
705
 * Display: displays previously rendered output
574
706
 *****************************************************************************
575
707
 * This function sends the currently rendered image to the display.
615
747
 
616
748
    /* SDL fucked up fourcc definitions on bigendian machines */
617
749
    uint32_t i_sdl_chroma;
 
750
    char *psz_chroma = NULL;
 
751
    uint32_t i_chroma = 0;
 
752
 
 
753
    bool b_overlay = config_GetInt( p_vout, "overlay" );
618
754
 
619
755
    /* Set main window's size */
 
756
#if SDL_VERSION_ATLEAST(1,2,10)
 
757
    p_vout->p_sys->i_width = p_vout->b_fullscreen ? p_vout->p_sys->i_desktop_width :
 
758
                                                    p_vout->i_window_width;
 
759
    p_vout->p_sys->i_height = p_vout->b_fullscreen ? p_vout->p_sys->i_desktop_height :
 
760
                                                     p_vout->i_window_height;
 
761
#else
620
762
    p_vout->p_sys->i_width = p_vout->b_fullscreen ? p_vout->output.i_width :
621
763
                                                    p_vout->i_window_width;
622
764
    p_vout->p_sys->i_height = p_vout->b_fullscreen ? p_vout->output.i_height :
623
765
                                                     p_vout->i_window_height;
 
766
#endif
624
767
 
625
768
    /* Initialize flags and cursor */
626
769
    i_flags = SDL_ANYFORMAT | SDL_HWPALETTE | SDL_HWSURFACE | SDL_DOUBLEBUF;
646
789
 
647
790
    SDL_LockSurface( p_vout->p_sys->p_display );
648
791
 
649
 
    /* Choose the chroma we will try first. */
650
 
    switch( p_vout->render.i_chroma )
651
 
    {
652
 
        case VLC_FOURCC('Y','U','Y','2'):
653
 
        case VLC_FOURCC('Y','U','N','V'):
 
792
    if( ( psz_chroma = config_GetPsz( p_vout, "sdl-chroma" ) ) )
 
793
    {
 
794
        if( strlen( psz_chroma ) >= 4 )
 
795
        {
 
796
            memcpy(&i_chroma, psz_chroma, 4);
 
797
            msg_Dbg( p_vout, "Forcing chroma to 0x%.8x (%4.4s)", i_chroma, (char*)&i_chroma );
 
798
        }
 
799
        else
 
800
        {
 
801
            free( psz_chroma );
 
802
            psz_chroma = NULL;
 
803
        }
 
804
    }
 
805
 
 
806
    if( b_overlay )
 
807
    {
 
808
        /* Choose the chroma we will try first. */
 
809
        do
 
810
        {
 
811
            if( !psz_chroma ) i_chroma = 0;
 
812
            switch( i_chroma ? i_chroma : p_vout->render.i_chroma )
 
813
            {
 
814
                case VLC_FOURCC('Y','U','Y','2'):
 
815
                case VLC_FOURCC('Y','U','N','V'):
 
816
                    p_vout->output.i_chroma = VLC_FOURCC('Y','U','Y','2');
 
817
                    i_sdl_chroma = SDL_YUY2_OVERLAY;
 
818
                    break;
 
819
                case VLC_FOURCC('U','Y','V','Y'):
 
820
                case VLC_FOURCC('U','Y','N','V'):
 
821
                case VLC_FOURCC('Y','4','2','2'):
 
822
                    p_vout->output.i_chroma = VLC_FOURCC('U','Y','V','Y');
 
823
                    i_sdl_chroma = SDL_UYVY_OVERLAY;
 
824
                    break;
 
825
                case VLC_FOURCC('Y','V','Y','U'):
 
826
                    p_vout->output.i_chroma = VLC_FOURCC('Y','V','Y','U');
 
827
                    i_sdl_chroma = SDL_YVYU_OVERLAY;
 
828
                    break;
 
829
                case VLC_FOURCC('Y','V','1','2'):
 
830
                case VLC_FOURCC('I','4','2','0'):
 
831
                case VLC_FOURCC('I','Y','U','V'):
 
832
                default:
 
833
                    p_vout->output.i_chroma = VLC_FOURCC('Y','V','1','2');
 
834
                    i_sdl_chroma = SDL_YV12_OVERLAY;
 
835
                    break;
 
836
            }
 
837
            free( psz_chroma ); psz_chroma = NULL;
 
838
 
 
839
            p_vout->p_sys->p_overlay =
 
840
                SDL_CreateYUVOverlay( 32, 32, i_sdl_chroma,
 
841
                                      p_vout->p_sys->p_display );
 
842
            /* FIXME: if the first overlay we find is software, don't stop,
 
843
             * because we may find a hardware one later ... */
 
844
        }
 
845
        while( i_chroma && !p_vout->p_sys->p_overlay );
 
846
 
 
847
 
 
848
        /* If this best choice failed, fall back to other chromas */
 
849
        if( p_vout->p_sys->p_overlay == NULL )
 
850
        {
 
851
            p_vout->output.i_chroma = VLC_FOURCC('I','Y','U','V');
 
852
            p_vout->p_sys->p_overlay =
 
853
                SDL_CreateYUVOverlay( 32, 32, SDL_IYUV_OVERLAY,
 
854
                                      p_vout->p_sys->p_display );
 
855
        }
 
856
 
 
857
        if( p_vout->p_sys->p_overlay == NULL )
 
858
        {
 
859
            p_vout->output.i_chroma = VLC_FOURCC('Y','V','1','2');
 
860
            p_vout->p_sys->p_overlay =
 
861
                SDL_CreateYUVOverlay( 32, 32, SDL_YV12_OVERLAY,
 
862
                                      p_vout->p_sys->p_display );
 
863
        }
 
864
 
 
865
        if( p_vout->p_sys->p_overlay == NULL )
 
866
        {
654
867
            p_vout->output.i_chroma = VLC_FOURCC('Y','U','Y','2');
655
 
            i_sdl_chroma = SDL_YUY2_OVERLAY;
656
 
            break;
657
 
        case VLC_FOURCC('U','Y','V','Y'):
658
 
        case VLC_FOURCC('U','Y','N','V'):
659
 
        case VLC_FOURCC('Y','4','2','2'):
660
 
            p_vout->output.i_chroma = VLC_FOURCC('U','Y','V','Y');
661
 
            i_sdl_chroma = SDL_UYVY_OVERLAY;
662
 
            break;
663
 
        case VLC_FOURCC('Y','V','Y','U'):
664
 
            p_vout->output.i_chroma = VLC_FOURCC('Y','V','Y','U');
665
 
            i_sdl_chroma = SDL_YVYU_OVERLAY;
666
 
            break;
667
 
        case VLC_FOURCC('Y','V','1','2'):
668
 
        case VLC_FOURCC('I','4','2','0'):
669
 
        case VLC_FOURCC('I','Y','U','V'):
670
 
        default:
671
 
            p_vout->output.i_chroma = VLC_FOURCC('Y','V','1','2');
672
 
            i_sdl_chroma = SDL_YV12_OVERLAY;
673
 
            break;
674
 
    }
675
 
 
676
 
    p_vout->p_sys->p_overlay =
677
 
        SDL_CreateYUVOverlay( 32, 32, i_sdl_chroma, p_vout->p_sys->p_display );
678
 
    /* FIXME: if the first overlay we find is software, don't stop,
679
 
     * because we may find a hardware one later ... */
680
 
 
681
 
    /* If this best choice failed, fall back to other chromas */
682
 
    if( p_vout->p_sys->p_overlay == NULL )
683
 
    {
684
 
        p_vout->output.i_chroma = VLC_FOURCC('I','Y','U','V');
685
 
        p_vout->p_sys->p_overlay =
686
 
            SDL_CreateYUVOverlay( 32, 32, SDL_IYUV_OVERLAY,
687
 
                                  p_vout->p_sys->p_display );
688
 
    }
689
 
 
690
 
    if( p_vout->p_sys->p_overlay == NULL )
691
 
    {
692
 
        p_vout->output.i_chroma = VLC_FOURCC('Y','V','1','2');
693
 
        p_vout->p_sys->p_overlay =
694
 
            SDL_CreateYUVOverlay( 32, 32, SDL_YV12_OVERLAY,
695
 
                                  p_vout->p_sys->p_display );
696
 
    }
697
 
 
698
 
    if( p_vout->p_sys->p_overlay == NULL )
699
 
    {
700
 
        p_vout->output.i_chroma = VLC_FOURCC('Y','U','Y','2');
701
 
        p_vout->p_sys->p_overlay =
702
 
            SDL_CreateYUVOverlay( 32, 32, SDL_YUY2_OVERLAY,
703
 
                                  p_vout->p_sys->p_display );
704
 
    }
705
 
 
706
 
    if( p_vout->p_sys->p_overlay == NULL )
707
 
    {
708
 
        msg_Warn( p_vout, "no SDL overlay for 0x%.8x (%4.4s)",
709
 
                  p_vout->render.i_chroma, (char*)&p_vout->render.i_chroma );
 
868
            p_vout->p_sys->p_overlay =
 
869
                SDL_CreateYUVOverlay( 32, 32, SDL_YUY2_OVERLAY,
 
870
                                      p_vout->p_sys->p_display );
 
871
        }
 
872
    }
 
873
 
 
874
    if( p_vout->p_sys->p_overlay == NULL )
 
875
    {
 
876
        if( b_overlay )
 
877
            msg_Warn( p_vout, "no SDL overlay for 0x%.8x (%4.4s)",
 
878
                      p_vout->render.i_chroma,
 
879
                      (char*)&p_vout->render.i_chroma );
 
880
        else
 
881
            msg_Warn( p_vout, "SDL overlay disabled by the user" );
710
882
 
711
883
        switch( p_vout->p_sys->p_display->format->BitsPerPixel )
712
884
        {