← Back to branch summary

~ubuntu-branches/debian/wheezy/vlc/wheezy

« back to all changes in this revision

Viewing changes to modules/video_output/caca.c

Tags: upstream-0.7.2.final
Import upstream version 0.7.2.final

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/video_output/caca.c
 
1
/*****************************************************************************
 
2
 * caca.c: Color ASCII Art video output plugin using libcaca
 
3
 *****************************************************************************
 
4
 * Copyright (C) 2003, 2004 VideoLAN
 
5
 * $Id: caca.c 7522 2004-04-27 16:35:15Z sam $
 
6
 *
 
7
 * Authors: Sam 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 <errno.h>                                                 /* ENOMEM */
 
28
#include <stdlib.h>                                                /* free() */
 
29
#include <string.h>                                            /* strerror() */
 
30
 
 
31
#include <caca.h>
 
32
 
 
33
#include <vlc/vlc.h>
 
34
#include <vlc/vout.h>
 
35
#include <vlc/intf.h>
 
36
#include <vlc_keys.h>
 
37
 
 
38
/*****************************************************************************
 
39
 * Local prototypes
 
40
 *****************************************************************************/
 
41
static int  Create    ( vlc_object_t * );
 
42
static void Destroy   ( vlc_object_t * );
 
43
 
 
44
static int  Init      ( vout_thread_t * );
 
45
static void End       ( vout_thread_t * );
 
46
static int  Manage    ( vout_thread_t * );
 
47
static void Render    ( vout_thread_t *, picture_t * );
 
48
static void Display   ( vout_thread_t *, picture_t * );
 
49
 
 
50
/*****************************************************************************
 
51
 * Module descriptor
 
52
 *****************************************************************************/
 
53
vlc_module_begin();
 
54
    set_description( _("color ASCII art video output") );
 
55
    set_capability( "video output", 12 );
 
56
    set_callbacks( Create, Destroy );
 
57
vlc_module_end();
 
58
 
 
59
/*****************************************************************************
 
60
 * vout_sys_t: libcaca video output method descriptor
 
61
 *****************************************************************************
 
62
 * This structure is part of the video output thread descriptor.
 
63
 * It describes the libcaca specific properties of an output thread.
 
64
 *****************************************************************************/
 
65
struct vout_sys_t
 
66
{
 
67
    struct caca_bitmap *p_bitmap;
 
68
};
 
69
 
 
70
/*****************************************************************************
 
71
 * Create: allocates libcaca video output thread
 
72
 *****************************************************************************
 
73
 * This function initializes libcaca vout method.
 
74
 *****************************************************************************/
 
75
static int Create( vlc_object_t *p_this )
 
76
{
 
77
    vout_thread_t *p_vout = (vout_thread_t *)p_this;
 
78
 
 
79
#if defined( WIN32 ) && !defined( UNDER_CE )
 
80
    if( AllocConsole() )
 
81
    {
 
82
        CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
 
83
        SMALL_RECT rect;
 
84
        COORD coord;
 
85
 
 
86
        HANDLE hstdout =
 
87
            CreateConsoleScreenBuffer( GENERIC_READ | GENERIC_WRITE,
 
88
                                       FILE_SHARE_READ | FILE_SHARE_WRITE,
 
89
                                       NULL, CONSOLE_TEXTMODE_BUFFER, NULL );
 
90
        if( !hstdout || hstdout == INVALID_HANDLE_VALUE )
 
91
        {
 
92
            msg_Err( p_vout, "cannot create screen buffer" );
 
93
            FreeConsole();
 
94
            return VLC_EGENERIC;
 
95
        }
 
96
 
 
97
        if( !SetConsoleActiveScreenBuffer( hstdout) )
 
98
        {
 
99
            msg_Err( p_vout, "cannot set active screen buffer" );
 
100
            FreeConsole();
 
101
            return VLC_EGENERIC;
 
102
        }
 
103
 
 
104
        coord = GetLargestConsoleWindowSize( hstdout );
 
105
        msg_Dbg( p_vout, "SetConsoleWindowInfo: %ix%i", coord.X, coord.Y );
 
106
 
 
107
        /* Force size for now */
 
108
        coord.X = 100;
 
109
        coord.Y = 40;
 
110
 
 
111
        if( !SetConsoleScreenBufferSize( hstdout, coord ) )
 
112
            msg_Warn( p_vout, "SetConsoleScreenBufferSize %i %i",
 
113
                      coord.X, coord.Y );
 
114
 
 
115
        /* Get the current screen buffer size and window position. */
 
116
        if( GetConsoleScreenBufferInfo( hstdout, &csbiInfo ) )
 
117
        {
 
118
            rect.Top = 0; rect.Left = 0;
 
119
            rect.Right = csbiInfo.dwMaximumWindowSize.X - 1;
 
120
            rect.Bottom = csbiInfo.dwMaximumWindowSize.Y - 1;
 
121
            if( !SetConsoleWindowInfo( hstdout, TRUE, &rect ) )
 
122
                msg_Dbg( p_vout, "SetConsoleWindowInfo failed: %ix%i",
 
123
                         rect.Right, rect.Bottom );
 
124
        }
 
125
    }
 
126
    else
 
127
    {
 
128
        msg_Err( p_vout, "cannot create console" );
 
129
        return VLC_EGENERIC;
 
130
    }
 
131
 
 
132
#endif
 
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 VLC_ENOMEM;
 
140
    }
 
141
 
 
142
    if( caca_init() )
 
143
    {
 
144
        msg_Err( p_vout, "cannot initialize libcaca" );
 
145
        free( p_vout->p_sys );
 
146
        return VLC_EGENERIC;
 
147
    }
 
148
 
 
149
    caca_set_window_title( VOUT_TITLE " - Colour AsCii Art (caca)" );
 
150
 
 
151
    p_vout->pf_init = Init;
 
152
    p_vout->pf_end = End;
 
153
    p_vout->pf_manage = Manage;
 
154
    p_vout->pf_render = Render;
 
155
    p_vout->pf_display = Display;
 
156
 
 
157
    return VLC_SUCCESS;
 
158
}
 
159
 
 
160
/*****************************************************************************
 
161
 * Init: initialize libcaca video output thread
 
162
 *****************************************************************************/
 
163
static int Init( vout_thread_t *p_vout )
 
164
{
 
165
    int i_index;
 
166
    picture_t *p_pic = NULL;
 
167
 
 
168
    I_OUTPUTPICTURES = 0;
 
169
 
 
170
    p_vout->output.i_chroma = VLC_FOURCC('R','V','3','2');
 
171
    p_vout->output.i_width = p_vout->render.i_width;
 
172
    p_vout->output.i_height = p_vout->render.i_height;
 
173
    p_vout->output.i_aspect = p_vout->render.i_aspect;
 
174
 
 
175
    p_vout->output.i_rmask = 0x00ff0000;
 
176
    p_vout->output.i_gmask = 0x0000ff00;
 
177
    p_vout->output.i_bmask = 0x000000ff;
 
178
 
 
179
    /* Create the libcaca bitmap */
 
180
    p_vout->p_sys->p_bitmap =
 
181
        caca_create_bitmap( 32,
 
182
                            p_vout->output.i_width,
 
183
                            p_vout->output.i_height,
 
184
                            4 * ((p_vout->output.i_width + 15) & ~15),
 
185
                            p_vout->output.i_rmask,
 
186
                            p_vout->output.i_gmask,
 
187
                            p_vout->output.i_bmask,
 
188
                            0x00000000 );
 
189
    if( !p_vout->p_sys->p_bitmap )
 
190
    {
 
191
        msg_Err( p_vout, "could not create libcaca bitmap" );
 
192
        return VLC_EGENERIC;
 
193
    }
 
194
 
 
195
    /* Find an empty picture slot */
 
196
    for( i_index = 0 ; i_index < VOUT_MAX_PICTURES ; i_index++ )
 
197
    {
 
198
        if( p_vout->p_picture[ i_index ].i_status == FREE_PICTURE )
 
199
        {
 
200
            p_pic = p_vout->p_picture + i_index;
 
201
            break;
 
202
        }
 
203
    }
 
204
 
 
205
    if( p_pic == NULL )
 
206
    {
 
207
        return VLC_EGENERIC;
 
208
    }
 
209
 
 
210
    /* Allocate the picture */
 
211
    p_pic->p->i_lines = p_vout->output.i_height;
 
212
    p_pic->p->i_pitch = 4 * ((p_vout->output.i_width + 15) & ~15);
 
213
    p_pic->p->i_pixel_pitch = 4;
 
214
    p_pic->p->i_visible_pitch = 4 * p_vout->output.i_width;
 
215
    p_pic->i_planes = 1;
 
216
    p_pic->p->p_pixels = malloc( p_pic->p->i_pitch * p_pic->p->i_lines );
 
217
 
 
218
    p_pic->i_status = DESTROYED_PICTURE;
 
219
    p_pic->i_type   = DIRECT_PICTURE;
 
220
 
 
221
    PP_OUTPUTPICTURE[ I_OUTPUTPICTURES ] = p_pic;
 
222
    I_OUTPUTPICTURES++;
 
223
 
 
224
    return VLC_SUCCESS;
 
225
}
 
226
 
 
227
/*****************************************************************************
 
228
 * End: terminate libcaca video output thread
 
229
 *****************************************************************************/
 
230
static void End( vout_thread_t *p_vout )
 
231
{
 
232
    caca_free_bitmap( p_vout->p_sys->p_bitmap );
 
233
}
 
234
 
 
235
/*****************************************************************************
 
236
 * Destroy: destroy libcaca video output thread
 
237
 *****************************************************************************
 
238
 * Terminate an output method created by AaCreateOutputMethod
 
239
 *****************************************************************************/
 
240
static void Destroy( vlc_object_t *p_this )
 
241
{
 
242
    vout_thread_t *p_vout = (vout_thread_t *)p_this;
 
243
 
 
244
    caca_end();
 
245
 
 
246
#if defined( WIN32 ) && !defined( UNDER_CE )
 
247
    FreeConsole();
 
248
#endif
 
249
 
 
250
    free( p_vout->p_sys );
 
251
}
 
252
 
 
253
/*****************************************************************************
 
254
 * Manage: handle libcaca events
 
255
 *****************************************************************************
 
256
 * This function should be called regularly by video output thread. It manages
 
257
 * console events. It returns a non null value on error.
 
258
 *****************************************************************************/
 
259
static int Manage( vout_thread_t *p_vout )
 
260
{
 
261
    int event;
 
262
    vlc_value_t val;
 
263
 
 
264
    while(( event = caca_get_event(CACA_EVENT_KEY_PRESS | CACA_EVENT_RESIZE) ))
 
265
    {
 
266
        if( event == CACA_EVENT_RESIZE )
 
267
        {
 
268
            /* Acknowledge the resize */
 
269
            caca_refresh();
 
270
            continue;
 
271
        }
 
272
 
 
273
        switch( event & 0x00ffffff )
 
274
        {
 
275
        case 'q':
 
276
            val.i_int = KEY_MODIFIER_CTRL | 'q';
 
277
            break;
 
278
        case ' ':
 
279
            val.i_int = KEY_SPACE;
 
280
            break;
 
281
        default:
 
282
            continue;
 
283
        }
 
284
 
 
285
        var_Set( p_vout->p_vlc, "key-pressed", val );
 
286
    }
 
287
 
 
288
    return VLC_SUCCESS;
 
289
}
 
290
 
 
291
/*****************************************************************************
 
292
 * Render: render previously calculated output
 
293
 *****************************************************************************/
 
294
static void Render( vout_thread_t *p_vout, picture_t *p_pic )
 
295
{
 
296
    caca_clear();
 
297
    caca_draw_bitmap( 0, 0, caca_get_width() - 1, caca_get_height() - 1,
 
298
                      p_vout->p_sys->p_bitmap, p_pic->p->p_pixels );
 
299
}
 
300
 
 
301
/*****************************************************************************
 
302
 * Display: displays previously rendered output
 
303
 *****************************************************************************/
 
304
static void Display( vout_thread_t *p_vout, picture_t *p_pic )
 
305
{
 
306
    caca_refresh();
 
307
}
 
308